Python全栈day19（函数补充）

一,深浅拷贝

　　看拷贝列子day19-1.py

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

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

?

1 2 3 4 5 6 7 8 9 10 11 12 13

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

?

1 2 3 4 5 6

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

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

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'}

　　等价与不等价

?

1	print(set('hello')==set('hellohello'))<br><br>True

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

?

1 2 3

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

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

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

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

?

1 2 3 4 5 6 7 8 9 10 11 12 13

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，函数的创建　　

?

1 2 3 4 5 6 7

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

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

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

 

　　c,形参和实参

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

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

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

 

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