Python第9讲

最新推荐文章于 2022-11-24 13:21:19 发布

Jaydenzuo

最新推荐文章于 2022-11-24 13:21:19 发布

阅读量155

点赞数

文章标签： python

本文链接：https://blog.youkuaiyun.com/Jaydenzuo/article/details/109639869

版权

本文深入探讨Python编程，涵盖字典的copy()方法、深复制和遍历，集合的创建、方法及运算，以及函数的定义、参数传递方式。详细解析了字典的keys(), values()和items()，集合的add(), update(), pop()和remove()等操作，同时介绍了函数的定义、调用及形参和实参的概念。" 120963161,5720964,ApplicationContext加载BeanFactory详解,"['Spring 5', 'BeanFactory', 'BeanDefinition', '配置']

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

字典

copy()方法

概念 —— 用来对序列浅复制（浅复制只会复制可变序列本身，如果可变序列中还有可变序列是不会进行复制。如list）

> a = {'a':1, 'b':2, 'c':3}
> b = a.copy()
> print(id(a),'|',id(b))
> 2350196295488 | 2350197381760 # id不同，修改任意一个字典都不影响另外一个字典

> a = {'a':1, 'b':2, 'c':3}
> c = a
> print(id(a),'|',id(c))
> 2350196295488 | 2350196295488 # id相同，修改任意一个字典都影响另外一个字典

> a = {'a':{'name':'呵呵', 'age':18}, 'b':2, 'c':3}
> d = a.copy()
> print(id(a),'|',id(d))
> 2350197382144 | 2350197381824
> d['a']['name'] = '哈哈'
> print(a,'|',d)
> {'a': {'name': '哈哈', 'age': 18}, 'b': 2, 'c': 3} | {'a': {'name': '哈哈', 'age': 18}, 'b': 2, 'c': 3}

深复制

需要导入copy模块

