您的位置:

python字符编码笔记(python默认字符编码)

本文目录一览:

python默认的字符编码是什么

Python的默认编码是ASCII格式:

ASCII(American Standard Code for Information Interchange),是一种单字节的编码。计算机世界里一开始只有英文,而单字节可以表示256个不同的字符,可以表示所有的英文字符和许多的控制符号;

源代码文件中,如果有用到非ASCII字符,则需要在文件头部进行字符编码的声明,如下:#-*- coding: UTF-8 -*-

实际上Python只检查#、coding和编码字符串,其他的字符都是为了美观加上的。另外,Python中可用的字符编码有很多,并且还有许多别名,还不区分大小写,比如UTF-8可以写成u8。

python3.4学习笔记 3.x和2.x的区别,持续更新

python3.4学习笔记(四) 3.x和2.x的区别

在2.x中:print html,3.x中必须改成:print(html)

import urllib2

ImportError: No module named 'urllib2'

在python3.x里面,用urllib.request代替urllib2

import thread

ImportError: No module named 'thread'

在python3.x里面,用_thread(在前面加一个下划线)代替thread

在2.x中except Exception,e : 3.x中改为except (Exception):

=================================

print函数

虽然print语法是Python 3中一个很小的改动,且应该已经广为人知,但依然值得提一下:Python 2中的print语句被Python 3中的print()函数取代,这意味着在Python 3中必须用括号将需要输出的对象括起来。

在Python 2中使用额外的括号也是可以的。但反过来在Python 3中想以Python2的形式不带括号调用print函数时,会触发SyntaxError。

Python 2.7.6

print 'Python', python_version()

print 'Hello, World!'

print('Hello, World!')

print "text", ; print 'print more text on the same line'

输出:

Hello, World!

Hello, World!

text print more text on the same line

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

Python 3.4.1

print('Python', python_version())

print('Hello, World!')

print("some text,", end="")

print(' print more text on the same line')

输出:

Hello, World!

some text, print more text on the same line

print 'Hello, World!'

File "ipython-input-3-139a7c5835bd", line 1

print 'Hello, World!'

^

SyntaxError: invalid syntax

注意:在Python中,带不带括号输出”Hello World”都很正常。

但如果在圆括号中同时输出多个对象时,就会创建一个元组,这是因为在Python 2中,print是一个语句,而不是函数调用。

print 'Python', python_version()

print('a', 'b')

print 'a', 'b'

Python 2.7.7

('a', 'b')

a b

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

整数除法

由于人们常常会忽视Python 3在整数除法上的改动(写错了也不会触发Syntax Error),所以在移植代码或在Python 2中执行Python 3的代码时,需要特别注意这个改动。

所以,我还是会在Python 3的脚本中尝试用float(3)/2或 3/2.0代替3/2,以此来避免代码在Python

2环境下可能导致的错误(或与之相反,在Python 2脚本中用from __future__ import division来使用Python

3的除法)。

Python 2.7.6

3 / 2 = 1

3 // 2 = 1

3 / 2.0 = 1.5

3 // 2.0 = 1.0

Python 3.4.1

3 / 2 = 1.5

3 // 2 = 1

3 / 2.0 = 1.5

3 // 2.0 = 1.0

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

Unicode

Python 2有基于ASCII的str()类型,其可通过单独的unicode()函数转成unicode类型,但没有byte类型。

而在Python 3中,终于有了Unicode(utf-8)字符串,以及两个字节类:bytes和bytearrays。

Python 2.7.6

print type(unicode('this is like a python3 str type'))

type 'unicode'

print type(b'byte type does not exist')

type 'str'

print 'they are really' + b' the same'

they are really the same

print type(bytearray(b'bytearray oddly does exist though'))

type 'bytearray'

Python 3.4.1 has class 'bytes'

print('and Python', python_version(), end="")

print(' also has', type(bytearray(b'bytearrays')))

and Python 3.4.1 also has class 'bytearray'

1

'note that we cannot add a string' + b'bytes for data'

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

