本文整理 Python 3 的相关学习笔记，示例按各小节说明理解。
输入与输出
1.基本的输入与输出函数
1.表达式语句和 print() 函数。
在python中输出的方法有两种，一种是直接使用表达式，会将结果输出，一种是使用print()函数。格式为：print(值1,值2,值3…)
>>> 59+44
103
>>> print('hello',',','wolrd!')
hello , wolrd!
2.输入函数input()
Python 提供了 input() 内置函数从标准输入读入一行文本，默认的标准输入是键盘。格式为：input(“提示字符串”)。注意输入中读到的都是字符串。
str_input = input('请输入一个整数：')
print(str_input)
#请输入一个整数：12
#'12'
2.对文件的I/O操作
1.文件的打开和关闭：
open() 方法用于打开一个文件，并返回文件对象(file)。在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。
**注意：**使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。
方法完整参数为：
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
- file:打开的文件路径
- mode: 打开模式
- encoding：使用的编码格式。在文本模式下，如果未指定 encoding 则所使用的编码格式将依赖于具体平台: locale.getencoding()会被调用以获取当前语言区域的编码格式。 (对于读取和写入原始字节数据请使用二进制模式并且不要指定 encoding。)
mode 参数有：
| 字符 | 含义 |
|---|---|
| ‘r’ | 读取（默认） |
| ‘w’ | 写入，并先截断文件 |
| ‘x’ | 排它性创建，如果文件已存在则失败 |
| ‘a’ | 打开文件用于写入，如果文件存在则在末尾追加 |
| ‘b’ | 二进制模式 |
| ‘+’ | 打开用于更新（读取与写入） |
| ‘t’ | 文本模式（默认） |
'w+' 和 'w+b' 模式将打开文件并清空内容。而 'r+' 和 'r+b' 模式将打开文件但不清空内容。
对于’w+’和’r+’来说都会将指针置于文首，都可以对文件进行读写操作，不同的是w会创建不存在的文件，并且会在打开的时候清空文件内容，而r如果路径文件不存在则会报错，并且不会清空文件内容，但是需要注意和’a’的区别：w和r都会将指针置于文首，也就是说对于’r+’模式，即使文件内容没有被清空，但是写入内容的时候会将原先的内容覆盖。
除了open()和close()之外，还可以使用with open as语法格式打开文件，对文件进行操作，这种方法的好处只在于with语法块结束之后会自动关闭文件，防止遗忘。
with open('vscode/flag.txt',mode='r+b',encoding='utf8') as f:
v = f.readline()
2.读取
file.read([size])
从文件读取指定的字节数，如果未给定或为负则读取文件的全部内容。
file.readlines([sizeint])
读取所有行并返回列表，包括换行符。若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
file.readline()
读取一行，包括换行符。
for循环读取
还可以使用for循环遍历file对象，每一次循环返回一行数据，包括换行符
f = open('vscode/flag.txt',mode='+r',encoding='utf8')
for i in f:
print(bytes(i,'utf8'))
f.close()
3.写入
file.write(str)
将字符串写入文件，返回的是写入的字符长度。
file.flush()
刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
使用write()函数只是将内容写入缓冲区，而没有立即写入文件，写入文件的时机在于缓冲区已满、等待系统写入或者是主动清空缓冲区，缓冲区的意义在于避免频繁的和硬盘联系，降低运行效率。
file.seek(offset[, whence])
将文件指针移动到指定位置。操作成功则返回指针当前所在字节位置，失败返回-1
- offset — 开始的偏移量，也就是代表需要移动偏移的字节数，如果是负数表示从倒数第几位开始。
- **whence：**可选，默认值为 0。给 offset 定义一个参数，表示要从哪个位置开始偏移；0 代表从文件开头开始算起，1 代表从当前位置开始算起，2 代表从文件末尾算起。
函数
1.函数的定义
def 函数名（参数列表）:
函数体
return 返回值列表
规则：
- 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
- 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号 : 起始，并且缩进。
- return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 return None。
def max(a, b):
'''
这里写函数的说明文档
:param a: 这里写参数的说明
:param b: 这里写参数的说明
:return :这里写返回值的说明
'''
if a > b:
return a
else:
return b
2.函数的调用
直接使用函数名加圆括号，括号内跟上参数列表，并使用变量接收返回值。
fun(arg1,arg2,arg3...)
# 例如
a = max(5,10)
3.参数问题
python是完全面向对象的语言，任何类型都是一个类，所以类型是对象，而变量无类型。所以变量只是一个引用，可以指向不同的对象。在数据类型一节中我们知道python中的数据类型分为不可变对象和可变对象。不可变对象Numbers，string，元组tuple。所谓不可变对象也就是在声明变量指向该类型的对象之后，其值就不可变了，重新赋值之后实际上是生成了一个新的对象，指向了一个新的引用。而可变对象list,set,dictionary,在声明之后可以修改其值，而引用没有发生改变。
# python中使用id()函数获取一个变量指向的内存空间
# 对不可变类型的数据进行操作
a = 10
id(a)# 140725185354456
a = 5
id(a)# 140725185354296 引用改变
#对可变类型的数据操作
b = [1,2,3]
id(b)# 2043195950656
b[1] = 5
id(b)# 2043195950656 引用未变
所以在函数传参过程中实际上传递的是参数的引用，对于不可变类型的参数而言，传递的是原变量的引用，但是在函数内部进行的所有修改操作实际上是重新生成了一个对象并改变变量的引用，所以对于参数而言，函数调用之后其值不会发生改变。因为原参数指向的引用一直未发生改变。
但是对于可改变类型的数据而言，传递的也是参数的引用，但是在函数内部的修改操作不会生成新的对象，而是在原地址上修改值，所以会影响原参数的值。当函数调用结束之后，参数的值也会发生改变。
def change(a):
print(id(a))# 140725208226520 传递的是原参数的引用
a += 1
print(id(a))# 140725208226552 但是对于a的任何修改都会生成一个新的对象，重新指向
a = 10
print(id(a))# 140725208226520
change(a)
print(id(a))# 140725208226520 参数引用未变，值也不会变
def change2(b):
print(id(b))# 2649347905856
b[1] +=1
print(id(b))# 2649347905856 均为同一引用
b = [10,5,6,2,4]
print(id(b))# 2649347905856
change2(b)
print(id(b))# 2649347905856 均为同一引用
在函数中，参数的类型有必需参数(位置参数)，默认参数，关键词参数和不定长参数。
必需参数就是正常按顺序使用逗号将不同的参数分割开来，在函数调用过程之中，如果使用必需参数则要求参数的数量和顺序必须与定义时一致。
必需参数的示例：
def show(name,age):
print(f'我叫{name},我今年{age}岁了')
name = 'zhangsan'
age = 18
# 使用必需参数调用，数量和顺序必须保持一致
show(name,age) # 我叫zhangsan,我今年18岁了
show(age,name) # 错误 顺序不同 我叫18,我今年zhangsan岁了
使用关键词参数传参则对顺序无要求，但是必须数量一致。
关键词参数的示例：
def show(name,age):
print(f'我叫{name},我今年{age}岁了')
name = 'zhangsan'
age = 18
# 使用关键词参数调用，则顺序无要求。
show(age=age,name=name)# 我叫zhangsan,我今年18岁了
show(age=age)# TypeError: show() missing 1 required positional argument: 'name'
如果在函数定义时指定参数的默认值，这样可以在调用的时候可以不传递该参数而使用默认值。
默认参数示例：
def play(name,ball = 'football'):
print(f'{name} is playing {ball}')
name = 'zhangsan'
ball = 'basketball'
# 正常调用
play(name,ball)# zhangsan is playing basketball
# 使用默认参数
play(name)# zhangsan is playing football
不定长参数，如果函数定义时不确定参数的数量，可以使用不定长参数，不定长参数可以是元组，也可以是字典，前者使用一个*来指定，后者使用两个**来指定。加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。而两个星号则会以字典的方式传入。
不定长参数的示例：
# 可写函数说明
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
print (vartuple)
# 调用printinfo 函数
printinfo( 70, 60, 50 )
'''
70
(60, 50)
'''
# 也可以在调用的时候不加未命名变量参数，则传入的空元组
print(20)
'''
20
'''
def printinfo2( arg2, **vardict ):
"打印任何传入的参数"
print ("输出: ")
print (arg2)
print (vardict)
# 调用printinfo2 函数
printinfo2(1, a=2,b=3)
'''
1
{'a': 2, 'b': 3}
'''
4.返回值
return语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的 return 语句返回 None。不带参数值的return语句返回值等同于不写return语句。
def sum( arg1, arg2 ):
# 返回2个参数的和."
total = arg1 + arg2
print ("函数内 : ", total)
return total
# 调用sum函数
total = sum( 10, 20 )
print ("函数外 : ", total)
'''
函数内 : 30
函数外 : 30
'''
多返回值
python中函数允许定义多个返回值，语法是return v1,v2,v3…对于多个返回值的函数而言，可以使用多个变量来接收。
def devision(a,b):
s = (b!=0)
v = 0
if b!=0:
v = a / b
return v,s
x,y = devision(20,0)
print(x,y)# 0 False
x,y = devision(200,3)
print(x,y)#66.66666666666667 True
5.函数传参和lambda匿名函数
在PYTHON中可以使用函数名作为参数来定义函数，这种方法是逻辑上的参数传递，而没有传递真正的数据参数。然后再函数内部可以调用参数传递的函数来实现有关的功能。
def recall_fun(devision):
return devision(5,2)
def devision(a,b):
s = (b!=0)
v = 0
if b!=0:
v = a / b
return v,s
x,y = recall_fun(devision)
print(x,y)# 2.5 True
Python 使用 lambda 来创建匿名函数。所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。lambda 函数通常用于编写简单的、单行的函数，通常在需要函数作为参数传递的情况下使用，例如在 map()、filter()、reduce() 等函数中。
使用匿名函数有几个优点：
- lambda 只是一个表达式，函数体比 def 简单很多。
- lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
- lambda 遵循普通函数的作用域规则，可以读取外层作用域和全局名称。
- 虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，内联函数的目的是调用小函数时不占用栈内存从而减少函数调用的开销，提高代码的执行速度。
lambda 函数的语法只包含一个语句，如下：
lambda [arg1 [,arg2,.....argn]]:expression
solve = lambda a,b,c:-b/2*a + (b**2-4*a*c)**0.5
print(solve(2,4,9))# (-3.9999999999999996+7.483314773547883j)
需要注意的是lambda匿名函数是为了简化函数，只有一个表达式所以只有一个返回值。并不能实现复杂的函数功能。
lambda 函数通常与内置函数如 map()、filter() 和 reduce() 一起使用，以便在集合上执行操作。例如：
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared)
# 输出: [1, 4, 9, 16, 25]
数据容器
数据容器是指能存储一组数据的容器，其中的每一个数据叫做一个元素。数据容器依据是否有序，是否重复等可以划分为不同的种类。
1.列表list
列表可以用来一次性存储多个数据，每一个数据都有对应的索引，可以通过索引访问不同的元素。列表对于存储的元素没有数据类型的限制，所以元素可以是不同的数据类型，也可以是一个列表，从而形成列表的嵌套。
定义语法
#列表的定义使用中括号括起来，然后每一个元素之间使用逗号隔开。
list_name = [value1,value2,value3,...]
name_list = ['zhangsan','lisi','wangwu']
mixed_list = ['string',123,65.3,True]
nested_list = [123,['a','b','c'],[True,False],'cmd']
#空列表的定义
#语法一：使用空的中括号[]
#语法二：使用函数list()
null_list1 = []
null_list2 = list()
访问列表的值可以通过元素的索引来访问，列表的索引从0开始，步长为1一次递增。除了正向索引之外，列表还存在着反向索引，也可以从尾部开始递减，也就是最后一个元素是-1，倒数第二个是-2。要访问对应索引的值使用中括号加索引即可。
# 列表的索引访问: value = list_name[index]
class_list = ['string','class',123,True]
print(class_list[0])# 'string'
print(class_list[-1])# True
使用索引除了可以访问列表中的元素之外，还可以对列表进行切片。将列表按照对应的索引切割出子列表。
# 列表切片 sub_list = src_list[begin_index:end_index]
num_list = [1,2,3,4,5,6,7,8,9,10]
sub_list = num_list[2:5]# [3,4,5]
# begin_index和end_index都可以缺省，默认从第一个元素开始或者直到最后一个元素
sub2_list = num_list[:3]# [1,2,3]
sub3_list = num_list[5:]# [6,7,8,9,10]
# 当然也可以像访问一样通过负索引来进行切片
sub4_list = num_list[1:-2]# [2,3,4,5,6,7,8]
对列表的更新操作通过索引和函数来进行操作，可以通过索引直接将对应的元素修改为新值，如果需要添加新的元素则需要使用append()函数来实现。
num_list = [0,1,2,3]
num_list[1] = 5# [0,5,2,3]
num_list.append('zhangsan')# [0,5,2,3,'zhangsan']
如果想删除列表中的某个元素可以通过del语法来实现，需要注意的是del语法是python的一个语法，可以实现删除对象。它会删除名称绑定或容器中的元素；对象是否释放取决于是否还有引用等因素。而不只是列表特有的。
num_list = [1,2,3,4,5]
del num_list[2]# [1,2,4,5]
列表脚本操作符：还可以使用len,+,*,in,for in等对列表进行更为便捷的操作
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| len([1, 2, 3]) | 3 | 长度 |
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 |
| [‘Hi!’] * 4 | [‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’] | 重复 |
| 3 in [1, 2, 3] | True | 元素是否存在于列表中 |
| for x in [1, 2, 3]: print(x, end=” “) | 1 2 3 | 迭代 |
| num_list = [1,2,3] num_list+=[7,8,9] | num_list=[1,2,3,7,8,9] | 加等于 |
num_list = [1,2,3,4,5,6,7]
num_list += [8,9]# 拼接操作 [1,2,3,4,5,6,7,8,9]
num_list * 2# 重复 [1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9]
for i in num_list:
do_something with i
...
# 迭代列表元素
列表常用函数
| 序号 | 函数 | 作用 |
|---|---|---|
| 1 | len(list) | 列表元素个数 |
| 2 | max(list) | 返回列表元素最大值 |
| 3 | min(list) | 返回列表元素最小值 |
| 4 | list(seq) | 将元组转换为列表 |
| 5 | list.append(obj) | 在列表末尾添加新的对象 |
| 6 | list.count(obj) | 统计某个元素在列表中出现的次数 |
| 7 | list.extend(seq) | 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| 8 | list.index(obj) | 从列表中找出某个值第一个匹配项的索引位置 |
| 9 | list.insert(index, obj) | 将对象插入列表 |
| 10 | list.pop([index=-1]) | 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| 11 | list.remove(obj) | 移除列表中某个值的第一个匹配项 |
| 12 | list.reverse() | 反向列表中元素 |
| 13 | list.sort( key=None, reverse=False) | 对原列表进行排序 |
| 14 | list.clear() | 清空列表 |
| 15 | list.copy() | 复制列表 |
2.元组tuple
元组与列表类似，定义的时候，列表使用中括号，而元组使用括号。对于元组而言，也存在正向索引和反向索引，也可以通过索引对元组中的元素进行访问或者对元组进行切片。与列表不同的是元组一旦被定义不能被修改，即使可以通过加号拼接两个元组，或者对元组进行了切片，但实际上是生成了新的元组，引用发生了改变而已，原元组指向的内存的内容一旦被定义就无法发生改变。这就是元组的不可变性。
# 定义一个元组 name = (value1,value2,value3,...)
tuple1 = (1,2,3)
print(id(tuple1))
tuple2 = (4,5,6)
print(id(tuple2))
# 对元组进行拼接操作
tuple1 += tuple2
print(tuple1)
print(id(tuple1))
# 对元组进行切片操作
tuple2 = tuple2[1:2]
print(id(tuple2))
'''
元组的内存发生了改变
2629266388800
2629266379008
(1, 2, 3, 4, 5, 6)
2629263552192
2629264326224
'''
需要注意的是对于元组而言，定义空元组可以使用(),也可以不使用括号，直接将元素使用逗号分隔开。当使用小括号定义的时候，如果元组中只有一个元素的时候，需要在元素后面再加一个逗号，否则括号会被当做运算符来处理，不会定义元组。
a = ()
b = (1)
c = (2,)
d = 1,2,3,4
print(type(a))
print(type(b))
print(type(c))
print(type(d))
print(d)
'''
<class 'tuple'>
<class 'int'>
<class 'tuple'>
<class 'tuple'>
(1, 2, 3, 4)
'''
通过索引修改元组的值是非法的，因为元组不能被修改，只能通过del语句将整个元组删除。
元组有关函数
| 序号 | 方法及描述 | 实例 |
|---|---|---|
| 1 | len(tuple) 计算元组元素个数。 | >>> tuple1 = ('Google', 'Runoob', 'Taobao') >>> len(tuple1) 3 >>> |
| 2 | max(tuple) 返回元组中元素最大值。 | >>> tuple2 = ('5', '4', '8') >>> max(tuple2) '8' >>> |
| 3 | min(tuple) 返回元组中元素最小值。 | >>> tuple2 = ('5', '4', '8') >>> min(tuple2) '4' >>> |
| 4 | tuple(iterable) 将可迭代系列转换为元组。 | >>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu'] >>> tuple1=tuple(list1) >>> tuple1 ('Google', 'Taobao', 'Runoob', 'Baidu') |
| 5 | List(tuple) 将元组转换为列表 | >>>tuple1 = ('Google', 'Taobao', 'Runoob', 'Baidu') >>>list1 = list(tuple1)>>>list1['Google', 'Taobao', 'Runoob', 'Baidu'] |
3.集合set
集合是一种无序不可重复的数据容器。可以对集合进行简单的并集，交集等操作。
定义语法
和列表以及元组的定义类似，使用大括号将元素括起来，每个元素使用逗号分割。或者使用set()函数定义。set()函数传入一个序列作为参数，将其转换为集合。
set1 = {1,2,True,'cmd'}
set2 = set()
需要注意的是：定义空集合不能使用{}，因为这样定义出来的是一个字典。只能使用set()定义。集合在定义和添加元素的时候如果有重复的元素会自动去重，不会报错。
对集合的操作运算符
| 运算符 | 功能 | 示例 |
|---|---|---|
| a-b | 去除a中b的元素 | a={1,2,3,4,5,6},b={2,4,6};a-b={1,3,5} |
| a|b | 取并集 | a={1,2,3,4,5,6},b={2,4,6};a|b={1,2,3,4,5,6} |
| a&b | 取交集 | a={1,2,3,4,5,6},b={2,4,6};a&b={2,4,6} |
| a ^ b | 不同时被a和b包含的元素集合 | a={1,2,3,4,5,6},b={5,6,7,8,9};a^b={1,2,3,4,7,8,9} |
对集合元素的操作
a = {'a','c','m','d'}
# 添加元素：set_name.add(value),如果添加已存在的元素则不会进行任何操作。
a.add('v')# a = {'a','c','m','d','v'}
a.add('a')# a = {'a','c','m','d','v'}
# 批量添加元素：set_name.update(x) 其中参数可以是列表，元组，字典等可迭代的序列。可以有多个参数，用逗号隔开。
a.update([1,2,3])# a = {'a','c','m','d','v',1,2,3}
a.update([1,2,3],"hello")# a = {1, 2, 3, 'a', 'v', 'd', 'o', 'e', 'l', 'h', 'm', 'c'}
#删除元素：set_name.remove(x) 将指定元素删除，如果元素不存在则会报错
a.remove(1)# a = {2, 3, 'a', 'v', 'd', 'o', 'e', 'l', 'h', 'm', 'c'}
a.remove('n')# a.remove('n') KeyError: 'n'
# 删除元素：set_name.discard(x) 这种方法即使元素不存在也不会报错
# 删除元素：set_name.pop() 这个函数会随机删除弹出一个元素，因为集合是无序的，所以弹出的元素随机。
print(a.pop())
print(a.pop())
print(a.pop())
print(a)
'''
a
2
d
{3, 'v', 'l', 'o', 'e', 'm', 'c', 'h'}
'''
# 清空集合：set_name.clear()
a.clear()# a = set()
#判断元素是否在集合中：x in set_name
a= {'e', 2, 3, 'h', 'm', 'l', 'o', 'a', 'd', 'v', 'c'}
print('m' in a)# True
# 计算集合内元素的个数：len(s)
len(a)# 11
集合有关函数
| 方法 | 描述 |
|---|---|
| add() | 为集合添加元素 |
| clear() | 移除集合中的所有元素 |
| copy() | 拷贝一个集合 |
| difference() | 返回多个集合的差集 |
| difference_update() | 移除集合中的元素，该元素在指定的集合也存在。 |
| discard() | 删除集合中指定的元素 |
| intersection() | 返回集合的交集 |
| intersection_update() | 返回集合的交集。 |
| isdisjoint() | 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。 |
| issubset() | 判断指定集合是否为该方法参数集合的子集。 |
| issuperset() | 判断该方法的参数集合是否为指定集合的子集 |
| pop() | 随机移除元素 |
| remove() | 移除指定元素 |
| symmetric_difference() | 返回两个集合中不重复的元素集合。 |
| symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。 |
| union() | 返回两个集合的并集 |
| update() | 给集合添加元素 |
| len() | 计算集合元素个数 |
4.字符串str
以数据容器的视角来看待字符串，字符串就是字符的序列，有序，可重复。所以和前面提到的序列类似，也存在正向和反向索引，也可以通过索引来访问元素以及对字符串进行切片操作。
var1 = 'Hello World!'
var2 = "Runoob"
print ("var1[0]: ", var1[0])# var1[0]: H
print ("var2[1:5]: ", var2[1:5])# var2[1:5]: unoo
字符串操作符
a = ‘hello’
b = ‘Python’
| 操作符 | 描述 | 实例 |
|---|---|---|
| + | 字符串连接 | a + b 输出结果： HelloPython |
| * | 重复输出字符串 | a*2 输出结果：HelloHello |
| [] | 通过索引获取字符串中字符 | a[1] 输出结果 e |
| [ : ] | 截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。 | a[1:4] 输出结果 ell |
| in | 成员运算符 – 如果字符串中包含给定的字符返回 True | ‘H’ in a 输出结果 True |
| not in | 成员运算符 – 如果字符串中不包含给定的字符返回 True | ‘M’ not in a 输出结果 True |
5.字典
字典是另一种可变的数据容器，可以存储任意类型的键值对。
**定义：**字典使用大括号定义，其中每一个键值对的键与值使用冒号分割，不同的键值对使用逗号分割。注意与集合的区别，空大括号定义的是空字典而不是空集合。
d = {'a':1,'b':2,'c':3,'d':4}
print(d)# {'a': 1, 'b': 2, 'c': 3, 'd': 4}
d2 = {'key1':123,'key2':2.35,'key1':256}# d2 = {'key1':256,'key2':2.35} 当键重复的时候值会被后面定义的覆盖。
null_d = {}# 定义空字典，也可以使用dict()
注意：键必须是唯一的，但值则不必。并且值可以取任何数据类型，但键必须是不可变的，如字符串，数字。
对字典的操作
1.查看值：把相应的键放入到方括号中
d = {'a':1,'b':2,'c':3,'d':4}
print(d['a'])# 1
如果访问的键名不存在则会报错
d = {'a':1,'b':2,'c':3,'d':4}
print(d[0])# print(d2[0])
# ~~^^^ KeyError: 0
2.向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对
d = {'a':1,'b':2,'c':3,'d':4}
d['a'] = 233# 修改原有的键值对
d['e'] = 'hello'# 添加新的键值对
print(d)# {'a': 233, 'b': 2, 'c': 3, 'd': 4, 'e': 'hello'}
3.删除键值对或者字典
#删除单个键值对可以使用del语句
d = {'a':1,'b':2,'c':3,'d':4}
del d['a']
print(d)# {'b': 2, 'c': 3, 'd': 4}
或者使用clear()函数清空整个字典
d.clear()
print(d)# {}
字典有关函数的使用
| 序号 | 函数|描述 | | :— | :—–:—————————————————— | —- | | 1 | dict.clear() | 删除字典内所有元素 | | 2 | dict.copy()] | 返回一个字典的浅复制 | | 3 | dict.fromkeys() | 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 | | 4 | dict.get(key, default=None) | 返回指定键的值，如果键不在字典中返回 default 设置的默认值 | | 5 | key in dict | 如果键在字典dict里返回true，否则返回false | | 6 | dict.items() | 以列表返回一个视图对象 | | 7 | dict.keys() | 返回一个视图对象 | | 8 | dict.setdefault(key, default=None) | 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default | | 9 | dict.update(dict2) | 把字典dict2的键/值对更新到dict里 | | 10 | dict.values() | 返回一个视图对象 | | 11 | pop(key[,default]) | 删除字典 key（键）所对应的值，返回被删除的值。 | | 12 | popitem() | 返回并删除字典中的最后一对键和值。 | | 13 | str(dict) | 将字典转换为可打印的字符串。 | | 14 | len(dict) | 计算字典元素个数，即键的总数。 |
6.数据容器的通用操作
1.都可以使用for循环对数据容器中的元素进行遍历操作。
2.都可以使用len(),max(),min()函数对数据容器进行统计。
但是需要注意的是max(),min()函数取最大最小值对于字符串而言是按 Unicode 码点顺序进行字典序比较，对于字典容器而言，比较的是键名，会将键值丢弃。
3.除了字典，每一个数据容器都有对应的转换函数，可以将其他容器转换为该容器。
但是需要注意的是字典可以转换为其他容器，但是会将值丢弃，只保留键名，并且字典可从键值对组成的可迭代对象构造，例如 dict([(‘a’, 1)])。
4.可以使用 sorted(c, reverse=True) 对可迭代对象排序并返回新列表；列表自身也有原地排序的 list.sort() 方法，对于字典而言会将键值舍弃，将键名排序。对于字符串而言同样是按 Unicode 码点顺序比较。
评论发表评论 ＋
评论