> import copy
> a = {'a':{'name':'呵呵', 'age':18}, 'b':2, 'c':3}
> d = copy.deepcopy(a)
> d['a']['name'] = '哈哈'
> print(a,'|',d)
> {{'a': {'name': '呵呵', 'age': 18}, 'b': 2, 'c': 3} | {'a': {'name': '哈哈', 'age': 18}, 'b': 2, 'c': 3}

遍历字典

d.keys() —— 返回字典所有的key
d.values() —— 返回字典所有的value
d.items() —— 返回字典所有的键值对

> # 遍历所有key
> a = {'a':1, 'b':2, 'c':3}
> for i in a.keys():
> 	print (i, end = '|')
> a|b|c|

> # 遍历所有的value
> a = {'a':1, 'b':2, 'c':3}
> for i in a.values()
>   print(i, end='|')
> 1|2|3|

> # 遍历所有的键值对
> a = {'a':1, 'b':2, 'c':3}
> for k,v in a.items():
>   print (k,',',v,end='|')
> a , 1|b , 2|c , 3|

集合

简介

数据类型 —— set
与列表非常相似（不同点如下）
- 集合只能存储不可变对象
- 集合中存储的对象是无序的（不是按照元素插入顺序保存的）
- 集合中不能出现重复的元素
- 不能通过切片、位置进行查找
创建方法

> a = {3,1,10,8}
> {8, 1, 10, 3} # 无序存放

> a = {1,2,2,5,8,1,10}
> {1, 2, 5, 8, 10} # 不能有重复项

> a = set()
> type(a)
> <class 'set'>

> a = {[1,2,3],4}
> '''
> File "<stdin>", line 1, in <module>
> TypeError: unhashable type: 'list'
> '''

set()可将序列和字典转换（字典转换为集合时，只会包含字典的键）为集合

> # 将序列转换为集合（list和tuple均可）
> set([1,1,2,2,3,6,6,10,8,8,8,])
> {1, 2, 3, 6, 8, 10}

> # 将字典转换为集合（字典转换为集合时，只会包含字典的键）
> set({'a':1,'b':2,'c':3})
> {'b', 'c', 'a'}

集合的方法

方法	含义
in 和 not in	检查集合中的元素
s.add(elem)	向集合s中添加元素elem
s.update(*other)	更新集合,向s集合中添加other中的所有元素
s.pop()	从集合中删除随机元素并有返回值。如果集合为空则报KeyError错误
s.remove(elem)	从集合中删除元素elem，如果elem元素不在集合中则报KeyError错误
s.clear()	清空集合

s.add() —— 向集合中添加元素

> a = {1,2,3}
> a.add(4)
> {1,2,3,4}

s.update(*other) —— 更新集合

> a = {1,2,3}
> b = {3,4,5}
> a.update(b)
> {1,2,3,4,5}

s.pop() —— 随机删除集合元素并返回值

> a = {1,2,3}
> r = a.pop()
> print (r,'|',a)
> 1 | {2,3}

s.remove(elem) —— 删除集合中指定元素

> a = {1,2,3,4}
> a.remove(3)
> print(a)
> {1,2,4}

集合的运算

运算符	含义
s\|other\|… 或 set(s).union(*others)	并集运算，原集合以及other的所有集合中的元素
s&other&… 或 set(s).intersection(*others)	交集运算，原集合以及others的所有集合中共有的元素
s-other-… 或 set(s).difference(*others)	差集运算，原集合中在others的集合中不存在的元素
s^other^… 或 set(s).symmetric_difference(*others)	亦或运算，不属于原集合且也不属于others的集合
a<=b 或 set(a).issubset(b)	检查a是b的子集，返回布尔值
a<b	检查a是b的真子集（a<=b且a!=b），返回布尔值
a>=b 或 seb(a).issuperset(b)	检查a是b的超集，返回布尔值
a>b	检查a是b的真超集（a>=b且a!=b），返回布尔值

并集运算

> a = {1, 2, 3}
> b = {3, 4, 5}
> a | b
> {1, 2, 3, 4, 5}
> set(a).union(b)
> {1, 2, 3, 4, 5}

交集运算

> a = {1, 2, 3}
> b = {3, 4, 5}
> a & b
> {3}
> set(a).intersection(b)
> {3}

差集运算

> a = {1, 2, 3}
> b = {3, 4, 5}
> a - b
> {1,2}
> set(a).difference(b)
> {1,2}

亦或运算

> a = {1, 2, 3}
> b = {3, 4, 5}
> a ^ b
> {1, 2, 4, 5}
> set(a).symmetric_difference(b)
> {1, 2, 4, 5}

子集运算

> a = {1, 2, 3, 4, 5, 6}
> b = {3, 4, 5}
> b <= a
> True
> set(a).issubset(b)
> False

真子集运算

> a = {1, 2, 3, 4, 5, 6}
> b = {3, 4, 5}
> b < a
> True
> b = {1, 2, 3, 4, 5, 6}
> b < a
> False

超集与真超集（和子集与真子集一样，略）

函数

函数快速入门

简介

函数是对象
函数可以保存可执行的代码，且可以在需要的时候多次对这些代码调用
语法：
- 定义函数：
  def 函数名(形式参数1，形式参数2，…):
  代码块
- 调用函数：
  函数对象()

> def a():
>   print ('这是我的第一个函数！')
> print(a)
> <function a at 0x00000223327671F0>
> a()
> 这是我的第一个函数！

函数的参数

定义参数的方法 —— 定义函数的时候，可以在函数后面的括号中定义数量不等的形式参数，定义多个形式参数要用逗号隔开
- 定义形参相当于在函数内部声明了变量，不是赋值
- 如果函数定义的时候指定了形参，在调用的时候必须传递实参，实参将会赋值给对应的形参（实参必须与形参数量相等）。

> def func(a,b):
> 	print(a,'+',b,'=', a+b)
> func()
> '''
> File "<stdin>", line 1, in <module>
> TypeError: func() missing 2 required positional arguments: 'a' and 'b'
> '''
> func(1,2)
> 1 + 2 = 3

函数参数的传递方式

定义形参时，可以为形参指定默认值（如果用户传递了参数则默认值没有作用；如果用户没有传递参数则默认值会生效）

位置传参 —— 将对应位置上的实参赋值给对应位置上的形参
关键字传参 —— 可以不按照形参定义的顺序传递，直接根据参数名传递
位置参数和关键字参数可以混合使用，但关键字参数必须在位置参数后面

> # 位置传参
> def func(a,b):
> 	print(a,'+',b,'=', a+b)
> func(1,2) # 1,2 对应的是a,b
> 1 + 2 = 3

> # 关键字传参
> def func(a,b):
> 	print(a,'+',b,'=', a+b)
> func(b = 1, a = 2) 
> 2 + 1 = 3