Python基础——函数（200512）

Python——函数

函数

1.函数概述：

　　函数：用于完成特定功能的一段代码块，可用于重复使用。函数能够提高应用的模块性，和代码的利用率；函数包含内置函数和用户自定义的函数两种。

2.为什么使用函数：

代码可以重复使用，提高代码的利用率
保持代码一致性，易维护
可扩展性

定义函数

1.定义一个函数

　　1）可以定义一个特定功能的函数，规则如下：

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明
函数内容以冒号起始，并且缩进
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None

　　2）语法：

 1 def function(x):
 2   '''函数说明文档'''
 3     x += 1
 4     return expression
 5 function(2)
 6 
 7 # def:定义函数的关键字
 8 # function:函数名
 9 # （）：括号内可以设置参数，形参
10 # x += 1:泛指代码块或程序处理逻辑
11 # return expression：定义返回值
12 # function(2):传入实参

　　3）举例：定义一个打印 hello + name 的函数

1 def greet(name):
2     '''打招呼函数'''
3     mes = 'hello %s !'%name
4     return mes
5 res = greet('alex')
6 print(res)
7 # =>hello alex !

2.函数返回值

　　1）函数和过程

过程：没有return返回值的函数
函数：有return返回值

　　2）返回值

　　return [expression] 语句：退出函数，函数运行到return语句就是直接退出函数，不会再继续运行函数体内return下面的语句。return返回值。

　　<1> 默认返回值

　　默认返回值：在函数体内部若无return返回值，则默认返回None，return是函数结束的标志。

1 def greet(name):
2     print('hello %s !'%name)
3 print(greet('张三'))
4 # =>hello 张三 !
5 # =>None

　　<2> 1个返回值

　　有1个返回值：指定了返回值

1 def greet(name):
2     print('hello %s !'%name)
3     return '你真棒！'
4 print(greet('张三'))
5 # =>hello 张三 !
6 # =>你真棒！

　　<3> 多个返回值

　　多个返回值：指定了多个返回值，当有多个返回值时，以元组形式返回，内含多个值

1 def greet(name):
2     print('hello %s !'%name)
3     return '你真棒！','Are you OK!','666'
4 print(greet('张三'))
5 # =>hello 张三 !
6 # =>('你真棒！', 'Are you OK!', '666')

3.函数参数

　　1）形参和实参

形参：形参在函数被调用时使用，只在函数体内部有效
实参：可以是常量、变量、表达式、函数等，函数调用时将值传递给形参

1 def calc(x,y):  # x,y :形参
2     result = x+y
3     return result
4 c = calc(1,2) # 1,2:实参(具体数值)
5 print(c)
6 # =>3

　　2）位置参数

　　位置参数：传递的实参个数与形参必须一一对应，少一个和多一个都不行，不对应会报错

 1 # 一一对应
 2 def position(x,y,z):
 3     print(x)
 4     print(y)
 5     print(z)
 6 position(1,2,3)
 7 # =>1
 8 # =>2
 9 # =>3
10 
11 # 不对应
12 def position(x,y,z):
13     print(x)
14     print(y)
15     print(z)
16 position(1,2,3,4)
17 # =>报错

　　3）关键字参数

　　关键字参数：对形参无需对应，但必须进行一一指定，少一个和多一个都不行，否则会报错

1 def key(x,y,z):
2     print(x)
3     print(y)
4     print(z)
5 key(x=1,y=2,z=3)
6 # =>1
7 # =>2
8 # =>3

　　4）位置和关键字参数混合使用

　　位置和关键字参数混合使用：位置参数必须在左边也就是前边，关键字参数在后面，一一对应关系，多个值会报错

 1 def position_key(x,y,z):
 2     print(x)
 3     print(y)
 4     print(z)
 5 position_key(1,2,z=3)
 6 # =>1
 7 # =>2
 8 # =>3
 9 
10 position(1,y=2,3) 
11 # =>报错

　　5）默认参数

　　默认参数：定义了默认形参，实参就可以不用传递，若传递会覆盖默认参数

1 def default(x,type='King'):   # type='King'：为默认参数
2     print(x)
3     print(type)
4 default('hello')   # 不对默认参数进行传递
5 # =>hello
6 # =>King
7 default('hello','lisi')   # 对默认参数进行传递，会覆盖原有参数
8 # =>hello
9 # =>lisi

　　6）参数组

　　参数组：（**字典；*列表）传递可变长参数

 1 def test(x,*args):  # *：作为列表存储
 2     print(x)
 3     print(args)   # 作为元组输出
 4 test(1,2,3,4,5)
 5 # =>1
 6 # =>(2, 3, 4, 5)
 7 
 8 def test(x,**kwargs):  # **：作为字典存储
 9     print(x)
10     print(kwargs)   # 作为字典输出
11 test(1,y=2,z=3)
12 # =>1
13 # =>{'y': 2, 'z': 3}
14 
15 def test(x,*args,**kwargs):  # 可以接受多个值
16     print(x)
17     print(args)  # 作为元组输出
18     print(kwargs)   # 作为字典输出
19 test(1,2,3,4,5,6,7,y=2,z=3)
20 # =>1
21 # =>(2, 3, 4, 5, 6, 7)
22 # =>{'y': 2, 'z': 3}
23 test(1,*[1,2,3],**{'y':2,'z':3})
24 # =>1
25 # =>(1, 2, 3)
26 # =>{'y': 2, 'z': 3}

