續集二來啦，希望對你們有幫助，有興趣的可以去我主頁去看第一期的學習內容，

第 5 天 - 串列

Python 中有四種集合資料型別：

• 串列：是一個有序且可變（可修改）的集合，允許重復成員，
• 元組：是有序且不可更改或不可修改（不可變）的集合，允許重復成員，
• Set：是一個無序、無索引且不可修改的集合，但我們可以向集合中添加新專案，不允許重復成員，
• 字典：是一個無序、可變（可修改）和索引的集合，沒有重復的成員，

串列是有序且可修改（可變）的不同資料型別的集合，串列可以為空，也可以具有不同的資料型別項，

如何創建串列

在 Python 中，我們可以通過兩種方式創建串列：

• 使用串列內置函式

# 語法
lst  =  list ()

empty_list  =  list () # 這是一個空串列，串列中沒有專案
print ( len ( empty_list )) # 0

• 使用方括號，[]

# 語法
lst  = []

empty_list  = [] # 這是一個空串列，串列中沒有專案
print ( len ( empty_list )) # 0

帶有初始值的串列，我們使用len()來查找串列的長度，

Fruits  = [ 'banana' , 'orange' , 'mango' , 'lemon' ]                      # 水果串列
蔬菜 = [ 'Tomato' , 'Potato' , 'Cabbage' , 'Onion' , 'Carrot' ]       # 蔬菜串列
動物產品 = [ '牛奶'，'肉'，'黃油'，'酸奶']              # 動物產品串列
web_techs  = [ 'HTML' , 'CSS', 'JS' , 'React' , 'Redux' , 'Node' , 'MongDB' ] # 網路技術
國家 串列= [ '芬蘭' , '愛沙尼亞' , '丹麥' , '瑞典' , '挪威' ]

＃列印串列和其長度
列印（“水果：”，水果）
列印（“水果的數量：”，len個（水果））
印刷（“蔬菜：”，蔬菜），
印刷（“蔬菜號碼：”，len個（蔬菜））
列印（'動物產品：'，animal_products）
列印（'動物產品的數量：'，len個（animal_products））
列印( 'Web 技術:' , web_techs )
 print ( 'Web 技術數:' , len ( web_techs ))
 print ( '國家:' ,國家)
 print ( '國家數:' , len (國家))

輸出
水果：[ '香蕉'、'橙子'、'芒果'、'檸檬' ]
水果數量：4
蔬菜：[ '番茄'、'土豆'、'卷心菜'、'洋蔥'、'胡蘿卜' ]
蔬菜數量：5
動物產品：[ '牛奶'、'肉'、'黃油'、'酸奶' ]
動物產品數量：4
網路技術：[ ' HTML '、' CSS '、' JS '、' React '、' Redux '、' Node '、' MongDB ' ]
網路技術數量：7
國家：[ '芬蘭'、'愛沙尼亞'、'丹麥'、'瑞典'、'挪威' ]
國家數量：5

• 串列可以包含不同資料型別的專案

 lst  = [ 'Asabeneh' , 250 , True , { 'country' : 'Finland' , 'city' : 'Helsinki' }] # 包含不同資料型別的串列

使用正索引訪問串列項

我們使用它們的索引訪問串列中的每個專案，一個串列索引從 0 開始，下圖清楚地顯示了索引從哪里開始

水果 = [ '香蕉'，'桔子'，'芒果'，'檸檬' ]
 first_fruit  = 水果[ 0 ] ＃，我們使用它的索引訪問所述第一項
列印（first_fruit）       ＃香蕉
second_fruit  = 水果[ 1 ]
印刷（second_fruit )      # 橙子
last_fruit  = 水果[ 3 ]
列印( last_fruit ) # 檸檬
# 最后一個索引
last_index  =  len ( fruits ) -  1 
last_fruit  =  fruits [ last_index ]

使用負索引訪問串列項

負索引表示從末尾開始，-1 表示最后一項，-2 表示倒數第二項，

水果 = [ '香蕉'，'桔子'，'芒果'，'檸檬' ]
 first_fruit  = 水果[ - 4 ]
 last_fruit  = 水果[ - 1 ]
 second_last  = 水果[ - 2 ]
列印（first_fruit）       ＃香蕉
列印（last_fruit）        # 檸檬
印花( second_last )       # 芒果

拆箱清單專案

lst  = [ 'item' , 'item2' , 'item3' , 'item4' , 'item5' ]
 first_item , second_item , third_item , * rest  =  lst 
print ( first_item )      # item1 
print ( second_item )     # item2 
print ( third_item )      # item3
列印( rest )            # ['item4', 'item5']

# 第一個例子
fruits  = [ 'banana' , 'orange' , 'mango' , 'lemon' , 'lime' , 'apple' ]
 first_fruit , second_fruit , third_fruit , * rest  =  lst 
