Python 목록에 대한 자세한 설명

추천 무료 학습: python 비디오 튜토리얼

python: list

• 1. 기본 개념
• 1.2. 색인
  • 1.3、 실제 적용
  • 2. 리스트(list)
• 2.1. 리스트의 개념
• 2.2. 슬라이싱의 개념
  • 3.2. 문법
  3.3.실전 적용
• 4. 일반 작업
  • 4.1 조작 및 지침
  • 4.2 실제 적용
• 5.1, 직접 수정
• 5 .2 , 슬라이스 수정
  • 5.3. 키워드 삭제
  6. 목록 방법
• 6.1 방법 및 설명
  • 6.2 실제 적용
  • 6.2.1. 방법 추가
  6.2.4. 운문 the list
• 6.2.1, Sort
• • 7, 조건문 보충(for 루프)
  • • 7.1, 기본 개념
    • 7.2, for 루프 구문
    • 7.2 range 사용법
    8. 방과후 숙제
• 8.1. 이제 목록을 뒤집는 데는 = [1,2,3,4,5,6]이 있습니다. ,1]) 그리고 도출 과정을 기록합니다
• 8.2 사용자에게 무작위로 1~10개의 숫자를 추측할 수 있는 기회를 9번 제공합니다.
  • 8.3. 동일한 내용의 요소를 얻으려면 lst1 = [11, 22, 33] lst2 = [22, 33, 44]가 필요합니다.
  • 8.4 이제 8명의 교사와 3개의 사무실이 필요합니다. 8명의 교사를 3개 사무실에 무작위 배정
  9. 추가(개인 코드 연습)
• 9.1.1/1-1/2+1/3-1/4+1/5... + 1 /99 - 1/100
  • 9.2의 값을 계산합니다. 1/3+3/5+5/7+...+97/99
  • 9.3. 2개의 값을 입력하고 그 사이에 몇 개의 소수가 있는지 구한 후 모든 소수를 출력합니다
1. 시퀀스(sequence)
• •  실제로 시퀀스의 인덱스는 이전 네 번째 블로그의 String Slicing에서 언급한 적이 있는데, 매우 중요하기 때문에 여기서 다시 언급합니다. , 중요하다, 중요하다, 매우 중요한 것은 세 번 말해야 합니다. 관심 있는 친구는 블로그 링크를 클릭하여 살펴볼 수 있습니다. 물론 이 기사에서는 목록 분할에 대해서도 설명합니다
  • 1.1 기본 개념

순서는 Python에서 가장 기본적인 데이터 구조입니다.   시퀀스는 순서가 지정된 데이터 집합을 저장하는 데 사용됩니다. 모든 데이터는 시퀀스에서 고유한 위치(인덱스)를 가지며 시퀀스의 데이터에는 추가된 순서대로 인덱스가 할당됩니다.
 시퀀스는 컨테이너라고 불리는 데이터 구조입니다. 시퀀스(예: 목록, 튜플) 및 맵(예: 사전) 시퀀스의 각 요소에는 숫자가 있고 맵의 각 요소에는 이름( 키)이 있습니다. /code>이며 컬렉션은 시퀀스 유형의 컨테이너도 아니고 매핑된 유형도 아닙니다.

  시퀀스는 인덱싱, 슬라이싱, 덧셈, 곱셈 및 요소가 시퀀스에 속하는지 확인하는 등 몇 가지 특수 작업을 수행할 수 있습니다. 게다가, 파이썬은 시퀀스의 길이를 계산하고 최대 함수와 최소 함수의 내장 함수를 찾을 수도 있습니다.

字符串切片中有说到过，这里再次提一下，因为它很重要，重要，重要，很重要的事情要说3遍嘛。博客链接，感兴趣的朋友可以点过去看看，当然，本篇中也讲述了列表的切片哦

1.1、基本概念

• 序列是Python中最基本的一种数据结构。

   序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引）并且序列中的数据会按照添加的顺序来分配索引
    序列就是名为容器的数据结构。序列（例如：列表，元组）和映射（例如：字典），序列中的每个元素都有一个编号，而映射中的每个元素都有一个名字（键），而集合既不是序列类型的容器也不是映射的类型。
    序列可以一些特殊的操作：索引，分片，加，乘，检查某个元素是否属于序列。除此之外python还可以计算序列的长度，找出最大函数和最小函数的内建函数。

