一、break 和 continue 語句

break 和 continue 語句都只能用在while 和 for 循環(huán)中。

1.1 continue 語句

• continue 語句： 用來告訴python 跳出當前循環(huán)的剩余語句，然后繼續(xù)進行下一輪循環(huán)。常用在 while 和 for 循環(huán)中。
  案例分析：
  i += 1位于 continue前面時：

i = 0
while i < 6:
    i += 1
    if  i ==4:
        continue
    print(i)
else:
  print('hello')
-------------執(zhí)行------------
1
2
3
5
6
hello

當 i += 1 位于 continue 后面時：

i = 0 
while i < 6:
    if i == 4:
       continue
    i += 1
    print(i)
else:
  print('hello')
--------------執(zhí)行------------
0
1
2
3
4

• 上面案例二中， i += 1在continue后時，i ==4 時，continue程序跳出if 當前循環(huán)，又重新進入下一輪循環(huán)，這樣一直在continue -->跳出-->continue …… 這樣程序就問題了。所以輸出一直停留在0 ，1，2，3。

• continue 語句時一個刪除的效果，他的純在時為了滿足循環(huán)條件下的某些不需要的成分：

j = 10
while j > 0:
    j -= 1
    if j ==3 or j == 7:
        continue
    print(j)
else:
    print('hello python')
-------------輸出-------------
9
8
6
5
4
2
1
0
hello python

• 可以看到上面效果就是去除了 3 和7 。
  案例3：打印1-10以內(nèi)的奇數(shù)

i =0
while i < 10:
  i += 1
  if i % 2 == 0:
    continue
  print(i)
--------------輸出--------------
1
3
5
7
9

1.2 break 語句

• break 用來立即跳出循環(huán)語句，包括else 語句。

i = 0 
while i < 10:
   i += 1
   if i == 4:
      break
   print(i)
else:
  print('hello python')
-----------輸出----------
1
2
3

上面案例中當 i==4 時，break 直接終止了循環(huán)。

• 如果使用嵌套循環(huán)，break 語句將停止執(zhí)行最深層的循環(huán)，并開始執(zhí)行下一段代碼。

j = 0
while  j < 2:
   i = 0
   j += 1
   while i < 10:
       i += 1
       if i == 4:
           break
       print(i)
   else:
       print('hello')
---------------輸出----------------
1
2
3
1
2
3

總結(jié)： continue 和 break 只會對當前的所在循環(huán)跳出或終止，不會對循環(huán)外的嵌套循環(huán)產(chǎn)生效果。

二、序列

2.1 序列 (sequence)

• 概念： 序列是 Python中最基本的一種數(shù)據(jù)結(jié)構(gòu)，用于保存一組有序的數(shù)據(jù)。
• 序列中數(shù)據(jù)都有一個唯一的索引，且數(shù)據(jù)會按照添加的順序來分配索引。
• 數(shù)據(jù)結(jié)構(gòu)：計算機中數(shù)據(jù)存儲的方式。

2.2 序列分類

• 可變序列：序列中元素可以改變 比如：list.
• 不可變序列：序列中元素不可以改變 比如：字符串(str) , 元組（tuble)

2.3 列表

• 多元化存儲，可以存儲各種數(shù)據(jù)類型
• 數(shù)據(jù)類型： 字符串、列表、元組、字典、集合。
• 格式：list []
  • [] 表示一個空列表。

list1 = [True, None, 'a', 111, [1,2,3]]

列表的增刪改查

1） 列表取值
使用下標索引來訪問列表中的值。

list1 = [True, '111', 23, [1,2,3]]]
print("list1[0]:", list1[0])
print("list1[1]:", list1[1])
print("list1[3]:", list1[3][0])
------------輸出--------------
list1[0]: True
list1[1]: 111
list1[3]: 2

2) 列表更新
我們同樣可以對列表的數(shù)據(jù)項目進行修改或更新?？梢允褂?append(), insert() ,extend()等方法來添加列表項。