　　7）参数集合实例

  1 # 第1种：1传给x；2传给y；3传给z
  2 def func(x,y,z):
  3     print(x,y,z)
  4 func(1,2,3)
  5 # =>1 2 3
  6 
  7 # 第2种：1传给x；3传给z；3传给y,改变y的默认值
  8 def func(x,z,y=5):
  9     print(x,y,z)
 10 func(1,3,3)
 11 # =>1 3 3
 12 
 13 # 第3种：1传给x; 2传给y; 3,4,5,6作为元组传给*z
 14 def func(x,y,*z):
 15     print(x,y,z)
 16 func(1,2,3,4,5,6)
 17 # =1 2 (3, 4, 5, 6)
 18 
 19 # 第4种:1传给x; 2,3作为元组传给*z；**y无元素传递为空字典
 20 def func(x,*z,**y):
 21     print(x,y,z)
 22 func(1,2,3)
 23 # =>1 {} (2, 3)
 24 
 25 # 第5种:1传给x; name=2,age=3键值对传给**z形成字典；*y无元素传递为空元组
 26 def func(x,*y,**z):
 27     print(x,y,z)
 28 func(1,name=2,age=3)
 29 # =>1 () {'name': 2, 'age': 3}
 30 
 31 # 第6种:1传给x；2,3,4作为元组传给*y；name=2,age=3键值对传给**z形成字典
 32 def func(x,*y,**z):
 33     print(x,y,z)
 34 func(1,2,3,4,name=2,age=3)
 35 # =>1 (2, 3, 4) {'name': 2, 'age': 3}
 36 
 37 # 第7种:name=2,age=3键值对传给**z成为字典；x=2为默认值无元素传递则继续为默认值2；*y无元素传递为空元组
 38 def func(x=2,*y,**z):
 39     print(x,y,z)
 40 func(name=2,age=3)
 41 # =>2 () {'name': 2, 'age': 3}
 42 
 43 # 第8种：1,2,3,4,5作为元组传给*y；**z无元素传递为空字典
 44 def func(*y,**z):
 45     print(y,z)
 46 func(1,2,3,4,5)
 47 # =>(1, 2, 3, 4, 5) {}
 48 
 49 # 第9种：[1,2,3,4,5]作为一个元素传给*y形成包含列表的元组；**z无元素传递为空字典
 50 def func(*y,**z):
 51     print(y,z)
 52 func([1,2,3,4,5])
 53 # =>([1, 2, 3, 4, 5],) {}
 54 
 55 # 第10种：*[1,2,3,4,5]有星号直接传给*y，直接中括号变小括号形成元组；**z无元素传递为空字典
 56 def func(*y,**z):
 57     print(y,z)
 58 func(*[1,2,3,4,5])
 59 # =>(1, 2, 3, 4, 5) {}
 60 
 61 # 第11种：*[1,2,3,4,5]有星号直接传给*y，直接中括号变小括号形成元组；name=2,age=3键值对传给**z形成字典
 62 def func(*y,**z):
 63     print(y,z)
 64 func(*[1,2,3,4,5],name='alex',age=18)
 65 # =>(1, 2, 3, 4, 5) {'name': 'alex', 'age': 18}
 66 
 67 # 第12种：*[1,2,3,4,5]有星号直接传给*y，直接中括号变小括号，{'name':'alex','age':18}无双星号，也作为一个元素最终形成元组；**z无元素传递为空字典
 68 def func(*y,**z):
 69     print(y,z)
 70 func(*[1,2,3,4,5],{'name':'alex','age':18})
 71 # =>(1, 2, 3, 4, 5, {'name': 'alex', 'age': 18}) {}
 72 
 73 # 第13种：*[1,2,3,4,5]有星号直接传给*y，直接中括号变小括号形成元组；**{'name':'alex','age':18}有双星号，直接作为字典传递，形成字典
 74 def func(*y,**z):
 75     print(y,z)
 76 func(*[1,2,3,4,5],**{'name':'alex','age':18})
 77 # =>(1, 2, 3, 4, 5) {'name': 'alex', 'age': 18}
 78 
 79 # 第14种
 80 def func1(x=1,*y,**z):
 81     print(x,y,z)
 82     return y
 83     print(x)
 84 def func2(arg):
 85     ret = func1(name=arg)
 86     print(ret)
 87 res = func2('alex')
 88 print(res)
 89 # =>1 () {'name': 'alex'}
 90 # =>()
 91 # =>None
 92 
 93 # 第15种
 94 def func(arg):
 95     arg.append(55)
 96 li = [11,22,33,44]
 97 func(li)
 98 print(li)
 99 # =>[11, 22, 33, 44, 55]
100 li = func(li)
101 print(li)
102 # =>None
103 
104 # 第16种
105 def func1(arg):
106     print(arg+100)
107 def func2(arg):
108     ret = func1(arg+1)
109     print(arg)
110     print(ret)
111 ret = func2(7)
112 print(ret)
113 # =>108
114 #   7
115 #   None
116 #   None

View Code

4.函数作用域

　　一个程序内变量的访问不是随处都可以进行访问的，访问权限决定于变量在哪里被赋值。

