列表、字典、元组、文件——Python

列表（list）：

列表是Python中最具灵活性的有序集合对象类型。

与字符串不同的是列表可以包含任何种类的对象，列表都是可变对象，支持在原处修改操作，可以通过指定的偏移值和分片、列表方法调用、删除语句等方法来实现。

Python列表的主要属性：

    任意对象的有序集合——列表就是收集其他对象的地方，包含的每一项都保持从左到右的顺序

    通过偏移读取——队列表对象通过偏移进行索引

    可变长度、异构、任意嵌套——列表可以实时的增长、缩短，可以包含任何类型的对象，支持任意嵌套

    属于可变序列分类——支持在原处修改

    对象引用数组——在Python解释器内部，列表就像C中的数组而不是链接结构。

常见的列表常量和操作：

为了得到更全面的信息，可以查阅Python标准库手册，或者运行help(list)，dir(list)查看list方法的完整列表清单。

L = []                                   #一个空列表

L = [0,1,2,3]                         #四项：索引为0到3

L = ['abc' , ['def' , 'ghi']]        #嵌套的子列表

L = list('spam')                     #可迭代项目的列表

L = list(range(-4,4))             #连续整数的列表，返回值：[-4, -3, -2, -1, 0, 1, 2, 3]

L[i]                                     #索引

L[i][j]                                  #索引的索引

L[i:j]                                   #分片

len(L)                                 #求长度

L1+L2                                #合并

L*3                                    #重复

for x in L：print (x)             #迭代

3 in L                                  #成员关系

L.append(4)                        #增长

L.extend([5,6,7])                 

L.insert(I,X)                        #插入

L.index(1)                          

L.Count(x)

L.sort()                             #索引

L.reverse()                       #反转

del L[k]                            #方法：缩短语句

del L[k:j]

L.pop()

L.remove(2)

L[k:j] = []

L[k] = 1                           #索引赋值

L[k:j] = [4，5，6]             #分片赋值

L = [x**2 for x in range(5)]                    #列表解析

list(map(ord,'spam'))

实际应用中的列表：

由于列表是序列，支持很多与字符串相同的操作。

基本列表操作：

>>> len([1,2,3])
3
>>> [1,2,3]+[4,5,6]
[1, 2, 3, 4, 5, 6]
>>> [1,2,3]*2
[1, 2, 3, 1, 2, 3]

不能将一个列表和一个字符串和并到一起，除非先把字符串转换为列表或把列表转换为字符串：

>>> str([1,2])+"34"
'[1, 2]34'
>>> [1,2]+list("34")
[1, 2, '3', '4']

列表迭代和解析：

>>> 3 in [1, 2, '3', '4']
False
>>> for x in [1, 2, '3', '4']:
...     print x
... 
1
2
3
4

列表解析——通过对序列中的每一项应用一个表达式来构建一个新的列表方式：

>>> res = [c*4 for c in 'spam']
>>> res
['ssss', 'pppp', 'aaaa', 'mmmm']

等同效果的手动构建：

>>> res = []
>>> for c in 'spam':
...     res.append(c*4)
... 
>>> res
['ssss', 'pppp', 'aaaa', 'mmmm']

map——内置函数map对序列中的各项应用一个函数并把结果收集到一个新列表中

>>> list(map(abs,[-1,-2,0,1,2]))
[1, 2, 0, 1, 2]

索引、分片、矩阵

由于列表都是序列，对于列表而言，索引和分片操作和字符串中基本相似——对列表进行索引的结果就是指定的偏移处的对象，对列表进行分片返回一个新列表。

>>> L = ['I','Love','Pyton']
>>> L[2]
'Pyton'
>>> L[-2]
'Love'
>>> L[1:]
['Love', 'Pyton']

矩阵（多维数组）：Python中为嵌套了子列表的列表

由于列表允许嵌套，所以有时需要多次索引操作连在一起使用。下面的例子中：使用一次索引操作得到一个嵌套的子列表，使用两次索引得到子列表中具体的项。

>>> matrix = [[1,2,3],[4,5,6],[7,8,9]]
>>> matrix[1]
[4, 5, 6]
>>> matrix[1][1]
5
>>> matrix[2][0]

原处修改列表：

由于列表是可变的，所以支持原处修改列表的操作，而不会像字符串那样强迫建立新的拷贝。

索引、分片、赋值：

>>> L = ['I','Love','Pyton']
>>> L[1] = 'LOVE'
>>> L
['I', 'LOVE', 'Pyton']
>>> L[0:2] = ['Bob','like']
>>> L
['Bob', 'like', 'Pyton']

