python支持的数据类型
int
整数型
float
浮点型
complex
复数，实数+虚数，虚数部分以“j”或“J”结尾，a+bj或者complex(a,b)
字符串
python不支持字符类型，所有字符都以字符串的形式存在，'a'或者"abc"
布尔类型
True和False，运算and(与)、or(或)、not(非)。False以0、0.0、空字符串‘’或“”、None、空集合，包括空元组()、空序列[]、空字典{}。其他的都是True
None
空值，不支持任何运算，也没有任何内置函数方法。和其他数据类型相比永远返回False。未指定返回值的函数会自动返回None
变量(variable)命名规则：
以_、数字、字母组成，不能是特殊符，包括空格也不行。
不能以数字开头，保留字符(命令字符)不能使用，不能以中文为变量名(python 3.x支持，但没有公司允许)。
不能以大写开头，变量名首个单词小写，后面的单词可首字母大写(注：变量对应的常量，例如pie=3.151592653……，python不区分常量和变量，程序员为了区分常量和变量，python中常量和变量，所以常量用全部大写的变量名来定义常量)。
单行注释用#，多行注释用3个'或者3个"括起来
字符串和字节
python2中用str表示字节字符串，默认保存ASII码。这种类型在Python3中用bytes对象来处理，明确区分字符串与字节。python3中只有一种能够保存文本信息的数据类型，就是str，它是不可变序列，保存的是Unicode码位
在python2中，Unicode需要有前缀(例如u"some string")。从python3.3开始，为保证向后兼容，仍然支持这个前缀，但它在python3中没有任何语法上的意义。字节的明确语法：字节也被单引号，双引号或三引号包围，但必须有一个b或B前缀。
字符串常用方法
python里创建一个字符串可用单引号' '或者双引号" " 特性：不可修改
s = 'a'str= "my name is luxi and I am 20"
1.输出字符串：
#逐个输出字符串str
str = "abcdefg"
for i inrange(0,len(str)):print(str[i])
a
b
c
d
e
f
g
range()函数原型：range(start， end， scan):
参数含义：
start:计数从start开始。默认是从0开始。例如range(3)等价于range(0， 3);
end:计数到end结束，但不包括end.例如：range(0， 5) 是[0, 1, 2, 3, 4]没有5
scan：每次跳跃的间距，默认为1。例如：range(0， 5) 等价于 range(0, 5, 1)
name = "my name is luxi and I am 20"
print(name)
name1= "my name is %s and I am %d"
print(name1 % ("luxi",20))
name2= "my name is {name} and I am {age}"
print(name2.format(name="luxi",age=20))
name3= "my name is {0} and I am {1}"
print(name3.format("luxi",20))#这四种方式输出的结果都是
my name is luxi and I am 20
%s 字符串，%d 整数，%f 浮点数
format()是python2.6新增的一个格式化字符串的方法，功能非常强大，有可能在未来完全替代%格式化方法,相比 % ，format()的优点有：
1.格式化时不必关心数据类型的问题，format()会自动转换
2. 单个参数可以多次输出，参数顺序可以不同
3. 填充方式灵活，对齐方式强大
2.字符串常用方法
s = 'a'str= "my name is luxi and I am 20"
str.capitalize()#首字母大写
My nameis luxi and i am 20
str.count('a')#统计 a 的个数，应该就是3个了
3
str.center(50, "-")# 字符串居中，一共打印50个字符，不够"-"来凑
------------my name is luxi and I am 20-----------
str.endswith("wll")#判断字符串是不是以"wll"结尾，返回真假
False
str = "my \tname is luxi and I am 20"str.expandtabs(tabsize=30)#在\t处打印30个空格，Python expandtabs() 方法把字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是 8。my nameis luxi and I am 20
str.find("y")#索引，找到第一个y的位置，从0开始
1
#str.find()方法只能找到第一个位置，如果要找所有的
str = "my name is luxi and I am 20"
print(str.find('m'))print("---------------------")
count=0for i inrange(len(str)):if 'm' ==str[i]:
count= count + 1
print("m在第",i,"个")print("m的总个数为", count)
0---------------------m在第 0 个
m在第5个
m在第23个
m的总个数为3
str[str.find("name"):]#切片，从"name"开始一直到最后打印，切片在列表会说到
nameis luxi and I am 20
str = "my name is {name} and I am {age} years old"str.format(name='luxi', age=20)
my nameis luxi and I am 20years old
str.format_map({'name': 'luxi', 'age': 22})#.format的字典用法
my nameis luxi and I am 20 years old
str.isalnum()#判断是不是阿拉伯数字(英文字符+1~9),特殊字符不行，这里有空格
False'abc123'.isalnum()#abc123只有英文字符abc和123，这就可以
True
str.isalpha()#判断是不是纯英文字符，显然不是
False'abA'.isalpha()#这就是了
True
'a1'.isidentifier()#判断是不是一个合法的标识符(变量名)，什么是合法的标识符，由字母和数字、下划线组成，开头不能是数字
True
str.islower()#判断是不是小写
False
str.isupper()#有小写就有大写，判断是不是大写
False
str.isnumeric()#判断是不是数字(只有数字，有小数点不行)
False
str.istitle()#判断每个首字母是不是大写
False'My Name'.istitle()#这显然就是了嘛
True
' '.isspace())#判断是不是空格
True
'+'.join(['1', '2', '3'])#连成字符串
1+2+3
str.ljust(50, '*')#一共打印50个字符，不够*来凑(在右边)
my nameis luxi and I am 20***********************name.rjust(50, '*')#有在右边的就有在左边的，一共打印50个字符，不够*来凑(在左边)
***********************my name is luxi and I am 20
str.lower()#把字符串大写改成小写
my nameis luxi and i am 20str.upper()#把字符串小写改成大写
MY NAME IS LUXI AND I AM20
str.replace('a', 'A')#替换，把a换成A
my nAmeis luxi And I Am 20str.replace('a', 'A', 1)#替换，把a换成A，后面有个1，意思只换一个
my nAmeis luxi and I am 20
str.rfind('a')#找到最右边的a的下标
22
name.split()#把字符串按空格分成列表
['my', 'name', 'is', 'luxi', 'and', 'I', 'am', '20']
'1+2+3+4'.split('+')#把字符串按+分成列表
['1', '2', '3', '4']
'1+2\n+3+4'.splitlines()#把字符串按换行分成列表
['1+2', '+3+4']
str.swapcase()#把字符串小写变大写，大写变小写
MY NAME IS LUXI AND i AM20
str.title()#把字符串每个首字母变大写
My Name Is Luxi And I Am20
str.zfill(50)#打印50个字符，不够用0填充
00000000000000000000000my nameis luxi and I am 20
补充一个小点，和字符串无关，三元组：三元运算，如果条件(a > b)为真则 d 值为a,否则 d 值为c
a = 1b= 2c= 3d= a if a > b elsecprint(d)3
元组
元组是有序的，只有index和count两种方法，切记元组不可更改
names = ('张三', '李四', '王五', '赵六', '许二', '李四')
print(names.index('张三')) #找'张三'在元组中的第几个，从0开始
0
print(names.count('李四')) #计数，'李四'在元组中有几个
2
print(names) #输出元组
print(names[0]) #输出元组的第一个元组，下标从0开始
('张三', '李四', '王五', '赵六', '许二', '李四')
张三
#逐个输出元组中的每个元素
for i innames:print(i)print("------------------")for i inrange(len(names)):print(names[i])
张三
李四
王五
赵六
许二
李四------------------张三
李四
王五
赵六
许二
李四
列表
列表也是有序的。
names = ['张三', '李四', '王五', '赵六', '许二', '李四']
names.append("WR") #插在最后一个
print(names)
names.insert(1, "YT") #插在第二个的位置上
print(names)
['张三', '李四', '王五', '赵六', '许二', '李四', 'WR']
['张三', 'YT', '李四', '王五', '赵六', '许二', '李四', 'WR']
1.del根据索引删除列表元素del list[1]；2.remove()方法直接删除列表里的元素list.remove('张三')或者list.remove(2019)；3.pop()方法删除列表指定位置的元素，无参数时删除最后一个元素list.pop(2)或者list.pop()
names.remove("李四") #如果有多个，只删除一个
print(names)del names[2] #删除列表中第三个元素，下标是2，从零开始
print(names)
names.pop()#默认不输入下标，则删除最后一个值
print(names)
['张三', '王五', '赵六', '许二', '李四']
['张三', '王五', '许二', '李四']
['张三', '王五', '许二']
names[2] = "Jxx" #把第三个元素改为‘Jiangxiaoxia’
print(names)
['张三', '李四', 'Jxx', '赵六', '许二', '李四']
print(names)print(names[0]) #切片,输出第一个元素
print(names[1:3]) #切片,左闭右开，输出从第二个到第三个
print(names[3]) #切片，输出第四个元素
print(names[-1]) #切片,-1表示最后一个元素
print(names[-3:-1]) #切片,从左往右数，不能从右往左数
print(names[-3:]) #切片,数到最后一个，冒号后面忽略
print(names[:3]) #切片,第一个开始数，冒号前面可以忽略，相当于[0:3]
print(names[0:-1:2]) #切片，从0开始到最后一个，步长为2
print(names[::2]) #切片，从0开始到最后一个，步长为2
print(names[:]) #切片，从0开始到最后一个，默认步长为1
#输出
['张三', '李四', '王五', '赵六', '许二', '李四']
张三
['李四', '王五']
赵六
李四
['赵六', '许二']
['赵六', '许二', '李四']
['张三', '李四', '王五']
['张三', '王五', '许二']
['张三', '王五', '许二']
['张三', '李四', '王五', '赵六', '许二', '李四']
其他方法
print(names.index("王五")) #索引，获取下标
print(names[names.index("许二")]) #许二是4，输出列表里4的元素，还是许二
2许二
print(names.count("李四")) ##计数，列表里李四的个数
2
names.clear() #清除
print(names)
[]
names.reverse() #反转
print(names)#输出
['李四', '许二', '赵六', '王五', '李四', '张三']
names.sort() #排序，按照ASCII码排序
print(names)#输出
['张三', '李四', '李四', '王五', '许二', '赵六']
names2 = [1, 2, 3, 4]
names.extend(names2)#合并
print(names)#输出
['张三', '李四', '王五', '赵六', '许二', '李四', 1, 2, 3, 4]
#循环输出列表
for i innames:print(i)#输出
张三
李四
王五
赵六
许二
李四
importcopy
names= ["张三", "李四", ["三子", "王五"], "赵六", "许二", "李四"]
names2= copy.deepcopy(names) #深copy，指向同一块地址
print(names)print(names2)
names[3] = "沈阳"names[2][0] = "Ran"
print(names)#输出
['张三', '李四', ['三子', '王五'], '赵六', '许二', '李四']
['张三', '李四', ['三子', '王五'], '赵六', '许二', '李四']
['张三', '李四', ['Ran', '王五'], '沈阳', '许二', '李四']
字典
字典 key-value
字典的特性：
dict是无序的
key必须是唯一的,so 天生去重
info = {"29": "张三","18": "李四","27": "王五","16": "赵六"}
1.输出字典里的元素
for i in info: #建议用这种
print(i, info[i])print("-"*20)for k, v in info.items(): #不建议用这种，数据量大的话很崩溃
print(k, v)#输出
29张三18李四27王五16赵六--------------------
29张三
18李四
27王五
16赵六
print(sorted(info.items(), key=lambda d: d[0], reverse=True)) #根据key的值倒序输出字典里的元素
#输出
[('29', '张三'), ('27', '王五'), ('18', '李四'), ('16', '赵六')]
print(info.items()) #把字典转成列表
info_3 = dict.fromkeys([1, 2, 3], [1, {"name": "wll"}, 111]) #也是一种创建字典
print(info_3)
info_3[2][1]["name"] = "bbb" #你以为只改了一个，其实都改了
print(info_3)#输出
dict_items([('29', '张三'), ('18', '李四'), ('27', '王五'), ('16', '赵六')])
{1: [1, {'name': 'wll'}, 111], 2: [1, {'name': 'wll'}, 111], 3: [1, {'name': 'wll'}, 111]}
{1: [1, {'name': 'bbb'}, 111], 2: [1, {'name': 'bbb'}, 111], 3: [1, {'name': 'bbb'}, 111]}
2.改
info_2 = {"01": "新鑫","02": "文文"}
info["29"] = "许二"
print(info)
info.update(info_2)#有的更新，没有的创建
print(info)#输出
{'29': '许二', '18': '李四', '27': '王五', '16': '赵六'}
{'29': '许二', '18': '李四', '27': '王五', '16': '赵六', '01': '新鑫', '02': '文文'}
3.增
info["20"] = "王宇"
print(info)#输出
{'29': '张三', '18': '李四', '27': '王五', '16': '赵六', '20': '王宇'}
4.删
info.pop("29") #标准删
print(info)del info["18"]print(info)
info.popitem()#随机删
print(info)#输出
{'18': '李四', '27': '王五', '16': '赵六'}
{'27': '王五', '16': '赵六'}
{'16': '赵六'}
5.查
print(info["29"]) #不建议用这种方法，除非很确定字典里有这个键值
print(info.get("29")) #一般用这种方法
print("29" in info) #info.has_key("29")
#输出
张三
张三
True
6.多层嵌套
1 list_move = {"电影": {2 "美国": ["恐怖游轮", "记忆碎片", "穆赫兰道"],3 "中国": ["唐人街探案", "杀破狼", "使徒行者"]4 }, "电视剧": {5 "美国": ["城堡岩", "神探夏洛克", "假面真情"],6 "中国": ["暗黑者", "武林外传", "无证之罪"]7 }, "动漫": {8 "日本": ["名侦探柯南", "进击的巨人", "灌篮高手"],9 "中国": ["画江湖系列", "狐妖小红娘", "全职高手"]10}11}12 list_move["动漫"]["中国"][1] = "斗破苍穹"
13 print(list_move)14
15 list_move.setdefault("小说", {"中国": [1,2]}) #在字典里找"小说"，如果能取到，返回，如果取不到，就创建一个新的key,value值为逗号后面的
16 print(list_move)17
18 #输出
19 {'电影': {'美国': ['恐怖游轮', '记忆碎片', '穆赫兰道'], '中国': ['唐人街探案', '杀破狼', '使徒行者']}, '电视剧': {'美国': ['城堡岩', '神探夏洛克', '假面真情'], '中国': ['暗黑者', '武林外传', '无证之罪']}, '动漫': {'日本': ['名侦探柯南', '进击的巨人', '灌篮高手'], '中国': ['画江湖系列', '斗破苍穹', '全职高手']}}20 {'电影': {'美国': ['恐怖游轮', '记忆碎片', '穆赫兰道'], '中国': ['唐人街探案', '杀破狼', '使徒行者']}, '电视剧': {'美国': ['城堡岩', '神探夏洛克', '假面真情'], '中国': ['暗黑者', '武林外传', '无证之罪']}, '动漫': {'日本': ['名侦探柯南', '进击的巨人', '灌篮高手'], '中国': ['画江湖系列', '斗破苍穹', '全职高手']}, '小说': {'中国': [1, 2]}}
7.其他方法
#values 取值
info.values()
dict_values(['张三', '李四', '王五', '赵六'])#keys 取键
info.keys()
dict_keys(['29', '18', '27', '16'])#setdefault 取出一个已有键的值(直接返回结果)，取出一个不存在的键的值(返回默认键的值，并且将新的键值保存在字典中)
info.setdefault("26","Alex") #返回"Alex"
info.setdefault("29","许二") #返回"张三"
#update 更新数据，对已有的键更改值，没有的直接添加
b = {1: 2, 3: 4, "18": "许二"}
info.update(b)#info{'29': '张三', '18': '许二', '27': '王五', '16': '赵六', 1: 2, 3: 4}
#items 以列表返回可遍历的(键, 值) 元组数组
dict_items = info.items() #dict_items([('29', '张三'), ('18', '许二'), ('27', '王五'), ('16', '赵六'), (1, 2), (3, 4)])
#通过一个列表生成默认dict,有个没办法解释的坑，少用吧这个
dict_items = dict.fromkeys([1,2,3],'testd') #会全部更改dict_items{1: 'testd', 2: 'testd', 3: 'testd'}
集合
集合是无序的，自动去重
可变集合(set)：可添加和删除元素，非可哈希的，不能用作字典的键，也不能做其他集合的元素
不可变集合(frozenset)：与上面恰恰相反
只能通过方法set()和frozenset()创建集合
s1 = set('abc')
s2= frozenset('bcd')
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中添加多项
t.remove('H') #使用remove()可以删除一项：
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”的一个浅复制
list_1 = [1, 1, 2, 3, 4, 5, 6, 8, 2, 5]
list_1=set(list_1)
list_2= set([3, 22, 3, 5, 10, 12])print(list_1, type(list_1), list_2) #打印集合1,1的类型，集合2
#输出
{1, 2, 3, 4, 5, 6, 8} {3, 5, 10, 12, 22}#list_1的类型是set，集合，集合是自动去重的
print(list_1.intersection(list_2)) #交集
#输出
{3, 5}
print(list_1 & list_2) #交集
#输出
{3, 5}
print(list_1.union(list_2)) #并集
#输出
{1, 2, 3, 4, 5, 6, 8, 10, 12, 22}
print(list_1 | list_2) #并集
#输出
{1, 2, 3, 4, 5, 6, 8, 10, 12, 22}
print(list_1.difference(list_2)) #差集，在1里面不在2里面
print(list_2.difference(list_1)) #差集，在2里面不在1里面
#输出
{1, 2, 4, 6, 8}
{10, 12, 22}
print(list_1 - list_2) #差集,在1里不在2里
print(list_2 - list_1) #差集,在2里不在1里
#输出
{1, 2, 4, 6, 8}
{10, 12, 22}
print(list_1.symmetric_difference(list_2)) #对称差集，去掉1和2的交集之后再合并
#输出
{1, 2, 4, 6, 8, 10, 12, 22}
print(list_1 ^ list_2) #对称差集，去掉1和2的交集之后再并
#输出
{1, 2, 4, 6, 8, 10, 12, 22}
list_3 = set([1, 2, 3])print(list_3.issubset(list_1)) #3是不是1的子集，是则返回True,否则返回False
print(list_1.issuperset(list_3)) #1是不是3的父子集，即3是不是1的子集
#输出
True
True
其他方法
list_3 = set([1, 2, 3])
list_4= set([4, 5, 6])print(list_3.isdisjoint(list_4)) #3和4没有交集返回为True,有交集返回为False
#输出
True
list_1.add(66) #添加元素
print(list_1)#输出
{1, 2, 3, 4, 5, 6, 66, 8}#集合是无序的，随机添加位置
list_1.update([88, 2333]) #添加多个元素
print(list_1)#输出
{1, 2, 3, 4, 5, 6, 66, 8, 88, 2333}
list_1.remove(1) #删除,直接删除元素值
print(list_1)#输出
{2, 3, 4, 5, 6, 8}
print(len(list_1)) #长度
#输出
7
print(1 in list_1) #1在集合里吗
print(1 not in list_1) #1不在集合里吗
#输出
True
False
list_5 = list_1.copy() #浅复制
print(list_5)#输出
{1, 2, 3, 4, 5, 6, 8}
print(list_1.pop(), list_1) #删除任一一个元素，并且将那个元素返回
#输出
1 {2, 3, 4, 5, 6, 8}
print(list_1.discard(6666), list_1) #删除，remove删除不存在的元素会报错，discard只返回None
#输出
None {2, 3, 4, 5, 6, 8}
文件
对文件操作流程
打开文件，得到文件句柄并赋值给一个变量
通过句柄对文件进行操作
关闭文件
1.打开文件
f = open("文件名", '读写打开模式', encoding="编码形式")
打开文件的模式有：
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
有open就有close，不管是读文件还是写文件，最后一定要关闭文件，f.close()
2.基本操作
f = open('lyrics') #打开文件
first_line =f.readline()print('first line:',first_line) #读一行
print('我是分隔线'.center(50,'-'))
data= f.read() #读取剩下的所有内容,文件大时不要用
print(data) #打印文件
f.close()#关闭文件
f = open("helloworld2", 'r', encoding="utf-8")
s=f.read().strip()print(s)
f = open("helloworld2", 'r', encoding="utf-8")
info=f.readlines()for i ininfo:print(i.strip())
f.close()
f = open("helloworld2", 'r', encoding="utf-8")for i in range(3):print(f.readline().strip())
f = open("helloworld2", 'r', encoding="utf-8")for index, line inenumerate(f.readlines()):if index == 3: #第三行上下分割
print("---------------------")continue
print(line.strip())
#高效的循环方法
f = open("helloworld2", 'r', encoding="utf-8")
count=0for line inf:if count == 3:print("---------------------")
count+= 1
continue
print(line.strip())
count+= 1
# 声明：s为字符串，rm为要删除的字符序列
s.strip(rm) 删除s字符串中开头、结尾处，位于 rm删除序列的字符
s.lstrip(rm) 删除s字符串中开头处，位于 rm删除序列的字符
s.rstrip(rm) 删除s字符串中结尾处，位于 rm删除序列的字符
注意：
1. 当rm为空时，默认删除空白符(包括'\n', '\r', '\t', ' ')
2.这里的rm删除序列是只要边(开头或结尾)上的字符在删除序列内，就删除掉。
f = open("helloworld", "r", encoding="utf-8")
f_new= open("helloworld1.bak", "w", encoding="utf-8")for line inf:if "wll" inline:
line= line.replace("wll", "wulanlan")
f_new.write(line)
f.close()
f_new.close()#helloworld内容
Hello World
Python
wll
ly
jiang
syq
jxx#helloworld1.bak内容
Hello World
Python
wulanlan#将wll改成了wulanlan
ly
jiang
syq
jxx
with语句
为了避免打开文件后忘记关闭，可以通过管理上下文，
with open('log','r') as f:
...
当with代码块执行完毕时，内部会自动关闭并释放文件资源。
在Python 2.7 后，with又支持同时对多个文件的上下文进行管理，
with open('log1') as obj1, open('log2') as obj2:pass
3.其它方法
for line in f: print line：通过迭代器访问。
file.read([size])：size 未指定则返回整个文件，如果文件大小 >2 倍内存则有问题。
def close(self): #关闭的文件不能用于进一步的I/O操作。close()可以多次调用，没有错误。
def fileno(self, *args, **kwargs): #返回基础文件描述符(整数)
def isatty(self, *args, **kwargs): #如果文件连接到tty设备，则为true。
def read(self, size=-1): #通常读取字节大小，以字节形式返回.注意，不一定能全读回来#只进行一次系统调用，因此返回的数据可能比请求的少。#在非阻塞模式下，如果没有可用数据，则返回“无”。#返回EOF处的空字节对象。
return ""
def readable(self, *args, **kwargs): #如果文件以读取模式打开，则为true
def readall(self, *args, **kwargs): #从文件中读取以字节形式返回的所有数据。 # 在非阻塞模式下，返回立即可用的，如果没有可用数据，则为无。#返回EOF处的空字节对象。
def readinto(self): #与RawIOBase.readinto()相同。
#不要用,没人知道它是干嘛用的
def seek(self, *args, **kwargs): #移动到新文件位置并返回文件位置。#参数偏移量是字节计数。可选参数，默认值为#eek_set或0(从文件开始的偏移量，偏移量应大于等于0)；#seek_cur”或“1”(相对于当前位置移动，正或负)#seek_end或“2”(相对于文件结尾移动，通常为负，尽管许多平台允许在文件结尾以外进行查找)。#请注意，并非所有文件对象都是可查找的。
def seekable(self, *args, **kwargs): #如果文件支持随机访问，则为true。
def tell(self, *args, **kwargs): #当前文件位置。无法为不可查找的文件引发OSError。
def truncate(self, *args, **kwargs): #将文件截断到最大大小字节，并返回截断的大小。#大小默认为当前文件位置，由tell()返回。#当前文件位置更改为大小值。
def writable(self, *args, **kwargs): #如果文件以写模式打开，则为true。
def write(self, *args, **kwargs): #将字节写入文件，返回写入的数字。#只进行一次系统调用，因此并非所有数据都可以写入。#返回实际写入的字节数。在非阻塞模式下，如果写入将阻塞，则返回“无”。
字符编码和转码
需知:
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
#-*-coding:gb2312 -*- #这个也可以去掉
__author__ = 'Alex Li'
importsysprint(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)
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
