本文目錄一覽：
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) 是以字元為單位；意思為從哪個字元開始讀
原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-tw/n/303409.html
微信掃一掃 
支付寶掃一掃 