注意：索引和分片都是原地修改即对列表直接修改，而不是生成一个新的列表作为结果

>>> L = [1,2,3]
>>> L[2] = [4,5]
>>> L
[1, 2, [4, 5]]
>>> L[1:2] = [4,5]
>>> L
[1, 4, 5, [4, 5]]

分片赋值可以理解为两步（但是实际情况并非如此）：

1）删除：删除等号左边指定的分片

2）插入：将等号右边的对象插中的片段插入旧分片被删除的位置

这样可以帮助你理解为什么插入的元素不需要与删除的元素数目相等

列表方法调用：

<pre code_snippet_id="384110" snippet_file_name="blog_20140609_11_4711602" name="code" class="python" style="margin-top: 4px; margin-right: 0px; margin-bottom: 4px; margin-left: 0px; background-color: rgb(240, 240, 240); ">>>> L = ['I','love','Python']
>>> L.append('more')  #将一个单项加至列表末端，append只允许传入单一对象；L.append(X)与L+[X]的结果</span>

                       一样但是前者会原地修改L，后者会产生新的列表</span>

>>> L
['I', 'love', 'Python', 'more']
>>> L.sort()           #sort原地对列表进行排序，以递增顺序进行排序
>>> L
['I', 'Python', 'love', 'more']   

我们可以通过传入关键字参数来修改排序行为：

>>> L = ['abc','ABD','aBe']
>>> L.sort()
>>> L
['ABD', 'aBe', 'abc']
>>> L.sort(key=str.lower)
>>> L
['abc', 'ABD', 'aBe']
>>> L = ['abc','ABD','aBe']
>>> L.sort(key=str.lower,reverse=True)
>>> L
['aBe', 'ABD', 'abc']</span>

其他方法调用：

sorted：

>>> sorted(L,key=str.lower,reverse=True)
['aBe', 'ABD', 'abc']
>>> sorted([x.lower() for x in L],reverse=True)  #使用列表解析在排序之前转换为小写
['abe', 'abd', 'abc']

extend()——在列表末端插入多个元素。

pop()——删除一个元素。

reversed ()——原地翻转列表使用时必须包含在一个list调用中，因为它是一个迭代器。

<span style="font-family:Arial, Helvetica, sans-serif;"><span style="white-space: normal;"><span style="font-family:monospace;"><span style="white-space: pre;"></span></span></span></span><p style="margin-top: 4px; margin-right: 0px; margin-bottom: 4px; margin-left: 0px; padding-top: 2px; padding-right: 0px; padding-bottom: 2px; padding-left: 0px; "><span style="font-family:monospace;"><span style="white-space: pre; "></span></span></p><span style="font-family:monospace;"></span><pre name="code" class="python" style="margin-top: 4px; margin-right: 0px; margin-bottom: 4px; margin-left: 0px; background-color: rgb(240, 240, 240); ">>>> L = [1,2]
>>> L.extend([4,5,6])
>>> L
[1, 2, 4, 5, 6]
>>> L.pop()
6
>>> L
[1, 2, 4, 5]
>>> L.reverse()
>>> L
[5, 4, 2, 1]
>>> list(reversed(L))
[1, 2, 4, 5]

>>> L = []
>>> L.append(1)
>>> L.append(2)
>>> L
[1, 2]
>>> L.pop() #pop()方法默认值为最后一个元素
2
>>> L = ['I','Love','Pyton']
>>> L.index('Love')
1
>>> L.insert(1,'LOVE')
>>> L
['I', 'LOVE', 'Love', 'Pyton']
>>> L.remove('Love')
>>> L
['I', 'LOVE', 'Pyton']
>>> L.pop(1) #pop()方法也可以指定将删除并返回元素的偏移
'LOVE'
>>> L
['I', 'Pyton']

其他常见列表操作：

del——列表是可变的，可以使用del语句在原处删除某项或某片段

>>> L = ['I','Love','Pyton']
>>> del L[0]
>>> L
['Love', 'Pyton']
>>> del L[1:]
>>> L
['Love']

因为分片赋值是删除加插入操作，所以可以通过将空列表赋值给分片来删除列表片段

>>> L = ['I','Love','Pyton']
>>> L[1:] = []
>>> L
['I']
>>> L[0] = []
>>> L
[[]]

字典（dictionary）：

除了列表以外，字典也许是Python之中最灵活的内置数据结构类型。如果把列表看作有序的对象集合，那么就可以把字典当成无序的对象集合，他们的主要差别在于：字典中的元素是通过键来存取的，而不是通过偏移存取的。

