目录

• 1. 遍历字典
• 2.集合
• 2.1 集合的简介
• 2.2 集合的使用方法
• 2.3 集合的运算

• 3.1 函数的简介
• 3. 2 函数的参数
• 3.2.1 形参和实参
• 3.2.2 函数的传递方式：

1. 遍历字典

用for循环遍历字典有三种方式：

1. keys（）该方法返回字典所有的key
2. values() 该⽅法返回⼀个序列 序列中保存有字典的值
3. items（）该⽅法会返回字典中所有的项 它返回⼀个序列，序列中包含有双值子序列 双值分别是 字典中的key和value。
   下面请看示例：

d = {'a':1, 'b':2,'c':3,'d':4}
for k in d.keys():
print(k,'\t',end='')
print()
for v in d.values():
print(v,'\t',end='')
print()
for i in d.items():
print(i,'\t',end='')

执行结果如下：
a b c d
1 2 3 4
(‘a’, 1) (‘b’, 2) (‘c’, 3) (‘d’, 4)

2.集合

2.1 集合的简介

• 集合表现形式set 集合和列表⾮常相似

• 不同点：

  集合只能存储不可变对象
• 集合中存储的对象是无序的
• 集合不能出现重复元素

2.2 集合的使用方法

• 使用{}来创建集合
• 可以通过set()来将序列和字典转换成集合
• len() 使用len()来获取集合中元素的数量
• add() 向集合中添加元素
• update() 将⼀个集合中的元素添加到另⼀个集合当中
• pop() 随机删除集合中的⼀个元素⼀般是删除最后⼀个元素
• remove() 删除集合中指定的元素
• clear() 清空集合
  下面请看示例：

s = {1,2,3,4,5} #创建集合
print(s,type(s))
d = {'a':1,'b':2}
s1 = set(d)    #将字典转换为集合
print(s1)
s.add(100)
print(s)  #向集合中添加元素
s2 = {101,102}
s.update(s2) #将一个集合添加到另外一个集合当中
print(s)
s.pop() #随机删除集合中的一个元素
print(s)
s.remove(2)  #将指定元素删除
print(s)
s.clear() #清空集合
print(s)

执行结果如下：
{1, 2, 3, 4, 5} <class ‘set’>
{‘a’, ‘b’}
{1, 2, 3, 4, 5, 100}
{1, 2, 3, 4, 5, 100, 101, 102}
{2, 3, 4, 5, 100, 101, 102}
{3, 4, 5, 100, 101, 102}
set()

2.3 集合的运算

集合之间可以进行以下运算：

• & 交集运算
• | 并集运算
• 差集运算

s1 = {1,2,3,4}
s2 = {2,3,4,5}
print(s1&s2)  # 求s1和s2的交集
print(s1|s2)  # 求s1和s2的并集
print(s1-s2)  # 求s1和s2的差集
print(s1^s2)  # 求s1和s2的亦或集
print(s1<=s2)  #检查s1是否是s2的子集
print(s1<s2)  # 检查s1是否是s2的真子集
print(s1>=s2) #检查s1是否是s2的超集
print(s1>s2) #检查s1是否是s2的真超集

执行结果如下：
{2, 3, 4}
{1, 2, 3, 4, 5}
{1}
{1, 5}
False
False
False
False

3. 函数

3.1 函数的简介

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

3. 2 函数的参数

3.2.1 形参和实参

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

def s_sum(a,b,c):
s = a+b+c
print(s)
s_sum(1,2,3)

执行代码结果如下：
这个函数中，a,b,c就是函数内部申明的变量形参，而1,2,3就是指定形参，调用函数，也就是实参。

3.2.2 函数的传递方式：

• 位置参数：位置参数就是将对应位置的实参赋值给对应位置的形参
        如3.2.1中的代码，就是用位置参数来讲实参赋值给对应位置的形参，可以看到，1对应a，2对应b, 3对应c
• 关键字参数 : 关键字参数可以不按照形参定义的顺序去传递，而根据参数名进行传递
  下面请看示例：

def s_sum(a,b,c):
s = a+b+c
print('a =',a)
print('b =',b)
print('c =',c)
s_sum(c=1,a=2,b=3)

代码执行结果如下：
a = 2
b = 3
c = 1
由此可见，虽然在申明形参的时候后，顺序是a、b、c。但是在传入实参的时候用了关键字的方法，仍然会对形参按照关键字而不是按照位置正确赋值。

• 混合使用位置参数和关键字参数的时候必须将位置参数写到关键字参数前面去
  下面请看示例：

def s_sum(a,b,c):
s = a+b+c
print('a =',a)
print('b =',b)
print('c =',c)
s_sum(1,2,c=3)

执行结果如下：
a = 1
b = 2
c = 3

• 参数默认值：定义形参时,可以为形参指定默认值。指定了默认值以后，如果⽤户传递了参 数则默认值不会⽣效。如果⽤户没有传递，则默认值就会⽣效。
  下面请看示例：

def s_sum(a,b,c=3):
s = a+b+c
print('c =',c)
s_sum(1,2)
def s_sum1(a,b,c=3):
s = a+b+c
print('c =',c)
s_sum1(1,2,4)

执行结果如下：
c = 3
c = 4
对比s_sum和s_sum1这两个函数可以看出，如果形参有默认值，当不传入该参数的时候会使用默认值，如果实参传入了该参数，则按照新传入的参数来执行。

3.3 可变对象

对象在内存中，都保存了3个数据：

1. id(标识）
2. type（类型）
3. value（值）
   请看下面的示例：

a = [1,2,3]
print('a=',a,id(a)) #原本a的id
a[0] = 5
print('a=',a,id(a)) #通过索引值改动后的id
a = [4,5,6]
print('a=',a,id(a)) #通过更改整个变量后的id

执行结果如下：
a= [1, 2, 3] 2652192056520
a= [5, 2, 3] 2652192056520
a= [4, 5, 6] 2652192056392
已知相同id，就是相同对象，我们可以得到结论：

• 通过索引值修改的a和原本的a是一个对象。
• 将整个a 重新赋值的操作和原本的a不是一个对象。

原因是：通过索引值更改元素的这个操作是修改对象的value，并且不会改变变量所指向的对象。而将整个a重新赋值的操作是给变量重新赋值，并且会改变量所指向的对象

3.4 实参的类型

• 函数的实参可以传递任意类型的对象
• 在实参传入的时候并不检查对象的类型，在调用函数的时候解释器才会检查对象的类型。
• 如果形参执行的是一个对象，通过形参修改对象的时候，会影响实参的变量。
  请看以下示例：

def fn(a):
a[0] = 5
print('a=',a,id(a))
c = [1,2,3]
fn(c)
print('c=',c,id(c))

执行结果如下：
a= [5, 2, 3] 1962692846792
c= [5, 2, 3] 1962692846792

原因是，当c时一个可变对象的时候，因为函数内部只更改了形参a的value，而形参a和实参c是同一个对象，所以也修改了实参c的值。

如果希望修改a的值不影响c的值，可以用copy的方法。
请看以下示例：

def fn(a):
a[0] = 5
print('a=',a,id(a))
c = [1,2,3]
fn(c.copy())
print('c=',c,id(c))

执行结果如下：
a= [5, 2, 3] 2947890881608
c= [1, 2, 3] 2947890881736

由此可见，用c.copy()这个方法当做实参传入函数中，不会影响c的值，因为c.copy（）复制了一个c, 他们不是同一对象。