　　函数的作用域决定了在哪一部分可以访问哪个特定的变量名称，两种最基本的变量作用域为：

全局变量
局部变量

　　1）函数作用域

　　函数作用域：与函数的调用位置无关，只与存在位置有关

　　<1> 一般函数作用域

1 def one():
2     print('666')
3 one()
4 # =>666
5 print(one)  # 打印one的内存地址
6 # =><function one at 0x000002004BC95438>
7 print(one())
8 # =>666
9 # =>None

　　<2> 嵌套函数作用域

 1 name = '张三'
 2 def find_name():
 3     name = '李四'
 4     def find_name_one():
 5         name = '王二麻子'
 6         def find_name_two():
 7             name = '刘五'
 8             print(name)
 9         return find_name_two
10     return find_name_one
11 # 方法一：
12 value = find_name()   # 得到的值为find_name_one的内存地址
13 print(value)
14 # =><function find_name.<locals>.find_name_one at 0x0000020068585678>
15 value_one = value()    # 运行find_name_one()函数，得到的值为find_name_two的内存地址
16 print(value_one)
17 # =><function find_name.<locals>.find_name_one.<locals>.find_name_two at 0x000001B114285708>
18 value_two = value_one()    # 运行find_name_two（）函数，打印‘刘五’，因函数中无返回值return，所以得到默认返回值None
19 print(value_two)
20 # =>刘五
21 # =>None
22 # 方法二
23 find_name()()()
24 # =>刘五
25 print(find_name()()())
26 # =>刘五
27 # =>None

5.局部变量与全局变量

　　1）局部变量和全局变量

局部变量和全局变量：在子程序中定义的变量称为局部变量，在程序一开始定义的变量称为全局变量。
当全局变量与局部变量同名时，在定义了局部变量的子程序内，局部变量起作用；其它地方全局变量起作用。

1 name = '李四'   # 全局变量，全部能够使用
2 def what_name():
3     name1 = '王五'    # 局部变量，只能在函数体内使用，只能局部调用
4     print('%s , %s' %(name,name1))
5 what_name()
6 # =>李四 , 王五
7 print(name)
8 # =>李四

　　2）global 关键字

　　<1> 函数内无 global 关键字

　　① 有声明局部变量：

优先读取局部变量；
能读取全局变量，无法对全局变量重新赋值，但是对于可变类型（集合、列表、字典），可对其内部元素进行操作

 1 name = '李四'  # 不可变类型，全局变量
 2 def what_name():   # 无global关键字，有局部变量声明
 3     name = '张三'   # 声明局部变量
 4     print(name)
 5 print(name)  # 此处打印全局变量，局部变量没有对全局变量进行修改，还为调用函数
 6 # =>李四
 7 what_name()  # 此处进入函数what_name（）内，由于函数体内对变量name进行了声明修改，所以打印出来为局部声明的变量
 8 # =>张三
 9 print(name)  # 此处没有global关键字，函数体内对name进行了修改但是无法影响到全局变量name
10 # =>李四
11 
12 li = [1,2,3,4,5]  # 可变类型，全局变量
13 def lis():
14     li.append(111)   # 读取全局变量，对于可变类型列表内的元素进行操作
15     print(li)
16 print(li)  # 没有运行函数体dis,全局变量没有变化
17 # =>[1, 2, 3, 4, 5]
18 lis()  # 运行了函数，对列表li进行了元素添加修改
19 # =>[1, 2, 3, 4, 5, 111]
20 print(li)   # 无global关键字，但函数体内可以对可变类型进行修改
21 # =>[1, 2, 3, 4, 5, 111]

　　② 无声明局部变量

　　无声明局部变量：如果有对变量的操作，直接读取全局变量，不能对其赋值，只能读取

1 name = '李四'  # 不可变类型，全局变量
2 def what_name():   # 无global关键字，无局部变量声明，直接读取全局变量
3     print(name)
4 print(name)  # 此处打印全局变量，无局部变量声明，所以不对其进行修改
5 # =>李四
6 what_name()  # 此处进入函数what_name（）内，无局部变量声明，直接读取全局变量name
7 # =>李四

　　<2> 函数内有 global 关键字

　　注意：global 变量，读取全局变量，局部变量与全局变量相同时，对其进行修改；若不相同时，函数体外部可以调用函数体内的局部变量。global 变量要放在声明变量的前面也就是上面，让global 先执行，在声明变量。

　　① 有声明局部变量

 1 name = '李四'  # 不可变类型，全局变量
 2 def what_name():   # 有global关键字，有局部变量声明
 3     global name    # 修改全局变量name,由'李四'变为‘张三’，不仅函数体可以使用，函数体外也可以使用。（注意前提：程序是从上而下执行，如果没有执行函数体内的代码块，则变量只为全局变量）
 4     name = '张三'   # 声明局部变量
 5     print(name)
 6 print(name)  # 此处因为还没有执行函数what_name（）代码块，所以直接打印全局变量
 7 # =>李四
 8 what_name()  # 此处进入函数what_name（）代码块内，局部变量name进行了声明变为‘张三’，将其变为全局变量，所以之后操作无论函数体内还是函数外变量name已发生了变化，变为‘张三’
 9 # =>张三
