函数基础

函数的定义

函数就是一大堆代码，给这一大堆代码起个名字，方便调用。比如：

1
2
3
4
5
6

def 函数名():
    ……
    ……
    ……

函数名()		#调用，函数的定义必须写在调用之前，一个函数可以调用另一个函数。

比如，可以定义为一个发邮件的函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 发邮件
# 1.导入python内置模块
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr

# 定义函数
def to_email():
    # 2.构邮件内容
	message = MIMEText("你好，别玩了去学习！","html","utf-8")
	message["From"] = formataddr(["邓胖胖","dengjinjun0805@126.com"])
	message['to'] = "498790885@qq.com"
	message['Subject'] = "准研究生"

	# 3.发送邮件
	server = smtplib.SMTP_SSL("smtp.126.com")
	server.login("dengjinjun0805@126.com", "QGQPCNRRUKHFPIJA")
	server.sendmail("dengjinjun0805@126.com", "498790885@qq.com", message.as_string())
	server.quit()

# 调用函数
to_email()

函数的参数

函数的参数在传递时，本质上传递的是内存地址（引用），不会重新拷贝一份再传递。

而函数内部在操作数据时，是重新生成数据还是修改原数据，取决于参数的数据类型是否是可变的。

1
2

# 可变类型：列表、字典、集合
# 不可变类型：整型、字符串、布尔类型、元组

当函数同时执行时，会为每个执行的函数创建一块内存（调用栈），因此数据不会混乱

静态参数

1
2
3
4
5
6
7

# 定义函数时，括号里可以包括一些参数，称为形式参数
def 函数名(形参1,形参2,形参3):
    ……
    ……
调用函数时，需要在括号里一些参数作为对应，称为实际参数
函数名(实参1,实参2,实参3)
# 函数要求几个参数，就需要传入几个参数，参数可以是任意类型

函数参数的传递方法有三种，按位置传参，按关键字传参和混合传参

1
2
3
4
5

# 按位置传参
def func(a1,a2,a3):
    ……
    ……
func(1,2,3)	# a1 = 1,a2 = 2,a3 = 3 需要注意实参的次序与形参相对应

1
2
3
4
5

# 按关键字传参
def func(a1,a2,a3):
    ……
    ……
func(a1 = 1,a2 = 2,a3 = 3)	# 不需要注意顺序

1
2
3
4
5

# 混合传参
def func(a1,a2,a3):
    ……
    ……
func(1,2,a3 = 3)	# 需要注意位置传参在前，关键字传参在后

另外，函数在定义时，也可以指定默认参数，若没有实参传入时，就使用默认参数。比如：

1
2
3

def func(a1,a2=2,a3=3):	# 需要注意含有默认参数的关键字必须放在后面
    ……
    ……

动态参数

定义函数时，可以不限制参数的个数

• 在形参前面加*，比如：

1
2
3
4
5
6

def func(*args):	#用户传来的参数都会被打包成元组的类型,按照位置传参
    ……
    ……
func(1)		# a1 = (1,)
func(1,2,3)	# a1 = (1,2,3)
func([22,33],"常州大学",1，2)	# a1 = ([22,33],"常州大学",1，2)

• 在形参前面加**，比如：

1
2
3
4

def func(**kwargs):	# 用户传来的参数会被打包成字典的类型，必须以关键字的形式传参
    ……
    ……
func(a1 = 1,a2 = 2,a3 = 3)	# dt = {'a1': 1, 'a2': 2, 'a3': 3}

• 静态参数和动态参数* 和 **混合使用,比如：

1
2
3
4
5

def func(a1,a2,a3,*args,**kwargs):	#静态参数必须放到动态参数前面，*必须放到**前面
    ……
    ……
func(1,2,3,4,5,6,v1 = 1,v2 = 2,v3 = 3)
# 位置参数在前，关键字参数在后，静态参数按顺序分配之后分配*动态参数，然后分配**动态参数

潜规则：含有动态参数的函数在定义时，形参的变量名一般使用*args和**kwargs

函数的返回值

定义一个函数，希望它产生一个结果，可以用到返回值。调用函数时，可以用一个变量来接收这个返回值。

