博客

欢迎使用 WordPress。这是您的第一篇文章。编辑或删除它，然后开始写作吧！

本文主题：python列表，元组，字典与循环体系。
时间：2025/10/29，第一次修改于2025/10/30，完善循环语句部分。

列表

列表的生成

基础理论不过多阐述，知道这是python中常用的数据结构之一，用于同时存贮大量数据即可。就从创建一个列表开始吧。

list1=[]
list2=[1,2,3,4,5]
list3=['abc','def','aaa']
list4=[1,'abc',3]
list5=list()
print(type(list1))
print(type(list2))
print(type(list3))
print(type(list4))
print(type(list5))

以上就是常见的列表定义形式，通常直接使用一个”[]”可直接生成一个空列表，例如list1，也可以在其中填入任意数据，不同数据之间用逗号隔开，这样生成的列表中就存在值了。当然也可以用一个函数方法生成一个列表，就像list5一样。打印出数据类型，发现他们都是属于list类，通常我们记住最简单的生成方式，直接用中括号生成就行。

range函数

range函数是python中内置的一个函数，用途十分广泛，在帮助我们生成一大堆数的时候。就比如下面这个例子。

for number in range(1,5):
    print(number)

我们可以发现，在终端依次输出了1~4，并没有5，这是因为range函数的采值范围是左闭右开的，也就是说，实际上它并不会达到5。至于这里的for循环遍历，暂且不需要太理解，暂且看到了这个结构，有点印象就好。

range函数的步长

range函数可以接受三个参数，第三个为可选参数，可添加可不添加，第一个参数为起点，第二个参数为终点（不取该值），第三个参数为步长，表示一次性走几格，就和上楼梯一样。

for number in range(1,10,2):
    print(number)

上述代码输出的值如下，可以发现它跳过了一个数，只输出奇数部分，就和你上楼梯一次性走两个格子一样，跳过了中间的格子。这个第三个一般可以不填的原因是因为它默认取1，也就是每个楼梯都走，那么这个参数能不能为零呢？亦或者是负数呢？我们不妨试试看。

很显然，取值不能为零，不然会产生报错的。

如果想让步长为负数的话，那么也就是下楼梯，那么这样的话我们的起点和终点就要交换一下，不然的话就会陷入死循环，一直往下输出直到十八层地狱。具体代码如下。

for number in range(10,1,-1):
    print(number)

可以看到我们将数倒过来输出了。记住左闭右开原则，所以这边并不会输出1。

那我们学习这个函数的目的是什么呢？这个函数在后续的循环体系学习等地方有很大的用武之地，同时这个函数也能配合list函数进行列表的生成。看看下面这个例子吧。

list1=list(range(1,10))
print(type(list1))
print(list1)

可以看到它能很便捷的帮我们生成一个纯数值的数组，不需要自己手动去敲。

列表的一些操作

列表中数组的访问

我们想访问列表中的某一个值该怎么办呢？这时候我们就可以使用下标值来进行引索寻找。如下。

list1=list(range(1,10))
print(list1[0])
print(list1[1])

我们可以看到终端输出了1和2，这是为什么呢？列表的下标引索值是从零开始，也就是说明，列表中的第一个数对应的下标值是零，第二个数对应的下标值是一，以此类推。列表中的某个值的查找我们就可以使用列表名[下标值]的形式来进行访问。

同时，我们可以不仅仅访问其中的某一个值，访问某一部分值也是可以的，这个操作叫做列表的切片。

list1=list(range(1,10))
print(list1[0:5])

可以注意到这里输出了列表中的前五个元素，但值得注意的是，这个和range函数一样取值是左闭右开的，实际上它只取了0，1，2，3，4这五个下标。

list1=list(range(1,10))
print(list1[0:9:2])

同样的，这个也有类似步长的写法。输出如下所示。

切片还可以有些奇特的写法，例如。

list1=list(range(1,10))
print(list1[:5])
print(list1[5:])
print(list1[-2:])
print(list1[:-2])

分别对应不写第一个参数，那么它就默认从0下标值开始。不写第二个参数，那么他就默认读取到列表结束。如果将负数填在第一个参数位置，例如文中的-2.那么就代表它会从列表的结束前往推两个两个引索值的位置开始然后读取，这个例子中就是下标值为7的位置，读取到最后。那么填在第二个参数位置的话，它就会从开始读取到下标值为7的位置。

列表的复制

我们可以使用切片来进行列表的复制，而不是直接用等号赋值。

list1=list(range(1,10))
list2=list1[:]
print(list1)
print(list2)
list2[0]=100
print(list1)
print(list2)

可以看到我们这里使用切片把list1复制给了list2，同时修改了list2中的第一个值，但是它只改变了list2中下标为0的值，并没有改变list1中的，但使用等于号赋值就不是这种情况了。

list1=list(range(1,10))
list2=list1
print(list1)
print(list2)
list2[0]=100
print(list1)
print(list2)

可以看到这回list1和list2中的下标为0的值都被改变了，这是为什么呢？其实这就相当于一个人有两个名字一样，虽然叫法不同，但还是他，所以这里其实只有一个列表，并没有达到复制的效果。

列表的元素添加和删除

我们可以使用append方法来给列表中添加元素，使用del方法来删除列表中的元素。

list1=list(range(1,10))
print(list1)
list1.append(10)
print(list1)
del list1[9]
print(list1)

输入如下所示，利用类似于列表名.append(加入值)的形式我们可以给列表的尾部添加上一个值，利用del 列表名[下标值]的形式可删除列表中指定位置的元素。

使用insert方法在列表中插入元素。

list1=['a','b','c']
print(list1)
list1.insert(1,'234')
print(list1)

采用列表名.insert(插入位置的下标索引，插入值)的形式，可在列表中你想要的位置插入特定的值。

使用pop方法进行列表元素的删除。

list1=list(range(1,10))
print(list1)
print(list1.pop())
print(list1)