• 数据结构指计算机中数据存储的方式

• 序列的分类：

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

1.2、索引

    数组索引，数组索引机制指的是用方括号（[]）加序号的形式引用单个数组元素，它的用处很多，比如抽取元素，选取数组的几个元素，甚至为其赋一个新值。
这里拿一个列表的索引展示一下，例如数组 a=['a','b','c','d','e','f','g','h','i']

데이터 구조는 데이터가 컴퓨터에 저장되는 방식을 나타냅니다. 가변 시퀀스(시퀀스의 요소는 변경될 수 있음): 목록(list)과 같은 불변 시퀀스( 순서대로 요소를 변경할 수 없음): 예를 들어 문자열(str) 튜플(tuple) 1.2, 인덱스  배열 인덱스, 배열 인덱스 메커니즘은 대괄호([ ]) 및 일련 번호 단일 배열 요소를 참조하면 요소 추출, 배열의 여러 요소 선택, 새 값 할당 등 다양한 목적으로 사용될 수 있습니다. list

시퀀스 분류:								여기서는 목록의 인덱스를 보여줍니다(예: 배열 a=['a','b','c','d','e','f','g','h). ', 'i']
'a'	'b'	'c'	'd'	'e'	'f	'g '	'h'	'i'
번호(양수순)	0	1	2	3	4	5	6	7	8

번호(역순)🎜🎜-9🎜🎜-8🎜🎜-7🎜🎜-6🎜🎜-5🎜🎜-4🎜🎜-3🎜🎜-2🎜🎜-1🎜🎜🎜 🎜

1.3 실제 적용

• 다음은 인덱싱을 통해 단일 배열의 요소를 얻는 배열입니다.

a=['a','b','c','d','e','f','g','h','i']
print(a[0])
# 运行结果 》》》a

print(a[4])
# 运行结果 》》》e

print(a[8])
# 运行结果 》》》i

print(a[-1])
# 运行结果 》》》i

2. 리스트(list)

2.1. 리스트의 개념

리스트는 Python의 객체입니다.
리스트의 역할:

• 여러 개의 정렬된 데이터를 저장할 수 있습니다. list
• List는 객체를 저장하는 데 사용되는 객체입니다

  리스트는 특정 순서로 배열된 일련의 요소로 구성되며 일반적으로 여러 요소를 포함합니다. 예: 문자열, 정수 값, 부동 소수점 값, 목록 , 없음, 목록, 사전 등. 파이썬에서는 대괄호 [ ]를 사용하여 목록을 나타내고, 쉼표를 사용하여 요소를 구분합니다. 例如：字符串，整型数值，浮点型数值，列表，None,列表，字典等。在python中，用方括号[ ] 表示列表，并用逗号分割其中的元素

2.2、 列表的使用

• 列表的创建：通过[]来创建一个空列表

a=[]
print(a)
# 运行结果 》》》[]

• 列表的创建：直接赋值

a=['a','b','c','d','e','f','g','h','i']
print(a)
# 运行结果 》》》['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']

3、切片

3.1、切片的概念

    在第四讲对字符串的切片中有讲过字符串切片的用法，其实切片不止是字符串能用，列表list，元组tuple都能够使用切片。
    切片做的事情在已知的数据上取出想要的部分。切片是在可迭代对象的基础上，取出任意长度的元素，同时取得范围、频次也是可以自定义的
总结：切片是取操作，不改变原值

• 切片是指从现有可迭代对象（列表）中获得一个子列表
• 通过切片来获取指定的元素

3.2、语法

• 列表[起始 : 结束 : 步长] 左闭右开区间 取头不取尾 步长默认是1

详细一点讲就是：
1、左闭右开区间：在通过切片获取元素时,会包括起始位置的元素,不会包括结束位置的元素

2.2 목록의 사용
• 목록 생성: []를 사용하여 빈 목록을 생성합니다

a=['a','b','c','d','e','f','g','h','i']

print(a[::])
# 运行结果 》》》['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
# 运行讲解：起始位置、结束位置和步长都是空，既打印所有列表元素

print(a[0:3])   # 默认步长为1
# 运行结果 》》》['a', 'b', 'c']
# 运行讲解：a列表从第一位a取到第4位d，d不可取，所以只能取到c，既abc这3个元素
# 也可以是如下写法，从 0 开始就可以把初始位置省略，效果如上
print(a[:3])

print(a[0:4:2])    # 初始位置为0可省略
# 运行结果 》》》['a', 'c']
# 运行讲解：a列表从第一位a取到第5位e，e不可取，步长为2,只能取到ac

print(a[-1:-4])
# 运行结果 》》》[]
# 运行讲解：步长不写默认为1，但初始和结束位置为负，但初始大于结束位置，则什么值都取不到

print(a[-4:-1:1])
# 运行结果 》》》['f', 'g', 'h']
# 运行讲解：初始小于结束位置，从倒数第4位f取到最后1位i,i不可取，步长为1

print(a[-1:-4:-1])
# 运行结果 》》》['i', 'h', 'g']
# 运行讲解：从倒数第一位i取到倒数第4位e（e不可取）。

print(a[::-1])
# 运行结果 》》》['i', 'h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']
# 运行讲解：初始和结束位置都为空，步长为负，则逆序打印

리스트 생성: 직접 할당

a = [1, 2, 3] + [4, 5, 6]
print(a)
# 运行结果 》》》[1, 2, 3, 4, 5, 6]

3, slicing

3.1, 슬라이싱의 개념

  스트링 슬라이싱에 대한 네 번째 강의에서 실제로 스트링 슬라이싱의 사용법에 대해 이야기했습니다. 슬라이싱은 단순한 문자열 그 이상입니다. 슬라이싱은 목록과 튜플 모두에 사용될 수 있습니다.   슬라이싱이 하는 일은 알려진 데이터에서 원하는 부분을 추출하는 것입니다. 슬라이싱은 반복 가능한 객체를 기반으로 하며, 획득 범위와 빈도도 사용자 정의할 수 있습니다.요약: 슬라이싱은 원래 값을 변경하지 않고 가져오는 작업입니다.

슬라이싱은 참조입니다. 기존 반복 가능한 객체(목록)에서 하위 목록을 얻으려면

slicing3.2, SyntaxList [시작 : 끝: 단계 크기로 지정된 요소 가져오기 ] 왼쪽 닫힘 오른쪽 열림 간격은 머리 부분을 가져오지만 꼬리 부분은 가져오지 않습니다. 기본 단계 크기는 1자세한 내용은 다음과 같습니다. 2. 시작 위치와 끝 위치의 인덱스는 필요하지 않습니다. 쓰세요시작 위치와 끝 위치가 모두 생략되면 첫 번째 요소부터 차단됩니다. 마지막 요소 차단을 시작합니다 4. 단계 크기는 0이 될 수 없지만 음수는 가능합니다3.3 실제 적용 슬라이싱 학습에 대한 개인적인 경험: 권장합니다. 아무리 많은 개념을 보아도 여러 번 연습하는 것보다 항상 더 좋습니다.

a = [1, 2, 3] *3
print(a)
# 运行结果 》》》[1, 2, 3, 1, 2, 3, 1, 2, 3]

# 错误用法：列表乘列表，不用这样使用
a = [1, 2, 3] * [4, 5, 6]
#上面这种写法会报错的哦，像这样：
# TypeError: can't multiply sequence by non-int of type 'list'
# 类型错误:不能用“列表”类型的非整数乘序列

4. 일반 작업4.1 작업 및 지침OperationInstructions+* 목록을 지정된 횟수만큼 반복할 수 있습니다지정된 요소가 목록에 없는지 확인하는 데 사용됩니다len()

	1. 왼쪽 닫힘 오른쪽 열림 간격: 슬라이싱 요소를 통해 얻은 경우, 시작 위치의 요소는 포함되지만 끝 위치의 요소는 포함되지 않습니다.
끝 위치를 생략하면 현재 위치부터 시작합니다. 끝까지 위치를 가로막습니다	시작 위치를 생략하면 첫 번째 요소부터 끝 요소까지 가로채지만, 끝 요소는 포함되지 않습니다
3 단계 크기는 가져오는 각 요소의 간격을 나타냅니다. 기본값은 1(생략 가능)
	연결할 수 있습니다. 두 개의 목록을 하나의 목록으로
	(두 개의 목록은 곱할 수 없으며 정수로 곱해야 합니다)
in	은 지정된 요소가 목록에 있는지 확인하는 데 사용됩니다
not in

🎜목록에 있는 요소 수를 가져옵니다.🎜🎜🎜🎜max()🎜🎜목록의 최대값을 가져옵니다. 🎜🎜🎜🎜min()🎜🎜목록의 최소값 가져오기🎜🎜🎜🎜list.index(x[, start[, end]])🎜🎜첫 번째 매개변수는 목록에서 지정된 요소의 위치를 ​​가져옵니다🎜The 두 번째 매개변수는 검색 시작 위치를 나타냅니다🎜세 번째 각 매개변수는 검색의 끝 위치를 나타냅니다🎜🎜🎜🎜list.count(x)🎜🎜목록에 나타나는 지정된 요소의 수를 계산합니다🎜🎜🎜🎜list.copy (x)🎜🎜Shallow copy list🎜🎜🎜🎜cmp( list1, list2) 🎜 연산자 모듈 🎜🎜 두 목록의 요소를 비교 🎜🎜🎜🎜

4.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]

