python02-字符編碼、字符串格式化、進制轉化、數據類型、列表、元組、字典總結

目錄：

一.字符編碼

二.字符串格式化

三.進制轉換

四.數據類型及其操做

1.int類

2.str類

五.格式轉換

六.列表

七.元組

八.字典

 

一.字符編碼：

計算機由美國人發明，最先的字符編碼爲ASCII，只規定了英文字母數字和一些特殊字符與數字的對應關係。最多隻能用 8 位來表示（一個字節），即：2**8 = 256，因此，ASCII碼最多隻能表示 256 個符號

ascii用1個字節表明一個字符；

unicode經常使用2個字節表明一個字符，生僻字須要用4個字節；

UTF-8英文字母被編碼成1個字節，漢字一般是3個字節有很生僻的字符纔會被編碼成4-6個字節。

例：

字母x，用ascii表示是十進制的120，二進制0111 1000

漢字中已經超出了ASCII編碼的範圍，用Unicode編碼是十進制的20013，二進制的01001110 00101101。

字母x，用unicode表示二進制0000 0000 0111 1000，因此unicode兼容ascii，也兼容萬國，是世界的標準

這時候亂碼問題消失了，全部的文檔咱們都使用可是新問題出現了，若是咱們的文檔通篇都是英文，你用unicode會比ascii耗費多一倍的空間，在存儲和傳輸上十分的低效

本着節約的精神，又出現了把Unicode編碼轉化爲「可變長編碼」的UTF-8編碼。UTF-8編碼把一個Unicode字符根據不一樣的數字大小編碼成1-6個字節，經常使用的英文字母被編碼成1個字節，漢字一般是3個字節，只有很生僻的字符纔會被編碼成4-6個字節。若是你要傳輸的文本包含大量英文字符，用UTF-8編碼就能節省空間：

字符	Ascll	Unicode	Utf-8
x	01000001	00000000 01000001	01000001
中	不能表示	01001110 00101101	11100100 10111000 10101101

從上面的表格還能夠發現，UTF-8編碼有一個額外的好處，就是ASCII編碼實際上能夠被當作是UTF-8編碼的一部分，因此，大量只支持ASCII編碼的歷史遺留軟件能夠在UTF-8編碼下繼續工做。

ASCII:只能存英文和拉丁字符，一個字符佔一個字節，8位

gb2312：只能存6700多箇中文，1980年

gbk1.0：存2萬多字符，1995年

gb18030：存27000中文，2000年

萬國碼：Unicode：utf-32  一個字符佔4個字節

                 Utf-16  一個字符佔2個字節，或兩個以上。

                 Utf-8   一個英文用ASCII碼來存，一箇中文佔3個字節

聲明編碼  -*- coding：utf-8 -*-

gbk默認不認識utf-8，utf-8是Unicode的一個子集

Unicode 默認向下兼容gbk等

python3內部默認是 unicode，文件默認編碼是utf-8

階段一：現代計算機起源於美國，最先誕生也是基於英文考慮的ASCII

ASCII:一個Bytes表明一個字符（英文字符/鍵盤上的全部其餘字符），1Bytes=8bit，8bit能夠表示0-2**8-1種變化，便可以表示256個字符

ASCII最初只用了後七位，127個數字，已經徹底可以表明鍵盤上全部的字符了（英文字符/鍵盤的全部其餘字符），後來爲了將拉丁文也編碼進了ASCII表，將最高位也佔用了

階段二:爲了知足中文和英文，中國人定製了GBK

GBK:2Bytes表明一箇中文字符，1Bytes表示一個英文字符

爲了知足其餘國家，各個國家紛紛定製了本身的編碼

日本把日文編到Shift_JIS裏，韓國把韓文編到Euc-kr裏

階段三：各國有各國的標準，就會不可避免地出現衝突，結果就是，在多語言混合的文本中，顯示出來會有亂碼。如何解決這個問題呢？？？