10 print(name)  # 此处由于前面执行了what_name（）函数，局部变量name发生变化，变为全局变量，所以name改变，变为“张三”
11 # =>张三

　　② 无声明局部变量

1 name = '李四'  # 不可变类型，全局变量
2 def what_name():   # 有global关键字，无局部变量声明，直接读取全局变量
3     global name1    # 将name1变量变为全局变量，之后name1变量函数体内外皆可使用（前提：name1要想在函数体外使用，必须先执行函数体）
4     print(name)
5 print(name)  # 此处没有运行函数，直接打印全局变量
6 # =>李四
7 what_name()  # 此处进入函数what_name（）代码块内，变量name没有发生变化，所以执行结果还是为全局变量的值
8 # =>李四
9 # print(name1)  # 报错！！！（name1在函数体what_name内，虽然global是全局变量，但没有对其进行赋值操作，所以无法打印，报错！）

6.嵌套函数

　　嵌套函数：在一个函数中定义了另外一个函数　　

　　1）第1种

 1 NAME = '张三'  # 1
 2 def one():  # 2
 3     name = '一层函数' # 3
 4     print(name)  # 4
 5     def two():  # 5
 6         name = '二层函数'  # 6
 7         print(name)  # 7
 8         def three():  # 8
 9             name = '三层函数'  # 9
10             print(name)  # 10
11         three()  # 11
12         print(name)  # 12
13     two()  # 13
14     print(name)  # 14
15 one() # 15
16 # =>一层函数
17 # =>二层函数
18 # =>三层函数
19 # =>二层函数
20 # =>一层函数
21 
22 # 代码总体执行顺序：1->2（将整个代码块加载如内存）->15->3->4->5（加载入内存）->13->6->7->8（加载入内存）->11->9->10->12->14
23 # 打印结果执行顺序：4->7->10->12->14

　　2）第2种

 1 name = '张三'
 2 def one():
 3     name = '李四'
 4     def one_one():
 5         global name   # global 声明全局变量
 6         name = '王二麻子'
 7     one_one()
 8     print(name)
 9 print(name)
10 # =>张三
11 one()
12 # =>李四
13 print(name)
14 # =>王二麻子
15 
16 name = '张三'
17 def one():
18     name = '李四'
19     def one_one():
20         nonlocal name   # nonlocal 声明上一级变量
21         name = '王二麻子'
22     one_one()
23     print(name)
24 print(name)
25 # =>张三
26 one()
27 # =>王二麻子
28 print(name)
29 # =>张三

　　3）第3种

1 def father(name):
2     print('I am father %s'%(name))
3     def son():
4         print('I am son')
5     print(locals())   # 打印当前层的局部变量
6 father('alex')
7 # =>I am father alex
8 # =>{'name': 'alex', 'son': <function father.<locals>.son at 0x0000022AD8C85288>}

7.前向引用

　　1）风湿理论

　　风湿理论：函数即变量

　　在函数使用之前必须要有定义，定义后才能使用

1 def one():
2     print(1)
3     two()
4 def two():
5     print(2)
6 one()
7 # =>1
8 # =>2

8.递归函数

　　1）递归函数

　　递归函数：在函数内部，可以调用其他函数，如果一个函数在内部调用自己本身，这个函数就是递归函数。

　　2）递归函数特性

必须有一个明确的结束条件
每次进入更深一层递归时，问题规模相比上次都应有所减少
递归效率不高，递归层次过多会导致栈溢出

　　3）案例

　　<1> 案例1

 1 import time
 2 person_list = ['张三','李四','王二麻子','刘五']
 3 def ask_way(person_list):
 4     print('-'*100)
 5     if len(person_list) == 0:
 6         return '无人知道路！'
 7     person = person_list.pop(0)
 8     if person == '王二麻子':
 9         return '王二麻子说：我知道路，沙坡头在中国宁夏中卫！'
10     print('你好！帅哥%s，请问一下沙坡头在哪里？'%person)
11     print('%s回答道：我不知道，你等着，我帮你问问%s'%(person,person_list))
12     time.sleep(1)
13     res = ask_way(person_list)
14     print('%s问的结果是：%s'%(person,res))
15     return res
16 res = ask_way(person_list)
17 print(res)
18 # =>----------------------------------------------------------------------------------------------------
19 # =>你好！帅哥张三，请问一下沙坡头在哪里？
20 # =>张三回答道：我不知道，你等着，我帮你问问['李四', '王二麻子', '刘五']
21 # =>----------------------------------------------------------------------------------------------------
22 # =>你好！帅哥李四，请问一下沙坡头在哪里？
23 # =>李四回答道：我不知道，你等着，我帮你问问['王二麻子', '刘五']
24 # =>----------------------------------------------------------------------------------------------------
25 # =>李四问的结果是：王二麻子说：我知道路，沙坡头在中国宁夏中卫！
26 # =>张三问的结果是：王二麻子说：我知道路，沙坡头在中国宁夏中卫！
27 # =>王二麻子说：我知道路，沙坡头在中国宁夏中卫！

　　<2> 案例2

 1 def calc(n):
 2     print(n)
 3     if int(n/2) == 0:
 4         return n
 5     res = calc(int(n/2))
 6     return res
 7 calc(10)   # 不带返回值
 8 # =>10
 9 # =>5
