python函数语法
1 def 函数名():
2 代码块(函数体)
3 函数名() #调用函数
4 注意：函数名按照变量命名规则命名
5 def func():
6 print('hello China')
7 print('你好 中国')
8 func()
9 结果
10 hello China
11 你好 中国
1 函数名的赋值 2 a = b = c = abc = f 3 拿到的是f函数的返回值 4 a = b = c = abc = f()
函数注释
1 def f(a,b): 2 ''' 3 这是一个函数,函数的功能 4 :param a: 数值1,数据类型,默认值,是否可选 5 :param b: 数值2,数据类型,是否有默认值,是否可选 6 :return: 函数返回结果 7 :creator: 创建者 8 :author: 作者 9 :date: 时间 10 ''' 11 c = f 12 c(1,2) 13 print(c.__name__) #看到函数的真实的名字(相对) 14 print(c.__doc__) #查看注释信息 15 print(str.capitalize.__doc__) #查看str方法的源码帮助文档
函数返回值return
函数的返回值:(谁调用的返回值,值就返回给谁)
函数可以有返回值, 也可以没有返回值
函数如果没有返回值,在函数最后执行完毕的时候会默认返回None
在函数中只写了return, 但是没有写返回值也会返回None
在函数中写了return None 返回的结果还是None
在函数中写了return 值, 返回一个结果.
在函数中写return 值1, 值2, 值3... 返回多个结果,多个结果会以元组的形式返回
1 不写return的情况
2 def func():
3 print('hello China')
4 print('你好 中国')
5 ret = func()
6 print(ret)
7 结果
8 hello China
9 你好 中国
10 None
11
12 只写return，后面不写其他内容
13 def func():
14 print('hello China')
15 print('你好 中国')
16 return
17 ret = func()
18 print(ret)
19 结果
20 hello China
21 你好 中国
22 None
23
24 就是一旦遇到return，结束整个函数,不再执行return下面的代码
25 def func():
26 print('hello China')
27 print('你好 中国')
28 return '返回值'
29 print('你好, 世界')
30 ret = func()
31 print(ret)
32 print(func) #返回函数的内存地址
33 结果
34 hello China
35 你好 中国
36 返回值
37
38 一个返回一个值的情况，只需在return后面写上要返回的内容即可
39 def f():
40 count = 0
41 for i in range(5):
42 count += i
43 return count
44 test = f()
45 print(test)
46 结果
47 10
48 注意：return和返回值之间要有空格，可以返回任意数据类型的值
49
50 返回任意多个、任意数据类型的值
51 def func():
52 print('hello China')
53 print('你好 中国')
54 return '返回值1','返回值2'
55 ret = func()
56 print(ret)
57 结果
58 hello China
59 你好 中国
60 ('返回值1', '返回值2')
61
62 def func():
63 print('hello China')
64 print('你好 中国')
65 return 1, ['a', 'b'], {'c': 'c1'}
66 ret = func()
67 print(ret)
68 结果
69 hello China
70 你好 中国
71 (1, ['a', 'b'], {'c': 'c1'})
72
73 返回一个值的时候就是本身,返回的多个值会被组织成元组被返回,也可以用多个值来接收
74 def f():
75 return 1,['a','b'],{'c':'c1'}
76 a,b,c= f()
77 print(a,b,c)
78 结果
79 1 ['a', 'b'] {'c': 'c1'}
80 注意：python中把用逗号分割的多个值就认为是一个元组
序列解压
1 >>> 1,2
2 (1, 2)
3 >>> a,b = (1,2)
4 >>> a
5 1
6 >>> b
7 2
8 >>> a,_,_,d=(1,2,3,4)
9 >>> a
10 1
11 >>> d
12 4
13 >>> a,*_=(1,2,3,4)
14 >>> a
15 1
16 >>> *_,d=(1,2,3,4)
17 >>> d
18 4
19 #也适用于字符串、列表、字典、集合
20 >>> a,b = {'name':'bob','age':23}
21 >>> a
22 'name'
23 >>> b
24 'age'
三元运算符
语法: 结果 如果条件成立使用前面的 否则就使用后边的
1 def func():
2 a = input('<<:')
3 b = input('<<:')
4 c = a if a>b else b
5 return c
6 ret = func()
7 print(ret)
8
9 def func():
10 s = input('<<:')
11 # if int(s.rsplit(',')[0]) > int(s.rsplit(',')[0]):
12 # return s.rsplit(',')[0]
13 # else:
14 # return s.rsplit(',')[1]
15 c = s.rsplit(',')[0] if int(s.rsplit(',')[0]) > int(s.rsplit(',')[1]) else s.rsplit(',')[1]
16 return c
17 ret = func()
18 print(ret)
函数的参数
实参：在函数调用的时候括号里放入的值就是实参
形参：在函数定义的时候括号里的变量就是形参(对于一个形参只能赋值一次)
传参：将实参传递给形参的过程
1 def func(a): #a就是形参
2 print('hello %s'%a)
3 return a
4 ret = func('China') #China就是实参
5 print(ret)
6 结果
7 hello China
8 China
位置参数：按照实参的位置对应把值赋值给形参中变量(位置参数必须传值，否则报错)
1 def func(a,b,c):
2 print('hello %s'%a)
3 print('你好 %s'%b)
4 print('Welcome %s'%c)
5 return a,b,c
6 ret = func('China','中国','世界')
7 print(ret)
8 结果
9 hello China
10 你好 中国
11 Welcome 世界
12 ('China', '中国', '世界')
13
14
15 拆包获取返回值
16 def f1(a,b):
17 he = a + b
18 cha = a - b
19 return (he,cha)
20 count1,count2 = f1(9,8)
21 print(count1)
22 print(count2)
23 结果
24 17
25 1
关键字传参: 按照形参声明的变量名进行传递
1 def func(a,b,c):
2 print('hello %s'%a)
3 print('你好 %s'%b)
4 print('Welcome %s'%c)
5 return a,b,c
6 ret = func(c='China',a='中国',b='世界')
7 print(ret)
8 结果
9 hello 中国
10 你好 世界
11 Welcome China
12 ('中国', '世界', 'China')
混合参数(位置关键字传参混合)：位置参数必须在关键字参数的前面
1 def func(a,b,c,d):
2 print('hello %s'%a)
3 print('Welcome %s' % d)
4 print('你好 %s'%b)
5 print('Welcome %s'%c)
6 return a,b,c,d
7 ret = func('China','中国',d='北京',c='世界')
8 print(ret)
9 结果
10 hello China
11 Welcome 北京
12 你好 中国
13 Welcome 世界
14 ('China', '中国', '世界', '北京')
默认参数(关键字参数)：在函数定义的时候,直接给变量赋值
默认参数可以不传参
默认参数可以传参,但会将默认参数的值覆盖
1 def func(a,b='China',c='上海'):
2 print('hello %s'%a)
3 print('你好 %s'%b)
4 print('Welcome %s'%c)
5 return a,b,c
6 ret = func('世界','中国')
7 print(ret)
8 结果
9 hello 世界
10 你好 中国
11 Welcome 上海
12 ('世界', '中国', '上海')
函数扩展
1 函数传参
2 def func(name, addr, sex, age):
3 print('%s在%s,想去找年龄%s的%s一起玩' % (name, addr, age, sex))
4 func('jarck', '上海', '小哥哥', 20)
5 结果
6 jarck在上海,想去找年龄20的小哥哥一起玩
7
8 事例二
9 def f1():
10 print('娃哈哈')
11
12 def f2():
13 print('qqxing')
14 l = [f1,f2]
15 print(l) #打印的是函数f1,f2的函数内存地址空间
16 f1_func = l[1] #f1_func变量就等于f2函数
17 f1_func() #所以f1_func的值就是qqxing
18 l[1]() #所以l[1]的值就是f2的值qqxing
19 for f in l: #l等于f1和f2两个函数的值
20 f()
21 结果
22 [<function f1 at 0x0000016C9D9E2E18>, <function f2 at 0x0000016C9F6E09D8>]
23 qqxing
24 qqxing
25 娃哈哈
26 qqxing
27
28
29 函数名可以作为函数的参数
30 def login():
31 print('欢迎登陆')
32 def index(auth): #用auth接收传递过来的login函数
33 auth() #执行auth相当于执行了login函数
34 print('欢迎来到首页')
35 index(login) #把login函数以形参的方式传递给index函数
36 结果
37 欢迎登陆
38 欢迎来到首页
39
40
41 高阶函数
42 lst = [{'name':'s1','age':18},{'name':'s3','age':19},{'name':'s2','age':18.5}]
43 def st(n):
44 return n['age']
45 ret = sorted(lst,key=st)
46 print(ret)
47 结果
48 [{'name': 's1', 'age': 18}, {'name': 's2', 'age': 18.5}, {'name': 's3', 'age': 19}]
49
50
51 使用场景
52 def count(num1,num2,cacu_func):
53 result = cacu_func(num1,num2)
54 print(result)
55
56 def sum(a,b):
57 return a + b
58
59 def jianfa(a,b):
60 return a - b
61
62 count(6,2,jianfa)
63 count(6,2,sum)
64 结果
65 4
66 8
67
68
69 返回函数
70 def get_func(flage):
71 def sum(a,b,c):
72 return a + b + c
73 def jian(a,b,c):
74 return a - b - c
75 if flage == '+':
76 return sum
77 elif flage == '-':
78 return jian
79
80 # result = get_func('+')
81 result = get_func('-')
82 ret = result(1,3,5)
83 print(ret)
84 结果
85 -7
86
87
88 函数名可以作为函数的返回值
89 def login_failed():
90 print('登陆失败')
91 def index():
92 print('欢迎来到首页')
93 def login(usr,pwd):
94 if usr == 'liugang' and pwd == '123':
95 return index #return一个index函数的返回值
96 else:
97 return login_failed #return一个login_failed函数的返回值
98 res_func = login('liugang','123')
99 res_func()
100 结果
101 欢迎来到首页
102
103
104 偏函数(某一个参数偏爱某个数值)
105 方式一
106 def f1(a,b,c=1):
107 print(a+b-c)
108 # f1(3,7,2)
109
110 def f2(a,b=7,c=2):
111 f1(a,b,c)
112 f2(3)
113
114 方式二
115 import functools
116 new_func = functools.partial(f1,c=2)
117 new_func(3,7)
118
119 结果
120 8
121
122 使用场景
123 num = '100010'
124 ret = int(num,base=2) #bese把一个数转换成二进制格式
125 print(ret)
126 等同于
127 import functools
128 int2 = functools.partial(int,base=2)
129 print(int2(num))
130 结果
131 34
132
133
134 参数陷阱: 默认参数是一个可变数据类型
135 def defult_param(a,l = []):
136 l.append(a)
137 print(l)
138 defult_param('bob')
139 defult_param('jarck')
140 结果
141 ['bob']
142 ['bob', 'jarck']
143
144 事例二
145 lst = []
146 def func(a, l=lst): #a就是一个位置参数,等待func给其传递参数l相当于空列表
147 l.append(a) #把传递过来a的值添加到l列表中,相当于加入到lst空列表中
148 print(l)
149 func(1)
150 func(2, []) #把2传递给a,l本身就是个空列表,再传递给其一个空列表,传递过来的这个空列表生效
151 func(3)
152 结果
153 [1]
154 [2]
155 [1, 3]
156
157
158 总结
159 函数名的本质上就是函数的内存地址
160 可以被引用
161 可以被当作容器类型的元素
162 可以当作函数的参数和返回值
来源：https://www.cnblogs.com/linuxcbb/p/9885777.html