前端学python（4）

1.集合

# 使用 {} 来创建集合
# s = {10,3,5,1,2,1,2,3,1,1,1,1} # <class 'set'>
# print(s , type(s))    {1, 2, 3, 5, 10} <class 'set'>
# s = {[1,2,3],[4,6,7]} TypeError: unhashable type: 'list'
# 使用 set() 函数来创建集合
#s = set() # 空集合      这里注意！！！！s = {}这是创建空字典
# 可以通过set()来将序列和字典转换为集合
# s = set([1,2,3,4,5,1,1,2,3,4,5])       {1, 2, 3, 4, 5}
# s = set('hello')     {'o', 'l', 'h', 'e'}
# s = set({'a':1,'b':2,'c':3}) # 使用set()将字典转换为集合时，只会包含字典中的键    {'b', 'c', 'a'}
 
# 创建集合
# s = {'a' , 'b' , 1 , 2 , 3 , 1}
# 使用in和not in来检查集合中的元素
# print('c' in s)    False

# 使用len()来获取集合中元素的数量
# print(len(s))   5    会忽略到重复的哦

# add() 向集合中添加元素
# s.add(10)
# s.add(30)   {1, 2, 3, 10, 'b', 'a', 30}

# update() 将一个集合中的元素添加到当前集合中
#   update()可以传递序列或字典作为参数，字典只会使用键
# s2 = set('hello')
# s.update(s2)          {1, 2, 3, 'a', 'h', 'b', 'e', 'o', 'l'}
# s.update((10,20,30,40,50))   {1, 2, 3, 40, 10, 50, 'a', 20, 'b', 30}
# s.update({10:'ab',20:'bc',100:'cd',1000:'ef'})      {1, 2, 3, 100, 1000, 10, 'a', 20, 'b'}

# {1, 2, 3, 100, 40, 'o', 10, 1000, 'a', 'h', 'b', 'l', 20, 50, 'e', 30}
# pop()随机删除并返回一个集合中的元素
# result = s.pop()      随机删，不一定是第一个，看着是从前往后删除  pop返回值都是那个被删的值

# remove()删除集合中的指定元素
# s.remove(1)    {2, 3, 'b', 'a'}    如果没会报错哦
# s.remove(1000)

# clear()清空集合
# s.clear()    set()

# copy()对集合进行浅复制
# result = s.copy()     {1, 2, 3, 'a', 'b'}

2.集合运算

# 在对集合做运算时，不会影响原来的集合，而是返回一个运算结果
# 创建两个集合
s = {1,2,3,4,5}
s2 = {3,4,5,6,7}

# & 交集运算
result = s & s2 # {3, 4, 5}

# | 并集运算
result = s | s2 # {1,2,3,4,5,6,7}

# - 差集
result = s - s2 # {1, 2}

# ^ 异或集 获取只在一个集合中出现的元素
result = s ^ s2 # {1, 2, 6, 7}

# <= 检查一个集合是否是另一个集合的子集
# 如果a集合中的元素全部都在b集合中出现，那么a集合就是b集合的子集，b集合是a集合超集
a = {1,2,3}
b = {1,2,3,4,5}

result = a <= b # True
result = {1,2,3} <= {1,2,3} # True
result = {1,2,3,4,5} <= {1,2,3} # False

# < 检查一个集合是否是另一个集合的真子集
# 如果超集b中含有子集a中所有元素，并且b中还有a中没有的元素，则b就是a的真超集，a是b的真子集
result = {1,2,3} < {1,2,3} # False
result = {1,2,3} < {1,2,3,4,5} # True

# >= 检查一个集合是否是另一个的超集
# > 检查一个集合是否是另一个的真超集
print('result =',result)

3.函数 不定长参数

# 定义一个函数，可以求任意个数字的和
def sum(*nums):
    # 定义一个变量，来保存结果
    result = 0
    # 遍历元组，并将元组中的数进行累加
    for n in nums :
        result += n
    print(result)
sum(1,2)

# sum(123,456,789,10,20,30,40)