說白了亂碼問題的本質就是不統一，若是咱們能統一全世界，規定全世界只能使用一種文字符號，而後統一使用一種編碼，那麼亂碼問題將不復存在，

不少地方或老的系統、應用軟件仍會採用各類各樣的編碼，這是歷史遺留問題。因而咱們必須找出一種解決方案或者說編碼方案，須要同時知足：

一、可以兼容萬國字符

二、與全世界全部的字符編碼都有映射關係，這樣就能夠轉換成任意國家的字符編碼

這就是unicode（定長），　統一用2Bytes表明一個字符，　雖然2**16-1=65535，但unicode卻能夠存放100w+個字符，由於unicode存放了與其餘編碼的映射關係，準確地說unicode並非一種嚴格意義上的字符編碼表

很明顯對於通篇都是英文的文原本說，unicode的式無疑是多了一倍的存儲空間（二進制最終都是以電或者磁的方式存儲到存儲介質中的）

階段四：因而產生了UTF-8（可變長，全稱Unicode Transformation Format），對英文字符只用1Bytes表示，對中文字符用3Bytes，對其餘生僻字用更多的Bytes去存。

二. Python 字符串格式化

Python 支持格式化字符串的輸出 。儘管這樣可能會用到很是複雜的表達式，但最基本的用法是將一個值插入到一個有字符串格式符 %s 的字符串中。

格式輸出彙總：

 1 #第一種
 2 val = "我叫%s,今年%d歲，身高%d"%('zrh',20,175)  3 print(val)   #運行結果：我叫zrh,今年20歲，身高175
 4 #第二種
 5 val = "我叫{0},今年{1}歲，身高{2}，我弟弟身高也是{2}"
 6 val1 = val.format("zrh",20,175)  7 print(val1) #運行結果：我叫zrh,今年20歲，身高175，我弟弟身高也是175
 8 #第三種
 9 v = input("your name:") #用戶輸入姓名
10 val = "我叫{name},今年{age}歲，身高{height}"
11 val1 = val.format(name=v,age="20",height="175") #name = v是用戶輸入的那個姓名
12 print(val1) 13 #第四種
14 val = "我叫{name},今年{age}歲"
15 dic1 = {"name":"zrh","age":20} 16 val1 = val.format(**dic1) 17 print(val1) 18 #第五種
19 name = "我叫{name},年齡{age}"
20 val = name.format_map({'name':'海角','age':18})   #只有一種寫法，裏面必須是字典
21 print(val)

若是在格式化輸出中想要輸出%號，就要用到%%格式

例如：

print("我是%s,個人進度已經完成80%%" %('zrh'))

輸出結果：

我是zrh,個人進度已經完成80%

三.進制轉換

進制也就是進制位，咱們經常使用的進制包括：二進制、八進制、十進制與十六進制，它們之間區別在於數運算時是逢幾進一位。好比二進制是逢2進一位，十進制也就是咱們經常使用的0-9是逢10進一位，16進制的10-15用A、B、C、D、E、F來表示。

1. 十進制轉二進制

方法爲：十進制數除2取餘法，即十進制數除2，餘數爲權位上的數，獲得的商值繼續除2，依此步驟繼續向下運算直到商爲0爲止。

2. 二進制轉十進制

方法爲：把二進制數按權展開、相加即得十進制數。

第一個的1*2的7次方，是由於數位就是8位，8-1=7，依此類推。

四. 數據類型

Python有五個標準的數據類型：

Numbers（數字） V = 1 int類

Boolean value（布爾值） V = True （bool類）

String（字符串） V = 「Good」 （str類）

List（列表） V = [「good」,」best」] （list類）

Tuple（元組） V = (「good」,」best」) （tuple類）

Dictionary（字典） V = {「name」:」zrh」,」age」:20} （dict類）

1.int類（記住一個）

bit_length()表示當前十進制數用二進制數表示時，最少使用的位數。

代碼示例：

count = 16 v = count.bit_length() print(v,"---",count)

輸出結果：

5 --- 16

