一、函数的内嵌和闭包
1.函数的内嵌就是一个函数里面包含着另一个函数。
正常函数
>>> def MyFun():
global count
count=10
print(count)
>>> MyFun()
10
内嵌函数
>>> def fun1():
print('fun1()正在被调用')
def fun2():
print('fun2()正在被调用')
fun2()
>>> fun1()
fun1()正在被调用
fun2()正在被调用
>>>
2.闭包（由外而内，由大而小，函数式编程）
>>> def fun1():
x=5 //此时的x对于fun2()来说是外部值，不可引用，除非是容器型的才可以赋值给fun2()
def fun2():
x*=x
return x
return fun2()
>>> fun1() //此时调用fun1()会出现错误，因为fun2()为内部函数，在不调用fun1()时，fun2()不会被赋值
上面的代码改编1：
>>> def fun1():
x=[5] //此时的x是容器型的可以给fun2()f赋值
def fun2():
x[0]*=x[0]
return x[0]
return fun2()
>>> fun1()
25
改编2：
>>> def fun1():
x=5
def fun2():
nonlocal x //此时把x定义成了全局变量
x*=x
return x
return fun2()
>>> fun1()
25
内部函数和外部函数的调用
>>> def FunX(x):
def FunY(y):
return x*y
return FunY
>>> i=FunX(8)
>>> type(i) //此时i的类型是“函数”
<class 'function'>
>>> i(5)
40
>>> FunX(3)(2) //此时赋值x=3,y=2
6
二、lambda表达式
例1.
>>> def ds(x):
return 2*x+1
>>> ds(5)
11
等价于
>>> lambda x:2*x+1 //冒号前面表示变量名字，后面表示对该变量的操作
<function <lambda> at 0x0000000002FEC6A8>
>>> g=lambda x:2*x+1
>>> g(5)
11
例2.
>>> def add(x,y):
return x+y
>>> add(3,4)
7
等价于
>>> g=lambda x,y:x+y
>>> g(3,4)
7
>>>
总结：使用lambda的优点是1.省下定义过程2.不用起变量的名字3.可读性比较强
三、两个牛逼的BIF
1.过滤函数filter(参1，参2)
参1表示过滤法则（一般过滤掉False和≤0的数），参2表示过滤范围
>>> def odd(x):
return x%2 ///取余之后的值非0及1
>>> temp=range(10)
>>> show=filter(odd,temp) //筛选出范围内所有的奇数
>>> list(show)
[1, 3, 5, 7, 9]
上面函数等价于
>>> list(filter(lambda x:x%2,range(10)))
[1, 3, 5, 7, 9]
2.map(参1，参2)映射函数
其中参1表示运算法则，参2表示源数据，而map()将参2的源数据引入参1的运算法则
>>> list(map(lambda x:x*2,range(10)))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
>>>
四、递归（汉诺塔、树结构、谢尔宾斯基三角形）
递归就是函数调用自身
典例1.求阶乘
法1：用传统的方法
>>> def fac(n):
result=n
for i in range(1,n):
result*=i
return result
>>> fac(5)
120
法2：用递归
>>> def fac(n):
if n==1:
return 1
else:
return n*fac(n-1)
>>> fac(5)
120
典例2.求斐波那契数列
法1：迭代
>>> def fab(n):
n1=1
n2=1
n3=1
if n<1:
prunt('输入有误')
return -1
while (n-2)>0:
n3=n1+n2
n1=n2
n2=n3
n-=1
return n3
>>> fab(1)
1
>>> fab(2)
1
>>> fab(3)
2
>>> fab(4)
3
法2：递归
>>> def fab(n):
if n<1:
print('输入有误')
return -1
if n==1 or n==2:
return 1
else:
return fab(n-1)+fab(n-2)
>>> fab(1)
1
>>> fab(2)
1
>>> fab(3)
2
>>> fab(4)
3
>>> fab(5)
5
典例3.汉诺塔
求解出玩汉诺塔游戏的攻略，即移动路线
def han(n,x,y,z): //定义函数
if n==1:
print(x,'->',z)
else:
han(n-1,x,z,y)
print(x,'->',z)
han(n-1,y,x,z)
n=int(input('请输入汉诺塔的层数')) //调用函数
han(n,'X','Y','Z')
调用结果：
============== RESTART: C:/ProgramData/Anaconda3/Scripts/han.py ==============
请输入汉诺塔的层数3
X -> Z
X -> Y
Z -> Y
X -> Z
Y -> X
Y -> Z
X -> Z
>>>
总结：递归在求解某些特定结构时（汉诺塔）是有优势的，而平常的问题比如斐波那契数列的求解中就可以看出来，递归耗时长，迭代速度更快！
五、字典（由键和值组成，Key–Values）
1.一般结构
>>> dict1={'李宁':'一切皆有可能','耐克':'just do it',' 阿迪达斯':'impossible is nothing'}
//字典结构使用中括号，每个键值对之间用逗号隔开，一组键值对之间用冒号
>>> print('李宁的口号是：',dict1['李宁'])
李宁的口号是： 一切皆有可能
>>>
2.调用方式
>>> dict2={1:'one',2:'two',3:'three'}
>>> dict2[2] //调用时【】里输入要调用的‘’键‘’
'two'
3.定义方式
>>> dict3=dict((('F',70),('i',105)))
>>> dict3
{'F': 70, 'i': 105}
>>> dict4=dict(小鱼='我好饿',爱迪生='我也好饿')
>>> dict4
{'小鱼': '我好饿', '爱迪生': '我也好饿'}
>>> dict4['爱迪生']
'我也好饿'
>>>
4.访问字典的方法-----keys(),values(),items()
>>> dict1={}
>>> dict1=dict1.fromkeys(range(32),'赞')
>>> dict1
{0: '赞', 1: '赞', 2: '赞', 3: '赞', 4: '赞', 5: '赞', 6: '赞', 7: '赞', 8: '赞', 9: '赞', 10: '赞', 11: '赞', 12: '赞', 13: '赞', 14: '赞', 15: '赞', 16: '赞', 17: '赞', 18: '赞', 19: '赞', 20: '赞', 21: '赞', 22: '赞', 23: '赞', 24: '赞', 25: '赞', 26: '赞', 27: '赞', 28: '赞', 29: '赞', 30: '赞', 31: '赞'}
>>>
>>> dict1={}
>>> dict1=dict1.fromkeys(range(32),'赞')
>>> for eachkey in dict1.keys():
print(eachkey) //依次显示每个键
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
>>>
>>> for eachvalue in dict1.values():
print(eachvalue) //依次显示每个值
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
>>>
>>> for eachitem in dict1.items():
print(eachitem) //依次显示每个项
(0, '赞')
(1, '赞')
(2, '赞')
(3, '赞')
(4, '赞')
(5, '赞')
(6, '赞')
(7, '赞')
(8, '赞')
(9, '赞')
(10, '赞')
(11, '赞')
(12, '赞')
(13, '赞')
(14, '赞')
(15, '赞')
(16, '赞')
(17, '赞')
(18, '赞')
(19, '赞')
(20, '赞')
(21, '赞')
(22, '赞')
(23, '赞')
(24, '赞')
(25, '赞')
(26, '赞')
(27, '赞')
(28, '赞')
(29, '赞')
(30, '赞')
(31, '赞')
>>>
>>> dict1.clear() //清空一个字典
>>> dict1
{}
>>>
>>> dict1={1:'one',2:'two',3:'three'}
>>> dict1.pop(1) //删除一个键
'one'
>>> dict1
{2: 'two', 3: 'three'}
>>> a={}
>>> a.setdefault('小白') //在字典中加入单个项
>>> a.setdefault(5,'five')
'five'
>>> a
{'小白
>>> a={}
>>> a.setdefault('小白')
>>> a.setdefault(5,'five')
'five'
>>> a
{'小白': None, 5: 'five'}
>>> b={'小白':'狗'}
>>> a.update(b) //用一个单个项的字典来更新旧的字典
>>> a
{'小白': '狗', 5: 'five'}
>>>
六、集合（元素具有唯一性、无序性，用中括号表示）
1.创建
法1
>>> num2={1,2,3,3,5,0,9,7,3,1,2} //创建一个无序的有重复项的集合，存储时会去掉重复项
>>> num2
{0, 1, 2, 3, 5, 7, 9}
>>>
法2：使用set函数
>>> set1=set([1,2,3,4,5,5,3])
>>> set1
{1, 2, 3, 4, 5}
>>>
2.典例:去掉重复的元素【1,2,3,4,5,5,3,1,0】
法1：
>>> num1=[1,2,3,4,5,5,3,1,0]
>>> temp=[]
>>> for each in num1:
if each not in temp:
temp.append(each)
>>> temp
[1, 2, 3, 4, 5, 0]
>>>
法2:
>>> num1=list(set(num1))
>>> num1
[0, 1, 2, 3, 4, 5]
>>>
2：集合中添加元素
>>> num2={1,2,3,4,5}
>>> num2.add(6)
>>> num2
{1, 2, 3, 4, 5, 6}
>>>
3：使集合不可变—frozen
>>> num3=frozenset([1,2,3,4])
>>> num3.add(5)
Traceback (most recent call last):
File "<pyshell#26>", line 1, in <module>
num3.add(5)
AttributeError: 'frozenset' object has no attribute 'add' //此时抛出异常显示frozen没有add这个功能
>>>
七、文件
1.文件对象方法
>>> f=open('F:\\record.txt') //注意等号
>>> f.read() //全部读取
''
>>> f.close() //不用文件及时关闭，养成个好习惯
>>> f=open('f:\\record.txt')
>>> f.read()
'我好饿呀呀呀\n'
>>> f.read(2) //只读取2个字符（因为此时光标在末尾所以只能读出空格）
''
>>> f.read(5)
''
>>> f.tell() //显示文件输入光标的位置
14
>>> f.seek(3,0) //从文件的开头偏移3个字节
3
>>> f.tell() //显示当前输入签的位置
3
>>> f.close()
>>>
>>> f=open('f:\\record.txt')
>>> f.seek(0,0) //从文件的开头偏移0个字节
0
>>> lines=list(f)
>>> for each_line in lines:
print(each_line)
我好饿呀呀呀
后开始发动了回复
爱护和对方拉黑后
爱的哈卢胡话
好阿纲爱是个哈哈哈功夫还是
>>> f.close()
>>>
- 文件的写入
f=open(‘E:\test.txt’,‘w’) f=open(‘E:\test.txt’,‘w’)
f.write(‘我爱工作’)
f.close()
备注：“文件“内容比较重要需要再看视频巩固学习
扫一扫
193
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
