python学习10-内置函数 迭代 二分法/面向对象初识（转载）

一、匿名函数

形式：

lambda 形参：返回值

lambda表示的是匿名函数. 不需要用def来声明, 一句话就可以声明出一个函数。匿名函数不是说一定没名字，而是他们的名字统一称为“lambda”,可以用__name__查看

注意:

1. 函数的参数可以有多个. 多个参数之间用逗号隔开

2. 匿名函数不管多复杂. 只能写一行, 且逻辑结束后直接返回数据

3. 返回值和正常的函数一样, 可以是任意数据类型

1 #计算n的n次方
2 f = lambda n : n**n
3
4 print(f(10))

二、sorted

排序函数，形式  sorted(iterable, key=None, reverse = False)

iterrable ：要进行排序的可迭代对象

key：相当于排序规则，在sorted内部会将可迭代对象的每一个元素传递给这个函数，根据函数的运算结果进行排序

reverse： 升序还是降序，False是升序，True是降序

1 lst = ["将夜","择天记","斗破苍穹","武动乾坤"]
2
3 s = sorted(lst, key= lambda el : len(el), reverse = False) #按电视剧名的长度排序
4
5 print(s)

三、filter

筛选函数，形式 filter(function , iterable )

function：筛选规则，将iterable的每一个元素传递给这个函数，根据function返回的True或者False来判断是否保留此项数据

llst = ["将夜","择天记","斗破苍穹","武动乾坤"]

s = filter( lambda el : len(el)>3,lst) #按电视剧名的长度排序
for el in s:
    print(el)

结果：
斗破苍穹
武动乾坤

四、map

映射函数 形式 map(function , iterable)

function：映射规则，分别取iterable中的每一个元素，传递给函数执行，得到新的数据

1 #列表中每个元素的平方组成新列表
2 lst = [2,4,6,8,10]
3 num = map(lambda x:x*x,lst)
4
5 for el in num :
6     print(el)

五、递归

在函数中调用函数本身，就是递归（自己调用自己）

递归的最大深度是1000，但是一般都取不到

递归关键的是找到递归入口和递归出口

应用：使用递归遍历文件夹系统（递归可以用来遍历各种树形结构）

 1 def func(path, ceng)
 2      lst = os.listdir(path) # 打开一个文件夹. 获取到文件夹内的所有内容
 3      for el in lst: # 当前文件夹内的所有的文件名(包括文件夹名字)
 4          file_real_path = os.path.join(path, el)  # 拼接文件的真实路径
 5          # 判断这个路径是文件还是文件夹
 6          if os.path.isdir(file_real_path):
 7              # 递归的入口
 8              print("\t"*ceng, el)
 9              func(file_real_path，ceng+1) # 重新执行刚才的操作
10
11         else:   # 不是文件夹, 是文件
12              # 递归的出口
13             print("\t"*ceng, el)
14
15 func("D:/PyCharm/workspace/周作业",0)  #调用函数

六、二分法

二分查找：每次能够排除掉一半的数据，查找的效率非常高。 但是局限性比较大， 必须是有序序列才可以使用二分查找。

#查找列表中是否存在n
lst = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963]

#普通查找
def func():
n =input(">>")
for el in lst:
if el == int(n):
return True
else:
return False

# print(func())

#判断列表中是否存在n
#二分查找---非递归
n = int(input(">>"))
left = 0 #左边界
right = len(lst)-1 #右边界
while left<=right: #左边界小于等于右边界进入循环
mid = (left+right)//2 #取商的整数
if n < lst[mid]: #判断你的数字和中间数大小
right = mid-1 #右边界往左移
elif n >lst[mid]:
left = mid+1 #左边界往右移
else:
print("找到了")
break
else: # 左边界大于右边界退出循环
print("找不到")
#二分查找---递归
def digui(n,left,right):
if left <= right:
mid = (left +right)//2
if n < lst[mid]:
right = mid -1
elif n > lst[mid]:
left = mid +1
else:
print("找到了")
return True
#digui(n, left, right)
return digui(n, left, right) # 不写return，返回值始终为None
else:
return -1
ret = digui(56,0,len(lst)-1)
print(ret)

