1 def  test(x):
 2         '''注释，解释函数用途'''
 3         x=x+1
 4         return x
 5 
 6 def:定义函数的关键字
 7 test:函数名
 8 ():括号内可定义形参
 9 x=x+1:泛指代码块或者程序处理逻辑
10 return:定义返回值

 1 1.形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元，因此，形参只有在函数内部才有效。函数调用结束返回主调用函数后则不能再使用该形参变量。
 2 2.实参变量可以是常量，变量，表达式，函数等，无论函数是何种类型的量，在进行函数调用时，它们必须有确定的值，以便把这些值传递给形参。因此应用预先赋值，输入等办法使参数获得确定值。
 3 def  calc(x,y):
 4         res=x**y
 5         return res
 6 a=calc(2,3)
 7 print(a)
 8 #运行结果：8
 9 
10 位置变量：(位置参数，一 一对应，缺一不可)
11 def  test(x,y,z):
12         print(x)
13         print(y)
14         print(z)
15 test(1,2,3)
16 
17 def  test(x,y,z):   (关键字参数，无须一一对应，缺一不行多一不行)
18         print(x)
19         print(y)
20         print(z)
21 test(x=1,z=3,y=2)

1 name="zhouyuan"      #全局变量，全局作用域
2 def  change_name():
3     name="zhoutao"    #局部变量，局部作用域
4     print(name)
5 change_name()
6 print(name)
7 #运行结果:zhoutao
8 #       zhouyuan

 1 name="zy"
 2 def a():
 3     global name
 4     print(name)
 5 def b():
 6     name="zt"
 7     print(name)
 8 a()
 9 b()
10 # 运行结果：zy
11 #         zt

 1 name="zy"
 2 def a():
 3     global name
 4     name="zz"        #现在zz是全局的
 5     print(name)
 6 def b():
 7     print(name)
 8 a()       
 9 b()
10 #运行结果：zz
11 #          zz        （因为a()先执行，a()已经将全局变量变成name=“zz”）
12 
13 name="zy"
14 def a():
15     global name
16     name="zz"        #现在zz是全局的
17     print(name)
18 def b():
19     print(name)     
20 b()         （先执行b()未执行到global）
21 a()
22 #运行结果：zy
23 #        zz

1 name=["蔡徐坤","朱正廷"]
2 def zy():
3     name.append("范丞丞")
4     print(name)
5 zy()
6 #运行结果：['蔡徐坤', '朱正廷', '范丞丞']

 1 name="蔡徐坤"
 2 
 3 def zy():
 4     name="范丞丞"
 5     def zt():
 6         global name
 7         name="农农"
 8     zt()
 9     print(name)
10 
11 print(name)
12 zy()
13 print(name)
14 
15 #运行结果：蔡徐坤
16 #        范丞丞
17 #        农农

 1 name="蔡徐坤"
 2 
 3 def zy():
 4     name="范丞丞"
 5     def zt():
 6         nonlocal name
 7         name="农农"
 8     zt()
 9     print(name)
10 
11 print(name)
12 zy()
13 print(name)
14 
15  #运行结果：蔡徐坤
16 #         农农
17 #         蔡徐坤 

递归调用是函数嵌套调用的一种特殊形式，函数在调用时，直接或间接调用了自身，就是递归调用

1 def calc(n):
2     print(n)
3     if int(n/2)==0:
4         return n
5     return calc(int(n/2))
6 calc(10)
7 #运行结果：10,5，2,1

 1 def test1():
 2     print("in the test1")
 3 def test():
 4     print("in the test")
 5     return test1
 6 res=test()
 7 print(res())
 8 #运行结果：in the test
 9 #        in the test1
10 #        None    （test1没有返回值默认返回None）

 1 def calc(x):
 2     return x+1
 3 
 4 res=calc(10)
 5 print(res)
 6 #运行结果：11
 7 
 8 使用lambda匿名函数：
 9 res=lambda x:x+1    【lambda匿名函数后面x是形参，x+1相当于return x+1】
10 print(res(1))
11 #运行结果：2