pop方法可以默认删除列表中的最后一个元素。而且pop是有放回值的，可以理解为是把列表中的最后一个元素给拿了出来。

pop方法也可以删除特定的位置的元素，在括号中加入对于的下标索引值就好。

list1=list(range(1,10))
print(list1)
print(list1.pop(2))
print(list1)

有时候我们不知道要删除的值位置在那里，于是我们可以使用remove方法，移除列表中的指定元素。remove方法和pop方法一样，存在返回值，可以将删除的值继续使用。

list1=['a','b','c']
print(list1)
list1.remove('a')
print(list1)

但要注意，如果这个列表中存在多个你要删除的元素的话，他只会默认删除第一个，需要使用循环来全部删除。

列表排序

可使用sort方法和sorted方法给列表进行排序，其中，sort方法排序是永久的，而sorted方法排序是临时的。

list1=[2,5,1,3,4]
list1.sort()
print(list1)
list1=[2,5,1,3,4]
list1.sort(reverse=True)
print(list1)

采用形如列表名.sort()的方法可以使列表进行排序，在括号中传入reverse=True参数，可以使得列表倒序排列。但此方法对于列表内的顺序改变是永久的。

而采用sorted（列表名）的方法并不会影响原列表的顺序，它将排序后的列表作为返回值提供使用，就像pop方法和remove方法一样。

list1=[2,5,1,3,4]
print(sorted(list1))
print(list1)

一些其他的列表操作

list1=[1,2,3,4,5]
list2=[6,7,8,9,10]
print(len(list1))
list3=list1+list2
print(list3)
list4=list1*2
print(list4)
list1.reverse()
print(list1)
           

我们可以使用len函数来读取列表的长度，同时也可以使用+运算符将两个列表拼接起来，亦或者是用*运算符将列表重复。利用reverse方法将列表永久倒转。

列表中还有许多方法，但初学阶段不咋使用，这里不过多阐述。

元组

元组大部分都和列表相同，只不过元组中的数值是不能修改的，接下我们看看元组的定义。

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = ()
print(type(tup1))
print(type(tup2))
print(type(tup3))

和列表不同的点就是，元组的定义是采用()而不是[]。

和列表类似，元组也可以进行切片和访问。

tup1 = (1, 2, 3, 4, 5 )
print(tup1[0])
print(tup1[1:3])

如果我们尝试修改元组中的值，那么就会发生报错。

字典

在 Python 中，字典是一系列键值对。每个键都与一个值关联，可以使用键来访问与之关联的值。就像每个人有一个名字一样。

字典的定义

student1={'name':'abc','age':20,'gender':'male'}
print(type(student1))

我们利用花括号将字典内的包含的元素给括起来，采用类似于字典名={“键名”：“值名”}的形式定义，不局限于数据结构，键名和值名可以为字符串亦或是数字，都无所谓。

访问字典内的值

student1={'name':'abc','age':20,'gender':'male'}
print(student1['name'])

我们通过字典名[键名]的形式来读取字典中的值，就类似根据名字找人了，值得一提的是，在一个字典中，一般键名是唯一的，值可以不是唯一的。

字典的添加键值对

字典是一种动态结构，可随时在其中添加键值对。要添加键值对，可依次指定字典名、用方括号括起来的键和与该键关联的值。字典名[键名]=值名

student1={'name':'abc','age':20,'gender':'male'}
student1['hobby']='pingpang'
print(student1)

修改字典中的值

student1={'name':'abc','age':20,'gender':'male'}
student1['name']='pingpang'
print(student1)

其实和添加是一样的，如果这个键名出现过在这字典里的话就会直接修改该键名所对应的值，如果不存在就会添加一个新的键值对于字典中。

删除字典里的键值对

student1={'name':'abc','age':20,'gender':'male'}
del student1['name']
print(student1)

对于字典中不需要的元素，可以使用类似列表删除的del 字典名[键名]进行删除，这样这个键值对就会永远消失在这字典内了。

循环

for循环

for letter in 'Python':     
   print("当前字母: %s" % letter)

类似于for 变量 in 遍历值：形式的结构体就是for循环，它可以用于遍历任何序列的项目，例如一个字符串，一个数组，等等。循环的目的是对这一类元素，例如这个列表或者字符串内的所有元素进行需要重复进行的操作而诞生的，不然你想象下写一大堆重复代码来实现当前效果的会是怎么样。

a = 'Python'
print("当前字母:",a[0])
print("当前字母:",a[1])
print("当前字母:",a[2])
print("当前字母:",a[3])
print("当前字母:",a[4])
print("当前字母:",a[5])

为了实现同样的的效果，一个所用代码只需要两行，一个则写了那么多行，要是我们要逐字打印出一篇文章的每个字母呢？那给写多少行重复代码啊？所以循环的目的就是帮我们实现简化重复操作。

for循环的代码架构为
for 变量 in 需要重复进行同一操作的元素群：
（四个空格的缩进）需要重复执行的代码行
简单来说，我们可以把我们需要进行同一操作的元素群视为一箱青苹果，现在我们要给每个苹果都涂成红色，所以我们使用一个变量，也就是另一个新箱子把原来箱子里的每个青苹果挨个装出来，然后执行涂红的操作。所以如果这个写成代码形式的应该是如下。需要记住的是，新箱子每次只能按顺序装出一个青苹果哦。

for 新箱子 in 一箱青苹果:
    涂红新箱子里的苹果

这样我们就能以很少的代码行数实现将箱子里的所有青苹果涂红的操作了。

for number in range(1,10):
    print(number)

例如我们之前提到的遍历输出数字1到9。当然我们也可以遍历一个数组，如下。

tang = [123,435,1234,513245,11243,1234,1234,534,346]
for i in range(len(tang)):
    print (tang[i])

while循环

count = 0
while count < 9:
   print ('The count is:', count)
   count = count + 1

while bool条件：while循环体就像这样，只要中间的bool值为true，那么这个循环就会一直进行下去，所以要使用这个循环的时候，一定要注意条件判断，避免进入死循环，导致程序一直进行下去。

