Python之路【第二篇】: 列表、元组、字符串、字典、集合

本文内容:

--------------------------------------

1. 列表、元组操作
2. 字符串操作
3. 字典操作
4. 集合操作
5. 文件操作
6. 字符编码与转码

1. 列表(list)

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

Python有6个序列的内置类型，但最常见的是列表和元组。

序列都可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];

与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。

>>> names = ['Shuke',"Jack",'Jone']
>>> names[0]
'Shuke'
>>> names[2]
'Jone'
>>> names[-1]     # 最后一个元素下标是-1
'Jone'
>>> names[-2]     # 倒数的第二个元素下标是-2
'Jack

• 切片

使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示：

>>> names = ["Alex","Tenglan","Eric","Rain","Tom","Amy"]
>>> names[1:4]  #取下标1至下标4之间的数字，包括1，不包括4
['Tenglan', 'Eric', 'Rain']
>>> names[1:-1] #取下标1至-1的值，不包括-1
['Tenglan', 'Eric', 'Rain', 'Tom']
>>> names[0:3]
['Alex', 'Tenglan', 'Eric']
>>> names[:3] #如果是从头开始取，0可以忽略，跟上句效果一样
['Alex', 'Tenglan', 'Eric']
>>> names[3:] #如果想取最后一个，必须不能写-1，只能这么写
['Rain', 'Tom', 'Amy']
>>> names[3:-1] #这样-1就不会被包含了
['Rain', 'Tom']
>>> names[0::2] #后面的2是代表，每隔一个元素，就取一个
['Alex', 'Eric', 'Tom']
>>> names[::2] #和上句效果一样
['Alex', 'Eric', 'Tom'

切片

• 追加

描述

append() 方法用于在列表末尾添加新的对象。

语法

append()方法语法：

list.append(obj)      #obj -- 添加到列表末尾的对象。

>>> names
['Shuke', 'Jack', 'Jone']
>>> names.append("Alex")     #追加
>>> names
['Shuke', 'Jack', 'Jone', 'Alex']

追加append()

• 插入

描述

insert() 函数用于将指定对象插入列表的指定位置。

语法

insert()方法语法：

list.insert(index, obj)　　　　　　# index -- 对象 obj 需要插入的索引位置,obj -- 要插入列表中的对象。

>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
>>> names.insert(2,"强行从Eric前面插入")
>>> names
['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
 
>>> names.insert(5,"从eric后面插入试试新姿势")
>>> names
['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']

插入(insert)

• 修改

语法

通过索引找到列表中的元素，并修改，使用=等号赋予新值

>>> names
['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
>>> names[2] = "该换人了"
>>> names
['Alex', 'Tenglan', '该换人了', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']

修改

• 删除

描述

del 删除列表中指定索引位置的元素。

remove() 函数用于移除列表中某个值的第一个匹配项

pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

语法

del list[index]               # 删除列表中指定索引位置的元素,index --留空表示删除列表。
list.remove(obj)　　　　　　　　#obj -- 列表中要移除的对象。
list.pop(obj=list[-1])        # obj -- 可选参数，要移除列表元素的对象。

>>> del names[2]
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
>>> del names[4]
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
>>>
>>> names.remove("Eric") #删除指定元素
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', '我是新来的']
>>> names.pop() #删除列表最后一个值
'我是新来的'
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']

删除(del/pop/remove)

• 拷贝

>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]
 
>>> name_copy = names.copy()
>>> name_copy
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

拷贝(copy)

• 统计

>>> names
['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]
>>> names.count("Amy")
2

统计(count)

• 排序和翻转

描述

sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

reverse() 函数用于反向列表中元素。

语法

sort()方法语法：

list.sort([func])     #func -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
list.reverse()        # 没有参数，直接调用方法

"""
注:
1. python2.x中列表元素可以为数字，字符串，布尔值，None等;
2. python3.x中列表元素必须为同一种数据类型
"""
 
# ========sort()=========
# python2.x
names = ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 123, True, False]
names.sort()
print names            # [False, True, 123, 'Alex', 'Amy', 'Rain', 'Tenglan', 'Tom']
 
# python3.x
'''
执行结果:
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: unorderable types: int() < str()
'''
 
# ========reverse()=========
# python2.x 和 python3.x相同
names = ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy',123, True, False]
names.reverse()
print(names)             # [False, True, 123, 'Amy', 'Tom', 'Rain', 'Tenglan', 'Alex']

排序(sort)和翻转(reverse)

• 获取下标

描述

index() 函数用于从列表中找出某个值第一个匹配项的索引位置。

语法

index()方法语法：

list.index(obj)            #obj -- 查找的对象。

>>> names
['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '', '', '']
>>> names.index("Amy")
2 #只返回找到的第一个下标

下标index()

• 列表扩展

描述

extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。

语法

extend()方法语法：

list.extend(seq)        # seq -- 元素列表。

>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']
>>> b = [1,2,3]
>>> names.extend(b)
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

扩展extend()

列表小结

Python列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表，如下所示：

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print x,	1 2 3	迭代

函数

• cmp(list1, list2) 比较两个列表的元素
• len(list) 列表元素个数
• max(list) 返回列表元素最大值
• min(list) 返回列表元素最小值
• list(seq) 将元组转换为列表

方法

1. list.append(obj)		在列表末尾添加新的对象
2. list.count(obj)		　　　　 统计某个元素在列表中出现的次数
3. list.extend(seq)		在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4. list.index(obj)		　　　　 从列表中找出某个值第一个匹配项的索引位置
5. list.insert(index, obj)		将对象插入列表
6. list.pop(obj=list[-1])		移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7. list.remove(obj)		移除列表中某个值的第一个匹配项
8. list.reverse()		　　     反向列表中元素
9. list.sort([func])		对原列表进行排序

注: http://www.runoob.com/python/python-lists.html

2. 元组(tuple)

Python的元组与列表类似，不同之处在于元组的元素不能修改，元组又称为是不可变的列表。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

语法:

tup1 = ('physics', 'chemistry', 1997, 2000);

创建空元组

tup1 = ();

元组中只包含一个元素时，需要在元素后面添加逗号

tup1 = (50,);

元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print x,	1 2 3	迭代

元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：

元组：

L = ('spam', 'Spam', 'SPAM!')

Python 表达式	结果	描述
L[2]	'SPAM!'	读取第三个元素
L[-2]	'Spam'	反向读取；读取倒数第二个元素
L[1:]	('Spam', 'SPAM!')	截取元素

元组内置函数

Python元组包含了以下内置函数

1. cmp(tuple1, tuple2)	比较两个元组元素。
2. len(tuple)	计算元组元素个数。
3. max(tuple)	返回元组中元素最大值。
4. min(tuple)	返回元组中元素最小值。
5. tuple(seq)	将列表转换为元组

注： http://www.runoob.com/python/python-tuples.html　

3. 字符串(string)

特性: 不可改变

name.capitalize()  首字母大写
name.casefold()   大写全部变小写
name.center(50,"-")  输出 '---------------------Alex Li----------------------'
name.count('lex') 统计 lex出现次数
name.encode()  将字符串编码成bytes格式
name.endswith("Li")  判断字符串是否以 Li结尾
 "Alex\tLi".expandtabs(10) 输出'Alex      Li'， 将\t转换成多长的空格
 name.find('A')  查找A,找到返回其索引， 找不到返回-1 
 
format :
    >>> msg = "my name is {}, and age is {}"
    >>> msg.format("alex",22)
    'my name is alex, and age is 22'
    >>> msg = "my name is {1}, and age is {0}"
    >>> msg.format("alex",22)
    'my name is 22, and age is alex'
    >>> msg = "my name is {name}, and age is {age}"
    >>> msg.format(age=22,name="ale")
    'my name is ale, and age is 22'
format_map
    >>> msg.format_map({'name':'alex','age':22})
    'my name is alex, and age is 22'
 
msg.index('a')  返回a所在字符串的索引
'9aA'.isalnum()   True
 
'9'.isdigit() 是否整数
name.isnumeric
name.isprintable
name.isspace
name.istitle
name.isupper
 "|".join(['alex','jack','rain'])
'alex|jack|rain'
 
maketrans
    >>> intab = "aeiou"  #This is the string having actual characters.
    >>> outtab = "12345" #This is the string having corresponding mapping character
    >>> trantab = str.maketrans(intab, outtab)
    >>>
    >>> str = "this is string example....wow!!!"
    >>> str.translate(trantab)
    'th3s 3s str3ng 2x1mpl2....w4w!!!'
 
 msg.partition('is')   输出 ('my name ', 'is', ' {name}, and age is {age}') 
 
 >>> "alex li, chinese name is lijie".replace("li","LI",1)
     'alex LI, chinese name is lijie'
 
 msg.swapcase 大小写互换
 
 >>> msg.zfill(40)
'00000my name is {name}, and age is {age}'
 
>>> n4.ljust(40,"-")
'Hello 2orld-----------------------------'
>>> n4.rjust(40,"-")
'-----------------------------Hello 2orld'
 
>>> b="ddefdsdff_哈哈"
>>> b.isidentifier() #检测一段字符串可否被当作标志符，即是否符合变量命名规则
True

注： http://www.runoob.com/python3/python3-string.html

4. 字典(dict)

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

一个简单的字典实例，语法:

info = {
    'stu1101': "TengLan Wu",
    'stu1102': "LongZe Luola",
    'stu1103': "XiaoZe Maliya",
}
或
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
或
dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };

字典的特性：

• dict是无序的。
• key必须是唯一的,so 天生去重  （不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住）。
• 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行。

增加

向字典添加新内容的方法是增加新的键/值对

>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> dict['School']='oldboy'
>>> dict
{'Age': 7, 'Name': 'Runoob', 'School': 'oldboy', 'Class': 'First'}

增加

修改

更改key对应的value即可

>>> dict['Name']='Shuke'
>>> dict
{'Age': 7, 'Name': 'Shuke', 'School': 'oldboy', 'Class': 'First'}

修改

删除

del dict['Name'] # 删除键 'Name'
dict.pop('Name') # 删除键 'Name',返回值为value
dict.popitem()   # 随机删除
dict.clear()     # 删除字典
del dict         # 删除字典

>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> dict.pop("Age")    #标准删除
>>> dict
{'Name': 'Runoob', 'Class': 'First'}
>>> del dict['Class']    #删除Class键值对
>>> dict
{'Name': 'Runoob'}
 
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> dict.popitem()    #随机删除
('Age', 7)
>>> dict
{'Name': 'Runoob', 'Class': 'First'}    
 
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> dict.clear()    #清空字典
>>> dict
{}
>>> info
{'stu1104': 'tenglan Wu', 'stu1101': 'TengLan Wu', 'stu1103': 'XiaoZe Maliya', 'stu1102': 'LongZe Luola'}
>>> del info
>>> info
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'info' is not defined
>>> 

删除

查找

>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> "Name" in dict     #标准用法
True
>>> dict.get("Age")    #获取
7
>>> dict['Age']      #获取，与get方法有区别
7
>>> dict['School']    #key不存在会报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'School'
>>> dict.get('School')     #key若不存在，返回为空，无报错
>>>

查找

多级字典嵌套及操作

av_catalog = {
    "欧美":{
        "www.youporn.com": ["很多免费的,世界最大的","质量一般"],
        "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
        "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
        "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]
    },
    "日韩":{
        "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
    },
    "大陆":{
        "":["全部免费,真好,好人一生平安","服务器在国外,慢"]
    }
}
 
av_catalog["大陆"][""][1] += ",可以用爬虫爬下来"
print(av_catalog["大陆"][""])
#ouput
['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']

字典嵌套

其他用法

#values
>>> info.values()
dict_values(['LongZe Luola', 'XiaoZe Maliya'])
 
#keys
>>> info.keys()
dict_keys(['stu1102', 'stu1103'])
 
#setdefault
>>> info.setdefault("stu1106","Alex")
'Alex'
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
>>> info.setdefault("stu1102","龙泽萝拉")
'LongZe Luola'
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
 
#update
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
>>> b = {1:2,3:4, "stu1102":"龙泽萝拉"}
>>> info.update(b)
>>> info
{'stu1102': '龙泽萝拉', 1: 2, 3: 4, 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
 
#items
info.items()
dict_items([('stu1102', '龙泽萝拉'), (1, 2), (3, 4), ('stu1103', 'XiaoZe Maliya'), ('stu1106', 'Alex')])
 
#通过一个列表生成默认dict,有个没办法解释的坑，少用吧这个
>>> dict.fromkeys([1,2,3],'testd')
{1: 'testd', 2: 'testd', 3: 'testd'}
 
#输出字典，以可打印的字符串表示
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> str(dict)
"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"
 
#计算字典元素个数，即键的总数
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> len(dict)
3

其他姿势

循环dict

#方法1，常用
for key in info:
    print(key,info[key])
 
#方法2
for k,v in info.items():    #会先把dict转成list,数据里大时慎用
    print(k,v)
 
#方法3,输出带有编号
>>> for k,v in enumerate(info,1):    #通过enumerate方法取出key，然后通过get方法获取value
...     print(k,v,info.get(v))
...
1 Age 7
2 Name Runoob
3 Class First

迭代dict

字典内置函数&方法

Python字典包含了以下内置函数：

序号	函数及描述	实例
1	len(dict) 计算字典元素个数，即键的总数。	>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> len(dict) 3
2	str(dict) 输出字典，以可打印的字符串表示。	>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> str(dict) "{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"
3	type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。	>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> type(dict) <class 'dict'>

Python字典包含了以下内置方法：

1. radiansdict.clear()　　　　　　　　　　　　　　　删除字典内所有元素
2. radiansdict.copy()　　　　　　　　　　　　　　　　返回一个字典的浅复制
3. radiansdict.fromkeys()　　　　　　　　　　　　　 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4. radiansdict.get(key, default=None)　　　　　　 返回指定键的值，如果值不在字典中返回default值
5. key in dict　　　　　　　　　　　　　　　　　　　　如果键在字典dict里返回true，否则返回false
6. radiansdict.items()　　　　　　　　　　　　　　 　以列表返回可遍历的(键, 值) 元组数组
7. radiansdict.keys()　　　　　　　　　　　　　　　　以列表返回一个字典所有的键
8. radiansdict.setdefault(key, default=None)　　 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9. radiansdict.update(dict2)　　　　　　　　　　　　把字典dict2的键/值对更新到dict里
10. radiansdict.values()　　　　　　　　　　　　　　以列表返回字典中的所有值

注： http://www.runoob.com/python3/python3-dictionary.html

5. 集合(set)

集合是一个无序的，不重复的数据组合，它的主要作用如下：

• 去重，把一个列表变成集合，就自动去重了
• 关系测试，测试两组数据之前的交集、差集、并集等关系

常用操作

s = set([3,5,9,10])      #创建一个数值集合  
 
t = set("Hello")         #创建一个唯一字符的集合  
 
a = t | s          # t 和 s的并集  
 
b = t & s          # t 和 s的交集  
 
c = t – s          # 求差集（项在t中，但不在s中）  
 
d = t ^ s          # 对称差集（项在t或s中，但不会同时出现在二者中）  
 
基本操作：  
 
t.add('x')            # 添加一项  
 
s.update([10,37,42])  # 在s中添加多项  
 
使用remove()可以删除一项：  
 
t.remove('H')  
 
len(s)
set 的长度  
 
x in s
测试 x 是否是 s 的成员  
 
x not in s
测试 x 是否不是 s 的成员  
 
s.issubset(t)
s <= t
测试是否 s 中的每一个元素都在 t 中  
 
s.issuperset(t)
s >= t
测试是否 t 中的每一个元素都在 s 中  
 
s.union(t)
s | t
返回一个新的 set 包含 s 和 t 中的每一个元素  
 
s.intersection(t)
s & t
返回一个新的 set 包含 s 和 t 中的公共元素  
 
s.difference(t)
s - t
返回一个新的 set 包含 s 中有但是 t 中没有的元素  
 
s.symmetric_difference(t)
s ^ t
返回一个新的 set 包含 s 和 t 中不重复的元素  
 
s.copy()
返回 set “s”的一个浅复制

常用(set)

参考: http://www.cnblogs.com/morninggood/articles/6829808.html

6. 文件操作(file)

对文件操作流程

1. 打开文件，得到文件句柄并赋值给一个变量
2. 通过句柄对文件进行操作
3. 关闭文件

基本操作：

f = open('lyrics') 　　# 打开文件
first_line = f.readline()
print('first line:',first_line) 　　# 读一行
print('我是分隔线'.center(50,'-'))
data = f.read()　　  # 读取剩下的所有内容,文件大时不要用
print(data) 　　　　  # 打印文件
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

Python文件指针：

seek():移动文件读取指针到指定位置，设置文件当前位置。

tell():返回文件读取指针的位置。

seek()的三种模式：

（1）f.seek(p,0)  移动当文件第p个字节处，绝对位置

（2）f.seek(p,1)  移动到相对于当前位置之后的p个字节

（3）f.seek(p,2)  移动到相对文章尾之后的p个字节

with语句

为了避免打开文件后忘记关闭，可以通过管理上下文，即：

with open('log','r') as f:　　　　　　# 如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源。
    ...

在Python 2.7 后，with又支持同时对多个文件的上下文进行管理，即：

with open('log1') as obj1, open('log2') as obj2:
    pass

文件操作常用方法:

1	file.close()   关闭文件。关闭后文件不能再进行读写操作。
2	file.flush()    刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
3	file.fileno()    返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
4	file.isatty()   如果文件连接到一个终端设备返回 True，否则返回 False。
5	file.next()    返回文件下一行。
6	file.read([size])   从文件读取指定的字节数，如果未给定或为负则读取所有。
7	file.readline([size])    读取整行，包括 "\n" 字符。
8	file.readlines([sizeint])    读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
9	file.seek(offset[, whence])    设置文件当前位置
10	file.tell()    返回文件当前位置。
11	file.truncate([size])   截取文件，截取的字节通过size指定，默认为当前文件位置。
12	file.write(str)   将字符串写入文件，没有返回值。
13	file.writelines(sequence)  向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

注: http://www.runoob.com/python3/python3-file-methods.html

7. 字符编码与解码

详细文章:

• http://www.cnblogs.com/yuanchenqi/articles/5956943.html
• http://www.diveintopython3.net/strings.html

需知:
 
1.在python2默认编码是ASCII, python3里默认是unicode
 
2.unicode 分为 utf-32(占4个字节),utf-16(占两个字节)，utf-8(占1-4个字节)， so utf-16就是现在最常用的unicode版本， 不过在文件里存的还是utf-8，因为utf8省空间
 
3.在py3中encode,在转码的同时还会把string 变成bytes类型，decode在解码的同时还会把bytes变回string

下图仅适用与py2.x

示例1：

#-*-coding:utf-8-*-
__author__ = 'shuke'
 
import sys
print(sys.getdefaultencoding())
 
msg = "我爱北京天安门"
msg_gb2312 = msg.decode("utf-8").encode("gb2312")
gb2312_to_gbk = msg_gb2312.decode("gbk").encode("gbk")
 
print(msg)
print(msg_gb2312)
print(gb2312_to_gbk)

python2.x

import sys
print(sys.getdefaultencoding())
 
msg = "我爱北京天安门"
#msg_gb2312 = msg.decode("utf-8").encode("gb2312")
msg_gb2312 = msg.encode("gb2312") #默认就是unicode,不用再decode,喜大普奔
gb2312_to_unicode = msg_gb2312.decode("gb2312")
gb2312_to_utf8 = msg_gb2312.decode("gb2312").encode("utf-8")
 
print(msg)
print(msg_gb2312)
print(gb2312_to_unicode)
print(gb2312_to_utf8)

python3.x