基础九：集合和函数一

一 集合的简介

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

创建集合

# 使用{}来创建集合

s = {10,1,2,3,4,1,1,1,2,2}
print(s,type(s))  # {1, 2, 3, 4, 10} <class 'set'>


# set()函数来创建集合
# set()函数可以把序列和字典转换成集合
s1 = set([10,1,2,3,4,1,1,1,2,2]) #list
s2 = set('python') #str
s3 = set({'a':1,'b':2}) # 使用set()函数将字典转换为集合的时候，只会包含字典的键
# s = {[1,2,3],[4,5,6]} #TypeError: unhashable type: 'list'
s = {} #{} <class 'dict'>
print(s,type(s))
print('s1',s1,type(s1)) #s1 {1, 2, 3, 4, 10} <class 'set'>
print('s2',s2,type(s2)) #s2 {'y', 'p', 't', 'o', 'n', 'h'} <class 'set'>
print('s3',s3,type(s3)) #s3 {'a', 'b'} <class 'set'>


s = {'a','b',1,2,3}

print(s, type(s)) #{1, 2, 3, 'a', 'b'} <class 'set'>
print(list(s)[0]) #1

集合的使用

# in 和 not in 来检查集合中的元素，结果会返回一个bool值

s = {'a','b',1,2,3}

# len() 获取集合中元素的个数(长度)
print(len(s))  #5

# add()可以向集合中添加元素
s.add(6)
s.add(7)
print('b' in s) #True

# update() 将一个集合中的元素添加到当前集合中
s = {'a','b',1,2,3}
s2 = set('python')
s.update(s2)
print(s) #{1, 'b', 3, 2, 't', 'y', 'h', 'p', 'a', 'n', 'o'}

# pop() 随机删除集合中的一个元素 ,返回被删除的元素

result = s.pop() # {2, 3, 'y', 'b', 'p', 'o', 'n', 'a', 't', 'h'}
print(result) #1

# remove() 删除集合中指定的元素
# s.remove(1) #因为1已经被删除，所以此时再删除1会报错
print(s)

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

二 集合的运算

s = {1,2,3,4,5}
s2 = {3,4,5,6,7}

# & 交集运算

result = s & s2
print(result) #{3, 4, 5}

# | 并集运算

result = s | s2
print(result) #{1, 2, 3, 4, 5, 6, 7}

# - 差集运算
result = s - s2 # {1,2}
print(result)

result = s2 - s # {6,7}
print(result)


# ^ 亦或集
result = s2 ^ s
print(result) #{1, 2, 6, 7}

# <= 检查一个集合是否是另一个集合的子集 结果返回一个bool值
# < 检查一个集合是否是另一个集合的真子集

# >=  检查一个集合是否是另一个集合的超集
# >   检查一个集合是否是另一个集合的真超集
a = {1,2,3}
b = {1,2,3,4,5}
result = a <= b #True
result = {1,2,3} < {1,2,3} # False
print(a,b,'result =',result) #{1, 2, 3} {1, 2, 3, 4, 5} result = False

三 函数的简介 function

函数也是一个对象
对象是内存中专门用来存储数据的一块区域
函数用来保存一些可以执行的代码，并且可以在需要的时候对这些语句多次调用

创建函数

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

#
def fn():

    print('这是我第一个函数')
    print('abc','bcd')
    print('python')
    print('hahaha')
# 打印fn
print(fn) #<function fn at 0x0000017B412A69D8>
print(fn())
'''
这是我第一个函数
abc bcd
python
hahaha
None
'''
# fn是函数对象 fn()调用函数

四 函数的参数

在定义函数的时候，可以在函数名后面的括号里面定义数量不等的形参
多个形参我们用,号隔开
形参(形式参数)定义形参就是相当于在函数内部定义了变量，但是并没有赋值
实参(实际参数)函数定义时指定了形参，那么调用函数的时候也必须传递实参
实参将会赋值给对应的形参，有几个形参就传几个实参
定义一个函数来实现任意两个数的和

def s():
    a = 1
    b = 2
    print(a+b)

s() #3


def fn2(a,b):
    # a =None
    # b = None
    # print('a =',a)
    # print('b =',b)
    print(a,'+',b,'=',a+b)

fn2(10,11) #10 + 11 = 21
fn2(100,200) #100 + 200 = 300

五 函数的传递方式

定义形参的时候我们可以为形参指定一个默认值
指定了默认值以后，如果用户传递了参数，默认值是不会有任何作用的
如果用户没有传递，则默认值会生效

def fn(a = 5,b = 8,c = 10):
    print('a =', a)
    print('b =', b)
    print('c =', c)

fn(1,2,3)
'''
a = 1
b = 2
c = 3
'''
fn(1,2)
'''
a = 1
b = 2
c = 10
'''
fn()
'''
a = 5
b = 8
c = 10
'''

# 函数的传递方式

