第六课（break和continue，列表，for循环，rang函数）

最新推荐文章于 2023-04-20 20:33:34 发布

weixin_44831124

最新推荐文章于 2023-04-20 20:33:34 发布

阅读量266

点赞数

文章标签： python

本文链接：https://blog.csdn.net/weixin_44831124/article/details/113836458

版权

第六课

一.break和continue
二.序列（sequence）
三.列表(list)
四.for循环
- 语法：
五.range函数（）
六.作业

一.break和continue

break 可以用来立即退出循环语句,包括else语句
continue 用来跳过当初循环

二.序列（sequence）

基本概念

序列是Python中最基本的一种数据结构。序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引）并且序列中的数据会按照添加的顺序来分配索引
数据结构指计算机中数据存储的方式

序列的分类

可变序列（序列中的元素可以改变）：例如列表（list）
不可变序列（序列中的元素不能改变）：例如字符串（str）元组（tuple）

三.列表(list)

列表是Python中的一个对象
列表的作用
- 列表中可以保存多个有序的数据
- 列表是用来存储对象的对象
通过[]来创建一个空列表
列表通过索引来取数据

# 列表支持增删改查
#列表用[]表示
#空列表可用[]创建
list0 = [] 
list1 = [1,'python',False,None]
print(list1,type(list1))    # 输出为：[1, 'python', False, None] <class 'list'>

#列表是用来存储对象的对象
#列表通过索引来取数据
print(list1[1]) # 输出为：python
print(list1[3]) # 输出为：None
print(list1[-1]) # 输出为：None
print(list1[-3]) # 输出为：python

切片（同字符串切片）

切片是指从现有列表中获得一个子列表
通过切片来获取指定的元素
语法: 列表[起始 : 结束 : 步长]
通过切片获取元素时,会包括起始位置的元素,不会包括结束位置的元素
起始位置和结束位置的索引可以不写
- 如果省略结束位置, 则会从当前的开始位置一直截取到最后
- 如果省略开始位置, 则会从第一个元素截取到结束的元素，但是不包括结束的元素
- 如果开始位置和结束位置都省略, 则则会从第一个元素开始截取到最后一个元素
步长表示每次获取元素的间隔，默认是1(可以省略不写)
步长不能是0,但可以是是负数

通用操作

+ 和 *
- + 可以将两个列表拼接成一个列表
- * 可以将列表重复指定的次数 (注意2个列表不能够做乘法，要和整数做乘法运算)

# 通用操作
a = [1,2,3] + [4,5,6]
print(a)    # 输出为：[1, 2, 3, 4, 5, 6]
a = [1,2,3] * 3
print(a)    # 输出为：[1, 2, 3, 1, 2, 3, 1, 2, 3]

in 和 not in
- in用来检查指定元素是否在列表当中
- not in 用来检查指定元素是否不在列表当中

a = [1,2,3]
print(1 in a )  # 输出为：True

len() 获取列表中元素的个数

a = [1,2,5]
print(len(a))   # 输出为：3

max() 获取列表中最大值
min() 获取列表中最小值

a = [1,2,5]
print(max(a))   # 输出为：5
print(min(a))   # 输出为：1

list.index(x[,start[,end]])
- 第一个参数获取指定元素在列表中的位置
- 第二个参数表示查找的起始位置
- 第三个参数表示查找的结束位置
- 列表是没有find方法的

a = [1,2,5]
print(a.index(1))   # 输出为：0
print(a.index(2))   # 输出为：1
print(a.index(5))   # 输出为：2

当指定起始位置和结束位置时，查询时包含起始索引，但是不包含结束索引。

a = [1,2,5]
print(a.index(5))   # 输出为：2
# help(a.index)
print(a.index(5,0,2))
'''
输出为:
Traceback (most recent call last):
  File "F:/python/第6课/lx.py", line 7, in <module>
    print(a.index(5,0,2))
ValueError: 5 is not in list
2   此处数值2为 print(a.index(5)) 语句所输出。
'''

a = [1,2,5]
print(a.index(5))   # 输出为：2
print(a.index(5,0,3))
'''
输出为:
2	#print(a.index(5))输出
2	#print(a.index(5,0,3))输出
'''

list.count(x) 统计指定元素在列表中出现的个数

a = [1,1,1,1,3,3,4,4,4]
print(a.count(1))   # 输出为：4
print(a.count(3))   # 输出为：2
print(a.count(4))   # 输出为：3

修改列表

通过切片来修改(其实就是给切片的内容重新赋值，但是赋值的内容必须是一个序列)

# 修改列表
list2 = ["中国","美国","日本","英国","西班牙","印度","德国"]
list2[-2] = '意大利'
print(list2)
'''
输出为:
['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国']
'''

当设值了起始位置、结束位置时，

list4 = ['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国']
# 切片的方式来修改
list4[3:5] = "外国"
print(list4)
'''
输出为:
['中国', '美国', '日本', '外', '国', '意大利', '德国']
'''