注意： 

 1 count = "1"
 2 count1 = "2"
 3 print(count+count1)  #輸出結果：12 字符串的加法是拼接的做用
 4 count2 = 1
 5 count3 = 2
 6 print(count2+count3)  #輸出結果：3 數字的加法是加法做用
 7 #需求，輸入一個數字，而後每一個數字相加，列入輸入152，結果就是1+5+2
 8 count4 = "152"  #在數字和字符串中只有字符串才能夠遍歷，因此要把count4轉爲str類型
 9 val = 0 10 for i in range(len(count4)): 11     val += int(count4[i])   #count4[i]是字符串，因此要轉爲數字才能相加
12 print(val) 

浮點數：

2.str類

對於字符串，執行內置命令後，原來的值不變。

2.1：upper()轉換字符串中的小寫字母爲大寫

代碼示例：

name = "zrh" v = name.upper() print(v,"---",name)

輸出結果：

ZRH --- zrh

2.2：lower()轉換字符串中全部大寫字符爲小寫

代碼示例：

name = "ZrH" v = name.lower() print(v,"---",name)

輸出結果：

zrh --- ZrH

2.3：capitalize()將字符串的第一個字符轉換爲大寫

代碼示例：

name = "zrh" v = name.capitalize() print(v,"---",name)

輸出結果：

Zrh --- zrh

2.4：strip()去除首尾的內容 空格、換行符、製表符、指定內容

代碼示例：

name = " zrh " v = name.strip() print(v+"---",name)

輸出結果：

zrh---  zrh

1 name_1 = "\tzrh\t"
2 print(name_1) 3 print(name_1.strip())

輸出結果：

    zrh

zrh

1 name_1 = "zrh"
2 print(name_1) 3 print(name_1.strip("h"))

輸出結果：

zrh
zr

2.5：lstrip()截掉字符串左邊的空格或指定字符

2.6：rstrip()刪除字符串字符串末尾的空格

2.7：replace(str1, str2 , max)將字符串中的 str1 替換成 str2,若是max指定，則替換不超過max次

代碼示例：

content = "人生自古誰無死，早死晚死都得死" v = content.replace("死","*",2) print(v,"---",content)

輸出結果：

人生自古誰無*，早*晚死都得死 --- 人生自古誰無死，早死晚死都得死

2.8： len(string)返回字符串長度

代碼示例：

content = "人生自古誰無死，早死晚死都得死" v = len(content) print(v)

輸出結果：

15

2.9：[]根據索引取值

代碼示例：

#索引值從0開始計算不是從1
content = "人生自古誰無死，早死晚死都得死" v = content[0]       #取字符串的第一個字符
v1 = content[-1]     #-表明從後往前找，1表明第一個，因此-1表明正向的最後一個
v2 = content[0:5]    #從0開始取到索引值爲4的對象，不包括索引值爲5的對象，至關於數學中的左閉右開區間
v3 = content[8:]     #從索引值爲8的對象開始取到最後一個
v4 = content[0:15:2]  #從0開始隔一個取一個，一直取到14，2表步長表示隔一個取一個，3就表示隔2個
print(v,v1,v2,v3,v4)

輸出結果：

人 死 人生自古誰 早死晚死都得死 人自誰死遲早都死

2.10 ：split(「str」,num)  （）裏沒有參數的話，默認是空格

以 str 爲分隔符截取字符串，若是 num 有指定值，則僅截取 num+1 個子字符串

代碼示例:

content = "人生自古誰無死，早死晚死都得死" v = content.split("死",2) print(v)

輸出結果：

['人生自古誰無', '，早', '晚死都得死']

2.11 ：.isdecimal()判斷當前字符串中是否所有都是數字

代碼示例:

v = "a123" c = v.isdecimal() print(c)

輸出結果：

False

補充：

python中isdigit()、isdecimal()和isnumeric的區別　　