list2 = []  #空列表
list2.append('k8s')
list2.append('jenkins')
print(list2)  # 使用append() 向列表最后追加一個元素。
list2.insert(1,'prometheus')) # 指定位置插入一個元素，1表示當前下標索引2之前插入。
print(list2)
list2.extend(['gitlab'])
----------輸出-----------
['k8s', 'jenkins']
['k8s', 'prometheus', 'jenkins']
['k8s', 'prometheus', 'jenkins', 'gitlab']

insert() : 在索引前插入
append(): 索引值后追加
extend(): 在列表末尾追加，添加其他列表到當前列表中來。

3) 刪除列表中的元素
可以使用 remove .pop 等語句來刪除列表中的元素, 如下：

list1 = ['python', 'java', 'golang', 'nodejs']
list1.remove('nodejs')
print(list1)
list2 = ['111', '222', '333', '444']
res = list2.pop(1)
print(res)
res = list2.pop()
print(res)

----------輸出------------
['python', 'java', 'golang']
222
444

• pop 根據(jù)索引值刪除并返回你刪除的數(shù)據(jù)，如果沒有傳遞索引值，那么會刪除最后一個元素。（特點，按索引刪除，并返回數(shù)據(jù)。）
• remove 根據(jù)指定元素刪除（特點：按值刪除）

2.4 切片

• 什么是切片？
  • 切片是指從現(xiàn)有列表中獲取一個子列表。
  • 通過切片獲取指定元素
• 語法： list [起始位置:結(jié)束位置:步長]
  ??????索引1??索引2

特性：左閉右開區(qū)間，即不包含結(jié)束位置的值
list1[1:3] : 表示取值索引1 和索引為3 的數(shù)據(jù)，即第2個和第4個數(shù)據(jù)，但是切片的特性，左閉右開區(qū)間, 最終取到就是第2和第3個數(shù)據(jù)。
(1) 切片可以取到開頭元素，但是不能取到結(jié)尾數(shù)據(jù)
但是，如果切片省略了開頭和結(jié)尾取到最后，就能取到整個列表 list[:]

list1 =  ['java', 'python', 'nodejs', 'golang']
print(list1[1:3])
print(list1[:])  #  省略了開頭和結(jié)尾，可以取到整個列表
---------輸出---------
['python', 'nodejs']
['java', 'python', 'nodejs', 'golang']

(2) 索引順序 <重點理解>

• 從左往右取值，索引從0開始，依次排序：0，1，2，3……
• 從右往左取值，索引從-1開始，依次 -1，-2，-3，-4……；但是，此時需要加上步長。步長決定了索引取值的方向。

list1 =  ['java', 'python', 'nodejs', 'golang']
print(list1[-1:-3])
# 輸出為 []
print(list[-1:-3:-1])  #步長為-1，從右往左取值，切片的特性可以取開頭，但取不到結(jié)尾。所以最終取到 golang,nodejs。
#輸出：['golang', 'nodejs']
print(list1[-3:-1])  # 沒有指定步長，這里默認步長為1，即從左往右取值[-3 到-1。但是，切片的特性可以取開頭，但取不到結(jié)尾。所以只能取到 python 和 nodejs。
# 輸出： ['python', 'nodejs'] 

2.5 通用操作

• +和*
  • + 兩個列表拼接成要給列表
  • ? 將兩個列表重復(fù)輸出為指定的次數(shù)。但是列表不能相乘，相除。

list1 = [1,2,3] + [4,5,6]
print(list1)
list2 = ['a', 'b', 'c'] *2
-----------輸出-----------
[1, 2, 3, 4, 5, 6]
['a', 'b', 'c', 'a', 'b', 'c']

• in 和 not in ： 判斷 元素是否在當前列表中。輸出 True or False.
• len : 獲取列表元素的個數(shù)

list1 = [1,2,3] + [4,5,6]
print(len(list1))
--------輸出---------
6

• max() && min()： 獲取列表中最大值，最小值
• index :
  • 在字符串中使用方式