print ( first_fruit )      # 香蕉
列印( second_fruit )     # 橙色
印花( third_fruit )      # 芒果
印花( rest )           # ['lemon','lime','apple'] 
# 解包串列的第二個例子
first , second , third , * rest , tenth  = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]
列印（第一）           #1
列印（第二）          #2
列印（第三）           #3
列印（休息）            ＃[4,5,6,7,8,9]
列印（第十）           ＃10 
＃第三個例子約拆包串列
國家 = [ '德'，'法國'，'比利時'，'瑞典'，“丹麥' , '芬蘭' , '挪威' , '冰島' , '愛沙尼亞' ]
 gr , fr , bg , sw , * scandic ,es  = 國家
列印(gr )
列印( fr )
列印( bg )
列印( sw )
列印( scandic )
列印( es )

從串列中切片專案

• 正索引：我們可以通過指定開始、結束和步驟來指定一系列正索引，回傳值將是一個新串列，（開始的默認值 = 0，結束 = len(lst) -
  1（最后一項），步驟 = 1）

水果 = [ “香蕉”，“桔子”，“芒果”，“檸檬” ]
 all_fruits  = 水果[ 0：4 ] ＃它回傳所有水果
＃這也將給出相同的結果與上述一個
all_fruits  = 水果[ 0：] ＃

• 負索引：我們可以通過指定開始、結束和步驟來指定一系列負索引，回傳值將是一個新串列，

水果 = [ '香蕉'，'桔子'，'芒果'，'檸檬' ]
 all_fruits  = 水果[ - 4：] ＃它回傳所有水果
orange_and_mango  = 水果[ - 3：- 1 ] ＃它不包括最后一個化指數，[ '桔子'， '芒果'] 
orange_mango_lemon  = 水果[ - 3：] ＃這會給開始從-3到結束，[ '桔子'， '芒果'， '檸檬'] 
reverse_fruits  = 水果[::- 1 ] # 一個否定的步驟會以相反的順序取串列，['lemon', 'mango', 'orange', 'banana']

修改串列

串列是可變或可修改的有序項集合，讓我們修改水果串列，

Fruits  = [ 'banana' , 'orange' , 'mango' , 'lemon' ]
水果[ 0 ] =  'avocado' 
print ( fruits )        # ['avocado', 'orange', 'mango', 'lemon']
水果[ 1 ] =  'apple' 
print ( fruits )        # ['avocado', 'apple', 'mango', 'lemon'] 
last_index  =  len ( fruits ) -  1 個
fruits [ last_index ] = 'lime' 
print ( fruits )         # ['avocado', 'apple', 'mango', 'lime']

檢查串列中的專案

使用in運算子檢查專案是否是串列的成員，請參閱下面的示例，

水果 = [ '香蕉'，'桔子'，'芒果'，'檸檬' ]
 does_exist  =  '香蕉' 在 水果
列印（does_exist）   ＃真
does_exist  =  '石灰' 在 水果
列印（does_exist）   ＃假

將專案添加到串列

要將專案添加到現有串列的末尾，我們使用方法append()，

# 語法
lst  =  list ()
 lst . 追加（專案）

水果 = [ '香蕉'，'橙色'，'芒果'，'檸檬' ]
水果，append ( 'apple' )
 print ( fruits )            # ['banana', 'orange', 'mango', 'lemon', 'apple']
水果. append ( 'lime' )    # ['banana', 'orange', 'mango', 'lemon', 'apple', 'lime']
列印(水果)

將專案插入串列

我們可以使用insert()方法在串列中的指定索引處插入單個專案，請注意，其他專案向右移動，該插件（）方法有兩個引數：指數和插入專案，

# 語法
lst  = [ 'item1' , 'item2' ]
 lst . 插入（索引，專案）

水果 = [ '香蕉'，'橙色'，'芒果'，'檸檬' ]
水果，insert ( 2 , 'apple' ) # 在橙子和芒果之間插入蘋果
print ( fruits )            # ['banana', 'orange', 'apple', 'mango', 'lemon'] 
fruits . insert ( 3 , 'lime' )    # ['banana', 'orange', 'apple', 'lime', 'mango', 'lemon'

從串列中洗掉專案

remove 方法從串列中洗掉指定的專案

# 語法
lst  = [ 'item1' , 'item2' ]
 lst . 洗掉（專案）

水果 = [ '香蕉'，'橙色'，'芒果'，'檸檬'，'香蕉' ]
水果，remove ( 'banana' )
 print ( fruits )   # ['orange', 'mango', 'lemon', 'banana'] - 此方法洗掉串列中第一次出現的專案
fruits，remove ( 'lemon' )
 print ( fruits )   # ['orange', 'mango', 'banana']

使用 Pop 洗掉專案
的彈出（）方法洗掉指定索引，（或如果未指定索引中的最后一項）：

# 語法
lst  = [ 'item1' , 'item2' ]
 lst . pop ()        # 最后一項
lst . 彈出（索引）

水果 = [ '香蕉'，'橙色'，'芒果'，'檸檬' ]
水果，pop ()
列印（水果）        # ['banana', 'orange', 'mango']

水果，pop ( 0 )
 print ( fruits )        # ['orange', 'mango']

標題使用 Del 洗掉專案

該洗掉關鍵字洗掉指定索引和它也可以被用于洗掉索引范圍內的物品，它也可以完全洗掉串列

# 語法
lst  = [ 'item1' , 'item2' ]
 del  lst [ index ] # 只有一個專案
del  lst         # 徹底洗掉串列

水果 = [ '香蕉'，'桔子'，'芒果'，'檸檬'，'獼猴桃'，'石灰' ]
德爾 水果[ 0 ]
列印（水果）        ＃[ '桔子'， '芒果'， '檸檬'， 'kiwi', 'lime'] 
del  Fruits [ 1 ]
 print ( fruits )        # ['orange', 'lemon', 'kiwi', 'lime'] 
del  Fruits [ 1 : 3 ]     # 這會洗掉給定索引之間的專案，因此它不會洗掉索引為 3 的專案！
列印（水果）        ＃[“橙色”，“灰”]
德爾 水果
列印（水果）        ＃這應該給：NameError：名字“水果”沒有定義

清除清單專案

在明確的（）方法清空串列：

# 語法
lst  = [ 'item1' , 'item2' ]
 lst . 清除()

水果 = [ '香蕉'，'橙色'，'芒果'，'檸檬' ]
水果，清除（）
列印（水果）        #[]

復制串列

可以通過以下方式將串列重新分配給新變數來復制串列：list2 = list1，現在，list2 是對list1 的參考，我們在list2 中所做的任何更改也將修改原來的list2，但是在很多情況下，我們不喜歡修改原始版本，而是喜歡擁有不同的副本，避免上述問題的一種方法是使用copy()，

# 語法
lst  = [ 'item1' , 'item2' ]
 lst_copy  =  lst . 復制（）

水果 = [ '香蕉'，'橙色'，'芒果'，'檸檬' ]
水果副本 = 水果，copy ()
 print ( fruit_copy )        # ['banana', 'orange', 'mango', 'lemon']

加盟名單

在 Python 中有多種方法可以連接或連接兩個或多個串列，

• 加號運算子 (+)

# 語法
list3  =  list1  +  list2

positive_numbers  = [ 1 , 2 , 3 , 4 , 5 ]
 zero  = [ 0 ]
 negative_numbers  = [ - 5 , - 4 , - 3 , - 2 , - 1 ]
 integers  =  negative_numbers  +  zero  +  positive_numbers 
print ( integers ) # [- 5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]
水果 = ['banana' , 'orange' , 'mango' , 'lemon' ]
蔬菜 = [ 'Tomato' , 'Potato' , 'Cabbage' , 'Onion' , 'Carrot' ]
 fruit_and_vegetables  = 水果 + 蔬菜
列印( fruit_and_vegetables ) # [ “香蕉”、“橙子”、“芒果”、“檸檬”、“番茄”、“土豆”、“卷心菜”、“洋蔥”、“胡蘿卜”]

• 使用extend() 方法連接extend()方法允許在串列中附加串列，請參閱下面的示例，

# 語法
list1  = [ 'item1' , 'item2' ]
 list2  = [ 'item3' , 'item4' , 'item5' ]
 list1 . 擴展（串列2）

num1  = [ 0 , 1 , 2 , 3 ]
 num2 = [ 4 , 5 , 6 ]
 num1，extend ( num2 )
 print ( 'Numbers:' , num1 ) # Numbers: [0, 1, 2, 3, 4, 5, 6] 
negative_numbers  = [ - 5 , - 4 , - 3 , - 2 , - 1 ]
 positive_numbers  =[ 1 , 2 , 3 , 4 , 5 ]
零 = [ 0 ]

負數，擴展（零）
 negative_numbers，extend ( positive_numbers )
 print ( 'Integers:' , negative_numbers ) # Integers: [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5] 
Fruits  = [ 'banana' , 'orange' , 'mango' , 'lemon' ]
蔬菜 = [ '番茄' , '土豆' , '卷心菜' , '洋蔥' , '胡蘿卜'. 擴展（蔬菜）
列印（'水果和蔬菜：'，水果）#水果和蔬菜：['香蕉'，'橙色'，'芒果'，'檸檬'，'番茄'，'土豆'，'卷心菜'，'洋蔥'，'胡蘿卜']

計算串列中的專案

的計數（）方法回傳的專案在串列中顯示的次數：

# 語法
lst  = [ 'item1' , 'item2' ]
 lst . 計數（專案）

水果 = [ '香蕉'，'桔子'，'芒果'，'檸檬' ]
列印（水果，計數（'橙色'））    ＃1
年齡 = [ 22，19，24，25，26，24，25，24 ]
列印（年齡，計數（24））            #3

查找專案的索引

的索引（）方法回傳在串列中的專案的索引：

# 語法
lst  = [ 'item1' , 'item2' ]
 lst . 索引（專案）

Fruits  = [ 'banana' , 'orange' , 'mango' , 'lemon' ]
 print ( fruits . index ( 'orange' ))    # 1
年齡 = [ 22 , 19 , 24 , 25 , 26 , 24 , 25 , 24 ]
列印（年齡，指數（24））            ＃2，第一次出現

反轉串列

在反向（）方法將反轉的串列的順序，

# 語法
lst  = [ 'item1' , 'item2' ]
 lst . 反轉()

水果 = [ '香蕉'，'橙色'，'芒果'，'檸檬' ]
水果，reverse ()
 print ( fruits ) # ['lemon', 'mango', 'orange', 'banana'] 
age  = [ 22 , 19 , 24 , 25 , 26 , 24 , 25 , 24 ]
年齡. reverse ()
列印（年齡）# [24, 25, 24, 26, 25, 24, 19, 22]

排序串列項

要對串列進行排序，我們可以使用sort()方法或sorted()內置函式，該排序（）方法進行重新排序升序排列串列項，并修改原來的串列中，如果sort()方法的引數reverse 等于 true，它將按降序排列串列，

• sort()：此方法修改原始串列

# 語法
lst  = [ 'item1' , 'item2' ]
 lst . sort ()                 #升序
lst . sort ( reverse = True )     # 降序

例子：

水果 = [ '香蕉'，'橙色'，'芒果'，'檸檬' ]
水果，sort ()
 print ( fruits )              # 按字母順序排序，['banana', 'lemon', 'mango', 'orange'] 
fruits . sort ( reverse = True )
 print ( fruits ) # ['orange', 'mango', 'lemon', 'banana'] 
ages  = [ 22 , 19 , 24 ,, 24 , 25 , 24 ]
年齡，sort ()
列印( age ) # [19, 22, 24, 24, 24, 25, 25, 26]

年齡，sort ( reverse = True )
 print ( ages ) # [26, 25, 25, 24, 24, 24, 22, 19]

• sorted()：在不修改原串列的情況下回傳有序串列 示例：

Fruits  = [ 'banana' , 'orange' , 'mango' , 'lemon' ]
 print ( sorted ( fruits ))    # ['banana', 'lemon', 'mango', 'orange'] 
# 倒序
fruits  = [ 'banana' , 'orange' , 'mango' , 'lemon' ]
水果 = 排序（水果，reverse = True）
列印（水果）      # ['橙色”、“芒果”、“檸檬”、“香蕉”]

你很勤奮，你已經取得了很多成就，您剛剛完成了第 5 天的挑戰，距離通往卓越之路還有 5 個步驟，

第 6 天 - 元組

元組是有序且不可更改（不可變）的不同資料型別的集合，元組用圓括號 () 書寫，一旦創建了一個元組，我們就不能改變它的值，我們不能在元組中使用 add、insert、remove 方法，因為它不可修改（可變），與串列不同，元組的方法很少，
與元組相關的方法：

• tuple(): 創建一個空元組
• count()：計算元組中指定項的個數
• index()：在元組中查找指定項的索引
• 運算子：連接兩個或多個元組并創建一個新元組

創建元組

• 空元組：創建一個空元組

# 語法
empty_tuple  = ()
 # 或使用元組建構式
empty_tuple  =  tuple ()

• 具有初始值的元組

# 語法
tpl  = ( 'item1' , 'item2' , 'item3' )

水果 =（'香蕉'，'橙色'，'芒果'，'檸檬'）

元組長度

我們使用len()方法來獲取元組的長度，

# 語法
tpl  = ( 'item1' , 'item2' , 'item3' )
 len ( tpl )

訪問元組專案

• 正索引與串列資料型別類似，我們使用正索引或負索引來訪問元組項，

# 語法
tpl  = ( 'item1' , 'item2' , 'item3' )
 first_item  =  tpl [ 0 ]
 second_item  =  tpl [ 1 ]

 水果 =（'香蕉'，'桔子'，'芒果'，'檸檬'） first_fruit = 水果[ 0 ] second_fruit = 水果[ 1 ] last_index = LEN（水果）- 1 last_fruit = 水果[ las_index ]

• 負索引 負索引表示從末尾開始，-1 表示最后一項，-2 表示倒數第二，串列/元組長度的負數表示第一項，

元組負索引

# 語法
tpl  = ( 'item1' , 'item2' , 'item3' , 'item4' )
 first_item  =  tpl [ - 4 ]
 second_item  =  tpl [ - 3 ]

水果 =（'香蕉'，'桔子'，'芒果'，'檸檬'）
 first_fruit  = 水果[ - 4 ]
 second_fruit  = 水果[ - 3 ]
 last_fruit  = 水果[ - 1 ]

切片元組

我們可以通過指定一個索引范圍來切出一個子元組從哪里開始和哪里結束在元組中，回傳值將是一個具有指定項的新元組，

• 正指數范圍

# 語法
tpl  = ( 'item1' , 'item2' , 'item3' , 'item4' )
 all_items  =  tpl [ 0 : 4 ]          # 所有專案
all_items  =  tpl [ 0 :]          # 所有專案
middle_two_items  =  tpl [ 1 : 3 ]   # 不包括索引 3 處的專案

水果 =（'香蕉'，'桔子'，'芒果'，'檸檬'）
 all_fruits  = 水果[ 0：4 ]     ＃所有專案
all_fruits = 水果[ 0：]       ＃所有專案
orange_mango  = 水果[ 1：3 ]   ＃沒有按'不包括索引 3
處的 專案orange_to_the_rest = 水果[ 1 :]

• 負指數范圍

# 語法
tpl  = ( 'item1' , 'item2' , 'item3' , 'item4' )
 all_items  =  tpl [ - 4 :]          # 所有專案
middle_two_items  =  tpl [ - 3 : - 1 ]   # 不包括索引 3 處的專案(-1)

水果 =（'香蕉'，'桔子'，'芒果'，'檸檬'）
 all_fruits  = 水果[ - 4：]     ＃所有專案
orange_mango  = 水果[ - 3：- 1 ]   ＃不在索引3包括項
orange_to_the_rest  = 水果[ - 3 :]

將元組更改為串列

我們可以將元組更改為串列，將串列更改為元組，元組是不可變的，如果我們想修改一個元組，我們應該把它改成一個串列，

# 語法
tpl  = ( 'item1' , 'item2' , 'item3' , 'item4' )
 lst  =  list ( tpl )

水果 =（'香蕉'，'橙色'，'芒果'，'檸檬'）
水果 = 串列（水果）
水果[ 0 ] =  '蘋果'
列印（水果）      #['蘋果'，'橙色'，'芒果' , 'lemon'] 
fruits  =  tuple ( fruits )
 print ( fruits )      #('apple', 'orange', 'mango', 'lemon')

檢查元組中的專案

我們可以使用in檢查元組中是否存在專案，它回傳一個布林值，

# 語法
tpl  = ( 'item1' , 'item2' , 'item3' , 'item4' )
 'item2'  in  tpl  # True

水果 =（“香蕉”，“桔子”，“芒果”，“檸檬”）
列印（“橙色” 在 水果）＃真
列印（“蘋果” 在 水果）＃假
水果[ 0 ] =  “蘋果”  ＃型別錯誤： “元組”物件不支持專案分配

加入元組

我們可以使用 + 運算子連接兩個或多個元組

＃語法
TPL1  =（'ITEM1' ，'ITEM2' ，'專案3' ）
 TPL2  =（'ITEM4' ，'ITEM5' ，'ITEM6' ）
 TPL3  =  TPL1  +  TPL2

Fruits  = ( 'banana' , 'orange' , 'mango' , 'lemon' )
蔬菜 = ( 'Tomato' , 'Potato' , 'Cabbage' , 'Onion' , 'Carrot' )
 fruits_and_vegetables  = 水果 + 蔬菜

洗掉元組

不可能洗掉元組中的單個專案，但可以使用del洗掉元組本身，

# 語法
tpl1  = ( 'item1' , 'item2' , 'item3' )
 del  tpl1

水果 =（'香蕉'，'橙色'，'芒果'，'檸檬'）
德爾 水果

你真勇敢，走到這一步，您剛剛完成了第 6 天的挑戰，距離通往卓越之路還有 6 個步驟，

第 7 天 - 集合

Set 是專案的集合，集合的數學定義也適用于 Python，而Set 是無序和無索引的不同元素的集合，在Python組用于存盤唯一的專案，就可以找到工會，交集，差，對稱差，子集，超集和分離集集之間，

創建一個集合

我們使用大括號 {} 來創建一個集合或set()內置函式，

• 創建一個空集

# 語法
st  = {}
 # 或
st  =  set ()

• 使用初始項創建集合

# 語法
st  = { 'item1' , 'item2' , 'item3' , 'item4' }

例子：

# 語法
水果 = { 'banana' , 'orange' , 'mango' , 'lemon' }

獲取 Set 的長度

我們使用len()方法來查找集合的長度，

# 語法
st  = { 'item1' , 'item2' , 'item3' , 'item4' }
 len ( set )

例子：

水果 = { '香蕉'，'橙色'，'芒果'，'檸檬' }
 len（水果）

訪問集合中的專案

我們使用回圈來訪問專案，我們將在回圈部分看到這一點

檢查專案

為了檢查我們在成員資格運算子中使用的串列中是否存在專案，

# 語法
st  = { 'item1' , 'item2' , 'item3' , 'item4' }
 print ( "Does set st contains item3?" , 'item3'  in  st ) # set st 包含 item3 嗎？真的

例子：

水果 = { “香蕉”，“桔子”，“芒果”，“檸檬” }
列印（“芒果” 在 水果）＃真

將專案添加到集合

一旦創建了一個集合，我們就不能更改任何專案，我們也可以添加其他專案，

• 使用add()添加一項

語法

st = { ‘item1’ , ‘item2’ , ‘item3’ , ‘item4’ }
st . 添加（‘item5’）
例子：

水果 = { '香蕉'，'橙色'，'芒果'，'檸檬' }
水果，添加（'石灰'）

• 使用添加多個專案的update（） 的更新（）允許多個專案添加到組，該更新（）接受一個串列引數，

# 語法
st  = { 'item1' , 'item2' , 'item3' , 'item4' }
 st . 更新（[ 'item5'，'item6'，'item7' ]）

例子：

Fruits  = { 'banana' , 'orange' , 'mango' , 'lemon' }
蔬菜 = ( 'tomato' , 'potato' , 'cabbage' , 'onion' , 'carrot' )
水果，更新（蔬菜）

從集合中洗掉專案

我們可以使用remove()方法從集合中洗掉一個專案，如果未找到該專案，remove()方法將引發錯誤，因此最好檢查該專案是否存在于給定集合中，但是，discard()方法不會引發任何錯誤，

# 語法
st  = { 'item1' , 'item2' , 'item3' , 'item4' }
 st . 洗掉（'item2'）

pop() 方法從串列中隨機洗掉一個專案，并回傳洗掉的專案，

例子：

水果 = { '香蕉'，'橙色'，'芒果'，'檸檬' }
水果，pop ()   # 從集合中隨機洗掉一個專案

如果我們對洗掉的專案感興趣，

水果 = { '香蕉'，'橙色'，'芒果'，'檸檬' } 已
移除_專案 = 水果，流行()

清除集合中的專案

如果我們想清除或清空集合，我們使用clear方法，

# 語法
st  = { 'item1' , 'item2' , 'item3' , 'item4' }
 st . 清除()

例子：

水果 = { '香蕉'，'橙色'，'芒果'，'檸檬' }
水果，清除（）
列印（水果）#設定（）

洗掉集合

如果我們想洗掉集合本身，我們使用del運算子，

# 語法
st  = { 'item1' , 'item2' , 'item3' , 'item4' }
 del  st

例子：

水果 = { “香蕉”，“桔子”，“芒果”，“檸檬” }
德爾 水果

將串列轉換為集合

我們可以將 list 轉換為 set 并將 set 轉換為 list，將串列轉換為 set 會洗掉重復項，并且只會保留唯一項，

# 語法
lst  = [ 'item1' , 'item2' , 'item3' , 'item4' , 'item1' ]
 st  =  set ( lst )   # {'item2', 'item4', 'item1', 'item3'} -順序是隨機的，因為集合通常是無序的

例子：

水果 = [ '香蕉' , '橙色' , '芒果' , '檸檬' , '橙色' , '香蕉' ]
水果 = 設定(水果) # {'芒果', '檸檬', '香蕉', '橙色' }

連接集

我們可以使用union()或update()方法連接兩個集合，

• Union 這個方法回傳一個新的集合

# 語法
st1  = { 'item1' , 'item2' , 'item3' , 'item4' }
 st2  = { 'item5' , 'item6' , 'item7' , 'item8' }
 st3  =  st1 . 聯合（st2）

例子：

水果 = { '香蕉'，'橙色'，'芒果'，'檸檬' }
蔬菜 = { '番茄'，'馬鈴薯'，'卷心菜'，'洋蔥'，'胡蘿卜' }
列印（水果，聯合（蔬菜） ) # {'lemon', 'carrot', 'tomato', 'banana', 'mango', 'orange', 'cabbage', 'potato', 'onion'}

• 更新此方法將一個集合插入給定的集合

# 語法
st1  = { 'item1' , 'item2' , 'item3' , 'item4' }
 st2  = { 'item5' , 'item6' , 'item7' , 'item8' }
 st1 . update ( st2 ) # st2 內容添加到 st1

例子：

水果 = { '香蕉' , '橙色' , '芒果' , '檸檬' }
蔬菜 = { '番茄' , '馬鈴薯' , '卷心菜' , '洋蔥' , '胡蘿卜' }
水果，更新（蔬菜）
列印（水果）# {'lemon', 'carrot', 'tomato', 'banana', 'mango', 'orange', 'cabbage', 'potato', 'onion'}

查找交叉項

交集回傳兩個集合中的一組專案，看例子

# 語法
st1  = { 'item1' , 'item2' , 'item3' , 'item4' }
 st2  = { 'item3' , 'item2' }
 st1 . 交集( st2 ) # {'item3', 'item2'}

例子：

Whole_numbers  = { 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 }
 even_numbers  = { 0 , 2 , 4 , 6 , 8 , 10 }
 whole_numbers，交集( even_numbers ) # {0, 2, 4, 6, 8, 10}

python  = { 'p' , 'y' , 't' , 'h' , 'o' , 'n' }
龍 = { 'd' , 'r' , 'a' , 'g' , 'o' , 'n' }
蟒蛇，交叉點（龍）      #{'o', 'n'}

檢查子集和超集

一個集合可以是其他集合的子集或超集：

• 子集：issubset()
• 超級集：issuperset

# 語法
st1  = { 'item1' , 'item2' , 'item3' , 'item4' }
 st2  = { 'item2' , 'item3' }
 st2 . issubset ( st1 ) #真
st1，issuperset ( st2 ) # 真

例子：

Whole_numbers  = { 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 }
 even_numbers  = { 0 , 2 , 4 , 6 , 8 , 10 }
 whole_numbers，issubset ( even_numbers ) # False，因為它是一個超集
whole_numbers，issuperset (even_numbers ) # 真

python  = { 'p' , 'y' , 't' , 'h' , 'o' , 'n' }
龍 = { 'd' , 'r' , 'a' , 'g' , 'o' , 'n' }
蟒蛇，issubset ( dragon )      # False

檢查兩組之間的差異

它回傳兩組之間的差異，

# 語法
st1  = { 'item1' , 'item2' , 'item3' , 'item4' }
 st2  = { 'item2' , 'item3' }
 st2 . 差（ST1）＃集（）
ST1，差異( st2 ) # {'item1', 'item4'} => st1\st2

例子：

Whole_numbers  = { 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 }
 even_numbers  = { 0 , 2 , 4 , 6 , 8 , 10 }
 whole_numbers，差異( even_numbers ) # {1, 3, 5, 7, 9}

python  = { 'p' , 'y' , 't' , 'o' , 'n' }
龍 = { 'd' , 'r' , 'a' , 'g' , 'o' , 'n' }
蟒蛇，差異( dragon )      # {'p', 'y', 't'} - 結果是無序的（集合的特征）
dragon，差異( python )      # {'d', 'r', 'a', 'g'}

尋找兩個集合之間的對稱差異

它回傳兩個集合之間的對稱差異，這意味著它回傳一個包含兩個集合中所有專案的集合，除了兩個集合中都存在的專案，數學上： (A\B) ∪ (B\A)

# 語法
st1  = { 'item1' , 'item2' , 'item3' , 'item4' }
 st2  = { 'item2' , 'item3' }
 # 意思是 (A\B)∪(B\A) 
st2 . symmetric_difference（ST1）＃{ 'ITEM1'， 'ITEM4'}

例子：

Whole_numbers  = { 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 }
 some_numbers  = { 1 , 2 , 3 , 4 , 5 }
 whole_numbers，symmetric_difference（some_numbers）＃{0，6，7，8，9，10}

python  = { 'p' , 'y' , 't' , 'h' , 'o' , 'n' }
龍 = { 'd' , 'r' , 'a' , 'g' , 'o' , 'n' }
蟒蛇，symmetry_difference ( dragon )   # {'r', 't', 'p', 'y', 'g', 'a', 'd', 'h'}

連接集

如果兩個集合沒有一個或多個公共項，我們稱它們為不相交的集合，我們可以使用isdisjoint()方法檢查兩個集合是聯合還是不相交，

# 語法
st1  = { 'item1' , 'item2' , 'item3' , 'item4' }
 st2  = { 'item2' , 'item3' }
 st2 . isdisjoint ( st1 ) # 假

例子：

even_numbers  = { 0 , 2 , 4 , 6 , 8 }
 even_numbers  = { 1 , 3 , 5 , 7 , 9 }
 even_numbers . isdisjoint ( odd_numbers ) # 真，因為沒有共同項

python  = { 'p' , 'y' , 't' , 'h' , 'o' , 'n' }
龍 = { 'd' , 'r' , 'a' , 'g' , 'o' , 'n' }
蟒蛇，isdisjoint ( dragon )   # False，有共同項{'o', 'n'}

你是一顆冉冉升起的新星，您剛剛完成了第 7 天的挑戰，您在通往偉大的道路上領先了 7 步，

第 8 天 - 字典

字典是無序、可修改（可變）成對（鍵：值）資料型別的集合，

創建字典

要創建字典，我們使用大括號 {} 或dict()內置函式，

# 語法
empty_dict  = {}
 # 包含資料值的字典
dct  = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }

例子：

person  = {
     'first_name' : 'Asabeneh' ,
     'last_name' : 'Yetayeh' ,
     'age' : 250 ,
     'country' : 'Finland' ,
     'is_marred' : True ,
     'skills' :[ 'JavaScript' , 'React ' , 'Node' , 'MongoDB' , 'Python' ],
     'address' :{
         'street' : 'Space street' ,
        “郵政編碼”：“02210”
    }
    }

上面的字典顯示一個值可以是任何資料型別：字串、布林值、串列、元組、集合或字典，

字典長度

它檢查字典中“鍵：值”對的數量，

# 語法
dct  = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }
 print ( len ( dct )) # 4

例子：

person  = {
     'first_name' : 'Asabeneh' ,
     'last_name' : 'Yetayeh' ,
     'age' : 250 ,
     'country' : 'Finland' ,
     'is_marred' : True ,
     'skills' :[ 'JavaScript' , 'React ' , 'Node' , 'MongoDB' , 'Python' ],
     'address' :{
         'street' : 'Space street' ,
        “郵政編碼”：“02210”
    }
    }
列印（len（人））#7

訪問字典專案

我們可以通過參考它的鍵名來訪問字典項，

# 語法
dct  = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }
 print ( dct [ 'key1' ]) # value1
列印( dct [ 'key4' ]) # value4

