Python —— 第一部分 序列

组合数据类型

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 集合操作符

1. " | " —— 并运算union

2. " - " —— 差运算difference

3. " & " —— 交运算intersection

4. " ^ " —— 补运算symmestric_difference

5. " > " " < " " >= " " <= " —— 判断集合包含关系，返回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 列表方法

1. ls.append(x)

   >>> ls = ['cat','dog','tiger',1024]
   >>> ls.append(1234)
   >>> ls
   ['cat', 'dog', 'tiger', 1024, 1234]
   

2. ls.clear()

   >>> ls = ['cat','dog','tiger']
   >>> ls.clear()
   >>> ls
   []
   

3. 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]
   

4. ls.count(x)

   >>> ls = [1,6,8,7,2,7,8,7,7]
   >>> ls.count(7)
   4
   

5. ls.extend(L)

   >>> ls = [1, 2, 3]
   >>> ls.extend([4, 5, 6])
   >>> ls
   [1, 2, 3, 4, 5, 6]
   

6. ls.index(x)

   >>> ls = ['cat','dog','tiger',1024]
   >>> ls.index('tiger')
   2
   

   还可以指定搜索范围，若不存在则抛出 ValueError 异常
   ls.index(value[start, [stop]])

7. ls.insert(n,x)

   >>> ls = ['cat','dog','tiger',1024]
   >>> ls.insert(3,'human')
   >>> ls
   ['cat', 'dog', 'tiger', 'human', 1024]
   

8. 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]
   

9. ls.remove(x) —— 仅移除正序的第一个x（即首次出现），如果该元素不存在，抛出异常

10. 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]
    

11. 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)
  

※引入元组的原因

1. 它们用作映射中的键（以及集合中的成员），列表不行
2. 有些内置函数和方法返回元组

• 给元组赋值是合法的

  >>> 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 字符串处理函数

1. len()

>>> len("一二三456")
6

2. str()

>>> str(1.23)
'1.23'
>>> str([1,2])
'[1, 2]'

3. hex() ——十六进制 或 oct()——八进制

>>> hex(425)
'0x1a9'
-------------
>>> oct(425)
'0o651'

4. chr()
   将 Unicode 转化为 单字符
5. 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 字符串处理方法

1. str.lower() 或 str.upper()

   >>> "AbCdefG".upper()
   'ABCDEFG'
   

   在检索“同一英文名的不同大小写”形式时非常实用。

2. str.split()★

   >>> "A,B,C".split(",")
   ['A', 'B', 'C']
   

   >>> "python".split("o")
   ['pyth', 'n']
   

   如没有指定分隔符，默认在单个或多个连续的空白符处拆分。

3. str.join(string)★ —— 在给定字符串的每个字符之间添加str

   >>> ",".join("12345")
   '1,2,3,4,5'
   

4. str.count()

   >>> "an apple a day".count("a")
   4
   

   补充：.ljust()、.rjust()

   >>> 'hello'.center(20, '=')
   '=======hello========'
   >>> 'hello'.ljust(20, '=')
   'hello==============='
   >>> 'hello'.rjust(20, '=')
   '===============hello'
   

5. str.replace(old, new, max)

   >>> "python".replace("n","n123.io")
   'python123.io'
   

   参数max指定子串替换的最大次数

6. str.center()

   >>> "Nice!".center(20,"=")
   '=======Nice!========'
   

7. str.strip()★ —— 从左向右以及从右向左的方向删除所列字符，遇到不是所列字符即停止

   >>> "8 aba1a5ca a8 1".strip(" bc158")
   'aba1a5ca a'
   

   无指定参数时，默认删除字符串左右的空白。
   在处理文本中，消除行末的回车符 ‘\n’ 常用。

   ※ 补充：
   .lstrip()方法 —— 用于截去字符串左边的空字符串
   .rstrip()方法 —— 用于截去字符串右边的空字符串

   >>> '   \n123\n'.lstrip()
   '123\n'
   >>> '     \n123\n    '.rstrip()
   '     \n123'
   

8. str.find()

   >>> 'abcdefge'.find('e')
   4
   

   还可指定搜索的起点、终点。

   >>> 'abcdefge'.find('e',6)
   7
   >>> 'abcdefg'.find('e',0,3)
   -1
   

9. str.title() —— 以字符串中每个单词首字母大写的方式显示字符串

   >>> "what a nice day!".title()
   'What A Nice Day!'
   

10. 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'
    

11. 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
    

12. 其他：判断字符串是否满足特定条件
    isspace()、isdigit()、isalpha()、isupper()、islower()、isalnum()等等
    返回True or False

    isnumeric() —— 判断字符串是否仅由数字组成
    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)
    

13. 补充： 函数sorted()
    函数sorted()用于排序，其对象一般是列表，
    但是，字符串可直接当作对象，返回字符串中对每一个字符的排序列表

    >>> num = '0123'
    >>> sorted(num, reverse=True)
    ['3', '2', '1', '0']
    

14. str.swapcase() —— 交换大小写

    >>> s = 'What Is Your Name?'
    >>> s.swapcase()
    'wHAT iS yOUR nAME?'
    

15. 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
  

  几种基本的字典创建方法：
  1. 使用=赋值

     >>> price = {'pork':35, 'beef':43, 'chicken':12}
     >>> price
     {'pork': 35, 'beef': 43, 'chicken': 12}
     

  2. 使用内置函数dict()通过已有数据快速建立

     >>> cost = [35, 43, 12]
     >>> meat = ['pork', 'beef', 'chicken']
     >>> price = dict(zip(meat, cost))
     >>> price
     {'pork': 35, 'beef': 43, 'chicken': 12}
     

  3. 使用内置函数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)
     

  4. 利用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}
     

     注意：fromkeys初始化字典直接返回值，不修改原件，因此需要重新赋值

1.3.1.2.2 基本的字典操作

1. del d[k] 删除字典中不需要的键值对

   >>> d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"}
   >>> del d["美国"]
   >>> d
   {'中国': '北京', '法国': '巴黎'}
   

2. k in d —— 查找的是键

   >>> d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"}
   >>> "中国" in d
   True
   

3. d.keys() —— 列出所有键

   >>> d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"}
   >>> d.keys()
   dict_keys(['中国', '美国', '法国'])
   

4. d.values() —— 列出所有值

   >>> d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"}
   >>> d.values()
   dict_values(['北京', '华盛顿', '巴黎'])
   

5. 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])]
   

6. d.get(k, < default >)相比用“键”来获取对应的值，更推荐安全的get()方法

   >>> d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"}
   >>> d.get("中国","伊斯兰堡")
   '北京'
   
   >>> d = {'a' : 1}
   >>> print(d.get('b'))
   None
   

7. d.pop(k, < default >)

   >>> d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"}
   >>> d.pop("中国","伊斯坦布尔")
   '北京'
   >>> d
   {'美国': '华盛顿', '法国': '巴黎'}
   >>> d.pop("俄罗斯","伊斯坦布尔")
   '伊斯坦布尔'
   >>> d
   {'美国': '华盛顿', '法国': '巴黎'}
   

8. 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'
   

9. 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}
   

10. d.clear()

    >>> d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"}
    >>> x = d
    >>> x = {}
    >>> d
    {'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
    

    对比：

    >>> d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"}
    >>> x = d
    >>> x.clear()
    >>> d
    {}
    

11. len(d)

    >>> d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"}
    >>> len(d)
    3
    

12. 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']}
    

13. 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.
  

15. 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."
  

  像这样使用字典时，可以使用任意数量的转换说明符。

字典处理实例