# 错误用法：列表乘列表，不用这样使用
a = [1, 2, 3] * [4, 5, 6]
#上面这种写法会报错的哦，像这样：
# TypeError: can't multiply sequence by non-int of type 'list'
# 类型错误:不能用“列表”类型的非整数乘序列

• in的使用

a = ['p','y','t','h','o','n']
print('y' in a)
# 运行结果 》》》True

• not in的使用

a = ['p','y','t','h','o','n']
print('y' not in a)
# 运行结果 》》》 False

• len() 的使用

a = ['p','y','t','h','o','n']
print(len(a))
# 运行结果 》》》6

• max()的使用

b = [1, 2, 3, 1]
print(max(b))
# 运行结果 》》》3

• min()的使用

b = [1, 2, 3, 1]
print(min(b))
# 运行结果 》》》1

• list.index的使用

a = ['p','y','t','h','o','n']
print(a.index('y'))
# 运行结果 》》》1
# 返回的结果就是当前这个数据‘y’的索引

注：列表没有find用法，使用find会报错的

• list.count(x)

a = ['p','y','t','h','o','n','y']
print(a.count('y'))
# 运行结果 》》》2
# 查找有几个这种元素

• list.copy(x)

a = ['p','y','t','h','o','n']
print(a.copy())
# 运行结果 》》》['p', 'y', 't', 'h', 'o', 'n']