Python字典的主要属性：

    通过键而不是偏移量来读取——字典有时叫做关联数组或是散列表，通过键将一系列值联系在一起。

    任意对象的无序集合——字典中的项没有特定顺序。

    可变长、异构、任意嵌套——字典可在原处增长、缩短（无须生成一份拷贝），可以包含任何类型对象，支持任意深                                            度嵌套。

    属于可变映射类型——通过索引赋值，字典可在原处修改。

    对象引用表——字典支持键读取的无序对象引用表，列表则支持位置读取的对象引用数组。

常见字典常量和操作：

该例总结了一些具有代表性的字典操作（查看库手册或者运行dir(dict)——{使用dir获取模块内部可用变量名的列表}或是help(dict)可以得到完整的清单，类型名为dict）。当写成常量表达式时，字典以一系列"键:值(key:value)"形式出现，用逗号隔开，大括号括起来。一个空字典就是一对大括号，字典可以作为另一个字典的（列表、元组）中的某一个值被嵌套。

>>> D = {} #空字典

>>> D = {'spam':2,'eggs':3} #两项目字典

>>> D = {'food':{'ham':1,'eggs':2}} #嵌套

>>> D = dict.fromkeys(['a','b']) #其他构造技术

>>> D = dict(zip(keylist,valslist)) #关键字、对应的对、键列表

>>> D = dict(name='Bob',age=42)

>>> D['eggs'] #以键进行索引运算

>>> D['food']['ham' ]

>>> 'eggs' in D #键存在测试

>>>D.keys #方法：键

>>>D.values#方法：值

>>>D.items #方法：键+值>>>D.copy#方法：副本

>>>D.get(key,values)#方法：默认

>>>D.update(D2)#合并

>>>D.pop(key) #删除等

>>>len(D) #长度

>>>D[key] = 42 #新增/修改 键，删除键

>>>delD[key] #根据键删除条目

>>>list(D.keys()) #字典视图（Python 3.0）

>>>D1.keys() & D2.keys()

>>>Dictionary views (Python 3.0)

>>>D = {x: x*2 for x in range(10)} #字典解析（Python 3.0）

实际应用中的字典：

字典通过键进行索引，被嵌套的字典是通过一系列的索引表示的，当Python创建字典时，会按照任意所选，从左到右的顺序来存储项，为了取值需要提供键。

字典的基本操作：

>>> D = {'spam':2,'ham':1,'eggs':3}
>>> D['spam']
2
>>> D
{'eggs': 3, 'ham': 1, 'spam': 2}

注意：本例中最后的输出和原先设定的顺序不同。这样设计的目的是为了快速进行键查找（也就是散列查找），键需在内存中随机设定这里就是为什么假设从左到右的顺序操（例如：分片和合并）作不适合字典，在字典中只能用键进行取值，而不是用位置进行取值。

>>> len(D)                   #返回keys列表长度或字典中元素数目
3
>>> 'ham' in D               #测试键是否存在
True
>>> list(D.keys())           #建立关于key的列表
['eggs', 'ham', 'spam']

原处修改字典：

字典是可变的因此可以在原处对其进行修改，扩展，缩短而不需要生成新的字典。

简单的一个赋值就可以生成或者改变元素。

>>> D
{'eggs': 3, 'ham': 1, 'spam': 2}
>>> D['ham'] = ['I','am','wy']          #改变键值对应的valus
>>> D
{'eggs': 3, 'ham': ['I', 'am', 'wy'], 'spam': 2}
>>> del D['eggs']                 #通过键值删除values
>>> D
{'ham': ['I', 'am', 'wy'], 'spam': 2}
>>> D['new'] = 'apple'            #增加新的values 为 apple，key为'new'
>>> D
{'new': 'apple', 'ham': ['I', 'am', 'wy'], 'spam': 2}

注意：在列表中Python会将超出列表末尾的偏移视为越界并报错，所以在列表中需要使用append方法或分片赋值来实现，但是在字典中可以对新的字典键进行赋值，而不需要考虑上述问题。

其他字典方法：

Eg：

字典的values和items方法分别返回字典的值列表和（key,values）对元组。

>>> D = {'spam':2,'ham':1,'eggs':3}
>>> list(D.values())
[3, 1, 2]
>>> list(D.items())
[('eggs', 3), ('ham', 1), ('spam', 2)]

