Python3简明教程二

这部分主要说明Python3的数据结构、字符串操作等。

来源：实验楼Python3简明教程

1. 列表的方法与列表的删除

• append() 调用该方法可以在列表末尾追加元素

>>> a = [23, 45, 1, -3434, 43624356, 234]
>>> a.append(45)
>>> a
[23, 45, 1, -3434, 43624356, 234, 45]

• insert() 可以将数据插入到任何位置

>>> a.insert(0, 1) # 在列表索引 0 位置添加元素 1
>>> a
[1, 23, 45, 1, -3434, 43624356, 234, 45]
>>> a.insert(0, 111) # 在列表索引 0 位置添加元素 111
>>> a
[111, 1, 23, 45, 1, -3434, 43624356, 234, 45]

• count(s) 会返回列表元素中s的数量，即出现的次数

>>> a.count(45)
2

• remove(s) 移除指定元素s
• reverse() 反转整个列表
• extend() 将一个列表的所有元素添加到另一个列表的末尾

>>> b = [45, 56, 90]
>>> a.extend(b) # 添加 b 的元素而不是 b 本身
>>> a
[45, 43624356, -3434, 1, 45, 23, 1, 111, 45, 56, 90]

• sort() 对列表进行排序，前提是该列表的元素是可比较的
• del a(index) 删除列表指定位置的元素

>>> del a[-1]
>>> a
[-3434, 1, 1, 23, 45, 45, 45, 56, 90, 111]

• pop() 不传参数会将列表最后一个元素弹出，传入一个参数 i 即 pop(i) 会将第 i 个元素弹出。

# 栈
>>> a = [1, 2, 3, 4, 5, 6]
>>> a.pop()
6
>>> a
[1, 2, 3, 4, 5]
>>> a.pop(2)
3
>>> a
[1, 2, 4, 5]

• 通过pop()可以将列表用作栈或队列。栈是我们通常所说的一种 LIFO （Last In First Out 后进先出）数据结构。队列是一种FIFO （First In First Out 先进先出）的数据结构。

# 队列
>>> a
[1, 2, 4, 5]
>>> a.append(0)
>>> a
[1, 2, 4, 5, 0]
>>> a.pop(0)
1
>>> a
[2, 4, 5, 0]

• 列表推导式
  列表推导式由包含一个表达式的中括号组成，表达式后面跟随一个 for 子句，之后可以有零或多个 for 或 if 子句。结果是一个列表，由表达式依据其后面的 for 和 if 子句上下文计算而来的结果构成。

# eg: 1
>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
# 等价于
>>> combs = []
>>> for x in [1,2,3]:
...     for y in [3,1,4]:
...         if x != y:
...             combs.append((x, y))

# eg: 2
>>> z = [x + 1 for x in [x ** 2 for x in a]]
>>> z
[2, 5, 10]

2. 元组

• 元组是由数个逗号分割的值组成。a = 'Fedora', 'ShiYanLou', 'Kubuntu', 'Pardus'。
• 可以对任何一个元组执行拆封操作divmod(num1, num2)并赋值给多个变量。
• 元组是不可变类型，不能在元组内删除或添加或编辑任何值。
• 要创建只含有一个元素的元组，在值后面跟一个逗号。

>>> b = 321,
>>> b
(321,)
>>> type(b)
<class 'tuple'>

>>> b = (123)
>>> b
123
>>> type(b)
<class 'int'>

3. 集合

集合是一个无序不重复元素的集。
集合对象还支持 union（联合），intersection（交），difference（差）和 symmetric difference（对称差集）等数学运算。
大括号或 set() 函数可以用来创建集合。注意：想要创建空集合，你必须使用 set() 而不是 {}。后者用于创建空字典。

• 集合的常见操作

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 你可以看到重复的元素被去除
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket
True
>>> 'crabgrass' in basket
False

>>> # 演示对两个单词中的字母进行集合操作
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # a 去重后的字母
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # a 有而 b 没有的字母
{'r', 'd', 'b'}
>>> a | b                              # 存在于 a 或 b 的字母
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # a 和 b 都有的字母
{'a', 'c'}
>>> a ^ b                              # 存在于 a 或 b 但不同时存在的字母
{'r', 'd', 'b', 'm', 'z', 'l'}

• 在集合中添加或弹出元素

>>> a = {'a','e','h','g'}
>>> a.pop()
'h'
>>> a.add('c')
>>> a
{'c', 'e', 'g', 'a'}

4. 字典

字典是是无序的键值对（key:value）集合，同一个字典内的键必须是互不相同的。
一对大括号 {} 创建一个空字典。
字典中的键必须是不可变类型，比如不能使用列表作为键。
使用键来检索存储在字典中的数据。