# 当切片的序列小于要赋值的索引时
list5 = ['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国']
print(len(list5))
print(list5[3:6])
list5[3:6] = "外国"
print(len(list5))
print(list5)
'''
输出为:
7
['英国', '西班牙', '意大利']
6
['中国', '美国', '日本', '外', '国', '德国']
'''

# 当切片的序列大于要赋值的索引时
list6 = ['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国']
print(len(list6))
print(list6[3:4])
list6[3:4] = "外国人"
print(len(list6))
print(list6)
'''
输出为:
7
['英国']
9
['中国', '美国', '日本', '外', '国', '人', '西班牙', '意大利', '德国']
'''

# 当切片的序列为空时，就是进行删除操作
list7 = ['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国']
print(len(list7))
print(list7[3:6])
list7[3:6] = ""
print(len(list7))
print(list7)
'''
输出为:
7
['英国', '西班牙', '意大利']
4
['中国', '美国', '日本', '德国']
'''

注：
- 通过索引对多个索引进行赋值时，会将所赋值的序列拆开赋值。
- （自己的理解：）将所取出的索引用所赋值的序列拆开替换，。

当设置了步长时,序列中元素的个数必须和切片中元素的个数保持一致
(当我们设置了步长的时候，那么你取到多少个数据，你替换的数据就要有多少个)

# 当我们设置了步长的时候，那么你取到多少个数据，你替换的数据就要有多少个
list9 = ['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国']
print(len(list9))
print(list9[::2])
list9[::2] = "123"
print(len(list9))
print(list9)
'''
输出为:
Traceback (most recent call last):
  File "F:/python/第6课/lx.py", line 5, in <module>
    list9[::2] = "123"
ValueError: attempt to assign sequence of size 3 to extended slice of size 4
7
['中国', '日本', '西班牙', '德国']
'''

list10 = ['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国']
print(len(list10))
print(list10[::2])
list10[::2] = "1234"
print(len(list10))
print(list10)
'''
输出为:
7
['中国', '日本', '西班牙', '德国']
7
['1', '美国', '2', '英国', '3', '意大利', '4']
'''

删除元素
- 1.通过关键字del进行删除：del list[起始 : 结束]
- 2.list = []
- 3.见上一步，切片时使用空字符串删除。

list3 = ['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国']
del list3[-1]
print(list3)
'''
输出为:
['中国', '美国', '日本', '英国', '西班牙', '意大利']
'''

列表的方法

（方法是和面向对象相关的使用方式是：对象.方法名（‘参数’））

append() 像列表的最后添加一个元素

list11 = ['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国']
# list.append()  向类表中最后的位置插入一个元素
list11.append('葡萄牙')
print(list11)
'''
输出为:
['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国', '葡萄牙']
'''

insert(arg1,arg2) 像列表指定位置插入一个元素参数1:要插入的位置参数2:要插入的元素

list11 = ['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国']
# list.insert() 向列表中的指定位置插入一个元素，第一个参数是要插入的位置，第二个参数是要插入的内容
list11.insert(4,'葡萄牙')
print(list11)
'''
输出为:
['中国', '美国', '日本', '英国', '葡萄牙', '西班牙', '意大利', '德国']
'''

extend(iterable) 使用一个新的序列来扩展当前序列(它会将该序列的中元素添加到列表中) 参数需要传递一个序列

list11 = ['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国']
# list.extend() 使用新的序列来扩展当前序列
list11.extend(['葡萄牙', '澳大利亚'])
print(list11)
'''
输出为:
['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国', '葡萄牙', '澳大利亚']
'''

pop() 根据索引删除并返回指定元素

list11 = ['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国']
# list.pop() 根据索引删除并返回元素， 如果不传递索引，默认删除最后一个
a = list11.pop()
print(a)
print(list11)
'''
输出为:
德国
['中国', '美国', '日本', '英国', '西班牙', '意大利']
'''

list11 = ['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国']
# list.pop() 根据索引删除并返回元素， 如果不传递索引，默认删除最后一个
a = list11.pop(4)
print(a)
print(list11)
'''
输出为:
西班牙
['中国', '美国', '日本', '英国', '意大利', '德国']
'''

remove() 删除指定元素 (如果相同值的元素有多个，只会删除第一个)

list11 = ['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国','德国','德国','德国']
# list.remove() 删除指定的元素,如果相同值的元素有多个，只会删除第一个
list11.remove('德国')
print(list11)
'''
输出为:
['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国', '德国', '德国']
'''

reverse() 翻转列表

注：

reverse() 方法会对列表本身进行修改，并且永久性的修改了列表元素的排列。

list11 = ['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国','德国','德国','德国']
# 反转列表 reverse()
list11.reverse()
print(list11)
'''
输出为:
['德国', '德国', '德国', '德国', '意大利', '西班牙', '英国', '日本', '美国', '中国']
'''