# 在定义函数时，可以在形参前边加上一个*，这样这个形参将会获取到所有的实参
# 它将会将所有的实参保存到一个元组中
# a,b,*c = (1,2,3,4,5,6)

# *a会接受所有的位置实参，并且会将这些实参统一保存到一个元组中（装包）
# def fn(*a):
#     print("a =",a,type(a))   a = (1, 2) <class 'tuple'>
# fn(1,2)

# fn(1,2,3,4,5)
# 带星号的形参只能有一个
# 带星号的参数，可以和其他参数配合使用
# 第一个参数给a，第二个参数给b，剩下的都保存到c的元组中
# def fn2(a,b,*c):
#     print('a =',a)  1
#     print('b =',b)  2 
#     print('c =',c)  (3, 3, 3)
# fn2(1,2,3,3,3)

# 可变参数不是必须写在最后，但是注意，带*的参数后的所有参数，必须以关键字参数的形式传递
# 第一个参数给a，剩下的位置参数给b的元组，c必须使用关键字参数
# def fn2(a,*b,c):
#     print('a =',a)   1
#     print('b =',b)  (2,2,2,3)
#     print('c =',c)    3
# fn2(1, 2, 2, 2, 3, c=3)

# 所有的位置参数都给a，b和c必须使用关键字参数
# def fn2(*a,b,c):
#     print('a =',a)   a = (1, 2, 3)
#     print('b =',b)    3
#     print('c =',c)    3
# fn2(1, 2, 3, b=3, c=3)

# 如果在形参的开头直接写一个*,则要求我们的所有的参数必须以关键字参数的形式传递
# def fn2(*,a,b,c):
#     print('a =',a)    3
#     print('b =',b)   4
#     print('c =',c)    5
# fn2(a=3,b=4,c=5)

# *形参只能接收位置参数，而不能接收关键字参数
# def fn3(*a) :
#     print('a =',a)    a = (1, 22, 3)
# fn3(1,22,3)
# **形参可以接收其他的关键字参数，它会将这些参数统一保存到一个字典中
#   字典的key就是参数的名字，字典的value就是参数的值
# **形参只能有一个，并且必须写在所有参数的最后
# def fn3(b,c,**a) :
#     print('a =',a,type(a))   a = {'d': 2, 'e': 10, 'f': 20} <class 'dict'
#     print('b =',b)      b = 1
#     print('c =',c)      c = 3
# fn3(b=1,d=2,c=3,e=10,f=20)

# 参数的解包（拆包）
# def fn4(a,b,c):
#     print('a =',a)  #10 
#     print('b =',b)   #20
#     print('c =',c)    #30
# # 创建一个元组
# t = (10,20,30)
# fn4(*t) 
# # 传递实参时，也可以在序列类型的参数前添加星号，这样他会自动将序列中的元素依次作为参数传递
# # 这里要求序列中元素的个数必须和形参的个数的一致
# # fn4(*t)    

# # 创建一个字典
# d = {'a':100,'b':200,'c':300}          100       200      300
# # 通过 **来对一个字典进行解包操作
# fn4(**d)

4.文档字符串

# help()是Python中的内置函数
# # 通过help()函数可以查询python中的函数的用法
# # 语法：help(函数对象)
# # help(print) # 获取print()函数的使用说明

# # 文档字符串（doc str）
# # 在定义函数时，可以在函数内部编写文档字符串，文档字符串就是函数的说明
# #   当我们编写了文档字符串时，就可以通过help()函数来查看函数的说明
# #   文档字符串非常简单，其实直接在函数的第一行写一个字符串就是文档字符串
# def fn(a:int,b:bool,c:str='hello') -> int:
#     '''
#     这是一个文档字符串的示例

#     函数的作用：。。。。。
#     函数的参数：
#         a，作用，类型，默认值。。。。
#         b，作用，类型，默认值。。。。
#         c，作用，类型，默认值。。。。
#     '''
#     return 10

# help(fn)  这是一个文档字符串的示例

#     函数的作用：。。。。。
#     函数的参数：
#         a，作用，类型，默认值。。。。
#         b，作用，类型，默认值。。。。
#         c，作用，类型，默认值。。。。