while 判断条件值：
（四个空格缩进）需要重复执行的操作代码行

while循环的结构体和for有点不一样，它只需要一个bool值来进行判断是否要继续执行下去，就像我们过马路，如果是绿灯的话，我们自然就一直往前走了，直到红灯为止。bool值为true就是绿灯，为false就是红灯。

while 红灯还是绿灯:
    需要重复执行的代码语句

所以这里就能看出for循环和while循环的差别，for循环在涂完那一箱青苹果的颜色后就自动退出了；而while循环只要是绿灯就会一直涂的去，哪怕苹果已经涂完了，所以使用while循环的时候一定要注意退出条件，避免进入死循环，导致程序崩溃。

continue和break语句

除了修改红绿灯能够改变while语句是否要执行，我们还可以使用continue和break语句来实现控制循环，其中continue 用于跳过该次循环而break 则是用于退出循环。举个例子来说，我们还是有一箱青苹果，还是要给其中的每个青苹果涂上红色，但是这回我只想给其中下标索引偶数的青苹果涂上红色，于是我们就可以使用类似如下语句形式来实现这个目的。

a_box_green_apple(一箱青苹果)
number=-1（记录当前涂到第几个苹果的变量值）
while number<箱子内的总苹果数:
    number+=1
    if number%2>0:(利用%进行求余运算，判断下标索引值是否为偶数)
        continue（continue语句跳出当前循环，直接执行下一次循环，那么本次循环此语句后还未执行的代码也就不会执行了，直接进去下一个循环了，所以就不会给该苹果涂成红色了）
    a_box_green_apple[number]涂成红色
 

例如我们下面还有个输出1到10内的偶数的例子，其实这两个例子一样的意思。

i = 1
while i < 10:   
    i += 1
    if i%2 > 0:     # 非双数时跳过输出
        continue
    print (i)        # 输出双数2、4、6、8、10
 

而break语句则是直接跳出循环体不在进行循环了，假如说我们之前给箱子里的前10个青苹果涂成红色，而后面的苹果保持不变，那么这时候我们就是可以使用break语句来控制了。

a_box_green_apple(一箱青苹果)
number=-1（记录当前涂到第几个苹果的变量值）
while True:（一直执行循环）
    number+=1
    a_box_green_apple[number]涂成红色
    if number==9：
        break

这样我们涂完了箱子里的前十个青苹果后就直接跳出循环了，不会再执行任何循环操作了。下面那个输出1到10的具体例子和上文例子是一样的思想。

i = 1
while True:            # 相当于一路绿灯
    print (i)        # 输出1~10
    i += 1
    if i > 10:     # 当i大于10时跳出循环
        break

continue语句和break语句都是用于控制循环的语句，这也就是意味着它们不仅仅可以使用于while循环体系之中，也可以使用于for循环体系之中。要时刻注意，continue语句是跳出当前循环不执行之后的语句直接开始下次循环，而break语句是直接跳出循环不再进行循环了。

循环嵌套

正如我们上文所说，循环是重复执行循环体内的循环，那么我们把另一个循环放入其中一个循环体内，那么就是实现循环嵌套。我们可以在一个for循环或是一个while循环中嵌套另一个for循环或者while循环，到达循环嵌套的目的。给个简单的例子。打印99乘法表。

for x in range(1,10):
    for y in range(1,10):
        print(x*y,end="\t")

再来个例子，用循环嵌套输出坐标（0，0）到坐标（3，3）。

for x in range(4):
    for y in range(4):
        print("当前坐标点",(x,y))

简单讲解一下就是，对于每个外层循环，都会把内部循环给全部执行一遍，在这个例子中就是对于每个x都会进行一遍y等于0到3的循环输出。所以也就是外层循环走一次，它的内层循环就会全部走完一遍，然后外层循环再进行下次循环，层循环再次全部走完一遍……

形如此类就是嵌套循环，循环嵌套是一种进行写数学题很有用的东西。但这里简单理解一下，明白有这个东西就好了。

本文主题：python列表，元组，字典与循环体系。
时间：2025/10/29，第一次修改于2025/10/30，完善循环语句部分。

列表

列表的生成

基础理论不过多阐述，知道这是python中常用的数据结构之一，用于同时存贮大量数据即可。就从创建一个列表开始吧。

list1=[]
list2=[1,2,3,4,5]
list3=['abc','def','aaa']
list4=[1,'abc',3]
list5=list()
print(type(list1))
print(type(list2))
print(type(list3))
print(type(list4))
print(type(list5))

以上就是常见的列表定义形式，通常直接使用一个”[]”可直接生成一个空列表，例如list1，也可以在其中填入任意数据，不同数据之间用逗号隔开，这样生成的列表中就存在值了。当然也可以用一个函数方法生成一个列表，就像list5一样。打印出数据类型，发现他们都是属于list类，通常我们记住最简单的生成方式，直接用中括号生成就行。

range函数

range函数是python中内置的一个函数，用途十分广泛，在帮助我们生成一大堆数的时候。就比如下面这个例子。

for number in range(1,5):
    print(number)

我们可以发现，在终端依次输出了1~4，并没有5，这是因为range函数的采值范围是左闭右开的，也就是说，实际上它并不会达到5。至于这里的for循环遍历，暂且不需要太理解，暂且看到了这个结构，有点印象就好。

range函数的步长

range函数可以接受三个参数，第三个为可选参数，可添加可不添加，第一个参数为起点，第二个参数为终点（不取该值），第三个参数为步长，表示一次性走几格，就和上楼梯一样。

for number in range(1,10,2):
    print(number)

上述代码输出的值如下，可以发现它跳过了一个数，只输出奇数部分，就和你上楼梯一次性走两个格子一样，跳过了中间的格子。这个第三个一般可以不填的原因是因为它默认取1，也就是每个楼梯都走，那么这个参数能不能为零呢？亦或者是负数呢？我们不妨试试看。

