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