TypeError Traceback (most recent call last)

ipython-input-13-d3e8942ccf81 in module()

---- 1 'note that we cannot add a string' + b'bytes for data'

TypeError: Can't convert 'bytes' object to str implicitly

=================================

python 2.4 与 python 3.0 的比较

一、 print 从语句变为函数

原: print 1,2+3

改为: print ( 1,2+3 )

二、range 与 xrange

原 : range( 0, 4 ) 结果 是 列表 [0,1,2,3 ]

改为:list( range(0,4) )

原 : xrange( 0, 4 ) 适用于 for 循环的变量控制

改为:range(0,4)

三、字符串

原: 字符串以 8-bit 字符串存储

改为: 字符串以 16-bit Unicode 字符串存储

四、try except 语句的变化

在2.x中except Exception,e : 3.x中改为except (Exception):

五、打开文件

原: file( ..... )

或 open(.....)

改为:

只能用 open(.....)

六、从键盘录入一个字符串

原: raw_input( "提示信息" )

改为: input( "提示信息" )

七、bytes 数据类型

A bytes object is an immutable array. The items are 8-bit bytes, represented by integers in the range 0 = x 256.

bytes 可以看成是“字节数组”对象,每个元素是 8-bit 的字节,取值范围 0~255。

由于在 python 3.0中字符串以 unicode 编码存储,当写入二进制文件时,字符串无法直接写入(或读取),必须以某种方式的编码为字节序列后,方可写入。

(一)字符串编码(encode) 为 bytes

例: s = "张三abc12"

b = s.encode( 编码方式)

# b 就是 bytes 类型的数据

# 常用的编码方式为 : "uft-16" , "utf-8", "gbk", "gb2312", "ascii" , "latin1" 等

# 注 : 当字符串不能编码为指定的“编码方式”时,会引发异常

(二) bytes 解码(decode)为字符串

s = "张三abc12"

b = s.encode( "gbk") # 字符串 s 编码为 gbk 格式的字节序列

s1 = b.decode("gbk") # 将字节序列 b以gbk格式 解码为字符串

# 说明,当字节序列不能以指定的编码格式解码时会引发异常

(三)使用方法举例

#coding=gbk

f = open("c:\\1234.txt", "wb")

s = "张三李四abcd1234"

# -------------------------------

# 在 python2.4 中我们可以这样写:

# f.write( s )

# 但在 python 3.0中会引发异常

# -------------------------------

b = s.encode("gbk")

f.write( b )

f.close()

input("?")

读取该文件的例子:

#coding=gbk

f = open("c:\\1234.txt", "rb")

f.seek(0,2) #定位至文件尾

n = f.tell() #读取文件的字节数

f.seek(0,0) #重新定位至文件开始处

b = f.read( n )

# ------------------------------

# 在 python 2.4 中 b 是字符串类型

# 要 python 3.0 中 b 是 bytes 类型

# 因此需要按指定的编码方式确码

# ------------------------------

s = b.decode("gbk")

print ( s )

# ------------------------------

# 在 python 2.4 中 可以写作 print s 或 print ( s )

# 要 python 3.0 中 必须写作 print ( s )

# ------------------------------

f.close()

input("?")

运行后应显示:

张三李四abcd1234

(四) bytes序列,一但形成,其内容是不可变的,例:

s="ABCD"

b=s.encode("gbk")

print b[0] # 显示 65

b[0] = 66

# 执行该句,出现异常: 'bytes' object does not support item assignment

八、 chr( K ) 与 ord( c )

python 2.4.2以前

chr( K ) 将编码K 转为字符,K的范围是 0 ~ 255

ord( c ) 取单个字符的编码, 返回值的范围: 0 ~ 255

python 3.0

chr( K ) 将编码K 转为字符,K的范围是 0 ~ 65535

ord( c ) 取单个字符的编码, 返回值的范围: 0 ~ 65535

九、 除法运算符

python 2.4.2以前

10/3 结果为 3

python 3.0

