1 序列概览
说明：序列包括（列表，元组，字符串，buffer对象，xrange对象）
注意：列表可以修改，元组不能被修改。
例子：
>>> edward=["Edward Gumby", 42]
>>> bill =["Bill Gunn", 30]
>>> database = [edward, bill]
>>> database
[['Edward Gumby', 42], ['Bill Gunn', 30]]
>>> database[0]
['Edward Gumby', 42]
2 通用序列操作
2.1 索引
说明：
索引值可正可负，正索引从0开始，从左往右；负索引从-1开始，从右往左。使用负数索引时，python会从最后一个元素开始计 数。最后一个元素的位置编号是-1；
字符串可以直接使用索引；
例子：
>>> str = "Test"
#一般索引
>>> str[0]
'T'
>>> str[1]
'e'
#负数索引
>>> str[-1]
't'
>>> str[-2]
's'
#字符串直接索引
>>> "Test"[0]
'T'
>>> "Test"[1]
'e'
>>> "Test"[-1]
't'
2.2 分片
说明：使用分片操作来访问一定范围内的元素。分片通过冒号相隔的两个 索引来实现。
注意：
第一个索引是需要提取部分的第一个元素的索引值，而最后的索引 则是分片之后右侧剩下部分的第一个元素的索引；
如果右侧全部提取，则分片时，可以不写右侧索引，也可以将右侧索引 写最后一个元素的下一个索引；
如果左侧全部提取，刚分片时，左侧索引可以写0，也可以不写；
设置步长：不指明步长时，步长取1，也可以指定步长，步长不能为 0 ，步长也可以是负数，可以反序输出提取部分。
例子：
>>> data=[1,2,3,4,5,6,7,8,9,10]
#提取序列的一部分
>>> data[1:6]
[2, 3, 4, 5, 6]
#提取右侧全部
>>> data[3:]
[4, 5, 6, 7, 8, 9, 10]
>>> data[7:10]
[8, 9, 10]
#提取左侧全部
>>> data[:3]
[1, 2, 3]
>>> data[0:3]
[1, 2, 3]
#负索引提取
>>> data[-3:-1]
[8, 9]
>>> data[-3:]
[8, 9, 10]
#设置步长
>>> data[::2]
[1, 3, 5, 7, 9]
>>> data[1::2]
[2, 4, 6, 8, 10]
#步长也可以是负数
>>> data[::-1]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> data[-1:-8:-1]
[10, 9, 8, 7, 6, 5, 4]
>>> data[8:1:-1]
[9, 8, 7, 6, 5, 4, 3]
2.3 序列相加
说明：通过加号可以进行序列连接；
例子：
#序列相加
>>> first=[1,2]
>>> second=[3,4]
>>> first+second
[1, 2, 3, 4]
2.4 乘法
说明：用一个正整型数乘以序列，可以得到一个新的重复了n次的序列
注意：
空列表可以简单地通过两个中括号进行表示（[]）
None 是Python关键字，表示“什么也没有”
例子：
#10个python
>>> 'python ' * 10
'python python python python python python python python python python '
#10个空对象
>>> [None] * 10
[None, None, None, None, None, None, None, None, None, None]
#打印盒子
mystr = input("Please input a string:")
strLen = len(mystr)
lineStart = 20
print (" " * lineStart + "+" + "-" * strLen + "+")
print (" " * lineStart + "|" + " " * strLen + "|")
print (" " * lineStart + "|" + mystr + "|")
print (" " * lineStart + "|" + " " * strLen + "|")
print (" " * lineStart + "+" + "-" * strLen + "+")
>>>
Please input a string:My name is Bill Gunn
+--------------------+
| |
|My name is Bill Gunn|
| |
+--------------------+
2.5 成员资格
说明：使用关键字 in 检查值是否在序列中。如果值在序列中返回 “True”，否则返回“False”。值可以是元素也可以是子序列。
例子：
#检查值是否在序列中
>>> mystr="this is a string"
>>> 'this' in mystr
True
2.6 长度，最大值，最小值
说明：
len ：返回序列包含元素的数量；
min ：返回序列中的最小值；
max ：返回序列中的最大值；
#min,max和len的用法
>>> data = [12,31,2,1,3,12,3,13,131234,12]
>>> min(data)
1
>>> max(data)
131234
>>> len(data)
10
3 列表：Python的“苦力”
3.1 list
说明：可以将字符串或其他序列转换成列表。
注意：list是类型，不是函数。
例子：
>>> list("This is a test string")
['T', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 't', 'e', 's', 't', ' ', 's', 't', 'r', 'i', 'n', 'g']
3.2 基本列表操作
说明：
元素赋值：使用索引标记来为某个特定的，位置明确的元素赋值；
元素删除：使用 del 语句；
分片赋值：
可以一次为多个元素赋值；
原片与新片可以长度不同；
分片赋值可以在指定位置插入新的元素；
例子：
>>> mylist = [1,2,3,4,5]
#列表元素赋值
#索引必须在列表范围内
>>> mylist[10] = 10
Traceback (most recent call last):
File "<pyshell#2>", line 1, in <module>
mylist[10] = 10
IndexError: list assignment index out of range
>>> mylist[0] = 100
>>> mylist
[100, 2, 3, 4, 5]
#删除元素
>>> del(mylist[0])
>>> mylist
[2, 3, 4, 5]
>>>
#分片赋值
>>> mystr = list("Nale Gunn")
>>> mystr[0:4] = list("Bill")
>>> mystr
['B', 'i', 'l', 'l', ' ', 'G', 'u', 'n', 'n']
#分片赋值时，原片与新片长度不同
>>> mystr=list("Bill Gunn")
>>> mystr[-5:] = list("gunn@gmail.com")
>>> mystr
['B', 'i', 'l', 'l', 'g', 'u', 'n', 'n', '@', 'g', 'm', 'a', 'i', 'l', '.', 'c', 'o', 'm']
>>>
#分片赋值可以在指定位置插入新的元素
>>> mystr=list("Bill Gunn")
>>> mystr[0:0] = list("My name is ")
>>> mystr
['M', 'y', ' ', 'n', 'a', 'm', 'e', ' ', 'i', 's', ' ', 'B', 'i', 'l', 'l', ' ', 'G', 'u', 'n', 'n']
>>>
3.3 列表方法
说明：
append：用于在列表末尾追加一个新的元素；列表调用该方法后，直接被该 方法修改；
count：用于统计某个元素在列表中出现的次数；
extend：在列表的末尾一次性追加另一个列表中的多个元素，该方法 也是直接修改原列表，这也是与列表连接操作的区别；
index：找出某个匹配项第一次出现的索引；
insert：在列表中插入新的对象；
pop：移除列表中的一个值（默认是最后一个），并返回该元素的值；
remove：用于移除某个值在列表中的第一个匹配项；
reverse：将列表中的值反向存放；
sort：对列表进行排序；
sorted内建函数：对序列进行反序，并返回一个列表
注意：
列表复制：用分片的方法复制比较有效率。
例子：
#append
>>> lst = list("Test")
>>> lst.append(list("String"))
>>> lst
['T', 'e', 's', 't', ['S', 't', 'r', 'i', 'n', 'g']]
>>> lst.append("String")
>>> lst
['T', 'e', 's', 't', ['S', 't', 'r', 'i', 'n', 'g'], 'String']
>>> lst=list("Test")
>>> lst.append("!")
>>> lst
['T', 'e', 's', 't', '!']
#count
>>> lst.count('T')
1
>>> lst.count('t')
1
#extend
>>> lst.extend(list("HaHa"))
>>> lst
['T', 'e', 's', 't', '!', 'H', 'a', 'H', 'a']
>>> lst.index('t')
3
>>>
#pop
>>> lst = [1,2,3]
>>> lst.pop()
3
>>> lst
[1, 2]
>>> lst.pop(0)
1
>>> lst
[2]
>>>
#pop
>>> lst = [1,2,3]
>>> lst.pop()
3
>>> lst
[1, 2]
>>> lst.pop(0)
1
>>> lst
[2]
#remove
>>> lst=list("12345678")
>>> lst
['1', '2', '3', '4', '5', '6', '7', '8']
#删除不存在的对象会报错
>>> lst.remove(2)
Traceback (most recent call last):
File "<pyshell#42>", line 1, in <module>
lst.remove(2)
ValueError: list.remove(x): x not in list
>>> lst.remove('2')
>>> lst
['1', '3', '4', '5', '6', '7', '8']
#reverse
>>> lst.reverse()
>>> lst
['8', '7', '6', '5', '4', '3', '1']
#sort
>>> lst.sort()
>>> lst
['1', '3', '4', '5', '6', '7', '8']
>>> lst.sort(key=len)
>>> lst
['1', '3', '4', '5', '6', '7', '8']
>>> lst = ['asdf','qwersf','aaf','s','afasfd','qre']
>>> lst.sort(key=len)
>>> lst
['s', 'aaf', 'qre', 'asdf', 'qwersf', 'afasfd']
>>> lst.sort(key=len,reverse=True)
>>> lst
['qwersf', 'afasfd', 'asdf', 'aaf', 'qre', 's']
>>>
#列表复制
>>> x = list('123456')
#下面的复制，只是让y也指向x指向的对象，所以修改x，也会影响y的值
>>> y = x
>>> x.reverse()
>>> y
['6', '5', '4', '3', '2', '1']
#用分片的方法复制，x与y相互独立，修改x，不会影响y
>>> y=x[:]
>>> y.sort()
>>> x
['6', '5', '4', '3', '2', '1']
>>> y
['1', '2', '3', '4', '5', '6']
>>>
4 元组
4.1 元组定义：
说明：元组不可以修改，一般用圆括号括起来
例子：
#一般元组
>>> 1,2,3
(1, 2, 3)
>>> (1,2,3)
(1, 2, 3)
#一个元素的元组
>>> (1,)
(1,)
>>> 2,
(2,)
#空元组
>>> ()
()
>>>
#元组的乘法
>>> 4* (2,)
(2, 2, 2, 2)
>>>
4.2 tuple函数
说明：以一个序列为参数，将其转换为元组；
例子：
>>> tuple("CONSTANT")
('C', 'O', 'N', 'S', 'T', 'A', 'N', 'T')
>>> tuple(list("CONST"))
('C', 'O', 'N', 'S', 'T')
>>>
4.3 元组的意义：
元组可以在映射中当作键使用；
元组作为很多内建函数和方法的返回值存在。
1 字典定义：
说明：通过名字引用值的数据结构称为映射，字典是Python中唯一内建的 映射类型；
2 字典的使用:
说明：通过检查到特定的词语（键），查找到它的含义（值）；
注意：比较适合电话薄，词典这类实现
例子：
1: #用列表来实现电话薄
2: >>> phoneNumbers = ['213123','542113','543231','974723']
3: >>> names=['Ada', 'Bill', 'Candy', 'David']
4: >>> phoneNumbers[names.index('Bill')]
5: '542113'
6: >>>
7:
3 创建和使用字典
说明：字典是由多个键以及其对应的值组成的键值对组成的，
字典以左大 括号开始，并以右大括号结束，键与值之间用冒号分隔，键值对儿之间用 逗号分隔；
注意：字典中的键是唯一的
例子：
1: >>> mydict={'ada':'1111', 'Bill':'2222', 'Candy':'3333'}
2: >>> mydict['Bill']
3: '2222'
4: >>>
5:
3.1 dict函数
说明：用于创建字典的内建函数，参数可以是键与值的序列，可以是关键 字参数，也可以是其他的映射；
注意：如果不给dict提供参数，则会返回一个空字典
例子：
1: #将序列转换成字典
2: >>> mylst=[('name', 'Bill'),('age', 30)]
3: >>> mydict = dict(mylst)
4: >>> mydict
5: {'age': 30, 'name': 'Bill'}
6: >>> mydict['name']
7: 'Bill'
8:
9: #通过向dict函数传递参数来创建字典
10: >>> mylst = dict(height=183,weight=161,hair='black')
11: >>> mylst['hair']
12: 'black'
13:
14: #通过字典来创建另一个字典
15: >>> mylst = dict(mydict)
16: >>> mylst
17: {'age': 30, 'name': 'Bill'}
18: >>>
19:
3.2 基本字典操作
说明：
len（d）：获取字典中键值对的数量；
d[k]：键k对应的值；
d[k]=v：将值v赋给键k；
del d[k]：删除字典d中键为k的项；
k in d：判断字典d中是否包含键为k的项；
注意：
键类型：键类型可以是任意不可变类型，如整数，浮点数，字符串等；
自动添加：如果字典中不包含指定的键，可以通过赋值增加新项；
成员资格：k in d 是查找字典中是不是有键k对应的项，而列表是查 找的是值，v in l， 值v是不是在列表中；
字典中检查键的效率要比列表检查值的高效；
例子：
1: #电话薄
2: people = {
3: 'Bill Gunn':
4: {
5: 'phone': '123456',
6: 'addr': 'Tianjin'
7: },
8: 'Media Zhang':
9: {
10: 'phone': '999999',
11: 'addr': 'Beijing'
12: }
13: }
14: #输出内容
15: lables = {
16: 'phone' : 'phone number',
17: 'addr' : 'address'
18: }
19: #用户名
20: name = input('Name:')
21: key = input('Phone number(p) or address(a):')
22: if key == 'p' : key = 'phone'
23: if key == 'a' : key = 'addr'
24: if name in people:
25: print("%s %s is %s" % (name, lables[key], people[name][key]))
26: input('Press enter!')
27:
28: >>>
29: Name:Bill Gunn
30: Phone number(p) or address(a):a
31: Bill Gunn address is Tianjin
32: Press enter!
33:
3.3 用字典格式化字符串
说明：在格式化字符串中的格式化说明符后添加 键 ，并且 键 需要 用圆括号括起来；
例子：
1: >>> table = {
2: 'Alice' : '457819',
3: 'Bill' : '929181',
4: 'Candy' : '826213'}
5: >>> print("Alice's phone number is %(Alice)s." % table)
6: Alice's phone number is 457819.
7: >>>
8:
3.4 字典方法
3.4.1 clear
说明：用于清除字典中全部的键值对儿，调用完该方法后，原字典变成一 个空字典；
注意：该方法直接操作原字典，调用后不返回值（或者说直接返回 None ）
例子：
1: #字典清空函数的一般用法
2: >>> mydict = {'Bill':'8289213', 'Candy':'192831'}
3: >>> mydict.clear()
4: >>> mydict
5: {}
6: >>>
7:
8: #字典清空的情况一
9: >>> x = {'Bill':'213121'}
10: #y和x指向同一个字典对象
11: >>> y = x
12: # x 指向一个空字典
13: >>> x = {}
14: # y 仍然指向原字典
15: >>> y
16: {'Bill': '213121'}
17: >>>
18:
19: #字典清空的情况二
20: >>> x = {'Name' : 'Bill'}
21: #y也指向字典
22: >>> y = x
23: #对字典中的项操作
24: >>> x['Name'] = 'Candy'
25: # y 也跟着变化
26: >>> y
27: {'Name': 'Candy'}
28: #清空字典 x
29: >>> x.clear()
30: #y也被清空了
31: >>> y
32: {}
33: >>>
34:
3.4.2 copy
说明：用于创建一个新的字典，用两种复制方法：copy和deepcopy
注意：
copy在复制过程中，
如果字典中的 值 对象是复杂对象，如列表， 字典等等，则拷贝完后，新的字典中的 值 指向的还是原字典中的 对象，所以修改新对象中的 值 ，同时也是修改原字典中的值，
但 是如果字典中的对象是普通类型，如是数字，字符串等，则修改新字 典不会影响原字典。
例子：
1: #copy的用法和效果
2: >>> x = {'Name' : 'Bill', 'Colors': {'red', 'green', 'blue'}}
3: >>> y = x.copy()
4: >>> y
5: {'Colors': ['blue', 'green', 'red'], 'Name': 'Bill'}
6: #删除颜色列表中的 ‘red’
7: >>> x['Colors'].remove('red')
8: >>> x
9: {'Colors': ['blue', 'green'], 'Name': 'Bill'}
10: #y字典中的颜色列表也发生的改变
11: >>> y
12: {'Colors': ['blue', 'green'], 'Name': 'Bill'}
13: >>>
14:
15:
16: #deepcopy的用法和效果
17: >>> from copy import deepcopy
18: >>> x = {'colors':['red','green','blue'],'name':'Bill'}
19: >>> x
20: {'colors': ['red', 'green', 'blue'], 'name': 'Bill'}
21: #将x深拷贝给y
22: >>> y = deepcopy(x)
23: >>> y
24: {'colors': ['red', 'green', 'blue'], 'name': 'Bill'}
25: #修改x
26: >>> x['colors'].remove('red')
27: >>> x
28: {'colors': ['green', 'blue'], 'name': 'Bill'}
29: #y没有发生改变
30: >>> y
31: {'colors': ['red', 'green', 'blue'], 'name': 'Bill'}
32: >>>
33:
3.4.3 fromekeys
说明：根据键创建新的字典；
例子：
1: >>> {}.fromkeys(['name','age'])
2: {'age': None, 'name': None}
3: >>> x.fromkeys(['age'])
4: {'age': None}
5: >>>
6:
3.4.4 get
说明：是个更宽松的访问字典项的方法，如果键在字典中，则返回值， 如果不在，返回空，也可以给不存在的键指定默认值；
例子：
1: >>> x = {'name': 'Bill'}
2: #字典中包含指定的键
3: >>> x.get('name')
4: 'Bill'
5:
6: #字典中不包含指定的键，返回空
7: >>> x.get('age')
8:
9: #为不包含的键指定默认值
10: >>> x.get('age', 'N/A')
11: 'N/A'
12: >>>
13:
3.4.5 has_key
说明：可以检查字典中是否含有给出的键，python3中已经 不 包含此 项，可以用 k in dict 的方式代替；
3.4.6 items和iteritems
说明：items以列表方式返回字典中的键值对，iteritems以迭代器对象 返回键值对儿(Python3中不再支持）；
例子：
1: >>> x
2: {'name': 'Bill'}
3: >>> x.items()
4: dict_items([('name', 'Bill')])
5:
6: #python3中不再包含iteritems
7: >>> x.iteritems()
8: Traceback (most recent call last):
9: File "<pyshell#66>", line 1, in <module>
10: x.iteritems()
11: AttributeError: 'dict' object has no attribute 'iteritems'
12:
3.4.7 keys
说明：返回字典中的 键
例子：
1: >>> x = {'Name':'Bill', 'Age':'30'}
2: >>> x
3: {'Age': '30', 'Name': 'Bill'}
4: >>> x.keys()
5: dict_keys(['Age', 'Name'])
6: >>>
7:
3.4.8 pop
说明：用于获取给定键的值，并将该键值对从字典中移除
例子：
1: >>> x = {'a':1,'b':2}
2: >>> x
3: {'a': 1, 'b': 2}
4: >>> x.pop('a')
5: 1
6: >>> x
7: {'b': 2}
8: >>>
9:
3.4.9 popitem
说明：用于随机弹出字典中的键值对儿；
例子：
1: >>> x = {'a': '1', 'c': '3', 'b': '2'}
2: >>> while len(x) > 0:
3: x.popitem()
4: ('a', '1')
5: ('c', '3')
6: ('b', 2)
7: >>> x
8: {}
9:
3.4.10 setdefault
说明：可以获得给定键的值，如果字典中没有给定键，可以在字典中添 加给定键。如果没有指定给定键的默认值，并且给定键也不在字典中， 则在添加给定键后，将其值设置为 None 。
例子：
1: >>> x = {'a':'1','b':'2','c':'3'}
2: >>> x
3: {'a': '1', 'c': '3', 'b'/span>: '2'}
4: #字典中包含 a，所以返回键a对应的值1
5: >>> x.setdefault('a')
6: '1'
7: #因为字典中有键a，所以setdefault方法不会改变键a对应的值
8: >>> x.setdefault('a', 'A')
9: '1'
10: >>> x
11: {'a': '1', 'c': '3', 'b': '2'}
12: #字典中没有键d，调用setdefault方法时也没有设置默认值，
13: #所以调用后，在字典中添加了键为d的键值对儿，并返回空。
14: >>> x.setdefault('d')
15: >>> x
16: {'a': '1', 'c': '3', 'b': '2', 'd': None}
17: #调用setdefault时带默认值
18: >>> x.setdefault('e', '5')
19: '5'
20: >>> x
21: {'a': '1', 'c': '3', 'b': '2', 'e': '5', 'd': None}
22: >>> x.setdefault('d', '4')
23: >>>
24:
3.4.11 update
说明：将新字典中的键值对儿更新到原字典中，如果新字典中有的键值 对儿，原字典中没有，则会在原字典中增加新键值对儿；
例子：
1: >>> x = {'a':'1','b':'2','c':'3'}
2: >>> x
3: {'a': '1', 'c': '3', 'b': '2'}
4: >>> y = {'a':'A', 'z':'zoo'}
5: >>> x.update(y)
6: #键‘a’被更新到字典中，‘z’被添加到字典中
7: >>> x
8: {'a': 'A', 'c': '3', 'b': '2', 'e': '5', 'd': None, 'z': 'zoo'}
9: >>> z=[('g','11'),('q','12')]
10: >>> x.update(z)
11: >>> x
12: {'a': 'A', 'q': '12', 'c': '3', 'b': '2', 'e': '5', 'd': None, 'g': '11', 'z': 'zoo'}
13: >>>
14:
3.4.12 values和itervalues
说明：values返回字典中的值，itervalues已经不被python3支持。
例子：
1: >>> x
2: {'a': 'A', 'q': '12', 'c': '3', 'b': '2', 'e': '5', 'd': None, 'g': '11', 'z': 'zoo'}
3: >>> x.values()
4: dict_values(['A', '12', '3', '2', '5', None, '11', 'zoo'])
5: >>>
6:
