本文目录一览：
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) 是以字符为单位；意思为从哪个字符开始读