很显然，取值不能为零，不然会产生报错的。

如果想让步长为负数的话，那么也就是下楼梯，那么这样的话我们的起点和终点就要交换一下，不然的话就会陷入死循环，一直往下输出直到十八层地狱。具体代码如下。

for number in range(10,1,-1):
    print(number)

可以看到我们将数倒过来输出了。记住左闭右开原则，所以这边并不会输出1。

那我们学习这个函数的目的是什么呢？这个函数在后续的循环体系学习等地方有很大的用武之地，同时这个函数也能配合list函数进行列表的生成。看看下面这个例子吧。

list1=list(range(1,10))
print(type(list1))
print(list1)

可以看到它能很便捷的帮我们生成一个纯数值的数组，不需要自己手动去敲。

列表的一些操作

列表中数组的访问

我们想访问列表中的某一个值该怎么办呢？这时候我们就可以使用下标值来进行引索寻找。如下。

list1=list(range(1,10))
print(list1[0])
print(list1[1])

我们可以看到终端输出了1和2，这是为什么呢？列表的下标引索值是从零开始，也就是说明，列表中的第一个数对应的下标值是零，第二个数对应的下标值是一，以此类推。列表中的某个值的查找我们就可以使用列表名[下标值]的形式来进行访问。

同时，我们可以不仅仅访问其中的某一个值，访问某一部分值也是可以的，这个操作叫做列表的切片。

list1=list(range(1,10))
print(list1[0:5])

可以注意到这里输出了列表中的前五个元素，但值得注意的是，这个和range函数一样取值是左闭右开的，实际上它只取了0，1，2，3，4这五个下标。

list1=list(range(1,10))
print(list1[0:9:2])

同样的，这个也有类似步长的写法。输出如下所示。

切片还可以有些奇特的写法，例如。

list1=list(range(1,10))
print(list1[:5])
print(list1[5:])
print(list1[-2:])
print(list1[:-2])

分别对应不写第一个参数，那么它就默认从0下标值开始。不写第二个参数，那么他就默认读取到列表结束。如果将负数填在第一个参数位置，例如文中的-2.那么就代表它会从列表的结束前往推两个两个引索值的位置开始然后读取，这个例子中就是下标值为7的位置，读取到最后。那么填在第二个参数位置的话，它就会从开始读取到下标值为7的位置。

列表的复制

我们可以使用切片来进行列表的复制，而不是直接用等号赋值。

list1=list(range(1,10))
list2=list1[:]
print(list1)
print(list2)
list2[0]=100
print(list1)
print(list2)

可以看到我们这里使用切片把list1复制给了list2，同时修改了list2中的第一个值，但是它只改变了list2中下标为0的值，并没有改变list1中的，但使用等于号赋值就不是这种情况了。

list1=list(range(1,10))
list2=list1
print(list1)
print(list2)
list2[0]=100
print(list1)
print(list2)

可以看到这回list1和list2中的下标为0的值都被改变了，这是为什么呢？其实这就相当于一个人有两个名字一样，虽然叫法不同，但还是他，所以这里其实只有一个列表，并没有达到复制的效果。

列表的元素添加和删除

我们可以使用append方法来给列表中添加元素，使用del方法来删除列表中的元素。

list1=list(range(1,10))
print(list1)
list1.append(10)
print(list1)
del list1[9]
print(list1)

输入如下所示，利用类似于列表名.append(加入值)的形式我们可以给列表的尾部添加上一个值，利用del 列表名[下标值]的形式可删除列表中指定位置的元素。

使用insert方法在列表中插入元素。

list1=['a','b','c']
print(list1)
list1.insert(1,'234')
print(list1)

采用列表名.insert(插入位置的下标索引，插入值)的形式，可在列表中你想要的位置插入特定的值。

使用pop方法进行列表元素的删除。

list1=list(range(1,10))
print(list1)
print(list1.pop())
print(list1)

pop方法可以默认删除列表中的最后一个元素。而且pop是有放回值的，可以理解为是把列表中的最后一个元素给拿了出来。

pop方法也可以删除特定的位置的元素，在括号中加入对于的下标索引值就好。

list1=list(range(1,10))
print(list1)
print(list1.pop(2))
print(list1)

有时候我们不知道要删除的值位置在那里，于是我们可以使用remove方法，移除列表中的指定元素。remove方法和pop方法一样，存在返回值，可以将删除的值继续使用。

list1=['a','b','c']
print(list1)
list1.remove('a')
print(list1)

但要注意，如果这个列表中存在多个你要删除的元素的话，他只会默认删除第一个，需要使用循环来全部删除。

列表排序

可使用sort方法和sorted方法给列表进行排序，其中，sort方法排序是永久的，而sorted方法排序是临时的。

list1=[2,5,1,3,4]
list1.sort()
print(list1)
list1=[2,5,1,3,4]
list1.sort(reverse=True)
print(list1)

采用形如列表名.sort()的方法可以使列表进行排序，在括号中传入reverse=True参数，可以使得列表倒序排列。但此方法对于列表内的顺序改变是永久的。

而采用sorted（列表名）的方法并不会影响原列表的顺序，它将排序后的列表作为返回值提供使用，就像pop方法和remove方法一样。

list1=[2,5,1,3,4]
print(sorted(list1))
print(list1)

一些其他的列表操作

list1=[1,2,3,4,5]
list2=[6,7,8,9,10]
print(len(list1))
list3=list1+list2
print(list3)
list4=list1*2
print(list4)
list1.reverse()
print(list1)
           

我们可以使用len函数来读取列表的长度，同时也可以使用+运算符将两个列表拼接起来，亦或者是用*运算符将列表重复。利用reverse方法将列表永久倒转。

列表中还有许多方法，但初学阶段不咋使用，这里不过多阐述。

元组

元组大部分都和列表相同，只不过元组中的数值是不能修改的，接下我们看看元组的定义。

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = ()
print(type(tup1))
print(type(tup2))
print(type(tup3))

