列表

列表简介

1. 列表的定义

  列表是Python中最基本的数据结构,列表是最常用的Python数据类型,列表的数据项不需要具有相同的类型。列表中的每个元素都分配一个数字 ,即它的位置,下标,或索引。第一个索引(或者位置,或者下标)是0,第二个索引(或者位置,或者下标)是1,依此类推。

  列表由一系列安特定顺序排列的元素组成。组成列表的元素可以包含字符、数字等等。我看可以将任何东西都加到列表中,其中的元素之间可以没有任何关系。
  Python有6个序列的内置类型,但最常见的是列表和元组。序列都可以进行的操作包括索引,切片,加,乘,检查成员。此外,Python已经内置确定序列的长度以及确定最大和最小的元素的方法。

  在Python中,用方括号([ ])来表示列表,并用逗号来分隔其中的元素。

  例如,我们将学生A、学生B、学生C的姓名存到一个列表中,并将其打印出来。

  代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 print(student_names)

 

运行结果:

['Yun Qtian', 'Feng Kuang', 'Yu Bao']

 

 以上方式是打印了整个列表,但是有时我们只想打印其中某个元素的位置。

 

2.  列表元素的访问

  列表是有序的集合,因此要访问列表中的任何元素,只需将该元素的位置或索引告诉Pyhonn即可。访问列表中某个元素的方法:

  列表名[位置或索引[]

  在Python中,第一个列表元素的位置下标或索引为0,而不是1;第二个列表元素的位置下标或索引是1;第三个列表元素的位置下标或索引为2。由此类推,第n个列表元素的位置下标或索引等于n-1。因此,要访问列表中的任何元素,只需将元素所在列表的位置减1后作为该元素的下标或索引来访问列表即可。

  例如,我们需要访问1.1 中学生的姓名列表中的第一个同学的姓名和最后一个学生的姓名,并分别打印一个相关信息。

  代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 student_names_len = len(student_names)
3 first_student = student_names[0]
4 last_student = student_names[student_names_len-1]
5 first_student_mes = "The first student is"+ first_student + "."
6 last_student_mes = "The last student is" + last_student + "."
7 print(first_student_mes)
8 print(last_student_mes)

  第1行,定义了一个列表student_names。

  第2行,用求长度的函数len()取出列表的长度,并赋值给变量student_names_len 。

  第3行,将第一个学生的姓名取出来,并赋给变量first_student。

  第4行,将列表中的最后一个学生的姓名取出来,并赋值给变量last_student。

  第 5行,给第一个学生要打印的信息变量first_student_mes 赋值一个字符串。

  第6行,给最后一个学生要打印的信息变量last_student_mes 赋值一个字符串。

  第7行,打印变量first_student_mes 的值。

  第8行,打印变量last_student_mes 的值。

  

  运行结果:

1 The first student is Yun Qtian .
2 The last student is Yu Bao .

  从以上的运行结果可知,当我们请求获取元素时,Python只返回该元素,而不包含方括号和引号。

 

3.  元素的增、删、改

  在Python中,我们创建的大多数列表都将是动态的,这意味着列表被创建后,将可能根据实际需要进行增删改等操作。

 

3.1  在列表中增加元素   

  在Python中,Python为我们提供了append()方法,让我们可以方便的将元素增加到已有的列表中。Python提供了多种在已有列表中增加新的元素的方式。现在介绍一下两种方式:

  (1)在列表末尾增加元素

  例如,现在有新的学生进入班级,我们在已有的学生列表student_names中增加该学生的姓名,并且将其增加到已有学生的后面,打印新列表,同时打印一条欢迎语句。

  代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 new_student_name = input("The new student:").title()
3 student_names.append(new_student_name)
4 message = "Welcome" +" " + new_student_name + " "+"to our class!"
5 print(student_names)
6 print("\033[31;1m %s \033[1m"%(message))

  说明:

  第1行,已有列表。

  第2行,根据提示输入新学生的姓名,并将其首字符大写后赋值给变量new_student_name。

  第3行,使用append()方法把变量的new_student_name的值增加到已有列表student_names中。

  第4行,编辑一条欢迎新同学来到我们班的欢迎信息。

  第5行,打印增加新同学后的列表,我们发现新同学的姓名被默认增加到已有列表的末尾。

  第6行,打印欢迎信息,并且字体颜色用红色,以表热烈欢迎。

 

  运行结果:

1 The new student:dian lei
2 ['Yun Qtian', 'Feng Kuang', 'Yu Bao', 'Dian Lei']
3  Welcome Dian Lei to our class! 

 

  (2)在列表中插入元素

  在实际编程中,有时我们不仅需要在已有列表中增加元素即可,而是希望在已有列表找那个的某个位置插入一个我们想要的值。那么,该怎么办呢?

  在Python中,我们可以使用insert()方法在已有列表的任何想要插入的位置增加新元素。因此,当我们使用insert()方法时,在括号中指定新元素要插入的位置下标或索引以及要插入的新值。其格式如下:

  insert(index,新元素)

  例如,现在有新的学生进入班级,我们在已有的学生列表student_names中增加该学生的姓名,并且将其增加到已有学生的前面,打印新列表,同时打印一条欢迎语句。

  代码:

 

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 new_student_name = input("The new student:").title()
3 student_names.insert(0,new_student_name)
4 message = "Welcome" +" " + new_student_name + " "+"to our class!"
5 print(student_names)
6 print("\033[31;1m %s \033[1m"%(message))

  说明:

  第3行,调用Python中的insert()方法,在列表student_names的第一个位置插入变量new_student_name的值。

  以上代码除第3行代码有变化之外,其余代码未变,因此,其余行不再重复解释。

  运行结果:

  

1 The new student:dian lei
2 ['Dian Lei', 'Yun Qtian', 'Feng Kuang', 'Yu Bao']
3  Welcome Dian Lei to our class! 

  从以上运行结果中,我们清楚的看到,元素 'Dian Lei' 被插入到列表的开头位置后,原有的元素都依次向右移了一个位置。

 

3.2  从列表中删除元素

  在实际应用中,有时我们需要从列表中删除一个或多个元素。因此,在Python中我们可以根据位置或值来删除列表中的元素。

  (1)使用 del 语句删除元素

   在Python列表中,如果我们知道所要删除的元素在列表总的具体位置,则可以使用del语句删除该元素。

  例如,我们删除已有列表student_names中的第二个元素。

  代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 print("删除前的列表:",student_names)
3 del student_names[1]
4 print("删除后的列表:",student_names)

 说明:第2行,使用del语句删除列表中的下标为1,或者说索引为1的元素,即列表中的第二个元素。

 

  运行结果: 

1 删除前的列表: ['Yun Qtian', 'Feng Kuang', 'Yu Bao']
2 删除后的列表: ['Yun Qtian', 'Yu Bao']

  从以上运行结果可知,在Python中,只要用del语句删除了的元素,再次访问列表时就无法再访问它了。

  

  (2)使用pop()方法删除元素

  在Python中实际应用中,有时我们想删除一些值,但又想接着使用它。此时,就可以使用pop()方法。

  pop()方法可以删除列表末尾的元素,并还能接着使用删除的元素。

  例如,我们删除已有列表student_names中的一个元素。

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 print("删除前的列表:",student_names)
3 popped_student_name = student_names.pop()
4 print("删除后的列表:",student_names)
5 print("删除的元素:",popped_student_name)

  说明:

  第3行,我们调用Python中的pop()方法,从列表student_names中删除一个元素,并赋值给变量popped_student_name。

 

  运行结果:

1 删除前的列表: ['Yun Qtian', 'Feng Kuang', 'Yu Bao']
2 删除后的列表: ['Yun Qtian', 'Feng Kuang']
3 删除的元素: Yu Bao

  从以上运行结果可知,在Python,pop()方法是从列表的末尾,将元素从该列表中弹出,不再让该元素出现在列表中。

  

  (3)弹出列表中任何位置处的元素

  在上面的使用pop()方法时,我们初步了解了pop()方法,其实,pop()方法也能删除列表中任何位置的元素,但是你必须告诉他具体位置,即在pop()方法的括号中指定要删除的元素的下标或索引即可。

  例如,我们仍然删除已有列表student_names中的二个元素。

  代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 print("删除前的列表:",student_names)
3 popped_student_name = student_names.pop(1)
4 print("删除后的列表:",student_names)
5 print("删除的元素:",popped_student_name)

  说明:

  第3行,我们调用Python中的pop()方法,指定删除列表student_names中下标为1的元素,并赋值给变量popped_student_name。

  

  运行结果:

1 删除前的列表: ['Yun Qtian', 'Feng Kuang', 'Yu Bao']
2 删除后的列表: ['Yun Qtian', 'Yu Bao']
3 删除的元素: Feng Kuang

  从以上运行结果,我们发现,其删除元素的效果跟(1)中的del语句的效果一样。那么我们在是情况该怎么选择哪种删除列表元素的方法呢?记住以下两条判断规则即可:

  第一条:如果你想要从列表中删除一个元素,并且不再以任何方式使用它,那么就是用del语句;

  第二条:如果你想要在删除该元素后还能继续使用它,那么就使用pop()方法。

 

  (4)根据值删除元素

  在实际应用中,有时我们想删除列表中的某个元素,但不知道该元素的具体位置,此时,我们可以选择用remove()方法删除该元素。

  例如,我们删除已有列表student_names中的元素"Yu Bao"。

  代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 print("删除前的列表:",student_names)
3 student_names.remove("Yu Bao")
4 print("删除后的列表:",student_names)

  说明:

  第3行,我们调用Python中的remove()方法,根据指定的元素"Yu Bao"删除列表student_names中的元素"Yu Bao"。

  

  运行结果:

1 删除前的列表: ['Yun Qtian', 'Feng Kuang', 'Yu Bao']
2 删除后的列表: ['Yun Qtian', 'Feng Kuang']

  

  那么,假如列表中存在相同值得元素时,我们根据元素值删除元素,究竟是删除哪个,还是都删呢?请看一下例子。

  例如,我们先把要删除的值存到列表的开头,然后再用remove()方法删除指定的值。

  代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 student_name_remove = "Yu Bao"
3 student_names.insert(0,student_name_remove)
4 print("删除前的列表:",student_names)
5 student_names.remove(student_name_romove)
6 print("删除后的列表:",student_names)
7 print(student_names[0])
8 print(student_name_remove)

  说明:

  第2行,将要删除的元素存到变量student_name_remove中。

  第3行,使用insert()方法在列表student_names中的第一个位置插入变量的值,

  第5行,使用remove()方法,根据指定的值删除该元素。

 

  运行结果:

1 删除前的列表: ['Yu Bao', 'Yun Qtian', 'Feng Kuang', 'Yu Bao']
2 删除后的列表: ['Yun Qtian', 'Feng Kuang', 'Yu Bao']
3 Yun Qtian
4 Yu Bao

  从以上运行结果可知,使用remove()方法从列表中删除元素时,也可以接着使用它的值。另外,如果指定删除的值在列表中出现多次,remove()只会删除指定值的第一个值,其余相同的值仍在列表中。若需将其他的值也删除,需要使用循环来判断是否删除了所有与指定值相同的元素。

   代码:

 1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
 2 student_name_remove = "Yu Bao"
 3 student_names.insert(0,student_name_remove)
 4 print("删除前的列表:",student_names)
 5 for _student_name in student_names:
 6    if _student_name == student_name_remove :
 7      student_names.remove(student_name_remove)
 8 print("删除后的列表:",student_names)
 9 print(student_names[0])
10 print(student_name_remove)

  说明:

  第5行,开始循环列表student_names,并将每次循环的结果存放到变量_student_name中。

  第6行,开始判断循环变量的值是否等于需要删除的元素值,如果结果为true,则执行第7行的循环体,删除该元素。反之继续循环,直到for循环结束为止。

  

  运行结果:

1 删除前的列表: ['Yu Bao', 'Yun Qtian', 'Feng Kuang', 'Yu Bao']
2 删除后的列表: ['Yun Qtian', 'Feng Kuang']
3 Yun Qtian
4 Yu Bao

  从以上运行结果可知,列表中所有的元素值为"Yu Bao" 的元素都已被删除。

 

3.3 列表元素的修改

  在Python中,修改列表元素的语法与访问列表元素的语法类似。要修改列表元素,可指定列表名和要修改的元素的索引,再指定该元素的新值即可。其语法格式如下:

  列表[index] = 新值

  例如,我们想要把已有的列表student_names中的最后一个元素的值改为"Dian Lei"。

  代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 print("修改前的列表:",student_names)
3 list_length = len(student_names)
4 student_names[list_length -1 ] = "Dian Lei"
5 print("修改后的列表:",student_names)

  说明:

  第3行,使用函数len()求出列表student_names的长度,并赋值给变量list_length。

  第4行,直接用等号给列表student_names的最后一个元素赋予新值。

 

  运行结果:

1 修改前的列表: ['Yun Qtian', 'Feng Kuang', 'Yu Bao']
2 修改后的列表: ['Yun Qtian', 'Feng Kuang', 'Dian Lei']

  从以上运行结果可知,列表的最后一个元素确实被修改为了新的值。

  在Python中,列表的第一个元素的索引为0,如果我们不知列表究竟有多长,就不知道列表的最后一个元素的索引是多少,但是Python找那个提供了一个获取列表倒数第一个元素的方式,即列表后的中括号中索引为-1时,则表示获取列表的最后一个元素。因此,以上的代码可优化为:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 print("修改前的列表:",student_names)
3 student_names[-1] = "Dian Lei"
4 print("修改后的列表:",student_names)

  

运行结果跟之前的一致:

1 修改前的列表: ['Yun Qtian', 'Feng Kuang', 'Yu Bao']
2 修改后的列表: ['Yun Qtian', 'Feng Kuang', 'Dian Lei']

 

4.  组织列表

  在我们创建的列表中,元素的排序常常是无法预测的,因为我们并非总能控制用户提供数据的顺序。虽然在许多情况下都是不可避免的,但我们经常需要一特定的顺序呈现信息。有时候我们希望保留列表元素最初的排列顺序,而有时又需要调整列表元素的排列顺序。因此,在Python中,Python提供了很多组织列表的方式,我们可以根据实际需要选择相应的排序方式。

4.1 列表的永久排序

  在Python中,如果需要对列表进行永久的排序,则可使用sort()方法。该方法可以让我们轻松的对列表进行排序。

  例如,我们对已有列表student_names进行永久排序。

  代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 print("p排序前的列表:",student_names)
3 student_names.sort()
4 print("排序后的列表:",student_names)

  说明:

  第3行,使用sort()方法对列表student_names中的元素进行了永久排序。

 

  运行结果:

1 p排序前的列表: ['Yun Qtian', 'Feng Kuang', 'Yu Bao']
2 排序后的列表: ['Feng Kuang', 'Yu Bao', 'Yun Qtian']

 

  在Python中,我们还可以按与字母顺序相反的顺序排列列表元素,为此,只需要向sort() 方法传递参数reverse=True即可实现。

  例如,将列表student_names中的元素按字母顺序相反的顺序排序。

  代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 print("p排序前的列表:",student_names)
3 student_names.sort()
4 print("第一次排序后的列表:",student_names)
5 student_names.sort(reverse=True)
6 print("第二次排序后的列表:",student_names)

  说明:

  第5行,向sort()方法中传递参数reverse=Ture,使第一次排序后的列表按字母顺序相反的顺序排列。

 

  运行结果:

1 p排序前的列表: ['Yun Qtian', 'Feng Kuang', 'Yu Bao']
2 第一次排序后的列表: ['Feng Kuang', 'Yu Bao', 'Yun Qtian']
3 第二次排序后的列表: ['Yun Qtian', 'Yu Bao', 'Feng Kuang']

  从运行结果中可知,对列表元素排序的修改是永久性的。

 

4.2 列表的临时排序

  在Python中,当我们既要保留列表元素原来的顺序,又想按特定的顺序展现它们时,可以使用函数sorted()。因为函数sorted()对列表的排序是临时的,不会影响原列表本身的排列顺序。

  例如,我们使用函数sorted()对列表student_names进行排序。

  代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 print("排序前的列表:",student_names)
3 student_names_sorted = sorted(student_names)
4 print("排序后的新列表:",student_names_sorted)
5 print("排序后的原列表:",student_names)

  说明:

  第3行,使用函数sorted()对列表student_names进行排序,并赋给一个变量student_names_sorted。

 

  运行结果:

1 排序前的列表: ['Yun Qtian', 'Feng Kuang', 'Yu Bao']
2 排序后的新列表: ['Feng Kuang', 'Yu Bao', 'Yun Qtian']
3 排序后的原列表: ['Yun Qtian', 'Feng Kuang', 'Yu Bao']

  从以上的运行结果可知,函数sorted()对列表student_names排序后,只对当前排序有效,并未改变原列表中的元素的排列顺序。

 

4.3 倒序打印列表

  在Python中,当我们需要将列表的元素倒序打印时,只需使用reverse()方法即可实现。

  例如,我们将列表student_names的元素倒序打印。

  代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 print("排序前的列表:",student_names)
3 student_names.reverse()
4 print("排序后的列表:",student_names)

  说明:

  第3行,使用reverse()方法对列表student_names进行倒序排列。

  

  运行结果:

1 排序前的列表: ['Yun Qtian', 'Feng Kuang', 'Yu Bao']
2 排序后的列表: ['Yu Bao', 'Feng Kuang', 'Yun Qtian']

  从以上运行结果中可知,reverse()方法不是指按字母顺序相反的顺序排列列表元素,而只是反转列表元素的排列顺序,并且该方法是永久性的,但可以随时恢复到原来的排列顺序,只需再次调用reverse()方法即可。

 

4.4  获取列表长度

  在Python中,使用函数len()即可快速获取列表的长度。其语法格式为:

  len(列表)

  例如,使用函数len()获取列表student_names的长度,并打印出来。

  代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 student_names_len = len(student_names)
3 print("列表student_names的长度为:",student_names_len)

  说明:

  第2行,使用函数len()求出列表student_names的长度,并赋值给变量student_names_len 。

 

  运行结果:

1 列表student_names的长度为: 3

 

5.  使用列表时如何避免索引错误

  当我们访问列表中的元素时,如果我们提供的索引超出了列表本身的长度减1时,则会提示索引错误。

  例如,我们的列表student_names中有三个元素,如果我们提供的索引为3,看看会出现什么结果。

  代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 print(student_names)
3 print(student_names[3])

 

  运行结果:

1 Traceback (most recent call last):
2   File "F:/PyProject/s14/day2/list.py", line 4, in <module>
3     print(student_names[3])
4 IndexError: list index out of range

  从运行结果错误提示可知,我们提供的索引超出了列表的索引的范围。

  因此,当我在访问列表时,在不确定列表的长度的情况下,我们最好先使用函数len()获取一下列表的长度,然后就知道我们提供的下标不能超过列表长度减1,或者将访问的索引打印出来,看看是否存在我们需要访问的元素。

  索引错误 意味着Python无法理解我们指定的索引。当程序发生索引错误时,可以尝试将我们指定的索引减1,然后再运行程序,看看结果是否正确。实在不行,就求一下列表的长度看看最大的索引值是多少。

  当我们需要访问列表中的最后一个元素,即列表的倒数第一个元素时,无论列表的长度如何变化,我们都可使用索引-1。

  例如,访问列表student_names中的倒数第一个元素,并打印出来。

  代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 print(student_names)
3 student_name_last = student_names[-1]
4 print(student_name_last)

 

  运行结果:

1 ['Yun Qtian', 'Feng Kuang', 'Yu Bao']
2 Yu Bao

 

  虽然索引-1总是能返回列表中的最后一个元素,但是前提是列表不为空。当列表为空时,这种访问列表中最后一个元素的方式才会引发程序错误。

  例如,我们创建一个空列表goods_list,然后用索引-1访问。

  代码:

1 goods_list = []
2 goods_last = goods_list[-1]
3 print(goods_last)

 

  运行结果:

1 Traceback (most recent call last):
2   File "F:/PyProject/s14/day2/list.py", line 4, in <module>
3     goods_last = goods_list[-1]
4 IndexError: list index out of range

 

 2. 操作列表

2.1 遍历整个列表

  在Python中,当我们需要遍历列表中的所有元素,并对其执行相同的操作时,我们可以使用for循环遍历列表。

  例如,我们有一个学生名单的列表student_names,现在要求依次打印出每个学生的名单。

  代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 print(student_names)
3 for student_name  in student_names:
4     print(student_name)

   说明:

  第3行,开始用for循环遍历列表student_names,并将每次取到的元素赋值给变量student_name。

  第4行,打印每次循环的变量的值。

 

  运行结果:

1 ['Yun Qtian', 'Feng Kuang', 'Yu Bao']
2 Yun Qtian
3 Feng Kuang
4 Yu Bao

 

2.2 避免缩进错误

  在Python中,由于没有大括号的使用,因此,Python根据缩进来判断代码与前一个代码行的关系。Python通过使用缩进让代码更容易读懂;简单地说,Python要求你使用缩进让代码整洁而结构清晰。

 

2.2.1 忘记缩进循环体

  对于位于for循环语句后面且循环组成部分的代码行,一定要缩进。如果你忘记缩进,Python会提示你。

  例如,我们用循环打印学生列表student_names。

  代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 print(student_names)
3 for student_name  in student_names:
4 print(student_name)

 

  运行结果:

1   File "F:/PyProject/s14/day2/list.py", line 4
2     print(student_name)
3         ^
4 IndentationError: expected an indented block

   从以上运行结果可知,由于代码中第4行没有缩进,导致Python没有找到期望缩进的代码,故出现错误。因此,Python中将紧跟在for语句后的代码进行缩进,可避免这种缩进错误发生。

 

2.2.2 忘记缩进额外的代码行

  在Python中,有时我们忘记缩进,其程序也能执行,也不报错,但其运行结果不是我们所想要的。

  例如,我们想打印学生列表中的学生,并为每个学生打印一条欢迎语句。

  代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 print(student_names)
3 for student_name  in student_names:
4     print(student_name)
5 print("Welcome to" +" " + student_name + "!")

 

  运行结果:

1 ['Yun Qtian', 'Feng Kuang', 'Yu Bao']
2 Yun Qtian
3 Feng Kuang
4 Yu Bao
5 Welcome to Yu Bao!

  从以上的运行结果可知,由于代码中的第5行忘记了缩进,导致运行结果中只为最后一个同学打印了欢迎语句。虽然代码运行为报错,但其结果不是我们想要的。因为这是一个逻辑错误。从语法说看,这是一个合法的Python代码,但由于存在逻辑错误,结果并不是我们想要的。

  正确的代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 print(student_names)
3 for student_name  in student_names:
4     print(student_name)
5     print("Welcome to" +" " + student_name + "!")

 

  满足需要的运行结果:

1 ['Yun Qtian', 'Feng Kuang', 'Yu Bao']
2 Yun Qtian
3 Welcome to Yun Qtian!
4 Feng Kuang
5 Welcome to Feng Kuang!
6 Yu Bao
7 Welcome to Yu Bao!

 

2.2.3  不需要的缩进

  在Python中,如果我们不小心将无需缩进的代码行缩进了,Python会提示我们哪里出错了。

  例如,我们打印一下学生列表。

  代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2     print(student_names)

 

  运行结果:

1 File "F:/PyProject/s14/day2/list.py", line 2
2     print(student_names)
3     ^
4 IndentationError: unexpected indent

  从以上结果中可知,代码的第2行,由于不属于前一行代码,因此Python将指出这种错误。

  为了避免意外缩进的错误,编写代码中一定要细心对待,是否缩进一定要严肃对待。

 

2.2. 4 循环后不必要的缩进

  在Python中,如果我们不小心缩进了应在循环结束后执行的代码,这些代码将针对每个列表元素进行重复执行。这种逻辑性错误,很多情况下时不会出现错误的,只是结果不是我们所期待的而已。

  例如,我们打印学生列表student_names时,并在最后打印一条欢迎信息。

   代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 for student_name  in student_names:
3     print(student_name)
4     print("Welcome to new students!" )

 

  运行结果:

1 Yun Qtian
2 Welcome to new students!
3 Feng Kuang
4 Welcome to new students!
5 Yu Bao
6 Welcome to new students!

  从以上的运行结果可知,我们在每个学生的后面打印了一条相同的欢迎信息,其实我们想要的是在所有学生打印完后打印这条信息即可。这就是由于代码中第4行不小心缩进了导致的结果。

  正确的代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 for student_name  in student_names:
3     print(student_name)
4 print("Welcome to new students!" )

 

  正确的运行结果:

1 Yun Qtian
2 Feng Kuang
3 Yu Bao
4 Welcome to new students!

 

2.2.5 遗漏了冒号

  在Python中,for循环末尾的冒号告诉Python解释器,下一行时循环的第一行。如果我们不小心遗漏了冒号,将会导致语法错误,因为Python不知道我将要做什么。这种错误虽然易于消除,但不易发现。

例如,我们需依次打印学生列表student_names。

  代码:

1 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
2 for student_name  in student_names
3     print(student_name)
4 print("Welcome to new students!" )

 

  运行结果:

1   File "F:/PyProject/s14/day2/list.py", line 2
2     for student_name  in student_names
3                                      ^
4 SyntaxError: invalid syntax

  从以上结果可知,代码第2行出错了。所以,在Python中,如果控制语句后提示不明显的错误提示,我们先看看是不是少了冒号。这样可能会帮忙我们尽快找到缺失冒号的问题。

 

2.3 创建数值列表

  在数据可视化中,处理的几乎都是有数字(如温度、距离、人口数量、经度和纬度等)组成的集合。然而列表非常适用于存储数字集合,Python提供了很多工具。可以帮助我们高效地处理数字列表。

 

2.3.1 函数range()的使用

  Python中提供了函数range(),让我们能够轻松地生成一系列的数字。函数range()一般有三种使用形式。

  (1)只指定一个数值

  例如,用函数range()打印一组数据。

  代码:

1 for i in range(10):
2     print("lood ",i)

 

  运行结果:

 1 lood  0
 2 lood  1
 3 lood  2
 4 lood  3
 5 lood  4
 6 lood  5
 7 lood  6
 8 lood  7
 9 lood  8
10 lood  9

  从以上运行结果可知,函数range()如果只指定一个数值,默认从0开始打印,并且到指定的数值减1后停止。

  

  (2)指定起始位置

  例如,我们想要打印1到10,是个数字,那么需要指定开始位置为1,结束位置为10。

  代码:

1 for i in range(1,11):
2     print("lood ",i)

 

  运行结果:

 1 lood  1
 2 lood  2
 3 lood  3
 4 lood  4
 5 lood  5
 6 lood  6
 7 lood  7
 8 lood  8
 9 lood  9
10 lood  10

  从以上结果可知,Python中,函数range(x,y),表示从x开始,到y-1结束,既不包含第二个数值。所以我们使用Python时,如果输出不符合预期,可以尝试将指定的值加1或者减1。

 

  (3)指定起始位置即步长

  例如,我们用函数range()打印1到10中内的所有奇数。

  代码:

1 for i in range(1,11,2):
2     print(i)

  说明:

  第1行,开始第一个数字为1,最后一个数字为11减1,然后步长为2,即每个两个打印一个。

 

  运行结果:

1 1
2 3
3 5
4 7
5 9

  从以上结果可知,假如我们需要打扫的是1到10之间的所有偶数,那么开始位置从2开始打印即可。

 

  例如:我们用函数range()打印1到10中内的所有偶数。

1 for i in range(2,11,2):
2     print(i)

 

  运行结果:

1 2
2 4
3 6
4 8
5 10

 

2.3.2 使用函数range()创建列表

  在Python中,当我们想要创建数字列表时,可以使用函数list()将函数range()的结果直接转换为列表。如果将函数range()作为函数list()的参数,输出将为一个数字列表。

  例如,我们用函数list()将函数range()打印的1到10的数字转换为一个列表。

  代码:

1 number_list = list(range(1,11))
2 print(number_list)

  说明:第1行,range(1,11)打印的结果被函数list()转换为一个数字列表。

 

  运行结果:

1 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

 

  在Python中,两个星号(**)表示乘方运输。

  例如,我们将1到10的乘方转换Wie一个数字列表。

  代码:

1 squares = []
2 for i in range(1,11):
3     square = i ** 2
4     squares.append(square)
5 print(squares)

  说明:

  第1行,定义了一个空列表squares。

  第2行,使用函数range让Python遍历1到10的值。

  第3行,将每次循环的数字赋值给变量square。

  第4行,使用方法append()将每次循环的变量的值追加到列表squares中。

 

  运行结果:

1 [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

 

  在Python中,创建更复杂的列表时,可使用上述两种方法中的任何一种。但是有时我们使用临时变量会让代码更易读;而在其他情况下,这样做只会让代码无谓的变长。所以我们编写Python代码时,应该先考虑如果编写清晰易懂,并且能够满足需要的代码;等到审核代码时,再考虑采用更高效的方法。

 

2.3.3 对数字列表执行简单的统计运算

  在Python中,有几个专门处理数字列表的函数,最大值(max);最小(min);总和。

  例如,我们需要求出0到9等10个数字的最大值、最小值,总和。

  代码:

1 list = []
2 for i in range(10):
3     list.append(i)
4 print("列表list为:",list)
5 print("列表list的最大值为:",max(list))
6 print("列表list的最小值为:",min(list))
7 print("列表list的总和为:",sum(list))

 

  运行结果:

1 列表list为: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
2 列表list的最大值为: 9
3 列表list的最小值为: 0
4 列表list的总和为: 45

 

2.3.4 列表解析

  在前面的生成列表squares的方式包含了四五行代码,然而列表解析只需编写一行代码就能生成这样的列表。列表解析将for循环和创建新元素的代码合并成一行,并自动附加新元素。

  例如,我们使用列表解析创建前面的生成的1到10的平方数列表。

  代码:

1 squares = [i**2 for i in range(1,11)]
2 print(squares)

 

  运行结果:

1 [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

 

2.4 使用列表的一部分

  在Python中,我们不仅可以对列表中的单个元素进行处理,还能处理列表元素中的部分元素——Python称之为切片。

 

2.4.1 切片

  我们创建切片时,可指定要是用的第一个元素和最后一个元素的索引。与函数range()一样,Python在到达我们指定的第二个索引前面的元素后停止。

  例如,我们创建一个1到10的中每个数的平方的数字组成的列表,然后分别对其中的部分元素进行各种切片操作。

  代码:

 1 squares = [i**2 for i in range(1,11)]
 2 print(squares)
 3 print("----指定第一个索引和第二个索引-------")
 4 print(squares[0:6])
 5 print(squares[-3:9])
 6 print(squares[-3:-1])
 7 print("----不指定第一个索引-------")
 8 print(squares[:6])
 9 print(squares[:-3])
10 print("----不指定第二个索引-------")
11 print(squares[5:])
12 print(squares[-3:])

  说明:

  第一行,从1开始循环到10,并将每个数字进行平方后组成一个列表squares。

  第2行,打印列表squares。

  第4行,打印列表squares的一个切片,其中包含列表的前五个元素。

  第5行,打印列表squares的一个切片,其中包含列表的后三个元素开始到列表的第8个元素。

  第6行,打印列表squares的一个切片,其中包含列表的后三个开始到后一个元素。

  第8行,打印列表squares的一个切片,其中第一数字省略不指定,打印到列表的第5个元素后停止。

  第9行,打印列表squares的一个切片,其中第一数字省略不指定,打印到列表的后三个元素之前停止。

  第11行,打印列表squares的一个切片,其中第二数字省略不指定,从列表的第5个元素开始打印到列表的末尾。

  第12行,打印列表squares的一个切片,其中第二数字省略不指定,从列表的倒数第三个元素开始到列表的末尾。

 

  运行结果:

 1 [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
 2 ----指定第一个索引和第二个索引-------
 3 [1, 4, 9, 16, 25, 36]
 4 [64, 81]
 5 [64, 81]
 6 ----不指定第一个索引-------
 7 [1, 4, 9, 16, 25, 36]
 8 [1, 4, 9, 16, 25, 36, 49]
 9 ----不指定第二个索引-------
10 [36, 49, 64, 81, 100]
11 [64, 81, 100]

  从以上的运行结果可知,Python切片后仍然是一个列表;Python切片中,如果不指定第一个索引,或指定为0时,则表示从列表的第一个元素开始进行切片;Python切片中,如果不指定第二个索引,或负1时,则表示切片到列表倒数第一个元素后停止切片;PYthon切片中,索引为负时,表示倒数的位置索引。

 

2.4.2 遍历切片

  在Python中,假如我们需要遍历部分列表元素,可在for循环中使用切片。

  例如,我们创建一个1到10的中每个数的平方的数字组成的列表,然后遍历前五个元素。

  代码:

1 squares = [i**2 for i in range(1,11)]
2 print(squares)
3 for _square in squares[:5]:
4     print(_square)

  说明:

  第3行,用for循环开始从列表的第一个元素开始循环到第五个元素,即索引为4的元素。

 

  运行结果:

1 [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
2 1
3 4
4 9
5 16
6 25

 

  在Python中,很多情况下,切片都很有用。处理数据时,我们可以使用切片来进行批量处理;编写Web程序时,可使用切片来分页显示信息,并在每页显示数量合适的信息。

 

2.4.3 复制列表

  在Python中,假如我们需要复制一个列表,那么可创建一个包含整个列表的切片,方法是同时省略起始索引和终止索引([:])。这让Python创建一个始于第一个元素,终止于最后一个元素的切片,即复制整个列表。

  例如,我们创建一个1到10的中每个数的平方的数字组成的列表,然后复制这个列表作为一个新列表。

  代码:

1 squares = [i**2 for i in range(1,11)]
2 print("原列表:",squares)
3 new_squares = squares[:]
4 print("新列表:",new_squares)

  说明:

  第3行,由于省略了切片中的开始和结束的索引,默认从列表的第一个元素开始切片,到最后一个元素后停止,并将切片后的结果赋值给变量new_squares。

 

  运行结果:

1 原列表: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
2 新列表: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

 

  例如,我们创建一个1到10的中每个数的平方的数字组成的列表,然后复制这个列表作为一个新列表,并分别在原列表和新列表中分别增加数字66、99。

  代码:

 1 squares = [i**2 for i in range(1,11)]
 2 print("原列表:",squares)
 3 new_squares = squares[:]
 4 _new_squares = squares
 5 print("新列表:",new_squares)
 6 print("变量_new_squares的值:",_new_squares)
 7 squares.append(66)
 8 new_squares.append(99)
 9 print("原列表新增元素后:",squares)
10 print("新列表增加元素后:",new_squares)
11 print("变量_new_squares的值:",_new_squares)

  说明:

  第4行,将列表squares的值赋值给变量_new_squares。

  第7行,向原列表squares中增加一个数字66。

  第8行,向原列表squares中增加一个数字99。

  

  运行结果:

1 原列表: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
2 新列表: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
3 变量_new_squares的值: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
4 原列表新增元素后: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 66]
5 新列表增加元素后: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 99]
6 变量_new_squares的值: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 66]

  从以上运行结果可知,切片后复制的是两列表,而使用等号直接复制给变量的是结果会随着原列表的变化而变化。

  以上复制列表的方式在Python中属于浅copy,除以上的方式外,还有以下几种列表的copy方式。

  代码:

 1 import copy
 2 
 3 squares = [i**2 for i in range(1,11)]
 4 print("原列表:",squares)
 5 new_squares = squares[:]
 6 new_squares2 = copy.copy(squares)
 7 new_squares3 = list(squares)
 8 print("新列表1:",new_squares)
 9 print("新列表2:",new_squares2)
10 print("新列表3:",new_squares3)

  说明:

  第1行,导入Python标准库中的copy模块。

  第5行,用切片的方式实现列表复制,并赋值给一个列表变量new_squares 。

  第6行,调用导入的Python标准库中的copy模块的copy方法,实现复制列表的功能,并赋值给列表变量new_squares2。

  第7行,调用Python中的工厂函数list()实现,并赋值给列表变量new_squares3。

  

  运行结果:

1 原列表: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
2 新列表1: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
3 新列表2: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
4 新列表3: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

  从以上结果可知,在Python中,实现列表复制,即浅copy的放肆有三种。其中copy()方法需要导入Python标准库中的copy模块。

 

2.4.4 列表嵌套使用

  在Python中,列表可以嵌套列表。

  例如,我们先用函数range()创建一个1到10的数字列表,然后将每个数字的平方作为一个平方列表,并将其嵌套到数字列表中。

  代码:

1 number_list = [i for i in range(1,11)]
2 print("原列表:",number_list)
3 squares = [i**2 for i in range(1,11)]
4 print("平方列表:",squares)
5 number_list.append(squares)
6 print("嵌套列表:",number_list)
7 print("嵌套列表的最后一个元素是:",number_list[-1])

  说明:

  第1行,用函数range()和for循环语句实现创建一个1到10的数字列表,并赋值给变量number_list。

  第3行,用函数range()和、for循环语句即求平方的方式实现创建一个1到10的数字的平方的列表,并赋值给变量squares。

  第5行,调用Python中的append()方法将创建的平方列表增加到开始创建的数字列表number_list中。

  

  运行结果:

1 原列表: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
2 平方列表: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
3 嵌套列表: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]]
4 嵌套列表的最后一个元素是: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

  从以上的运行结果可知,Python中列表可以嵌套列表。

 