例子：

person  = {
     'first_name' : 'Asabeneh' ,
     'last_name' : 'Yetayeh' ,
     'age' : 250 ,
     'country' : 'Finland' ,
     'is_marred' : True ,
     'skills' :[ 'JavaScript' , 'React ' , 'Node' , 'MongoDB' , 'Python' ],
     'address' :{
         'street' : 'Space street' ,
        “郵政編碼”：“02210”
    }
    }
print ( person [ 'first_name' ]) # Asabeneh 
print ( person [ 'country' ])     # Finland 
print ( person [ 'skills' ])      # ['JavaScript', 'React', 'Node', 'MongoDB', ' Python'] 
print ( person [ 'skills' ][ 0 ])   # JavaScript 
print ( person [ 'address' ][ 'street']) # 太空街
列印( person [ 'city' ])       ＃ 錯誤

如果鍵不存在，按鍵名訪問專案會引發錯誤，為了避免這個錯誤，首先我們必須檢查一個鍵是否存在，或者我們可以使用get方法，如果鍵不存在，get 方法回傳 None，這是一個 NoneType 物件資料型別，

person  = {
     'first_name' : 'Asabeneh' ,
     'last_name' : 'Yetayeh' ,
     'age' : 250 ,
     'country' : 'Finland' ,
     'is_marred' : True ,
     'skills' :[ 'JavaScript' , 'React ' , 'Node' , 'MongoDB' , 'Python' ],
     'address' :{
         'street' : 'Space street' ,
        “郵政編碼”：“02210”
    }
    }