1 name="zy"
2 f=lambda x:x+"_sb"
3 res=f(name)
4 print(res)
5 #运行结果：zy_sb

 1 #map(处理方法，可迭代对象)
 2 num_1=[1,2,3,4,5,6]
 3 
 4 def map_test(func,array):
 5     ret=[]
 6     for i in array:
 7         res=func(i)
 8         ret.append(res)
 9     return ret
10 
11 print(map_test(lambda x:x+1,num_1))
12 
13 res=map(lambda x:x+1,num_1)
14 print(list(res))
15 
16 #运行结果：[2, 3, 4, 5, 6, 7]
17 #        [2, 3, 4, 5, 6, 7]

 1 movie_people=['sb_alex','sb_zt','zy','sb_wu']
 2 
 3 def filter_test(array):
 4     ret=[]
 5     for i in array:
 6         if not i.startswith('sb'):
 7             ret.append(i)
 8     return ret
 9 
10 print(filter_test(movie_people))
11 #运行结果：['zy']
12 
13 #终极版本
14 movie_people=['alex_sb','zt_sb','zy','wu_sb']
15 
16 def filter_test(func,array):
17     ret=[]
18     for i in array:
19         if not func(i):
20             ret.append(i)
21     return ret
22 
23 res=filter_test(lambda n:n.endswith('sb'),movie_people)
24 print(res)

1 movie_people=['alex_sb','zt_sb','zy','wu_sb']
2 
3 res=list(filter(lambda n:not n.endswith('sb'),movie_people))
4 print(res)
5 #运行结果：['zy']
6 
7 filter()函数后面是可迭代对象，进行for循环，每个元素进行前面的操作，满足操作输出，没有list输出内存地址。list()就是将其转换成列表输出。

 1 #计算列表元素之积
 2 num_1=[1,2,3,100]
 3 
 4 def reduce_test(func,array):
 5     res=1
 6     for num in array:
 7         res=func(res,num)
 8     return res
 9 
10 print(reduce_test(lambda x,y:x*y,num_1))
11 #运行结果：600
12 
13 #reduce函数（将一个列表进行函数计算最终得一个结果）
14 from functools import reduce     #使用reduce函数python3中必须导入这个模块
15 num_1=[1,2,3,100]
16 print(reduce(lambda x,y:x+y,num_1,0))  
17 #reduce第一个参数是函数，第二个参数是被执行的列表，第三个参数是初始值
18 #运行结果：106

  1 #python中常用的内置函数
  2 【1】abs()   取绝对值
  3  print(abs(-1))
  4 #结果：1
  5 
  6 【2】all()  判断True False 只要有一个为False就为False  #0,空,None是False，其它为True
  7  print(all([1,2,'3']))
  8  print(all([1,2,'3','']))
  9 #结果：True False
 10 
 11  【3】any() 有一个为真就是True
 12  print(any([0,'']))
 13  print(any([0,'',1]))
 14 #结果：False True
 15 
 16  【4】bin() 十进制转换为二进制
 17  print(bin(3))
 18 #结果：0b11
 19 
 20  【5】bool()   布尔值  #0,空,None是False，其它为True
 21  print(bool(''))
 22  print(bool(None))
 23  print(bool(0))
 24 #结果：False False False
 25 
 26  【6】bytes()  字节编码
 27  name='你好'
 28  print(bytes(name,encoding='utf-8'))
 29 #结果：b'\xe4\xbd\xa0\xe5\xa5\xbd'
 30  print(bytes(name,encoding='utf-8').decode('utf-8'))
 31 #结果：你好
 32 #用什么编码就用什么解码， decode()解码，次例是utf-8编码，所以是utf-8解码
 33 #gbk,utf-8都可以解码，对于ascii码不能编码中文。
 34  
 35  【7】chr()  数字对应的ascii值
 36  print(chr(97))
 37 #结果：a
 38 
 39  【8】dir() 打印方法里的属性
 40  print(dir(dict))
 41 #结果：['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
 42 
 43  【9】divmod()  两数相除返回得数与余数
 44  print(divmod(10,3))
 45 #结果：(3,1)
 46 
 47  【10】eval()  计算字符串中表达式的结果；
 48  express='1+2*(5*1)'
 49  print(eval(express)) 
 50 #结果：11
 51 
 52  【11】hash() #可hash数据类型就是不可变数据类型；不可根据hash值来反推原值
 53  print(hash('1525'))    
 54 #结果：6370411092133961450
 55 #所有字符串或者值对于hash值是一样的，所以对于某个软件字符串hash是一样的，可用来判断软件是否被篡改。
 56 
 57  【12】help()  查看方法如何使用
 58 print(help(all))
 59 
 60  【13】hex()  十进制转化为十六进制
 61  print(hex(12))
 62 #结果：0xc
 63 
 64  【14】oct()  十进制转化为八进制
 65  print(oct(12))
 66 #结果：0o14
 67 
 68  【15】isinstance()  判断数据类型，返回True False
 69  print(isinstance(1,int))
 70 #结果：True
 71 
 72  【16】max()  min() 取最大最小
 73 
 74  【17】ord()  显示字符对应的数字
 75   print(ord(a))
 76 #结果：97
 77 
 78  【18】pow()  次方
 79  print(pow(2,4))   #2**4
 80  print(pow(2,4,3))   #（2**4）%3
 81 #结果：16 1
 82 
 83  【19】reversed()  反转
 84  li=[1,2,3,4]
 85  print(list(reversed(li)))
 86 #结果：[4,3,2,1]
 87 
 88  【20】round()   四舍五入
 89  print(round(3.5))
 90 #结果：4
 91 
 92  【21】slice()  切片操作
 93  li='hello'
 94  s1=slice(3,5)
 95  s2=slice(1,4,2)
 96  print(li[s1])
 97  print(li[s2])
 98 #结果：lo el
 99 
