1.函数定义、格式、参数
1)定义
函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需要调用其函数名即可。
2)一般格式
def 函数名(参数):
函数体
def为函数关键字，参数根据需求传入即可，hi()表示调用定义的函数。
1
def
hi():
2
print("hi")
3hi()
4结果：
5 hi
3)参数
形参：形式参数，在定义函数和函数体的时候使用形参。
实参：实际参数，调用函数时传给函数的参数，可以是常量，变量，表达式，函数，传给形参。
参数分类：必需参数、关键字参数、默认参数、不定长参数。
2.函数的参数
1)必需参数
必需参数需要按照函数声明时的顺序依次传入函数，数量也必须保持一致。
1
def
fun(name,age):
2
print("my name is %s,%s years."%(name,age))
3 fun(‘fox‘,22)
4结果：
5 my name is fox,22 years.
2)关键字参数
关键字参数只是在调用的时候加上关键字，此时顺序可以颠倒，无需像必需参数一样顺序保持一致。
1
def
fun(name,age):
2
print("my name is %s,%s years."%(name,age))
3 fun(age=22,name=‘fox‘)
4 fun(name=‘fox‘,age=22)
5结果：
6 my name is fox,22 years.
7 my name is fox,22 years.
3)默认参数
默认参数指给某个参数加上默认值，在调用传入时未重新指定值时就用默认值，重新指定就用新的值。
1
def fun(name,age,sex=‘M‘):
2print("my name is %s,%s years,%s."%(name,age,sex))
3 fun(‘fox‘,22)
4 fun(‘fox‘,22,sex=‘Female‘)
5结果：
6 my name is fox,22 years,M.
7 my name is fox,22 years,Female.
4)不定长参数
当传入的参数无法得知准确数量或者数量多的时候，可用(*args)充当形参，生成时不会被命名，此时传入的实参会组成以args命名的元组。
1
def fun(*args):
2print(args)
3print(type(args))
4 fun(1,‘a‘,2,‘b‘)
5结果：
6 (1, ‘a‘, 2, ‘b‘)
7 <class‘tuple‘>
8 9 *****分割线*****
1011def add(*args):
12 sumb = 0
13for i in args:
14 sumb += i
15print(sumb)
16 add(1,2,3,4,5)
17结果：
18 15
(*args)生成时不会被命名，而(**kwargs)充当形参时，调用函数时，传入的实参可以被命名，此时传入的实参会组成以kwargs命名的字典，args和kwargs只是惯用写法，也可以重命名。
1
def fun(**kwargs):
2print(kwargs)
3print(type(kwargs))
4 fun(name=‘fox‘,age=22,sex=‘M‘,work=‘it‘)
5结果：
6 {‘sex‘: ‘M‘, ‘age‘: 22, ‘work‘: ‘it‘, ‘name‘: ‘fox‘}
7 <class‘dict‘>
8 9 *****分割线*****
1011def fun(**kwargs):
12for i in kwargs:
13print("%s:%s"%(i,kwargs[i]))
14 fun(name=‘fox‘,age=22,sex=‘M‘,work=‘it‘)
15结果：
16name:fox
17work:it
18 age:22
19 sex:M
3.高阶函数
至少满足下列其中之一的函数：
1)接收一个或者多个函数作为输入。
2)输出一个函数。
下列函数返回的是一个函数，此时我们调用foo()函数时，返回的不是结果numb,而是函数add()，调用f()时才是求和的结果。
1
def foo(*args):
2def add():
3 numb = 0
4for i in args:
5 numb += i
6return numb
7return add
8 f = foo(1,2,3,4)
9f()
10print(f)
11print(f())
12结果：
13 <function foo.<locals>.add at 0x000002B63B8EC400>
14 10
4.函数的返回值和作用域
1)函数的返回值
执行函数的返回值时，可以使用return语句。
函数在执行过程中遇到return语句时，就会停止执行并返回结果，即return代表着函数的终止。
如果未在函数中指定return，则返回值为None。
return有多个对象时，解释器会把多个对象组成一个元组作为一个整体输出。
2)函数的作用域
作用域分为四种情况：
local:局部作用域，即最里层函数的作用域。
enclosing:父级函数的局部作用域，里层函数的外一层，相对而言。
globa:全局变量，即模块级别的作用域。
built-in:系统固定模块的变量。
作用域的优先级顺序，局部作用域>父级局部作用域>全局变量>python内置作用域，python中只有模块、类、函数才会引入新作用域。
1 b_count = int(1) #python内置作用域2 g_count = 2 #全局变量3def foo():
4 e_count = 3 #父级函数的局部作用域5def bar():
6 l_count = 4 #局部作用域7#print(l_count) #报错，找不到变量l_count8#print(e_count) #报错，找不到变量e_count
5.修改不同作用域的变量
1)global关键字
当在函数内需要修改的变量是全局变量global时，只需在修改前声明 global 变量名 即可，在局部作用域和父级函数局部作用域都可以使用。
1 a = 10
2def foo():
3global a
4print(a)
5 a = 100
6print(a)
7foo()
8结果：
9 10
10 100
2)nonlocal关键字
当函数内需要修改的变量是父级函数局部变量时，在修改前声明 nonlocal 变量名 即可。
1
def
foo():
2 a = 10
3def bar():
4 nonlocal a
5print(a)
6 a = 100
7print(a)
8return bar
9 f = foo()
10f()
11结果：
12 10
13 100
6.函数的执行过程
程序在逐句执行代码时，当遇到def关键字时会跳过该函数，继续往下执行，直到遇到有调用此函数时，重新回到def依次往下执行，故下列代码中，先输出的时3 10。
1
def foo(): # 1 3 2 a = 10 # 4 3def bar(): # 5 8 4 nonlocal a
5print(1,a) # 9 6 a = 100 # 10 7print(2,a) # 11 8print(3, a) # 6 9return bar # 710 foo()() # 211结果：
12 3 10
13 1 10
14 2 100
7.递归函数
1)定义
如果一个函数在内部调用自身，那么这个函数就是递归函数。
2)递归特性
必须有一个明确的结束条件。
每次进入更深层次的递归时，递归次数相继减少。
递归效率不高，但是逻辑清晰。
3)分别用递归函数和普通函数实现阶乘
正整数的阶乘是所有小于及等级该数的正整数的积，如5的阶乘为5*4*3*2*1，表示为5!；利用for循环时，第三行也可以改为 for i in range(1,numb+1)，即从1开始，numb结束遍历。
1
def
fun(numb):
2 count = 1
3for i in range(numb):
4 count *= i+1
5print(count)
6 fun(4)
7结果：
8 24
递归函数，当传入参数为1时，1*fun(0)超出阶乘的定义范围，则另外设置当numb为1时的值。
1
def
fun(numb):
2
if numb == 1:
3return 1
4return numb * fun(numb - 1)
5print(fun(5))
6结果：
7 120
4)分别用递归函数和普通函数实现斐波那契数列
斐波那契数列又叫黄金分割数列，是一组前两个数之和为第三个数的有迹可循的数列，即1，1，2，3，5，8，13，21，34...
1
def
fun(numb):
2 before = 0
3 after = 1
4for i in range(numb-1):
5 sum1 = after + before
6 before = after
7 after = sum1
8return sum1
9print(fun(4))
10结果：
11 3
递归函数，根据斐波那契数列性质可知，前两个之和等于第三个，目的是为了求传入的参数所对应的值，则可以求前两个数之和即为所求的值。
1
def
fun(numb):
2
if numb == 1:
3return 1
4if numb == 2:
5return 1
6return fun(numb - 1) + fun(numb - 2)
7print(fun(4))
8结果：
9 3
8.内置函数
1)map()
map()是内置的高阶函数，它接收一个函数fun和一个列表list，并通过把函数fun依次作用在列表list的每个元素上，得到一个新的列表list并返回。
map()函数返回的是一个map对象，需要list将映射之后的map对象转换成列表。
map()函数是挨个的处理一个列表中的每一个元素。
1 lis = [1,2,3,4,5]
2def fun(x):
3return x * x
4 ret = (map(fun,lis))
5print(list(ret))
6结果：
7 [1, 4, 9, 16, 25]
8 9 *****分割线*****
1011 lis = ["aDFSsd","ADFfdsS","sDfDfY"]
12def foo(lis):
13 s1 = lis[0:1].upper() + lis[1:].lower()
14return s1
15set = map(foo,lis)
16 print(list(set))
17结果：
18 [‘Adfssd‘, ‘Adffdss‘, ‘Sdfdfy‘]
2)filter()
filter()是内置的另一个高阶函数，同样接收一个函数fun和一个列表list，函数fun的作用是对每个元素进行判断，返回True或False，filter()根据判断结果自动过滤掉不符合元素，返回符合条件的新的list。
filter()与map()类似，挨个处理列表中的每一个元素，map()是通过函数fun处理list中每个元素，filter()是通过函数fun删选每一个元素。
例如，要去除列表[3,6,7,8,15,34,75]中的奇数，保留偶数。
1 lis = [3,6,7,8,15,34,75]
2def foo(x):
3if x % 2 == 0:
4return x
5set = filter(foo,lis)
6 print(list(set))
7结果：
8 [6, 8, 34]
3)reduce()
reduce() 是接收的参数和 map()类似，一个函数fun，一个list，但行为和 map()不同，reduce()传入的函数fun必须接收两个参数。
deduce()对list的每个元素反复调用函数fun，并返回最终结果值。
第一次调用是把list的前两个元素传递给fun,第二次调用时，就是把前两个list元素的计算结果当成第一个参数，list的第三个元素当成第二个参数，传入fun进行操作，以此类推，并最终返回结果。
1
from
functools import reduce
2 lis = [1,2,3,4,5,6,7,8,9]
3def fun(x,y):
4return x + y
5print(reduce(fun,lis))
6结果：
745
4)匿名函数
用lambda关键字标识，冒号‘:‘左边表示函数接收的参数，右边表示函数的返回值，因在创建的时候无须命名则叫匿名函数。
1 fun = lambda a,b:a + b
2 print(fun(5,6))
3结果：
411
原文：https://www.cnblogs.com/foxshu/p/12035633.html
【说明】：本文章由站长整理发布，文章内容不代表本站观点，如文中有侵权行为，请与本站客服联系(QQ:254677821)！