2.5 元组

2.5.1 元祖的定义

  在Python中,将不能修改的值称为不可变的,而不可变的列表被称为元组。元组看起来犹如列表,但其使用圆括号而不是方括号来标识。定义元组后,就可以使用索引来访问其元素,就像访问列表一样。

  例如,定义一个元组,并访问其元素。

  代码:

1 emp_nos = (100001,100002,100003,100004,100005)
2 print("元组的第一个元素是:",emp_nos[0])
3 print("元组的第二个元素是:",emp_nos[1])
4 print("元组的所有的元素是:",emp_nos[:])

  说明:

  第1行,定义了一个元组,元素分别为:100001,100002,100003,100004,100005 。

  第2行,打印元组的第一个元素。

  第3行,打印元组的第二个元素。

  第4行,打印元组的所有元素。

  

  运行结果:

1 元组的第一个元素是: 100001
2 元组的第二个元素是: 100002
3 元组的所有的元素是: (100001, 100002, 100003, 100004, 100005)

  从以上的运行结果可知,我们用每个元素的索引,即可访问每个元素。跟列表一样,元组也可以进行各种切片,其切片方式跟列表切片类似。

  例如,定义一个元组,并对其进行切片。

  代码:

1 emp_nos = (100001,100002,100003,100004,100005)
2 print("元组:",emp_nos)
3 print("元组的第一个元素是:",emp_nos[0])
4 print("元组的第二个元素是:",emp_nos[1])
5 print("元组的所有的元素是:",emp_nos[:])
6 print("元组的前三个元素是:",emp_nos[:3])
7 print("元组的后三元素是:",emp_nos[-3:])
8 print("元组的第二个元素到第三个元素是:",emp_nos[1:3])

  说明:

  第6行,打印元组的前三个元素。

  第7行,打印元组的后三个元素。

  第8行,打印元组的第二个元素到第三的元素。

 

  运行结果:

1 元组: (100001, 100002, 100003, 100004, 100005)
2 元组的第一个元素是: 100001
3 元组的第二个元素是: 100002
4 元组的所有的元素是: (100001, 100002, 100003, 100004, 100005)
5 元组的前三个元素是: (100001, 100002, 100003)
6 元组的后三元素是: (100003, 100004, 100005)
7 元组的第二个元素到第三个元素是: (100002, 100003)

 

2.5.2 遍历元组

  在Python中,有时我们需要遍历访问元组中的所有元素。

  例如,定义一个元组,并用for循环对其进行遍历访问。

  代码:

1 emp_nos = (100001,100002,100003,100004,100005)
2 print("元组:",emp_nos)
3 print("工号如下:")
4 for emp_no in emp_nos:
5     print(emp_no)

 

  运行结果:

1 元组: (100001, 100002, 100003, 100004, 100005)
2 工号如下:
3 100001
4 100002
5 100003
6 100004
7 100005

 

2.5.3 修改元组变量

  在Python中,虽然我们不能修改元组的元素,但可以给存储元祖的变量赋值。即可以重新定义整个元祖。

  例如,定义一个元祖,然后将其修改为另一个新值。

  代码:

 1 emp_nos = (100001,100002,100003,100004,100005)
 2 print("修改元组变量前的:",emp_nos)
 3 print("工号如下:")
 4 for emp_no in emp_nos:
 5     print(emp_no)
 6 
 7 emp_nos = (600001,600002,600003,600004,600005)
 8 print("修改元组变量后的:",emp_nos)
 9 print("工号如下:")
