Python基礎知識點

編程語言的進化：機器語言、彙編語言、高級語言

機器語言：因爲計算機內部只能接受二進制代碼，所以，用二進制代碼0或1描述的指令稱爲機器指令，所有機器指令的集合構成計算機的機器語言。

彙編語言：實質和機器語言是相同的，都是直接對硬件操做，只不過指令採用英文縮寫的標識符，更容易識別和記憶。

高級語言：高級語言對開發人員更加友好，開發效率大大提升
高級語言所編制的程序不能直接被計算機識別，必須通過轉換才能被執行。

高級語言按轉換方式可分爲：編譯型、解釋型
編譯型：指在應用源程序執行以前，將程序源代碼轉換成目標代碼，所以其目標代碼能夠脫離其語言環境獨立執行。
編譯後程序運行時不須要從新翻譯，直接使用翻譯的結果就行。程序執行效率高，依懶性編譯器，跨平臺性差。如C、C++、GO、Delphi等

解釋型：應用程序源代碼一邊由相應語言的解釋器翻譯成目標代碼，一邊執行，所以效率比較低，不能生成可獨立執行的可執行文件，應用程序不能脫離其解釋器。如Python、Java、PHP、Ruby等。跨平臺性好、開發效率不高。

編譯型語言執行速度快，不依賴語言環境運行，跨平臺差
解釋型跨平臺好，一份代碼，處處運行。缺點是執行速度慢，依賴解釋器運行。

Python創始人：Guido van Rossum（龜叔）
Python誕生在1989年
2008年12月出現Python3.0
2010年出現一個過渡版本Python2.7（最多隻支持到2020年,以後不支持2.0版本）

Python解釋器是用C語言寫的
Python解釋器種類有：CPython、IPython、PyPy、Jython、IronPython

Python的安裝：打開官網http://www.python.org/downloads/windows/下載中心

測試安裝是否成功：
windows-->運行-->輸入cmd,回車，彈出cmd程序，輸入Python，若是進入交互環境，表明安裝成功。

print('hello world!')
保存爲helloworld.py,注意.py後綴名的做用：命名約束規範，方便程序員識別代碼。
進入cmd命令行，執行Python helloworld.py,看結果。
注意文件名前面加python的緣由是要把代碼交給python解釋器去解釋執行

內存和磁盤的關係：內存存取速度快，斷電就丟失；磁盤存取速度慢，永久保存。

Python交互器是主要用來對代碼進行調試用的

變量：先定義後使用
變量做用：存數據，佔內存，存儲程序運行的中間結果，能夠被後面的代碼調用。

聲明變量：變量名=變量的值

變量的命名規則：
1.變量名只能是數字、字母或下劃線的任意組合
2.變量名的第一個字符不能是數字
3.如下關鍵字不能聲明爲變量名['and','as','assert','break','class','continue','def','elif','else','except','exec','finally','for','from','global','if','import','in','is','lambda','not','or','pass','print','raise','return','try','while','with','yield']

常量：程序在執行過程當中不能改變的量
在Python中沒有一個專門的語法表明常量，程序員約定俗成的變量名所有大寫表明常量。

讀取用戶輸入

name = input(" what's your name:") print("hello "+name)

 

 

輸入用戶姓名和密碼

username= input("username:")

password= input("password:")

print(username,password)

 

 

註釋:解釋說明，幫助閱讀代碼。
單行註釋：#
多行註釋：'''....'''

數據類型
數據類型-數字類型

int（整型）：32位機器上：-2**31 —— 2**31-1 64位一樣的道理
long（長整型）：Python的長整型沒有指定位寬。（Python3裏再也不有long類型）
float（浮點型）：

數據類型-字符串類型
字符串：在Python中，加了引號的字符都被認爲是字符串！
注意：單雙引號是沒有任何區別的；多行字符串必須用多引號。

布爾類型：
只有兩個值True、False ，主要用來作邏輯判斷

