1、序列（列表、元组和字符串）的方法

Python包含以下函数:

注意：

• sum、max和min要求序列中的值必须是同一个类型，不然无法比较或者求和。

例如：

>>> string = "asdfqer12314"
>>> sorted(string)
['1', '1', '2', '3', '4', 'a', 'd', 'e', 'f', 'q', 'r', 's']
>>> max(string)
's'
>>> min(string)
'1'
>>> string
'asdfqer12314'
>>> list = sorted(string)
>>> max(list)
's'
>>> min(list)
'1'
>>> list = [1,1,2,3,4,'a','d']
>>> max(list)
Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    max(list)
TypeError: unorderable types: str() > int()

注意：

• 和其他语言中不同，python中没有和数字类型可以互转的char类型，所以单个字符’a’实际上也是字符串，无法直接和数字进行比较。

1.1、序列的filter函数

filter函数的定义是：filter(function or None, iterable) –> filter object。

可以通过输入的函数来对序列进行过滤，并返回一个filter object。注意：

• 输入None的话，会自动将0和False过滤掉。

In [16]: list(filter(None,[1,0,False,True]))
Out[16]: [1, True]

• 可以输入函数来指定过滤的规则（和Java8中的Stream类似的功能）,例如：

In [18]: list(filter(lambda x:(x&0x01)==1,[1,2,3,4,5,6,7]))
Out[18]: [1, 3, 5, 7]

1.2、序列的map函数

map函数的定义是： map(func, *iterables) –> map object。

map函数可以对输入的序列中的每一个函数，进行一次func操作，并返回一个map object。（同样和Java中Stream的map类似）。例如：

In [21]: list(map(lambda x: x+1,[1,2,3,4,5,6]))
Out[21]: [2, 3, 4, 5, 6, 7]

2、列表

2.1、有关列表的所有方法和函数

List包含以下内置函数:

例如：

2.1.1、向列表中插入元素

In [1]: animals = ['cai','dog','snake','lion']

In [2]: animals.append('pig')

In [3]: animals
Out[3]: ['cai', 'dog', 'snake', 'lion', 'pig']

In [4]: animals.append('bird','cow')
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-4-57b332645244> in <module>()
----> 1 animals.append('bird','cow')

TypeError: append() takes exactly one argument (2 given)

In [5]: animals.extend('bird','cow')
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-5-d37215d6ed56> in <module>()
----> 1 animals.extend('bird','cow')

TypeError: extend() takes exactly one argument (2 given)

In [6]: animals.extend(['bird','cow'])

In [7]: animals
Out[7]: ['cai', 'dog', 'snake', 'lion', 'pig', 'bird', 'cow']

In [8]: animals.insert(0,'dragon')

In [9]: animals
Out[9]: ['dragon', 'cai', 'dog', 'snake', 'lion', 'pig', 'bird', 'cow']

注意：

• append一次只能添加一个元素
• 一次添加多个元素需要使用extend
• 注意extend接受一个数组，而不能以多个元素的形式输入，否则报错
• insert插入，不替换原位置的元素

2.1.2、删除列表元素

In [9]: animals
Out[9]: ['dragon', 'cai', 'dog', 'snake', 'lion', 'pig', 'bird', 'cow']

In [10]: animals.remove('cai')

In [11]: animals
Out[11]: ['dragon', 'dog', 'snake', 'lion', 'pig', 'bird', 'cow']

In [12]: del animals[0]

In [13]: animals
Out[13]: ['dog', 'snake', 'lion', 'pig', 'bird', 'cow']

In [14]: animals.pop()
Out[14]: 'cow'

In [15]: animals
Out[15]: ['dog', 'snake', 'lion', 'pig', 'bird']

In [16]: animals.pop(1)
Out[16]: 'snake'

In [17]: animals.remove(0)
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-17-98c2ad3daa0d> in <module>()
----> 1 animals.remove(0)

ValueError: list.remove(x): x not in list

注意：

• remove返回None，只接收元素，不接收下标
• pop不接收元素，接收下标
• 也可以用del指定删除元素

2.1.3、列表的排序

Python可以通过list.sort()和sorted(list)进行排序。差别是：

• list.sort()对数组进行原址排序，返回None
• sorted(list)数组本身不变，返回排序好的数组的副本

list = [1,8,3,6,7,9]
# 返回[1, 3, 6, 7, 8, 9]
print(sorted(list))
# 返回[1, 8, 3, 6, 7, 9]
print(list)
# 返回None
print(list.sort())
print(list)
# 还可以指定进行逆序排序
print(list.sort(reverse=True))

2.1.4、其他函数

In [25]: animals
Out[25]: ['dog', 'lion', 'pig', 'bird']

In [26]: animals.index('lion')
Out[26]: 1

In [27]: animals.append('dragon')

In [28]: animals.append('dragon')

In [29]: animals.count('dragon')
Out[29]: 2

In [30]: animals
Out[30]: ['dog', 'lion', 'pig', 'bird', 'dragon', 'dragon']

In [31]: animals.reverse()

In [32]: animals
Out[32]: ['dragon', 'dragon', 'bird', 'pig', 'lion', 'dog']

2.2、 把列表当做“栈”使用

“栈”是一个“后进先出”的数据结构，用append()和pop()可以轻松实现栈的操作：

• 压栈：append()
• 弹栈：pop()

和Java中的LinkedList等结构不同，Java中的实现是在列表的“头”存取，而python是在列表的“尾”存取，但是这并不重要，“栈”结构重要的是在“同一端存取”。

2.3、“队列”