• cmp(list1, list2)，这里用operator模块

# cmp是python2中的函数，python3中以无法使用，可以用operator代替，效果一样的
a = ['11','22','33']
b = ['22','33','44']
import operator
print(operator.eq(a,b))
# 运行结果 》》》False

这里有一种关于operator模块的使用，感兴趣的朋友可以了解一下

5、修改列表

通过切片来修改(起始就是给切片的内容重新赋值，但是赋值的内容必须是一个序列)
当设置了步长时,序列中元素的个数必须和切片中元素的个数保持一致
通过切片来删除元素

• del list[起始 : 结束]
  list = []

5.1、 直接修改

a = ['孙悟空', '猪八戒', '鲁班', '露娜', '安琪拉', '虞姬']
a[-1] = '亚瑟'
print(a)
# 运行结果 》》》['孙悟空', '猪八戒', '鲁班', '露娜', '安琪拉', '亚瑟']

5.2、切片修改

a = ['孙悟空', '猪八戒', '鲁班', '露娜', '安琪拉', '虞姬']
print(a[3:5])
# 运行结果 》》》['露娜', '安琪拉']

a[3:4] = '橘右京'
print(a)
# 运行结果 》》》['孙悟空', '猪八戒', '鲁班', '橘', '右', '京', '安琪拉', '虞姬']

a[3:5] = '李白'
print(a)
# 运行结果 》》》['孙悟空', '猪八戒', '鲁班', '李', '白', '京', '安琪拉', '虞姬']

a[0:0] = ['牛魔']
print(a)
# 运行结果 》》》['牛魔', '孙悟空', '猪八戒', '鲁班', '李', '白', '京', '安琪拉', '虞姬']

