Python 集合与函数简介

1. Python 集合

• 集合的简介
  集合只能存储不可变对象，即字符串，元组，数字，布尔值。字典、列表、集合不能作为集合存储的对象。
  集合中的元素是无序的。
  集合中不能出现重复的元素。

s = {25,4,6,13,1,1,1,2,2,2,2} # {4,6,25,13,2,1}
s = {[1,2,3],[4,5,6]} # TypeError: unhashable type: 'list'
s = {} # 空字典

• set（）函数
  可以作为数据类型的转换，如把列表、元组、字符串等转换成集合，转换字典，只能返回字典的keys。不能转换布尔值。数据类型转换，同样不能把字典、列表、集合作为新集合的元素。

#set()函数可以创建集合，可以通过set()函数将序列转换为集合
s = set([1,2,3,4,2,2,3,1]) # {1, 2, 3, 4}
s = set('python') # {'t', 'y', 'o', 'n', 'p', 'h'} <class 'set'>
s = set({'a':1,'b':2}) # {'a', 'b'} <class 'set'> 使用set()函数将字典转换为集合时，只包含字典的keys(键)
s = {'a','b',1,2,3}
print(s[0]) # TypeError: 'set' object does not support indexing，集合不支持索引。
# print(list(s)[0])

1.2 集合的使用

in 和 not in来检查集合中的元素
len() 获取集合的长度或者元素的数量
add() 向集合中添加元素
update() 将一个集合中的元素添加到当前的集合中
pop() 随机删除集合中的一个元素 返回值(删除的元素)
remove() 删除集合中指定的元素
clear() 清空集合

s = {'a','b',1,2,3}
print(len(s)) # 5
s.add(40)
print(s) # {1, 2, 3, 'a', 40, 'b'}
s1 = set('python')
s.update(s1)
print(s) # {1, 2, 3, 'y', 'p', 'h', 'a', 40, 'n', 'b', 't', 'o'}
result = s.pop()
print(result) # 1
s.remove(40)
print(s) # {2, 3, 'h', 'y', 'a', 't', 'p', 'b', 'o', 'n'}
s.clear()
print(s) # set()

1.3 集合的运算

交集运算 &
并集运算 |
差集运算 -
亦或集 ^ 不相交的部分
<= 检查一个集合是否是另一个集合的子集
< 检查一个集合是否是另一个集合的真子集
>= 检查一个集合是否是另一个集合的超集
> 检查一个集合是否是另一个集合的超超集
如果超集b中包含子集a中所有的元素，并且b中还有a集合中没有的元素，b是a的真超级 a

1. 函数简介

• 函数也是一个对象
• 函数用来保存一些可执行的代码，并且可以在需要时，对这些语句进行多次调用
语法
def 函数名([形参1,形参2,形参3…]):
代码块
注意：
函数名必须符合标识符的规范(可以包含字母、数字、下划线但是不能以数字开头)
print是函数对象 print()是调用函数

2. 函数的参数

2.1 形参和实参

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

2.2 函数的传递方式

• 在定义函数的时候，可以在函数后面的()中定义数量不等的形参。多个形参之间使用,隔开
def s(a,b):

定义形参时,可以为形参指定默认值。指定了默认值以后，如果用户传递了参数则默认值不会生效。如果用户没有传递，则默认值就会生效

def fn(a = 5,b =10,c=20):
    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=20

• 位置参数：位置参数就是将对应位置的实参赋值给对应位置的形参
• 关键字参数 : 关键字参数可以不按照形参定义的顺序去传递，而根据参数名进行传递
• 混合使用位置参数和关键字参数的时候必须将位置参数写到关键字参数前面去。如 fn(1,2,c=3)

def fn(a):
    a = 20 # 在函数中对形参进行赋值，不会影响其他的变量. 
    print('a =',a)
c = 10
fn(c)
print('c =',c) 
# a = 20
# c = 10
def fn4(a):
    a[0] = 20
    print('a =',a)
     # 但当a是一个列表会修改列表中的元素。
c = [1,2,3]
fn(c)
print('c =',c) 
# a = [20,2,3]
# c = [20,2,3]

3. 不定长参数

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

def fn( a,*c ):
  print("输出: ")
  print(a)
  for i in c:
     print(i)
  return
fn(1,2,3)
# 结果
输出: 
1
2
3

# 不定长参数不一定都要写在后面，但是注意 带*的参数后面的所有参数，必须以关键字形式来传递


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

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

fn3(b=4,d=5,c=6)
# 结果 
a = {'b':2,'d':1,'c':3}

4. 参数的解包

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

def fn(a,b,c):

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

# 创建一个元组
t = (20,30,40)
fn(*t)
# 结果
a = 20
b = 30
c = 40
# 传递实参时候，也可以在序列类型的参数前面添加*号，这样它会自动的将序列三种的元素依次作为参数传递

# 可以通过**来对字典进行解包
d = {'a':2,'b':3,'c':4}
fn(**d)
# 结果
a = 2
b = 3
c = 4