您的位置:首页 > 编程语言 > Python开发

*Python基础(3)-数据类型操作、Python字符编码详解

2017-05-30 23:50 851 查看

一、数据类型操作

1、String(字符串)

特性:不可修改 

1、去除字符串前后的空格以及换行符

通过strip(),lstrip(),rstrip()方法去除字符串的空格

S.strip()去掉字符串的左右空格

S.lstrip()去掉字符串的左边空格

S.rstrip()去掉字符串的右边空格

2、切分字符串

字符串分割,可以用split,rsplit方法,通过相应的规则来切割成生成列表对象

info = 'name:haha,age:20$name:python,age:30$name:fef,age:55'
content = info.split('$')
print content


3、字符串连接

方法1: 用字符串的join方法

a = ['a','b','c','d']
content = ''
content = ''.join(a)
print content


方法2: 用字符串的替换占位符替换

a = ['a','b','c','d']
content = ''
content = '%s%s%s%s' % tuple(a)
print content


4、字符串截取

python的字串列表有2种取值顺序

①从左到右索引默认0开始的,最大范围是字符串长度少1

s = ‘ilovepython’

s[0]的结果是i

②从右到左索引默认-1开始的,最大范围是字符串开头

s = ‘ilovepython’

s[-1]的结果是n

5、字符串替换

①字符串本身的replace方法

a = 'hello word'
b = a.replace('word','python')
print b


②正则表达式来完成替换

import re
a = 'hello word'
strinfo = re.compile('word')
b = strinfo.sub('python',a)
print b


6、字符串查找

①find()

info = 'abca'
print info.find('a')##从下标0开始,查找在字符串里第一个出现的子串,返回结果:0

info = 'abca'
print info.find('a',1)##从下标1开始,查找在字符串里第一个出现的子串:返回结果3

info = 'abca'
print info.find('333')##返回-1,查找不到返回-1


②index()方法

python 的index方法是在字符串里查找子串第一次出现的位置,类似字符串的find方法,不过比find方法更好的是,如果查找不到子串,会抛出异常,而不是返回-1

info = 'abca'
print info.index('a')
print info.index('33')


*7、字符串翻转

通过步进反转[::-1]

a = 'abcd'
b = a[::-1]##[::-1]通过步进反转
print b


8、字符串编码

通过字符串的decode和encode方法

encode([encoding,[errors]])其中encoding可以有多种值,比如gb2312 gbk gb18030 bz2 zlib big5 bzse64等都支持。errors默认值为”strict”,意思是UnicodeError。可能的值还有’ignore’, ‘replace’, ‘xmlcharrefreplace’, ‘backslashreplace’ 和所有的通过codecs.register_error注册的值。

S.decode([encoding,[errors]]) 下面是字符串编码应用:

a = '你好'
b = 'python'
print a.decode('utf-8').encode('gbk')##decode方法把字符串转换为unicode对象,然后通过encode方法转换为指定的编码字符串对象
print b.decode('utf-8')##decode方法把字符串转换为unicode对象


9、字符串追加和拼接

通过字符串的占位符来进行字符串的拼接

#1 元组拼接
m = 'python'
astr = 'i love %s' % m
print astr

#2 字符串的format方法
#①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'

#3 字典格式化字符串
m = 'python'
astr = "i love %(python)s " % {'python':m}
print astr


10、字符串长度

通过内置方法len()来计算字符串的长度,注意这个计算的是字符的长度。

aa = 'afebb'
bb = '你'
print len(aa)
print len(bb)


11、字符串对照表翻译

#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!!!'


12、字符串大小写

通过下面的upper(),lower()等方法来转换大小写

S.upper()#S中的字母大写

S.lower() #S中的字母小写

S.capitalize() #首字母大写

S.istitle() #S是否是首字母大写的

S.isupper() #S中的字母是否便是大写

S.islower() #S中的字母是否全是小写

13、字符串其他方法

S.center(width, [fillchar]) #中间对齐

S.count(substr, [start, [end]]) #计算substr在S中出现的次数

S.expandtabs([tabsize]) #把S中的tab字符替换没空格,每个tab替换为tabsize个空格,默认是8个