列印（人，得到（'FIRST_NAME' ））＃Asabeneh
列印（人，獲得（'國家'））    ＃芬蘭
印刷（人，獲得（'技能'））＃[ 'HTML'， 'CSS'， 'JavaScript的' ， '陣營'， '節點'， 'MongoDB的'， 'Python的']
列印（人，獲得（'城市'））   ＃無

將專案添加到字典

我們可以向字典中添加新的鍵值對

# 語法
dct  = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }
 dct [ 'key5' ] =  'value5'

例子：

person  = {
     'first_name' : 'Asabeneh' ,
     'last_name' : 'Yetayeh' ,
     'age' : 250 ,
     'country' : 'Finland' ,
     'is_marred' : True ,
     'skills' :[ 'JavaScript' , 'React ' , 'Node' , 'MongoDB' , 'Python' ],
     'address' :{
         'street' : 'Space street' ,
        “郵政編碼”：“02210”
        }
}
人[ 'job_title' ] =  '講師'
人[ '技能' ]，追加（'HTML'）
列印（人）

修改字典中的專案

我們可以修改字典中的專案

# 語法
dct  = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }
 dct [ 'key1' ] =  'value-one'

例子：

person  = {
     'first_name' : 'Asabeneh' ,
     'last_name' : 'Yetayeh' ,
     'age' : 250 ,
     'country' : 'Finland' ,
     'is_marred' : True ,
     'skills' :[ 'JavaScript' , 'React ' , 'Node' , 'MongoDB' , 'Python' ],
     'address' :{
         'street' : 'Space street' ,
        “郵政編碼”：“02210”
    }
    }
