6、Python基础之列表

一、break 和 continue 语句

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
  • 可以看到上面效果就是去除了 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
    (1) 切片可以取到开头元素，但是不能取到结尾数据
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++'
print(list1)
------------输出------------
['java', 'c', '+', '+', 'nodejs', 'golang']
  • 注意有坑： 通过索引修改来，来替换的内容必须是一个序列。
    上面 ‘C++’,也是一个序列，序列中保存的一组有序的数据，在序列中都有唯一的索引位置，在内存中存储时也是连续，顺序存储的，C++三个字符索引分别为：0，1，2.

    所以，我们在切片时，取出数据是一个列表。

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

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 循环来遍历列表。
    语法：
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]

练习：

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