格式化輸出：（%s 以一個字符替換 %d以一個整數替換 %f以一個浮點數替換）都是一個佔位符 %是一個鏈接符

運算符
算術運算符（+,-,*,/,%,**,//），
比較運算符(==,!=,<>,>,<,>=,<=)，
邏輯運算符(and,or,not)，
賦值運算符(=,+=,*=,/=,%=,**=,//=)，
成員運算符(in,not in)，
身份運算符(is , is not)，
位運算(>>,<<)

流程控制

單分支：
if 條件：
　　知足條件後要執行的代碼塊

多分支：
if 條件：
　　知足條件後要執行的代碼塊
elif 條件：
　　上面的條件不知足就走這個
elif 條件：
　　上面的條件不知足就走這個
elif 條件：
　　上面的條件不知足就走這個
else:
　　上面的條件不知足就走這個

while循環

while 條件：
　　執行代碼...

Dead Loop
count=0
while True:
　　print("你個基佬！！！",count)
　　count+=1

循環終止語句：break語句或continue語句
break語句：用於徹底結束一個循環，跳出循環體執行後面的語句
continue語句：只終止本次循環，接着執行後面的循環

while...else用法
當while循環正常執行完，中間沒有被break終止的話，就會執行else後面的語句。

 

二進制運算、字符編碼、數據類型
二進制（0,1）、八進制（0-7）、十進制（0-9）、十六（0-9，A-F）進制的轉換
四位二進制表示一位十六進制
oct() 八進制 hex()十六進制
char(num)將ASCII值得數字轉換成ASCII字符，範圍只能是0-255
ord(char)接受一個ASCII值字符，返回相應的ASCII值

每一位0或1所佔的空間單位爲bit(比特)，這是計算機中最小的表示單位
8bits = 1Bytes字節,最小的存儲單位，1bytes縮寫爲1B
1024Bytes = 1KB = 1KB
1024KB = 1MB 
1024MB =1GB
1024GB = 1TB
1024TB = 1PB

ASCII 256，每個字符佔8位
Unicode編碼(統一碼、萬國碼):規定了全部的字符和符號最少由16位表示
UTF-8:ascii碼中的內容用1個字節保存，歐洲的字符用2個字節保存，東亞的字符用3個字節保存...
winsows系統中文版默認編碼是GBK
Mac OS\Linux系統默認編碼是UTF-8

UTF是爲unicode編碼 設計的一種在存儲和傳輸時節省空間的編碼方案。

不管以什麼編碼在內存裏顯示字符，存到硬盤上都是二進制。不一樣編碼的二進制是不同的
存到硬盤上以何種編碼存的，那麼讀的時候還得以一樣的編碼讀，不然就亂碼了。

python2.x默認編碼是ASCII；默認不支持中文，支持中文須要加：#_*_ coding:utf-8 _*_ 或者 #!encoding:utf-8
Python3.x默認編碼是UTF-8，默認支持中文

Python數據類型
字符串 str
數字：整型（int）長整型(long) 浮點型(float) 布爾（bool） 複數（complex）
列表 list
元組 tuple
字典 dictionary
集合:可變集合(set) 不可變集合（frozenset）
不可變類型：數字，字符串，元組
可變類型：列表，字典，集合

 

字符串
特色：有序、不可變
字符串的經常使用方法:isdigit,replace,find,count,index,strip,split,format,join,center

 

  1 s = "abcd"
  2 print(s.swapcase())     #都變成大寫字母
  3 
  4 print(s.capitalize())   #都變成首字母大寫
  5 
  6 print(s.center(50,"*"))   #打印變量s的字符串 指定長度爲50，字符串長度不夠的用*號補齊
  7 
  8 print(s.count("a",0,5))     #統計字符串a在變量裏有幾個；0,5表明統計範圍是下標從0-5的範圍
  9 
 10 print(s.endswith("!"))      #是不是以什麼結尾的。
 11 
 12 print(s.startswith("a"))    #判斷以什麼開始
 13 
 14 
 15 s = "a  b"
 16 print(s.expandtabs(20))  #至關於在a和b中間的tab長度變成了20個字符，交互模式可看出效果
 17 
 18 s.find("a",0,5)     #查找字符串，並返回索引
 19 
 20 s.format()          #字符串格式化
 21 s1 = "my name is {0},i am {1} years old"
 22 print(s1)
 23 print(s1.format("aaa",22))  #分別把{0}替換成aaa  {1}替換成22
 24 #也能夠寫成以下
 25 s1 = "my name is {name},i am {age} years old"
 26 s1.format(name="aaa",age = 22)  #字典形式賦值
 27 
 28 #s.format_map()  #後續補充
 29 
 30 
 31 print(s.index("a"))     #返回索引值
 32 
 33 print(s.isalnum())      #查看是不是一個阿拉伯字符 包含數字和字母
 34 
 35 print(s.isalpha())      #查看是不是一個阿拉伯數字 不包含字母
 36 
 37 print(s.isdecimal())    #判斷是不是一個整數
 38 
 39 print(s.isdigit())      #判斷是不是一個整數
 40 
 41 print(s.isidentifier())     #判斷字符串是不是一個可用的合法的變量名
 42 
 43 print(s.islower())      #判斷是不是小寫字母
 44 
 45 print(s.isnumeric())    #判斷只有數字在裏邊
 46 
 47 print(s.isprintable())  #判斷是否能夠被打印，linux的驅動不能被打印
 48 
 49 print(s.isspace())      #判斷是不是一個空格
 50 
 51 print(s.istitle())      #判斷是不是一個標題   每一個字符串的首字母大寫  Hello Worlld
 52 
 53 print(s.isupper())      #判斷是否都是大寫
 54 
 55 # s.join()
 56 name = ["a","b","1","2"]
 57 name2 = "".join(name)   #列表轉成字符串，把列表裏邊的元素都join到字符串中
 58 print(name2)        #得出ab12
 59 
 60 #s.ljust
 61 s = "Hello World"
 62 print(s.ljust(50,"-"))  #給字符串從左往右設置長度爲50，字符串長度不夠用 - 補充
 63 
 64 print(s.lower())        #字符串都變成小寫
 65 
 66 print(s.upper())        #變大寫
 67 
 68 print(s.strip())        #脫掉括號裏邊的，能夠是空格 換行 tab ...
 69 
 70 s.lstrip()              #只脫掉左邊的空格
 71 s.rstrip()              #只拖點右邊的空格
 72 
 73 # s.maketrans()           #
 74 str_in = "abcdef"       #必須是一一對應
 75 str_out = "!@#$%^"      #必須是一一對應
 76 tt = str.maketrans(str_in,str_out)  #生成對應表，就像密碼錶同樣
 77 print(tt)
 78 #結果：{97: 33, 98: 64, 99: 35, 100: 36, 101: 37, 102: 94}
 79 
 80 print(s.translate(tt))  # s.translate方法調用 加密方法tt 給 s的字符串加密
 81 #結果：H%llo Worl$
 82 
 83 # s.partition()
 84 s = "Hello World"
 85 print(s.partition("o")) #把字符串用 從左到右第一個o把 字符串分紅兩半
 86 #結果：('Hell', 'o', ' World')
 87 
 88 s.replace("原字符","新字符",2)     #字符串替換，也能夠寫換幾回 默認全換，能夠設置count次數
 89 
 90 s.rfind("o")       #查找最右邊的字符，也有開始和結束
 91 
 92 print(s.rindex("o") )   #查找最右邊的字符的索引值
 93 
 94 s.rpartition("o")       #從最右邊的字符開始 把字符串分紅兩半
 95 
 96 s.split()               #已括號裏邊的把字符串分紅列表，括號裏能夠是空格、等字符來分紅列表
 97 
 98 s.rsplit()              #從最右邊以 某字符 來分開字符串
 99 
100 s.splitlines()          #設置以換行的形式 把字符串分紅列表
101 
102 print(s.swapcase())       #字母換成相反的大小寫，大的變成小，小的變成大
103 #結果「：hELLO wORLD
104 #原來的「hello World」
105 
106 s.title()               #把字符串變成title格式  Hello World
107 
108 s.zfill(40)             #把字符串變成40，字符串不夠，從左往右用0 補齊
109 
110 
111 #"a\tb"  字符串中間的\t 被認爲是tab 是4個或者8個空格
112 #總體意思是：a 有一個tab 而後 又有一個b

View Code

 

 

 

 

列表
列表的經常使用方法：建立、查詢、切片、增長、修改、刪除、循環、排序、反轉、拼接、clear、copy
列表的特色：能夠重複；列表是有序的

 1 1、建立
 2 ​ 方法一：list1 = ["a", "b"]　　  # 經常使用
 3 ​ 方法二：list2 = list () 　　　  # 通常不用這種方法
 4 
 5 2、查詢
 6 ​ 列表的索引 (也稱下標)：
 7 列表從左到右下標是從0開始0、一、二、3....
 8 ​列表從右到左下標是從 - 1開始 -1 -2 -3...
 9 
10 ​查詢索引值：
11 ​list1.index (a) 　　  # index查詢找到第一個a程序就不走了，
12 list1[0] 　　  # 經過a的索引 得出a
13 list1[-1]　　  # 經過b的下標 得出b
14 
15 當list1 = [1, 2, 3, 4, 4, 4, 4, 4, 4]
16 列表裏出現元素相同時，統計相同次數
17 list1.count (4) 　　  # 統計得出:6   表明列表有6個4
18 
19 3、切片
20 切片：經過索引 (或下標)
21 截取列表中一段數據出來。
22 list1 = [1, 2, 3, 4, 4, 4, 4, 4, 4]
23 list1[0:2] 　　  # 得出 [1,2] ，列表切片顧頭不顧尾，也可成list1[:2]
24 list1[-5:] 　　  # 得出[4,4,4,4,4]，取最後5個元素，只能從左往右取
25 按步長取元素：
26 list1 = [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5]
27 list1[:6:2] 　　  # 得出:[1, 3, 5] 　　:2 表明步長 ，每隔兩步取一個元素
28 list1[::2] 　　  # 得出:[1, 3, 5, 1, 3, 5] 　在列表全部元素中，每隔2步取一個數
29 
30 4、增長
31 list1 = ["a", "b", "c"]
32 list1.append ("d") 　　  # 追加d到列表list1的最後 結果:['a', 'b', 'c', 'd']
33 list1.insert (1, "aa") 　　  # 插入aa到列表下標爲1的以前 　　得出結果:['a', 'aa', 'b', 'c', 'd']
34 
35 5、修改
36 list1[1] = "bb" 　　  # 直接給對應位置賦值，便是修改 結果:['a', 'bb', 'b', 'c', 'd']
37 批量修改
38 把['a', 'bb', 'b', 'c', 'd']裏的前兩個元素替換掉
39 list1[0:2] = "boy" 　　  # 結果:['b', 'o', 'y', 'b', 'c', 'd']
40 
41 6、刪除
42 list1 = ['b', 'o', 'y', 'b', 'c', 'd']
43 list1.pop () 　　  # 默認刪除最後一個元素 d
44 list1.remove ("o") 　　  # 刪除元素O remove只能一個一個刪除
45 list1.remove (0) 　　  # 刪除下標爲0的元素 b
46 del list1[0] 　　  # 刪除下標爲0的元素 del是一個全局刪的方法
47 del list1[0:2] 　　  # del能夠批量刪除
48 
49 7、for循環列表
50 list1 = [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5]
51 for i in list1:  #使用for循環循環列表list1裏邊的元素
52 range (10) 　　  # 生成0到10 的數字
53 
54 8、排序
55 list1 = ["1", "5", "3", "a", "b", "f", "c", "d", "A", "C", "B"]
56 list1.sort ()      #結果：['1', '3', '5', 'A', 'B', 'C', 'a', 'b', 'c', 'd', 'f']
57 
58 排序是按照ASCII碼對應排序。
59 反轉
60 list1.reverse ()   #結果：['f', 'd', 'c', 'b', 'a', 'C', 'B', 'A', '5', '3', '1']
61 
62 9、兩個列表拼一塊
63 # 方法一
64 list1 = [1, 2, 3, 4, 5]
65 list2 = [6, 7, 8, 9]
66 list1 + list2    #結果：[1, 2, 3, 4, 5, 6, 7, 8, 9]
67 # ​方法二
68 list1.extend (list2) 　　  # 把列表2擴展到list1中
69 結果：[1, 2, 3, 4, 5, 6, 7, 8, 9]
70 
71 10、clear
72 # 清空列表
73 list2.clear () 　　  # 清空list2
74 
75 11、copy
76 淺copy
77 複製列表
78 list2 = list1.copy ()
79 當列表只有一層數據，沒有列表嵌套列表的狀況下，複製後的列表和原來的列表是徹底獨立的。
80 當列表有多層嵌套的時候，列表嵌套裏邊的列表的內容是和原有列表是共享的。
81 list1.copy () #因此這個叫作：淺copy
82 
83 ​深copy:須要藉助python模塊
84 import copy
85 list2 = copy.deepcopy (list1)
86 深copy後，新的列表和舊的列表，無論有沒有列表嵌套列表，都是徹底獨立的個體。
87 能夠經過查看列表名對應的內存地址分辨兩個列表是否獨立
88 查看python解釋器裏邊的內存地址：id (變量名)

View Code

 

元組
特色：有序的，不可變的列表
經常使用功能：index,count,切片
使用場景：顯示的告知別人，此處數據不可修改；數據庫鏈接配置信息等

hash函數
hash，通常翻譯爲「散列」，也有直接翻譯爲「哈希」的，就是把任意長度的輸入，經過散列算法，變成固定長度的輸出，該輸出就是散列值。這種轉換是一種壓縮映射，也就是，散列值的空間一般遠小於輸入的空間，不通的輸入可能會散列成相同的輸出，因此不可能從散列值來肯定惟一的輸入值，簡單的說就是一種將任意長度的消息壓縮到某一固定長度的消息摘要的函數。
特徵：hash值的計算過程是依據這個值的一些特徵計算的，這就要求被hash的值必須固定，所以被hash的值必須是不可變的。（不能保證輸出的數據惟一的，容易形成衝突）
用途：文件簽名；md5加密；密碼驗證

 

1 >>> hash("abc")
2 -6784760005049606976
3 >>> hash((1,2,3))
4 2528502973977326415

View Code

 

 

 

字典
語法：info={}
特色：1.key-value結構，key必須是可hash、必須是不可變數據類型、必須惟一
           2.每個key必須對應一個value值，value能夠存聽任意多個值，可修改，能夠不惟一
           3.字典是無序的
字典的查找速度快是由於字典能夠把每一個key經過hash變成一個數字（數字是按照ASCII碼錶進行排序的）
字典的方法：增刪改查 多級嵌套 等

 

 1 # 字典方法
 2 info = { 
 3     "student01":"aaa" , 
 4     "student02":"bbb",
 5     "student03":"ccc"
 6 }
 7 
 8 # 增長
 9 info["student04"] = "ddd"
10 info["student05"] = "eee"
11 info["student06"] = "fff"
12 
13 # 查詢
14 # 判斷student01在不在info字典裏
15 print("student01" in info    )   # 返回True
16 print(info.get("student01"))    # 返回aaa，沒有返回None
17 info["student01"]   # 獲取對應的value ，若是沒有這個key 就報錯，因此通常用get
18 
19 # 刪除
20 print(info.pop("student01"))  # 刪除key
21 print(info.popitem())       # 隨機刪除一個key
22 del info["student02"]   # 刪除的key ，若是沒有刪除的key 就報錯 KeyError: 'student01'
23 
24 info.clear()    # 清空字典
25 
26 # 多級字典嵌套
27 dic1 = {"aaa": {"aa": 11}, "bbb": {"bb": 22}}
28 
29 # 其餘方法
30 info = {
31     "name1": [22, "it"],
32     "name2": [24, "hr"],
33     "name3": 33
34 }
35 
36 info2 = {
37     "name1": 44,
38     "name4": 33,
39     1: 2
40 }
41 info.keys() # 打印全部的key
42 info.values()   # 打印全部的value
43 info.items()    # 把字典轉成一個列表
44 info.update(info2)   # 把兩個字典合成一個,若是有重複的key ，info2裏邊的重複key會覆蓋info裏邊的key
45 info.setdefault("student07","abcdef")   # 設置一個默認的key:value ,
46 # 若是info字典裏沒有key student07 ，那麼info字典裏有添加 student07:abcdef
47 # 若是info字典裏已經手動添加了student07的key value，那麼這裏的student07:abcdef 就不起做用
48 print(info.fromkeys(["name1","name2"],"aaa") )    # 從一個可迭代的對象中批量生成key和相同的value
49 
50 # 字典的循環:高效循環
51 for k in info:
52     print(k,info[k])    # 打印key value
53 
54 # 另一種方法 低效
55 for k,v in info.items():    # 先把字典轉成列表，在循環，因此低效
56     print(k,v)

View Code

 

 

 

集合
集合是一個無序的、不重複的數據組合
做用：1.去重
           2.關係測試，測試兩組數據之間的交集、差集、並集等關係
語法：
s = {} #若是爲空，就是字典
s = {1,2,3,4} #就成了集合 set
s = {1,2,3,4,1,2} #有重複數據，顯示結果就直接去重{1, 2, 3, 4}

列表轉成給一個字典
l = [1,2,3,4,1,2]
l2 = set(l)

集合的方法

 

 1 #集合方法
 2 s = {1,2,3,4,5}     #定義一個集合
 3 
 4 #增長
 5 s.add(6)
 6 print(s)    #{1, 2, 3, 4, 5, 6}
 7 
 8 #刪除
 9 #隨機刪除
10 s.pop()
11 print(s)    #{2, 3, 4, 5, 6}
12 #指定刪除,若是不存在，就報錯
13 s.remove(6)
14 print(s)    #{2, 3, 4, 5}
15 #指定刪除，若是不存在，不報錯
16 s.discard(6)
17 print(s)
18 
19 #聯合其餘集合，能夠添加多個值
20 s.update([7,8,9])
21 print(s)    #{2, 3, 4, 5, 7, 8, 9}
22 
23 #清空集合
24 s.clear()
25 
26 
27 #集合的關係測試
28 iphone7 = {"alex","rain","jack","old_driver"}
29 iphone8 = {"alex","shanshan","jack","old_boy"}
30 
31 #交集
32 print(iphone7.intersection(iphone8))
33 print(iphone7 & iphone8)
34 # 輸出：
35 {'jack', 'alex'}
36 {'jack', 'alex'}
37 
38 #差集
39 print(iphone7.difference(iphone8))
40 print(iphone7 - iphone8)
41 # 輸出：
42 {'rain', 'old_driver'}
43 {'rain', 'old_driver'}
44 
45 #並集 把兩個列表加起來
46 print(iphone7.union(iphone8))
47 print(iphone7 | iphone8)
48 # 輸出：
49 {'rain', 'jack', 'old_driver', 'alex', 'shanshan', 'old_boy'}
50 {'rain', 'jack', 'old_driver', 'alex', 'shanshan', 'old_boy'}
51 
52 #對稱差集   把不交集的取出來
53 print(iphone7.symmetric_difference(iphone8))
54 # 輸出:
55 {'rain', 'old_driver', 'shanshan', 'old_boy'}
56 
57 s = {1,2,3,4}
58 s2 = {1,2,3,4,5,6,}
59 #超集 誰是誰的父集
60 print(s2.issuperset(s))   #s2是s的父集
61 print(s2 >= s)
62 # 輸出：
63 True
64 True
65 
66 #子集
67 print(s.issubset(s2)) #s是s2的子集
68 print(s <= s2)
69 # 輸出：
70 True
71 True
72 
73 #判斷兩個集合是否不相交
74 print(s.isdisjoint(s2))
75 # 輸出：
76 False    #表明兩個集合是相交的
77 
78 s = {1,2,3,-1,-2}
79 s2 = {1,2,3,4,5,6}
80 s.difference_update(s2)  #求出s和s2 的差集，並把差集 覆蓋給 s
81 print(s)               # 結果：{-2, -1}
82 
83 s.intersection_update(s2)    #求出s和s2的交集，並把交集 覆蓋給 s
84 print(s)
85 print(s2)
86 # 結果:
87 {1, 2, 3}
88 {1, 2, 3, 4, 5, 6}

View Code

 

 

 

 

字符編碼
python3
　　文件編碼默認 ：utf-8
　　字符串編碼：unicode
python2
　　文件編碼默認：ascii
　　字符串編碼默認：ascii
　　若是文件頭聲明瞭utf-8，那字符串的編碼是utf-8
　　unicode是一個單獨的類型

python3的內存裏：所有是unicode
python3執行代碼的過程：
一、解釋器找到代碼文件，把代碼字符串按文件頭定義的編碼加載到內存，轉成unicode
二、把代碼字符串按照python語法規則進行解釋
三、全部的變量字符都會以unicode編碼聲明

在python2裏邊，默認編碼是ASCII編碼，那麼文件頭聲明是utf-8的代碼，在windows中將顯示亂碼
如何在windows上顯示正常呢？（windows的默認編碼是gbk）
　　一、字符串以gbk格式顯示
　　二、字符串以unicode編碼
修改方法：
1.UTF-8 -- >decode解碼 --> Unicode
2.Unicode -- > encode編碼 -- > GBK / UTF-8

1 s="路飛學城"
2 print("decode before:",s)
3 s2=s.decode("utf-8")
4 print("decode after:",s2)
5 print(type(s2))
6 s3=s2.encoded("gbk")
7 print(s3)
8 print(type(s3))

View Code

 

python中bytes類型
二進制的組合轉換成16進制來表示就稱之爲bytes類型，即字節類型，它把8個二進制組成一個bytes，用16進制來表示。
在python2裏，bytes類型和字符串是本質上時沒有區分的。
　　str = bytes
　　python2 以utf-8編碼的字符串，在windows上不能顯示，亂碼。
　　如何在python2下實現一種，寫一個軟件，在全球各國電腦上 能夠直接看？
　　　　以unicode編碼寫軟件。

　　　　s = you_str.decode("utf-8")

　　　　s2 = u"路飛"

 

 

　　unicode類型 也算字符串
文件頭：
python2：以utf-8 or gbk 編碼的代碼，代碼內容加載到內存，並不會被轉成unicode，編碼依然是utf-8 或 gbk。
python3：以utf-8 or gbk編碼的代碼，代碼內容加到在內存，會被自動轉成unicode。

在python3裏，bytes類型主要來存儲圖片、視頻等二進制格式的數據
　　str = unicode
　　默認就支持了全球的語言編碼

常見編碼錯誤的緣由有：
　　一、python解釋器的默認編碼
　　二、python源文件文件編碼
　　三、終端使用的編碼（windows/linux/os）
　　四、操做系統的語言設置