python支持的数据类型
变量（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 in range(0,len(str)): print(str[i]) abc d e fg
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 name is 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 name is 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 in range(len(str)):if 'm' == str[i]:count = count + 1print("m在第",i,"个")print("m的总个数为", count)0---------------------m在第 0 个m在第 5 个m在第 23 个m的总个数为 3
str[str.find("name"):] # 切片，从"name"开始一直到最后打印，切片在列表会说到name is luxi and I am 20
str = "my name is {name} and I am {age} years old"str.format(name='luxi', age=20)my name is luxi and I am 20 years oldstr.format_map({'name': 'luxi', 'age': 22}) # .format的字典用法my name is 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()#判断是不是小写Falsestr.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 name is luxi and I am 20***********************name.rjust(50, '*') # 有在右边的就有在左边的，一共打印50个字符，不够*来凑(在左边)***********************my name is luxi and I am 20
str.lower() # 把字符串大写改成小写my name is luxi and i am 20str.upper() # 把字符串小写改成大写MY NAME IS LUXI AND I AM 20
str.replace('a', 'A') # 替换，把a换成Amy nAme is luxi And I Am 20str.replace('a', 'A', 1) # 替换，把a换成A，后面有个1，意思只换一个my nAme is 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 AM 20
str.title() # 把字符串每个首字母变大写My Name Is Luxi And I Am 20
str.zfill(50) # 打印50个字符，不够用0填充00000000000000000000000my name is luxi and I am 20
补充一个小点，和字符串无关，三元组：三元运算，如果条件（a > b）为真则 d 值为a,否则 d 值为c
a = 1b = 2c = 3d = a if a > b else cprint(d)3
元组
元组是有序的，只有index和count两种方法，切记元组不可更改
names = ('张三', '李四', '王五', '赵六', '许二', '李四')
print(names.index('张三')) # 找'张三'在元组中的第几个，从0开始0
print(names.count('李四')) # 计数，'李四'在元组中有几个2
print(names) # 输出元组print(names[0]) # 输出元组的第一个元组，下标从0开始('张三', '李四', '王五', '赵六', '许二', '李四')张三
# 逐个输出元组中的每个元素for i in names:print(i)print("------------------")for i in range(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()；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开始到最后一个，步长为2print(names[::2]) # 切片，从0开始到最后一个，步长为2print(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 in names:print(i)#输出张三李四王五赵六许二李四
import copynames = ["张三", "李四", ["三子", "王五"], "赵六", "许二", "李四"]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} <class 'set'> {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,否则返回Falseprint(list_1.issuperset(list_3)) # 1是不是3的父子集，即3是不是1的子集# 输出TrueTrue
其他方法
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不在集合里吗# 输出TrueFalse
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+ 模式同使用）
rUr+U
"b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）
rbwbab
有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 in info: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 in enumerate(f.readlines()):if index == 3: # 第三行上下分割print("---------------------")continueprint(line.strip())
# 高效的循环方法f = open("helloworld2", 'r', encoding="utf-8")count = 0for line in f:if count == 3:print("---------------------")count += 1continueprint(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 in f:if "wll" in line:line = line.replace("wll", "wulanlan")f_new.write(line)f.close()f_new.close()#helloworld内容Hello WorldPythonwlllyjiangsyqjxx#helloworld1.bak内容Hello WorldPythonwulanlan #将wll改成了wulanlanlyjiangsyqjxx
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): # 如果文件以读取模式打开，则为truedef 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'import sysprint(sys.getdefaultencoding())msg = "我爱北京天安门"#msg_gb2312 = msg.decode("utf-8").encode("gb2312")msg_gb2312 = msg.encode("gb2312") #默认就是unicode,不用再decodegb2312_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)