10 # =>2
11 # =>1
12 print(calc(10))   # 带返回值
13 # =>10
14 # =>5
15 # =>2
16 # =>1
17 # =>1

9.匿名函数

　　Python 采用 lambda 关键字创建匿名函数

lambda 只是一个表达式，函数体比 def 简单很多
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率

　　1）语法

1 lambda x:x+1   # 匿名函数（格式）：lambda 形参：返回值

　　2）举例

 1 # 常规函数
 2 def calc(x):
 3     return x+1
 4 res = calc(10)
 5 print(res)
 6 # =>11 
 7 
 8 # 匿名函数
 9 lambda x:x+1   # 匿名函数（格式）：lambda 形参：返回值
10 print(lambda x:x+1)   # 打印内存地址
11 # =><function <lambda> at 0x000001A4111E5318>
12 func = lambda x:x+1
13 print(func(10))
14 # =>11

10.编程的方法论

　　1) 面向过程编程

　　面向过程编程：找到解决问题的入口，按照一个固定的流程去模拟解决问题的流程。

　　如：

　　<1> 搜索目标，用户输入（配偶要求，按照要求到数据结构（字典）内检索合适的人群）；

　　<2> 表白：表白成功进入<3>,否则进入<2>;

　　<3> 恋爱：恋爱成功进入<4>,否则返回<1>;

　　<4> 见家长：家长同意进入<5>,家长说你是她失散多年的妹妹，返回<1>

　　<5> 结婚。

　　2）函数式编程

　　函数式编程：函数式=编程语言定义的函数+数学意义的函数

　　通俗讲，函数式就是用编程语言来实现数学函数，这种函数内对象是永恒不变的，要么参数是函数，要么返回值是函数；没有 for 和 while 循环，所有的循环都由递归实现，无变量的赋值（即不用变量去保存状态），无赋值即不改变。

　　函数式编程的特征：

　　<1> 不可变数据

不可变：不用变量保存状态，不修改变量

　　例1：数学函数表达式：y = 2*x + 1,用函数实现

1 # 函数式编程：省去复杂的中间过程，但可读性较差
2 def calc(x):
3     return 2*x+1
4 
5 # 面向过程编程：细化过程，每一个过程都较为详细，可读性比较高，但教繁琐
6 def calc(x):
7     res = 2*x
8     res += 1
9     return res

　　<2> 第一类对象

　　第一类对象：函数即“变量”

　　高阶函数两个特征（满足其一变为高阶函数）：

函数接收的参数是一个函数名
返回值中包含函数名

 1 # 第1种：把函数当做参数传给另外一个函数
 2 def foo(n):
 3     print(n)
 4 def bar(name):
 5     print('my name is %s'%name)
 6 foo(bar('alex'))
 7 # =>my name is alex
 8 # =>None
 9 
10 
11 # 第2种：返回值中包含函数
12 def bar():
13     print('from bar')
14 def foo():
15     print('from foo')
16     return bar
17 n = foo()  # 运行foo()函数
18 # =>from foo
19 n()   # 运行foo()
20 # =>from bar
21 
22 def handle():
23     print('from handle')
24     return handle
25 h = handle()
26 # =>from handle
27 h()
28 # =>from handle

　　<3> 尾调用优化（尾递归）

　　尾调用：在函数的最后一步调用另外一个函数（最后一行不一定是函数的最后一步）

 1 # 第1种：函数bar在foo内为尾递归
 2 def bar(n):
 3     return n
 4 def foo(x):
 5     return bar(x)
 6 
 7 # 第2种：函数bar1和bar2在foo内均为尾调用，二者在if判断条件不同情况下都有可能作为函数的最后一步
 8 def bar1(n):
 9     return n
10 def bar2(n):
11     return n+1
12 def foo(x):
13     if type(x) is str:
14         return bar1(x)
15     elif type(x) is int:
16         return bar2(x)
17     
18 # 第3种：函数bar在foo内为非尾调用
19 def bar(n):
20     return n
21 def foo(x):
22     y = bar(x)
23     return y
24 
25 # 第4种：函数bar在foo内为非尾调用
26 def bar(n):
27     return n
28 def foo(x):
29     return bar(x)+1

Python内置函数

　　1.abs():返回数字的绝对值。

　　举例：

1 print(abs(-100))
2 # =>-100
3 
4 print(abs(250))
5 # =>250
6 
7 print(abs(78.4))
8 # =>78.4

View Code

　　2.all():用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、None、False 外都算 True。

　　all()函数等价于：

1 def all(iterable):
2     for element in iterable:
3         if not element:
4             return False
5     return True

View Code

　　举例：

 1 a = all((1,0,2))
 2 print(a)
 3 # =>False
 4 b = all(['',121,'sf'])
 5 print(b)
 6 # =>False
 7 c = all({'我':'I','':''})
 8 print(c)
 9 # =>False
10 d = all([12,23,45])
11 print(d)
12 # =>True
13 e = all([[],34,'ok',True])
14 print(e)
15 # =>False
16 f = all([{},78,'df'])
17 print(f)
18 # =>False

View Code

　　3.any():用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。元素除了是 0、空、FALSE 外都算 TRUE。

　　any() 函数等价于：

1 def any(iterable):
2     for element in iterable:
3         if element:
4             return True
5     return False