人[ 'first_name' ] =  'Eyob'
人[ '年齡' ] =  252

檢查字典中的鍵

我們使用in運算子來檢查字典中是否存在鍵

# 語法
dct  = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }
 print ( 'key2'  in  dct ) # True 
print ( ' KEY5' 在 DCT）＃假

從字典中洗掉鍵和值對

• pop(key)：洗掉具有指定鍵名的專案
• popitem() : 洗掉最后一項
• del : 洗掉具有指定鍵名的專案

# 語法
dct  = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }
 dct . pop ( 'key1' ) # 洗掉 key1 項
dct  = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }
 DCT，彈出項()# 洗掉最后一項
del  dct [ 'key2' ] # 洗掉 key2 項

例子：

person  = {
     'first_name' : 'Asabeneh' ,
     'last_name' : 'Yetayeh' ,
     'age' : 250 ,
     'country' : 'Finland' ,
     'is_marred' : True ,
     'skills' :[ 'JavaScript' , 'React ' , 'Node' , 'MongoDB' , 'Python' ],
     'address' :{
         'street' : 'Space street' ,
        “郵政編碼”：“02210”
    }
    }
人，pop ( 'first_name' )         # 洗掉名字項
person，popitem ()                 # 移除地址項
del  person [ 'is_married' ]         # 移除 is_married 項

將字典更改為專案串列

該專案（）方法的改變字典元組的串列，