上述方法在逐项遍历字典项的循环中是很有效的。读取不存在的键会出错， 键不存在时通过get的方法会返回默认值（None或用户定义的默认值）。这是当键不存在时为了避免missing-key错误而填入默认值的一个方法：

>>> D.get('spam')
2
>>> print D.get('new')
None
>>> D.get('new',12)
12

字典的update方法有点类似于合并，但是它和从左到右的顺序无关（再一次强调，字典中没有这样的事情）。

>>> D = {'spam':2,'ham':1,'eggs':3}
>>> D2 = {'new':4,'name':6}
>>> D.update(D2)
>>> D
{'new': 4, 'eggs': 3, 'ham': 1, 'name': 6, 'spam': 2}

把一个字典的键值合并到另一个字典中时会有覆盖键值的情况存在：

>>> D = {'spam':2,'ham':1,'eggs':3}
>>> D2 = {'new':4,'eggs':6}
>>> D.update(D2)
>>> D
{'new': 4, 'eggs': 6, 'ham': 1, 'spam': 2}

字典的pop方法能从字典中删除一个键并返回他的值（和列表的pop方法区别在于删除的是键而不是一个可选位置）：

>>> D = {'new': 4, 'eggs': 3, 'ham': 1, 'name': 6, 'spam': 2}
>>> D
{'new': 4, 'eggs': 3, 'spam': 2, 'ham': 1, 'name': 6}
>>> D.pop('new')
4
>>> D
{'eggs': 3, 'spam': 2, 'ham': 1, 'name': 6}
>>> L = ['aa','bb','cc','dd']
>>> 
>>> L.pop()
'dd'
>>> L.pop(1)
'bb'
>>> L
['aa', 'cc']

元组：

元组——无法修改的对象的集合。

元组由简单的对象构成，与列表相似，之不过元组不能在原处修改（它们是不可变的），通常写成圆括号中的一系列项。元组不支持任何方法调用，但是具有列表的大多数属性。

元组的属性：

任意对象的有序集合——元组是一个位置有序的对象集合。

通过偏移存取——在元组中的元素通过偏移访问。

属于不可变数据类型——元组是不可变的，不支持任何原处修改操作。

固定长度、异构、任意嵌套——因为元组是不可变的，在不生成一个拷贝的情况下不能增长或缩短。

对象引用的数组——元组可以看成对象引用的数组。

常见元组常量和运算：

()                                    #空元组

T = (0，)                         #单个元素的元组，非表达式

T = (0，'Ni'，1.2，3)        #四个元素的元组

T = 0，'Ni'，1.2，3         #四个元素的元组，与上述元组等价

T = ('abc'，('def','ghi'))    #嵌套元组

T = tuple('spam')            #一个可迭代对象的项的元组

T[i]                                #索引

T[i][j]                             #索引的索引

T[i:j]                              #分片

len(T)                            #长度

T1 + T2                        #合并

T1 * 3                           #重复

for X in T: print (x)        #迭代，成员关系

'spam' in T

[x**2 for x in T]

T.index('Ni')                  #搜索

T.count('Ni')                  #计数

实际应用中的元组：

元组没有方法（例如，append()方法在元组是不可用的），然而元组支持字符串和列表的一般序列操作。

>>> (1,2)+(3,4)
(1, 2, 3, 4)
>>> (1,2)*3
(1, 2, 1, 2, 1, 2)
>>> T = (1,2,3,4)
>>> T[0]
1
>>> T[1:]
(2, 3, 4)

元组的特殊语法：逗号和圆括号

注意：因为圆括号可以把表达式括起来，如果圆括号里的单一对象是元组对象而不是简单的表达式，需要对Python进行特别说明。如果确实想得到一个元组，只需要在单个元素之后，关闭括号之前加上一个逗号就可以了。

>>> X = (40)
>>> X
40
>>> Y = (40,)
>>> Y
(40,)

作为特殊情况，在不引起语法冲突的情况下，Python允许忽略元组的圆括号。

在赋值语句中，即使没有圆括号，Python也能识别出这是一个元组：

>>> X = 1,2,3,4
>>> X
(1, 2, 3, 4)

圆括号有助于增加脚本的可读性。但是在元组作为常量传递给函数调用以及元组在Python2.X的print语句中列出的情况下是必不可少的，其他情况根据自己编码爱好可有可无。

转换、方法、不可变性：

除了常量语法不同以外，元组的操作与字符串及列表是一致的。注意：+、*、分片操作在用于元祖中时将返回新元组，并且元组不提供字符串、列表和字典中的方法。