View Code

　　举例：

 1 a = any((1,0,2))
 2 print(a)
 3 # =>True
 4 b = any(['',121,'sf'])
 5 print(b)
 6 # =>True
 7 c = any({'我':'I','':''})
 8 print(c)
 9 # =>True
10 d = any([12,23,45])
11 print(d)
12 # =>True
13 e = any([[],34,'ok',True])
14 print(e)
15 # =>True
16 f = any([{},78,'df'])
17 print(f)
18 # =>True
19 g = any([[],'',0,False])
20 print(g)
21 # =>False

View Code

　　4.bin():返回一个整数 int 或者长整数 long int 的二进制表示.0b表示二进制。

　　举例：

1 a = bin(120)
2 print(a)
3 # =>0b1111000

View Code

　　5.bool():用于将给定参数转换为布尔类型，如果没有参数，返回 False。

　　举例：

1 a = bool(0)
2 print(a)
3 # =>False
4 b = bool([])
5 print(b)
6 # =>False
7 c = bool('I love you')
8 print(c)
9 # =>True

View Code

　　6.bytes():将字符串转换为字节数。

　　举例：

1 a = 'I love you!!!'
2 print(bytes(a,encoding='utf-8'))
3 # =>b'I love you!!!'
4 print(bytes(a,encoding='utf-8').decode('utf-8'))
5 # =>I love you!!!

View Code

　　7.chr():用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符,按照ASCII表进行转换。

　　举例：

1 a = chr(50)
2 print(a)
3 # =>2
4 b = chr(78)
5 print(b)
6 # =>N

View Code

　　8.dir():获取某一对象下的方法属性。

　　举例：

1 a = dir(tuple)
2 print(a)

View Code

　　9.dict():用于创建一个字典。

　　举例：

1 a = dict()
2 print(a,type(a))
3 # =>{} <class 'dict'>
4 b = dict(a=12,b=23)
5 print(b,type(b))
6 # =>{'a': 12, 'b': 23} <class 'dict'>

View Code

　　10.divmod():把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b).可用于分页使用。

　　举例：

1 a = divmod(10,3)  # 可用于分页，如制作网页时，总共有10条信息，1页只显示3条，可使用divmod（）函数进行分页
2 print(a)
3 # =>(3, 1)
4 b = divmod(15,3)
5 print(b)
6 # =>(5, 0)

View Code

　　11.enumerate():用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

　　语法：

1 enumerate(sequence,[start = 0])

　　参数：

　　sequence:一个序列、迭代器或其他支持迭代对象

　　start:下标起始位置

　　举例：

1 a = ['张三','李四','王二麻子']
2 print(list(enumerate(a,1)))
3 # =>[(1, '张三'), (2, '李四'), (3, '王二麻子')]
4 b = {'name':'alex','age':18,'tel':'1234546'}
5 for i,o in enumerate(b.values(),1):
6     print(i,o)
7 # =>1 alex
8 # =>2 18
9 # =>3 1234546

View Code

　　12.eval():①提取字符串中的数据结构；②可以将字符串中的数学运算进行计算。

　　举例：

1 a = eval('2*7')
2 print(a)
3 # =>14
4 b = eval('[11,22,33]')
5 print(b[1],type(b))
6 # =>22 <class 'list'>

View Code

　　13.filter()：①用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。返回迭代器对象；②该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

　　举例：

1 a = filter(lambda x:x%2==1,[1,2,3,4,5,6,7,8,9])  # 过滤出列表中的奇数
2 print(list(a))
3 # =>[1, 3, 5, 7, 9]
4 def func(x):
5     return x == True
6 b = [[],{},False,0,True,'',111]
7 c = list(filter(func,b))
8 print(c)
9 # =>[True]

View Code

　　14.float():用于整数和字符串转换为浮点数。

　　举例：

1 a = float(13)
2 print(a)
3 # =>13.0
4 b = float('78.4')
5 print(b)
6 # =>78.4

View Code

　　15.format():用于字符串格式化。

　　举例：

1 a = 'my name is {} ,age {}'.format('alex',18)
2 print(a)
3 # =>my name is alex ,age 18
4 b = 'my name is {name} ,age {age}'.format(name='alex',age=18)
5 print(b)
6 # =>my name is alex ,age 18

View Code

　　16.frozenset():创建一个冻结的集合，冻结后集合不能再添加或删除任何元素。

　　举例:

1 a = frozenset(range(1,10))
2 print(a)
3 # =>frozenset({1, 2, 3, 4, 5, 6, 7, 8, 9})

View Code

　　17.hash():进行哈希运算。①可哈希的（不可变类型）；②不可哈希的（可变类型）,返回对象的哈希值。

　　举例：

1 a = 'I love you'
2 print(hash(a))
3 # =>9013143733982312212
4 b = (1,2,3)
5 print(hash(b))
6 # =>2528502973977326415
7 c = 1
8 print(hash(c))
9 # =>1

View Code

　　18.help():用于查看函数或模块用途的详细说明。

　　举例：

1 print(help(list))   # 查看list的详细说明

View Code

　　19.hex():十进制转换为十六进制（0x：十六进制）。

　　举例：

1 # ---实例
2 a = hex(5)
3 print(a)
4 # =>0x5
5 b = hex(45)
6 print(b)
7 # =>0x2d