# 第一个是 位置传参
# 位置传参就是将对应位置的实参传递给对应位置的形参

# 第二个是 关键字传参
# 关键字传参可以不按照形参定义的顺序去传参，而根据参数名来传递参数
def fn(a = 5,b = 8,c = 10):
    print('a =', a)
    print('b =', b)
    print('c =', c)

fn(b=1,c=2,a=3)
'''
a = 3
b = 1
c = 2
'''
# 位置传参也可以和关键字传参混合使用
fn(1,c=10)
'''
a = 1
b = 8
c = 10
'''
# 混合使用的时候，必须将位置参数写到关键字参数前面,否则就会报错
# fn(c=10,1)

六 实参的类型

def fn2(a):

    print('a =',a)
# 函数在调用的时候，解释权不会检查实参的类型
# 实参的类型可以是任意的对象
b = 123
fn2(b) #a = 123
b = 'python'
fn2(b) #a = python
b = None
fn2(b) #a = None
b = True
fn2(b) #a = True
b = [1,2,3]
fn2(b) #a = [1, 2, 3]


def fn3(a,b):

    print(a + b)

fn3(123,'456') #TypeError: unsupported operand type(s) for +: 'int' and 'str'


def fn4(a):
    # 在函数中对形参重新复制不会影响其他的变量
    # a = 30
    # 如果形参在执行的时候，当我们通过形参去修改对象时
    # 会影响到指向该对象的变量
    a[0] = 5
    print('a =',a,id(a))

# c = 10
c = [1,2,3]
# fn4(c)
fn4(c.copy()) #a = [5, 2, 3] 2160525726792
print('c.copy =',c,id(c)) #c.copy = [1, 2, 3] 2160525726280
fn4(c[:]) #a = [5, 2, 3] 2332639777864
print('c: =',c,id(c)) #c = [1,2,3]

七 不定长参数

定义一个函数来实现任意数的和
在定义函数的时候，可以在形参的前面加上一个*,这样这个形参将会获取到所有的形参
它会将所有的实参保存到一个元祖中

def s(*a):

    # 定义一个变量来保存 结果
    r = 0
    # 遍历元祖，将元祖中的元素取出来并进行累加
    for n in a:
        r += n
    print(r)

s(1,2,3,4,5,6) #21


def fn(*a):

    print('a = ',a,type(a)) # a =  (2, 3, 4, 5, 6, 7, 8, 9, 90) <class 'tuple'>

fn(2,3,4,5,6,7,8,9,90)


def fn2(a,b,*c):

    print('a =',a)
    print('b =',b)
    print('c =',c)

fn2(1,2,3,4,5,6)
'''
a = 1
b = 2
c = (3, 4, 5, 6)
''' 

# 可变长参数不是必须要写到最后的，但是注意 带*的参数后面的参数，必须以关键字的形式传参
def fn21(a,*b,c=6):

    print('a =',a)
    print('b =',b)
    print('c =',c)
    # a = 1
    # b = (2, 3, 4, 5, 6)
    # c = 6


fn21(1,2,3,4,b=5,c=6)# TypeError: fn21() got an unexpected keyword argument 'b'




def fn2(*a,b,c):

    print('a =',a)
    print('b =',b)
    print('c =',c)

fn2(1,2,3,4,b=5,c=6)
'''
a = (1, 2, 3, 4)
b = 5
c = 6
'''



# 若果在形参的开头直接写一个*，则要求我们所有的参数要以关键字的形式来传递
def fn2(*,a,b,c):

    print('a =',a)
    print('b =',b)
    print('c =',c)

fn2(a=3,b=4,c=5)
'''
a = 3
b = 4
c = 5
'''



# **形参可以接收其他的关键字参数，它会将这些参数统一保存到一个字典当中
# 字典当中的key是参数的名字，字典当中的value是参数的值
# **形参只能有一个，并且必须写在最后面
def fn3(b,c,**a):
    print('a =', a,type(a))

    print('b =',b)
    print('c =',c)

fn3(b=1,d=2,c=3,e=4,f=5)
'''
a = {'d': 2, 'e': 4, 'f': 5} <class 'dict'>
b = 1
c = 3
'''

八 参数解包

def fn4(a,b,c):
    print('a =', a)
    print('b =', b)
    print('c =', c)
# 这里面要求序列中的元素的个数必须和形参的个数一致
t = (5,6,7,8)
y = (1,5,6)
# fn4(t) #TypeError: fn4() missing 2 required positional arguments: 'b' and 'c'
# fn4(t[0],t[1],t[2])
'''
a = 5
b = 6
c = 7
'''
# fn4(*t) #TypeError: fn4() takes 3 positional arguments but 4 were given
fn4(*y)
'''
a = 1
b = 5
c = 6
'''

d = {'a':100,'b':200,'c':300}

fn4(**d)
'''
a = 100
b = 200
c = 300
'''
fn4(*d)
'''
a = a
b = b
c = c
'''