- 前言
- 函数基础
- 函数的参数
- 函数的返回值
- 变量进阶[理解 知道]
- 变量的引用[理解]
- 可变类型和不可变类型
- 面试题
- 题目一
- 题目二
- 题目3 面试题 列表的+=操作
- 题目 4 交换两个变量的值
- 组包和拆包
- 局部变量和全局变量
- 局部变量
- 全局变量
- 函数进阶
- 返回值- 函数返回多个数据值
- 函数参数
- 函数传参的方式
- 缺省参数
- 多值参数[可变参数/不定长参数]
- Print 函数的解析
- 不定长参数补充-函数调用时的拆包
- 匿名函数
此篇文章是我在B站学习时所做的笔记，部分为亲自动手演示过的，方便复习用。此篇文章仅供学习参考。
提示：以下是本篇文章正文内容，下面案例可供参考
函数基础 函数的参数# 1. 定义一个函数, my_sum ,对两个数字进行求和计算.
def my_sum():
num1 = 10
num2 = 20
num = num1 + num2
print(num)
my_sum()
# 函数存在的问题, 这个函数只能对 10 和 20 进行求和, 不能对任意的函数进行求和计算.
# 问题的解决: 想要解决这个问题,可以使用函数参数来解决
函数参数: 在函数定义的时候,使用变量代替具体的数据值(进行占位), 在函数调用的时候 , 传递具体的数据值.
好处: 让函数更加通用,能够解决以类问题, 而不是单纯的一个
掌握理解 形参和实参的概念
函数的返回值
函数的返回值,可以理解为是 函数整体执行的结果是什么 什么上班需要书写返回值: 函数中得到的数据在后续的代码中还要使用,这个时候就应该将这个数据作为返回值返回,以供后续使用 print() ---> None input() ---> 键盘输入的内容 type() ---> 类型 len() ---> 数据的长度(元素的个数) 在函数中想要将一个数据作为返回值 返回, 需要使用 return 关键字(只能在函数中使用) 作用: 1. 将数据值作为返回值返回 2. 函数代码执行遇到 return, 会结束函数的执行
def my_sum(a, b):
num = a + b
# print(num) # 代码中没有返回值,只有 print,这个结果只能在函数中用一次,不能后续使用
# 我们想要将这个求和的结果 在后续的代码中使用, 需要使用 return 将求和的结果进行返回
return num # 将这个结果返回到调用的地方法
# return 之后的代码会执行吗
print('我是 return 之后的代码, 我会执行吗---> 不会执行')
# 1. 函数中没有 print, 只有 return, 想要查看结果,需要在调用的时候使用 print
print(my_sum(1, 2))
# 2, 想要将函数中返回的结果,在后续代码中使用, 即需要将这个数据保存下来, 需要使用变量来接收(保存) 函数的返回值(执行结果)
# 变量 = 函数()
result = my_sum(10, 20) # 将求和的结果保存到变量 result 中, 可以在后续代码中使用
print('使用: 1, 直接打印: ', result)
print('使用: 2, 对数字 加 10:', result + 10)
-
返回值的说明
def 函数名(): # 返回值 None
pass # 代码中没有 return
def 函数名():
return # return 后边没有数据, 返回值 None
def 函数名():
return xx # 返回值是 xx
在这一部分 我们了解 Python 底层是如何处理数据的
变量的引用[理解]- 在定义变量的时候 变量 = 数据值, Python 解释器会在内存中开辟两块空间
- 变量和数据都有自己的空间
- 日常简单理解, 将数据保存到变量的内存中, 本质是 将 数据的地址保存到变量对应的内存中
- 变量中存储数据地址的行为 就是引用 (变量引用了数据的地址, 简单说就是变量中存储数据), 存储的地址称为 引用地址
- 可以使用 id() 来获取变量中的引用地址(即数据的地址), 如果两个变量的 id() 获取的引用地址一样, 即代表着, 两个变量引用了同一个数据,是同一个数据
- 只有 赋值运算符=, 可以改变变量的引用(等号左边数据的引用)
- python 中数据的传递,都是传递的引用
image-20210625113925383
数据类型: int float bool str list tuple dict set
可变不可变是指: 数据所在的内存是否允许修改, 允许修改就是可变类型, 不允许修改就是不可变类型(不使用=, 变量引用的数据中的内容是否会变化,会变化是可变的, 不会变化是不可变的)
可变类型: 列表 list, 字典 dict, 集合 set
列表.append()
字典.pop(键)
不可变类型:int float bool str tuple
对于列表来说, += 的本质是 extend 操作
a = 10 b = 20 # 方法一: 常规方法 引入第三个变量 # c = a # 将 变量 a 中的值先保存起来 10 # a = b # 将变量 b 中的值 给 a # b = c # 将变量 c中的值(即最开始 a 的值) 10 给 b # print(a, b) # 方法二, 不使用第三个变量, 使用数学中的方法 # a = a + b # a 的值 30 # b = a - b # 30 - 20 ===> 10 # a = a - b # 30 - 10 ===> 20 # print(a, b) # 方法三, 重点掌握, Python 特有 a, b = b, a print(a, b)组包和拆包
组包(pack): 将多个数据值使用逗号连接, 组成元组
拆包(unpack): 将容器中的数据值使用多个变量分别保存的过程,注意: 变量的个数和容器中数据的个数要保持一致
赋值运算符, 都是先执行等号右边的代码, 执行的结果,保存到等号左边的变量中
# 组包 c = b, a # 组包 print(type(c), c) #局部变量和全局变量(10, 20) # 拆包 a, b = c print(a, b) x, y, z = [1, 2, 3] print(x, y, z)
变量: 根据变量的定义位置, 可以将变量分为局部变量和全局变量,
局部变量局部变量: 在函数内部(函数的缩进中)定义的变量,称为是局部变量
特点:
- 局部变量只能在当前函数内部使用, 不能在其他函数和函数外部使用
- 在不同函数中,可以定义名字相同的局部变量, 两者之间没有影响
- 生存周期(生命周期, 作用范围)–> 在哪 能用
在函数被调用的时候,局部变量被创建, 函数调用结束, 局部变量的值被销毁(删除), 不能使用
所以函数中的局部变量的值, 如果想要在函数外部使用, 需要使用 return 关键字, 将这个值进行返回
def func1():
num = 10 # num 就是局部变量
print(f"func1 函数中 {num}")
def func2():
num = 100 # 可以在不同函数中定义名字相同的局部变量,没有影响
print(f"func2 函数中 {num}")
func1() # 10
func2() # 100
func1() # 10
全局变量
定义位置: 在函数外部定义的变量, 称为是 全局变量
特点:
- 可以在任何函数中读取(获取) 全局变量的值
- 如何在函数中存在和全局变量名字相同的局部变量, 在函数中使用的是 局部变量的值(就近)
- 在函数内部想要修改全局变量的引用(数据值), 需要添加 global 关键字, 对变量进行声明为全局变量
- 生命周期
代码执行的时候被创建, 代码执行结束,被销毁(删除)
g_num = 10 # 全局变量
def func1():
print(f'func1 中 {g_num}') # 在函数中可以读取全局变量的值
def func2():
g_num = 20 # 定义局部变量, 不会影响全局变量
print(f'func2 中 {g_num}')
def func3():
global g_num # 这个函数中使用的 g_num 都是全局变量, 写在函数的第一行
g_num = 30 # 修改了全局变量
print(f'func3 中 {g_num}')
# func1() # 10
# func2() # 20
# func1() # 10
# func3() # 30
# func1() # 30
print(g_num) #10
函数进阶
返回值- 函数返回多个数据值
函数中想要返回一个数据值, 使用 return 关键字
将 多个数据值组成容器进行返回, 一般是元组(组包)
def calc(a, b):
num = a + b
num1 = a - b
return num, num1
# 写法一
result = calc(10, 5)
print(result, result[0], result[1])#(15,5) 15 5
# 写法二, 直接拆包
x, y = calc(20, 10)
print(x, y)#30 10
函数参数
形参的不同书写方法
函数传参的方式- 位置传参:
在函数调用的时候, 按照形参的顺序, 将实参值传递给形参
- 关键字传参
在函数调用的时候, 指定数据值给到那个形参
- 混合使用
- 关键字传参必须写在位置传参的后面
- 不要给一个形参传递多个数据值
def func(a, b, c):
print(f'a: {a}, b: {b}, c: {c}')
# 位置传参
func(1, 2, 3)
# 关键字传参
func(a=2, b=3, c=1)
# 混合使用
func(1, 3, c=5)
缺省参数
缺省参数, 默认参数
列表.pop() # 不写参数,删除最后一个
列表.sort(reverse=True)
- 定义方式
在函数定义的时候, 给形参一个默认的数据值, 这个形参就变为缺省参数, 注意, 缺省参数的书写要放在普通参数的后边 - 特点(好处)
缺省参数, 在函数调用的时候, 可以传递实参值, 也可以不传递实参值
如果传参,使用的就是传递的实参值, 如果不传参,使用的就是默认值
def show_info(name, sex='保密'):
print(name, sex)
show_info('小王')#小王 保密
show_info('小王', '男')#小王 男
多值参数[可变参数/不定长参数]
print(1) print(1, 2) print(1, 2, 3) print(1, 2, 3, 4)
当我们在书写函数的时候, 不确定参数的具体个数时, 可以使用 不定长参数
- 不定长位置参数(不定长元组参数)
- 书写, 在普通参数的前边,加上一个 *, 这个参数就变为不定长位置参数
- 特点, 这个形参可以接收任意多个 位置传参的数据
- 数据类型, 形参的类型是 元组
- 注意, 不定长位置参数 要写在普通的参数的后面
5, 一般写法, 不定长位置参数的名字为 args, 即(*args) # arguments
- 不定长关键字参数(不定长字典参数)
- 书写, 在普通参数的前边,加上 两个 *, 这个参数就变为不定长关键字参数
- 特点, 这个形参可以接收任意多个 关键字传参的数据
- 数据类型, 形参的类型是 字典
4, 注意, 不定长关键字参数,要写在所有参数的最后边
5, 一般写法, 不定长关键字参数的名字为 kwargs, 即(**kwargs), keyword arguments
- 完整的参数顺序
def 函数名(普通函数, *args, 缺省参数, **kwargs):
pass
# 一般在使用的时候, 使用 1-2种, 按照这个顺序挑选书写即可
def func(*args, **kwargs):
print(type(args), args)
print(type(kwargs), kwargs)
print('-' * 30)
func() #()
func(1, 2, 3) #{'a':1,'b':2,'c':3} 位置传参, 数据都给 args
func(a=1, b=2, c=3) #(1,2,3) 关键字传参, 数据都给 kwargs
func(1, 2, 3, a=4, b=5, c=6)#{'a':4,'b':5,'c':6}
Print 函数的解析
# print() # sep=' ', 多个位置参数之间的间隔 # end='n' 每一个 print 函数结束, 都会打印的内容 结束符 print(1, end=' ') print(2, end=' ') print(3) #1 2 3 print(1, 2, 3, 4, 5, 6, sep='_')#1_2_3_4_5_6 print(1, 2, 3, 4, 5, 6, sep='_*_')#1_*2_*_3_*_4_*_5_*_6不定长参数补充-函数调用时的拆包
def my_sum(*args, **kwargs):
num = 0 # 定义变量,保存求和的结果
for i in args:
num += i
for j in kwargs.values():
num += j
print(num)#10
# 需求, my_list = [1, 2, 3, 4] 字典 my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
my_list = [1, 2, 3, 4]
my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# 将字典和列表中的数据使用 my_sum 函数进行求和, 改如何传参的问题
# my_sum(1, 2, 3, 4)
# my_sum(a=1, b=2, c=3, d=4)
# 想要将列表(元组)中的数据 分别作为位置参数,进行传参,需要对列表进行拆包操作
# my_sum(*my_list) # my_sum(1, 2, 3, 4)
# 想要将字典中的数据, 作为关键字传参,, 需要使用 使用 ** 对字典进行拆包
my_sum(**my_dict) # my_sum(a=1, b=2, c=3, d=4)
匿名函数
匿名函数: 就是使用 lambda 关键字定义的函数
一般称为使用def 关键字定义的函数为, 标准函数
匿名函数只能书写一行代码
匿名函数的返回值不需要 return, 一行代码(表达式) 的结果就是返回值
使用场景: 作为函数的参数, 这个函数比较简单,值使用一次,没有必要使用 def 定义
- 语法
lambda 参数: 一行代码 # 这一行代码,称为是表达式 # 匿名函数一般不需要我们主动的调用, 一般作为函数的参数使用的 # 我们在学习阶段为了查看匿名函数定义的是否正确,可以调用 # 1, 在定义的时候 ,将匿名函数的引用保存到一个变量中 变量 = lambda 参数: 一行代码 # 2. 使用变量进行调用 变量()
- 代码
# 1. 无参无返回值
def func1():
print('hello world')
func1()
# lambda : print('hello lambda') # 匿名函数的定义
func11 = lambda: print('hello lambda')
func11()
# 2. 无参有返回值
def func2():
return 10
print(func2())
func22 = lambda: 10
print(func22())
# 3. 有参无返回值
def my_sum(a, b):
print(a + b)
my_sum(1, 2)
my_sum11 = lambda a, b: print(a+b)
my_sum11(10, 20)
# 4. 有参有返回值
def func4(a, b):
return a + b
print(func4(1, 2)) # num = func4(1, 2) print(num)
func44 = lambda a, b: a+b
print(func44(10, 20))
- 练习
- 定义一个匿名函数可以求两个数的乘积
- 定义一个匿名函数, 参数为字典,返回字典中键为 age 的值
# 1. 定义一个匿名函数可以求两个数的乘积 (参数需要两个, )
func1 = lambda a, b: a * b
# 2. 定义一个匿名函数, 参数为字典,返回字典中键为 age 的值
# 参数只是一个占位的作用,定义的时候没有具体的数据值, 形参的值是在调用的时候进行传递,此时,形参才有数据值形参的类型就是由实参来决定的, 在函数定义的时候,参数只是一个符号,写什么都可以, 想让其是字典类型,只需要保证
# 实参是字典即可
func2 = lambda x: x.get('age')
func3 = lambda x: x['age']
print(func1(1, 2))
print(func1(3, 2))
my_dict = {'name': '张三', 'age': 18}
print(func2(my_dict))
print(func3(my_dict))
- 匿名函数作为函数的参数 - 列表中的字典排序
user_list = [
{"name": "zhangsan", "age": 18}, {"name": "lisi", "age": 19}, {"name": "wangwu", "age": 17}
]
列表排序(列表中的数字):
列表.sort() # 升序
列表.sort(reverse=True) # 降序
列表中的内容都是字典, 想要排序?
user_list = [
{"name": "zhangsan", "age": 18},
{"name": "lisi", "age": 19},
{"name": "wangwu", "age": 17}
]
# user_list.sort()
# 列表的排序, 默认是对列表中的数据进行比大小的, 可以对 数字类型和字符串进行比大小,
# 但是对于字典来说,就不知道该怎么比大小, 此时,我们需要使用 sort 函数中的 key 这个参数, 来指定字典比大小的方法
# key 这个参数, 需要传递一个函数,一般是匿名函数, 字典的排序,其实要指定根据字典的什么 键进行排序, 我们只需要使用
# 匿名函数返回字典的这个键对应的值即可
# 列表.sort(key=lambda x: x['键'])
# 根据年龄排序
# user_list.sort(key=lambda x: x['age'])
user_list.sort(key=lambda x: x['age'], reverse=True)
print(user_list)
# user_list.sort(key=lambda x: x['age'])
# 说明: 匿名函数中的参数是 列表中的数据, 在 sort 函数内部,会调用 key 这个函数(将列表中每个数据作为实参传递给形参),
# 从列表中的获取函数的返回值, 对返回值进行比大小操作(<)
def get_value(x):
return x['age']
user_list.sort(key=get_value)
- 字符串比大小
字符比大小,是比较字符对应的 ASCII 码值
A < Z < a < z
ord(字符) # 获取字符对应的 ASCII 的值
chr(ASCII 值) # 获取对应的 字符
字符串比大小:
对应下标位置字符的大小, 直到比出大小, 如果全部比完了, 还没有比出大小,就是相等