返回值可以是任意类型。如果返回一组分散的变量，则会打包成元组。如果没有返回值，默认返回None。

在函数运行过程中 ，遇到return()会立即结束运行并返回值。

函数的变量

python中的变量分为全局变量和局部变量。（在定义全局变量时用大写，定义局部变量时用小写，多个单词用下划线连接。）

全局变量：在python文件顶层中定义的变量，python具有一个全局作用域，只要python代码运行，就在此全局作用域中运行。

局部变量：在函数中定义的变量，python中以函数为作用域，执行一个函数，就会为函数创建一个作用域。

寻找变量的值时，优先从自己的作用域中寻找，没有的话就从父级作用域中找。

如果要在函数中修改和使用全局变量，可以使用global关键字，表明此变量不是新创建的变量，而是指向全局变量。比如：

1
2
3
4
5

NAME = "张三"
def func():
    NAME = "李四"
    print(NAME)
print(NAME)	# "张三"

1
2
3
4
5
6

NAME = "张三"
def func():
    global NAME
    NAME = "李四"
    print(NAME)
print(NAME)	# "李四"

对于函数名的理解

函数名代指这个函数，函数名后加()，会执行函数。

函数名也可以理解为一个变量名，比如：

1
2
3
4
5

def func():
    pass
v1 = func
func()
v1()	# func()

函数名和函数都可以放到列表中，比如：

1
2
3
4
5

def func():
    return 123
data_list = [1, 2, 3, "常州大学", func, func()]
print(data_list)	# [1, 2, 3, '常州大学', <function func at 0x0000028952ADF040>, 123]
data_list[-2]()		# func(),执行这个函数

函数名还可以放到列表中，当作字典中的值，比如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

def func():
    pass

func_dict = {"11":func,"22":func,"33":func}
# 获取函数并执行，方法1
func_dict["11"]()	# func()
# 这种方式如果键名不存在，会报错

# 获取函数并执行，方法2
func_object = func_dict.get("11")
if func_object == None:
    print("函数不存在")
else:
    func_object()
# 这种方式当键名不存在时，会返回空值，不会报错

一个函数的函数名可以作为参数传入另一个函数中，比如：

1
2
3
4
5

def do():
    return 11
def func(a1,a2):
    print(a1+a2())
func(22,do)		# 33

lambda表达式（匿名函数）

使用lambda表达式，可以用一行代码实现简单的函数，比如：

1
2
3
4

def func():
    return 123
# 这种定义方式可以用lambda表达式实现
func = lambda :123

1
2
3
4

def func(a1,a2):
    return a1+a2
# 这种定义方式可以用lambda表达式实现
func = lambda a1,a2 :a1+a2

1
2
3
4

def func(data_list):
    return data_list[0]
# 这种定义方式可以用lambda表达式实现
func = lambda data_list : data_list[0]

内置函数

内置函数是python内部已经编写好的函数，可以直接拿来用。

数值计算相关的函数

• abs()，绝对值

  1	data = abs(-10) # data = 10

• pow()，次方

  1	data = pow(2, 5) # data = 32,pow(a,b)就是求a的b次方

• sum()，求和

  1 2	num_list = [1,2,3,4] res = sum(num_list) # data = 10,将列表中所有元素的值相加

• divmod()，商和余数

  1 2	v1,v2 = divmod(92,10) # v1 = 9, v2 = 2 v1接收商，v2接收余数

• round()，保留小数点后几位

  1 2	data = round(3.1415926, 2) # data = 3.14 保留小数点后两位，支持四舍五入

• max()和min()，求最大值和最小值

  1 2 3

  num_list = [2,34,-1,26] v1 = max(num_list) # v1 = 34 v2 = min(num_list) # v2 = -1

• all()和any()，判断列表中的元素所转化的布尔值

  1 2 3 4 5 6

  data_list1 = [1,4,"",0,"cczu"] data_list2 = [1,4,"cczu"] all(data_list1) # False , all判断列表中的元素转化为布尔值是否为True all(data_list2) # True , 都可以转化为True，结果是True，否则为False any(data_list1) # True , any判断列表中是否存在元素转化为布尔值为True any(data_list2) # True , 都不能转化为True，结果是False，否则为True

