Python全栈day19（函数补充）

一,深浅拷贝

　　看拷贝列子day19-1.py

s=[1,'zhangsan','lisi']
#s2是s的拷贝
s2=s.copy()
#打印s2和s是一样的
print(s2)
#修改s2
s2[0]=2
#打印s是未变的
print(s)
#打印s2因为修改了所以有变化
print(s2)

[1, 'zhangsan', 'lisi']
[1, 'zhangsan', 'lisi']
[2, 'zhangsan', 'lisi']

　　假如修改的元素是一个列表，源列表也会发生变化day19-2.py

s = [[1,2],'zhangsan','lisi']
s3=s.copy()
print(s3)
print(s)
s3[0][1]=3
#修改s3里面列表元素以后源列表也对应改变了
print(s3)
print(s)

[[1, 2], 'zhangsan', 'lisi']
[[1, 2], 'zhangsan', 'lisi']
[[1, 3], 'zhangsan', 'lisi']
[[1, 3], 'zhangsan', 'lisi']

　　为什么会这样，因为第一次修改的是一个不可变元素对应的指针发生了变化，第二次s和s3指向的内存地址是一个可变的元素（列表）当列表发生改变，但是列表的内存地址没有改变s和s3的指向没有发生改变，所以修改s3的第一个元素列表对应的s的第一个元素列表也发生了改变。

　　这就是浅拷贝，浅拷贝只拷贝第一层

　　深拷贝等于克隆一份，需要单独的模块day19-4.py

import copy
L1 = [[1,2],3]
L2 = copy.deepcopy(L1)
print(L2)

 [[1,2],3]

　　

　　深浅拷贝小结

• 深浅拷贝都是对源对象的复制，占用不同的内存空间
• 如果源对象只有一级目录的话，源做任何改动，不影响深浅拷贝对象
• 如果源对象不止一级目录的话，源内可变元素（列表，字典）做任何改动，都要影响浅拷贝，但不影响深拷贝
• 序列对象的切片其实是浅拷贝，即只拷贝顶级的对象

　　

二，集合

　　把不同元素整合在一起形成集合（元素不能重复，重复认为是一个）

　　创建集合的方法 set() 必须是可哈希的对象，单个元素不能是列表或者字典等不可哈希对象

　　集合分类：可变集合，不可变集合

　　可变集合（set）：可添加删除元素，非可哈希的，不能用做字典的建，不能做其他集合的元素

　　不可变集合（frozenset）：与可变集合恰恰相反 （可变集合不能作为字典的建不可变集合可以作为字典的建）

　　集合是无序的不能通过索引或者切片操作，可以通过for循环遍历或者通过in，not in判断是否在里面

　　更新集合

　　s.add() 添加一个元素

　　s.remove()移除指定元素

　　s.pop()随机删除一个元素

　　s.clear()清空（和删除不一样清空后还是有大括号的）

　　s.update()更新 接一个可迭代对象添加多个元素 之前的保留（接的是一个可迭代对象）

　　day19-5.py

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

print(s)
s.add(4)
print(s)
s.remove(4)
print(s)
s.update('hello')
print(s)

{1, 2, 3}
{1, 2, 3, 4}
{1, 2, 3}
{1, 2, 3, 'o', 'h', 'e', 'l'}

　　等价与不等价

print(set('hello')==set('hellohello'))

True

　　子集与父集（父集要包含子集并且多于子集不能等于否则Python认为不包含返回False）

print(set('123')<set('1234'))

True

　　交集，并集，差集day19-6.py

a = set([1,2,3,4,5])
b = set([4,5,6,7,8])
#以下两种方式求交集
print(a.intersection(b))
print(a&b)
#以下两种方法求并集
print(a.union(b))
print(a|b)
#in a but not in b (差集)
print(a.difference(b))
print(a-b)
#in b but not in a（差集）
print(b.difference(a))
print(b-a)
#除了交集把其余的取出来 对称差集或者叫反向交集
print(a.symmetric_difference(b))
print(a^b)

{4, 5}
{4, 5}
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3}
{1, 2, 3}
{8, 6, 7}
{8, 6, 7}
{1, 2, 3, 6, 7, 8}
{1, 2, 3, 6, 7, 8}

　　父集，子集day19-6.py

a = set([1,2,3])
b = set([1,2])
#判断是否a是否是b的父集
print(a.issuperset(b))
print(a>b)
#判断b是否是a的子集
print(b.issubset(a))
print(b<a)

True
True
True
True

　　

三，函数

　　a，定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可

　　特性:

　　1.代码重用

　　2.保持一致性

　　3.可扩展性

　　b，函数的创建　　

#函数的定义
def f():
    print('Hello World')
#函数的调用
f()

'Hello World

　　PS：函数的命名规则（和变量命名规则是一样的）

• 函数名必须以下划线或字母开头，可以包含字母下划线和数字，不能包含其他特殊符号
• 函数名是区分大小写的
• 函数名不能是保留字

　　c,形参和实参

　　形参：形式参数，不是实际存在，是虚拟变量。在定义函数和函数体的时候使用形参，目的是在函数调用时接收实参（实参个数，类型应与实参一一对应）

　　实参：实际参数，调用函数时传给函数的参数，可以是常量，变量，表达式，函数，传给形参

　　区别：形参是虚拟的，不占用内存空间，.形参变量只有在被调用时才分配内存单元，实参是一个变量，占用内存空间，数据传送单向，实参传给形参，不能形参传给实参

与之前重复，未整理完整！