#二分查找 ----递归（切列表）
def binary_search(lst,n):
left = 0
right = len(lst)-1
if left >right:
print("找不到")
mid = (left + right)//2
if n < lst[mid]:
#binary_search(lst[:mid], n)
return binary_search(lst[:mid],n) # 不写return，返回值会始终为None
elif n > lst[mid]:
#binary_search(lst[mid + 1:], n)
return binary_search(lst[mid+1: ],n)
else:
print("找到了")
return True
ret = binary_search(lst,56)
print(ret)

示例

一、面向过程和面向对象

1、面向过程

以我为中心，做一件事先干什么，在干什么，后干什么，有一套清楚完整的流程。核心是“过程”。

优点：将要解决的问题流程化, 编写相对简单

缺点：可扩展性差

2、面向对象

以对象为中心，做一件事不需要你清楚怎么做，你创建能做这件事的对象即可。对象是具体的事物，它能实现一定的功能。

优点：可扩展性强

缺点：编程的复杂度高于面向过程

二、面向对象如何编写

在现实世界中，是先有对象，然后后归类；在代码中，是先定义类，然后再创建对象

#定义类 格式：

class 类名：

　　def  __init__(self,参数):     #这是类的构造方法，在创建对象的时候会自动执行；self指当前正在创建的对象，由python自动传值

　　　　pass

　　def  方法名(self,参数)：     #类中自定义的方法

　　　　pass

#创建对象：

变量 = 类名(参数)

# 访问对象的属性信息
对象.属性
# 方法的访问:
对象.方法()

 1 #定义computer类
 2 class Computer:
 3     def __init__(self,pinpai,cpu):
 4         self.pinpai = pinpai
 5         self.cpu = cpu
 6
 7     def playgame(self,game):
 8         print("使用%s电脑打%s游戏" % (self.pinpai, game))
 9 #创建具体对象c
10 c = Computer("lenovo", "A8")
11 print(c.pinpai)
12 c.playgame("lol")
13
14 #创建对象c2
15 c2 = Computer("xiaomi", "i7")
16 print(c2.pinpai)
17 c2.playgame("吃鸡")

！！！注意：

　　对类与对象关系的理解： 类通过实例化创建一个对象，每个对象都是独立的。

　　点 . 可以理解为“的”，或者“调用”  比如 c.pinpai 就是对象c的品牌；c.playgame()   对象c调用playgame方法

三、面向对象和面向过程大PK

那么面向对象和面向过程到底哪个好?

具体问题，具体分析。 没有绝对的好和不好。 这点 要格外注意。

对于大型项目，更适合用面向对象；对于小型脚本，更适合用面向过程

四、面向对象三大特征

（一）封装

封装是一个很宽泛的概念，你写一个函数，可以称为封装，对象，打包成模块也都属于封装的思想。

在面向对象思想中，把一些看似无关紧要的内容组合到一起统一进行存储和使用，这就是封装。

对属性封装

　　self.xxx = xxxx
对方法封装

　　def 方法名():

　　　　pass

（二）继承

继承格式

class 子类名（父类1，父类2）：

　　pass

子类可以自动拥有父类中除了私有内容外的其他所有内容

（三）多态

同一个对象多种形态

 1 class Animal:
 2      def chi(self):
 3          print("动物就知道吃")
 4 class Pig(Animal):
 5      def chi(self):
 6          print("猪在吃")
 7 class Haski(Animal):
 8      def chi(self):
 9          print("哈士奇在吃")
10 class Alasika(Animal):
11      def chi(self):
12          print("阿拉斯加在吃")
13
14 class SiYangYuan:
15      def yanng_animal(self, ani):  #本来这里的参数要的是Animal类的对象，但是传入Pig类，Haski类，Alasika类的对象也可以，这就是多态
16          ani.chi()
17
18 zhu = Pig()
19 erha = Haski()
20 ala = Alasika()
21 alex = SiYangYuan()
22 alex.yanng_animal(zhu)
23 alex.yanng_animal(erha)
24 alex.yanng_animal(ala)                  

多态的好处：

程序具有超高的可扩展性。

面向对象思想的核心与灵魂。

python自带多态，我们一直在用多态，但是感觉并不明显。 比如. 我们创建一个变量a = 10 , 我们知道此时a是整数类型。但是我们可以通过程序让a = "alex", 这时, a又变成了字符串类型。