集合（set）
集合和列表基本一致
集合和列表的不同点
- 集合只能存储不可变对象
- 集合中存储的对象是无序的
- 集合中不能出现重复的元素
创建集合
1. {}
s = {1, 2, 3, 4, 5, 6}
print(s,type(s))
# {1, 2, 3, 4, 5, 6} <class 'set'>
s = {[1, 2, 3], [4, 5, 6]}
print(s)
# TypeError: unhashable type: 'list'
# 集合只能存储不可变对象，列表是可变对象
s = {1, 2, 3, 4, 5, 6}
s1 = {7, 1, 2, 3, 4, 5, 6}
s2 = {1, 2, 3, 4, 5, 6, 6, 1, 2, 3}
print(s)
print(s1)
print(s2)
# {1, 2, 3, 4, 5, 6}
# {1, 2, 3, 4, 5, 6, 7} 集合中存储的对象是无序的
# {1, 2, 3, 4, 5, 6} 集合中的元素不可重复
- set()
s = set() # 创建空集合的方式
# s1 = set(1, 2, 3, 4, 5, 6) # 会报错，set()函数可以创建一个无序不重复的元素集，这个函数至多可以传一个参数
s2 = set('python') # str也是序列
s3 = set([1, 2, 3, 4, 5, 6]) # 将列表转换为集合
s4 = set({'a':1, 'b':2}) # 将字典转换成集合，只会包含字典的键
# s1[2] = 30 会报错，集合无序，如果想使用该方法，通过list将集合转换为列表
# out:
# set()
# {'n', 't', 'p', 'y', 'h', 'o'}
# {1, 2, 3, 4, 5, 6}
# {'a', 'b'}
集合的使用
in¬ in
使用in 和 not in 来检查集合中的元素，结果会返回一个bool值
s = {'a', 'b', 1, 2, 3}
print('b' in s)
# True
len()
获取集合中元素的个数（长度）
s = {'a', 'b', 1, 2, 3}
print(len(s))
# 5
add()
可以向集合中添加元素
s = {'a', 'b', 1, 2, 3}
s.add(4)
print(s)
updata
讲一个集合中的元素添加到当前集合中
s = {'a', 'b', 1, 2, 3}
s2 = {'miss', 'you'}
s.updata(s2)
print(s2)
# {1, 'b', 3, 2, 4, 'a'}
pop
随机删除集合中的一个元素，返回被删除的元素
s = {'a', 'b', 1, 2, 3}
info = s.pop()
print(info)
print(s)
# 1
# {2, 3, 'b', 'a'}
remove
删除集合中指定的元素
s = {'a', 'b', 1, 2, 3}
info = s.remove(1)
print(info)
print(s)
# None
# {2, 3, 'a', 'b'}
clear
清空集合
s = {'a', 'b', 1, 2, 3}
s.clear()
print(s)
# set()
集合的运算
&交集运算，|并集运算，-差集运算，^亦或集
s = {1, 2, 3, 4, 5}
s2 = {3, 4, 5, 6, 7}
info = s & s2 # 交集运算
print(info)
union = s | s2 # 并集运算
print(union)
diff = s - s2 # 差集运算
diff2 = s2 - s
print(diff)
print(diff2)
or_set = s ^ s2 # 亦或集
print(or_set)
# {3, 4, 5}
# {1, 2, 3, 4, 5, 6, 7}
# {1, 2}
# {6, 7}
# {1, 2, 6, 7}
<= 包含于
检查一个集合是否是另一个集合的子集，结果返回boll值
<
检查一个集合是否是另一个集合的真子集
如果集合A是集合B的子集，并且集合B不是集合A的子集，那么集合A叫做集合B的真子集（proper subset）。如果A包含于B,且A不等于B,就说集合A是集合B的真子集。
a = {1, 2, 3}
b = {1, 2, 3, 4, 5}
info = a <= b
print(info)
c = {1, 2, 3} <= {1, 2, 3}
print(c)
d = {1, 2, 3} < {1, 2, 3}
print(d)
# True
# True
# False
>=
超集 检查一个集合是否是另一个集合的超集
>
真超集 检查一个集合是否是另一个集合的真超集
a = {1, 2, 3}
b = {1, 2, 3, 4, 5}
info = b >= a
print(info)
c = {1, 2, 3} >= {1, 2, 3}
print(c)
d = {1, 2, 3} > {1, 2, 3}
print(d)
True
True
False
函数(function)
简介
- 函数也是一个对象
- 对象是内存中专门用来存储数据的一块区域
- 函数用来保存一些可以执行的代码，并且可以再需要的时候对这些语句多次调用
创建函数
def 函数名([形参1, 形参2, 形参3....]):
代码块
def first():
print('hello function')
print(first)
# <function first at 0x0000027D73AA67B8>
first()
# hello function
0x0000027D73AA67B8 是一串16进制数据，函数在内存中也是已数字的方式存储的
first是函数对象 first()调用函数
函数的参数
- 在定义函数的时候，可以在函数名后面的括号里面定义数量不等的形参
- 多个形参用逗号隔开
- 形参（形式参数），定义形参就是相对于在函数内部定义了变量，但没有赋值
- 实参（实际参数），函数定义时指定了形参，那么调用函数的时候也必须传递实参
- 实参将会赋值给对应的形参，有几个形参就传几个实参，否则报错
定义一个函数实现任意两个数的和
def sum(a,b):
print(a, '+', b,'=', a+b)
sum(12,16)
# 12 + 16 = 28
函数的传递方式
- 位置传参
位置传参就是对应位置的实参传递给对应位置的形参
- 定义形参的时候我们可以为形参指定一个默认值
- 指定了默认值以后，如果用户传递了参数，默认值是不会有任何作用的
- 如果用户没有传递实参，则默认值会生效
def fn(a, b, c=10):
print('a =',a)
print('b =',b)
print('c =',c)
fn(1， 2)
fn(1, 2, 3)
# a = 1
# b = 2
# c = 10
# a = 1
# b = 2
# c = 3
- 关键字传参
- 可以不按照形参定义的顺序去传参，而是根据参数名来传递参数
- 可与位置传参混合使用,但是位置参数必须写在关键字参数前
def fn(a, b, c=10):
print('a =',a)
print('b =',b)
print('c =',c)
fn(b=1, c=2, a=3)
fn(1, 2, c=9)
# a = 3
# b = 1
# c = 2
# a = 1
# b = 2
# c = 9
实参的类型
- 函数在调用的时候，解释器不会检查实参的类型
- 实参的类型可以是任意的对象
def fn(a, b):
print(a + b)
fn(1, 1)
# 2
在参数中对形参重新赋值不会影响其他的变量
def fn(a):
a = 10
print('a = ', a)
c = 20
fn(c)
print('c=', c)
# a = 10
# c= 20
如果形参在执行的时候，当我们通过形参去修改对象时，会影响到指向对象的变量
def fn(a):
a[0] = 5
print('a = ', a)
c = [1, 2, 3]
fn(c)
print('c=', c)
# a = [5, 2, 3]
# c= [5, 2, 3]
若我不想影响指向对象的变量
def fn(a):
a[0] = 5
print('a = ', a， id(a))
c = [1, 2, 3]
fn(c.copy())
print('c=', c, id(c))
总结：
如果你向函数内部传递一个参数而不影响函数外部，你需要传入一个可变序列的副本，不可变的不需要担心影响外部。
不定长参数
*参数
用于处理位置参数
装包
在定义函数的时候，可以在形参前面加上一个*，这样这个形参将会获取所有的参数，且保存到一个元组当中
def fn(*a):
print('a=', a, type(a))
fn()
fn(1, 2, 3, 4)
# a= () <class 'tuple'> 若什么都不传，则产生一个空元组
# fn(1, 2, 3, 4)
定义一个函数实现任意数的和
def sum(*a):
info = 0 # 定义一个变量保存结果
for n in a:
info += n
print(info)
sum(1, 2, 3, 4, 5, 6)
# 21
可变长参数不是必须写到最后，但需要注意的是，后的参数，必须是关键字传参，否则，所有多余的元素会已元组的形式存储在b中，c没有实参
def sum(a, *b, c=6):
print(a)
print(b)
print(c)
sum(1, 2, 3, 4, 5, 6)
# 1
# (2, 3, 4, 5, 6)
# 6
若果在形参的开头直接写一个*，但是所有的参数要以关键字的形式来传递
def fn(*, a, b, c):
print(a)
print(b)
print(c)
fn(a=6,b=7,c=8)
**形参
- 用于处理关键字参数
- 可以接受其他的关键字参数，它会将这些参数统一保存到一个字典当中，字典当中的key是参数的名字，字典中的value是参数的值
- 只能有一个，并且必须写在最后
def fn(b, c, **a):
print('a=', a)
fn(a = 4, b = 1, c = 2, d = 5, e = 6)
# a= {'a': 4, 'd': 5, 'e': 6}
# b= 1
# c= 2
参数解包
- 解包时，序列中的元素的个数必须和形参的个数一致
def fn(a, b, c):
print('a =', a)
print('b =', b)
print('c =', c)
t = (1, 2, 3)
d = {'a':10, 'b':20, 'c':30}
fn(*t)
fn(**d)
# a = 1
# b = 2
# c = 3
# a = 10
# b = 20
# c = 30
字典解包
**d
156
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