a = "good 1 night 2" a.isdecimal() #若是a中只有十進制字符，則返回True，不然爲False
a.isdigit()      #若是a中的全部字符都是數字，而且在S中至少有一個字符，則返回True
a.isnumeric()    #若是a中只有數字字符，則返回True，不然爲False

 

2.12 ：join(seq) 以指定字符串做爲分隔符，將 seq 中全部的元素(的字符串表示)合併爲一個新的字符串

seq裏的元素必須是字符串，不能是數字，數字和字符串（前面的「_」）不能相加，

代碼示例:

list1 = ['alex','zrh','sdv'] a = '_'.join(list1)             #這裏的_就表示用_鏈接
b = "".join(list1)              #""裏什麼都沒有表示直接鏈接
print(a) print(b)

輸出結果：

alex_zrh_sdv

alexzrhsdv

2.13：把字符串轉換成字節encode（）

name = "天下" name.encode("utf-8")   #把字符串（Unicode）轉換成字節（utf-8格式）
name.encode("gbk")     #把字符串（Unicode）轉換成字節（gbk格式）

 2.14：count() 

count() 方法用於統計字符串裏某個字符出現的次數。可選參數爲在字符串搜索的開始與結束位置。

1 name = "ooxxooxxooxx"
2 print(name.count("o")) 3 #有兩個參數，不寫默認爲print(name.count("o",0,len(name)))
4 #0表示條件統計起始索引值，len(name)表示終止索引值

2.15：expandtabs() 方法把字符串中的 ('\t')轉爲空格，('\t')默認的空格數是 8

\t 表示橫向製表符  \n表示換行符

1 name = "ID\tname\tpasswd\n1\tzrh1\t123\n2\tzrh2\t123"
2 val = name.expandtabs(20)   #20表示連同\t前面的內容一共佔20個字符的位置
3 print(val)

輸出結果：

2.16其餘不經常使用的方法彙總：

五.格式轉換

1.數字轉字符串 str(對象)

2.字符串轉數字 int(對象)

對象必須是形爲數字，才能轉換

Int(string)就會報錯

3.數字轉布爾值 bool(對象)

bool(0)是False

其餘不是0的數都是True

可是在其餘方面true = 1 flase = 0

4.字符串轉布爾值 bool(對象)

bool(「」)是False

其餘任何字符串都是True

注意：

代碼示例：

a = 9 or 2>3
print(a)

輸出結果：

9

代碼示例：

a = 0 or 2>3
print(a)

輸出結果：

False

代碼示例：

a = 0 or 6
print(a)

輸出結果：

6

代碼示例：

a = 0 or 2<3
print(a)

輸出結果：

True

5.元組轉列表

v = (1,2,3) val = list(v)

6.列表轉元組

v = [1,2,3] val = tuple(v)

7.列表轉字符串

v = ["1","2","3"] result = "".join(v) print(result)

六.列表

列表是Python中最基本的數據結構。列表中的每一個元素都分配一個數字 - 它的位置，或索引，第一個索引是0，第二個索引是1，依此類推。

建立一個列表，只要把逗號分隔的不一樣的數據項使用方括號括起來便可。

以下所示：

list = ["one","two",3,4,"five"]

列表能夠進行 增、刪、改、查。若是列表只有一個對象，在後面也要加上，

列表中的元素能夠是 數字、字符串、布爾值、列表（列表的嵌套）

複製列表：

a = [1,2,3] b = a[:]      #[:]是複製列表
print(a,b)     

1.查 切片：

list[1:]      #從1開始取到最後 
list[1:-1]    #從1開始取到倒數第二值
list[1:-1:1]   #從左到右一個一個去取，取到倒數第二值
list[1::2]     #左到右隔一個去取
list[3::-1]     #從3開始從右到左一個一個取，注意索引值不變

2.增  添加：

2.1：append()

append(「str」)將數據插到最後一個位置

代碼示例：

list = ["one","two",3,4,"five"] list.append("six") print(list)

輸出結果：

['one', 'two', 3, 4, 'five', 'six']

append()注意事項：

