一、break 和 continue 语句
break 和 continue 语句都只能用在while 和 for 循环中。
1.1 continue 语句
- continue 语句： 用来告诉python 跳出当前循环的剩余语句，然后继续进行下一轮循环。常用在 while 和 for 循环中。
案例分析：
i += 1位于 continue前面时：
i = 0
while i < 6:
i += 1
if i ==4:
continue
print(i)
else:
print('hello')
-------------执行------------
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')
--------------执行------------
0
1
2
3
4
上面案例二中， i += 1在continue后时，i ==4 时，continue程序跳出if 当前循环，又重新进入下一轮循环，这样一直在continue -->跳出-->continue …… 这样程序就问题了。所以输出一直停留在0 ，1，2，3。
continue 语句时一个删除的效果，他的纯在时为了满足循环条件下的某些不需要的成分：
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以内的奇数
i =0
while i < 10:
i += 1
if i % 2 == 0:
continue
print(i)
--------------输出--------------
1
3
5
7
9
1.2 break 语句
- break 用来立即跳出循环语句，包括else 语句。
i = 0
while i < 10:
i += 1
if i == 4:
break
print(i)
else:
print('hello python')
-----------输出----------
1
2
3
上面案例中当 i==4 时，break 直接终止了循环。
- 如果使用嵌套循环，break 语句将停止执行最深层的循环，并开始执行下一段代码。
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
总结： continue 和 break 只会对当前的所在循环跳出或终止，不会对循环外的嵌套循环产生效果。
二、序列
2.1 序列 (sequence)
- 概念： 序列是 Python中最基本的一种数据结构，用于保存一组有序的数据。
- 序列中数据都有一个唯一的索引，且数据会按照添加的顺序来分配索引。
- 数据结构：计算机中数据存储的方式。
2.2 序列分类
- 可变序列：序列中元素可以改变 比如：list.
- 不可变序列：序列中元素不可以改变 比如：字符串(str) , 元组（tuble)
2.3 列表
- 多元化存储，可以存储各种数据类型
- 数据类型： 字符串、列表、元组、字典、集合。
- 格式：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) 列表更新
我们同样可以对列表的数据项目进行修改或更新。可以使用 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 根据索引值删除并返回你删除的数据，如果没有传递索引值，那么会删除最后一个元素。（特点，按索引删除，并返回数据。）
- remove 根据指定元素删除（特点：按值删除）
2.4 切片
- 什么是切片？
- 切片是指从现有列表中获取一个子列表。
- 通过切片获取指定元素
- 语法： list [起始位置:结束位置:步长]
索引1 索引2
特性：左闭右开区间，即不包含结束位置的值
list1[1:3] : 表示取值索引1 和索引为3 的数据，即第2个和第4个数据，但是切片的特性，左闭右开区间, 最终取到就是第2和第3个数据。
(1) 切片可以取到开头元素，但是不能取到结尾数据
但是，如果切片省略了开头和结尾取到最后，就能取到整个列表 list[:]
list1 = ['java', 'python', 'nodejs', 'golang']
print(list1[1:3])
print(list1[:]) # 省略了开头和结尾，可以取到整个列表
---------输出---------
['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，从右往左取值，切片的特性可以取开头，但取不到结尾。所以最终取到 golang,nodejs。
#输出：['golang', 'nodejs']
print(list1[-3:-1]) # 没有指定步长，这里默认步长为1，即从左往右取值[-3 到-1。但是，切片的特性可以取开头，但取不到结尾。所以只能取到 python 和 nodejs。
# 输出： ['python', 'nodejs']
2.5 通用操作
- +和*
- + 两个列表拼接成要给列表
- ✳ 将两个列表重复输出为指定的次数。但是列表不能相乘，相除。
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 : 获取列表元素的个数
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) : 表示指定元素在列表中出现的次数。
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']
注意： 通过切片来修改列表时，来替换的内容必须是一个序列。并且序列还会被拆开。
上面 'C++',也是一个序列，序列中保存的一组有序的数据，在序列中都有唯一的索引位置，在内存中存储时也是连续，顺序存储的，C++三个字符索引分别为：0，1，2.
图片.png
所以，我们在切片时，取出数据是一个列表。
列表中多个元素被替换成少的元素是，也是不可以的
list1 = ['java', 'python', 'c++', 'nodejs', 'golang']
list1[1::2] # 从索引1开始取值，步长为2 ，取出数据：python 和 nodejs
print(list1[1::2])
# 然后做替换操作会怎么样呢 ？
list1[1::2] = ['123']
结果当然会报错，因为我们取出2个元素，而只有一个替换的元素，因此会报错。
list1[1::2] = ['123', '234']
print(list1)
-----------------输出---------------
['python', 'nodejs']
['java', '123', 'c++', '234', 'golang']
结论：当设置了步长时，序列中元素的个数必须和切片中元素的个数保持一致。
列表反转
reverse
用法： list.reverse()
- 列表排序
sort 升序和降序排列，默认时升序排列
用法： list.sort(reverse=True)
当 reverser=False时不反转，reverse=True，反转。
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循环遍历
for 循环
- 作用：主要通过for 循环来遍历列表。
- 语法：
for 变量 in 序列(遍历的规则):
代码块
注意：
for 循环的代码块会执行多次，序列中有几个元素就会执行几次，每执行一次，就会将序列中的一个元素赋值给变量，所以我们可以通过变量来获取列表中的元素。
案例：
list1 = [1,2,3,4,5,6]
for i in list1:
print(i)
-------------正常输出-----------
0
1
2
3
4
5
6
- 注意：当我们对列表进行for 循环时，对list 里面的内容是无法更改的。
list1 = [1,2,3,4,5,6]
for i in list1:
i += 1
print(list1)
--------------输出-------------
[0, 1, 2, 3, 4, 5, 6]
# list1 依然没变。
- for 循环 else 格式：
- 对于for 循环，我们假如要改变list 里面的数据，我们可以在循环外重新定义一个新的列表。
list1 = ['a', 'b', 'c', 'd', 'e', 123]
list2 = []
for i in list1:
print(i)
list2.append(i)
else:
print("循环正常结束")
------------输出------------
a
b
c
d
e
123
循环正常结束
['a', 'b', 'c', 'd', 'e', 123]
range() 函数
- 特点：range() 函数 是一个左闭右开区间，可以取到开始数据，但是取不到结束数据，步长默认为1，通常可以省略。
- 格式：
range(开始数据，结束数据，步长)
案例使用：
range(9) # 等价于 range(0, 9, 1) 类似于 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# range函数常与 for 循环结合使用
for i in range(9):
print(i)
print(list(range(9)))
- 作用：方便我们去创建一个列表。
练习：
1、现在 a = [1,2,3,4,5,6] 用多种方式实现列表的反转 ([6,5,4,3,2,1],)，并写出推到过程
方法一：直接通过 reverse()函数进行列表反转
a = [1, 2, 3, 4, 5, 6]
a.reverse()
print(a)
-----------输出------------
[6, 5, 4, 3, 2, 1]
方法二：通过sort 结合reverse 进行降序排列
# sort 默认是升序排序，再加上reverse 反转，则进行降序排列
a.sort(reverse=True)
print(a)
-------------输出-----------
[6, 5, 4, 3, 2, 1]
方法三：切片
# 分析： 切片，设置步长为-1, 按照下标索引，从-1开始，从右到左取值，依次打印
print(a[-1::-1])
------------输出-------------
[6, 5, 4, 3, 2, 1]
方法四： 按照索引替换
# 分析：[1,2,3,4,5,6] 是一个列表，我们可以直接替换列表的值
根据索引替换，从下标索引0开始a[0] = 6，依次替换。
要替换6次，因此可以通过 while循环实现
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] 获取内容相同的元素。
分析：通过 for 循环，比较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('内容相同的元素有：', i)
------------输出-------------
内容相同的元素有：22
内容相同的元素有：33