s = 'abcd'
print(s.index('a'))  # 返回的是索引值
print(s.find('a'))   #
# 但是如果是字符串中沒有的元素呢：
print(s.index('e'))  # index 直接報錯
print(s.find('e'))    # 沒有找到，返回-1

在列表中，只能使用 index, 不能使用find

• 特性1：index在列表中，只能找到第一個元素得索引并返回出來。
• 特性2：如果找不到list 中的元素直接報錯

print(list2.index('a'))  # 只能找到第一個值得索引，并返回出來。
print(list2.index('d'))  # 如果找不到list 中得元素，則報錯。

• list.count(x) : 表示指定元素在列表中出現(xiàn)的次數(shù)。

2.6 修改列表

• 通過索引修改： 替換

list1 =  ['java', 'python', 'nodejs', 'golang']
list1[1] = 'c++'
print(list1)
---------------輸出------------
['java', 'c++', 'nodejs', 'golang']

• 通過切片修改

情況一：
list1 =  ['java', 'python', 'nodejs', 'golang']
list1[1:2] = 'c++'  # 這里c++ 字符串是一個序列，分配三個索引值，因此會被拆分
print(list1)
------------輸出------------
['java', 'c', '+', '+', 'nodejs', 'golang']

情況二：
list1 =  ['java', 'python', 'nodejs', 'golang']
list1[1:2] = ['c++']   # c++ 就是列表序列中的一個元素，分配一個索引，所以會完整替換。
print(list1)
------------輸出------------
['java', 'c++', 'nodejs', 'golang']

注意： 通過切片來修改列表時，來替換的內(nèi)容必須是一個序列。并且序列還會被拆開。
上面 'C++',也是一個序列，序列中保存的一組有序的數(shù)據(jù)，在序列中都有唯一的索引位置，在內(nèi)存中存儲時也是連續(xù)，順序存儲的，C++三個字符索引分別為：0，1，2.

圖片.png

所以，我們在切片時，取出數(shù)據(jù)是一個列表。

列表中多個元素被替換成少的元素是，也是不可以的

list1 =  ['java', 'python', 'c++', 'nodejs', 'golang']
list1[1::2]   # 從索引1開始取值，步長為2 ，取出數(shù)據(jù)：python 和 nodejs
print(list1[1::2])
# 然后做替換操作會怎么樣呢 ？
list1[1::2] = ['123']
結(jié)果當然會報錯，因為我們?nèi)〕?個元素，而只有一個替換的元素，因此會報錯。
list1[1::2] = ['123', '234']
print(list1)
-----------------輸出---------------
['python', 'nodejs']
['java', '123', 'c++', '234', 'golang']

• 結(jié)論：當設(shè)置了步長時，序列中元素的個數(shù)必須和切片中元素的個數(shù)保持一致。

• 列表反轉(zhuǎn)
  reverse
  用法： list.reverse()

• 列表排序
  sort 升序和降序排列，默認時升序排列
  用法： list.sort(reverse=True)
  當 reverser=False時不反轉(zhuǎn)，reverse=True，反轉(zhuǎn)。

list1 = ['a', 'b', 'c']
list2 = [2, 4, 1, 5, 8, 6]
list1.sort(reverse=True)
list2.sort(reverse=True)
print('修改后：', list1) # ['a', 'b', 'c']
print('修改后：', list2)  # [8, 6, 5, 4, 2, 1]
list2.sort(reverse=False)
print('修改后：', list2)  # [1, 2, 4, 5, 6, 8]
------------輸出--------------
修改后： ['a', 'b', 'c']
修改后： ['c', 'b', 'a']
修改后： [8, 6, 5, 4, 2, 1]
修改后： [1, 2, 4, 5, 6, 8]

補充 for循環(huán)遍歷

for 循環(huán)

• 作用：主要通過for 循環(huán)來遍歷列表。
• 語法：

for  變量  in  序列(遍歷的規(guī)則):
      代碼塊

注意：
for 循環(huán)的代碼塊會執(zhí)行多次，序列中有幾個元素就會執(zhí)行幾次，每執(zhí)行一次，就會將序列中的一個元素賦值給變量，所以我們可以通過變量來獲取列表中的元素。
案例：