a[::2] = ['凯','凯','凯','凯','凯']
print(a)
# 运行结果 》》》['凯', '孙悟空', '凯', '鲁班', '凯', '白', '凯', '安琪拉', '凯']
# 取到多少个数据，替换的数据就得有多少

print(a)
print(a.index('安琪拉'))
# 运行结果 》》》7

5.3、 删除 关键字

a = ['孙悟空', '猪八戒', '鲁班', '露娜', '安琪拉', '虞姬']
del a[-1]
# 运行结果 》》》['孙悟空', '猪八戒', '鲁班', '露娜', '安琪拉']

6、列表的方法

6.1 方法与说明

方法	说明
append()	像列表的最后添加一个元素
insert(arg1,arg2)	像列表指定位置插入一个元素 参数1:要插入的位置 参数2:要插入的元素
extend(iterable)	使用一个新的序列来扩展当前序列 (它会将该序列的中元素添加到列表中) 参数需要传递
pop()	根据索引删除并返回指定元素
remove()	删除指定元素 (如果相同值的元素有多个，只会删除第一个)
reverse()	翻转列表
sort(key=None,reverse=False)	用来对列表中的元素进行排序 reverse：True反序；False 正序

6.2 实际运用

6.2.1、添加方法

• append()

# list.append()  向类表中最后的位置插入一个元素
a = ['孙悟空', '猪八戒', '鲁班', '露娜', '安琪拉', '虞姬']
a.append('凯')
print(a)
# 运行结果 》》》['孙悟空', '猪八戒', '鲁班', '露娜', '安琪拉', '虞姬', '凯']

• insert(arg1,arg2)

# list.insert() 向列表中的指定位置插入一个元素，第一个参数是要插入的位置，第二个参数是要插入的内容
a = ['孙悟空', '猪八戒', '鲁班', '露娜', '安琪拉', '虞姬']
a.insert(4, '亚瑟')
print(a)
# 运行结果 》》》['孙悟空', '猪八戒', '鲁班', '露娜', '亚瑟', '安琪拉', '虞姬']

• extend(iterable)

# list.extend() 使用新的序列来扩展当前序列，就是添加多个元素
a = ['孙悟空', '猪八戒', '鲁班', '露娜', '安琪拉', '虞姬']
a.extend(['亚瑟', '凯'])
print(a)
# 运行结果 》》》['孙悟空', '猪八戒', '鲁班', '露娜', '安琪拉', '虞姬', '亚瑟', '凯']

6.2.2、删除方法

• pop()

# list.pop() 根据索引删除并返回元素， 如果不传递索引，默认删除最后一个
a = ['孙悟空', '猪八戒', '鲁班', '露娜', '安琪拉', '虞姬']
a = a.pop()
print(a)
运行结果 》》》虞姬

• remove()

# list.remove() 删除指定的元素
a = ['孙悟空', '猪八戒', '鲁班', '露娜', '安琪拉', '虞姬']
a.remove('鲁班')
print(a)
运行结果 》》》['孙悟空', '猪八戒', '露娜', '安琪拉', '虞姬']

6.2.4、反转列表

• reverse()

a = ['孙悟空', '猪八戒', '鲁班', '露娜', '安琪拉', '虞姬']
a.reverse()
print(a)
运行结果 》》》['虞姬', '安琪拉', '露娜', '鲁班', '猪八戒', '孙悟空']

6.2.1、排序

• sort(key=None,reverse=False)

# list.sort()  默认是正序排序 他有一个参数reverse
a = [4,5,2,7,1,0,5,8]
a.sort(reverse=True)
print(a)
运行结果 》》》[8, 7, 5, 5, 4, 2, 1, 0]

7、对条件语句的补充（for循环）

7.1、基本概念

    for 语句是 Python 中执行迭代的两个语句之一，另一个语句是 while。while在之前的博客里有讲过，这里我们补充介绍一下for循环的用法。
    Python 中，for 循环用于遍历一个迭代对象的所有元素。循环内的语句段会针对迭代对象的每一个元素项目都执行一次。这里我们用的迭代对象就是列表和range。

7.2、for 循环语法

• 字符串

for i(迭代变量) in 'Python':
	循环体

• range

for i(迭代变量) in range(1,9):
	循环体

• 序列

for i(迭代变量) in 序列(遍历的规则):
	循环体