和列表不同的点就是，元组的定义是采用()而不是[]。

和列表类似，元组也可以进行切片和访问。

tup1 = (1, 2, 3, 4, 5 )
print(tup1[0])
print(tup1[1:3])

如果我们尝试修改元组中的值，那么就会发生报错。

字典

在 Python 中，字典是一系列键值对。每个键都与一个值关联，可以使用键来访问与之关联的值。就像每个人有一个名字一样。

字典的定义

student1={'name':'abc','age':20,'gender':'male'}
print(type(student1))

我们利用花括号将字典内的包含的元素给括起来，采用类似于字典名={“键名”：“值名”}的形式定义，不局限于数据结构，键名和值名可以为字符串亦或是数字，都无所谓。

访问字典内的值

student1={'name':'abc','age':20,'gender':'male'}
print(student1['name'])

我们通过字典名[键名]的形式来读取字典中的值，就类似根据名字找人了，值得一提的是，在一个字典中，一般键名是唯一的，值可以不是唯一的。

字典的添加键值对

字典是一种动态结构，可随时在其中添加键值对。要添加键值对，可依次指定字典名、用方括号括起来的键和与该键关联的值。字典名[键名]=值名

student1={'name':'abc','age':20,'gender':'male'}
student1['hobby']='pingpang'
print(student1)

修改字典中的值

student1={'name':'abc','age':20,'gender':'male'}
student1['name']='pingpang'
print(student1)

其实和添加是一样的，如果这个键名出现过在这字典里的话就会直接修改该键名所对应的值，如果不存在就会添加一个新的键值对于字典中。

删除字典里的键值对

student1={'name':'abc','age':20,'gender':'male'}
del student1['name']
print(student1)

对于字典中不需要的元素，可以使用类似列表删除的del 字典名[键名]进行删除，这样这个键值对就会永远消失在这字典内了。

循环

for循环

for letter in 'Python':     
   print("当前字母: %s" % letter)

类似于for 变量 in 遍历值：形式的结构体就是for循环，它可以用于遍历任何序列的项目，例如一个字符串，一个数组，等等。循环的目的是对这一类元素，例如这个列表或者字符串内的所有元素进行需要重复进行的操作而诞生的，不然你想象下写一大堆重复代码来实现当前效果的会是怎么样。

a = 'Python'
print("当前字母:",a[0])
print("当前字母:",a[1])
print("当前字母:",a[2])
print("当前字母:",a[3])
print("当前字母:",a[4])
print("当前字母:",a[5])

为了实现同样的的效果，一个所用代码只需要两行，一个则写了那么多行，要是我们要逐字打印出一篇文章的每个字母呢？那给写多少行重复代码啊？所以循环的目的就是帮我们实现简化重复操作。

for循环的代码架构为
for 变量 in 需要重复进行同一操作的元素群：
（四个空格的缩进）需要重复执行的代码行
简单来说，我们可以把我们需要进行同一操作的元素群视为一箱青苹果，现在我们要给每个苹果都涂成红色，所以我们使用一个变量，也就是另一个新箱子把原来箱子里的每个青苹果挨个装出来，然后执行涂红的操作。所以如果这个写成代码形式的应该是如下。需要记住的是，新箱子每次只能按顺序装出一个青苹果哦。

for 新箱子 in 一箱青苹果:
    涂红新箱子里的苹果

这样我们就能以很少的代码行数实现将箱子里的所有青苹果涂红的操作了。

for number in range(1,10):
    print(number)

例如我们之前提到的遍历输出数字1到9。当然我们也可以遍历一个数组，如下。

tang = [123,435,1234,513245,11243,1234,1234,534,346]
for i in range(len(tang)):
    print (tang[i])

while循环

count = 0
while count < 9:
   print ('The count is:', count)
   count = count + 1

while bool条件：while循环体就像这样，只要中间的bool值为true，那么这个循环就会一直进行下去，所以要使用这个循环的时候，一定要注意条件判断，避免进入死循环，导致程序一直进行下去。

while 判断条件值：
（四个空格缩进）需要重复执行的操作代码行

while循环的结构体和for有点不一样，它只需要一个bool值来进行判断是否要继续执行下去，就像我们过马路，如果是绿灯的话，我们自然就一直往前走了，直到红灯为止。bool值为true就是绿灯，为false就是红灯。

while 红灯还是绿灯:
    需要重复执行的代码语句

所以这里就能看出for循环和while循环的差别，for循环在涂完那一箱青苹果的颜色后就自动退出了；而while循环只要是绿灯就会一直涂的去，哪怕苹果已经涂完了，所以使用while循环的时候一定要注意退出条件，避免进入死循环，导致程序崩溃。

continue和break语句

除了修改红绿灯能够改变while语句是否要执行，我们还可以使用continue和break语句来实现控制循环，其中continue 用于跳过该次循环而break 则是用于退出循环。举个例子来说，我们还是有一箱青苹果，还是要给其中的每个青苹果涂上红色，但是这回我只想给其中下标索引偶数的青苹果涂上红色，于是我们就可以使用类似如下语句形式来实现这个目的。

a_box_green_apple(一箱青苹果)
number=-1（记录当前涂到第几个苹果的变量值）
while number<箱子内的总苹果数:
    number+=1
    if number%2>0:(利用%进行求余运算，判断下标索引值是否为偶数)
        continue（continue语句跳出当前循环，直接执行下一次循环，那么本次循环此语句后还未执行的代码也就不会执行了，直接进去下一个循环了，所以就不会给该苹果涂成红色了）
    a_box_green_apple[number]涂成红色
 

例如我们下面还有个输出1到10内的偶数的例子，其实这两个例子一样的意思。

i = 1
while i < 10:   
    i += 1
    if i%2 > 0:     # 非双数时跳过输出
        continue
    print (i)        # 输出双数2、4、6、8、10
 