list1 = [1,2,3,4,5,6]
for i in list1:
    print(i)
-------------正常輸出-----------
0
1
2
3
4
5
6

• 注意：當我們對列表進行for 循環(huán)時，對list 里面的內(nèi)容是無法更改的。

list1 = [1,2,3,4,5,6]
for i in list1:
    i += 1
print(list1)
--------------輸出-------------
[0, 1, 2, 3, 4, 5, 6]
# list1 依然沒變。

• for 循環(huán) else 格式：
• 對于for 循環(huán)，我們假如要改變list 里面的數(shù)據(jù)，我們可以在循環(huán)外重新定義一個新的列表。

list1 = ['a', 'b', 'c', 'd',  'e', 123]
list2 = []
for i  in list1:
     print(i)
     list2.append(i)
else:
     print("循環(huán)正常結(jié)束")
------------輸出------------
a
b
c
d
e
123
循環(huán)正常結(jié)束
['a', 'b', 'c', 'd', 'e', 123]

range() 函數(shù)

• 特點：range() 函數(shù) 是一個左閉右開區(qū)間，可以取到開始數(shù)據(jù)，但是取不到結(jié)束數(shù)據(jù)，步長默認為1，通?？梢允÷?。
• 格式：

range(開始數(shù)據(jù)，結(jié)束數(shù)據(jù)，步長)

案例使用：

range(9)   # 等價于 range(0, 9, 1)  類似于 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# range函數(shù)常與 for 循環(huán)結(jié)合使用
for i in range(9):
    print(i)
    print(list(range(9)))

• 作用：方便我們?nèi)?chuàng)建一個列表。

練習(xí)：
1、現(xiàn)在 a = [1,2,3,4,5,6] 用多種方式實現(xiàn)列表的反轉(zhuǎn) ([6,5,4,3,2,1],)，并寫出推到過程

方法一：直接通過 reverse()函數(shù)進行列表反轉(zhuǎn)
a = [1, 2, 3, 4, 5, 6]
a.reverse()
print(a)
-----------輸出------------
[6, 5, 4, 3, 2, 1]

方法二：通過sort 結(jié)合reverse 進行降序排列
# sort 默認是升序排序，再加上reverse 反轉(zhuǎn)，則進行降序排列
a.sort(reverse=True)
print(a)
-------------輸出-----------
[6, 5, 4, 3, 2, 1]

方法三：切片
# 分析： 切片，設(shè)置步長為-1, 按照下標索引，從-1開始，從右到左取值，依次打印
print(a[-1::-1])
------------輸出-------------
[6, 5, 4, 3, 2, 1]

方法四： 按照索引替換
# 分析：[1,2,3,4,5,6] 是一個列表，我們可以直接替換列表的值
根據(jù)索引替換，從下標索引0開始a[0] = 6，依次替換。
要替換6次，因此可以通過 while循環(huán)實現(xiàn)
i 作為索引下標，初始值為0 ，依次加1；j 作為列表元素，依次減 i 。
i = 0
j = 6
while i <6:
    a[i] = j-i
    i += 1
print(a)
------------輸出-------------
[6, 5, 4, 3, 2, 1]

2、有2個列表 list1 = [11,22,33] list = [22,33,44] 獲取內(nèi)容相同的元素。

分析：通過 for 循環(huán)，比較2個列表中的每個元素是否相等。
方法一：分別從list1 與 list2 取出值進行比較。
list1 = [11, 22, 33]
list2 = [22, 33, 44]
for i in list1:
    for j in list2:
        if i == j:
            print(i)

方法二:  取list1 的元素，通過 if 判斷 元素是否 in list2
list1 = [11, 22, 33]
list2 = [22, 33, 44]
for i in list1:
  if i  in list2:
     print('內(nèi)容相同的元素有：', i)
------------輸出-------------
內(nèi)容相同的元素有：22
內(nèi)容相同的元素有：33