1 list1 = [11,22,33] 2 val = list1.append(44) 3 print(val) 4 #這裏返回的是None，對於列表來講，執行方法以後改變的是原來的值，變量接收不到

 

2.2：insert()

根據索引值位置將數據插入到任意一個位置

代碼示例：

list = ["one","two",3,4,"five"] list.insert(2,"two2")     #想把新對象插在什麼位置就輸入相應的索引值
print(list)

輸出結果：

['one', 'two', 'two2', 3, 4, 'five']

3.改  修改：

想要修改首先得用切片把相應的值取出來，在進行賦值便可。

代碼示例：

list = ["one","two",3,4,"five"] list[1] = 2   #將索引值爲1的對象取出來，再從新賦值
print(list)

輸出結果：

['one', 2, 3, 4, 'five']

需求：將list = ["one","two",3,4,"five"]這個列表裏的two 和 4 修改爲 2 和 four

代碼示例：

list = ["one","two",3,4,"five"] list[1:4:2] = [2,"four"] print(list)

輸出結果：

['one', 2, 3, 'four', 'five']

注意：在list[1:4:2] = [2,"four"]中，由於list[1:4:2]輸出得是一個列表，因此等號右邊也必須是個列表

4.刪 刪除：

4.1：remove

remove只能刪除一個，而且（）裏填寫的是對象內容

代碼示例：

list = ["one","two",3,4,"five"] list.remove("two")     #刪除two
print(list)

輸出結果：

['one', 3, 4, 'five']

4.2 ：pop 

pop刪除的時候（）裏是填寫索引值，而且還能夠將刪除數據返回出來，若是括號裏面不填索引值，即pop（），則默認刪除最後一個值。

代碼示例：

list = ["one","two",3,4,"five"] a = list.pop(1)    #刪除 two
print(list,a)

輸出結果：

['one', 3, 4, 'five'] two

4.3 ：del什麼均可以刪除

代碼示例：

list = ["one","two",3,4,"five"] del list[0]    #刪除 one
print(list)

輸出結果：

['two', 3, 4, 'five']

5.列表的其餘操做

5.1 ：count:計算某元素出現次數

代碼示例：

list = ["one","two",3,4,"five"] v = list.count("two")   #計算two出現的次數
print(v)

輸出結果：

1

5.2：extend：用於在列表末尾一次性追加另外一個序列中的多個值，括號中必須是可迭代對象，能夠理解爲批量的append（）

代碼示例：

a = [1,2,3] b = [4,5,6] a.extend(b) #把b加到a裏面
print(a) print(b)

輸出結果：

[1, 2, 3, 4, 5, 6]

[4, 5, 6]

5.3：index根據內容找位置,輸出得是第一個匹配內容的索引位置

代碼示例：

list = ["one","two",3,4,"five"] T = list.index("five")      #查找five的索引值
print(T)

輸出結果：

4

5.4 合集

1.reverse：用於反向列表中元素

2.sort：對原列表進行排序

reverse -- 排序規則，reverse = True 降序（由大到小）， reverse = False 升序（由小到大）（默認）

3.in：查一個數據在不在列表內

4.type：身份判斷：判斷一個對象是否是列表

代碼示例：

list0 = ["one","two",str(3),str(4),"five"] list0.reverse() #反向列表中元素
print(list0) list0.sort(reverse=True)    #由大到小de對原列表進行排序
print(list0) a = "six" in list0         #判單six在不在列表裏
print(a) b = type(list0) is list     #判斷list0是否是列表
print(b)

輸出結果：

['five', '4', '3', 'two', 'one']

['two', 'one', 'five', '4', '3']

False

True

6.列表練習題：

list = ["one","two",3,4,"five","天才"]

把list列表中的天才的 天 改爲 蠢

代碼示例：

list = ["one","two",3,4,"five","天才"] v = list[5].replace("天","蠢") list[5] = v print(list)

輸出結果：

['one', 'two', 3, 4, 'five', '蠢才']