而break语句则是直接跳出循环体不在进行循环了，假如说我们之前给箱子里的前10个青苹果涂成红色，而后面的苹果保持不变，那么这时候我们就是可以使用break语句来控制了。

a_box_green_apple(一箱青苹果)
number=-1（记录当前涂到第几个苹果的变量值）
while True:（一直执行循环）
    number+=1
    a_box_green_apple[number]涂成红色
    if number==9：
        break

这样我们涂完了箱子里的前十个青苹果后就直接跳出循环了，不会再执行任何循环操作了。下面那个输出1到10的具体例子和上文例子是一样的思想。

i = 1
while True:            # 相当于一路绿灯
    print (i)        # 输出1~10
    i += 1
    if i > 10:     # 当i大于10时跳出循环
        break

continue语句和break语句都是用于控制循环的语句，这也就是意味着它们不仅仅可以使用于while循环体系之中，也可以使用于for循环体系之中。要时刻注意，continue语句是跳出当前循环不执行之后的语句直接开始下次循环，而break语句是直接跳出循环不再进行循环了。

循环嵌套

正如我们上文所说，循环是重复执行循环体内的循环，那么我们把另一个循环放入其中一个循环体内，那么就是实现循环嵌套。我们可以在一个for循环或是一个while循环中嵌套另一个for循环或者while循环，到达循环嵌套的目的。给个简单的例子。打印99乘法表。

for x in range(1,10):
    for y in range(1,10):
        print(x*y,end="\t")

再来个例子，用循环嵌套输出坐标（0，0）到坐标（3，3）。

for x in range(4):
    for y in range(4):
        print("当前坐标点",(x,y))

简单讲解一下就是，对于每个外层循环，都会把内部循环给全部执行一遍，在这个例子中就是对于每个x都会进行一遍y等于0到3的循环输出。所以也就是外层循环走一次，它的内层循环就会全部走完一遍，然后外层循环再进行下次循环，层循环再次全部走完一遍……

形如此类就是嵌套循环，循环嵌套是一种进行写数学题很有用的东西。但这里简单理解一下，明白有这个东西就好了。

本文主题：python列表，元组，字典与循环体系。
时间：2025/10/29，第一次修改于2025/10/30，完善循环语句部分。

列表

列表的生成

基础理论不过多阐述，知道这是python中常用的数据结构之一，用于同时存贮大量数据即可。就从创建一个列表开始吧。

list1=[]
list2=[1,2,3,4,5]
list3=['abc','def','aaa']
list4=[1,'abc',3]
list5=list()
print(type(list1))
print(type(list2))
print(type(list3))
print(type(list4))
print(type(list5))

以上就是常见的列表定义形式，通常直接使用一个”[]”可直接生成一个空列表，例如list1，也可以在其中填入任意数据，不同数据之间用逗号隔开，这样生成的列表中就存在值了。当然也可以用一个函数方法生成一个列表，就像list5一样。打印出数据类型，发现他们都是属于list类，通常我们记住最简单的生成方式，直接用中括号生成就行。

range函数

range函数是python中内置的一个函数，用途十分广泛，在帮助我们生成一大堆数的时候。就比如下面这个例子。

for number in range(1,5):
    print(number)

我们可以发现，在终端依次输出了1~4，并没有5，这是因为range函数的采值范围是左闭右开的，也就是说，实际上它并不会达到5。至于这里的for循环遍历，暂且不需要太理解，暂且看到了这个结构，有点印象就好。

range函数的步长

range函数可以接受三个参数，第三个为可选参数，可添加可不添加，第一个参数为起点，第二个参数为终点（不取该值），第三个参数为步长，表示一次性走几格，就和上楼梯一样。

for number in range(1,10,2):
    print(number)

上述代码输出的值如下，可以发现它跳过了一个数，只输出奇数部分，就和你上楼梯一次性走两个格子一样，跳过了中间的格子。这个第三个一般可以不填的原因是因为它默认取1，也就是每个楼梯都走，那么这个参数能不能为零呢？亦或者是负数呢？我们不妨试试看。

很显然，取值不能为零，不然会产生报错的。

如果想让步长为负数的话，那么也就是下楼梯，那么这样的话我们的起点和终点就要交换一下，不然的话就会陷入死循环，一直往下输出直到十八层地狱。具体代码如下。

for number in range(10,1,-1):
    print(number)

可以看到我们将数倒过来输出了。记住左闭右开原则，所以这边并不会输出1。

那我们学习这个函数的目的是什么呢？这个函数在后续的循环体系学习等地方有很大的用武之地，同时这个函数也能配合list函数进行列表的生成。看看下面这个例子吧。

list1=list(range(1,10))
print(type(list1))
print(list1)

可以看到它能很便捷的帮我们生成一个纯数值的数组，不需要自己手动去敲。

列表的一些操作

列表中数组的访问

我们想访问列表中的某一个值该怎么办呢？这时候我们就可以使用下标值来进行引索寻找。如下。

list1=list(range(1,10))
print(list1[0])
print(list1[1])

我们可以看到终端输出了1和2，这是为什么呢？列表的下标引索值是从零开始，也就是说明，列表中的第一个数对应的下标值是零，第二个数对应的下标值是一，以此类推。列表中的某个值的查找我们就可以使用列表名[下标值]的形式来进行访问。

同时，我们可以不仅仅访问其中的某一个值，访问某一部分值也是可以的，这个操作叫做列表的切片。

list1=list(range(1,10))
print(list1[0:5])

可以注意到这里输出了列表中的前五个元素，但值得注意的是，这个和range函数一样取值是左闭右开的，实际上它只取了0，1，2，3，4这五个下标。

list1=list(range(1,10))
print(list1[0:9:2])

同样的，这个也有类似步长的写法。输出如下所示。

切片还可以有些奇特的写法，例如。

list1=list(range(1,10))
print(list1[:5])
print(list1[5:])
print(list1[-2:])
print(list1[:-2])