进制转换相关函数

二进制以0b开头、八进制以0o开头、十六进制以0x开头，都是字符串形式

十进制可以转换为二进制、八进制、十六进制。比如：

• bin()、oct()、hex()

  1 2 3 4

  num = 123 bin(num) # 0b1111011 转换为2进制 oct(num) # 0o173 转换为8进制 hex(num) # 0x7b 转换为16进制

• 其他进制也可以通过int()转换为十进制数，比如：

  1 2 3

  int("0b1111011",base=2) # 123 2进制转化为10进制 int("0o173",base=8) # 123 8进制转化为10进制 int("0x7b",base=16) # 123 16进制转化为10进制

字符与十进制数字相对应

在unicode编码中，每个字符都是由2进制来存储的，这个2进制数可以转化为10进制数，因此字符与10进制数也有对应关系。

• ord()，将字符转化为10进制数

  1 2	num = "A" ord(num) # 65

• chr()，将10进制数还原为字符

  1	chr(65) # A

  基于chr函数，可以实现随机验证码的功能

  1 2 3 4 5 6 7 8 9

  import random char_list = [] for i in range(6): num = random.randint(67, 90) char = chr(num) char_list.append(char) text = "".join(char_list) print(text) # NVKUQX

数据类型转换的函数

之前已经提及，将一种数据类型转化为另一种数据类型，包括：

1

int()	str()	list()	 tuple()	dict()	 bool()	  bytes()	 set()	 float()

其他函数

之前已经提及的，比如以下等，不详细列举

• print()，输出
• input()，输入
• len()，求长度
• open()，打开文件

未曾提及的，以下：

• range()，生成一个数字列表

  1 2 3 4

  range(4,9) # [4,5,6,7,8] 前后两个数字与索引的方法类似，从0计数，前取后不取 range(5) # [0,1,2,3,4] 相当于range(0,5) range(5,10,2) # [5,7,9] 第三个数字是每次递加的数,此处每次加2 range(10,5,-1) # [10,9,8,7,6] 此处每次减1

  range()函数可以与for循环结合使用

• hash()，计算哈希值（字典和集合的值都必须是可哈希的）

• type()，查看数据类型

  1 2 3

  print(type("邓胖胖")) # str print(type(123)) # int print(type((123,))) # tuple

• callable()，判断一个变量名是否可执行

  1 2 3 4 5

  name = "张三" def func(): print("111") callable(name) # False 不可执行结果为False callable(func) # True 可执行结果为True

• enumerate()，在循环中提供自增的一列

  1 2 3 4 5 6 7 8 9 10 11 12 13

  用法：enumerate(iterable, start=0) - `iterable`: 表示要枚举的可迭代对象，如列表、元组、字符串等。 - `start=0`: 可选参数，表示枚举的起始索引，默认为0，即从0开始编号。 # 使用enumerate()可以减少一个递增变量，使循环更加简洁 goods = ["AKM", "M4","M762"] for idx, items in enumerate(goods, 1): print("{} {}".format(idx, item)) """ 1 AKM 2 M4 3 M762 """

• sorted()，对列表、元组、集合进行排序

  1 2 3 4 5

  data_list = [13,8,3,56,-1,] data_tuple = (13,8,3,56,-1,) new_list = sorted(data_list) # [-1, 3, 8, 13, 56], 不修改原数据，生成新列表 new_list = sorted(data_tuple) # [-1, 3, 8, 13, 56], 对元组还是集合排序，最终生成的都是列表 # 当元素是字符串时，会按照首个字符的Unicode编码顺序排列

  1 2 3 4 5 6 7 8 9

  # 有时默认规则并不能得到理想的顺序，sorted()支持自定义排序，比如： data_list = ["1.张三"， "2.李四", "3.王五", "11.赵六", "12.吴七"] new_list = sorted(data_list) # ['1.张三', '11.赵六', '12.吴七', '2.李四', '3.王五'] # 此处定义一个函数将排序对象改变 def func(arg): return int(arg.split(".")[0]) new_list = sorted(data_list, key=func) # key是关键字，也可以直接将lambda表达式写在key后面 # ['1.张三', '2.李四', '3.王五', '11.赵六', '12.吴七']