Python之路【第二篇】: 列表、元组、字符串、字典、集合
本文内容:
--------------------------------------
- 列表、元组操作
- 字符串操作
- 字典操作
- 集合操作
- 文件操作
- 字符编码与转码
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']
-
插入
描述
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', '我是新来的']
-
修改
语法
通过索引找到列表中的元素,并修改,使用=等号赋予新值
>>> 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']
-
拷贝
>>> names ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3] >>> name_copy = names.copy() >>> name_copy ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]
-
统计
>>> names ['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3] >>> names.count("Amy") 2
-
排序和翻转
描述
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']
-
获取下标
描述
index() 函数用于从列表中找出某个值第一个匹配项的索引位置。
语法
index()方法语法:
list.index(obj) #obj -- 查找的对象。
>>> names ['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '3', '2', '1'] >>> names.index("Amy") 2 #只返回找到的第一个下标
-
列表扩展
描述
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]
列表小结
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":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"] }, "大陆":{ "1024":["全部免费,真好,好人一生平安","服务器在国外,慢"] } } av_catalog["大陆"]["1024"][1] += ",可以用爬虫爬下来" print(av_catalog["大陆"]["1024"]) #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
字典内置函数&方法
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”的一个浅复制
参考: http://www.cnblogs.com/morninggood/articles/6829808.html
6. 文件操作(file)
对文件操作流程
- 打开文件,得到文件句柄并赋值给一个变量
- 通过句柄对文件进行操作
- 关闭文件
基本操作:
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. 字符编码与解码
详细文章:
需知: 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)
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)