100  【22】sorted()  排序
101  li=[5,1,8,3]
102  print(sorted(li))
103 #结果：[1,3,5,8]
104  li=[{'age':18},{'age':22},{'age':20}]
105  print(sorted(li,key=lambda dic:dic['age']))
106 #结果：[{'age': 18}, {'age': 20}, {'age': 22}]
107 
108  【23】zip()  取key和values的组合值
109   people={'蔡徐坤age':18,
110                 '农农age':19,
111                 '范丞丞age':20}
112   print(sorted(zip(people.values(),people.keys())))
113 #结果：[(18, '蔡徐坤age'), (19, '农农age'), (20, '范丞丞age')]
114 
115  【24】str() 任意类型转化成字符串
116 
117  【25】sum()  求和
118 
119  【26】type() 判断数据类型

 1 zip方法
 2 print(list(zip(('a','b','c'),(1,2,3))))
 3 #结果：[('a', 1), ('b', 2), ('c', 3)]  （类似拉链，左右对应）
 4 
 5 p={'name':'alex','age':'18'}
 6 print(list(zip(p.keys(),p.values())))
 7 print(list(p.keys()))
 8 print(list(p.values()))
 9 #结果：[('age', '18'), ('name', 'alex')]
10 #     ['age', 'name']
11 #     ['18', 'alex']

 1  #【只要是可迭代对象都可以用max与min，原理就是for循环】
 2 li=[1,3,51,6]
 3 print(max(li))
 4 print(min(li))
 5 #结果：51  1
 6 
 7 age_dic={'age1':18,'age2':20,'age3':100}
 8 print(max(age_dic.values()))
 9 print(max(age_dic))      #默认是取key的值
10 #结果：100  age3    
11 
12 li=[(5,'a'),(1,'b'),(3,'e'),(4,'d')]
13 print(list(max(li)))
14 #结果：[5, 'a']
15 
16 li=['a10','b12','c10']      #不同类型之间不能进行比较['a10','b12','c10'，100]不行  
17 print(list(max(li)))
18 #结果：['c', '1', '0']
19 
20 终极：
21 people=[{'name':'alex','age':100},
22             {'name':'zy','age':18},
23             {'name':'zt','age':12}]
24 print(max(people,key=lambda dic:dic['age']))
25 #结果：{'name': 'alex', 'age': 100}