7.2 range的用法

• for 迭代变量 in range ( i, j [,k ]):

参数说明：

这个也是左闭右开区间，所以终止值不可取
i: 初始值（默认为‘0’）
j: 终止值（默认为‘1’）
k: 步长值，即每次重复操作时比上一次操作所增长的数值。（默认为‘1’）

执行过程：

第一步：将 i 值传递给 ‘迭代变量’，然后执行一次内部语句;
第二步：在 i 的基础上 + k 再次传递给 ‘迭代变量’，如果 ‘迭代变量’ 的值小于 ‘j’ 的值，则再次执行内部语句，否则退出for循环。

详情如下：

for i in range(9):
    print(i)

运行结果如图;

8、课后作业

8.1、 现在有 a = [1,2,3,4,5,6] 用多种方式实现列表的反转([6,5,4,3,2,1]) 并写出推导过程

# 第一种方法，使用append
a = [1,2,3,4,5,6]
b = []
for i in a:
    b.append(a[6-i])
print(b)

# 第二种方法，切片的运用
a = [1,2,3,4,5,6]
print(a[::-1])

# 第三种方法，反转列表
a = [1,2,3,4,5,6]
a.reverse()
print(a)

# 第四种方法，排序
a = [1,2,3,4,5,6]
a.sort(reverse=True)
print(a)

• 运行结果如下：
  

• 知识点运用及编写思路：

    第一种方法用到了列表方法append和for循环的配合，每一次运行都将列表a中的值添加给b，达到逆序的效果。
    第二种方法是切片的逆序打印，详情可以看上面切片的介绍及运用。
    第三种和第四张方法都是列表方法的运用，不过第三种不管里面的元素是什么类型的都可以逆序打印，但第四张只能针对像这种原本就是元素从小到大的列表，其他的就达不到逆序的效果。

8.2、给用户9次机会 猜1 - 10 个数字随机来猜数字。

# 第一种
list1 = [1,2,3,4,5,6,7,8,9,10]
list2=[]
print('现在我们来猜数字，给你9次机会哦')
for i in range(1,10):
    a = int(input('请输入1 - 10中的数字：'))
    if a in list1:
        print(f'你猜错啦,不是{a}')
        list2.append(a)
    else:
        print('哎呀，要猜1到10内的数字哦！！！')
        continue
else:
    for a in list1:
        if a not in list2:
            d = a
print(f'哈哈哈，你9次都没猜对哦！！！应该是{d}才对哦!')

# 第二种
list1 = [1,2,3,4,5,6,7,8,9,10]
list2=[]
print('现在我们来猜数字，给你9次机会哦')
i=1
while i

• 运行结果如下（最终方法的运行）

• 知识点运用及编写思路：

    这3种方法也是循序渐进的，由Cheney老师以及群里的各位大佬指点改进的
    第一种方法中规中矩，就是利用for循环，循环9次，让用户每次都猜一次，我们就将用户猜的值添加给列表list2，最后9次循环之后将list1与list2的值进行判断，最后输出用户没有猜到的值。
    第二种方法就是再第一题的基础上加上了判断，限定用户必须猜1~10之间的数字。
    上述的2种方法也能达到效果，但是还是不够简便，所以在听取了群里的大佬西安聂泽雨的意见后改的，使用remove方法将用户猜的数字都从列表中删除，这样就能达到与上面2种方法相同的效果，也简化了代码。
    在此，还要非常感谢一下Cheney老师以及群里的大佬的指点与帮助，让我学习到了更多的代码知识以及思路。学无止境，希望各位再观看完我的博客后，能给我的不足地方指出，谢谢。

• 下面是我原本写的，解题思路稍微有点偏差，也可以借鉴一下的
• 让用户9次都猜不对，前2种方法都有一点点问题，可以结合第三种一起理解一下

# 让用户9次都猜不对，然后每一次都输出一个值
# 第一种方法
list1 = [1,2,3,4,5,6,7,8,9,10]
for i in range(1,10):
    a = int(input('请输入1 - 10中的数字：'))
    b = list1[a+1]
    print(f'你猜错啦，应该是{b}才对哦!')
else:
    print('哈哈哈，你9次都没猜对哦！！！')
    
