一、集合的简介和使用
1.1 集合的简介
- 集合的表现形式为 set
- 集合基本与列表一致
- 集合与列表的不同：
集合中只能存储不可变的对象(集合中元素不能为列表等可变对象)
集合中的元素是无序的（其插入顺序与存储顺序不一致）
集合中元素是不重复的
1.2 集合的创建
集合的创建共有两种方法
第一种：{元素1，元素2.。。。}
使用该方法不能创建空集合
s1 = {10,20,30,40} #创建一个非空集合
第二种：set()
set()可以把序列和字典转换为集合
使用set()将字典转换为集合时，只会包含字典中的key值
s1 = set() #创建一个空集合
s2 = set(10,20,30,40) #创建一个非空集合
1.3 访问集合元素
将集合转换为列表，在根据索引值取数
s1 = {10,20,30,40}
print(list(s1)[0]) #返回结果为40
1.4 集合的使用
-
in 和 not in 判断某元素是否为集合中的元素
s1 = {10,20,30,40} print(10 in s1) #返回值为True -
len() 获取集合中元素的个数（集合的长度）
s1 = {10,20,30,40} print(len(s1)) #返回值为4 -
add() 向集合中增加元素
s1 = {10,20,30,40} s1.add(60) s1.add(70) print(s1) #返回结果为{70, 40, 10, 20, 60, 30} -
update() 将一个集合添加到当前集合中
s1 = {10,20,30,40} s2 = set("python") s1.update(s2) print(s1) #返回结果为{'p', 'y', 'o', 40, 10, 't', 'h', 20, 'n', 30} -
pop() 随机删除一个集合中的元素，返回被删除的元素值
s1 = {10,20,30,40} s2 = set("python") s1.update(s2) result = s1.pop() print("result = ",result) #返回为被删除的元素值 result = n print(s1) #返回结果为 {'t', 'p', 40, 'h', 10, 20, 'o', 'y', 30} -
remove() 删除集合中指定的元素，没有返回值
s1 = {10,20,30,40} s2 = set("python") s1.update(s2) s1.remove(20) print(s1) #结果为{'h', 'y', 'o', 't', 'p', 40, 10, 'n', 30} -
clear() 清空当前的元素集合
s1 = {10,20,30,40} s1.clear() print(s1) #结果为set()
二、集合的基本运算
2.1 集合的交集
运算符号 &
s1 = {1,2,3,4}
s2 = {3,4,5,6}
print(s1 & s2) #返回结果为{3, 4}
2.2 集合的并集
运算符号 |
s1 = {1,2,3,4}
s2 = {3,4,5,6}
print(s1 | s2) #返回结果为{1,2,3,4,5,6}
2.3 集合的差集
运算符号 -
s1 = {1,2,3,4}
s2 = {3,4,5,6}
print(s1 - s2) #返回结果为{1,2} 在s1中不在s2中的元素
2.4 集合的亦或集
运算符号 ^
s1 = {1,2,3,4}
s2 = {3,4,5,6}
print(s1 ^ s2) #返回结果为{1,2,5,6} 在s1中不在s2中的元素或者在s2中不在s1中的元素
2.5 集合的子集或真子集
<= 检查一个集合是否是另一个集合的子集，返回结果为bool类型
< 检查一个集合是否是另一个集合的真子集，返回结果为bool类型
>= 检查一个集合是否是另一个集合的超集，返回结果为bool类型
> 检查一个集合是否是另一个集合的真超集，返回结果为bool类型
s = {1,2,3,4}
s1 = {1,2}
print(s1 < = s) #返回值为True
print(s1 < s) #返回值为True
print(s >= s1) #返回值为True
print(s > s1) #返回值为True
三、函数简介
- 函数也是一个对象，其表现形式为function
- 对象是指内存中专门存放数据的一块区域
- 函数中存放的是一些可执行代码，并可以在需要的多次调用该函数
3.1 函数的创建
函数创建的语法
def 函数名([形参1,形参2…]):
代码块
def fn():
print("haha")
print("hello")
print("这是第一个函数")
print(fn) #返回函数对象fn在内存中的地址 <function fn at 0x015B6300>
fn() #定义函数并运行后并不会立即输出结果，需要调用函数，才会输出结果
调用函数 输出结果：
haha
hello
这是第一个函数
fn为函数对象，fn()为调用函数。需要查看函数对象时使用fn，需要执行函数功能时用fn().
四、函数的参数
-
在定义函数时，可以在函数名后面的括号能传入多个形参
-
多个形参之间用“,”分隔
-
形参(形式参数)就相当于在函数内部定义多个变量，但并没有给变量赋值
-
实参(实际参数)是指如果定义函数时传入了形参，那么在调用函数时也必须传入实参
-
有几个形参就需要传递几个实参，且将实参赋值给对应位置的形参
#定义一个函数，实现任意两个数的相加 def fn(a,b): #定义了两个形参a,b print(a,"+",b,"=",a+b) fn(10,20) #传递两个实参，且a = 10,b=20，返回结果为10 + 20 = 30 fn(100,199) #返回结果为100 + 199 = 299
五、函数的传递方式
在定义函数时，我们可以给形参设置默认值。
如果调用函数时，传递了相应位置的实参，则默认值不起任何作用
如果调用函数时，没有传递该参数的实参，则默认值发挥作用
def fn(a,b,c=9): #形参c设置默认值为9
print("a=",a)
print("b=",a)
print("c=",a)
fn(1,2,3)
'''
输出结果为：
a= 1
b= 2
c= 3
'''
fn(1,2)
'''
输出结果为：
a= 1
b= 2
c= 10
'''
参数的传递方式有两种：
-
位置传参
将对应位置的实参传递给对应位置的形参 -
关键字传参
可以不按照形参定义顺序传递，而根据参数名来传递
可以和位置传参混合使用
在混合使用时，位置传参必须在关键字传参前def fn(a,b,c=9): #形参c设置默认值为9 print("a=",a) print("b=",b) print("c=",c) fn(1,2,3) #位置传参 fn(c=8,a=2,b=4) #关键字传参 fn(1,c=8,b=7) #混合使用 fn(c=8,7,a=1) #报错,位置传参必须在关键字传参前
六、实参的类型
1.函数在调用时，解释器不会检查实参的类型
2.实参可以是任意对象，甚至是函数
def fn(a):
print("a=",a)
c = 10
fn(c) #将变量c的值赋值给形参a，返回结果为a= 10
print("c=",c) #返回结果为c= 10
def fn1(a):
#在函数内部修改形参的值，不会影响其他变量（c）
a= 30
print("a=",a)
c= 10
fn1(c) #调用函数，输出a= 30
print("c=",c) #打印c= 10
def fn2(a):
#在函数内部修改可变对象的值会影响到指向该对象的变量(c)
a[0] = 10
print("a=",a,id(a))
c = [1,2,3]
fn2(c) #调用函数，输出 a= [10,2,3] 22568432
print("c=",c,id(c)) #打印 c= [10,2,3] 22568432
#要想其他变量不受影响，可以向创建其他对象的副本，然后在作为实参传递给形参
def fn2(a):
a[0] = 10
print("a=",a,id(a))
c = [1,2,3]
fn2(c.copy()) #创建c的副本，传递给形参 输出a= [10,2,3] 21836824
#fn2(c[:]) #通过列表的切片创建c的副本
print("c=",c,id(c)) #打印 c= [1,2,3] c= [1, 2, 3] 22437360
如果传递的实参为可变对象，但不希望在函数内部修改可变对象的值时影响到指向该对象的变量，可以将该对象的副本作为实参进行传递。
七、不定长参数
1.在函数定义时，可以在形参前面添加*，这样这个形参会接收所有的位置实参
2. 它会将所有的位置实参保存到一个元组当中
def fn(*a):
print("a=",a,type(a))
fn() #输出结果为 a= () <class 'tuple'>
定义一个函数，获得任意数的和
def fn(*a):
#定义一个变量，接收结果
r = 0
for n in a:
r += n
print(r)
fn(1,2,3,4,5) #输出结果 15
不定长参数可以与位置参数混合使用
def fn(b,c,*a):
print("a=",a,type(a))
print("b=",b)
print("c=",c)
fn(1,2,3,4,5,6,7)
'''
输出结果为：
a= (3, 4, 5, 6, 7) <class 'tuple'>
b= 1
c= 2
'''
不定长参数与位置参数混合使用时，只能放在最后，否则会报错。
为了解决这个问题，要求当不定长参数不在最后时，其后的参数必须使用关键字传参。
def fn(*b,c,a):
print("a=",a)
print("b=",b)
print("c=",c)
fn(a =1,c=2,3,4,5,6,7)
'''
输出结果为：
a= 1
b= (3,4,5,6,7)
c= 2
'''
当函数的形参以*作为第一个参数时，要求其后所有的参数的传递方式均为关键字传参。
def fn(**a):
print("a=",a)
fn(a =1,c=2,b=4,e=5)
**形参用来接收多个使用关键字传参的实参，且必须放在最后。
**形参将多个关键字参数保存在一个字典中，字典的key就是参数名，字典的value就是参数的值
**形参只能有一个
def fn(b,c,**a):
print("a=",a)
print("b=",b)
print("c=",c)
fn(b =1,c=2,a=3,e=4,f=5,g=6,d=7)
'''
输出结果为：
a= {'a': 3, 'e': 4, 'f': 5, 'g': 6, 'd': 7}
b= 1
c= 2
'''
*形参用来接收多个位置传参，不一定必须放在最后，但其之后的参数必须采用关键字传参。
**形参用来接收多个关键字传参，且只能放在最后。
八、参数解包
当传递的实参类型为序列(元组、列表)或者字典时，可以在实参前加一个*或者**，实现参数的解包。
def fn(a,b,c):
print("a=",a)
print("b=",b)
print("c=",c)
t = (1,2,3)
#要求序列中的元素个数与形参的个数相等
fn(*t) #序列实参的解包
'''
输出结果为：
a= 1
b= 2
c= 3
'''
def fn(a,b,c):
print("a=",a)
print("b=",b)
print("c=",c)
#要求字典中的key必须与形参名一致，且元素个数等于形参个数
d = {"a":100,"b":200,"c":300}
fn(**d) #字典的解包
'''
输出结果为：
a= 100
b= 200
c= 300
'''
扫一扫
472
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
