九 函数

九 函数

1、集合

1.1 集合的简介

▶ 集合：不同点（列表）
1.集合只能存储不可变对象
2.集合中存储的对象是无序的

      s={11,3,4,6}
      print(s)
     # 输出：{3,11,4,6}

3.集合中不能出现重复的元素

  s={11,3,4,6,6,6,6,6}
  print(s)
  #输出：{3,11,4,6}

▶ set函数可以创建集合

  s=set('python')

▶ 可以通过set()函数将序列转换为集合

   s=set([1,2,3,4,2,2,3,1])

▶ 使用set()函数将字典转换为集合时，只包含字典的keys（键）

  s=set({'a':1,'b':2})
  print(s)
  #输出：{'b','a'}

▶ 不能通过索引来获取集合中的元素

   s={'a','b',1,2,3}
   print(s[0])
   #输出：TypeError:'set' object does not support indexing

1.2 集合的使用

▶ in 和 not in 用来检查集合中的元素

  s= {'a','b',1,2,3}
  print('b' in s)

▶ len() 获取集合的长度或者元素的数量

  s= {'a','b',1,2,3}
   print(len(s))

▶ add() 向集合中添加元素

    s= {'a','b',1,2,3}
    s.add(10)
    print(s)

▶ update() 将一个集合中的元素添加的当前的集合中

  s2=set('Hello')
  s.update(s2)
  print(s)

▶ pop()随机删除集合中的一个元素，返回值（删除的元素）

 s={1,2,3,'a','50'}
 resut=s.pop()
 print(result)   

▶ remove() 删除集合中指定的元素

 s={1,2,3,'a','50'}
 s.remove(2)
 print(s

▶ 交集运算 &

s1={1,2,3,4,5}
s2={3,4,5,6,7}
result=s1&s2
print(result)
#输出：{3,4,5}

▶ 并集运算 |

s1={1,2,3,4,5}
s2={3,4,5,6,7}
result=s1 | s2
print(result)
#输出：{1,2,3,4,5,6,7}

▶ 差集运算 -

 s1={1,2,3,4,5}
 s2={3,4,5,6,7}
 result=s1 - s2                  result=s2 - s1       
 print(result)                   print(result)
 #输出：{1,2}                       {6,,7}

▶ 亦或集 ^

 s1={1,2,3,4,5}
 s2={3,4,5,6,7}
 result=s1 ^ s2
 print(result)
 #输出：{1,2,6,7}

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

 s1={1,2,3}
 s2={1,2,3,4,5}
 result=s1<=s2    #s1集合是s2集合的子集（s2集合是s1集合的超集）
 print(result)
 #输出：{1,2,3}

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

 s1={1,2,3}
 s2={1,2,3,4,5}
 result=s1<s2    #s1集合是s2集合的子集（s2集合是s1集合的超集）
 print(result)
 #输出：{1,2,3}

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

  s1={1,2,3}
  s2={1,2,3,4,5}
  result=s2>s1    #s1集合是s2集合的子集（s2集合是s1集合的超集）
  print(result)
 # 输出：{1,2,3}

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

  s1={1,2,3}
  s2={1,2,3,4,5}
  result=s2>=s1    #s1集合是s2集合的子集（s2集合是s1集合的超集）
  print(result)
# 输出：{1,2,3}

▶如果超集s2中包含子集s1中所有的元素，并且s2中还有s1集合中没有的元素，s2是s1的真超集，s1是s2的真子集。

2、函数

2.1 函数的简介

▶ 函数：用来保存一些可执行的代码，并且可以在需要时，对这些语句进行多次调用。
▶ 函数中保存的代码不会立即执行，需要调用函数代码才会执行

   def fn():
      print('这是我的第一个函数')
   print(fn)  
   fn()

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

3、函数的参数

3.1 形参和实参

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

3.2 函数的传递方式

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

   def s():
      print(1+2)
    s()

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

#其中a,b为形参，1,2为实参
  def s(a,b):
    print(a+b)    #-----输出的为一个值
    print(a,'+',b,'=',a+b)    #----输出的是一个表达式
  s(1,2)

#形参不能为空值，必须赋予实参
  def s(a,b):
    a=None
    b=None
    print(a,b) #TypeError: s() missing 2 required positional arguments: 'a'  and 'b'
   s()

▶ 位置参数：位置参数就是将对应位置的实参赋给对应位置的形参。

 def fn(a,b,c=20):
      print('a=',a)
      print('b=',b)
      print('c=',c)
fn(1,2,3)
#输出：a=1 b=2 c=3   

▶ 关键字参数:关键字参数可以不按照形参定义的顺序去传递，而根据参数名进行传递。

 def fn(a=4,b=10,c=20):
     print('a=',a)
     print('b=',b)
     print('c=',c)
fn()
#输出：a=4 b=10 c=20   

▶ 混合使用位置参数和关键字参数的时候必须将位置参数写到关键字参数前面去。

 def fn(a,b,c):
    print('a=',a)
    print('b=',b)
    print('c=',c)
fn(1,c=20)
#输出：a=1 c=20   

   def s(a):
     print('a=',a)
   c=10
   s()
 输出：a=10
 
#在函数中对形参进行赋值，不会影响其它的变量    
    def s(a):
     a=20
     print('a=',a)
    c=10
    s()
    print('c=',c)
# 输出：a=20  c=10  

#a是一个列表，修改列表中的元素
  def s(a):
     a[0]=20
     print('a=',a)
  c=[1,2,3]
  s()
  print('c=',c)
 #输出：a=[20,2,3]    c=[20,2,3]

3.3 不定长参数

▶ 定义函数时，可以在形参前面加一个*，这样这个形参可以获取到所有的参数，它会将所有的实参保存到一个元组中。

def fn(a,b,*c):
   print('a',a)
   print('b',b)
   print('c',c)
fn(1,2,3,4) 
#输出：a=1,b=2,c={3,4}  

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

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

▶ 带 * 号的形参只能有一个，可以和其它参数配合使用。
▶ * 形参只能接受位置参数，不能接受关键字参数。
▶ 形参可以接收其他的关键字参数，它会将这些参数统一保存到字典当中。字典的key就是参数的名字，字典的value就是参数的值。
▶ **形参只有一个，并且必须写在所有参数的后面。

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

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

3.4 参数的解包

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

 def fn(a,b,c):
     print('a',a)
     print('b',b)
     print('c',c)
 t=(10,20,30)
 fn(*t)

#可以通过**来对字典解包
def fn(a,b,c):
   print('a',a)
   print('b',b)
   print('c',c)
d={'a':10,'b':20,'c':30}
fn(**d)