# 第二种方法    
list1 = [1,2,3,4,5,6,7,8,9,10]
i=1
while i=1 and a

• 运行结果如下（这里只展示第3种方法的效果，还有2种也差不多）：
  

• 知识点运用及编写思路：

    此代码是我在理解错题目意思后写的，让用户9次都猜不对，每一次都输出一个数字。
    这里我写了3种方法，思路是循序渐进的，应该更好理解。
    首先我们第一种方法用到的就是for循环和列表的运用，先创建一个列表，里面的元素就是1~10的数字，然后不管用户输入什么数字，我这边都加上2输出，这里因为索引是从0开始，所以list1[a+1]就能达到这种效果，但是我发现这个方法又不足，先不说，我们输出的数字不随机，再有就是我不管输入什么数字都行，缺少了一个判断，所以我又进行了更改
    第二种方法我就在第一种方法加上了if判断，但是我这个时候又遇到一个问题，如果接着用for循环，就算我输不是1 ~ 10 内的数字，然后他总的循环只能有9次，所以不符合我的预期效果，这个时候我想到了while循环，并将其添加进去，这时我就限定了用户只能输入1 ~ 10内的数字。
    第三种方法，是我想让我们输出的数字也随机，这是我想到了random模块，使用这个模块不就能随机了能生成随机数了嘛，但是我又想到这个还有一个问题，就是他有很大概率让用户懵中，所以我这又给他加了个循环，使其就算猜中了也没用，猜中我就换一个随机数就好了。最后的效果就如上图了。

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

# 第一种方法 while循环
lst1 = [11, 22, 33]
lst2 = [22, 33, 44]
a = 0
c = '相同的元素为：'
while a

• 运行结果如下：
  
• 知识点运用及编写思路：

   这题比较容易，获取2个列表相同的元素，我们只要用一下循环嵌套就好了，外循环和内循环都是循环3次，外循环就是lst1的元素数量，内循环是lst2的元素数量，之后那list1的每一个元素都与list2的元素一一对比判断就行了，相同的复制给c,最后直接输出c即可。

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

# 第一种方法 while循环
import random
a = 1
while a

• 运行结果如下：
  

• 知识点运用及编写思路：

   这题说白了就是random模块与循环之间的使用，将老师的数量作为迭代变量，也就是循环的次数，然后使用random模块生产随机的1~3之间的数字，然后就是输出啦。

9、附加（个人代码练习）

9.1、求1/1-1/2+1/3-1/4+1/5 …… + 1/99 - 1/100的值

# 求1/1-1/2+1/3-1/4+1/5 …… + 1/99 - 1/100的值
# while循环
i=1
sum=0
while i<blockquote><p>运行结果：<br><img src="https://img.php.cn/upload/article/000/000/052/035db9fe0baa39f789db2df222f2d9f8-10.png" alt="Python 목록에 대한 자세한 설명"></p></blockquote><p><strong>9.2、计算下面数列的和值。 1/3+3/5+5/7+…+97/99</strong></p><pre class="brush:php;toolbar:false"># 计算下面数列的和值。 1/3+3/5+5/7+....+97/99
# while循环
i,j,sum = 1,3,0
while i<blockquote><p>运行结果：<br><img src="https://img.php.cn/upload/article/000/000/052/035db9fe0baa39f789db2df222f2d9f8-11.png" alt="Python 목록에 대한 자세한 설명"></p></blockquote><p><strong>9.3、 输入2个数值，判断之间有多少个素数，并输出所有素数</strong></p><pre class="brush:php;toolbar:false"># 输入2个数值，判断之间有多少个素数，并输出所有素数
c=[int(input('输入第一个数:')),int(input('输入第二个数:'))]
c.sort(reverse=False)  #保证2个数以升序方式排列
a,b=c[0],c[1]
while a <blockquote><p>运行结果：<br><img src="https://img.php.cn/upload/article/000/000/052/035db9fe0baa39f789db2df222f2d9f8-12.png" alt="Python 목록에 대한 자세한 설명"></p></blockquote><blockquote><p><strong>相关免费学习推荐：</strong><a href="https://www.php.cn/course/list/30.html" target="_blank"><strong>python教程</strong></a><strong>（视频）</strong></p></blockquote>

위 내용은 Python 목록에 대한 자세한 설명의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!