“队列”是一个“先进先出”的数据结构。

和“栈”的情况不同，队列“不在同一端存取”。python中的列表类似于Java中的ArrayList，在头部删除、添加需要移动所有元素，效率低下。

固一般不用列表实现队列，而使用专门的类似于Java中LinkedList的类：collections.deque（双向链表）：

from collections import deque
queue = deque([1, 2, 3])
queue.append(4)
print(list(queue))
pop = queue.pop()
print(pop)
popleft = queue.popleft()
print(popleft)

• 入队：append()
• 出队：popleft()

栈同样可以用deque实现，方法和list的相同。

2.4、列表推导式

列表推导式由一个包含一个表达式的括号组成，表达式后面跟随一个或多个for或者if语句（for语句和if语句按顺序进行）。

# 使用lambda表达式快速创建list
squares = list(map(lambda x: x**2, range(10)))
print(squares)
# 使用列表推导式快速创建list
squares = [x**2 for x in range(10)]
print(squares)
# 带if的列表推导式
squares = [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]
print(squares)
# 上面的列表推导式等同于
squares1 = []
for x in [1, 2, 3]:
    for y in [3, 1, 4]:
        if x != y:
            squares1.append((x,y))
print(squares1)

# 还可以有更复杂的表达式
from math import pi
squares2 = [str(round(pi, i)) for i in range(1, 6)]
print(squares2)

除了这些“简单”的列表以外，还可以用嵌套的列表推导式，进行更复杂的操作：

# 矩阵
matrix = [
            [1, 2, 3, 4],
            [5, 6, 7, 8],
            [9, 10, 11, 12]
        ]
print(matrix)

# 交换行列
tMatrix = [[row[i] for row in matrix] for i in range(4)]
print(tMatrix)

# 交换行列还可以通过拆分列表实现，*代表拆分，zip按顺序取每个子列表的同位置的元素
print(list(zip(*matrix)))

嵌套的多个for或者if语句，按嵌套的内外关系，外层的先进行。

2.5、序列的相互比较

序列对象可以与相同类型的其他对象比较。序列的相互比较和字符串的相互比较类似，由按顺序第一个不同的元素的”大小“来决定两个序列的大小。

需要注意的是，元素的比较只比较”值“。

例如：

In [19]: list1 = [123]

In [20]: list2 = [234]

In [21]: list1 > list2
Out[21]: False

In [22]: list1 = [123,456]

In [23]: list2 = [234,123]

In [24]: list1 > list2
Out[24]: False

2.6、序列的拆分

序列（列表、元组和字符串）都可以进行如下形式的快速拆分操作：

# 声明元组
t = 12345, 54321, 'hello!'
# 拆分元组，变量数需要和元组的元素个数相等
x, y, z = t

3、集合

集合的操作（并集、交集、差集、对称差集）：

# 构建元组
t = {"q","w","e","r"}
# 还可以用和列表推导式类似的方法构建
a = {x for x in "asdfqewrgq" if x not in "abc"}
print(a)

# 并集
print(t | a)
# 交集
print(t & a)
# 差集(注意，a-t和t-a不同)
print(a - t)
# 对称差集(不同时在t和a中的元素）
print(t ^ a)

4、字典

字典以关键字为索引，关键字可以是任意不可变类型。需要注意的是：

• 如果元组只包含字符串和数字或者其他不可变类型，则它可以作为关键字，如果包含任何可变类型，则不能作为关键字

字典同样可以通过推导式创建：

# 使用推导式创建字典
dict1 = {x: x ** 2 for x in (2, 5, 6)}
print(dict1)

除此之外还可以通过元组创建：

dict1 = dict(((1,'cai'),(2,'li')))
print(dict1)

4.1、fromkeys()函数

fromkeys函数接收元组，创建指定key和值的dict。例如：

In [3]: dict1 = dict.fromkeys((1,2,3,4,5))

In [4]: dict1
Out[4]: {1: None, 2: None, 3: None, 4: None, 5: None}

In [5]: dict1 = dict.fromkeys((1,2,3,4,5),'Number')

In [6]: dict1
Out[6]: {1: 'Number', 2: 'Number', 3: 'Number', 4: 'Number', 5: 'Number'}

In [7]: dict1 = dict.fromkeys((1,2,3,4,5),('n1','n2','n3','n4','n5'))

In [8]: dict1
Out[8]:
{1: ('n1', 'n2', 'n3', 'n4', 'n5'),
 2: ('n1', 'n2', 'n3', 'n4', 'n5'),
 3: ('n1', 'n2', 'n3', 'n4', 'n5'),
 4: ('n1', 'n2', 'n3', 'n4', 'n5'),
 5: ('n1', 'n2', 'n3', 'n4', 'n5')}

In [12]: dict1 = dict.fromkeys(range(3))

In [13]: dict1
Out[13]: {0: None, 1: None, 2: None}

注意：

• 如果不指定值，会自动填充None
• 如果指定了值，所有的key都会被填充相同的值。
• 除了元组以外，也可以接收range

4.2、setdefault函数 

许多时候我们需要往字典中的元素添加数据，我们首先要判断这个元素是否存在，不存在则创建一个默认值。如果在循环里执行这个操作，每次迭代都需要判断一次，降低程序性能。

我们可以使用 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']}

试图索引一个不存在的键将会抛出一个 keyError 错误（这点和Java不同，Java会返回Null）。我们可以使用 dict.get(key, default) 来索引键，如果键不存在，那么返回指定的 default 值。

>>> data['foo']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'foo'
>>> data.get('foo', 0)
0