＃語法
DCT  = { 'KEY1' ：'VALUE1' ，'KEY2' ：'值'，'KEY3' ：'值3' ，'KEY4' ：'VALUE4' }
列印（DCT，專案（））＃dict_items（[（ 'key1', 'value1'), ('key2', 'value2'), ('key3', 'value3'), ('key4', 'value4')])

清除字典

如果我們不想要字典中的專案，我們可以使用clear()方法清除它們

＃語法
DCT  = { 'KEY1' ：'VALUE1' ，'KEY2' ：'值'，'KEY3' ：'值3' ，'KEY4' ：'VALUE4' }
列印（DCT，清晰（）） ＃無

洗掉字典

如果我們不使用字典，我們可以完全洗掉它

# 語法

dct  = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }
 del  dct

復制字典

我們可以使用copy()方法復制字典，使用復制我們可以避免原始字典的變異，

# 語法
dct  = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }
 dct_copy  =  dct . copy () # {'key1':'value1', 'key2':'value2', 'key3':'value3', 'key4':'value4'}

獲取字典鍵作為串列

該鍵（）方法為我們提供了AA字典作為一個串列的所有鍵，

# 語法
dct  = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }
 keys  =  dct . 鍵()
列印(鍵)      # dict_keys(['key1', 'key2', 'key3', 'key4'])

獲取字典值作為串列

該值的方法為我們提供了AA字典作為一個串列的所有值，

# 語法
dct  = { 'key1' : 'value1' , 'key2' : 'value2' , 'key3' : 'value3' , 'key4' : 'value4' }
 values  =  dct . values ()
列印( values )      # dict_values(['value1', 'value2', 'value3', 'value4'])

你是驚人的，現在，您對字典的強大功能感到非常興奮，您剛剛完成了第 8 天的挑戰，距離通往卓越之路還有 8 步，

第 9 天 - 條件陳述句

默認情況下，Python 腳本中的陳述句從上到下依次執行，如果處理邏輯需要，可以通過兩種方式改變執行的順序流程：

• 條件執行：如果某個運算式為真，將執行一個或多個陳述句塊
• 重復執行：只要某個運算式為真，一個或多個陳述句塊就會被重復執行，在本節中，我們將介紹if、else、elif陳述句，我們在前幾節中學到的比較和邏輯運算子在這里會很有用，

如果條件

在 python 和其他編程語言中，關鍵字if用于檢查條件是否為真并執行塊代碼，記住冒號后的縮進，

＃語法
，如果 條件：
    這 部分 的 代碼 運行 的 truthy 條件

示例：1

a  =  3 
if  a  >  0 :
     print ( 'A is a positive number' )
 # A 是正數

正如你在上面的例子中看到的，3 大于 0，條件為真，塊代碼被執行，但是，如果條件為假，我們將看不到結果，為了查看虛假條件的結果，我們應該有另一個塊，即else，

如果條件為真

如果條件為真，將執行第一個塊，否則將運行 else 條件，

＃語法
，如果 條件：
    這 部分 的 代碼 運行 的 truthy 條件
還有：
     這 部分 的 代碼 運行 的 虛假 條件

例子：

a  =  3
如果 a  <  0 :
    列印( 'A 是負數' )
否則:
    列印( 'A 是正數' )

上面的條件證明為假，因此執行了 else 塊，如果我們的條件超過兩個呢？我們可以使用 _ elif_，

如果Elif Else

在日常生活中，我們每天都在做決定，我們不是通過檢查一兩個條件而是通過多個條件來做出決定，和生活一樣，編程也是充滿條件的，當我們有多個條件時，我們使用elif，

# 語法
if 條件：
    代碼
elif 條件：
    代碼
else：
    代碼

例子：

a  =  0 
if  a  >  0 :
     print ( 'A is a positive number' )
 elif  a  <  0 :
     print ( 'A is a negative number' )
 else :
     print ( 'A is zero' )

簡寫

# 語法
代碼 if 條件 else 代碼

**例子： **

a  =  3 
print ( 'A is positive' ) if  a  >  0  else  print ( 'A is negative' ) # 第一個條件滿足，'A is positive' 將被列印

嵌套條件

條件可以嵌套

# 語法
if 條件：
    代碼
    if 條件：
    代碼

**例子： **

a  =  0 
if  a  >  0 :
     if  a  %  2  ==  0 :
         print ( 'A is a positive and even integer' )
     else :
         print ( 'A is a positive number' )
 elif  a  ==  0 :
     print ( 'A為零' )


 else :
    列印( 'A 是負數' )

我們可以通過使用邏輯運算子和來避免撰寫嵌套條件，

If 條件和邏輯運算子

# 語法
if 條件 和 條件：
    代碼

**例子： **

a  =  0 
if  a  >  0  and  a  %  2  ==  0 :
         print ( 'A is an even positive integer' )
 elif  a  >  0  and  a  %  2  !=   0 :
      print ( 'A is a positive integer' )
 elif  a  ==  0：
    列印（'A 為零'）
否則：
    列印（'A 為負'）

If 和 Or 邏輯運算子

# 語法
if 條件 或 條件：
    代碼

**例子： **

user  =  'James' 
access_level  =  3 
if  user  ==  'admin'  or  access_level  >=  4 :
         print ( '訪問被授予！' )
 else :
     print ( '訪問被拒絕！' )

你做得很好，永遠不要放棄，因為偉大的事情需要時間，您剛剛完成了第 9 天的挑戰，距離通往偉大之路還有 9 步，

第 10 天 - 回圈

生活處處都是例行公事，在編程中，我們也會做很多重復的任務，為了處理重復性任務，編程語言使用回圈，Python 編程語言還提供了以下兩種回圈型別：

1. while 回圈
2. for回圈

While 回圈

我們使用保留字while來創建一個 while 回圈，它用于重復執行陳述句塊，直到滿足給定條件，當條件變為假時，回圈后的代碼行將繼續執行，

  ＃語法
而 條件：
    代碼 去 這里

例子：

count  =  0
而 count  <  5 :
     print ( count )
     count  =  count  +  1 
#prints from 0 to 4

在上面的 while 回圈中，當 count 為 5 時條件變為假，也就是回圈停止的時候，如果我們有興趣在條件不再為真時運行代碼塊，我們可以使用else，

  ＃語法
而 條件：
    代碼 去 這里
還有：
    代碼 去 這里

例子：

計數 =  0
而 計數 <  5：
    列印（計數）
    計數 = 計數 +  1
否則：
    列印（計數）

當 count 為 5 時，上述回圈條件為假，回圈停止，執行 else 陳述句，結果將列印 5，

