一、公共 *** 作
1.1 运算符1.2 公共方法1.3 容器类型转换 二、推导式
2.1 列表推导式2.2 字典推导式2.3 集合推导式 三、函数
3.1 函数的定义3.2 函数的说明文档3.3 变量的作用域3.4 函数的返回值3.5 函数的参数
3.5.1 位置参数3.5.2 关键字参数3.5.3 缺省参数（默认参数）3.5.4 不定长参数（可变参数） 3.6 拆包和交换变量值
3.6.1 拆包3.6.2 交换变量值 3.7 引用
3.7.1 了解引用3.7.2 引用当实参 3.8 递归 四、lambda表达式
4.1 lambda表达式语法4.2 lambda表达式的参数
4.2.1 无参数4.2.2 有参数4.2.3 默认参数4.2.4 可变参数 4.3 lambda表达式的应用
4.3.1 带判断的lambda4.3.2 列表数据按字典key的值排序 五、高阶函数
5.1 高阶函数示例5.2 内置高阶函数
5.2.1 map()5.2.2 reduce()5.2.3 filter()
一、公共 *** 作 1.1 运算符
# 合并
str1 = 'aa'
str2 = 'bb'
list1 = [1, 2]
list2 = [10, 20]
t1 = (1, 2)
t2 = (10, 20)
# 1. 字符串
print(str1+str2) # aabb
# 2. 列表
print(list1 + list2) # [1, 2, 10, 20]
# 3. 元组
print(t1 + t2) # (1, 2, 10, 20)
# 复制
str1 = 'a'
list1 = ['hello']
t1 = ('hello',)
# 1. 字符串
print(str1 * 5) # aaaaa
# 2. 列表
print(list1 * 5) # ['hello', 'hello', 'hello', 'hello', 'hello']
# 3. 元组
print(t1*5) # ('hello', 'hello', 'hello', 'hello', 'hello')
# 元素是否存在
str1 = 'abcd'
list1 = [10, 20, 30, 40]
t1 = (100, 200, 300, 400)
dict1 = {'name': 'Python', 'age ': 30}
# 1. 字符
print('a' in str1) # True
print('a' not in str1) # False
# 2. 列表
print(10 in list1) # True
print(10 not in list1) # False
# 3. 元组
print(10 in t1) # False
print(10 not in t1) # True
# 4. 字典
print('name' in dict1) # True
print('name' not in dict1) # False
print('name' in dict1.keys()) # True
print('name' in dict1.values()) # False
1.2 公共方法
测试数据如下：
str1 = 'abcd'
list1 = [10, 20, 30, 40]
t1 = (10, 20, 30, 40)
s1 = {10, 20, 30, 40}
dict1 = {'name': 'Python', 'age ': 30}
len()：
print(len(str1)) # 4 print(len(list1)) # 4 print(len(t1)) # 4 print(len(s1)) # 4 print(len(dict1)) # 2
del 或 del()：
del str1 # 删除字符串str1 # print(str1) # 报错 # del list1 # 删除列表list1 # print(list1) # 报错 del(list1[0]) # 删除 10 print(list1) # [20, 30, 40]
max() 和 min()：
print(max(str1)) # d print(max(list1)) # 40
range(start, end, step)：
'''
# 1. 如果不写开始，默认从 0 开始
# 2. 如果不写步长，默认步长为 1
'''
print(range(1, 10, 1)) # range(1, 10) 可迭代对象
for i in range(1, 10, 1):
print(i) # 循环打印 1-9
for i in range(1, 10):
print(i) # 循环打印 1-9
for i in range(10):
print(i) # 循环打印 0-9
enumerate()：
list1 = ['a', 'b', 'c', 'd', 'e']
# enumerate 返回结果是元组，元组第一个数据是原迭代对象的数据对应的下标，元组第二个数据是原迭代对象的数据
for i in enumerate(list1):
print(i) # (0, 'a') (1, 'b') (2, 'c') (3, 'd') (4, 'e')
# 设置对应下标的起始值
for i in enumerate(list1, start=1):
print(i) # (1, 'a') (2, 'b') (3, 'c') (4, 'd') (5, 'e')
for index, char in enumerate(list1, start=1):
print(f'下标是{index}, 对应的字符是{char}') # 下标是1, 对应的字符是a 下标是2, 对应的字符是b ...
1.3 容器类型转换
list1 = [10, 20, 30, 40, 20, 50]
t1 = (10, 20, 30, 40)
s1 = {10, 20, 30, 40}
# tuple()：转换成元组
print(tuple(list1)) # (10, 20, 30, 40, 20, 50)
print(tuple(s1)) # (40, 10, 20, 30)
# list()：转换成列表
print(list(t1)) # [10, 20, 30, 40]
print(list(s1)) # [40, 10, 20, 30]
# set()：转换成集合
# 集合可以快速完成列表去重
print(set(list1)) # {40, 10, 50, 20, 30}
print(set(t1)) # {40, 10, 20, 30}
二、推导式
推导式作用： 简化代码
只有列表、字典、集合有推导式。
作用：用一个表达式创建一个有规律的列表或控制一个有规律的列表。
一般列表推导式
# 需求:创建一个 0-10 的列表。
# for 循环
list1 = []
for i in range(10):
list1.append(i)
print(list1)
# 列表推导式实现
list1 = [i for i in range(10)]
print(list1) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
带 if 的列表推导式
# 需求：创建0-10的偶数列表 # 法一： list1 = [i for i in range(0, 10, 2)] print(list1) # [0, 2, 4, 6, 8] # 法二：带 if 的列表推导式 list1 = [i for i in range(10) if i % 2 == 0] print(list1) # [0, 2, 4, 6, 8]
多个 for 循环实现列表推导式
# 需求：创建 [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)] # 法一： list1 = [] # for i in range(1, 3): # for j in range(3): # list1.append((i, j)) # 法二：多个 for 循环实现列表推导式 list1 = [(i, j) for i in range(1, 3) for j in range(3)] print(list1)
2.2 字典推导式
创建一个字典：字典 key 是 1-5 数字，value 是这个数字的 2 次方。
dict1 = {i: i**2 for i in range(1, 5)}
print(dict1) # {1: 1, 2: 4, 3: 9, 4: 16}
将两个列表合并为一个字典
list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, 'man']
dict1 = {list1[i]: list2[i] for i in range(min(len(list1), len(list2)))}
print(dict1) # {'name': 'Tom', 'age': 20, 'gender': 'man'}
注意：
- 如果两个列表数据个数相同时，len 统计任何一个列表的长度都可以。如果两个列表数据个数不同时，len 统计数据多的列表数据个数会报错；len统计数据少的列表数据的个数不会报错。
提取字典中目标数据
# 提取上述电脑数量大于等于 200 的字典数据
counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}
dict1 = {key: value for key, value in counts.items() if value >= 200}
print(dict1) # {'MBP': 268, 'DELL': 201}
2.3 集合推导式
# 需求:创建一个集合，数据为下方列表的2次方。
list1 = [1, 1, 2]
set1 = {i ** 2 for i in list1}
print(set1) # {1, 4} -- 去重
三、函数 3.1 函数的定义
不带参数：
def 函数名(): 代码...
带参数：
def 函数名(参数): 代码...
有返回值：
def 函数名(参数): 代码... return 返回值
其中，参数可有可无。
调用函数：
函数名()
示例：
# 不带参数
def fun():
print('hello python')
fun() # hello python
# 带参数
def add_num(a, b):
result = a + b
print(result)
add_num(2, 4) # 6
# 有返回值
def sum_num(a, b):
return a + b
print(sum_num(30, 40)) # 70
注意：Python中，函数必须 先定义后使用。
3.2 函数的说明文档
语法：
# 定义函数的说明文档 def 函数名(参数): """ 说明⽂文档的位置 """ 代码 ...... # 查看函数的说明文档 help(函数名)
注意： 函数说明文档只能在第一行进行说明
def sum_num(a, b):
'''求和函数'''
return a + b
help(sum_num)
函数说明文档的高级使用：回车可见参数信息
def sum_num1(a, b):
"""
参数信息
:param a:
:param b:
:return:
"""
return a + b
help(sum_num1)
3.3 变量的作用域
局部变量
局部变量是定义在函数体内部的变量量，即只在函数体内部生效。当函数调用完成后，则销毁局部变量。
def testA():
a = 100
print(a)
testA()
print(a) # 报错，编译通不过
全局变量
全局变量，指的是在函数体内、外都能生效的变量。
a = 100
def testA():
# a = 200 # 访问局部变量 a，对全局变量没有影响
global a # global 关键字声明 a 是全局变量
a = 200 # 修改全局变量 a
print(a)
testA() # 200
print(a) # 200
注意： 在函数里修改全局变量，必须用 global 声明，否则修改的是局部变量。
3.4 函数的返回值
当函数有 多个返回值 时，有如下写法：
def return_num():
# return 1, 2 # 默认返回元组 (1, 2)
# return (1, 2) # 返回元组 (1, 2)
# return [1, 2] # 返回列表 [1, 2]
return {"name":"Kevin", "age":20} # 返回字典 {"name":"Kevin", "age":20}
result = return_num()
print(result)
注意：
- 只执行第一个 returnreturn a，b 写法，返回多个数据的时候，默认是元组类型。return 后面可以连接列表、元组或字典，以返回多个值。
3.5 函数的参数 3.5.1 位置参数
位置参数： 调用函数时 根据函数定义的参数位置 来传递参数。
def user_info(name, age, gender):
print(f'名字是{name}, 年龄是{age}, 性别是{gender}')
user_info('Kevin', 23, '男') # 名字是Kevin, 年龄是23, 性别是男
# user_info('Kevin', 23) # 报错
user_info(23, 'Kevin', '男') # 名字是23, 年龄是Kevin, 性别是男
注意： 传递和定义参数的顺序及个数必须一致。
3.5.2 关键字参数
函数调用，通过 键=值 形式加以指定。
def user_info(name, age, gender):
print(f'名字是{name}, 年龄是{age}, 性别是{gender}')
# 实参不加引号
user_info('Kevin', age = 23, gender = '男') # 名字是Kevin, 年龄是23, 性别是男
user_info(gender = '男', name = 'Kevin', age = 23) # 名字是Kevin, 年龄是23, 性别是男
# 位置参数必须在关键字参数前面
# user_info(gender = '男', name = 'Kevin', 23) # 报错，因为 23 是位置参数，其在关键字参数后面
注意： 函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序。
3.5.3 缺省参数（默认参数）
缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值。
def user_info(name, age, gender='男'):
print(f'名字是{name}, 年龄是{age}, 性别是{gender}')
user_info('Kevin', 23) # 名字是Kevin, 年龄是23, 性别是男
user_info('Kevin', 23, '女') # 名字是Kevin, 年龄是23, 性别是女
# 注意：所有位置参数必须出现在默认参数前，包括函数定义和调⽤
# def user_info1(name, age=23, gender): # 报错
# print(f'名字是{name}, 年龄是{age}, 性别是{gender}')
注意： 所有位置参数必须出现在默认参数前，包括函数定义和调用。
3.5.4 不定长参数（可变参数）
不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数（不传参也可以）的场景。
包裹位置传递：返回值是 元组类型。
def user_info(*args): # 一般用 args
print(args)
# 传进的所有参数都会被 args 变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是包裹位置传递
user_info() # ()
user_info('Kevin') # ('Kevin',)
user_info('Kevin', 20) # ('Kevin', 20)
user_info('Kevin', 20, '男') # ('Kevin', 20, '男')
包裹位置传递：返回值是 字典类型。
def user_info(**kwargs): # 一般用 kwargs
print(kwargs)
user_info() # {}
user_info(name = 'Kevin', age = 20) # {'name': 'Kevin', 'age': 20}
综上： 无论是包裹位置传递还是包裹关键字传递，都是一个 组包 的过程。
3.6 拆包和交换变量值 3.6.1 拆包
拆包：元组
def return_num():
return 1, 2 # 返回值默认元组类型
num1, num2 = return_num()
print(num1) # 1
print(num2) # 2
拆包：字典
dict1 = {'name': 'Kevin', 'age': '20'}
a, b = dict1
# 对字典进行拆包，取出来的是字典的 key
print(a) # name
print(b) # age
print(dict1[a]) # Kevin
print(dict1[b]) # 20
3.6.2 交换变量值
a = 1 b = 2 # 法一： ''' c = a a = b b = c print(a, b) # 2 1 ''' # 法二： a, b = b, a print(a, b) # 2 1
3.7 引用
在 python 中，值是靠引用来相互传递。课用 id() 来判断两个变量是否为一个值的引用。（id 可以理解为变量开辟的内存地址）
3.7.1 了解引用# 1. int 类型 --- 不可变类型 a = 1 b = a # a 与 b 的 id 值相同 print(id(a) == id(b)) # True a = 2 print(b) # 1 # a 与 b 的 id 值不同 print(id(a) == id(b)) # False # 2. 列表 -- 可变数据类型 aa = [10, 20] bb = aa # aa 与 bb 的 id 值相同 print(id(aa) == id(bb)) # True aa.append(30) print(bb) # [10, 20, 30] # id 值相同 print(id(aa) == id(bb)) # True
总结：
不可变数据类型对数据进行修改时，相当于在内存中重新开辟了一块内存空间来存储变量值，或者说重新创建了一个对象。可变数据类型对数据进行修改时，没有开辟新的内存空间，即没有创建新的对象。
3.7.2 引用当实参
# 不可变数据类型
def testA(a):
a = 6
print(f"函数内：{a}, 内存地址:{id(a)}")
a = 0
testA(a)
print(f"函数外：{a}, 内存地址:{id(a)}")
# 可变数据类型
def testB(a):
a.append(30)
print(f"函数内：{a}, 内存地址:{id(a)}")
a = [11, 22]
testB(a)
print(f"函数外：{a}, 内存地址:{id(a)}") # id 值相同
print(a)
总结：
不可变数据类型作为参数时，在函数内对变量进行赋值，相当于重新开辟了一个内存空间来存储临时变量值，或者说重新创建一个对象去指向所赋的值。可变数据类型作为参数， 在函数内外修改的都是同一个对象。注意结合变量作用域进行区分理解，如果是刻板数据类型在函数体内进行修改，相当于修改全局变量。
3.8 递归
递归特点： 函数内部自己调用自己，且必须有出口。
# 数字以内累加和，如：3 + 2 + 1
def sum_numbers(num):
if num == 1:
return 1
return num + sum_numbers(num-1)
result = sum_numbers(3)
print(result) # 6
四、lambda表达式
如果一个函数有一个返回值，并且只有一句代码，可以使用 lambda 简化。
4.1 lambda表达式语法语法： lambda 参数列表︰表达式
注意：
- lambda 表达式的参数可有可无，函数的参数在 lambda 表达式中完全适用。lambda 函数能接收任何数量的参数 但只能返回一个表达式的值 。
# 测试函数
def fun1():
return 100
print(fun1()) # 100
# lamdba 表达式化简上式
fun2 = lambda : 100
print(fun2) # at 0x0000023F6F523E20>
print(fun2()) # 100
需求：实现两数相加
# 测试函数
def add(a, b):
return a + b
# lamdba 表达式化简上式
fun1 = lambda a, b: a + b
print(fun1) # at 0x000001D0BCECA560>
print(fun1(1, 2)) # 3
4.2 lambda表达式的参数 4.2.1 无参数
fn1 = lambda : 100 print(fn1()) # 1004.2.2 有参数
fn2 = lambda a: a
print(fn2('hello')) # hello
4.2.3 默认参数
fn3 = lambda a, b, c = 100: a + b + c print(fn3(1,2)) # 1034.2.4 可变参数
# 可变参数：*args
fn4 = lambda *args: args
print(fn4(1)) # (1,)
print(fn4(1, 2, 3)) # (1, 2, 3)
# 可变参数 **kwargs
fn5 = lambda **kwargs: kwargs
print(fn5(name = 'python')) # {'name': 'python'}
print(fn5(name = 'python', age = 20)) # {'name': 'python', 'age': 20}
4.3 lambda表达式的应用 4.3.1 带判断的lambda
fn1 = lambda a, b: a if a > b else b # 三目运算符 print(fn1(100, 200)) # 2004.3.2 列表数据按字典key的值排序
students = [
{'name': 'TOM', 'age': 20},
{'name': 'ROSE', 'age': 19},
{'name': 'Jack', 'age': 22}]
# 按 name 值升序排列
students.sort(key = lambda x: x['name']) # x 指代待排序的元素或数据
print(students) # [{'name': 'Jack', 'age': 22}, {'name': 'ROSE', 'age': 19}, {'name': 'TOM', 'age': 20}]
# 按 name 值降序排列
students.sort(key = lambda x: x['name'], reverse=True)
print(students) # [{'name': 'TOM', 'age': 20}, {'name': 'ROSE', 'age': 19}, {'name': 'Jack', 'age': 22}]
# 按 age 值升序排列
students.sort(key = lambda x: x['age'])
print(students) # [{'name': 'ROSE', 'age': 19}, {'name': 'TOM', 'age': 20}, {'name': 'Jack', 'age': 22}]
注意：key = lambda x: x['name'] 中 x 指代待排序的元素或数据。
五、高阶函数
把函数作为参数传入，这样的函数称为高阶函数，高阶函数是函数式编程的体现。函数式编程就是指这种高度抽象的编程范式。
高阶函数示例：
5.1 高阶函数示例# 需求：任意两个数字，先进行数字处理（绝对值或四舍五入）在求和计算
# abs 取绝对值，round 四舍五入
# 1. 法一：
def add_num(a, b): # 只能进行绝对值处理，如果四舍五入还需要再写另一个函数
return abs(a) + abs(b)
result1 = add_num(-1.1, 1.9)
print(result1)
# 2. 法二：
def add_num2(a, b, f): # f 是函数参数
return f(a) + f(b)
print(add_num2(-1.1, 1.9, abs)) # 3.0
print(add_num2(-1.1, 1.9, round)) # 1
5.2 内置高阶函数 5.2.1 map()
map(func, Ist)，将传入的函数变量 func 作用到 lst 变量的每个元素中，并将结果组成新的迭代器(Python3)返回。注：Python2 中是作为列表返回。
示例：
# 计算 list1 序列中各个数字的2次方。
list1 = [1, 2, 3, 4]
def func(x):
return x ** 2
result = map(func, list1)
print(result) # 迭代器
5.2.2 reduce()
reduce(func(x,y), lst)，其中 func 必须有两个参数。每次func计算的结果继续和序列的下一个元素做累积计算。
示例：
# 计算 list1 序列中各个数字的累加和。
import functools
list1 = [1, 2, 3, 4]
def func(a, b):
return a + b
result = functools.reduce(func, list1)
print(result) # 10
5.2.3 filter()
filter(func, lst) 用于过滤序列，返回一个 filter 对象，如果要转换为列表，可以使用 list() 来转换。
示例：
# 在 list1 中提取偶数序列
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def func(x):
return x % 2 == 0
result = filter(func, list1)
print(result) #
print(list(result)) # [2, 4, 6, 8, 10]
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）