14.6、补充：列表去重
面试题可能出现
列表去重：列表中存在多个数据，需求，去除列表中重复的数据
方式1：思路
遍历原列表中的数据判断新列表是否存在，如果存在，不管，如果不存在放入新列表
遍历：for 循环使用
判断是否存在：可以 使用 in
存入数据：append()
方式2：
在python中还有一种数据类型（容器），称为是 集合（set）
特点：集合中不能有重复数据（如果有重复的数据会自动去重）
可以使用集合的特点对列表去重
1.使用set()类型转换将列表转换为集合 集合为类型
2.再使用list()类型转换将集合转换为列表
缺点：不能保证数据在原列表中出现的顺序（一般来说，也不考虑这件事）
list1=[1,2,3,4,2,3,12,4,1]
list2=set(list1)
print(list2)
14.7、函数的参数
# 1、定义一个函数，my_sum,对两个数字进行求和计算。
def my_sum():
num1=10
num2=20
num = num1+num2
print(num)
my_sum()
# 函数存在的问题，这个函数只能对10和20进行求和，不能对任意的函数进行求和
#问题解决： 想要解决这个额问题，可以使用函数参数来解决
函数参数：在函数定义的时候，使用变量代替具体的数据值（进行占位），
在函数调用的时候，传递具体的数据值。
好处：让函数更加通用，能够解决一类问题，而不是单纯的一个
# num1和num2 是函数定义时候的参数，起到占位的作用，没有具体的数据值，称为形式参数，简称 形参
def my_sum(num1,num2):
num = num1+num2 # 函数中使用的数据会变化时，就可以定义为参数
print(num)
my_sum(10,20) # 在函数调用的时候，括号中的数据会传递给形参，是具体的数据值，称为实际参数，简称 实参
# 目前书写的函数，在定义的时候如果有形参，那么在调用的时候，必须传递实参值，个数要对应，否则会出错
格式：定义函数前后空两行
14.8、函数的返回值
函数的返回值，可以理解为是 函数整体执行的结果是什么
什么时候需要书写返回值：函数中得到的数据在后续的代码中还要使用，这个时候就应该将这个数据作为返回值返回，以供后续使用
print()--->None
input()--->键盘输入的内容
type() --->类型
len() --->数据的长度（元素的个数）
在函数中想要将一个数据作为返回值 返回，需要使用return关键字（只能在函数中使用）
作用：
1.将数据值作为返回值返回
2.函数代码执行遇到return，会结束函数的执行
def my_sum(num1, num2):
num = num1 + num2 # 函数中使用的数据会变化时，就可以定义为参数
print(num) # 代码中没有返回值，只有print,这个结果 只能在函数中用一次，不能后续使用
# 想要将这个求和的结果 在后续代码中使用，需要使用return将求和的结果进行返回
return num # 将这个结果返回调用的地方
# 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
14.9、变量的进阶、id（理解
变量的引用
1.在定义变量的时候 变量=数据值，python解释器会在内存中开辟两块空间
2.变量和数据都有自己的空间
3.可理解为，将数据保存到变量的内存中，本质是将 数据的地址保存到变量对应的内存
4.变量中存储数据地址的行为 就是引用（变量引用了数据的地址，简单说就是变量中存储数据
5.可以使用id() 来获取变量中的引用地址（即数id据的地址),如果两个变量的id()获取的引用地址一样，即代表着，两个变量引用了同一个数据，是同一个数据
6.只有赋值运算符 = ，可以改变变量的引用（等号左边数据的引用）
7.python中数据的传递，们都是传递的引用
a = 1 # 将数据1 的地址，存到a对应的内存中
print(id(a))
b = a # 将数据a中的引用 保存到变量b中
print('b：', id(b))
a = 10 # 将数据10的地址保存到a对应的地址，即a的引用变了
print('a:', id(a))
print('b:', id(b))
输出：
1648048734448
b： 1648048734448
a: 1648048734736
b: 1648048734448
14.10、可变类型和不可变类型
数据类型：int float bool str list tuple dict set
可变不可变是指：数据所在的内存是否允许被修改，允许修改就是可变类型，不允许修改就是不可变类型(不使用=，变量引用的数据)
可变类型：列表list, 字典dict, 集合set
列表.append()
字典.pop(键)
不可变类型：int float bool str tuple
my_list = [1, 2, 3]
my_list1 = [1, 2, 3]
print('my_list:', id(my_list))
print('my_list1:', id(my_list1))
# my_list: 2470301722240
# my_list1: 2470301691776
my_list[1]=10 # 这里修改的是列表中下表为1的位置引用
print(id(my_list)) # 列表的引用没有发生变化
tuple1 = (1, 2, [3.4]) # 元组中存储的是1的地址，2的地址，和列表的地址
# 元组中的数据不能改变，是指 这三个地址不能改变
print(tuple1,id(tuple1))
tuple1[-1][0] = 10 # 修改的是列表中下表为0的位置的引用地址，列表的地址没变，元组中的内容没有变化
print(tuple1,id(tuple1))
# (1, 2, [3.4]) 1769201489536
# (1, 2, [10]) 1769201489536
14.11、面试题
题目一：
def func(list1):
list1.append(10)
my_list = [1,2]
func(my_list)
print(my_list)
# [1,2,10]
def func(list1):
list1[0] = 10 # 修改的是列表中下标为0位置的数据， 没有修改列表的引用
my_list = [1,2]
func(my_list)
print(my_list)
# [10,2]
题目二：
def func(list): # list1 =my_list 此时
list1 = [2,1] #此时，list变量的引用发生了改变，my_list的引用不会发生改变，数据不变
my_list= [1,2]
func(my_list)
print(my_list)
# [1,2]
1.只有 = 可以改变引用
2.可变类型做参数，在函数内部，如果不使用 = 直接修改形参的引用，对形参进行的数据修改会同步到实参中
题目三：
列表的+=操作
对于列表来说，+=的本质是extend操作
def func(list1) # list = my_list 引用相同
list1 += [1,2] # list1.extend([1,2]) 没有直接使用等号改变形参的引用，
# 形参的数据改动会影响实参值
my_list = ['a','b']
func(my_list)
print(my_list)
# ['a','b',1,2]
14.12、题目四 交换两个变量的值
# 方法一：常规方法 引入第三个变量
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)
14.13、组包和拆包
组包（pack）：将多个而数据值使用逗号连接的过程，组成元组
拆包（unpack):将容器中的数据值使用多个变量分别保存的过程，注意：变量的个数和容器中数据要保持一致
赋值运算符，都是先执行等号右面的代码,执行的结果，保存到左面的变量中
a=10
b=20
# 组包
c = b,a # 组包
print(type(c),c)
# 输出：<class 'tuple'> (20, 10)
# 拆包
a,b = c
print(a,b)
# 输出：20 10
# 对字典拆包，返回键
# x,y =[1,2,3] # 错误
x,y,z = [1,2,3]
print(x,y,z)
# 1 2 3
14.14、局部变量和全局变量
变量：根据变量的定义位置，分局部和全局变量
- 局部变量
局部变量：在函数内部（函数的缩进中）定义的变量，称为是局部变量
特点：
1.局部变量只能在当前函数内部使用，不能在其他函数和函数外部使用
2.在不同函数中，可以定义名字相同的局部变量，两者只见那没有影响
3.生存周期：（生命周期，作用范围）在函数被调用的时候，局部变量被创建，函数调用结束，局部变量的值被销毁（删除），不能在使用
所以函数中的局部变量的值，如果想要在函数外部使用，需要使用return关键字，将这个值进行返回
def func1():
num = 10 # num就是局部变量
print(f'func1 函数中{num}')
def func2():
num = 100 # 可以在不同函数中定义名字相同的局部变量，没有影响
print(f"func2 函数中{num}")
# print(num) # 错误
func1() # func1 函数中10
func2()
func2
函数中100
- 全局变量
定义位置：在函数定义的外面，称为全局变量
特点：
1、可以在任何函数中读取（获取）全局变量的值
2、在函数中存在和全局变量名字相同的局部变量，在函数中使用的是 局部变量的值（就近）
3、在函数内部想要修改全局变量的引用，需要使用globle关键字，对变量声明为全局变量
4、生命周期 代码执行时被创建 代码结束时被销毁
global要用就放在第一行
num1 = 10 # 全局变量
def func1():
print(f"func1 中{num1} ")
def func2():
num1 =20 # 定义局部变量
print(f"func2中 {num1}")
def func3():
global num1 # 这个函数中使用的num1 都是全局变量
num1 =30 # 修改了全局变量
print(f"func3 中 {num1}")
func1() # func1 中10
func2() # func2中 20
func1() # func1 中10
func3() # func3 中 30
func1() # func1 中30
print(num1) # 从上到下执行，若没有上面调用结果为 10
14.15、函数返回值进阶
返回值–函数返回多个数据值
函数中想要返回一个数据值，使用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
14.16、函数参数
形参的不同书写方法
-
位置传参：
在函数调用的时候，按照形参的顺序，将实参值传递给形参 -
关键字传参
在函数调用的时候，指定数据值给到那个形参 -
混合传参
1.关键字传参必须写在位置传参的后面 2.不要给一个形参传递多个数据值
def func(a, b, c):
print(f"a:{a},b={b},c:{c}")
# 位置传参
func(1, 2, 3) # a:1,b=2,c:3
# 关键字传参
func(a=2, b=3, c=1) # a:2,b=3,c:1
# 混合使用
func(1, 3, c=5) # a:1,b=3,c:5
14.17、缺省参数
缺省参数，默认参数
列表.pop() # 不写参数，删除最后一个
列表.sort(reverse = True)
1.定义方式
在函数定义的时候，给形参一个默认数据值，这个形参就变为缺省参数，
注意，缺省参数的书写要放在普通参数后面
2.特点（好处）
缺省参数，调用的时候，可以传递实参值，也可以不传递实参值
如果传参，使用的是实参 值，如果不传参，使用的是默认值
可以传参或不传参都可以
def show(name ,sex='保密'):
print(name,sex)
show('小于') #小于 保密
show('小于','男') #小于 男
14.18、多值参数（可变参数/不定长参数）
print(1)
print(1,2)
print(1,2,3)
当书写函数时，不确定参数具体个数时，可以使用不定长参数
-
不定长位置参数（不定长元组）
1.在普通参数的前面，加上一个*，这个参数就变为不定长位置参数 2.特点，这个参数可以接收任意多个 位置 传参的数据 3.数据类型，形参的类型是 元组 4.注意，不定长位置参数 要写在普通的参数的后面 5.一般写法。不定长位置参数的名字为args,即（*args) # arguments -
不定长关键字参数（不定长字典参数）
1.书写，在普通参数的前面，加上两个*，这个参数就变为不定长关键字参数 2.特点，这个形参可以接受任意多个 关键字 传参的数据 3.数据类型，形参的类型是 字典 4.注意，不定长关键字参数，要写在所以参数的最后边 5.一般写法，不定长关键字参数的名字为kwargs,即（**kwargs),keyword arguments -
完整的参数顺序
def 函数名（普通函数，*aegs,缺省参数，**kwargs): pass # 一般在使用时，使用1-2种，按照这个顺序挑选书写即可
def func(*args, **kwargs):
print(type(args), args)
print(type(kwargs), kwargs)
print('-' * 30)
func()
# <class 'tuple'> ()
# <class 'dict'> {}
func(1, 2, 3) # 位置传参，数据都给args
# <class 'tuple'> (1, 2, 3)
# <class 'dict'> {}
func(a=1,b=2,c=4) # 关键字传参，数据都给kwargs
# <class 'tuple'> ()
# <class 'dict'> {'a': 1, 'b': 2, 'c': 4}
func(1,2,3,a=1,b=3,c=2)
# <class 'tuple'> (1, 2, 3)
# <class 'dict'> {'a': 1, 'b': 3, 'c': 2}
14.19、print说明
print()
# sep='',多个位置参数之间的空格
# end='\n' 每一个print函数结束，都会打印的内容 结束符
print(1, end=' ') # 不在换行
print(2, end=' ')
print(3, end=' ')
# 输出：1 2 3
print(1, 2, 3, 4, 5, 6, sep='_')
print(1, 2, 3, 4, 5, 6, sep='*_')
# 1 2 3 1_2_3_4_5_6
# 1*_2*_3*_4*_5*_6
2314
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
