从集合到初见函数——我的初体验

copy() 潜复制

• 潜复制:复制序列时只复制最外层的序列，对于序列中存在的子序列是不会复制的
• 当子序列的元素被改变时，被复制的序列的元素也会随之改变，因为潜复制不会为子序列提供一个位置储存其中的数据，它就只能一次又一次的返回原序列的子序列中更改元素再复制给自身；不论是原序列还是复制产生的序列当除子序列以外的元素被改变时，另一个序列不会发生相应的变动

d = {'a': {'name': '老子', 'age': 74}, 'b': 1, 'c': 2, 'd': 3, 'e': 4}
d2 = d.copy()
d2['c'] = 100
d2['a']['name'] = '韩非子'
d['d'] = 50
print('d=', d)
print('d2=', d2)
结果：
d= {'a': {'name': '韩非子', 'age': 74}, 'b': 1, 'c': 2, 'd': 50, 'e': 4}
d2= {'a': {'name': '韩非子', 'age': 74}, 'b': 1, 'c': 100, 'd': 3, 'e': 4}

• 深复制：复制一个与原序列除id以外完全相同的序列
• 不论是潜复制还是深复制id都会发生改变
• 深复制需要导入相应的模块，并且两个序列之间的改变不会互相干扰

import copy
list_1 = [1, 2, 3, [4, 5, 6]]
list_2 = copy.deepcopy(list_1)
list_2[3][1] = 100
print('list_1=', list_1, id(list_1))
print('list_2=', list_2, id(list_2))
结果：
list_1= [1, 2, 3, [4, 5, 6]] 1385317563144
list_2= [1, 2, 3, [4, 100, 6]] 1385317625928

遍历字典

• 我们主要可以通过3种方式对字典进行遍历
  keys() 该方式返回字典所有的key
  values() 该方式返回⼀个序列，序列中保存有字典的值
  items() 该方式会返回字典中所有的项。它返回⼀个序列，序列中包含有双值子序列，双值分别是字典中的key和value

d = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4}
# keys()
for i in d.keys():
	print(d[i])
结果：
0
1
2
3
4
# values()
for i in d.values():
	print(i)
结果：
0
1
2
3
4
# items()
for i in d.items():
	print(i)
	print(i[1])
结果：
('a', 0)
0
('b', 1)
1
('c', 2)
2
('d', 3)
3
('e', 4)
4

for i, j in d.items():
    print(i, j)
结果：
a 0
b 1
c 2
d 3
e 4

集合

集合的一些概念

• 集合（set类型）和列表相似
• 集合和列表的不同点：
  • 1.集合中只能保存不可变对象
  • 2.集合中元素是以无序的顺序保存的（不是按照插入顺序保存的）
  • 3.集合中不会存在有相同的元素
• 创建集合
  • 1.使用{}创建非空集合
  • 2.用set()函数将序列和字典转换成集合

s = {1, 2, 10, 4, 5, 5, 4, 10, 2, 1, 1, 1}
s2 = set({'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4})
print(s)
print(s2)
结果：
{1, 2, 4, 5, 10}
{'e', 'a', 'b', 'c', 'd'}

set_2 = {[1, 2, 3], [4, 5, 6]}
# TypeError: unhashable type: 'list'

print(s[0])
# TypeError: 'set' object does not support indexing

集合的使用

• 判断是否存在于集合中 in，not in
• add()向集合中添加元素
• update() 将一个集合中的元素添加到另一个集合中
• pop() 随机删除集合中的一个元素，具有返回值
• remove() 删除集合中指定的元素
• clear() 清空集合

set_1 = {'a', 'b', 1, 2, 3}
set_2 = set('welcome')
# in 和 not in
print('a' in set_1)

# add()向集合中添加元素
set_1.add(50)

# update() 将一个集合中的元素添加到另一个集合中
set_1.update(set_2)
print(set_1)
结果：
{'e', 1, 2, 3, 'o', 'm', 'w', 'b', 50, 'l', 'c', 'a'}

# pop() 随机删除集合中的一个元素
b = set_1.pop()
print(set_1, b)
结果：
{1, 2, 3, 'o', 'm', 'w', 'b', 50, 'l', 'c', 'a'} e

# remove() 删除集合中指定的元素
set_1.remove(50)

# clear() 清空集合
set_1.clear()

集合的运算

• & 交集运算
• | 并集运算
• 差集运算
• ^ 亦或集运算
• 子集、真子集、超集、真超集
• < <= > >=

s = {1, 2, 3, 4, 5, 6, 7}
s2 = {1, 3, 5, 7, 9, 11, 13}
# & 交集运算
r = s & s2
print(r)
{1, 3, 5, 7}
# | 并集运算
m = s | s2
print(m)
{1, 2, 3, 4, 5, 6, 7, 9, 11, 13}
# - 差集运算
n = s - s2
print(n)
{2, 4, 6}
x = s2 - s
print(x)
{9, 11, 13}
# ^ 亦或集运算
y = s ^ s2
print(y)
{2, 4, 6, 9, 11, 13}
# 子集、真子集、超集、真超集
a = {1, 2, 3}
b = {1, 2, 3, 4, 5, 6}
c = a <= b
d = a < b
e = a >= b
f = a > b
print(c, d, e, f)
True True False False

函数基础

初步函数

函数的一些概念

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

语法：
def 函数名(形参1,形参2...)
	代码块

def fn():
    print('这是我的第一个函数')
    print('哈哈')
    print('呵呵')
    print('嘿嘿')
print(fn)
结果：function fn at 0x000001FE47402E18
fn()
结果：这是我的第一个函数
哈哈
呵呵
嘿嘿

• fn是函数对象，fn()是调用函数
• print是函数对象，print()是调用函数

函数的参数

• 在定义函数的时候可以再函数名后面的括号里定义数量不等的形参
• 定义多个形参需要用逗号隔开
• 形参即形式参数 定义形参就相当于再函数内部声明了变量（不是赋值）
• 实参即实际参数 如果函数定义的时候只定义了形参，那么再调用函数的时候就需要指定实参（数量和形参相等）

def he(x, y):
    print(x + y)
he(3, 5)
结果：8
he()
# TypeError: he() missing 2 required positional arguments: 'x' and 'y'（缺少实参）

参数的传递

• 定义形参的时候可以为形参指定默认值,如果用户传递了参数则默认值没有任何作用，如果用户没有传递参数，默认值生效
• 参数的传递方式
• 1.位置传参 将对应位置上的实参赋予对应位置上的形参 m(1, 2, 3)
• 2.关键字传参 可以不按照形参定义的顺序传参，直接以参数名来传参 m(c = 2, b = 3, a = 1)
• 位置参数和关键字参数可以混合使用，但是关键字参数不能放在位置参数之前

def m(a, b, c = 28):
    print('a =', a)
    print('b =', b)
    print('c =', c)

m(1, 2, 3)
结果：
a = 1
b = 2
c = 3
m(4, c = 5, b = 19)
结果：
a = 4
b = 19
c = 5
m(c = 5, 5, a = 19)
# SyntaxError: positional argument follows keyword argument