10 / 3 结果为 3.3333333333333335

10 // 3 结果为 3

十、字节数组对象 --- 新增

(一) 初始化

a = bytearray( 10 )

# a 是一个由十个字节组成的数组,其每个元素是一个字节,类型借用 int

# 此时,每个元素初始值为 0

(二) 字节数组 是可变的

a = bytearray( 10 )

a[0] = 25

# 可以用赋值语句更改其元素,但所赋的值必须在 0 ~ 255 之间

(三) 字节数组的切片仍是字节数组

(四) 字符串转化为字节数组

#coding=gbk

s ="你好"

b = s.encode( "gbk") # 先将字符串按某种“GBK”编码方式转化为 bytes

c = bytearray( b ) #再将 bytes 转化为 字节数组

也可以写作

c = bytearray( "你好", "gbk")

(五) 字节数组转化为字符串

c = bytearray( 4 )

c[0] = 65 ; c[1]=66; c[2]= 67; c[3]= 68

s = c.decode( "gbk" )

print ( s )

# 应显示: ABCD

(六) 字节数组可用于写入文本文件

#coding=gbk

f = open("c:\\1234.txt", "wb")

s = "张三李四abcd1234"

# -------------------------------

# 在 python2.4 中我们可以这样写:

# f.write( s )

# 但在 python 3.0中会引发异常

# -------------------------------

b = s.encode("gbk")

f.write( b )

c=bytearray( "王五","gbk")

f.write( c )

f.close()

input("?")

Python-lesson 2 数据类型、字符编码、文件处理

什么是垃圾:当一个值身上没有人绑定任何变量名(该值的引用计数=0)时,该值就是一个垃圾,会将该值内存空间释放掉。

引用计数增加

age=18 //18的引用计数等于1

x=age //18的引用计数等于2

引用计数减少

age=19 //18的引用计数等于1

del x //解除值与变量名的绑定关系;18的引用计数变为0

1、 为何数据要分不同的类型?

数据是用来表示状态的,不同的状态就应该用不同的类型的数据去表示

2、数据类型

数字(整形,长整形,浮点型,复数)

字符串

字节串:在介绍字符编码时介绍字节bytes类型

列表

元组

字典

集合

3、按照以下几个点展开数据类型的学习

==========================基本使用============================

1、用途

2、定义方式

3、常用操作+内置的方法

==========================该类型总结==========================

存一个值or存多个值

有序or无序

可变or不可变(1、可变:值变,id不变。可变==不可hash 2、不可变:值变,id就变。不可变==可hash)

1、整型int

作用:年纪,等级,身份证号,qq号等整型数字相关

定义:age=10 #本质age=int(10)

2、浮点型float

作用:薪资,身高,体重,体质参数等浮点数相关

salary=3000.3 #本质salary=float(3000.3)

类型转换

a=('123') //字符串类型

a=int('123') //字符串转成整型类型

a=float('12.3') //字符串转成浮点型

作用:记录多个值

定义方式:在[ ]内用逗号分隔开多个任意类型的值;原材料可以是字符串,列表,字典;可变类型

1、按索引存取值(正向存取+反向存取);可存也可以修改;对于赋值操作必须是已存在的索引

l=['a','b','c','d','e']

print(l[0]) =a

print(l[-1]) =e

l[0]='A' //修改列表

print(l) =['A','b','c','d','e']

2、切片(顾头不顾尾,步长),步长与字符串一样;原列表不会修改

print(l[1:4]) =['b','c','d']

3、长度

print(len(l)) =5

4、成员运算in和not in

print('a' in l) =True

print('sss' not in l) =True

5、追加插入

l.append(333) //append最后追加

print(l) =['a','b','c','d','e','333']

l.insert(0,111) //第一个位置添加值

print(l) =['111','a','b','c','d','e']

6、删除remove ,有返回值;del也可删,但是没有返回值;pop 剪切一个值,返回剪切的值

l.remove('a') //()内为值,不能为索引

print(l) =['b','c','d','e']