View Code

　　20.oct():十进制转换为八进制（0o：八进制）。

　　举例：

1 a = oct(12)
2 print(a)
3 # =>0o14
4 b = oct(111)
5 print(b)
6 # =>0o157

View Code

　　21.id():获取对象的内存地址。

　　举例：

1 a = id('i love you')
2 print(a)
3 # =>2232217431280

View Code

　　22.globals():打印当前位置的全局变量。

　　23.locals():打印当前位置的局部变量。

　　24.input():输入。

　　举例：

1 a = input('你的名字：')
2 print(a)
3 # =>你的名字：alex
4 # =>alex

View Code

　　25.int():将一个字符串或数字转换为整型。

　　举例：

1 a = '123'
2 print(int(a),type(a))
3 # =>123 <class 'str'>
4 b = 78.3
5 print(int(b),type(b))
6 # =>78 <class 'float'>

View Code

　　26.len():返回对象（字符、列表、元组等）长度或项目个数。

　　举例：

1 print(len('i love you'))
2 # =>10
3 print(len([1,2,3,4,5,6]))
4 # =>6

View Code

　　27.list():用于创建列表。

　　举例：

1 a = 'I love you'
2 print(list(a))
3 # =>['I', ' ', 'l', 'o', 'v', 'e', ' ', 'y', 'o', 'u
4 b = (1,2,3,4)
5 print(list(b))
6 # =>[1, 2, 3, 4]

View Code

　　28.map():①根据提供的函数对指定序列做映射，返回迭代器对象；②第一个参数function以参数序列中的每一个元素调用function函数，返回包含每次function函数返回值的新列表。

　　举例：

1 a = map(lambda x:x*100,[1,2,3,4,5,6,7,8,9])
2 print(list(a))
3 # =>[100, 200, 300, 400, 500, 600, 700, 800, 900]
4 def func(x):
5     return x**2
6 b = [12,13,14]
7 c = list(map(func,b))
8 print(c)
9 # =>[144, 169, 196]

View Code

　　29.max():返回给定参数的最大值，参数可以为序列。

　　举例：

1 print(max(12,32,45,23,50))
2 # =>50
3 print(max(['bs','fb','ok']))
4 # =>ok

View Code

　　30.min():返回给定参数的最小值，参数可以为序列。

　　举例：

1 print(min(12,32,45,23,50))
2 # =>12
3 print(min(['bs','fb','ok']))
4 # =>bs

View Code

　　31.next():①返回迭代器的下一个项目；②next() 函数要和生成迭代器的iter() 函数一起使用。

　　举例：

 1 a = 'Interesting'
 2 b = iter(a)
 3 print(next(b))
 4 # =>I
 5 print(next(b))
 6 # =>n
 7 print(next(b))
 8 # =>t
 9 
10 mes = iter([1,2,3,4,5])
11 while True:
12     try:
13         x = next(mes)
14         print(x)
15     except StopIteration:
16         break
17 # =>1
18 # =>2
19 # =>3
20 # =>4
21 # =>5

View Code

　　32.ord():将一个字符转化为ASCII中相对应的数字。

　　举例：

1 print(ord('!'))
2 # =>33
3 print(ord('a'))
4 # =>97

View Code

　　33.pow(x,y,z): 两个参数幂运算,三个参数先取幂运算再除第三个参数所得出的余数。

　　举例：

1 print(pow(10,3))
2 # =>1000
3 print(pow(15,2,2))
4 # =>1

View Code

　　34.print():打印输出。

　　举例：

1 print('Hello world!')
2 # =>Hello world!

View Code

　　35.range():range(start,stop,step)可创建一个整数列表，一般用在for循环中。

　　举例：

 1 a = range(1,10)
 2 print(a)
 3 # =>range(1, 10)
 4 b = range(2,25,3)
 5 print(b)
 6 # =>range(2, 25, 3)
 7 c = 'love'
 8 for i in range(1,3):
 9     print(i)
10 # =>1
11 # =>2

View Code

　　36.reduce():①使用前需要导入模块“from functools import reduce”；②对参数序列中元素进行累积，返回运算结果数值；③函数将一个数据集合（链表、元组等）中的所有数据进行下列操作：用传给reduce中的函数function(有两个参数)先对集合中的第1、2个元素进行操作，得到的结果再与第三个数据用function函数运算，最后得到一个结果。

　　举例：

1 from functools import reduce
2 print(reduce(lambda x,y:x+y,[12,13,14,15,16]))
3 # =>70

View Code

　　37.reverse():用于反转列表中的元素。

　　举例：

1 a = [234,45,123,34]
2 a.reverse()
3 print(a)
4 # =>[34, 123, 45, 234]

View Code

　　38.reversed():返回一个反转的迭代器。

　　举例：

1 a = 'love you'
2 print(list(reversed(a)))
3 # =>['u', 'o', 'y', ' ', 'e', 'v', 'o', 'l']
4 b = [234,76,34,89]
5 print(list(reversed(b)))
6 # =>[89, 34, 76, 234]

View Code

　　39.round():返回浮点数x的四舍五入值。

　　举例：

1 print(round(23.456))
2 # =>23
3 print(round(78.98))
4 # =>79

View Code

　　40.set():创建一个无序不重复元素集合，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