S.isdigit() #是否整数

S.isalnum() #是否全是字母和数字,并至少有一个字符

S.isalpha() #是否全是字母,并至少有一个字符

S.isspace() #是否全是空白字符,并至少有一个字符

S.join()#S中的join,把列表生成一个字符串对象

S.ljust(width,[fillchar]) #输出width个字符,S左对齐,不足部分用fillchar填充,默认的为空格。

S.rjust(width,[fillchar]) #右对齐

S.splitlines([keepends]) #把S按照行分割符分为一个list,keepends是一个bool值,如果为真每行后而会保留行分割符。

S.swapcase() #大小写互换

S.isidentifier() #检测一段字符串可否被当作标志符,即是否符合变量命名规则

2、List、Tuple(列表、元组)

1、List(列表)

列表是我们最以后最常用的数据类型之一,通过列表可以对数据实现最方便的存储、修改等操作

1、通过下标访问列表中的元素,下标从0开始计数

>>> names[0]
'Alex'
>>> names[2]
'Eric'
>>> names[-1]
'Eric'
>>> names[-2] #还可以倒着取
'Tenglan'


2、切片:取多个元素  

>>> 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']


3、追加

>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy']
>>> names.append("我是新来的")
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']


4、插入

>>> 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', '我是新来的']


5、修改

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


6、删除

>>> 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']


7、扩展

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


***8、深浅拷贝

如果希望将列表复制一份,通过列表的内置方法copy就可以实现:

s = [[1,2],3,4]
s1 = s.copy()
print(s)
print(s1)


拷贝出的列表s1与原列表s完全一致。

[[1, 2], 3, 4]
[[1, 2], 3, 4]


对s1修改:

s = [[1,2],3,4]
s1 = s.copy()
s1[1] = 'oliver'
s1[0][1] = 'hello'
print('列表s:',s)
print('列表s1:',s1)


输出:把列表s1中的元素3修改为’oliver’后,原列表并未受影响。

  将s1中第一个元素[1,2]中的2修改为’hello’时,原列表中也跟着变了。

列表s: [[1, 'hello'], 3, 4]
列表s1: [[1, 'hello'], 'oliver', 4]


问题来了,通过copy方法拷贝列表s得到列表s1,修改s1中的元素后,s中的元素有的没变,有的跟着变了。为什么会出现这种现象?s与s1之间有什么联系呢?二者的内存空间是否完全独立?

如下图所示,使用列表内置的copy方法,是将新列表中的元素指向了与原列表相同的内存空间。但是,如果列表中嵌套了列表,拷贝后的列表中嵌套的列表元素指针,指向原列表中嵌套列表的整体地址,而不是指向嵌套列表中元素的内存地址。





由此可得,s1[0][1]修改后,s列表中的该元素指针指向的内存空间也会发生改变。

这便是列表的浅拷贝

如果希望拷贝后的列表拥有完全独立的内存空间,则需要一个新的方法深拷贝来实现:

import  copy
s = [[1,2],3,4]
s2 = copy.deepcopy(s)
s2[0][1] = 'abc'
print('列表s:',s)
print('列表s2:',s2)


使用copy.deepcopy()方法来拷贝列表,修改嵌套列表中的元素,原列表不受影响。

列表s: [[1, 2], 3, 4]
列表s2: [[1, 'abc'], 3, 4]


总结

1、浅拷贝只能拷贝最外层,修改内层则原列表和新列表都会变化。

2、深拷贝是指将原列表完全克隆一份新的。

9、统计

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


10、排序&翻转