注意：字符串不能經過索引值修改，只能經過索引值取出來。（⬇）

7.補充：

需求：索引爲奇數值，刪除
注意：刪除列表元素時，會影響列表長度，從而使得索引取值時，容易出現錯誤。

li = [11,22,33,44,66] # 解決方案一：
li = [11, 22, 33, 44, 66] # 0
new_list = [] for i in range(0,len(li)): if i%2 == 0: new_list.append(li[i]) li = new_list print(li) # 解決方案二：
 li = [11, 22, 33, 44, 66] # 0
 for i in range(len(li)-1,-1,-1): # 4,0
    if i%2 == 1: del li[i] print(li) #解決方案三：切片+步長
li = [11, 22, 33, 44, 66] del li[0:4:2] print(li)        

七.元組

Python 的元組與列表相似，不一樣之處在於元組的元素不能修改。

元組使用小括號，列表使用方括號。

元組建立很簡單，只須要在括號中添加元素，並使用逗號隔開便可。

1. 建立空元組

tup1 = ()

2. 元組中只包含一個元素時，須要在元素後面添加逗號，不然括號會被看成運算符使用：

代碼示例：

tup1 = (50) print(type(tup1))     # 不加逗號，類型爲整型
tup1 = (50,) print(type(tup1))     # 加上逗號，類型爲元組

輸出結果：

<class 'int'>

<class 'tuple'>

3. 元組可使用下標索引來訪問元組中的值

4. 能夠對元組進行鏈接組合

5.元組能夠計算長度len()

6.元組中的元素值是不容許刪除的，但咱們可使用del語句來刪除整個元組

7.重點：

元組的兒子不能修改，可是孫子能夠，元組的元素不能修改，可是元組的元素的元素是能夠修改的。

代碼示例：

tuple1 = ("one","two","three",[1,2,"zrh"],(1,2,3),"four") tuple1[3][1] = 3
print(tuple1) tuple1[3].append("q") print(tuple1)

輸出結果：

('one', 'two', 'three', [1, 3, 'zrh'], (1, 2, 3), 'four')

('one', 'two', 'three', [1, 3, 'zrh', 'q'], (1, 2, 3), 'four')

八.字典

字典是另外一種可變容器模型，且可存儲任意類型對象。

字典的每一個鍵值(key=>value)對，用冒號(:)分割，每一個對之間用逗號(,)分割，整個字典包括在花括號({})中

鍵必須是惟一的，但值則沒必要。

值能夠取任何數據類型，但鍵必須是不可變類型。

不可變類型：整型、字符串、元組

可變類型：字典、列表

格式：變量名 = {鍵:值,鍵:值}

代碼示例:

dict1 = { "name":"zrh", "age":20, "height":75 }

1.：dict.get

1.1經過鍵取值

代碼示例：

dict1 = { "name":"zrh", "age":20, "height":75 } print(dict1.get("name"))

輸出結果：

zrh

1.2（）參數，若是鍵不存在，就用後面的結果看成默認值。

代碼示例：

dict1 = { "name":"zrh", "age":20, "height":75 } print(dict1.get("key",999))

輸出結果：

999

2.：dict.keys() 、 dict.values() and dict.items()

常常和for循環一塊兒使用

字典在for循環的時候儘可能不要用兩個變量去分別接收 鍵 和 值，這樣會形成內存負荷過大，能夠先遍歷鍵，而後經過鍵去找值

代碼示例：

dict1 = { "name":"zrh", "age":20, "height":75 } a = dict1.keys()         #查看全部鍵
print(type(a))           #查看a的類型
print(a) print(dict1.values())    #查看全部值
print(dict1.items())     #查看全部鍵值對

輸出結果：

<class 'dict_keys'>

dict_keys(['name', 'age', 'height'])

dict_values(['zrh', 20, 75])

dict_items([('name', 'zrh'), ('age', 20), ('height', 75)])

for循環注意事項：

1 dict1 = {} 2 for key in dict1: 3     pass
4 for key in dict1.items(): 5     pass
6 for key in dict1.keys(): 7     pass
8 for key in dict1.values(): 9     pass

注意dict1後面括號的有無

3.增長鍵值對

代碼示例：

dict1 = { "name":"zrh", "age":20, "height":75 } dict1["hobby"] = "eat"
print(dict1)

輸出結果：

{'name': 'zrh', 'age': 20, 'height': 75, 'hobby': 'eat'}

若是增長的鍵已經存在，那就是改的功能。

4.刪除

代碼示例：

dict1 = { "name":"zrh", "age":20, "height":75 } del dict1["name"]     #刪除指定鍵值對
print(dict1) dict1.clear() print(dict1)         #清空字典中全部鍵值對，但空字典還存在
dict2 = { "name":"zrh", "age":20, "height":75 } a = dict2.pop("name")    #經過鍵去刪除，並能夠返回相應的值
print(a) print(dict2) b = dict2.popitem() print(b) print(dict2)            #隨機刪除一對鍵值對，而且返回相相應鍵值對

輸出結果：

{'age': 20, 'height': 75}

{}

zrh

{'age': 20, 'height': 75}

('height', 75)

{'age': 20}

5.嵌套

字典裏面可嵌套字典或者列表均可以，列表頁均可以嵌套字典。

在修改時，遇到字典用鍵，遇到列表用索引值，而後查找出來以後賦值便可，其餘操做同樣，反正一句話：

遇到字典用鍵，遇到列表用索引值。

6.update()用於將括號中的鍵值對添加到目標對象中，若是括號中的鍵在目標對象中存在，則更新目標對象的值

1 dict1 = { 2     'k1':'v1', 3     'k2':'v2', 4     'k3':'v3'
5 } 6 dict1.update({'k4':'v4','k1':'v11'}) 7 print(dict1) 8 #輸出結果：{'k1': 'v11', 'k2': 'v2', 'k3': 'v3', 'k4': 'v4'}

7.fromkeys（）建立字典

 1 #fromkeys使用的時候不是文件名. 是用dict.來調用
 2 val = dict.fromkeys(['k1','k2','k3'],666)   #將666做爲值賦給K1 K2 K3三個鍵
 3 print(val)          #輸出結果{'k1': 666, 'k2': 666, 'k3': 666}
 4 val['k1'] = 999     #給數字從新賦值，在內存中從新開闢一塊內存用來儲存999，而後k1指向999，原來的k2 k3值不變
 5 print(val)         #輸出結果{'k1': 999, 'k2': 666, 'k3': 666}
 6 
 7 val = dict.fromkeys(['k1','k2','k3'],[])  8 val['k1'].append(666)  9 val['k2'].append(999) 10 #k1 k2 k3指向的是同一個值，即[]，每次往裏加內容的時候 k1 k2 k3 的值都會發生變化
11 print(val)   #輸出結果{'k1': [666, 999], 'k2': [666, 999], 'k3': [666, 999]}
12 
13 val = dict.fromkeys(['k1','k2','k3'],[]) 14 val['k1'].append(666) 15 val['k1'] = [1,2,3]  #這裏是從新賦值操做，在內存中從新開闢一塊空間儲存[1,2,3],k1指向他，k2 k3值不變
16 print(val)  #輸出結果{'k1': [1, 2, 3], 'k2': [666], 'k3': [666]}

8.補充

# 題：dic = {'k1':"v1",'k2':'v2'}把key="k1",鍵值對刪除
del dic['k1'] # 題：dic = {'u1':"v1",'k2':'v2','k3':'v3'}把key中存在k,鍵值對刪除
dic = {'u1':"v1",'k2':'v2','k3':'v3'} # 不要在循環當前字典的過程當中，修改當前字典大小
錯誤方式： for key in dic: if 'k' in key: del dic[key] 正確方式 ： dic_key_list = [] for key in dic: dic_key_list.append(key) for row in dic_key_list: if 'k' in row: del dic[row] print(dic)    、