>>> data = {'kushal':'Fedora', 'kart_':'Debian', 'Jace':'Mac'}
>>> data
{'kushal': 'Fedora', 'Jace': 'Mac', 'kart_': 'Debian'}
>>> data['kart_']
'Debian'

• 创建新的键值对

>>> data['parthan'] = 'Ubuntu'
>>> data
{'kushal': 'Fedora', 'Jace': 'Mac', 'kart_': 'Debian', 'parthan': 'Ubuntu'}

• del 关键字删除任意指定的键值对

>>> del data['kushal']
>>> data
{'Jace': 'Mac', 'kart_': 'Debian', 'parthan': 'Ubuntu'}

• in 关键字查询指定的键是否存在于字典

>>> 'ShiYanLou' in data
False

• dict() 可以从包含键值对的元组中创建字典

>>> dict((('Indian','Delhi'),('Bangladesh','Dhaka')))
{'Indian': 'Delhi', 'Bangladesh': 'Dhaka'}

• 要遍历一个字典，使用字典的 items() 方法

>>> data
{'Kushal': 'Fedora', 'Jace': 'Mac', 'kart_': 'Debian', 'parthan': 'Ubuntu'}
>>> for x, y in data.items():
...     print("{} uses {}".format(x, y))
...
Kushal uses Fedora
Jace uses Mac
kart_ uses Debian
parthan uses Ubuntu

• dict.setdefault(key, default) 首先会判断这个元素是否存在，不存在则创建一个默认值。这种方法更具有效率。

>>> data = {}
>>> data.setdefault('names', []).append('Ruby')
>>> data
{'names': ['Ruby']}
>>> data.setdefault('names', []).append('Python')
>>> data
{'names': ['Ruby', 'Python']}
>>> data.setdefault('names', []).append('C')
>>> data
{'names': ['Ruby', 'Python', 'C']}

• dict.get(key, default) 来索引键，如果键不存在，那么返回指定的 default 值。
• 遍历列表（或任何序列类型）的同时获得元素索引值，可以使用 enumerate()。

>>> for i, j in enumerate(['a', 'b', 'c']):
...     print(i, j)
...
0 a
1 b
2 c

• 时遍历两个序列类型，可以使用 zip() 函数

>>> a = ['Pradeepto', 'Kushal']
>>> b = ['OpenSUSE', 'Fedora']
>>> for x, y in zip(a, b):
...     print("{} uses {}".format(x, y))
...
Pradeepto uses OpenSUSE
Kushal uses Fedora

5. 字符串

• '...'和"..."都可以表示字符串
• """..."""或'''...'''可将行尾的换行符自动包含到字符串

>>> s = "Here is a line \n split in two lines"
>>> print(s)
Here is a line
split in two lines

>>> print("""\
... Usage: thingy [OPTIONS]
...      -h                        Display this usage message""")
Usage: thingy [OPTIONS]
     -h                        Display this usage message

• 字符串的一些方法
  -- split() 分割任意字符串，split() 允许有一个参数，用来指定字符串以什么字符分隔（默认为 " "）
  -- join() 和split() 相反，指定字符连接多个字符串，它需要一个包含字符串元素的列表作为输入然后连接列表内的字符串元素
  -- title() 返回字符串的标题版本，即单词首字母大写其余字母小写
  -- upper()、lower() 字符串的大写、小写
  -- swapcase() 大写变小写，小写变大写
  -- isalnum() 检查所有字符是否为字母或数字
  -- isalpha() 检查字符串之中是否只有字母
  -- isdigit() 检查字符串之中是否只有数字
  -- islower() 检查字符串是否所有字符为小写
  -- isupper() 检查字符串是否所有字符为大写
  -- istitle() 检查字符串是否为标题样式
• 字符串剥离
  -- strip(chars) 用来剥离字符串首尾中指定的字符，允许是一个字符串参数，不指定参数则默认剥离掉首尾的空格和换行符。
  -- lstrip(chars) 或rstrip(chars)只对字符串左或右剥离

>>> s = "www.foss.in" 
>>> s.lstrip("cwsd.") #删除在字符串左边出现的'c','w','s','d','.'字符
'foss.in'
>>> s.rstrip("cnwdi.") #删除在字符串右边出现的'c','n','w','d','i','.'字符
'www.foss'

• 字符串文本搜索find()，能找到第一个匹配的子字符串，没有找到则返回 -1

>>> s = "faulty for a reason"
>>> s.find("for")
7
>>> s.find("fora")
-1
>>> s.startswith("fa") # 检查字符串是否以 fa 开头
True
>>> s.endswith("reason") # 检查字符串是否以 reason 结尾
True

• 回文检查
  回文是一种无论从左还是从右读都一样的字符序列

>>> s = '123'
>>> z = s[::-1]
>>> z
'321'