列表、元组操作
列表不同于元组和字符串的地方：列表是可变的–可以改变列表的内容，并且列表有很多有用的、专门的方法。
基本的列表操作
list函数
>>>list("hello")
['h','e','l','l','0']
#注意，list函数适用于所有类型的序列，而不只是字符串改变列表：元素赋值
>>> x = [1,2,3]
>>> x[1] = 5
>>> x
[1,5,3]
#注意 不能为一个位置不存在的元素进行赋值。如果的列表长度为2，那么不能为索引为100的元素进行赋值。如果要那样做，就必须创建一个长度为101(或者更长)的列表删除元素
从列表中删除元素很容易，使用del语句：
>>> names = ['Alice','Beth','Cecil','Dee-Dee','Earl']
>>> del names[2]
>>> names
['Alice','Beth','Dee-Dee','Earl']
#注意 Cecil是如何彻底消失的，并且列表的长度也变成了4.del除了可以删除列表中的元素，还可以删除字典元素，甚至是其它变量分片赋值
>>> name = list('Perl')
>>> name
['P','e','r','l']
>>> name[2:] = list('ar')
>>> name
['P','e','a','r']列表方法
append
append方法用于在列表末尾追加新的对象
>>> lst = [1,2,3]
>>> lst.append(4)
>>> lst
[1,2,3,4]
#为啥我选择了如此糟糕的变量名lst，而不是使用list来表示一个列表呢？原因在于list是一个内键函数[^LaTeX].如果使用list作为变量名，我就无法调用list函数了。根据给定的应用程序可以定义更好的变量名，像lst这种变量名是毫无益处的。如果要定义一个价格的列表，那么就应该使用prices、prices_of_eggs，或者priceOfEggs作为变量名
注意：[^LaTeX]从python2.2开始，list就是一个类型而不是一个函数了。(tuple和str也是如此)count
count方法统计某个元素在列表中出现的次数：
>>>['to','be','or','not','to','be'].count('to')
2
>>> x = [[1,2],1,1,[2,1,[1,2]]]
>>> x.count(1)
2
>>> x.count([1,2])
1extend
extend方法可以在列表的末尾一次性追加另一个序列中的多个值。换句话，可以用新列表扩展原有的列表：
>>> a = [1,2,3]
>>> b = [4,5,6]
>>> a.extend(b)
>>> a
[1,2,3,4,5,6]
#这个操作看起来很像链接操作，两者最主要的区别在于：extend方法修改了被扩展的序列(在这个例子中，就是a)而原始的链接操作则不然，它会返回一个全新的列表：
>>> a = [1,2,3]
>>> b = [4,5,6]
>>> a + b
[1,2,3,4,5,6]
>>> a
[1,2,3]
#我们可以看到被连接的列表与之前例子中被扩展的列表是一样的，但是这一次它并没有被修改。这是因为原始的连接操作创建了一个包含了a和b副本的新列表index
index方法用于从列表中找出某个值第一个匹配项的索引位置:
>>> knights = ['We','are','the','knights','who','say','ni']
>>> knights.index('who')
4
>>> knights.index('hering')
Traceback (innermost last):
File "<pyshell#76>",line 1.in ?
knights.index('hering')
ValueError: list.index(x): x not in listinsert
>>> numbers = [1,2,3,4,5,6]
>>> numbers.insert(3,'four')
>>> numbers
[1, 2, 3, 'four', 4, 5, 6]
>>> numbers = [1,2,3,4,5,6,,7]
File "<stdin>", line 1
numbers = [1,2,3,4,5,6,,7]
^
SyntaxError: invalid syntax
>>> numbers = [1,2,3,4,5,6,7]
>>> numbers[3:3] = ['four']
>>> numbers
[1, 2, 3, 'four', 4, 5, 6, 7]
>>> pop
pop方法会移除列表中的一个元素(默认是最后一个)，并且返回该元素的值：
>>> numbers
[1, 2, 3, 'four', 4, 5, 6, 7]
>>> numbers
[1, 2, 3, 'four', 4, 5, 6, 7]
>>> numbers.pop()
7
>>> numbers
[1, 2, 3, 'four', 4, 5, 6]
#注意: pop方法是唯一一个既能修改列表又返回元素值(除了None)的列表方法
#使用pop方法可以实现一种常见的数据结构--栈。栈的原理就像堆放盘子那样。只能在顶部放一个#盘子，同样，也只能从顶部那走一个盘子，最后放入堆栈的最先被移除(这个原则称为LIFO，即后#进先出)remove
remove方法用于移除列表中某个值的第一个匹配项：
>>> x = ['to','be','or','not','to','be']
>>> x.remove('be')
>>> x
['to','be','or','not','to']reverse
reverse方法将列表中的元素反向存放
>>> x = [1,2,3]
>>> x.reverse()
>>> x
[3, 2, 1]sort
>>> x = [4,5,2,4,9,6,0]
>>> x.sort()
>>> x
[0, 2, 4, 4, 5, 6, 9]
>>> x = [2,1,6,3,9,7]
>>> y = x.sort()
>>> print y
None
>>> x = [3,4,1,7,5,0]
>>> y = x[:]
>>> y.sort()
>>> y
[0, 1, 3, 4, 5, 7]
>>> x
[3, 4, 1, 7, 5, 0]
>>> y = x
>>> y.sort()
>>> x
[0, 1, 3, 4, 5, 7]
>>> y
[0, 1, 3, 4, 5, 7]
>>> x = [4,6,2,1,7,9]
>>> y = sorted(x)
>>> x
[4, 6, 2, 1, 7, 9]
>>> y
[1, 2, 4, 6, 7, 9]
sorted函数实际上可以用于任何序列，却总是返回一个列表
>>>
补充列表的复制copy(python2.7中list没有copy属性，python3.x中有)
>>> name1 = ["cntsp","cnhsh","cntsw","cnlhq"]
>>> name2 = name1.copy()
>>> print(name1,"\n",name2)
["cntsp","cnhsh","cntsw","cnlhq"]
["cntsp","cnhsh","cntsw","cnlhq"]
>>> name1[2] ="CNTSW"
>>> print(name1,"\n",name2)
["cntsp","cnhsh","CNTSW","cnlhq"]
["cntsp","cnhsh","cntsw","cnlhq"]
>>> name3 = ["cntsp","cnhsh",["wang","jack"],"cntsw","cnlhq"]
>>> name4 = name3.copy()
>>> print(name3,"\n",name4)
["cntsp","cnhsh",["wang","jack"]"cntsw","cnlhq"]
["cntsp","cnhsh",["wang","jack"]"cntsw","cnlhq"]
>>> name3[1] = "CNHSH"
>>> name3[2][0] = "WANG"
>>> print(name3,"\n",name4)
['cntsp', 'CNHSH', ['WANG', 'jack'], 'cntsw', 'cnlhq']
['cntsp', 'cnhsh', ['WANG', 'jack'], 'cntsw', 'cnlhq']
# copy.copy() copy.deepcopy()的区别
字符串操作
基本字符串操作
所有标准的序列操作(索引、分片、乘法、判断成员资格、求长度、取最小值和最大值)对字符串同样适用
字符串格式化：精简版
format = “hello, %s, %s enough for ya?”
values = (“world”,”hot”)
print(format,% values)
hello, world, hot enough for ya?format = “Pi with three decimals: %.3f”
from math import pi
print(format % pi)
Pi with three decimals: 3.142
#格式化实数(浮点数),可以使用f说明转换说明符的类型，同时提供所需要的精度:一个句点再加上希望保留的小数位数。因为格式化转换说明符总是以表示类型的字符结束，所有精度应该放到类型字符前面
字符串方法
1 find方法
find方法可以在一个较长的字符串中查找子串。它返回子串所在位置的最左端索引。如果没有周到则返回-1.
>>>"with a moo-moo here, and a moo-moo there".find('moo')
7
>>>title = "Monty Python's Flying Circus"
>>>title.find('Monty')
02 join 方法
join方法是非常重要的字符串方法，它是split方法的逆方法，用来连接序列中的元素：
>>> seq = [1,2,3,4,5]
>>> sep = "+"
>>> sep.join(seq)#连接数字列表
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: sequence item 0: expected string, int found
>>> seq = ["1","2","3","4","5"]
>>> sep.join(seq)#连接字符串列表
'1+2+3+4+5'
>>> dirs = '','usr','bin','env'
>>> '/'.join(dirs)
'/usr/bin/env'
>>> print 'C:' + '\\'.join(dirs)
C:\usr\bin\env
#需要被连接的元素都必须是字符串，注意最后两个例子中使用了目录的列表，unix,windows不同3 lower方法
lower方法返回字符串的小写字符
>>> 'Trondheim Hammer Dance'.lower()
'trondheim hammer dance'
#islower\capitalize\swapcase\title\istitle\upper\isupper4 replace 方法
replace方法返回某字符串的所有匹配项均被替换之后得到字符串
>>> 'This is a test'.replace('is','eez')
'Theez eez a test'5 split
这是一个非常重要的字符串方法，它是join的逆方法，用来将字符串分隔成序列
>>> '1+2+3+4+5'.split('+')
['1', '2', '3', '4']
如果不提供任何分隔符，程序会把所有空格作为分隔符(空格、制表、换行等)6 strip
strip方法返回去除两侧(不包括内部)空格的字符串:
>>> ' internal whitespace is kept '.strip()
'internal whitespace is kept'字典操作
字典是一种key-value的数据类型
定义字典
phonebook = {'Alice':'1234','Beth':'912','Cecil':'1231'}dic函数
可以用dict函数，通过其它映射(比如其它字典)或者(键，值)对的序列建立字典
>>> items = [('name','Gumby'),('age',42)]
>>> d = dict(items)
>>> d
{'age': 42, 'name': 'Gumby'}dict函数也可以通过关键字参数来创建字典如：
>>> d = dict(name='Gumby',age=42)
>>> d
{'age': 42, 'name': 'Gumby'}
注意：dict函数根本不是真正的函数。它是一个类型，就像list、tuple和str一样基本字典操作
字典的基本行为在很多方面与序列(sequence)类似:
- len(d)返回d中项(键-值对)的数量
- d[k]返回关联到建k上的值
- d[k] = v 将值v关联到键k上
- del d[k]删除键为k的项
- k in d 检查d中是否有含有键为k的项
字典与列表的区别：- 键类型： 字典的键不一定为整型数据，键可以是任意的不可变类型，比如浮点类型、字符串或者元组
- 自动添加： 字典中可以随时添加键值对，从而建立新字典,而(在不使用append方法或者其他类型他操作的情况下)不能将值关联到列表之外的索引上
- 成员资格判断：表达式k in d(d为字典)查找的是键，而不是值，表达式v in l(l为列表)，则用来查找值，而不是索引。
注意：在字典中检查键的成员资格比在列表中检查值的成员资格更高效，数据结构的规模越大，两者的效率差距越明显
>>> x = []
>>> x[43] = "fools"
>>> x = {}
>>> x[42] = 'fools'
#有没有发现什么啊？字典方法
1 clear方法
>>> d = {}
>>> d['name'] = 'Gumby'
>>> d['age'] = 42
>>> d
{'age':42,'name':'Gumby'}
>>> returned_value = d.clear()
>>> d
{}
>>> print(returned_value)
None2 copy方法
copy方法返回一个具有相同键-值对的新字典(这个方法实现的是浅复制(shallow copy)),因为值本身就是相同的，而不是副本
>>> x = {'username':'admin','machines':{'foo','bar','barz'}}
>>> y = x.copy()
>>> y['username'] = 'mlh'
>>> y['machines'].remove('bar')
>>> y
{'username': 'mlh', 'machines': set(['barz', 'bar', 'foo'])}
>>> x
{'username': 'admin', 'machines': set(['barz', 'bar', 'foo'])}可以看到，挡在副本中替换值的时候，原始字典不受影响，但是，如果修改了某个值(原地修改，而不是替换),原始的字典也会改变，因为同样的值也存储在原字典中(就像上面例子中machines列表一样)
#接下来我们试试深度复制(deep copy)
>>> from copy import deepcopy
>>>d = {}
>>>d["name"] = ["Alfred","Bertrand"]
>>>c = d.copy()
>>>dc = deepcopy(d)
>>>d['name'].append('Clive')
>>>c
{'name': ['Alfred', 'Bertrand', 'Clive']}
>>>dc
{'name': ['Alfred', 'Bertrand']}3 fromkeys
fromkeys 方法使用给定的键建立新字典，每个键都对应一个默认值none
>>>{}.fromkeys(['name','age'])
{'age':None,'name': None}
>>> dict.fromkeys(['name','age'])
{'age':None,'name': None}
>>>dict.fromkeys(['name','age'],'know')
{'age':'know','name':'know'}4 get
get方法是个更宽松的访问字典项的方法。一般来说，如果试图访问字典中不存在的项时会出错：
>>>d = {}
>>>print(d['name'])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'name'
>>>print(d.get('name'))
None
>>>d.get('name','N/A')
'N/A'
>>>d['name'] = 'alice'
>>>d.get('name')
'alice'5 has_key
has_key方法可以检查字典中是否含有特定的键，表达式d.has_key(k)相当于表达式k in d.
>>>d = {}
>>>d.has_key('name')
False
>>>d['name'] = 'eric'
>>>d.has_key('name')
True6 items和iteritems
items方法将字典所有的项以列表方式返回，列表中的每一项都表示为(键-值)对的形式。但是项在返回时并没有遵循特定的次序
>>>d = {'title':'python is good','url':'http://www.python.org','spam':0}
>>>d.items()
[('url','http://www.python.org'),('spam',0),('title','python is good')]
iteritems方法的作用大致相同，但是会返回一个迭代器对象而不是列表
>>>it = d.iteritems()
>>>it
<dictionary-itemiterator object at 0x7f92b867ec00>
>>> list(it)#Convert the iterator to a list
[('url', 'http://www.python.org'), ('spam', 0), ('title', 'python is good')]
在很多情况下使用iteriterms会更加高效(尤其是想要迭代结果的情况下)7 keys和iterkeys
keys方法将字典中的键以列表的形式返回，而iterkeys则返回针对键的迭代器
8 pop
pop方法用来获得对应于给定键的值，然后将这个键-值对从字典中移除。
>>>d = {'x':1,'y':2}
>>>d.pop('x')
1
>>>d
{'y':2}9 setdefault
setdefault方法在某种程度上类似于get方法，能够获得给定键相关联的值，除此之外，setdefault还能在字典中不含有给地ing键的情况下设定相应的键值
d = {}
d.setdefault(‘name’,’N/A’)
‘N/A’
d
{‘name’:’N/A’}
d[‘name’] = ‘Gumby’
d.setdefault(‘name’,’N/A’)
‘Gumby’
d
{‘name’:’Gumby’}
可以看到，当键不存在的时候，setdefault返回默认值并且相应地更新字典。如果键存在，那么就返回与其对应地值，但不改变字典。默认值可选，这点和get一样，如果不设定，会默认使用None
## 10 update
update方法可以利用一个字典项更新另外一个字典
``` bash
>>>d = {'python':'oldboy','java':'oldgirls','c++':'oldman'}
>>>t = {'c#':'oldwomen'}
>>>d.update(t)
{'python': 'oldboy', 'c#': 'oldwomen', 'java': 'oldgirls', 'c++': 'oldman'}11 values和itervalues
values方法以列表地形式返回字典中地值(itervalues返回值地迭代器)。与返回键不同，列表中可以有重复值，因为字典中地值不是唯一的
>>>d = {'1':1,'2':2,'3':3,'4':1}
[1, 3, 2, 1]集合操作
天然去重，且无序
list_1 = {1,3,4,5,6,9}
list_2 = {1,3,7,8,34,0}
交集
list_1.intersection(list_2)
并集
print(list-1.union(list_2))
#差集
print(list_1.difference(list_2))
print(list_2.difference(list_1)
#子集
print(list_1.issubset)
文件操作
文件操作流程
- 打开文件，得到文件句柄并赋值给一个变量
- 通过句柄对文件进行操作
- 关闭文件
基本操作
f = open(“cntsp”) #打开文件
first_line = f.readline() #读一行
fire_line = f.readlines() #把文件中的内容全部读入到一个列表中，文件中的每行作为列表的一个元素
fire_line = f.read() #读取剩下的所有内容，文件大时不要用
f.close() #关闭文件
打开文件的模式有：- r,只读模式(默认)
- w,只写模式[不可读；不存在则创建；存在则删除内容;]
- a,追加模式[可读；不存在则创建；存在则追加内容;]
- “+” 表示可以同时读写某个文件
- r+,可读写文件
- w+,写读
- a+,同a
“U”表示在读取时，可以将\r \n \r\n自动转换成\n(与r或r+模式同使用) - rU
- r+U
“b”表示处理二进制文件(如；FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注) - rb
- wb
- ab
with 语句
为了避免打开文件后忘记关闭，可以通过管理上下文，即：
在python2.7后，with又支持同时对多个文件的上下文进行管理，即：> with open("log") as f: > pass > with open("logs1") as obj1, open("log2") as obj2: > pass
字符编码与转码
须知：
- 在python2默认编码时ASCII,python3里默认是unicode
- unicode 分为utf-32(占4个字节)，utf-16(占两个字节)，utf-8(占1-4个字节)，so utf-16就是现在最常用的unicode版本，不过在文件里存的还是utf-8，因为utf8省空间
- 在py3中encode，在转码的同时还会把string变成bytes类型，decode在解码的同时还会把bytes变回string
GBK需要转换为UTF-8格式流程
首先通过解码[decode]转换为Unicode编码
然后通过通过编码[encode]转换为UTF-8的编码
UTF-8需要转为GBK格式流程：
首先通过解码[decode]转换为Unicode编码
然后通过编码[encode]转换为GBK的编码