del l[0] //[ ] 内为索引

l.pop(0) // () 内为索引,不指定索引默认时-1

res=l.pop(0)

print(res) =a

7、循环

for item in l

print(item)

1、count 统计次数

print(l.count('a')) =1

2、extend 一次性往列表末尾追加多个值,一个参数:可以被 for 循环的列表

item=[1,2,3,4,5]

l.extend(item)

print(l) =['a','b','c','d','e',1,2,3,4,5]

3、index 找索引,以找到的第一个值为准,不存在的值会报错,可以用成员运算判断查找的值是否存在,以避免报错;列表没有find

print(l.index('a')) =0

print(l.index('c',2,5)) =2 //指定查找范围,第二个开始,第五个结束

4、sort 排序,默认从小到大排序

l=[4,6,2,9,10,3,1]

l.sort()

print(l) =[1, 2, 3, 4, 6, 9, 10]

l.sort(reverse=True) //从大到小排序

print(l) =[10, 9, 6, 4, 3, 2, 1]

作用:就是一个不可变的列表(是可以当做字典的key的),主要是用来读

定义:在()内用逗号分隔开多个任意类型的元素

t=(1,2,3,('a','b'),['q','w','e'])

本质age=tuple(t=(1,2,3,('a','b'),['q','w','e']))

如果元组只有一个值,必须加一个逗号

t=('a',)

元组总结

1、存多个值

2、有序

3、不可变

1、按索引取值(正向取+反向取):只能取,不能添加、减少、修改

t=(1,2,3,('a','b'),['q','w','e'])

print(t[0]) =1

print(t[-1]) =['q','w','e']

2、切片(顾头不顾尾,步长),步长与字符串一致

print(t[1:4]) =(2, 3, ('a', 'b'))

3、长度

print(len(t)) =5

4、成员运算in和not in

print(1 in t) =True

5、循环

for item in t:

print(item)

t=(1,2,3,('a','b'),3,['q','w','e'])

作用:记录多个值,key对应值,key对value有描述性功能;取值速度快

定义:在{ } 内用逗号隔开多个元素,每个元素都是key:value的形式;key必须是不可变类型,value可以是任意类型

info={'name':'egon','age':18,'sex':'male'}

本质

info=dict(name='egon',age=18,sex='male')

info=dict([['name','egon'],('age',18)])

{}.fromkeys(('name','age','sex'),None)

总结

1、存多个值

2、无序

3、可变

1、将值导入字典

2、按key存取值:可存可取

dic={'name': 'egon', 'age': '18', 'gender': 'male'}

print(dic['name']) =egon //当key不存在时会报错

print(dic.get('name')) =egon

print(dic.get('xxx')) =None //当key不存在时会返回一个None

dic['name']='Egon' //修改value

dic['hight']=18 //如果key不存在,就是一个加值的操作

print(dic) ={'name': 'egon', 'age': '18', 'gender': 'male', 'hight': 18}

3、长度len,统计key:value的个数; 不能有重复的key,后面的key会覆盖前面的key

print(len(dic)) =3

4、成员运算in和not in,以字典的key为准

print('name' in dic) =True

print('dasda' not in dic) =True

5、删除

第一种:del dic['name']

第二种:res=dic.pop('name') //根据key删除,有返回值,返回值为key对应的value值

第三种:res=dic.popitem() //随机删,返回值是(key:value),返回值格式是元组

6、键keys(),值values(),键值对items()

print(dic.keys()) =dict_keys(['name', 'age', 'gender']) //取索引

print(dic.values()) =dict_values(['egon', '18', 'male']) //取值

print(dic.items()) =dict_items([('name', 'egon'), ('age', '18'), ('gender', 'male')]) //取键值对

7、循环

for item in dic:

print(item) //输出的是key

for item in dic.values():

print(item) //输出的是值

for item in dic.items():

print(ietm) //输出的是 (key:value) 的元组

1、update 新字典中已经存在的以新的为准,不存在的增加

dic={'name': 'egon', 'age': '18', 'gender': 'male'}

