python基础3_函数+组合数据类型
一、 函数
1.1 函数介绍
函数是组织好的、可重复使用的、用来实现特定功能的代码块。
使用函数，可以得到一个针对特定需求、可供重复利用的代码段，提高程序的复用性，减少重复性代码，提高开发效率。
1.2 函数的定义
-
函数的定义：
def 函数名(传入参数): 函数体 return 返回值 -
函数的调用：
函数名(参数) -
注意事项：
- 参数如不需要，可以省略
- 返回值如不需要，可以省略
- 函数必须先定义后使用
示例如下：
def printHello():
print("欢迎来到这里！")
print("请出示您的健康码以及72小时核算证明。")
printHello()
1.3 函数的参数
传入参数的功能是：在函数进行计算的时候，接受外部（调用时）提供的数据
-
函数定义时，提供的x和y，称之为：形式参数/形参，表示函数声明将要使用2个参数
- 参数之间使用逗号（,）进行分隔
-
函数调用中，提供的参数，称之为：实际参数/实参，表示函数执行时真正使用的参数值
- 传入的时候，按照顺序传入数据，使用逗号（,）分隔
-
传入参数的数量是不受限制的
- 可以不使用参数
- 也可以仅使用任意N个参数
# 定义一个函数，名称任意，并接受一个参数传入（数字类型，表示体温）
# 在函数内进行体温判断（正常范围：小于等于37.5度），并按要求输出内容
def check(num2):
print("欢迎来到这里！请出示您的健康码以及72小时内的核酸证明，并配合测量体温！")
if num2 <= 37.5:
print("体温测量中，您的体温：{}度，体温正常请进！".format(num2))
else:
print("体温测量中，您的体温：{}度，需要隔离！".format(num2))
num = int(input("请输入您的体温："))
check(num)
1.4 函数的返回值
-
函数返回值的定义
-
函数返回值：程序中函数完成事情后，最后给调用者的结果
-
语法格式：
def 函数(参数...): 函数体 return 返回值 变量 = 函数(参数...) -
注意：函数体在遇到return后就结束了，所以写在reutrn后的代码不会执行
-
-
None类型
- None是一个特殊的字面量，其类型是<class ‘NoneType’>
- 无返回值的函数，实际上就是返回了：None
- 函数返回该字面量表示：这个函数没有返回什么有意义的内容
- 应用场景：
- 用在函数无返回值上
- 用在if判断上（在if判断中，None等同于False；一般用于在函数中主动返回None，配合if判断做相关处理）
- 用在声明无内容的变量上：声明变量，但暂时不需要变量有具体值，可以用None来代替
# 定义一个函数，返回两个参数的和
def getSum(a, b):
return a+b
print(getSum(100,50))
1.5 函数说明文档
函数说明文档，即通过注释对函数进行解释说明，辅助理解函数（函数是纯代码语言，想要理解其含义，就需要一行行去阅读理解代码，效率比较低）
语法如下：
def func(x, y):
"""
函数说明
:param x: 形参x的说明
:param y: 形参y的说明
:return: 返回值的说明
"""
函数体
return 返回值
示例如下：
# 定义一个函数，返回两个参数的和
def getSum(a, b):
"""
函数getSum可以得到两个形参的和
:param a: 两个加数其中之一
:param b: 两个加数中另一个
:return: 两个加数的和
"""
return a+b
print(getSum(100,50))
1.6 函数的嵌套使用
函数的嵌套使用：一个函数里面又调用了另一个函数
执行流程：函数A中执行到调用函数B的语句，会将函数B全部执行完成后，继续执行函数A的剩余内容
示例如下：
def printA():
print("A")
def printB():
print("B")
def printAll():
printA()
printB()
printAll()
1.7 变量的作用域
变量作用域：变量的作用范围（变量在哪里可用，在哪里不可用）
- 局部变量：定义在函数体内部的变量，即只在函数体内部生效
- 局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量
- 全局变量：在函数体内、外都能生效的变量
- global关键字：使用global关键字，可以在函数内部声明变量为全局变量（global num）
1.8 综合案例
ATM案例：
# ATM案例
# 初始化
money = 50000
name = input("请输入您的姓名：")
# 主菜单效果
def index(s):
"""
打印主菜单效果
:param s: 用户姓名
:return: 返回用户选择
"""
print("{}，您好，欢迎来到银行ATM，请选择操作：".format(name))
print("查询余额 【输入1】")
print("存款 【输入2】")
print("取款 【输入3】")
print("退出 【输入4】")
return int(input("请输入您的选择："))
# 查询余额
def checkMoney():
"""
查询余额函数
:return:无返回值
"""
print("----------余额查询----------")
print("{}，您好，您的余额剩余：{}".format(name, money))
# 存款效果
def inMoney():
"""
存款
:return: 无返回值
"""
n = int(input("存入："))
global money
money += n
print("{}，您好，您存款{}元成功！".format(name, n))
print("{}，您好，您的余额剩余：{}".format(name, money))
# 取款效果
def outMoney():
"""
取款
:return: 无返回值
"""
n = int(input("取出："))
global money
if n>money:
print("余额不足！！！")
else:
money -= n
print("{}，您好，您取款{}元成功！".format(name, n))
print("{}，您好，您的余额剩余：{}".format(name, money))
while name :
choice = index(name)
if choice == 1 :
checkMoney()
elif choice == 2:
inMoney()
elif choice == 3:
outMoney()
elif choice == 4:
name = ''
else:
print("请输入有效操作！！！")
二、 数据容器
2.1 数据容器入门
当变量数目较多时，定义多个变量不高级且低效；我们会采用数据容器，一个变量完成，容纳多个数据
- python中的数据容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素；每一个元素，可以是任意类型的数据，如字符串、数字、布尔等
- 数据容器根据特点的不同（是否支持重复元素、是否可以修改、是否有序，等等）分为五类：
- 列表list
- 元组tuple
- 字符串str
- 集合set
- 字典dict
2.2 数据容器：List（列表）
-
列表的定义
-
基本语法：
# 字面量 [元素1, 元素2, 元素3, 元素4, ...] # 定义变量 变量名称 = [元素1, 元素2, 元素3, 元素4, ...] # 定义空列表 变量名称 = [] 变量名称 = list() -
注意：
- 列表内的每一个数据，称之为元素
- 列表以“[]”作为标识
- 列表内的每个元素之间用逗号“,”隔开
- 列表可以依次存储多个数据，且可以为不同的数据类型，支持嵌套
-
-
列表的下标索引
-
从前向后，从0开始，依次递增
my_list = [1, 2, 3, 4] n = my_list[2] -
从后向前，从-1开始，依次递减
my_list = [1, 2, 3, 4] n = my_list[-2] -
嵌套列表的下标索引
my_list = [[1, 2, 3], [4, 5, 6]] n = my_list[0][0] -
注意：要注意下标索引的取值范围，超出范围无法取出元素，并且会报错
-
-
列表的常用操作/方法
-
查找某元素的下标：
-
功能：查找指定元素在列表的下标，如果找不到，报错ValueError
-
语法：列表.index(元素)，其中，index就是列表对象（变量）内置的方法（函数）
-
示例：
my_list = [123, 234, 345] n = my_list.index(123)
-
-
修改特定位置（索引）的元素值：
-
语法：列表[下标] = 值
-
可以使用如上语法，直接对指定下标（正向、反向下标均可）的值进行重新赋值/修改
-
示例：
# 正向下标 my_list = [1, 2, 3] my_list[0] = 0 # 反向下标 my_list[-1] = 2
-
-
插入元素：
-
语法：列表.insert(下标, 元素)，在指定的下标位置，插入指定的元素
-
示例：
my_list = [1, 2, 3] my_list.insert(1, 3)
-
-
追加一个元素：
-
语法：列表.append(元素)，将指定元素追加到列表的尾部
-
示例：
my_list = [1, 2, 3] my_list.append(4)
-
-
追加多个元素：
-
语法：列表.extend(其他数据容器)，将其他数据容器的内容取出，依次追加到列表尾部
-
示例：
my_list = [1, 2, 3] my_list.extend([4, 5, 6])
-
-
删除元素：
-
语法1：del 列表[下标]
-
语法2：列表.pop(下标)
-
示例：
my_list = [1, 2, 3] # 方法一 del my_list[0] # 方法二 my_list.pop(0)
-
-
删除某元素在列表中的第一个匹配项
-
语法：列表.remove(元素)
-
示例：
my_list = [1, 2, 3] my_list.remove(1)
-
-
清空列表内容
-
语法：列表.clear()
-
示例：
my_list = [1, 2, 3] my_list.clear()
-
-
统计某元素在列表中的数量
-
语法：列表.count(元素)
-
示例：
my_list = [1, 2, 3] num = my_list.count(1)
-
-
统计列表内有多少元素
-
语法：len(列表)
-
示例：
my_list = [1, 2, 3] num = len(my_list)
-
-
常用方法总结：
使用方式 作用 列表.append(元素) 向列表中追加一个元素 列表.extend(容器) 将数据容器的内容依次取出，追加到列表尾部 列表.insert(下标, 元素) 在指定下标处，插入指定的元素 del 列表[下标] 删除列表指定下标元素 列表.pop(下标) 删除列表指定下标元素 列表.remove(元素) 从前向后，删除此元素第一个匹配项 列表.clear() 清空列表 列表.count(元素) 统计此元素在列表中出现的次数 列表.index(元素) 查找指定元素在列表的下标，找不到报错ValueError len(列表) 统计容器内有多少元素
-
-
列表特点：
- 可以容纳多个元素
- 可以容纳不同类型的元素
- 数据是有序存储的
- 允许重复数据存在
- 可以修改/增加/删除元素等
2.3 List（列表）的遍历
-
while循环遍历：利用列表的下标取出
my_list = [21, 25, 21, 23, 22, 20] i = 0 while i < len(my_list): print(my_list[i]) i += 1 -
for循环遍历：
my_list = [21, 25, 21, 23, 22, 20] for e in my_list: print(e) -
两者对比：
- 在循环控制上：
- while循环可以自定循环条件，并自行控制
- for循环不可以自定循环条件，只可以一个个从容器内取出数据
- 在无限循环上：
- while循环可以通过条件控制做到无限循环
- for循环理论上不可以，因为被遍历的容器容量不是无限的
- 在使用场景上：
- while循环适用于任何想要循环的场景
- for循环适用于，遍历数据容器的场景或简单的固定次数循环场景
- 在循环控制上：
-
示例：取出列表中的偶数
# 取出列表中的偶数 # 数据初始化 my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] res = [] # 列表遍历 for e in my_list: if e%2 == 0: res.append(e) # 输出结果 print(res)
2.4 数据容器：Tuple（元组）
元组同列表一样，都是可以封装多个、不同类型的元素在内，但最大的不同点在于：元组一旦定义完成，就不可以修改
-
元组的定义格式：使用小括号，且使用逗号（,）隔开各个数据，数据可以是不同的数据类型
# 定义元组字面量 (元素, 元素, ..... , 元素) # 定义元组变量 变量名称 = (元素, 元素, ..... , 元素) # 定义空元组 变量名称 = () 变量名称 = tuple()注：若元组只有一个数据，这个数据后面要添加逗号（,）
-
元组的特点：
- 可以容纳多个数据
- 可以容纳不同类型的数据
- 数据是有序存储的
- 允许重复数据存在
- 不可以修改
- 支持for循环
-
元组的常见操作：
方法 作用 index() 查找每个数据，如果数据存在返回对应的下标，否则报错 count() 统计某个元素在当前元组出现的次数 len(元组) 统计元组内的元素个数 注：不可以修改元组的内容，否则会直接报错；可以修改元组内list的内容（修改元素、增加、删除、反转等）
2.5 数据容器：str（字符串）
字符串是字符的容器，一个字符串可以存放任意数量的字符
-
字符串的下标/索引
- 和其他容器（列表、元组）一样，字符串也可以通过下标进行访问
- 从前向后，下标从0开始
- 从后向前，下标从-1开始
-
同元组一样，字符串是一个无法修改的数据容器，所以，修改指定下标的字符、移除特定下标的字符、追加字符等均无法完成。如果必须要做，只能得到一个新的字符串
-
查找特定字符串的下标索引值：
-
语法：字符串.index(字符串)
-
示例：
my_str = "a and b and c" print(my_str.index("and"))
-
-
字符串的替换：
- 语法：字符串.replace(字符串1, 字符串2)
- 功能：将字符串内的所有字符串1替换成字符串2
- 注意：不是修改字符串本身，而是得到了一个新的字符串
-
字符串的分隔：
-
语法：字符串.split(分隔符字符串)
-
功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
-
注意：字符串本身不变，而是得到了一个列表对象
-
示例：
my_str = "a and b and c" print(my_str.split(" "))
-
-
字符串的规整操作（去掉前后空格）：
-
语法：字符串.strip()
-
示例：
my_str = " a and b " print(my_str.strip())
-
-
字符串的规整操作（去掉前后字符串）：
-
语法：字符串.strip(字符串)
-
示例：
my_str = "12a and b21" print(my_str.strip("12")) # 注意：传入的“12”其实就是，“1”和“2”都会被移除
-
-
字符串常见操作汇总：
操作 说明 字符串[下标] 根据下标索引取出特定位置字符 字符串.index(字符串) 查找给定字符的第一个匹配项的下标 字符串.replace(字符串1, 字符串2) 将字符串内的所有字符串1替换成字符串2；不会修改原字符串，而是得到一个新的字符串 字符串.split(字符串) 按照给定字符串，对字符串进行分隔；不会修改原字符串，而是得到一个新的列表 字符串.strip()/字符串.strip(字符串) 移除首尾的空格和换行符或指定字符串 字符串.count(字符串) 统计字符串内某字符串的出现次数 len(字符串) 统计字符串的字符个数 -
字符串的遍历：同列表、元组一样，字符串也支持while循环和for循环进行遍历
-
字符串的特点：
- 只可以存储字符串
- 长度任意（取决于内存大小）
- 支持下标索引
- 允许重复字符串出现
- 不可以修改/增加/删除元素等
- 支持while循环和for循环进行遍历
-
示例：
# 数据初始化 my_str = "itheima itcast boxuegu" # 统计字符串内有多少个“it”字符串 print("字符串{}中有{}个“it”字符".format(my_str, my_str.count("it"))) # 将字符串内的空格全部替换为“|” my_str2 = my_str.replace(" ", "|") print("字符串{}替换后的字符串为{}".format(my_str, my_str2)) # 按照“|”进行字符串分隔得到列表 print("字符串{}分隔后的列表为{}".format(my_str2, my_str2.split("|")))
2.6 数据容器（序列）的切片
-
什么是序列：是指内容连续、有序，可使用下标索引的一类数据容器
- 列表、元组、字符串，均可以视为序列
-
序列的切片操作：序列支持切片（从一个序列中取出一个子序列）
- 语法：序列[起始下标:结束下标:步长]
- 表示从序列中，从指定位置开始，依次取出元素，到指定位置结束（不包括指定位置），得到一个序列：
- 起始下标表示从何处开始，可以留空，留空视作重新开始
- 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
- 步长表示，依次取元素的间隔（若为负数，表示反向取，起始下标和结束下标也要反向标记）
- 注意：此操作不会影响序列本身，而是会得到一个新的序列
-
示例：
# 数据初始化 my_str = "序秩护维，课听真认，体得装着，表仪洁整" # 字符串倒序 my_str2 = my_str[::-1] print(my_str2) # 以“,”分隔 my_str3 = my_str2.split("，")[2] print(my_str3) # 替换“认真”为“ ” my_str4 = my_str3.replace("认真", " ") print(my_str4) # 去除前后的空格 my_str5 = my_str4.strip() print(my_str5)
2.7 数据容器：set（集合）
集合，最主要的特点就是：不支持元素的重复（自带去重功能）、并且内容无序
-
集合的定义格式：
# 定义元素字面量 {元素, 元素, 元素,......,元素} # 定义集合变量 变量名称 = {元素, 元素, 元素,......,元素} # 定义空集合 变量名称 = set() -
集合的特点：
- 可以容纳多个元素
- 可以容纳不同类型的数据
- 数据是无序存储的（不支持下标索引）
- 不允许重复数据存在（自带去重功能）
- 可以修改/增加/删除元素等等
- 支持for循环，不支持while循环
-
集合的常见操作：
-
添加新元素：
-
语法：集合.add(元素)
-
功能：将指定元素添加到集合内
-
结果：集合本身被修改，添加了新元素
-
示例：
my_set = {"qwe", "wer", "ert"} my_set.add("rty") print(my_set) # {"qwe", "wer", "ert", "rty"}
-
-
移除元素：
-
语法：集合.remove(元素)
-
功能：将指定元素从集合内移除
-
结果：集合本身被修改，移除了元素
-
示例：
my_set = {"qwe", "wer", "ert"} my_set.remove("qwe") print(my_set) # {"wer", "ert"}
-
-
从集合中随机取出元素：
-
语法：集合.pop()
-
功能：从集合中随机取出一个元素
-
结果：会得到一个元素的结果；同时集合本身被修改，元素被移除
-
示例：
my_set = {"qwe", "wer", "ert"} element = my_set.pop() print(element) # qwe print(my_set) # {"wer", "ert"}
-
-
清空集合：
-
语法：集合.clear()
-
功能：清空集合
-
结果：集合本身被清空
-
示例：
my_set = {"qwe", "wer", "ert"} my_set.clear() print(my_set) # set()
-
-
取出两个集合的差集：
-
语法：集合1.difference(集合2)
-
功能：取出集合1和集合2的差集（集合1有而集合2没有的）
-
结果：得到一个新集合，集合1和集合2不变
-
示例：
set1 = {1, 2, 3} set2 = {1, 5, 6} set3 = set1.difference(set2) print(set1) # {1, 2, 3} print(set2) # {1, 5, 6} print(set3) # {2, 3}
-
-
消除两个集合的差集：
-
语法：集合1.difference_update(集合2)
-
功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素
-
结果：集合1被修改，集合2不变
-
示例：
set1 = {1, 2, 3} set2 = {1, 5, 6} set1.difference_update(set2) print(set1) # {2, 3} print(set2) # {1, 5, 6}
-
-
两个集合合并：
-
语法：集合1.union(集合2)
-
功能：将集合1和集合2组成新集合
-
结果：得到新集合，集合1和集合2不变
-
示例：
set1 = {1, 2, 3} set2 = {1, 5, 6} set3 = set1.union(set2) print(set1) # {1, 2, 3} print(set2) # {1, 5, 6} print(set3) # {1, 2, 3, 5, 6} -
常见操作总结：
操作 说明 集合.add(元素) 集合内添加一个元素 集合.remove(元素) 移除集合内指定的元素 集合.pop() 从集合内随机取出一个元素 集合.clear() 将集合清空 集合1.diference(集合2) 得到一个新集合，内含2个集合的差集；原有的两个集合内容不变 集合1.diference_update(集合2) 在集合1中，删除集合2中存在的元素；集合1被修改，集合2不变 集合1.union(集合2) 得到一个新集合，内含2个集合的全部元素；原有的两个集合元素不变 len(集合) 得到一个整数，记录了集合的元素数量
-
-
-
示例：
# 数据初始化 my_list = ['qwe', 'wer', 'ert', 'rty', 'qwe', 'wer'] # 定义一个空集合 my_set = set() # 将列表的数据移到集合中 for e in my_list: my_set.add(e) print(my_set)
2.8 数据容器：dict（字典、映射）
-
字典的定义：
-
字典定义语法：
# 定义字典字面量 {key: value, key: value, ..., key: value} # 定义字典变量 my_dict = {key: value, key: value, ..., key: value} # 定义空字典 my_dict = {} my_dict = dict() -
字典数据的获取：字典同集合一样，不可以通过key值来取得对应的value，但是可以通过key值来取得对应的value
my_dict = {'score1': 100, 'score2': 99, 'score': 98} print(my_dict['score1']) # 100 -
字典的嵌套：字典的key和value可以是任意数据类型（key不可为字典），表明字典是可以嵌套的
stu_score = { "name1": { "chinese": 77, "math": 66, "english": 33 }, "name2": { "chinese": 88, "math": 86, "english": 55 }, "name3": { "chinese": 99, "math": 96, "english": 66 }, } print(stu_score["name1"]["math"]) # 66 -
注意：
- 键值对的key和value可以是任意类型
- 字典内key不允许重复，重复添加等同于覆盖原有数据
- 字典不用下标索引，而是通过key检索value
-
-
字典的通用操作：
-
新增元素：
- 语法：字典[key] = value
- 结果：字典被修改，新增了元素
-
修改元素：
- 语法：字典[key] = value
- 结果：字典被修改，元素被更新
- 注意：字典key不可以重复，所以对已经存在的key执行上述操作，就是更新value值
-
删除元素：
- 语法：字典.pop(key)
- 结果：获得指定key的value，同时字典被修改，指定key的数据被删除
-
清空元素：
- 语法：字典.clear()
- 结果：字典被修改，元素被清空
-
获取全部的key：
- 语法：字典.keys()
- 结果：得到字典中的全部key
-
字典常用操作总结：
操作 说明 字典[key] 获取指定key对应的value值 字典[key] = value 添加或更新键值对 字典.pop(key) 取出key对应的value并在字典内删除此key的键值对 字典.clear() 清空字典 字典.keys() 获取字典的全部key，可用于for循环遍历列表 len(字典) 计算字典内的元素数量
-
-
字典的特点：
- 可以容纳多个数据
- 可以容纳不同类型的数据
- 每一份数据是KeyValue键值对
- 可以通过key获取到value，key不可重复（重复会覆盖）
- 不支持下标索引
- 可以修改/增加/删除/更新元素等等
- 支持for循环，不支持while循环
-
示例：
# 数据初始化 my_dict = { "name1": { "部门": "科技部", "工资": 3000, "级别": 1 }, "name2": { "部门": "市场部", "工资": 5000, "级别": 2 }, "name3": { "部门": "市场部", "工资": 7000, "级别": 3 }, "name4": { "部门": "科技部", "工资": 4000, "级别": 1 }, "name5": { "部门": "市场部", "工资": 6000, "级别": 2 }, } for e in my_dict.keys(): if my_dict[e]["级别"] == 1: my_dict[e]["级别"] += 1 my_dict[e]["工资"] += 1000 print(my_dict)
2.9 数据容器的对比总结
-
分类：
- 是否支持下标索引：
- 支持（序列类型）：列表、元组、字符串
- 不支持（非序列类型）：集合、字典
- 是否支持重复元素：
- 支持（序列类型）：列表、元组、字符串
- 不支持（非序列类型）：集合、字典
- 是否可以修改：
- 支持：列表、集合、字典
- 不支持：元组、字符串
- 是否支持下标索引：
-
特点对比：
列表 元组 字符串 集合 字典 元素数量 支持多个 支持多个 支持多个 支持多个 支持多个 元素类型 任意 任意 仅字符 任意 key（除字典外的任意类型）: value（任意类型） 下标索引 支持 支持 支持 不支持 不支持 重复元素 支持 支持 支持 不支持 不支持 可修改性 支持 不支持 不支持 支持 支持 数据有序 是 是 是 否 否 使用场景 可修改、可重复的一批数据记录场景 不可修改、可重复的一批数据记录场景 一串字符的记录场景 不可重复的数据记录场景 以key检索value的数据记录场景
2.10 数据容器的通用操作
数据容器各自有各自的特点，但是它们也有一些通用的操作
-
遍历：
- 5类数据容器都支持for循环遍历
- 列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）
-
功能方法：
- len(容器)：统计容器的元素个数
- max(容器)：统计容器的最大元素
- min(容器)：统计容器的最小元素
- 补充：字符串的大小补充
- 在程序中，字符串所用的所有字符（大小写英文字母、数字、特殊符号）都有其对应的ASCII码表值
- 字符串进行比较就是基于数字的码制大小进行比较的
- 字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大
-
类型转换：
- list(容器)：将给定容器转换为列表
- str(容器)：将给定元素转换为字符串
- tuple(容器)：将给定元素转换为元组
- set(容器)：将给定元素转换为集合
-
通用排序功能：
- sorted(容器, [reverse=True])
- 将给定容器进行排序
-
总览：
功能 描述 通用for循环 遍历容器（字典是遍历key） max 容器内最大元素 min() 容器内最小元素 len() 容器元素个数 list() 转换为列表 tuple() 转换为元组 str() 转换为字符串 set() 转换为集合 sorted(容器, [reverse=True]) 排序，reverse=True表示降序，得到一个排好序的列表
三、 函数补充
3.1 函数多返回值
按照返回值的顺序，写对应顺序的多个变量接收即可
变量之间用逗号隔开
支持不同类型的数据return
def test_return():
return 1, 2
x, y = text_return()
print(x) # 1
print(y) # 2
3.2 函数多种传参方式
3.2.1 位置参数
位置参数：调用函数时根据函数定义的参数位置来传递参数
-
示例：
def user_info(name, age, gender): print("my name is {}. i am {} years old. my gender is {}.".format(name, age, gender)) user_info("tom", 20, "nan") -
注意：传递的参数和定义的参数的顺序及个数必须一致
3.2.2 关键字参数
关键字参数：函数调用时通过“键=值”形式传递参数
-
作用：可以让函数更加清晰，容易使用，同时也清除了参数的顺序需求
-
示例：
def user_info(name, age, gender): print("my name is {}. i am {} years old. my gender is {}.".format(name, age, gender)) # 关键字传参 user_info(name="tom", age=20, gender="nan") # 可以不按照固定顺序 user_info(age=20, name="tom", gender="nan") # 可以和位置参数混用，位置参数必须在关键字参数的前面，且匹配参数顺序 user_info("tom", age=20, gender="nan") -
注意：函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
3.2.3 缺省参数
缺省参数：缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用参数时可不传该默认参数的值（注：所有位置参数必须出现在默认参数前，包括函数定义和调用）
-
作用：当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值
-
示例：
def user_info(name, age, gender="nan"): print("my name is {}. i am {} years old. my gender is {}.".format(name, age, gender)) user_info("tom", 20) user_info("tom", 20, "nv") -
注意：函数调用时，如果为缺省参数传值则修改默认参数值，否则使用这个默认值
3.2.4 不定长参数
不定长参数： 不定长参数也叫可变参数，用于不确定调用的时候会传递多少个参数（不传参也可以）的场景
-
作用：当调用函数不确定参数个数时，可以使用不定长参数
-
分类：
-
位置传参：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组，args是元组类型，这就是位置传参
def user_info(*args): print(args) user_info("tom", 20) -
关键字传参：关键字不定长传递以**号标记一个形式参数，以字典的形式接受参数，形式参数一般命名为kwargs
-
3.3 匿名函数
-
函数作为参数传递：函数本身作为参数，传入另一个函数中进行使用
-
作用：传入计算逻辑，而非传入数据
-
示例：
def test_func(compute): res = compute(1, 2) return res def compute(a, b): return a+b
-
-
lambda匿名函数
-
定义语法：
lambda 传入参数: 函数体(一行代码)- lambda是关键字，表示定义匿名函数
- 传入参数表示匿名函数的形式参数
- 函数体，就是函数的执行逻辑，要注意：只能写一行，不能写多行代码
-
使用def和使用lambda，定义的函数功能完全一致，知只是后者定义的函数是匿名的，无法二次使用
-
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