sort(key=None,reverse=False) 用来对列表中的元素进行排序默认是正序排序
- 参数key，可以提供一个函数来作为排序的依据
- 参数reverse：True反序；False 正序

注：

sort方法会对列表本身进行修改，并且永久性的修改了列表元素的排列。
若只需临时对列表进行排序，可使用函数sorted()函数

list11 = ['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国','德国','德国','德国']
# 排序
# list.sort()  默认是正序排序 他有一个参数reverse
list11.sort(reverse=True)
print(list11)
'''
输出为:
['西班牙', '英国', '美国', '日本', '意大利', '德国', '德国', '德国', '德国', '中国']
'''

# 列表的方法
list11 = ['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国','德国','德国','德国']
# 排序
# list.sort()  默认是正序排序 他有一个参数reverse
list11.sort(reverse=False)
print(list11)
'''
输出为:
['中国', '德国', '德国', '德国', '德国', '意大利', '日本', '美国', '英国', '西班牙']
'''

list11 = ['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国','德国','德国','德国']
# 排序
# sorted()  临时对列表排序，默认是正序排序 他有一个参数reverse
print(sorted(list11))
print(list11)
'''
输出为:
['中国', '德国', '德国', '德国', '德国', '意大利', '日本', '美国', '英国', '西班牙']
['中国', '美国', '日本', '英国', '西班牙', '意大利', '德国', '德国', '德国', '德国']
'''

四.for循环

通过for循环来遍历列表

语法：

for 变量 in 序列(遍历的规则):
代码块
else:
代码块
注意:

for循环的代码块会执行多次,序列中有几个元素就会执行几次。每执行一次就会将序列中的一个元素赋值给变量,所以我们可以通过变量来获取列表中的元素
禁止在for循环中对原列表的长度进行修改操作。如果你在循环过程中对列表的长度做了修改，那么你的循环次数就不在受控制了。

五.range函数（）

range(start, stop[, step])
参数说明
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5）是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5）等价于 range(0, 5, 1)

六.作业

1.现在有 a = [1,2,3,4,5,6] 不通过函数的形式实现列表的反转([6,5,4,3,2,1]) 并写出推导过程

#1.现在有 a = [1,2,3,4,5,6] 不通过函数的形式实现列表的反转([6,5,4,3,2,1]) 并写出推导过程
#第一种方法。
a = [1,2,3,4,5,6]
#使用切片翻转
b = a[::-1]
print(b)

a = [1,2,3,4,5,6]
#使用while函数翻转
i = 1
b = []
while i<7:
    b.append(a[len(a)-i])
    i += 1
print(b)

a = [1,2,3,4,5,6]
b = []
#使用for函数翻转
for i in range(1,len(a)+1):
    b.append(a[len(a)-i])
print(b)

a = [1,2,3,4,5,6]
#直接使用翻转列表函数
a.reverse()
print(a)

a = [1,2,3,4,5,6]
# 使用排序函数
a.sort(reverse=True)
print(a)

2.给用户9次机会猜1-10个数字随机来猜数字。如果随机的数字和用户输入的数字一致则表示正确，如果不一致则表示错误。最终结果要求用户怎么也猜不对。

i=1
b = []
c = [1,2,3,4,5,6,7,8,9,10]
while i < 10:
    a = input("请输入你猜的数字:")
    try:
        a = eval(a)
        if type(a) == int:
            if 1 <= a <=10:
                b.append(a)
                print("猜错了！")
            else:
                print("你输入的数据不合法！")
                continue
        else:
            print("你输入的数据不合法！")
            continue
    except:
        print("你输入的数据不合法！")
        continue
    i += 1
for j in c:
    if j not in b:
        d.append(j)
# d = list(set(c)-set(b))   #第二种方法,求两个集合差集
print("随机的数字为：",d[0])

3.有两个列表lst1=[11,22,33]，lst2=[22,33,44]获取内容相同的元素

a = []
lst1=[11,22,33]
lst2=[22,33,44]
for i in lst1:
    if i in lst2:
        a.append(i)
# a = list(set(lst1)&set(lst2))	#第二种方法,求两个集合交集
print(a)

4.现在有8位老师，3个办公室，要求将8位老师随机的分配到三个办公室中。

import random
teachers = list(range(1,9))
offices = [[],[],[]]
for teacher in teachers:
    a = random.randint(0,2)
    offices[a].append(teacher)
print(offices)

5.现在有8位老师，3个办公室，要求将8位老师随机的分配到三个办公室中，要求每个办公室至少有一个老师（如果觉得上面的题不够写的话，写这个）。

import random
teachers = list(range(1, 9))
offices = [[], [], []]
for teacher in teachers:
    a = random.randint(0, 2)
    if teacher == teachers[7]:
        for office in offices:
            if office == []:
                office.append(teacher)
            else:
                offices[a].append(teacher)
    else:
        offices[a].append(teacher)
print(offices)