dic.update({'age':19,'hight':180})

print(dic) ={'name': 'egon', 'age': 19, 'gender': 'male', 'hight': 180}

2、setdefault 加入一个键值对,如果key已存在,则保留字典里的原值,如果key不存在,则加入键值对;返回字典里key对应的value值

作用:关系运算,去重

定义方式:在{ }内用逗号分隔开多个元素,但是元素的特点是

1、每个元素必须是不可变类型(可hash,可作为字典的key)

2、没有重复的元素

3、无序

注意:集合的目的是将不同的值存放到一起,不同的集合间用来做关系运算,无需纠结于集合中单个值

类型转换

res=set('hello') //字符串转集合

rds=set([1,'a','b']) //列表转集合

print(res) ={'h', 'l', 'e', 'o'} //去重

print(rds) ={1, 'a', 'b'}

总结:

1、有多个值

2、无序

3、可变

pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}

linuxs={'wupeiqi','oldboy','gangdan'}

1、长度len

2、成员运算in和not in

3、合集

print(pythons | linuxs)

4、交集

print(pythons linuxs)

5、两个集合差集,以第一个集合为准

print(pythons - linuxs) //求只报名python的学生

print(linuxs - pythons) //求只报名linux的学生

6、对称差集;求没有报名两门课程的学生

第一种:res=(pythons - linuxs) | (linuxs - pythons)

第二种:res=pythons ^ linuxs

print(res)

7、== ,集合值相等即可,无需顺序一致

s1={1,2,3}

s2={3,2,1}

print(s1 == s2) =True

8、父集:,= ;子集:,=

s1={1,2,3}

s2={3,2,1,4,6}

print(s2 = s1) =True

print(s1 = s2) =True

介绍:计算机系统分为:计算机硬件,操作系统,应用程序三部分。

1、什么是文件?

文件是操作系统为应用程序或者用户提供一种操作硬盘的虚拟单位。

window系统默认为GBK编码

2、为什么要用文件?

文件对应的硬盘空间,如果需要考虑永久保存数据那必须使用文件

3、如何用文件?

(1)打开文件

f=open(r'D:\untitled1\a.txt',mode='r',encoding='utf-8')

第一个小r,表示原生的字符串,\没有转义的意思,防止\a、\n转义

第二个小r,以读的模式打开,rb以二进制格式读,rt会把文本文件二进制解码成unicode格式存到内存,针对文本文件用rt模式;w为写操作;

赋值给一个变量,变量指定该文件对象,文件对象占的是应用程序的资源

(2)读/写文件

(3)关闭文件

f.close() //向操作系统发送指令,让操作系统关闭打开的文件,回收操作系统资源

1、控制文件读写操作模式

r 只读模式,以该模式打开文件,当文件不存在时报错;

w 只写模式,如果该文件存在则覆盖,如果该文件不存在,创建新文件写入;文件打开不关闭的情况下,连续写入自动追加;

a 追加,如果该文件存在则文件结尾追加内容,如果该文件不存在,创建新文件写入;

w+ 读写,如果该文件存在则覆盖,如果该文件不存在,创建新文件写入

2、控制文件读写内容的模式(不能单独使用,必须与r、w、a连用)

t (默认) 读写只能是文本文件,都是字符串类型,会自动解码文本文件;必须指定encoding参数

b 对于非文本文件,我们只能使用b模式,linux可忽略;"b"表示以字节的方式操作;以b方式打开时,读取到的内容是byte字节类型,写入时也需要提供字节类型,不能指定编码

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

with open('log','r') as f:

3、文件的修改

f.seek(3,0) //3指移动的字节数,0是模式

1、三种模式,以字节为单位;只有0模式既可以在t模式下用也可以在b模式下用,而1、2两种模式只能在b模式下用

0 (默认模式):永远参照文件开头往后数

1:参照指针当前所在位置

2:参照文件末尾,倒着数

注意:t 模式下的read(n) 是以字符为单位;意思为从哪个字符开始读