>>> names
['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]
>>> names.sort() #排序
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unorderable types: int() < str()   #3.0里不同数据类型不能放在一起排序了,擦
>>> names[-3] = '1'
>>> names[-2] = '2'
>>> names[-1] = '3'
>>> names
['Alex', 'Amy', 'Amy', 'Tenglan', 'Tom', '1', '2', '3']
>>> names.sort()
>>> names
['1', '2', '3', 'Alex', 'Amy', 'Amy', 'Tenglan', 'Tom']

>>> names.reverse() #反转
>>> names
['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '3', '2', '1']


11、获取下标

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


1、Tuple(元组)

元组其实跟列表差不多,也是存一组数,只不是它一旦创建,便不能再修改,所以又叫只读列表

语法

names = ("alex","jack","eric")


它只有2个方法,一个是count,一个是index,完毕。

3、Dict(字典)

字典一种key - value 的数据类型,使用就像我们上学用的字典,通过笔划、字母来查对应页的详细内容。

字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。

语法:

info = {
'stu1101': "TengLan Wu",
'stu1102': "LongZe Luola",
'stu1103': "XiaoZe Maliya",
}


字典的特性:

dict是无序的

key必须是唯一的,所以天然去重

1、增加

>>> info["stu1104"] = "苍井空"
>>> info
{'stu1102': 'LongZe Luola', 'stu1104': '苍井空', 'stu1103': 'XiaoZe Maliya', 'stu1101': 'TengLan Wu'}


2、修改

>>> info['stu1101'] = "武藤兰"
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤兰'}


3、删除

>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤兰'}
>>> info.pop("stu1101") #标准删除姿势
'武藤兰'
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
>>> del info['stu1103'] #换个姿势删除
>>> info
{'stu1102': 'LongZe Luola'}
>>>
>>>
>>>
>>> info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'} #随机删除
>>> info.popitem()
('stu1102', 'LongZe Luola')
>>> info
{'stu1103': 'XiaoZe Maliya'}


4、查找

>>> info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
>>>
>>> "stu1102" in info #标准用法
True
>>> info.get("stu1102")  #获取
'LongZe Luola'
>>> info["stu1102"] #同上,但是看下面
'LongZe Luola'
>>> info["stu1105"]  #如果一个key不存在,就报错,get不会,不存在只返回None
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'stu1105'


5、多级字典嵌套及操作

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
['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']


6、其它方法

#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'}


7、循环dict

#方法1
for key in info:
print(key,info[key])

#方法2
for k,v in info.items(): #会先把dict转成list,数据里大时莫用
print(k,v)


4、Set(集合)

集合(set):把不同的元素组成一起形成集合,是python基本的数据类型。

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

去重,把一个列表变成集合,就自动去重了

关系测试,测试两组数据之前的交集、差集、并集等关系

集合对象是一组无序排列的可哈希的值:集合成员可以做字典的键

li=[[1,2],'a','b']
s =set(li) #TypeError: unhashable type: 'list'
print(s)


集合分类:可变集合、不可变集合

可变集合(set):可添加和删除元素,非可哈希的,不能用作字典的键,也不能做其他集合的元素

不可变集合(frozenset):与上面恰恰相反

1、创建

由于集合没有自己的语法格式,只能通过集合的工厂方法set()和frozenset()创建

s1 = set('alvin')
s2= frozenset('yuan')

print(s1,type(s1))  #{'l', 'v', 'i', 'a', 'n'} <class 'set'>
print(s2,type(s2))  #frozenset({'n', 'y', 'a', 'u'}) <class 'frozenset'>


2、访问

由于集合本身是无序的,所以不能为集合创建索引或切片操作,只能循环遍历或使用in、not in来访问或判断集合元素。

s1 = set('alvin')
print('a' in s1)
print('b' in s1)
#s1[1]  #TypeError: 'set' object does not support indexing

for i in s1:
print(i)
#
# True
# False
# v
# n
# l
# i
# a


3、更新

可使用以下内建方法来更新:

s.add()

s.update()

s.remove()

注意只有可变集合才能更新:

# s1 = frozenset('alvin')
# s1.add(0)  #AttributeError: 'frozenset' object has no attribute 'add'

s2=set('alvin')
s2.add('mm')
print(s2)  #{'mm', 'l', 'n', 'a', 'i', 'v'}

s2.update('HO')#添加多个元素
print(s2)  #{'mm', 'l', 'n', 'a', 'i', 'H', 'O', 'v'}

s2.remove('l')
print(s2)  #{'mm', 'n', 'a', 'i', 'H', 'O', 'v'}


4、集合类型操作符

①in ,not in

②集合等价与不等价(==, !=)

③子集、超集

s=set('alvinyuan')
s1=set('alvin')
print('v' in s)
print(s1<s)


④联合(|)

联合(union)操作与集合的or操作其实等价的,联合符号有个等价的方法,union()。

s1=set('alvin')
s2=set('yuan')
s3=s1|s2
print(s3)  #{'a', 'l', 'i', 'n', 'y', 'v', 'u'}
print(s1.union(s2)) #{'a', 'l', 'i', 'n', 'y', 'v', 'u'} 


⑤交集(&)

与集合and等价,交集符号的等价方法是intersection()

s1=set('alvin')
s2=set('yuan')
s3=s1&s2
print(s3)  #{'n', 'a'}
print(s1.intersection(s2)) #{'n', 'a'}


⑥差集(-)

等价方法是difference()

s1=set('alvin')
s2=set('yuan')
s3=s1-s2
print(s3)  #{'v', 'i', 'l'}
print(s1.difference(s2)) #{'v', 'i', 'l'}


⑦对称差集(^)

对称差分是集合的XOR(‘异或’),取得的元素属于s1,s2但不同时属于s1和s2.其等价方法symmetric_difference()

s1=set('alvin')
s2=set('yuan')
s3=s1^s2
print(s3)  #{'l', 'v', 'y', 'u', 'i'}
print(s1.symmetric_difference(s2)) #{'l', 'v', 'y', 'u', 'i'}


二、字符编码详解

1、什么是编码?

基本概念很简单。首先,我们从一段信息即消息说起,消息以人类可以理解、易懂的表示存在。我打算将这种表示称为“明文”(plain text)。对于说英语的人,纸张上打印的或屏幕上显示的英文单词都算作明文。

其次,我们需要能将明文表示的消息转成另外某种表示,我们还需要能将编码文本转回成明文。从明文到编码文本的转换称为“编码”,从编码文本又转回成明文则为“解码”。

编码问题是个大问题,如果不彻底解决,它就会像隐藏在丛林中的小蛇,时不时地咬你一口。那么到底什么是编码呢?

//ASCII

记住一句话:计算机中的所有数据,不论是文字、图片、视频、还是音频文件,本质上最终都是按照类似 01010101 的二进制存储的。

再说简单点,计算机只懂二进制数字!

所以,目的明确了:如何将我们能识别的符号唯一的与一组二进制数字对应上?于是美利坚的同志想到通过一个电平的高低状态来代指0或1,

八个电平做为一组就可以表示出256种不同状态,每种状态就唯一对应一个字符,比如A—>00010001,而英文只有26个字符,算上一些特殊字符和数字,128个状态也够用了;每个电平称为一个比特为,约定8个比特位构成一个字节,这样计算机就可以用127个不同字节来存储英语的文字了。这就是ASCII编码。

扩展ANSI编码:

刚才说了,最开始,一个字节有八位,但是最高位没用上,默认为0;后来为了计算机也可以表示拉丁文,就将最后一位也用上了,从128到255的字符集对应拉丁文啦。至此,一个字节就用满了!

//GB2312:

计算机漂洋过海来到中国后,问题来了,计算机不认识中文,当然也没法显示中文;而且一个字节所有状态都被占满了,万恶的帝国主义亡我之心不死啊!我党也是棒,自力更生,自己重写一张表,直接生猛地将扩展的第八位对应拉丁文全部删掉,规定一个小于127的字符的意义与原来相同,但两个大于127的字符连在一起时,就表示一个汉字,前面的一个字节(他称之为高字节)从0xA1用到0xF7,后面一个字节(低字节)从0xA1到0xFE,这样我们就可以组合出大约7000多个简体汉字了;这种汉字方案叫做“GB2312”。GB2312 是对 ASCII 的中文扩展。

//GBK 和 GB18030编码:

但是汉字太多了,GB2312也不够用,于是规定:只要第一个字节是大于127就固定表示这是一个汉字的开始,不管后面跟的是不是扩展字符集里的

内容。结果扩展之后的编码方案被称为 GBK 标准,GBK 包括了 GB2312 的所有内容,同时又增加了近20000个新的汉字(包括繁体字)和符号。

//UNICODE编码:

很多其它国家都搞出自己的编码标准,彼此间却相互不支持。这就带来了很多问题。于是,国际标谁化组织为了统一编码:提出了标准编码准则:UNICODE 。

UNICODE是用两个字节来表示为一个字符,它总共可以组合出65535不同的字符,这足以覆盖世界上所有符号(包括甲骨文)

//utf8:

unicode都一统天下了,为什么还要有一个utf8的编码呢? 大家想,对于英文世界的人们来讲,一个字节完全够了,比如要存储A,本来00010001就可以了,现在吃上了unicode的大锅饭,得用两个字节:00000000 00010001才行,浪费太严重!基于此,美利坚的科学家们提出了天才的想法:utf8.UTF-8(8-bit Unicode Transformation Format)是一种针对Unicode的可变长度字符编码,它可以使用1~4个字节表示一个符号,根据

不同的符号而变化字节长度,当字符在ASCII码的范围时,就用一个字节表示,所以是兼容ASCII编码的。

这样显著的好处是,虽然在我们内存中的数据都是unicode,但当数据要保存到磁盘或者用于网络传输时,直接使用unicode就远不如utf8省空间啦!

这也是为什么utf8是我们的推荐编码方式。

Unicode与utf8的关系:

一言以蔽之:Unicode是内存编码表示方案(是规范),而UTF是如何保存和传输Unicode的方案(是实现)这也是UTF与Unicode的区别。

2、py2的string编码

在py2中,有两种字符串类型:str类型和unicode类型;注意,这仅仅是两个名字,python定义的两个名字,关键是这两种数据类型在程序运行时存在内存地址的是什么?

#coding:utf8

s1='苑'

print type(s1) # <type 'str'>
print repr(s1) #'\xe8\x8b\x91

s2=u'苑'
print type(s2) # <type 'unicode'>
print repr(s2) # u'\u82d1'


内置函数repr可以帮我们在这里显示存储内容。原来,str和unicode分别存的是字节数据和unicode数据;那么两种数据之间是什么关心呢?如何转换呢?这里就涉及到编码(encode)和解码(decode)了

s1=u'苑'
print repr(s1) #u'\u82d1'

b=s1.encode('utf8')
print b
print type(b)  #<type 'str'>
print repr(b)  #'\xe8\x8b\x91'

s2='苑昊'
u=s2.decode('utf8')
print u        # 苑昊
print type(u)  # <type 'unicode'>
print repr(u)  # u'\u82d1\u660a'

#注意
u2=s2.decode('gbk')
print u2  #鑻戞槉

print len('苑昊') #6


无论是utf8还是gbk都只是一种编码规则,一种把unicode数据编码成字节数据的规则,所以utf8编码的字节一定要用utf8的规则解码,否则就会出现乱码或者报错的情况。



py2编码的特色:

#coding:utf8

print '苑昊' #  苑昊
print repr('苑昊')#'\xe8\x8b\x91\xe6\x98\x8a'

print (u"hello"+"yuan")

#print (u'苑昊'+'最帅')   #UnicodeDecodeError: 'ascii' codec can't decode byte 0xe6
# in position 0: ordinal not in range(128)


Python 2 悄悄掩盖掉了 byte 到 unicode 的转换,只要数据全部是 ASCII 的话,所有的转换都是正确的,一旦一个非 ASCII 字符偷偷进入你的程序,那么默认的解码将会失效,从而造成 UnicodeDecodeError 的错误。py2编码让程序在处理 ASCII 的时候更加简单。你复出的代价就是在处理非 ASCII 的时候将会失败。

3、py3的string编码

python3 renamed the unicode type to str ,the old str type has been replaced by bytes.

py3也有两种数据类型:str和bytes; str类型存unicode数据,bytse类型存bytes数据,与py2比只是换了一下名字而已。

import json

s='苑昊'
print(type(s))       #<class 'str'>
print(json.dumps(s)) #  "\u82d1\u660a"

b=s.encode('utf8')
print(type(b))      # <class 'bytes'>
print(b)            # b'\xe8\x8b\x91\xe6\x98\x8a'

u=b.decode('utf8')
print(type(u))       #<class 'str'>
print(u)             #苑昊
print(json.dumps(u)) #"\u82d1\u660a"

print(len('苑昊')) # 2




py3的编码哲学:

Python 3最重要的新特性大概要算是对文本和二进制数据作了更为清晰的区分,不再会对bytes字节串进行自动解码。文本总是Unicode,由str类型表示,二进制数据则由bytes类型表示。Python 3不会以任意隐式的方式混用str和bytes,正是这使得两者的区分特别清晰。你不能拼接字符串和字节包,也无法在字节包里搜索字符串(反之亦然),也不能将字符串传入参数为字节包的函数(反之亦然)。

#print('alvin'+u'yuan')#字节串和unicode连接 py2:alvinyuan
print(b'alvin'+'yuan')#字节串和unicode连接 py3:报错 can't concat bytes to str


注意:无论py2,还是py3,与明文直接对应的就是unicode数据,打印unicode数据就会显示相应的明文(包括英文和中文)

4、文件从磁盘到内存的编码

说到这,才来到我们的重点!

抛开执行执行程序,请问大家,文本编辑器大家都是用过吧,如果不懂是什么,那么word总用过吧,ok,当我们在word上编辑文字的时候,不管是中文还是英文,计算机都是不认识的,那么在保存之前数据是通过什么形式存在内存的呢?yes,就是unicode数据,为什么要存unicode数据,这是因为它的名字最屌:万国码!解释起来就是无论英文,中文,日文,拉丁文,世界上的任何字符它都有唯一编码对应,所以兼容性是最好的。

好,那当我们保存了存到磁盘上的数据又是什么呢?

答案是通过某种编码方式编码的bytes字节串。比如utf8---一种可变长编码,很好的节省了空间;当然还有历史产物的gbk编码等等。于是,在我们的文本编辑器软件都有默认的保存文件的编码方式,比如utf8,比如gbk。 当我们点击保存的时候,这些编辑软件已经”默默地”帮我们做了编码工作。

那当我们再打开这个文件时,软件又默默地给我们做了解码的工作,将数据再解码成unicode,然后就可以呈现明文给用户了!所以,unicode是离用户更近的数据,bytes是离计算机更近的数据。

说了这么多,和我们程序执行有什么关系呢?

先明确一个概念:py解释器本身就是一个软件,一个类似于文本编辑器一样的软件!

现在让我们一起还原一个py文件从创建到执行的编码过程:

打开pycharm,创建hello.py文件,写入

ret=1+1
s='苑昊'
print(s)


当我们保存的的时候,hello.py文件就以pycharm默认的编码方式保存到了磁盘;关闭文件后再打开,pycharm就再以默认的编码方式对该文件打开后读到的内容进行解码,转成unicode到内存我们就看到了我们的明文;

而如果我们点击运行按钮或者在命令行运行该文件时,py解释器这个软件就会被调用,打开文件,然后解码存在磁盘上的bytes数据成unicode数据,这个过程和编辑器是一样的,不同的是解释器会再将这些unicode数据翻译成C代码再转成二进制的数据流,最后通过控制操作系统调用cpu来执行这些二进制数据,整个过程才算结束。

那么问题来了,我们的文本编辑器有自己默认的编码解码方式,我们的解释器有吗?

当然有啦,py2默认ASCII码,py3默认的utf8,可以通过如下方式查询

import sys
print(sys.getdefaultencoding())


大家还记得这个声明吗?

#coding:utf8


是的,这就是因为如果py2解释器去执行一个utf8编码的文件,就会以默认地ASCII去解码utf8,一旦程序中有中文,自然就解码错误了,所以我们在文件开头位置声明 #coding:utf8,其实就是告诉解释器,你不要以默认的编码方式去解码这个文件,而是以utf8来解码。而py3的解释器因为默认utf8编码,所以就方便很多了。



注意:我们上面讲的string编码是在cpu执行程序时的存储状态,是另外一个过程,不要混淆!
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: