day02學習大綱

一. 格式化輸出:
    %s 佔位字串
    %d 佔位數字
    "xxx%sx %sxx" % (變數, 變數)

二. 運算子:
    a+=b  a = a + b

    and 並且. 左右兩端同時為真. 結果才能是真
    or 或者. 左右兩端有一個是真. 結果就是真
    not  非真既假, 非假既真

    順序: () => not => and => or

    a or b:
        如果a是0, 結果是b, 否則結果是a

    a and b : 和or相反

三. 編碼
    ascii : 8bit 1byte, 英文字母+ 數字 + 特殊符號
 

    gbk: 16bit 2byte, 主要是中文
    unicode: 32bit 4byte
    utf-8:
        英文:8bit 1byte
        歐洲:16bit 2byte
        中文:24bit 3byte

    encode()  編碼成bytes位元組
    decode()  解碼


四. 基本資料型別int和bool
    int bit_length()
    bool:
        資料型別的轉換
            True: 1
            False: 0
            0: False
            非0: True
 


        結論: 如果想把x轉化成y. y(x)
        結論: 所有的空都認為是False

五. 基本資料型別str
    索引和切片: 索引的下標從0開始
    切片: [p:q:r] 從p到q每隔r出來1個
        r如果是負數, 從右往左

    常用的操作:
        1. upper() 轉化成大寫.
        2. split() 字串切割. 切割的結果是列表
        3. replace() 字串替換
        4. stript() 去掉左右兩端的空白(空格, \t, \n)
        5. isdigit() 判斷是否是數字組成
        6. startswith()  是否以xxx開頭
 

        7. find() 查詢. 如果找不到返回-1

    內建函式:
        len()求字串長度.

    for迴圈
        for 變數 in 可迭代物件:
            迴圈體

    in 和 not in

六 列表和元組
    [元素, 元素]
    列表有索引和切片
    增刪改查:
        增加: append() insert()
        刪除: remove(元素) pop(索引)
        修改: lst[index] = 新元素
        查詢: lst[index]
            for item in lst:
                迴圈體

    深淺拷貝:
        1. 賦值. 沒有建立新列表
        2. 淺拷貝. 只拷貝表面(第一層)
        3. 深拷貝. 全部都拷貝一份

    元組: 不可變, 主要用來儲存資料

    range(),可以讓for迴圈數數(重點中的重點)


七. 字典
    由{}表示. 以k:v形式儲存資料
    k必須可雜湊. 不可變

    增刪改查:
        1. 新增: dic['新key'] = 新value, setdefault(key, value)
        2. 刪除: pop(), del, cleart()
        3. 修改: dic[key] = value
        4. 查詢: get(), dic[key], keys(), values(), items()

        迴圈(必須要掌握):
            1. for k in dic:
                    k
                    dic[k]

            2. for k, v in dic.items():
                    k
                    v
八: set集合
    特點: 無序, 不重複, 元素必須可雜湊
    add() 新增

九: is和==
    is判斷記憶體地址
    ==判斷資料

十: 列表和字典的迴圈
    在迴圈列表和字典的時候. 不能刪除原來列表和字典中的內容
    把要刪除的內容記錄在新列表中. 迴圈這個新列表. 刪除老列表

下週要預習:
    1. 檔案操作

    2. 函式 

 

 

一、格式化輸出

%s是佔位字元數,實際可以佔位任何東西，%s用的比較多.

%d要佔位整數,只能佔位數字，這時對應的資料必須是int型別. 否則程式會報錯.一般用的不多.

例：現在有以下需求,讓⽤使用者輸入name, age, job,hobby 然後輸出如下所⽰示:

 例2:製作標準化的名片,分別輸入name,job,address,phone.自動生成名片.

程式碼如下：

name = input("請輸入你的名字:")
job = input("請輸入你的工作:")
address = input("請輸入你的地址:")
phone = input("請輸入你的電話:")


print('''
===============%s==================
==Name: %s=========================
==Job:  %s==========================
==Address: %s====
==Phone: %s==========================
========================================
''' % (name, name, job, address, phone))

 如果Python3.6以上,可以使用模板字串模板字串f”{}”，例如：

name = "wusir"
hobby = "playing basketball"
print("%s love %s." %(name,hobby))
print(f"{name} love {hobby}")

當出現2%或3%等%號時，使用2%%表示：例如：

hobby = "playing basketball"
print("80%% of children love %s" %hobby)

二、基本運算子

計算機可以進⾏行行的運算有很多種，可不不只加減乘除這麼簡單，運算按種類可分為:算數運算、比較運算、邏輯運算、賦值運算、成員運算、身份運算、位運算.

1、算數運算（a=10，b=20）

2、比較運算

==和is的區別

== 比較的是資料,這兩個人長得是不是一樣的

Is 比較的是記憶體地址,這兩個人是不是同一個人

例如：下列程式，第一個是True，第二個是False。

lst=[1,2,3]
lst2=[1,2,3]
print(lst==lst2)
print(lst is lst2)

 

 3.賦值運算

[右邊是變數] = 把右邊的值賦值給左邊的變數,其優先順序是最低的.右邊的東西必須向執行.

 

 4.算邏輯運

(1)and 並且,只要有一個不成立,就是False,左右兩端同時為真,然後最終是真.比如：print（1>5 and 6>4）返回時false.

(2)or 或者,左右兩端有一個是真就是真.全部是假,結果才是假.

(3)not 不,非真既假,非假既真.

(4)如果出現混合邏輯運算,先算括號(),再算not,然後是and,最後是or.

例如:

返回:False

返回True 

(5)在計算機中:非1就是True,0就是False.如果a or b,if a==False 則結果是b,否則是a.

a or b:
    如果a=0 結果是b
    如果a=非0,結果是a
a and b:
    與a or b 相反.

 

    例題:

print(3>4 or 4<3 and 1==1)#False
print(1 < 2 and 3 < 4 or 1>2)#True
print(2 > 1 and 3 < 4 or 4 > 5 and 2 < 1)#True
print(1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8)#False
print(1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6)#False
print(not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6)#False

print(8 or 4)#8
print(0 and 3)#0
print(0 or 4 and 3 or 7 or 9 and 6)#3

 

 

三、編碼的問題

ascii : 8bit 1byte, 英文字母+ 數字 + 特殊符號
gbk: 16bit 2byte, 主要是中文
unicode: 32bit 4byte
utf-8:
  英文:8bit 1byte
  歐洲:16bit 2byte
  中文:24bit 3byte

encode()  編碼成bytes位元組
decode()  解碼

(1)美國人發行的計算機使用的編碼是ASCII.裡面編碼的內容都是美國人編碼的方式,所以ASCII碼中就是英文字母+數字+鍵盤上的特殊符號+操作符的編碼.

(2)編碼就是用特定的排列組合來表示我們的文字資訊.計算機底層只認識0和1.

(3)在A由於SCII碼中使用8位01組合來表示的一個ASCII碼的字元.最開始只有7位,但是計算機對7不敏感,整整128個,所以為了拓展,增加了一位,變成了8byte=8bit.ASCII是隻有7位是有效的,最前面的那位是空著的,0111 1111

(4)ASCII碼沒有中文標準,提出一個標準ANSI,在ASCII中擴充套件1倍.可以相容ASCII碼.即0000 0000 0111 1111

(5)給各個國家進行編碼.就產生了,中國GB2312.由於GB2312逐漸擴充套件,產生了國標擴充套件碼:GBK.中國的計算機上就是GBK.臺灣用的大五碼big5

(6)GBK共65000多個,包含了中文\中國鄰國的文字\韓文\日文\繁體字.如果不能顯示,就會顯示????

(7)如果中國人使用德國的文字,中國的文字看不到歐洲的文字.就產生了國與國的交流碼.產生了Unicode(萬國碼),需要擴容到了32bit.us2和us4(32bit)即:print(2**32)共42億文字.

(8)早起的Unicode無法使用,因為(1)太大了.比ASCII碼增加了8倍,即1M的英文就產生了4M的空間.(2)網路傳輸:傳輸慢,費用高.

(9)隨著機能的提高和utf-8的產生,Unicode可以使用了.把Unicode重新定.義,可變長度的Unicode=>tuf-8和utf-16.

Utf-8:最小位元組單位是8bit

Utf-16:最小位元組單位是16bit

(9)我們用的最多的是utf-8,是從Unicode來的.

　　1)英文:8位,ASCII碼的東西還是ASCII碼.

　　2)歐洲的文字佔16位;

　　3)中文佔24位,因為中文有9萬多個,如果出現亂碼用utf-8後GBK處理.

(10)Python2預設是ASCII,Python3記憶體使用的Unicode,檔案儲存使用的utf-8. 記憶體使用Unicode是可以的,因為記憶體是實時回收的.記憶體是可以浪費的.而硬碟是不能超標的.

(11)想要儲存,必須進行轉換成utf-8或GBK

一個字是3個位元組,古力娜扎四個中文就是12個位元組.

12.位元組的作用就是儲存和傳輸.

13.GBK的編碼 一箇中文2個位元組,古力娜扎一共8個位元組.

　　14.編碼encode(得到的是byte型別)\解碼 decode(得到的是字串)

　　用什麼編碼,用什麼解碼.

即:bs.encode(“utf-8”)  解碼也必須用utf-8 即 bs.decode(“utf-8”).同理GBK.

15.字串

0,1=>1bit

8bit =>1byte

1024byte=>1kb

1024kb=>1mb

1024mb=>1gb

 

 

四、 基本資料型別int和bool 

    int bit_length()
    bool:
        資料型別的轉換
            True: 1
            False: 0
            0: False
            非0: True

        結論: 如果想把x轉化成y. y(x)
        結論: 所有的空都認為是False

 

1.基本資料型別:int型別的資料,基本運算.只有一個應用,bit_length()二進位制長度. 

 

0=>False

非0=> True  與正負號無關

2.While 1 和while True的區別,while 1會效率高一點.

3.你想把x轉換成y,需要y(x)

例如:print(bool(“”))#能夠表示False的字串是假.

4.所有表示空的東西都是假.

比如:print(bool([0]))#列表有東西就是真. print(bool([]))#列表沒有東西,就是假. print(bool(none))#none:空,真空,是假.其作用最主要的就是佔位.

 

五、 基本資料型別str

 

    索引和切片: 索引的下標從0開始
    切片: [p:q:r] 從p到q每隔r出來1個
        r如果是負數, 從右往左

    常用的操作:
        1. upper() 轉化成大寫.
        2. split() 字串切割. 切割的結果是列表
        3. replace() 字串替換
        4. stript() 去掉左右兩端的空白(空格, \t, \n)
        5. isdigit() 判斷是否是數字組成
        6. startswith()  是否以xxx開頭
        7. find() 查詢. 如果找不到返回-1

    內建函式:
        len()求字串長度.

    for迴圈
        for 變數 in 可迭代物件:
            迴圈體

    in 和 not in

 

一、字串str:由單引號\雙引號\三引號\三雙引號括號引起來的內容.即:引號引起來的都是字串. 

單引號中不能有單引號

雙引號中可以有單引號.

單引號和雙引號都是單行的.如果回車就會出現\ 表示下面內容和本行是同一行程式碼

三引號表示的是一段字串,可以多行.

二、字串的索引和切片

1、索引就是第幾個字元,索引從0開始.

正序:012

倒敘:-3,-2.-1

[]表示索引.

-1表示倒數第一個

s = "jay"
print(s[1])#a
print(s[2])#y
print(s[-1])#y
print(s[-3])#j

2、切片:拿到字串的一部分

1)顧頭不顧尾,比如[4:8]取的是4,5,6,7不能取8.

2)預設順序:從左到右.比如[8:4],不能切出來.從8往後找不到4.

3)還可以負數切,比如[-6:-2],

4)[6:]#表示,從-6開始切到最後.

5)[:6]#表示從頭開始切,切到6位

6)[:]#從頭切到尾.

 

 

s = "jay is a asshole!!!!"
print(s[4:8])#is a
print(s[8:4])#none
print(s[-6:-2])#le!!
print(s[6:])# a asshole!!!!
print(s[:6])#jay is
print(s[:])#jay is a asshole!!!!
print(s[2:8:3])#ys

 

3、帶有步長的切片

#每2個出來一個

#步長可以為負數,表示從右到左.

#[::-1]#相當於從右到左一個一個數,整個句子放過來.

s = "jay is a asshole!!!!"
print(s[3:8:2])#從3到8,每2個出來1個
print(s[::2])
print(s[-1:-6:-2])

 

 三、字串大小轉換

1.首字母大寫capitallize:字串是不可變的資料型別.比如下面這個程式不能首字母大寫.每次操作都會返回新字串.

S還是原來的字串alex

只能把改變的s賦值給S1,才能顯示Alex. 

s = "jay is a asshole!!!!"
s1=s.capitalize()
print(s)#jay is a asshole!!!!
print(s1)#Jay is a asshole!!!!

 

2.所有字母大寫:upper；全部轉成成小寫:lower,對一些歐洲文字不敏感.

 

s = "Jay Is a Asshole!!!!"
s1=s.upper()
s2=s.lower()
print(s)#Jay Is a Asshole!!!!
print(s1)#JAY IS A ASSHOLE!!!!
print(s2)#jay is a asshole!!!!

 

例如:讓使用者輸入的字母,需要忽略大小寫. 

s="Q"
while True:
    game = input("Please input your favorite games:"
                 "Or input Q to exit")
    if game.upper()==s:
        break
    print("Your favorite game:%s" %game)

 

 

3.title()標題:每個單詞的首字母大寫.

s = "Jay Is a Asshole!!!!"
s1=s.title()
print(s1)#Jay Is A Asshole!!!!

 

 4.字串切割:split()#把字串切成很多段,預設用空白切割.比如以a為切口,那麼打印出來列表,沒有a了.

如果沒有切的刀,所以原有的字串還是原有的字串.

如果刀卡到了邊緣.只要下刀了,至少會有兩段,用’’空字串表示.如果下刀的地方是邊緣,一定能獲得空字串.

 

 

s = "alex_wusir_taibai"
ret = s.split("_")
print(ret)#['alex', 'wusir', 'taibai']
print(type(ret))#<class 'list'>

 

5.字串的替換:replace

s = "alex_wusir_taibai"
ret=s.replace("sir","先生")
print(ret)

 

6.strip() 去左右兩端的空白,=>脫掉空白

\t #tab,就空格,即製表符,首行縮排2個字元.

　\n #newlines 換行

s = "\talex_wusir\t_taibai\t"
ret=s.strip()
print(s)#    alex_wusir    _taibai 前後有空格
print(ret)#alex_wusir    _taibai

 

應用：防止客戶輸入的alex+空格,無法檢查出來

Strip(“a”)去掉字串兩端的a.

username = input("使用者名稱:").strip()
password = input("輸密碼:").strip()
if username == "ken" and password =="123":
    print("登入成功!")
else:
    print("使用者名稱或密碼錯誤")

 

7.判斷這句話是否是***開頭,start.with()   判斷是以***結尾endwith()
例如：一般應用於判斷姓氏。判斷開頭或結尾是不是“alex”

s = "alex_wusir_taibai"
print(s.startswith("alex"))#True
print(s.endswith("alex"))#False

8.count(“a”)#計算某XX出現的次數.
9.s.find()#找到是索引
如果不存在,返回-1
如果存在,從左到右,第一個位置.

s = "alex_wusir_taibai"
print(s.count("a"))#3
print(s.find("a"))#0
print(s.find("i"))#8

 

 

10.isdigit()#判斷是否為數字構成.
11.isalpha()只能判斷非數字,判斷是否由文字的基礎組成.所以加上華辣湯後也是True.
12.isalnum判斷是否由數字和字母構成,能遮蔽特殊字元.
13.isnumeric():能判斷中文的數字,但不認識”兩”和”倆”.

s = "asd123"
a = "壹貳三四"
print(s.isdigit())#False
print(s.isalpha())#False
print(a.isnumeric())#True
print(s.isalnum())#True

 

14.len()#求字串的長度,內建函式

例如：比如列印“kenments”每個字母

s = "kenments"
i=0
while i<len(s):
    print(s[i])
    i+=1

 

15.for迴圈，比上面案例更簡單

for 變數 in 可迭代(iterable)物件:

    迴圈體

#可迭代:能夠一個一個的拿出來,拍出來.字串就是可迭代物件.

#把字串的中每個一個字元賦值給變數c

s = "kenments"
for c in s:
    print(c)

 

C就是字元變數a,l,e,x.

#但是數字不能放,比如 for i in 10:

16. in/not in #成員運算,

比如判斷某某是我們班的成員.應用最多的方面就是評論區/禁言等敏感字詞.

比如:s=”alex特別喜歡麻花藤”#麻花藤是敏感詞.

s ="ken is a good man!"
if "ken" in s:
    print("sorry,you can't write")
else:
    print("OK,No problem!")

 

8.while…else…

 

For…else…

 

和if…else…一樣的

Break不會執行else,他直接打斷這個迴圈,不執行else,這是一個大坑.

For迴圈和while迴圈一樣,也可以使用break\continue和else.

For只有迭代完成後,才執行else.

i=0
while i<100:
    print(i)
    if i == 66:
        break
    i+=1
else:
    print("It's Done")

 

六、列表和元組

（一）列表:能裝物件的物件:一個能裝東西的物件,比如把東西裝包裡.

 

列表是一個可迭代物件,可迴圈

存在的意義:儲存大量的資料.

(1)如果字串的話,需要切片,比較麻煩.

(2)列表使用[]括起來,內部元素用,逗號隔開.

List=[“張三丰”,”張無忌”,”張無忌”]

(3)列表和字串也有索引和切片

Print(list[1])#索引張無忌

Print(list[1::2])#切片

list = ["Ken","Lucy","Tom","John"]
print(list[1])#索引 Lucy
print(list[::2])#切片#['Ken', 'Tom']
print(list[-1::-2])#從右每2個切#['John', 'Lucy']

 

(4)列表的增刪改查

#增加

1)append:追加,向列表的最後放資料.

空列表的建立:list[]或list()
append只能參加一個

list = []
list.append("lucy")
list.append("ken")
print(list)#['lucy', 'ken']

 

2)insert()#插入\加塞

下面存在問題,後排的位置都後移,效率較低.

list = ["Ken","Lucy","Tom","John"]
list.insert(2,"Lily")
print(list)

 

3)迭代新增:extend()

一個一個的疊加.

主要應用在兩個列表中,進行融合.

list = ["Ken","Lucy","Tom","John"]
list.extend("獸獸")
list.extend("Lily")
print(list)#['Ken', 'Lucy', 'Tom', 'John', '獸', '獸', 'L', 'i', 'l', 'y']

 

兩個列表融合

list = ["Ken","Lucy","Tom","John"]
list1 = ["大米","玉米","石頭"]
list.extend(list1)
print(list)#['Ken', 'Lucy', 'Tom', 'John', '大米', '玉米', '石頭']

 

#刪除

1)   pop(1)#制定位置刪除

2)   remove(“麻花藤”)#刪除,制定某個元素刪除.

3)   Del list(3)#刪除第三個 

4)   List.clear#清空.

 

list = ["Ken","Lucy","Tom","John"]
list.pop(2)
print(list)#['Ken', 'Lucy', 'John']
list.remove("John")
print(list)#['Ken', 'Lucy']
del list[1]
print(list)#['Ken', 'Tom', 'John']
list.clear()
print(list)#[]

 

#修改

 list[1]=”東北一家人”#制定某位置的元素,修改成XXX

最常用的索引修改.

list = ["Ken","Lucy","Tom","John"]
list[1]="大米"
print(list)#['Ken', '大米', 'Tom', 'John']

 

#查詢+成員判斷

list = ["Ken","Lucy","Tom","John"]
list[1]="大米"
print(list)#['Ken', '大米', 'Tom', 'John']
print(list[2])#Tom
for item in list:
    print(item)#列印每個元素
print("大米" in list)#True#成員判斷

 

#list.sort() 排序,升序

#list.reverse() 降序

list = ["Ken","Lucy","Tom","John"]
list1 = [1,6,5,4,36]
list.sort#['John', 'Ken', 'Lucy', 'Tom']
list.reverse()
print(list)#['Tom', 'Lucy', 'Ken', 'John']
list1.sort()
print(list1)#[1, 4, 5, ()
print(list)6, 36]
list1.reverse()
print(list1)#[36, 6, 5, 4, 1]

 

#深淺拷貝

1)Python中的賦值

Python內部的執行過程,比如a=10,在記憶體先給10,然後想辦法給a,a通過記憶體地址1A2B,找到10.

如果變數a賦值20,那麼20的記憶體地址eee,則a通過記憶體eee,找到20.

如果b=a,彼此a放的是eee,所以變數賦值b為記憶體地址eee.所以a和b是同一個資料.

 賦值操作沒有拷貝,是同一個地址.

a = [1,6,5,4]
b =a
b.append(888)
print(a)#[1, 6, 5, 4, 888]
print(b)#[1, 6, 5, 4, 888]

賦值操作沒有建立新列表.

如果b=a[:]#此時對a進行了複製.此時建立了新的列表.

a = [1,6,5,4]
b =a[:]
b.append(888)
print(a)#[1, 6, 5, 4]
print(b)#[1, 6, 5, 4, 888]

 

2)淺拷貝:先按照樣子複製一個新記憶體地址.記憶體地址不一樣.給a新增444,b不變.

淺拷貝的問題就是隻抄個地址.其有附件就有問題.

3)這就是深拷貝,其問題的情況需要複製一份自地址.

一般情況使用淺拷貝,省記憶體.如果涉及到兩個操作,都有可能操作你的列表,那此時需要深拷貝.

a = [1,2,3,4,[5,6,7],[7,9,8],"附件1"]
b = a.copy()
c = a.deepcopy()
b.append("444")
print(a)#[1, 2, 3, 4, [5, 6, 7], [7, 9, 8], '附件1']
print(b)#[1, 2, 3, 4, [5, 6, 7], [7, 9, 8], '附件1', '444']#b不能copy附件1
print(c)#[1, 2, 3, 4, [5, 6, 7], [7, 9, 8], '附件1', '444']#c不能copy附件1

 

 

 (二)元組

元組是不可變的列表:只能看,不能幹

元組用小括號()表示,並且空元祖用tuple(),如果元組中只有一個元素,必須在後面加逗號.

但如果只有一個元素,比如tu=(1)或tu=(“sjdkf”),那麼統type的格式int和str.因此元組後面必須加逗號,如:tu=(“sd”,)

元組是可迭代的

ken=("金庸","古龍","黃奕","孫曉")
john=("金庸")
lily=("金融",)
print(type(ken),type(john),type(lily))#<class 'tuple'> <class 'str'> <class 'tuple'>
for item in ken:
    print(item)#元組是可迭代的

 

 七.字典

1.字典的存在意義:就是快,根據hash值(散亂的)儲存的,字典中所有的key必須是可雜湊的.

2.字典用{}表示,以key:value的形式儲存資料.

3.{}大括號是字典,[]中括號是列表,()小括號是元組.

比如:

dictionary={
    "北京":"政治中心",
    "上海":"金融中心",
    "深圳":"改革中心",
    "臺灣":"收復重心"
}

 

 4.不可變就是hash值.

 

 ###查詢

 

要想查詢,必須知道key

dictionary={
    "北京":"政治中心",
    "上海":"金融中心",
    "深圳":"改革中心",
    "臺灣":"收復重心"
}
print(dictionary["北京"])#弊端就是:如果沒有這個可以,就會報錯.
print(dictionary["臺灣"])

print(dictionary["廣州"])#報錯

print(dictionary.get("廣州","沒有這個人" ))#沒有這個人

 

 

 

 

###新增

方法1:直接新增

dictionary={
    "北京":"政治中心",
    "上海":"金融中心",
    "深圳":"改革中心",
    "臺灣":"收復重心"
}
dictionary["重慶"]="辣椒之都"
print(dictionary)

 

 

 

dictionary={
    "北京":"政治中心",
    "上海":"金融中心",
    "深圳":"改革中心",
    "臺灣":"收復重心"
}
dictionary["重慶"]="辣椒之都"#不存在就新增
print(dictionary)#{'北京': '政治中心', '上海': '金融中心', '深圳': '改革中心', '臺灣': '收復重心', '重慶': '辣椒之都'}
dictionary["北京"]="外交中心"#存在就修改
print(dictionary)#{'北京': '外交中心', '上海': '金融中心', '深圳': '改革中心', '臺灣': '收復重心', '重慶': '辣椒之都'}

 

 

 

     方法2:dictionary.setdefault["西安","古都之城"]

 

#如果只有一個引數,value放空.如果有兩個引數,就可以新增.

Setdifault執行流程:

1.首先判斷你的key有沒有出現,如果出現了,就不執行任何操作,如果沒有出現,就執行新增.

2.不論前面是否執行新增,最後都會把對應的key的value查詢出來.

不管key:value存在不存在,都查出一個結果.

dictionary={
    "北京":"政治中心",
    "上海":"金融中心",
    "深圳":"改革中心",
    "臺灣":"收復重心"
}
dictionary.setdefault("西安","古都之城")
print(dictionary)#{'北京': '政治中心', '上海': '金融中心', '深圳': '改革中心', '臺灣': '收復重心', '西安': '古都之城'}
dictionary.setdefault("西安")
print(dictionary)#{'北京': '政治中心', '上海': '金融中心', '深圳': '改革中心', '臺灣': '收復重心', '西安': None}

 

 

 

 應用場景:對列表

 

[11,12,33,44,55,66,77,88,99],在key1放小於66,key2放大於60.

第一種方式:比較麻煩

lst= [11,22,33,44,55,66,77,88,99,100]
ret ={}
for item in lst:
    if item < 66:
        if not ret.get("key01"):
            ret["ken01"]=[item]
        else:
            ret["ken01"].append(item)
    else:
        if not ret.get("key02"):
            ret["key02"]=[item]
        else:
            ret["key02"].append(item)
print(ret)

 

 

 

第二種方法:

 

lst= [11,22,33,44,55,66,77,88,99,100]
ret={}
for item in lst:
    if item < 60:
        ret.setdefault("key01",[]).append(item)
    else:
        ret.setdefault("key02",[]).append(item)
print(ret)

 

 

 

###刪除

dic.pop(“alex”)#根據key去刪除

dic.clear()#清空

 

del dic[“wusir”]#根據key刪除.

 

dictionary={
    "北京":"政治中心",
    "上海":"金融中心",
    "深圳":"改革中心",
    "臺灣":"收復重心"
}
dictionary.pop("北京")
print(dictionary)#{'上海': '金融中心', '深圳': '改革中心', '臺灣': '收復重心'}
del dictionary["上海"]
print(dictionary)#{'深圳': '改革中心', '臺灣': '收復重心'}
dictionary.clear()
print(dictionary)#{}

 

 

 

### 查詢

 

Keys() #找到keys

dictionary={
    "北京":"政治中心",
    "上海":"金融中心",
    "深圳":"改革中心",
    "臺灣":"收復重心"
}
print(dictionary.keys())#dict_keys(['北京', '上海', '深圳', '臺灣'])
print(dictionary.values())#dict_values(['政治中心', '金融中心', '改革中心', '收復重心'])
print(dictionary.items())#dict_items([('北京', '政治中心'), ('上海', '金融中心'), ('深圳', '改革中心'), ('臺灣', '收復重心')])

 

dic.value() #獲取的所有value

字典只能通過key去找value,不能用value找key.

 dic.item()#獲取的是元組

通過元組拿到了key和value

 

dictionary={
    "北京":"政治中心",
    "上海":"金融中心",
    "深圳":"改革中心",
    "臺灣":"收復重心"
}
print(dictionary.items())
for i in dictionary.items():
    print(i)
    k = i[0]
    v = i[1]
    print(k,v)

 

 

 

解構和解包(資料和變數要一一對應)

 

a,b=1,2#1,2是元組,把元組中每一項賦值給前面的變數,叫解包.同a,b=(1,2),但a,b=(1,2,3,),不能解包.

dictionary={
    "北京":"政治中心",
    "上海":"金融中心",
    "深圳":"改革中心",
    "臺灣":"收復重心"
}
#方法一
for item in dictionary.items():
    k,v = item
    print(k,v)
#方法二:
for k,v in dictionary.items():
    print(k,v)