旅途——Python函数与集合

集合

简介

• 集合表现形式set 集合和列表非常相似
• 不同点
  • 集合只能存储不可变对象
  • 集合中存储的对象是无序的
  • 集合不能出现重复元素
  • 使用{}来创建集合
  • 可以通过set()来将序列和字典转换成集合
  • len() 使用len()来获取集合中元素的数量
  • add()像集合中添加元素
  • update()将一个集合中的元素添加到另一个集合当中
  • pop()随机删除集合中的一个元素一般是删除最后一个元素
  • remove() 删除集合中指定的元素
  • clear() 清空集合

运算

#交集运算 &
s1 & s2
print(s1 &s2)

# 并集 ｜
s1= {1,2,3,4,5}
s2={3,4,5,6,7}
print(s1｜s2)

# 差集运算 -

s1= {1,2,3,4,5}
s2={3,4,5,6,7}
print(s1 - s2) #s2中没有的元素
print(s2 - s1) #s1中没有的元素

# 异或集 ^
s1= {1,2,3,4,5}
s2={3,4,5,6,7}
print(s1 - s2) # s1、s2除去共有的

# <= :检查一个集合是否是另一个集合的子集

s1 = {1,2,3,4}
s2 = {1,2,3}
result = s2 <= s1
print(result)


# < :检查一个集合是否是另一个集合的真子集

s1 = {1,2,3,4}
s2 = {1,2,3}
result = s2 < s1
print(result)

# >= :检查一个集合是否是另一个集合的超集

# > :检查一个集合是否是另一个集合的真超集

函数

简介

• 函数也是一个对象
• 函数用来保存一些可执行的代码，并且可以在需要时，对这些语句进行多次调用

语法
def 函数名([形参1,形参2,形参3....]):
    代码块

注意：
函数名必须符合标识符的规范(可以包含字母、数字、下划线但是不能以数字开头)
print是函数对象 print()是调用函数

def Mine():
    print('我的第一个函数')

print(Mine) # 打印函数
Mine() #调用函数，实现功能

# Mine 是函数对象
# Mine（） 调用函数

参数

形参和实参

• 形参(形式参数) 定义形参就相当于在函数内部声明了变量，但是并不是赋值
• 实参(实际参数)指定了形参，那么在调用函数时必须传递实参，实参将会赋值给对应的形参，简单来说有几个形参就要有几个实参

函数的传递方式

• 定义形参时,可以为形参指定默认值。指定了默认值以后，如果用户传递了参数则默认值不会生效。如果用户没有传递，则默认值就会生效
• 位置参数：位置参数就是将对应位置的实参赋值给对应位置的形参
• 关键字参数 : 关键字参数可以不按照形参定义的顺序去传递，而根据参数名进行传递
• 混合使用位置参数和关键字参数的时候必须将位置参数写到关键字参数前面去

# 定义一个函数求任意两个数的和

方法1
def addition():
    a = int(input('输入第一个数：'))
    b = int(input('输入第二个数：'))
    print(a+b)

addition()

#定义函数的时候，可以在（）里面定义数量不等的形参，有几个形参，就有就几个实参
方法2
def addition(a,b):
    print('a=',a)
    print('b=',b)
    print(a+b)

addition(2,3) #a = 2,b =3。对应位置传递

函数的传递方式：
定义形参时，可以指定默认值
当用户没有传递参数则默认值生效，传递则不生效

• 位置传参：第一个形参给第一个形参，以此类推

def fn(a,b=4,c=20):
    print('a=',a)
    print('b=', b)
    print('c=', c)
fn(1,2)
fn(1,2,3)

• 关键字传参：可以不按照形参定义顺序传递参数

def fn(a,b=4,c=20):
    print('a=',a)
    print('b=', b)
    print('c=', c)
fn(c=1,a=2,b=3)

• 两种传参方式可以混合使用，但是此时必须注意：关键字传参不可以在位置传参前面

def fn(a,b=4,c=20):
    print('a=',a)
    print('b=', b)
    print('c=', c)
fn(2,c=50)

#实参可以是各种类型

def fn(a,b=4,c=20):
    print('a=',a)
    print('b=', b)
    print('c=', c)
fn(c=1,a=2,b=3)

def fn2(a):
    print('a=',a)
b=123
fn2(b)
b=False
fn2(b)
b='123e'
fn2(b)
fn2(fn)


def fn2(a):
    # 在函数中对形参赋值，不会影响其他变量
    a= 20
    print('a=',a)
b=123
fn2(b)
print('b=',b)

def fn2(a):
    # 当a是一个列表时，修改列表中的元素，通过形参修改时，会修改所有指向该形参的变量
    a[0]= 20
    print('a=',id(a))
b=[1,2,3]
fn2(b.copy())#副本：此时两个没有什么影响copy()
print('b=',id(b))
fn2(b) #这时候有影响
print('b=',id(b))

不定长参数

• 定义函数时，可以在形参前面加一个*,这样这个形参可以获取到所有的实参，它会将所有的实参保存到一个元组中
• 带*号的形参只能有一个，可以和其他参数配合使用
• *形参只能接受位置参数，不能接受关键字参数
• **形参可以接收其他的关键字参数,它会将这些参数统一保存到字典当中。字典的key就是参数的名字,字典的value就是参数的值
• **形参只有一个，并且必须写在所有参数的后面

#定一个函数求任意个数参数的函数

def addition(*a):
    print('a=',a,type(a))
    s = 0
    #遍历元组，获得数据，将元素相加
    for i in a:
        s += i
    print(s)


addition(1,2,3,4,5,6,7)

def fn2(a,b,*c):
    print('a=', a)
    print('b=', b)
    print('c=', c)
fn2(1,2,3,4,5)

def fn2(a,*b,c):#只有这种写法*b可以在中间
    print('a=', a)
    print('b=', b)
    print('c=', c)
fn2(1,2,3,4,c=5)

def fn2(*a,b,c):#只有这种写法*a可以在开头
    print('a=', a)
    print('b=', b)
    print('c=', c)
fn2(1,2,3,b=4,c=5)

#不定长参数不一定都要在最后面，*后的参数，必须用关键字传参来传递
#不定长参数不接受关键字参数此时需要**b，储存在字典里面:只能在最后
字典的Key是参数的名字，value是参数的值


# *a处理的是位置参数
#**a处理关键字参数

def fn3(**a):
    print('a=',a)

fn3(a=3,b=4,c=5)

参数的解包

• 传递实参时，也可以在序列类型的参数前添加星号，这样它会自动的将序列中元素依次作为参数传递
• 要求序列中的元素的个数必须和形参的个数一致

def fn2(a,b,c):
    print('a=', a)
    print('b=', b)
    print('c=', c)

#创建一个元组
t = (20,30,40)
fn2(t[0],t[1],t[2])#普通操作
#传递实参的时候，也可以在序列类型的前面加*，这样子会自动将序列的元素作为参数传递
#但是，必须要求序列元素和形参=个数保持一致
fn2(*t)

#创建一个字典
s = {'a':1,'b':2,'c':3}
#通过**对字典解包
fn2(**s)