组合数据类型
1.1 集合类型
1.1.1 集合类型的定义
def:集合是多个元素的无序组合
-
集合元素之间无序,每个元素唯一,不存在相同元素
-
集合元素不可更改,是不可变数据类型(immutable)
-
集合用大括号{}表示,元素间逗号分隔
-
建立集合类型用{}或set()
-
建立空集合类型必须使用set()
>>> A = {"python", 123, ("python",123)} >>> A {123, 'python', ('python', 123)} >>> B = set("pypy123") >>> B {'1', '2', '3', 'y', 'p'} >>> C = {"python", 123, "python", 123} >>> C {123, 'python'}
1.1.2 集合操作符
-
" | " —— 并运算union
-
" - " —— 差运算difference
-
" & " —— 交运算intersection
-
" ^ " —— 补运算symmestric_difference
-
" > " " < " " >= " " <= " —— 判断集合包含关系,返回True/False
增强运算符:" |= " " -= " " &= " " ^= ">>> A = {"p", "y", 123} >>> B = set("pypy123") >>>> A - B {123} >>> B - A {'1', '3', '2'} >>> A & B {'p', 'y'} >>> A | B {'1', '2', '3', 'y', 'p', 123} >>> A ^ B {'1', '2', '3', 123}
1.1.3 集合处理方法
-
S.add(x) —— 若x不在集合S中,则添加
-
S.discard(x) —— 移除S中的元素x,若x不在集合S中,不报错
-
S.remove(x) —— 移除S中元素x,若x不在集合S中,产生KeyError异常。(可用try-except捕捉异常)
-
S.clear() —— 移除S中所有元素
-
S.pop() —— 随即返回S的一个元素,更新S,若S为空,产生KeyError异常
-
S.copy() —— 返回集合S的一个副本
-
S.update() —— 更新集合,添加新元素
>>> a = {1,2,3} >>> a.update({2,3,4}) >>> a {1, 2, 3, 4}
-
len(S) —— 返回集合S中的元素个数
-
x in S —— 判x是否在集合S中,是,返回True,否则False
-
x not in S —— 判x是否不在集合S中,是,返回True,否则False
-
set(x) —— 将其他类型变量x转变为集合类型
>>> A = {"p", "y", 123} >>> for item in A: print(item, end="") 123py >>> A {123, 'p', 'y'} >>> try: while True: print(A.pop(), end="") except: pass 123py >>> A set()
1.1.4 集合类型的应用
-
包含关系比较
>>> "p" in {"p", "y", 123} True >>> {"p", "y",} >= {"p", "y", 123} False
-
数据去重★:集合类型所有元素无重复!
>>> ls = ["p", "p", "y", "y", 123] >>> s = set(ls) >>> s {123, 'p', 'y'} >>> lt = list(s) >>> lt [123, 'p', 'y']
1.2 序列类型
-
序列包括列表、元组和字符串。
-
通用的序列操作:索引、切片、序列相加、相乘、成员资格。
不能拼接不同类型的序列。
补充:集合实例
1.2.1 列表
列表是可修改的
-
执行切片操作时,若第一个索引指定的元素位于第二个索引指定元素后面,结果就为空序列。除非指定步长为负数,此时要特别注意边界包含关系切勿混淆。
>>> numbers = [1,2,3,4,5,6,7,8,9,10] >>> numbers[-3:-1] [8, 9] >>> numbers[-3:0] [] >>> numbers[8:1:-2] # 此时,区间包含numbers[8]但不包含numbers[1],即包含9但不包含2 [9, 7, 5, 3]
-
执行索引操作技巧
>>> fourth = input("Year: ")[3] Year: 2005 >>> fourth '5'
-
空列表初始化
>>> sequence = [None] * 10 >>> sequence [None, None, None, None, None, None, None, None, None, None]
不能给不存在的元素做赋值操作,须申请列表空间,如上👆,否则会报错。
>>> ls = [None] * 3 >>> ls [None, None, None] >>> ls[4] = 0 Traceback (most recent call last): File "<pyshell#5>", line 1, in <module> ls[4] = 0 IndexError: list assignment index out of range
-
函数list(seq)
使用字符串创建列表。>>> list('Hello') ['H', 'e', 'l', 'l', 'o']
-
赋值及删除
-
赋值
>>> x = [1,1,1] >>> x[1] = 2 >>> x [1, 2, 1]
-
删除
>>> nums = ['1','2','3','4','5','6'] >>> del nums[2] >>> nums ['1', '2', '4', '5', '6']
-
切片操作
-
赋值
>>> name = list('Perl') >>> name ['P', 'e', 'r', 'l'] >>> name[2: ] = list('ar') >>> name ['P', 'e', 'a', 'r']
>>> name = list('Perl') >>> name[2:] = 'ar' >>> name ['P', 'e', 'a', 'r']
-
替换
>>> name[1: ] = list('ython') >>> name ['P', 'y', 't', 'h', 'o', 'n']
-
插入(“替换”一个空切片)
>>> nums = [1,5] >>> nums[1:1] = [2,3,4] >>> nums [1, 2, 3, 4, 5]
-
删除
>>> nums [1, 2, 3, 4, 5] >>> nums[1:4] = [] >>> nums [1, 5]
-
-
-
复制列表
>>> lis1 = [1,2,3,4] >>> lis2 = lis1 >>> lis3 = lis1[:] >>> lis1.append(5) >>> lis1 [1, 2, 3, 4, 5] >>> lis2 [1, 2, 3, 4, 5] >>> lis3 [1, 2, 3, 4]
使用👆“ [:] ”进行复制,可以变成两个不同的列表。
1.2.1.1 列表方法
-
ls.append(x)
>>> ls = ['cat','dog','tiger',1024] >>> ls.append(1234) >>> ls ['cat', 'dog', 'tiger', 1024, 1234]
-
ls.clear()
>>> ls = ['cat','dog','tiger'] >>> ls.clear() >>> ls []
-
ls.copy()
>>> ls = ['cat','dog','tiger',1024] >>> txt = ls.copy() >>> txt ['cat', 'dog', 'tiger', 1024] >>> txt.remove(txt[2]) >>> txt ['cat', 'dog', 1024] >>> ls ['cat', 'dog', 'tiger', 1024]
-
ls.count(x)
>>> ls = [1,6,8,7,2,7,8,7,7] >>> ls.count(7) 4
-
ls.extend(L)
>>> ls = [1, 2, 3] >>> ls.extend([4, 5, 6]) >>> ls [1, 2, 3, 4, 5, 6]
-
ls.index(x)
>>> ls = ['cat','dog','tiger',1024] >>> ls.index('tiger') 2
还可以指定搜索范围,若不存在则抛出 ValueError 异常
ls.index(value[start, [stop]]) -
ls.insert(n,x)
>>> ls = ['cat','dog','tiger',1024] >>> ls.insert(3,'human') >>> ls ['cat', 'dog', 'tiger', 'human', 1024]
-
ls.pop(i)
>>> ls = ['cat','dog','tiger',1024] >>> ls.pop(2) 'tiger' >>> ls ['cat', 'dog', 1024]
如果给出的索引超出了指定范围,则抛出异常。
不指定参数,默认删除列表最后的元素。>>> d = [1,2,3,4,5,6,7] >>> d.pop() 7 >>> d [1, 2, 3, 4, 5, 6]
-
ls.remove(x) —— 仅移除正序的第一个x(即首次出现),如果该元素不存在,抛出异常
-
ls.reverse()
>>> ls = ['cat','dog','tiger',1024] >>> ls.reverse() >>> ls [1024, 'tiger', 'dog', 'cat']
对比reversed():
① reversed()方法直接返回如👇所示的内部数据类型
② 通过reversed()方法获取逆序列表需用list()收集
③ reversed()方法并不修改原件>>> ls = ['cat','dog','tiger',1024] >>> reversed(ls) <list_reverseiterator object at 0x00000262034AAFA0> >>> list(reversed(ls)) [1024, 'tiger', 'dog', 'cat'] >>> ls ['cat', 'dog', 'tiger', 1024]
-
ls.sort() —— 对 同种 类型的数据进行排序(默认从小到大),还可指定 key 以及 reverse
>>> ls = [6,1,7,9,5,4,3,8,2,0] >>> ls.sort() >>> ls [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] ----------------------------------------------- >>> x = ['1', '345', '23', '34343434', '9999'] >>> x.sort(key=len, reverse=True) >>> x ['34343434', '9999', '345', '23', '1']
对比sorted(list, key, reverse):
①sorted()方法可以指定排序关键字key以及是否逆序,默认是按值排序、不逆序
②sorted()方法不就地修改原件>>> d = {'B':[1],'A':[3,3,3],'C':[2,2]} >>> sorted(d.items(), key=lambda d:len(d[1]), reverse=True) [('A', [3, 3, 3]), ('C', [2, 2]), ('B', [1])] >>> sorted(d.items(), key=lambda d:d, reverse=True) [('C', [2, 2]), ('B', [1]), ('A', [3, 3, 3])]
lambda匿名函数在排序中,支持多条件排序!!!
形式👇:
key = lambda <序列名> : (参数1, 参数2, 参数3……)
1.2.2 元组
元组是不!可!修改的!(immutable)
-
创建
①>>> 1,2,3 (1, 2, 3)
②常用做法
>>> (1,2,3) (1, 2, 3)
③空元组
>>> () ()
特殊的,表示仅包含一个值的元组:
X>>> 42 42
√ 需在她后面加上逗号
>>> 42, (42,)
-
函数tuple() —— 将一个序列作为参数,转化为元组
>>> tuple([1,2,3]) (1, 2, 3) >>> tuple('abc') ('a', 'b', 'c') >>> tuple((1,2,3)) (1, 2, 3)
※引入元组的原因
- 它们用作映射中的键(以及集合中的成员),列表不行
- 有些内置函数和方法返回元组
- 给元组赋值是合法的
>>> x = (1, 2, 3) >>> x = (4, 5, 6) >>> x (4, 5, 6)
1.2.3 字符串
def:由0个或多个字符组成的有序字符序列
使用input()获得的用户输入都是字符串!!!
※字符串是不!可!修改的!(immutable)
- 字符串由一对单引号或一对双引号表示
由一对单引号或一对双引号,仅表示单行字符串
由一对三单引号或三双引号,可表示多行字符
长字符串:由一对三引号表示
原始字符串:使用前缀r表示
>>> print('C:\nowhere')
C:
owhere
--------------
>>> print(r'C:\nowhere')
C:\nowhere
——※原始字符串不能以单个反斜杠结尾。
>>> print(r'123\')
SyntaxError: EOL while scanning string literal
——※若对此反斜杠转义,用于转义的反斜杠也将是字符串的一部分
>>> print(r'123\\')
123\\
——※若指定以反斜杠结尾的方法:
>>> print(r'123''\\')
123\
-
字符串是有序序列,可以对其中的字符进行索引
-
索引
返回字符串中的单个字符。>>> tempstr = '1','23','4','5','6' >>> print(tempstr) ('1', '23', '4', '5', '6') >>> tempstr[0] '1' >>> tempstr[1] '23'
-
切片
返回字符串中一段字符串。>>> tempstr = '1','23','4','5','6' >>> tempstr[0:-1] ('1', '23', '4', '5') >>> tempstr[1:3] ('23', '4') >>> tempstr[::2] ('1', '4', '6') >>> tempstr[::-1] #逆置输出,不修改字符串。 ('6', '5', '4', '23', '1') >>> print(tempstr) ('1', '23', '4', '5', '6')
1.2.3.1 转义字符
与数一样,字符串也是值。
>>> 'Let 's go'
SyntaxError: invalid syntax
Python识别了 'Let ',但不知道怎么处理余下内容。
处理:
法①:双引号解决分歧
>>> "Let's go"
"Let's go"
法②:引入反斜杠“\”转义
>>> 'Let\'s go'
"Let's go"
转义字符
转义字符 | 含义 | 转义字符 | 含义 |
---|---|---|---|
\n | 换行符(光标移动到下行首) | \ " | 双引号 |
\t | 制表符 | \ \ | 一个\ |
\r | 回车(光标移动到本行首) | \ ddd | 3位八进制数对应的字符 |
\ ’ | 单引号 | \ xhh | 2位十六进制数对应的字符 |
\b | 回退 |
1.2.3.2 str与repr
- str是一个类,repr是一个函数
>>> print(repr("Hello,\nworld!"))
'Hello,\nworld!'
>>> print(str("Hello,\nworld!"))
Hello,
world!
>>> print("{pi!s} {pi!r} {pi!a}".format(pi = "Π"))
Π 'Π' '\u03a0'
-
ascii(obj, /):
Return an ASCII-only representation of an object.As repr(), return a string containing a printable representation of an
object, but escape the non-ASCII characters in the string returned by
repr() using \x, \u or \U escapes. This generates a string similar
to that returned by repr() in Python 2.>>> ascii('a') "'a'" >>> ascii(97) '97' >>> ascii('python') "'python'" >>> print(ascii('python')) 'python'
s、r和a指定分别使用str、repr和ascii进行转化。
- 函数str通常创建外观普通的字符串版本。
- 函数repr尝试创建给定值的python表示。
- 函数ascii创建只包含ASCII字符的表示。
1.2.3.3 字符串操作
x + y——连接两个字符串
n * x 或 x * n——复制n次字符串x
x in s——判x是s的子串,是则返回True,否则Flase
-
实例:
# 在位于屏幕中央且宽度合适的方框内打印一个句子 sentence = input("Sentence: ") screen_width = 80 text_width = len(sentence) box_width = text_width + 6 left_margin = (screen_width - box_width) // 2 print() print(' ' * left_margin + '+' + '-' * (text_width+4) + '+') print(' ' * left_margin + '| ' + ' ' * text_width + ' |') print(' ' * left_margin + '| ' + sentence + ' |') print(' ' * left_margin + '| ' + ' ' * text_width + ' |') print(' ' * left_margin + '+' + '-' * (box_width-2) + '+') print()
-
输出:
Sentence: He is a very naughty boy! +-----------------------------+ | | | He is a very naughty boy! | | | +-----------------------------+
1.2.3.4 字符串处理函数
- len()
>>> len("一二三456")
6
- str()
>>> str(1.23)
'1.23'
>>> str([1,2])
'[1, 2]'
- hex() ——十六进制 或 oct()——八进制
>>> hex(425)
'0x1a9'
-------------
>>> oct(425)
'0o651'
- chr()
将 Unicode 转化为 单字符 - ord()
将 单字符 转化为 Unicode
>>> "1 + 1 = 2" + chr(10004)
'1 + 1 = 2✔'
------------------------------------------------
>>> "这个字符♉的Unicode值是:" + str(ord("♉"))
'这个字符♉的Unicode值是:9801'
------------------------------------------------
>>> for i in range(12):
print(chr(9800+i),end = "")
♈♉♊♋♌♍♎♏♐♑♒♓
1.2.3.5 字符串处理方法
-
str.lower() 或 str.upper()
>>> "AbCdefG".upper() 'ABCDEFG'
在检索“同一英文名的不同大小写”形式时非常实用。
-
str.split()★
>>> "A,B,C".split(",") ['A', 'B', 'C']
>>> "python".split("o") ['pyth', 'n']
如没有指定分隔符,默认在单个或多个连续的空白符处拆分。
-
str.join(string)★ —— 在给定字符串的每个字符之间添加str
>>> ",".join("12345") '1,2,3,4,5'
-
str.count()
>>> "an apple a day".count("a") 4
补充:.ljust()、.rjust()
>>> 'hello'.center(20, '=') '=======hello========' >>> 'hello'.ljust(20, '=') 'hello===============' >>> 'hello'.rjust(20, '=') '===============hello'
-
str.replace(old, new, max)
>>> "python".replace("n","n123.io") 'python123.io'
参数max指定子串替换的最大次数
-
str.center()
>>> "Nice!".center(20,"=") '=======Nice!========'
-
str.strip()★ —— 从左向右以及从右向左的方向删除所列字符,遇到不是所列字符即停止
>>> "8 aba1a5ca a8 1".strip(" bc158") 'aba1a5ca a'
无指定参数时,默认删除字符串左右的空白。
在处理文本中,消除行末的回车符 ‘\n’ 常用。※ 补充:
.lstrip()方法 —— 用于截去字符串左边的空字符串
.rstrip()方法 —— 用于截去字符串右边的空字符串>>> ' \n123\n'.lstrip() '123\n' >>> ' \n123\n '.rstrip() ' \n123'
-
str.find()
>>> 'abcdefge'.find('e') 4
还可指定搜索的起点、终点。
>>> 'abcdefge'.find('e',6) 7 >>> 'abcdefg'.find('e',0,3) -1
-
str.title() —— 以字符串中每个单词首字母大写的方式显示字符串
>>> "what a nice day!".title() 'What A Nice Day!'
-
str.capitalize() —— 字符串首字母大写
>>> ls = 'dog is cute' >>> ls.title() 'Dog Is Cute' >>> ls 'dog is cute' >>> ls.capitalize() 'Dog is cute' >>> ls 'dog is cute' >>> '23sd'.capitalize() '23sd'
-
str.tanslate()★
一般搭配maketrans()使用~maketrans()创建映射字典,进而translate()根据字典“翻译”相应字符串>>> str.maketrans({'a':1, 'b':2, 'c':3}) {97: 1, 98: 2, 99: 3} >>> str.maketrans('abc', '123') {97: 49, 98: 50, 99: 51} >>> d = str.maketrans('abc', '123') >>> 'aabbcc'.translate(d) '112233' >>> 'kkkaabbcc'.translate(d) 'kkk112233' >>> str.maketrans('abc', '123', '456') {97: 49, 98: 50, 99: 51, 52: None, 53: None, 54: None} >>> str.maketrans('abc', '123', 'efg', '456') Traceback (most recent call last): File "<pyshell#4>", line 1, in <module> str.maketrans('abc', '123', 'efg', '456') TypeError: maketrans expected at most 3 arguments, got 4
-
其他:判断字符串是否满足特定条件
isspace()、isdigit()、isalpha()、isupper()、islower()、isalnum()等等
返回True or Falseisnumeric() —— 判断字符串是否仅由数字组成
Python中 isdigit() 和 isnumeric() 的区别isalnum() —— 判断字符串中是否仅由字母或数字组成
实例:将列表中非字母或数字组成的的字符串过滤
>>> seq = [‘foo’, ‘x41’, ‘?1’, ‘***’]
方法① —— 定义函数判断>>> def func(x): return x.isalnum() >>> list(filter(func, seq)) ['foo', 'x41']
方法② —— 列表推导√√√
>>> [x for x in seq if x.isalnum()] ['foo', 'x41']
方法③ —— 匿名函数lambda
>>> filter(lambda x : x.isalnum(), seq)
-
补充: 函数sorted()
函数sorted()用于排序,其对象一般是列表,
但是,字符串可直接当作对象,返回字符串中对每一个字符的排序列表>>> num = '0123' >>> sorted(num, reverse=True) ['3', '2', '1', '0']
-
str.swapcase() —— 交换大小写
>>> s = 'What Is Your Name?' >>> s.swapcase() 'wHAT iS yOUR nAME?'
-
str.startswith()、str.endswith()
>>> s = 'Beautiful is better than ugly.' >>> s.startswith('Be') True >>> s.startswith('Be', 5) #指定检测起始位置 False >>> s.startswith('Be', 0, 5) True
另外还可接收一个字符串元组作为前缀或后缀
>>> import os >>> os.listdir('/Users/Documents') ['496eedf122c714cc14808d15ae3a3be2.jpg', 'python', '.localized'] >>> [filename for filename in os.listdir('/Users/Documents') if filename.endswith(('.jpg', '.bmp', '.gif'))] ['496eedf122c714cc14808d15ae3a3be2.jpg']
1.2.3.6 字符串类型的格式化
.format()
类型 | 含义 |
---|---|
b | 将整数表示为二进制 |
c | 将整数解读为Unicode码点 |
d | 整数视为十进制数(默认) |
e | 科学表示法表示小数(用e表示指数) |
E | 与e相同,但使用E表示指数 |
f | 将小数表示为定点数 |
F | 与f相同,但对于特殊值(nan和inf),使用大写表示 |
g | 自动选择定点表示法或科学表示法。是默认用于小数的说明符,默认情况下至少有1位小数 |
G | 与g相同,但用大写来表示指数和特殊值 |
n | 与g相同,但插入随区域而异的数字分隔符 |
o | 将整数表示为八进制数 |
s | 保持字符串的格式不变(默认用于字符串的说明符) |
x | 将整数表示为十六进制并使用小写字母 |
X | 与x相同,但使用大写字母 |
% | 将数表示为百分比值(乘以100,按 f 设置格式,最后加上%) |
★★★
小数精度控制遵循四舍五入
>>> print('{:.2f}'.format(12.357))
12.36
>>> print('{:.2f}'.format(12.355))
12.36
>>> print('{:.2f}'.format(12.354))
12.35
%的实例
>>> print('{:.3f}'.format(0.132))
0.132
>>> print('{:.3f%}'.format(0.132))
Traceback (most recent call last):
File "<pyshell#29>", line 1, in <module>
print('{:.3f%}'.format(0.132))
ValueError: Invalid format specifier
>>> print('{:.3%}'.format(0.132))
13.200%
>>> print('{:.1%}'.format(0.132))
13.2%
实例:
# 根据指定宽度打印格式良好的表格
width = int(input('Please enter width: '))
price_width = 10
item_width = width - price_width
header_fmt = '{{:{}}}{{:>{}}}'.format(item_width, price_width)
fmt = '{{:{}}}{{:>{}.2f}}'.format(item_width, price_width)
print('=' * width)
print(header_fmt.format('Item','Price'))
print('-' * width)
print(fmt.format('Apples',0.4))
print(fmt.format('Pears',0.5))
print(fmt.format('Cantaloupes',1.92))
print(fmt.format('Dried Apricots (16 oz.)',8))
print(fmt.format('Prunes (4 lbs.)',12))
print('=' * width)
输出:
Please enter width: 35
===================================
Item Price
-----------------------------------
Apples 0.40
Pears 0.50
Cantaloupes 1.92
Dried Apricots (16 oz.) 8.00
Prunes (4 lbs.) 12.00
===================================
1.2.3.7 格式化字符串f-string
f-string,亦称为格式化字符串常量(formatted string literals),是Python3.6新引入的一种字符串格式化方法,该方法源于PEP 498 – Literal String Interpolation,主要目的是使格式化字符串的操作更加简便。
>>> name = 'Molly'
>>> status = 'princess'
>>> f'{name} is a {status}'
'Molly is a princess'
1.3 映射类型
映射(mapping):映射是一种键(索引)和值(数据)的对应
字典是Python中唯一的内置映射类型。
1.3.1 字典
def:
字典由键及其相应的值组成,这种键值对称为项(item)。
- 键值对:键是数据索引的拓展
- 字典是键值对的集合,键值对之间无序
- 采用大括号{}和dict()创建,键值对用冒号:表示
注:在字典(以及其他映射类型)中,键必须是独一无二的,而字典中的值无须如此。
1.3.1.1 字典的用途
- 表示棋盘的状态,其中每个键都是由坐标组成的元组。
- 存储文件修改使用时间,其中的键为文件名。
- 数字电话/地址簿。
1.3.1.2 创建和使用字典
1.3.1.2.1 函数dict
>>> items = [('name','Gumby'),('age',42)]
>>> d = dict(items)
>>> d
{'name': 'Gumby', 'age': 42}
>>> d['name']
'Gumby'
还可以使用关键字实参来调用:
>>> d = dict(name = 'Gumby',age = 42)
>>> d
{'name': 'Gumby', 'age': 42}
- 列表和字典的比较
>>> x = [] >>> type(x) <class 'list'> >>> x[42] = 'Foobar' Traceback (most recent call last): File "<pyshell#34>", line 1, in <module> x[42] = 'Foobar' IndexError: list assignment index out of range ---------------------------------------------- >>> x = {} >>> type(x) <class 'dict'> >>> x[42] = 'Foobar' >>> x {42: 'Foobar'}
- 字典中列表的创建和连接★★★
几种基本的字典创建方法:>>> d = {} >>> d['A'] = [] >>> d {'A': []} >>> d['A'] = [1] >>> d {'A': [1]} >>> d['A'] += [2] >>> d {'A': [1, 2]} >>> d['B'] = [4,5,6] >>> d {'A': [1, 2], 'B': [4, 5, 6]} >>> len(d) 2 >>> len(d['A']) 2 >>> len(d['B']) 3
- 使用=赋值
>>> price = {'pork':35, 'beef':43, 'chicken':12} >>> price {'pork': 35, 'beef': 43, 'chicken': 12}
- 使用内置函数dict()通过已有数据快速建立
>>> cost = [35, 43, 12] >>> meat = ['pork', 'beef', 'chicken'] >>> price = dict(zip(meat, cost)) >>> price {'pork': 35, 'beef': 43, 'chicken': 12}
- 使用内置函数dict()指定“键-值”对
>>> price = {} >>> price = dict('pork' = 35, 'beef' = 43, 'chicken' = 12) SyntaxError: expression cannot contain assignment, perhaps you meant "=="? # 注意:这种赋值方法,“键”不需要添加引号!创建成功后会自动添加 >>> price = dict(pork = 35, beef = 43, chicken = 12)
- 利用fromkeys()方法,创建指定“键”,“值”为空的字典
注意:fromkeys初始化字典直接返回值,不修改原件,因此需要重新赋值>>> price = dict() >>> price {} >>> price.fromkeys(meat) {'pork': None, 'beef': None, 'chicken': None} >>> price.fromkeys(meat, 0) {'pork': 0, 'beef': 0, 'chicken': 0} >>> price {} >>> price = price.fromkeys(meat,0) >>> price {'pork': 0, 'beef': 0, 'chicken': 0}
- 使用=赋值
1.3.1.2.2 基本的字典操作
-
del d[k] 删除字典中不需要的键值对
>>> d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"} >>> del d["美国"] >>> d {'中国': '北京', '法国': '巴黎'}
-
k in d —— 查找的是键
>>> d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"} >>> "中国" in d True
-
d.keys() —— 列出所有键
>>> d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"} >>> d.keys() dict_keys(['中国', '美国', '法国'])
-
d.values() —— 列出所有值
>>> d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"} >>> d.values() dict_values(['北京', '华盛顿', '巴黎'])
-
d.items() —— 列出所有项(键值对)
>>> d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"} >>> d.items() dict_items([('中国', '北京'), ('美国', '华盛顿'), ('法国', '巴黎')])
👆形成将键和值组成元组的内部数据类型
扩展:结合sorted()方法>>> d = {'A': [1, 2], 'B': [4, 5, 6], 'C': [3]} >>> sorted(d.items(), key=lambda d:len(d[1]), reverse=False) [('C', [3]), ('A', [1, 2]), ('B', [4, 5, 6])] >>> sorted(d.items(), key=lambda d:len(d[1]), reverse=True) [('B', [4, 5, 6]), ('A', [1, 2]), ('C', [3])]
-
d.get(k, < default >)相比用“键”来获取对应的值,更推荐安全的get()方法
>>> d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"} >>> d.get("中国","伊斯兰堡") '北京' >>> d = {'a' : 1} >>> print(d.get('b')) None
-
d.pop(k, < default >)
>>> d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"} >>> d.pop("中国","伊斯坦布尔") '北京' >>> d {'美国': '华盛顿', '法国': '巴黎'} >>> d.pop("俄罗斯","伊斯坦布尔") '伊斯坦布尔' >>> d {'美国': '华盛顿', '法国': '巴黎'}
-
d.popitem() —— 随机从字典d中取出一个键值对,以元组形式返回。
>>> d = {"中国":"北京","法国":"巴黎"} >>> d.popitem() ('法国', '巴黎') >>> d.popitem() ('中国', '北京') >>> d.popitem() Traceback (most recent call last): File "<pyshell#83>", line 1, in <module> d.popitem() KeyError: 'popitem(): dictionary is empty'
-
d.update(dict)
将另一个字典的键值对一次性全部添加到当前字典对象。
如果两个字典中存在相同的键,则以另一个字典中的值为准,对准当前字典进行更新。>>> d = {'a':1} >>> d.update({'b':2, 'c':3}) >>> d {'a': 1, 'b': 2, 'c': 3} >>> d.update({'a':1111, 'd':4}) >>> d {'a': 1111, 'b': 2, 'c': 3, 'd': 4}
-
d.clear()
>>> d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"} >>> x = d >>> x = {} >>> d {'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
对比:
>>> d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"} >>> x = d >>> x.clear() >>> d {}
-
len(d)
>>> d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"} >>> len(d) 3
-
copy() —— 该方法执行的是浅复制,因为值本身是原件,而非副本
>>> d = {"中国":"北京","美国":"华盛顿","法国":["巴黎","里昂"]} >>> x = d.copy() >>> x["美国"] = "伦敦" >>> x["法国"].remove("巴黎") >>> x {'中国': '北京', '美国': '伦敦', '法国': ['里昂']} >>> d {'中国': '北京', '美国': '华盛顿', '法国': ['里昂']}
当替换副本中的值时,原件不受影响。
如果修改副本中的值(就地修改而不是替换),原件也将发生变换。没太理解为避免这种问题,可以执行深复制,即同时复制值及其包含的所有值。
可使用copy模块中的deepcopy>>> from copy import deepcopy >>> d = {} >>> d['names'] = ['Alfred', 'Bertrand'] >>> c = d.copy() >>> dc = deepcopy(d) >>> d['names'].append('Clive') >>> c {'names': ['Alfred', 'Bertrand', 'Clive']} >>> dc {'names': ['Alfred', 'Bertrand']}
-
fromkeys(seq, value=None) —— 创建一个新字典,其中包含序列seq中所指定的键,且每个键对应的值都是value。
>>> d = {} >>> d.fromkeys([1,2,3,4,5,6], 0) {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0} >>> d {}
- 字典实例:
输出示例:# 一个简单的数据库 # 一个将人名用作键的字典。每个人都用一个字典表示。 people = { 'Alice': { 'phone': '2341', 'addr': 'Foo drive 23' }, 'Beth': { 'phone':'9102', 'addr':'Bar street 42' }, 'Cecil': { 'phone':'3158', 'addr':'Baz avenue 90' } } # 电话号码和地址的描述性标签,供打印输出时使用,提高可读性 labels = { 'phone':'phone number', 'addr':'address' } name = input('Name: ') # 要查找电话还是地址 request = input('Phone number (p) or address (a)? ') # 使用正确的键 if request == 'p': key = 'phone' if request == 'a': key = 'addr' # 仅当名字是字典包含的键时才打印信息 if name in people: print("{}'s {} is {}.".format(name,labels[key],people[name][key]))
Name: Beth Phone number (p) or address (a)? p Beth's phone number is 9102.
- setdefault() —— 有点像get(),它也获取与指定键相关联的值,此外,在不包含指定键时进行添加
>>> d = {} >>> d.setdefault('name', 'N/A') 'N/A' >>> d {'name': 'N/A'} >>> d['name'] = 'Gumby' >>> d.setdefault('name', 'N/A') 'Gumby' >>> d {'name': 'Gumby'}
1.3.1.2.3 将字符串式设置功能用于字典
- 字典中的format方法format_map
像这样使用字典时,可以使用任意数量的转换说明符。>>> phonebook = {'Beth': '9102', 'Alice': '2341', 'Cecil': '3258'} >>> "Cecil's phone number is {Cecil}.".format_map(phonebook) "Cecil's phone number is 3258."