python第九课 集合和函数

一、集合的基本概念

集合的表现形式：set
集合和列表基本一致
不同：
1、集合只能存储不可变对象
2、集合中存储的对象是无序的
3、几何中不能出现重复的元素

##创建集合
#使用{}来创建
s = {10, 1, 5, 8, 5, 7, 6}
print(s, type(s))

>>> {1, 5, 6, 7, 8, 10} <class 'set'>

#使用set()函数创建 //set()函数可以把序列和字典转换成集合
#集合中只能是不可变对象，即元素不能是列表

s = set({1, 2})
print(s, type(s))
s = set([1, 4, 5, 8, 4, 1])
print(s, type(s))
s = set('hello world')
print(s, type(s))
#使用set()函数对字典进行转换时，只会包含字典中的键
se ={
    'name': '天问',
    'number' : '1',
    'usr' : '秦始皇'
} 
s = set(se)
print(s, type(se), type(s))

>>> {1, 2} <class 'set'>
>>> {8, 1, 4, 5} <class 'set'>
>>> {'h', 'e', 'w', 'o', 'd', 'r', ' ', 'l'} <class 'set'>
>>> {'usr', 'name', 'number'} <class 'dict'> <class 'set'>

二、集合的使用

# in 和 not in 来检查集合中含有的元素，结果返回bool值
s = {1, 4, 5, 8, 4, 1}
print(1 in s)


#len（）函数获取集合元素的个数（长度）
print(len(s))

#add()向集合中添加元素
s.add(7)
s.add('k')
print(s)
#update()将集合中的元素添加到当前集合中
s1 = set('hello')
s.update(s1)
print(s)
#pop()随机删除集合中的一个元素
#remove()删除指定元素
#clear()清空

>>> True
>>> 4
>>> {1, 4, 5, 7, 8, 'k'}

三、集合的运算

集合在进行运算时，通常是在做交集并集类的运算而不是加减类的运算。

s1 = {1, 2, 3, 5, 4}
s2 = {2, 5, 7, 6, 8}
##交集运算 &
result = s1 & s2
print(result)
##并集运算 “|” 
result2 = s1 | s2
print(result2)
##差集运算  就是在被减集上去掉两者的交集
result3 = s1 - s2
print(result3)
##亦或运算 ' ^ '  去除交集之后的并集
result4 = s1 ^ s2
print(result4)

>>> {2, 5}
>>> {1, 2, 3, 4, 5, 6, 7, 8}
>>> {1, 3, 4}
>>> {1, 3, 4, 6, 7, 8}

此外，此外还有子集的判断。如下

# <= 检查一个集合是否是另一个集合的子集，结果返回bool值
a = {1, 2, 3}
b = {1, 2, 3, 4, 5}
print(a <= b)
#< 检查一个集合是不是另一个集合的真子集
print(a < b)
# >= 检查一个集合是否是另一个集合的超集，结果返回bool值
# > 检查一个集合是不是另一个集合的真超集

>>> True
>>> True

四、函数

函数也是一个对象 function
#对象是内存在中专门用来存储数据的一块区域

#创建
#语法：
def 函数名(形参1, 形参2， …):

代码块

def fun1(x):
    y = 3 * x + 5
    return y

五、函数的参数

#在定义函数的时候，可以在函数名后面的括号里面定义数量不等是形参
#多个形参之间用“，”隔开
#形参 ：形式参数，没有真正的赋值
#实参：实际参数，在调用函数时使用需要跟定义函数时的形参对应上

六、函数的主要传递方式

定义函数的时候我们可以为形参定义一个默认值

def funct(a, b, c = 10):
    return(a + b + c)


print(funct(1,1))
print(funct(1,1,1))

>>> 12
>>> 3

参数的传递方式

#位置传参：按照形参位置在调用函数时根据位置传参
print(funct(1, 2, 3))
#关键字传参：按照形参进行传参
print(funct(a = 1, c = 6,  b = 2))
#上述两者可以混合使用
print(funct(1, 2, c = 3))

>>> 6
>>> 9
>>> 6

ps:混合使用时位置传参写道关键字传参前面

七、参数的类型

#函数再调用的时候，解释权不会检查实参的类型
#实参的类型可以是任意对象

形参在执行 的过程中当我们通过形参去改对象时会影响到指向该对象的变量

d = [1, 2, 3]
def f(a):
    a[0] = 10
    print(a)
f(d)
print(d)

>>> [10, 2, 3]
>>> [10, 2, 3]

通过浅复制，可以解决这个问题

d = [1, 2, 3]
def f(a):
    a = a.copy()
    a[0] = 10
    print(a)
f(d)
print(d)

>>> [10, 2, 3]
>>> [1, 2, 3]

八、不定长参数

位置参数’ * ’

#定义一个函数来实现任意数的和
#在定义函数的时候在形参前面加“*”这样这个实参将会获取到所有的实参
#并且将所有的实参保存到一个元组中

def fu(a, b, *c):
    print(a)
    print(b)
    print(c)
fu(1,2,3,4,5)

>>> 1
>>> 2
>>> (3, 4, 5)

对于不定长参数的传参

def fu(a, *b, c):#加在第b上在传参时会直接被b所包含
    print(a)
    print(b)
    print(c)
fu(1,2,3,4,5)#使用该方法传参会报错如下
fu(1,2,3,4,c=5)#传参时需要指定c的值

>>> TypeError: fu() missing 1 required keyword-only argument: 'c'
>>> 1
>>> (2, 3, 4)
>>> 5

特殊传参要求：

#在形参前面直接写“*”，表明该函数在调用时只能使用关键字传参
def fu(*，a, b, c):
    print(a)
    print(b)
    print(c)
fu(a = 1, c = 2, b = 3)

>>> 1
>>> 3
>>> 2

关键字参数’ ** ’

“ ** ”形参可以接收其他的关键字参数，他会将这些参数统一保存到一个字典当中

def fu(**a):
    print(a)
fu(a = 1, c = 3, d = 5)

>>> {'a': 1, 'c': 3, 'd': 5}

“ ** ”形参只能有一个，而且必须写最后一个参数上

def fu(a, b, **c):
    print(a)
    print(b)
    print(c)
fu(a=1,c=2,s=3,e=4,b=5)

>>> 1
>>> 5
>>> {'c': 2, 's': 3, 'e': 4}

九、参数的解包

#序列在传递的过程中加 * 会自动将序列按照参数的方式进行传递
#要求序列中的元素个数必须和形参的个数一致

def fu(a, b, c):
    print(a)
    print(b)
    print(c)
t = (4, 5, 6)
fu(*t)

>>> 4
>>> 5
>>> 6

使用 ** 对字典进行解包

d = {
    'a': 10,
    'b': 20,
    'c': 1
}
fu(**d)

>>> 10
>>> 20
>>> 1