分别对应不写第一个参数，那么它就默认从0下标值开始。不写第二个参数，那么他就默认读取到列表结束。如果将负数填在第一个参数位置，例如文中的-2.那么就代表它会从列表的结束前往推两个两个引索值的位置开始然后读取，这个例子中就是下标值为7的位置，读取到最后。那么填在第二个参数位置的话，它就会从开始读取到下标值为7的位置。

列表的复制

我们可以使用切片来进行列表的复制，而不是直接用等号赋值。

list1=list(range(1,10))
list2=list1[:]
print(list1)
print(list2)
list2[0]=100
print(list1)
print(list2)

可以看到我们这里使用切片把list1复制给了list2，同时修改了list2中的第一个值，但是它只改变了list2中下标为0的值，并没有改变list1中的，但使用等于号赋值就不是这种情况了。

list1=list(range(1,10))
list2=list1
print(list1)
print(list2)
list2[0]=100
print(list1)
print(list2)

可以看到这回list1和list2中的下标为0的值都被改变了，这是为什么呢？其实这就相当于一个人有两个名字一样，虽然叫法不同，但还是他，所以这里其实只有一个列表，并没有达到复制的效果。

列表的元素添加和删除

我们可以使用append方法来给列表中添加元素，使用del方法来删除列表中的元素。

list1=list(range(1,10))
print(list1)
list1.append(10)
print(list1)
del list1[9]
print(list1)

输入如下所示，利用类似于列表名.append(加入值)的形式我们可以给列表的尾部添加上一个值，利用del 列表名[下标值]的形式可删除列表中指定位置的元素。

使用insert方法在列表中插入元素。

list1=['a','b','c']
print(list1)
list1.insert(1,'234')
print(list1)

采用列表名.insert(插入位置的下标索引，插入值)的形式，可在列表中你想要的位置插入特定的值。

使用pop方法进行列表元素的删除。

list1=list(range(1,10))
print(list1)
print(list1.pop())
print(list1)

pop方法可以默认删除列表中的最后一个元素。而且pop是有放回值的，可以理解为是把列表中的最后一个元素给拿了出来。

pop方法也可以删除特定的位置的元素，在括号中加入对于的下标索引值就好。

list1=list(range(1,10))
print(list1)
print(list1.pop(2))
print(list1)

有时候我们不知道要删除的值位置在那里，于是我们可以使用remove方法，移除列表中的指定元素。remove方法和pop方法一样，存在返回值，可以将删除的值继续使用。

list1=['a','b','c']
print(list1)
list1.remove('a')
print(list1)

但要注意，如果这个列表中存在多个你要删除的元素的话，他只会默认删除第一个，需要使用循环来全部删除。

列表排序

可使用sort方法和sorted方法给列表进行排序，其中，sort方法排序是永久的，而sorted方法排序是临时的。

list1=[2,5,1,3,4]
list1.sort()
print(list1)
list1=[2,5,1,3,4]
list1.sort(reverse=True)
print(list1)

采用形如列表名.sort()的方法可以使列表进行排序，在括号中传入reverse=True参数，可以使得列表倒序排列。但此方法对于列表内的顺序改变是永久的。

而采用sorted（列表名）的方法并不会影响原列表的顺序，它将排序后的列表作为返回值提供使用，就像pop方法和remove方法一样。

list1=[2,5,1,3,4]
print(sorted(list1))
print(list1)

一些其他的列表操作

list1=[1,2,3,4,5]
list2=[6,7,8,9,10]
print(len(list1))
list3=list1+list2
print(list3)
list4=list1*2
print(list4)
list1.reverse()
print(list1)
           

我们可以使用len函数来读取列表的长度，同时也可以使用+运算符将两个列表拼接起来，亦或者是用*运算符将列表重复。利用reverse方法将列表永久倒转。

列表中还有许多方法，但初学阶段不咋使用，这里不过多阐述。

元组

元组大部分都和列表相同，只不过元组中的数值是不能修改的，接下我们看看元组的定义。

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = ()
print(type(tup1))
print(type(tup2))
print(type(tup3))

和列表不同的点就是，元组的定义是采用()而不是[]。

和列表类似，元组也可以进行切片和访问。

tup1 = (1, 2, 3, 4, 5 )
print(tup1[0])
print(tup1[1:3])

如果我们尝试修改元组中的值，那么就会发生报错。

字典

在 Python 中，字典是一系列键值对。每个键都与一个值关联，可以使用键来访问与之关联的值。就像每个人有一个名字一样。

字典的定义

student1={'name':'abc','age':20,'gender':'male'}
print(type(student1))

我们利用花括号将字典内的包含的元素给括起来，采用类似于字典名={“键名”：“值名”}的形式定义，不局限于数据结构，键名和值名可以为字符串亦或是数字，都无所谓。

访问字典内的值

student1={'name':'abc','age':20,'gender':'male'}
print(student1['name'])

我们通过字典名[键名]的形式来读取字典中的值，就类似根据名字找人了，值得一提的是，在一个字典中，一般键名是唯一的，值可以不是唯一的。

字典的添加键值对

字典是一种动态结构，可随时在其中添加键值对。要添加键值对，可依次指定字典名、用方括号括起来的键和与该键关联的值。字典名[键名]=值名

student1={'name':'abc','age':20,'gender':'male'}
student1['hobby']='pingpang'
print(student1)

修改字典中的值

student1={'name':'abc','age':20,'gender':'male'}
student1['name']='pingpang'
print(student1)

其实和添加是一样的，如果这个键名出现过在这字典里的话就会直接修改该键名所对应的值，如果不存在就会添加一个新的键值对于字典中。

删除字典里的键值对

student1={'name':'abc','age':20,'gender':'male'}
del student1['name']
print(student1)

对于字典中不需要的元素，可以使用类似列表删除的del 字典名[键名]进行删除，这样这个键值对就会永远消失在这字典内了。

循环

for循环

for letter in 'Python':     
   print("当前字母: %s" % letter)