例如：对元组进行排序操作，通常先将其转换成一个可变对象，才能获得使用排序方法调用的权限或者使用新的sorted方法，他接受任何序列对象。

>>> tmp
['cc', 'aa', 'dd', 'bb']
>>> tmp.sort()
>>> tmp
['aa', 'bb', 'cc', 'dd']
>>> T = tuple(tmp)         #将tmp初始化为元组
>>> T
('aa', 'bb', 'cc', 'dd')
>>> T = ('cc','aa','dd','bb')
>>> sorted(T)
['aa', 'bb', 'cc', 'dd']

列表解析也可以用于元组转换。

由元组生成的列表每一项都加上20：

>>> T = (1,2,3,4,5) 
>>> L = [x+20 for x in T]
>>> L
[21, 22, 23, 24, 25]

注：列表解析是名副其实的序列操作——他们总会创建新列表，但也可以用于遍历包括元组、字符串、以及其他列表在内的任何序列序列上，列表解析还可以用在某些并非实际存储的序列之上—任何可遍历的对象都可以，包括可自动逐行读取的文件。

尽管元组的方法和列表字符串不同，但是元组在Python2.6和3.0中有两个自己的方法——index和count：

>>> T = (1,2,3,2,4,2) 
>>> T.index(2)
1
>>> T.index(2,2)
3
>>> T.count(2)
3

注意：元组的不可变性只适用于元组本身顶层，而并非其内容。

>>> T = (1,[2,3],4) 
>>> T
(1, [2, 3], 4)
>>> T[1]
[2, 3]
>>> T[1] = 'love'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> T[1][0] = 'love'
>>> T
(1, ['love', 3], 4)
>>> T[0] = 'I'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

对于多数程序而言，这种单层深度的不可变性对一般元组角色已经足够了。

为什么有了列表还要有元组：

元组的不可变性提供了某种完整性，这样可以确保元组在程序中不会被另一个引用修改，而列表就没有这样的保证，因此，元组的角色类似于其他语言中的“常量”声明。然而，这种常数概念在Python中是与对象结合的，而不是变量。

文件：

文件对象——计算机上外部文件的接口，处理文件常用的并且全能的工具。

文件：计算机中由操作系统管理的具有名字的存储区域。

Python文件对象——提供一种可以存取Python程序内部文件的方法。

简而言之：内置open函数会创建一个Python文件对象，可以作为计算机上的一个链接。在调用open之后，可以通过调用返回文件对象的方法读写相关外部文件。

与我们之前见过的类型相比，文件对象多少有些不一样。它们不是数字、序列也不是对应。相反，文件对象只是常见文件处理任务输出模块。

常见文件操作：

output = open(r'filename','w')                             #创建输出文件（'w'表示写入）

input = open('filename','r')                                  #创建输入文件（'r'表示读写）

input = open('filename')                                      #同上'r'为默认值

aString = input.read()                                         #把整个文件独进单一字符串

aString = input.read(N)                                       #读取之后的N个字节到一个字符串

aString = input.readline()                                    #读取下一行（包括行末标识符）到一个字符串

aList =  input.readlines()                                      #读取整个文件到字符串列表

output.write(aString)                                           #写入字节字符串到文件

output.writelines(aList)                                        #把列表内所有的字符串写入文件

output.close()                                                      #手动关闭文件

output.flush()                                                       #把输出缓冲区刷到硬盘中，但不关闭文件

anyFile.seek(N)                                                    #修改文件位置到偏移量N处以便进行下一个操作

for line in open('filename'): use line                       #文件迭代器，一行一行的读取文件

open('f.txt',encoding='latin-1')                               #Python 3.0 unicode文件

open('f.bin','rb')                                                     #Python 3.0 二进制byte文件

打开文件：

为了打开一个文件，程序会调用内置open函数，首先是外部名，接着是处理模式。

模式：

r（默认值）:为输入打开文件

w:为输出并打开文件

a:为在文件尾部追加内容而打开文件

在模式字符串尾部加上b可以进行二进制数据处理，加上+表示同时为输入和输出打开文件。

使用文件:

一旦存在一个文件对象，就可以调用其方法来读写相关的外部文件。任何情况下，Python程序的中的文本文件都采取字符串形式。读取文件时会返回字符串形式的文本，我文本作为字符串传递给write方法。

基础用法： 文件迭代器是最好的读取行工具；

                从文件读取数据到脚本时是一个字符串，如果字符串不是你所需，就需要转换类型；

                close是通常选型；

                文件是缓冲的并且是可查找的；

参考：Python学习手册