中斷并繼續 - 第 1 部分

• Break：當我們想退出或停止回圈時，我們使用 break，

# 語法
while  condition :
    代碼 在 這里
    if  another_condition :
         break

例子：

count  =  0
而 count  <  5 :
     print ( count )
     count  =  count  +  1 
    if  count  ==  3 :
         break

上面的 while 回圈只列印 0, 1, 2，但是當它到達 3 時就停止了，

• 繼續：使用 continue 陳述句，我們可以跳過當前迭代，并繼續下一個：

 # 語法
while  condition :
    代碼 在 這里
    if  another_condition :
         continue

例子：

count  =  0
而 count  <  5：
    如果 count  ==  3：
        繼續
    列印（count）
     count  =  count  +  1

上面的 while 回圈只列印 0、1、2 和 4（跳過 3），

For回圈

一對關鍵字是用來做一個for回圈，與其他編程語言類似，但有一些語法差異，回圈用于迭代序列（即串列、元組、字典、集合或字串），

• 帶串列的for回圈

＃語法
為 迭代器 在 LST：
    代碼 去 這里

例子：

numbers  = [ 0 , 1 , 2 , 3 , 4 , 5 ]
 for  number  in  numbers : # number 是參考串列項的臨時名稱，僅在此回圈內有效
    print ( number )        # 數字將逐行列印, 從 0 到 5

• 帶字串的for回圈

＃語法
的 迭代器 中 的字串：
    代碼 去 這里

例子：

language  =  'Python' 
for  letter  in  language :
     print ( letter )


for  i  in  range ( len ( language )):
     print ( language [ i ])

• 帶元組的 for 回圈

＃語法
為 迭代器 在 TPL：
    代碼 去 這里

例子：

數字 = ( 0 , 1 , 2 , 3 , 4 , 5 )
對于 數字 中的 數字：
    列印(數字)

• 帶字典的 for 回圈回圈遍歷字典為您提供字典的鍵，

 ＃語法
為 迭代器 在 DCT：
    代碼 去 這里

例子：

person  = {
     'first_name' : 'Asabeneh' ,
     'last_name' : 'Yetayeh' ,
     'age' : 250 ,
     'country' : 'Finland' ,
     'is_marred' : True ,
     'skills' :[ 'JavaScript' , 'React ' , 'Node' , 'MongoDB' , 'Python' ],
     'address' :{
         'street' : 'Space street' ,
        “郵政編碼”：“02210”
    }
}
對于 關鍵 在 人：
    列印（鑰匙）

對于 關鍵的，價值 的 人，items ():
     print ( key , value ) # 這樣我們就可以同時列印出鍵和值

• 回圈設定

＃語法
為 迭代器 在 ST：
    代碼 去 這里

例子：

it_companies  = { 'Facebook' , 'Google' , 'Microsoft' , 'Apple' , 'IBM' , 'Oracle' , 'Amazon' }
 for  company  in  it_companies :
     print ( company )

中斷并繼續 - 第 2 部分

簡短提醒： Break：當我們想在回圈完成之前停止回圈時，我們使用 break，

＃語法
為 迭代器 在 序列：
    代碼 去 這里
    ，如果 條件：
        破

例子：

numbers  = ( 0 , 1 , 2 , 3 , 4 , 5 )
對于 數字 中的 數字：
    列印（數字）
    如果 數字 ==  3：
        中斷

在上面的例子中，回圈在到達 3 時停止，

Continue：當我們想跳過回圈迭代中的某些步驟時，我們使用 continue，

 ＃語法
為 迭代器 在 序列：
    代碼 去 這里
    ，如果 條件：
        繼續

例子：

數 =（0，1，2，3，4，5）
對 數 中 的數字：
    列印（數字）
    如果 數 ==  3：
        繼續
    列印（'下一步數應該是'，數目 +  1），如果 數 ！=  5 別的 print ( "loop's end" ) # 簡寫條件需要 if 和 else 陳述句
列印（'回圈外'）

在上面的示例中，如果數字等于 3，則跳過條件之后的步驟（但在回圈內），如果還有任何迭代剩余，則回圈繼續執行，

范圍函式

的范圍（）函式是一個數字的使用的串列，的范圍（開始，結束，步驟）三個引數：開始，結束和增量，默認情況下，它從 0 開始，增量為 1，范圍序列至少需要 1 個引數（結束），使用范圍創建序列

lst  =  list ( range ( 11 )) 
 print ( lst ) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 
st  =  set ( range ( 1 , 11 ))     # 2引數表示序列的開始和結束，步驟設定為默認 1 
print ( st ) # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

lst  =  list ( range ( 0 , 11 , 2 ))
 print ( lst ) # [0, 2, 4, 6, 8, 10] 
st  =  set ( range ( 0 , 11 , 2 ))
 print ( st ) # { 0, 2, 4, 6, 8, 10}

＃語法
用于 迭代器 在 范圍（開始，結束，步驟）：

例子：

for  number  in  range ( 11 ):
     print ( number )    # 列印 0 到 10，不包括 11

嵌套 For 回圈

我們可以在回圈內撰寫回圈，

# 語法
for  x  in  y :
     for  t  in  x :
         print ( t )

例子：

person  = {
     'first_name' : 'Asabeneh' ,
     'last_name' : 'Yetayeh' ,
     'age' : 250 ,
     'country' : 'Finland' ,
     'is_marred' : True ,
     'skills' : [ 'JavaScript' , 'React ' , 'Node' , 'MongoDB' , 'Python' ],
     'address' : {
         'street' : 'Space street',
         '郵政編碼' : '02210'
    }
}
對于 關鍵 在 人：
    如果 鍵 ==  “技能”：
        對 技能 的 人[ “技能” ]：
            列印（技能）

對于其他

如果我們想在回圈結束時執行一些訊息，我們使用 else，

＃語法
的 迭代器 在 范圍（開始，結束，步）：
    做 一些
別的：
    列印（“回圈結束”）

例子：

for  number  in  range ( 11 ):
     print ( number )    # 列印 0 到 10，不包括 11 
else :
     print ( '回圈停止于' , number )

經過

在python中需要陳述句時（分號后），但我們不喜歡在那里執行任何代碼，我們可以寫pass這個詞來避免錯誤，我們也可以將它用作占位符，用于未來的陳述，

例子：

對于 數目 在 范圍（6）：
    通

你建立了一個重要的里程碑，你勢不可擋，繼續！您剛剛完成了第 10 天的挑戰，距離通往卓越之路還有 10 步，

你們的三連是我堅持更新下去的動力，感謝，