10 for emp_no in emp_nos:
11     print(emp_no)

 

  运行结果:

 1 修改元组变量前的: (100001, 100002, 100003, 100004, 100005)
 2 工号如下:
 3 100001
 4 100002
 5 100003
 6 100004
 7 100005
 8 修改元组变量后的: (600001, 600002, 600003, 600004, 600005)
 9 工号如下:
10 600001
11 600002
12 600003
13 600004
14 600005

  从以上结果可知,相对于列表,元组是更简单的数据结构。如果需要存储一组值,在程序的整个生命周期内都不不变,可使用元组。

 

2.6 设置代码格式

  在Python中,为了确保所有人编写的代码的结构都大致一致,Python程序员都遵循一些格式设置约定。

 

2.6.1 格式设置指南

  在Python中,若要提出Python语言修改建议,需要编写Python改进提案(Python Enhancement Proposal,PEP)。PEP 8 时最古老的的PEP之一,它向Python程序员提供了代码格式设置指南。

 

2.6.2 缩进

   PEP 8 S建议每级缩进都使用四个空格,这既可以提高可读性,又留下了足够的多级缩进空间。

 

2.6.3 行长

  在Python中,很多程序员都建议每行代码不超过80字符。

 

2.6.4 空行

  在Python中,若要将程序的不同部分分开,可使用空行。

  空行虽然不会影响代码的运行,但会影响代码的可读性。Python解释器根据水平缩进情况来解读代码,但不关心垂直距离。

 

2.6.5 其他格式设置指南

  PEP 8 还有很多其他的格式设置指南,但这些指南针对的程序大多比目前的提到的复杂。如:文档编排、文档描述、空格的使用、注释、命名规范、编码建议等等。

       

posted @ 2017-12-11 00:03  晴天云  阅读(393)  评论(0编辑  收藏  举报