　　举例：

1 print(set('i love you'))
2 # =>{'v', 'l', 'o', 'e', ' ', 'i', 'y', 'u'}
3 print(set([12,23,43,56,12,87,23]))
4 # =>{43, 12, 23, 87, 56}

View Code

　　41.slice():设置切片。

　　举例：

 1 # 方法一：
 2 mes = 'interesting'
 3 print(mes[3:7])
 4 # =>eres
 5 
 6 # 方法二：
 7 mes = 'interesting'
 8 a = slice(3,7)   # 设置切片
 9 print(mes[a])
10 # =>eres
11 b = slice(1,10,2)   # 可设置步长
12 print(mes[b])
13 # =>neetn

View Code

　　42.sorted():排序（从小到大）,排序本质比较大小，不同类型数据不能排序。

　　举例：

1 a = [12,43,54,11]
2 print(sorted(a))
3 # =>[11, 12, 43, 54]

View Code

　　43.str():将对象转换为字符串。

　　举例：

1 a = 12345
2 b = str(a)
3 print(b,type(b))
4 # =>12345 <class 'str'>

View Code

　　44.sum():对系列进行求和计算。

　　举例：

1 a = [12,43,54,11]
2 print(sum(a))
3 # =>120

View Code

　　45.tuple():创建一个元组。

　　举例：

1 a = 'interesting'
2 print(tuple(a))
3 # =>('i', 'n', 't', 'e', 'r', 'e', 's', 't', 'i', 'n', 'g')
4 b = [12,43,54,11]
5 print(tuple(b))
6 # =>(12, 43, 54, 11)

View Code

　　46.type():返回数据的类型。

　　举例：

1 print(type(111))
2 # =><class 'int'>
3 print(type('ok'))
4 # =><class 'str'>
5 print(type([11,22,33]))
6 # =><class 'list'>
7 print(type({'ok':'好'}))
8 # =><class 'dict'>

View Code

　　47.zip():①拉链函数（左右一一对应）；②用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

　　举例：

1 print(list(zip(('a','b','c'),(1,2,3))))
2 # =>[('a', 1), ('b', 2), ('c', 3)]
3 dic = {'name':'alex','age':24,'money':10000}
4 print(list(zip(dic.keys(),dic.values())))
5 # =>[('name', 'alex'), ('age', 24), ('money', 10000)]

View Code

posted @ 2020-05-04 12:50 星落…… 阅读(232) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

蔚蓝轻语

Python基础——函数（200512）

Python——函数

函数

1.函数概述：

函数：用于完成特定功能的一段代码块，可用于重复使用。函数能够提高应用的模块性，和代码的利用率；函数包含内置函数和用户自定义的函数两种。

2.为什么使用函数：

定义函数

1.定义一个函数

1）可以定义一个特定功能的函数，规则如下：

2）语法：

3）举例：定义一个打印 hello + name 的函数

2.函数返回值

1）函数和过程

2）返回值

<2> 1个返回值

<3> 多个返回值

3.函数参数

1）形参和实参

2）位置参数

3）关键字参数

4）位置和关键字参数混合使用

5）默认参数

6）参数组

7）参数集合实例

4.函数作用域

1）函数作用域

<1> 一般函数作用域

<2> 嵌套函数作用域

5.局部变量与全局变量

1）局部变量和全局变量

2）global 关键字

<1> 函数内无 global 关键字

① 有声明局部变量：

② 无声明局部变量

<2> 函数内有 global 关键字

① 有声明局部变量

6.嵌套函数

1）第1种

2）第2种

3）第3种

7.前向引用

1）风湿理论

8.递归函数

1）递归函数

2）递归函数特性

3）案例

<1> 案例1

<2> 案例2

9.匿名函数

1）语法

2）举例

10.编程的方法论

1) 面向过程编程

2）函数式编程

<1> 不可变数据

<2> 第一类对象

<3> 尾调用优化（尾递归）

Python内置函数

公告

　　函数：用于完成特定功能的一段代码块，可用于重复使用。函数能够提高应用的模块性，和代码的利用率；函数包含内置函数和用户自定义的函数两种。

　　1）可以定义一个特定功能的函数，规则如下：

　　2）语法：

　　3）举例：定义一个打印 hello + name 的函数

　　1）函数和过程

　　2）返回值

　　<2> 1个返回值

　　<3> 多个返回值

　　1）形参和实参

　　2）位置参数

　　3）关键字参数

　　4）位置和关键字参数混合使用

　　5）默认参数

　　6）参数组

　　7）参数集合实例

　　1）函数作用域

　　<1> 一般函数作用域

　　<2> 嵌套函数作用域

　　1）局部变量和全局变量

　　2）global 关键字

　　<1> 函数内无 global 关键字

　　① 有声明局部变量：

　　② 无声明局部变量

　　<2> 函数内有 global 关键字

　　① 有声明局部变量

　　1）第1种

　　2）第2种

　　3）第3种

　　1）风湿理论

　　1）递归函数

　　2）递归函数特性

　　3）案例

　　<1> 案例1

　　<2> 案例2

　　1）语法

　　2）举例

　　1) 面向过程编程

　　2）函数式编程

　　<1> 不可变数据

　　<2> 第一类对象

　　<3> 尾调用优化（尾递归）