类似于for 变量 in 遍历值：形式的结构体就是for循环，它可以用于遍历任何序列的项目，例如一个字符串，一个数组，等等。循环的目的是对这一类元素，例如这个列表或者字符串内的所有元素进行需要重复进行的操作而诞生的，不然你想象下写一大堆重复代码来实现当前效果的会是怎么样。

a = 'Python'
print("当前字母:",a[0])
print("当前字母:",a[1])
print("当前字母:",a[2])
print("当前字母:",a[3])
print("当前字母:",a[4])
print("当前字母:",a[5])

为了实现同样的的效果，一个所用代码只需要两行，一个则写了那么多行，要是我们要逐字打印出一篇文章的每个字母呢？那给写多少行重复代码啊？所以循环的目的就是帮我们实现简化重复操作。

for循环的代码架构为
for 变量 in 需要重复进行同一操作的元素群：
（四个空格的缩进）需要重复执行的代码行
简单来说，我们可以把我们需要进行同一操作的元素群视为一箱青苹果，现在我们要给每个苹果都涂成红色，所以我们使用一个变量，也就是另一个新箱子把原来箱子里的每个青苹果挨个装出来，然后执行涂红的操作。所以如果这个写成代码形式的应该是如下。需要记住的是，新箱子每次只能按顺序装出一个青苹果哦。

for 新箱子 in 一箱青苹果:
    涂红新箱子里的苹果

这样我们就能以很少的代码行数实现将箱子里的所有青苹果涂红的操作了。

for number in range(1,10):
    print(number)

例如我们之前提到的遍历输出数字1到9。当然我们也可以遍历一个数组，如下。

tang = [123,435,1234,513245,11243,1234,1234,534,346]
for i in range(len(tang)):
    print (tang[i])

while循环

count = 0
while count < 9:
   print ('The count is:', count)
   count = count + 1

while bool条件：while循环体就像这样，只要中间的bool值为true，那么这个循环就会一直进行下去，所以要使用这个循环的时候，一定要注意条件判断，避免进入死循环，导致程序一直进行下去。

while 判断条件值：
（四个空格缩进）需要重复执行的操作代码行

while循环的结构体和for有点不一样，它只需要一个bool值来进行判断是否要继续执行下去，就像我们过马路，如果是绿灯的话，我们自然就一直往前走了，直到红灯为止。bool值为true就是绿灯，为false就是红灯。

while 红灯还是绿灯:
    需要重复执行的代码语句

所以这里就能看出for循环和while循环的差别，for循环在涂完那一箱青苹果的颜色后就自动退出了；而while循环只要是绿灯就会一直涂的去，哪怕苹果已经涂完了，所以使用while循环的时候一定要注意退出条件，避免进入死循环，导致程序崩溃。

continue和break语句

除了修改红绿灯能够改变while语句是否要执行，我们还可以使用continue和break语句来实现控制循环，其中continue 用于跳过该次循环而break 则是用于退出循环。举个例子来说，我们还是有一箱青苹果，还是要给其中的每个青苹果涂上红色，但是这回我只想给其中下标索引偶数的青苹果涂上红色，于是我们就可以使用类似如下语句形式来实现这个目的。

a_box_green_apple(一箱青苹果)
number=-1（记录当前涂到第几个苹果的变量值）
while number<箱子内的总苹果数:
    number+=1
    if number%2>0:(利用%进行求余运算，判断下标索引值是否为偶数)
        continue（continue语句跳出当前循环，直接执行下一次循环，那么本次循环此语句后还未执行的代码也就不会执行了，直接进去下一个循环了，所以就不会给该苹果涂成红色了）
    a_box_green_apple[number]涂成红色
 

例如我们下面还有个输出1到10内的偶数的例子，其实这两个例子一样的意思。

i = 1
while i < 10:   
    i += 1
    if i%2 > 0:     # 非双数时跳过输出
        continue
    print (i)        # 输出双数2、4、6、8、10
 

而break语句则是直接跳出循环体不在进行循环了，假如说我们之前给箱子里的前10个青苹果涂成红色，而后面的苹果保持不变，那么这时候我们就是可以使用break语句来控制了。

a_box_green_apple(一箱青苹果)
number=-1（记录当前涂到第几个苹果的变量值）
while True:（一直执行循环）
    number+=1
    a_box_green_apple[number]涂成红色
    if number==9：
        break

这样我们涂完了箱子里的前十个青苹果后就直接跳出循环了，不会再执行任何循环操作了。下面那个输出1到10的具体例子和上文例子是一样的思想。

i = 1
while True:            # 相当于一路绿灯
    print (i)        # 输出1~10
    i += 1
    if i > 10:     # 当i大于10时跳出循环
        break

continue语句和break语句都是用于控制循环的语句，这也就是意味着它们不仅仅可以使用于while循环体系之中，也可以使用于for循环体系之中。要时刻注意，continue语句是跳出当前循环不执行之后的语句直接开始下次循环，而break语句是直接跳出循环不再进行循环了。

循环嵌套

正如我们上文所说，循环是重复执行循环体内的循环，那么我们把另一个循环放入其中一个循环体内，那么就是实现循环嵌套。我们可以在一个for循环或是一个while循环中嵌套另一个for循环或者while循环，到达循环嵌套的目的。给个简单的例子。打印99乘法表。

for x in range(1,10):
    for y in range(1,10):
        print(x*y,end="\t")

再来个例子，用循环嵌套输出坐标（0，0）到坐标（3，3）。

for x in range(4):
    for y in range(4):
        print("当前坐标点",(x,y))

简单讲解一下就是，对于每个外层循环，都会把内部循环给全部执行一遍，在这个例子中就是对于每个x都会进行一遍y等于0到3的循环输出。所以也就是外层循环走一次，它的内层循环就会全部走完一遍，然后外层循环再进行下次循环，层循环再次全部走完一遍……

形如此类就是嵌套循环，循环嵌套是一种进行写数学题很有用的东西。但这里简单理解一下，明白有这个东西就好了。