Python的列表

列表简介

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中增加该学生的姓名，并且将其增加到已有学生的后面，打印新列表，同时打印一条欢迎语句。

　　代码：

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

　　说明：

　　第1行，已有列表。

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

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

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

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

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

　　运行结果：

 The new student:dian lei
 ['Yun Qtian', 'Feng Kuang', 'Yu Bao', 'Dian Lei']
  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行代码有变化之外，其余代码未变，因此，其余行不再重复解释。

　　运行结果：

　　

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

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

3.2  从列表中删除元素

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

　　（1）使用 del 语句删除元素

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

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

　　代码：

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

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

　　运行结果：

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

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

　　

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

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

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

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

 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
 print("删除前的列表：",student_names)
 popped_student_name = student_names.pop()
 print("删除后的列表：",student_names)
 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中的二个元素。

　　代码：

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

　　说明：

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

　　

　　运行结果：

 删除前的列表： ['Yun Qtian', 'Feng Kuang', 'Yu Bao']
 删除后的列表： ['Yun Qtian', 'Yu Bao']
 删除的元素： Feng Kuang

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

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

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

　　（4）根据值删除元素

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

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

　　代码：

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

　　说明：

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

　　

　　运行结果：

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

　　

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

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

　　代码：

 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
 student_name_remove = "Yu Bao"
 student_names.insert(0,student_name_remove)
 print("删除前的列表：",student_names)
 student_names.remove(student_name_romove)
 print("删除后的列表：",student_names)
 print(student_names[0])
 print(student_name_remove)

　　说明：

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

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

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

　　运行结果：

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

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

　　代码：

 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
 student_name_remove = "Yu Bao"
 student_names.insert(0,student_name_remove)
 print("删除前的列表：",student_names)
 for _student_name in student_names:
    if _student_name == student_name_remove :
      student_names.remove(student_name_remove)
 print("删除后的列表：",student_names)
 print(student_names[0])
 print(student_name_remove)

　　说明：

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

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

　　

　　运行结果：

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

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

3.3 列表元素的修改

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

　　列表[index] = 新值

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

　　代码：

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

　　说明：

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

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

　　运行结果：

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

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

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

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

　　

运行结果跟之前的一致：

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

4.  组织列表

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

4.1 列表的永久排序

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

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

　　代码：

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

　　说明：

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

　　运行结果：

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

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

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

　　代码：

 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
 print("p排序前的列表：",student_names)
 student_names.sort()
 print("第一次排序后的列表：",student_names)
 student_names.sort(reverse=True)
 print("第二次排序后的列表：",student_names)

　　说明：

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

　　运行结果：

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

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

4.2 列表的临时排序

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

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

　　代码：

 student_names = ["Yun Qtian","Feng Kuang","Yu Bao"]
 print("排序前的列表：",student_names)
 student_names_sorted = sorted(student_names)
 print("排序后的新列表：",student_names_sorted)
 print("排序后的原列表：",student_names)

　　说明：

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

　　运行结果：

 排序前的列表： ['Yun Qtian', 'Feng Kuang', 'Yu Bao']
 排序后的新列表： ['Feng Kuang', 'Yu Bao', 'Yun Qtian']
 排序后的原列表： ['Yun Qtian', 'Feng Kuang', 'Yu Bao']

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

　

4.3 倒序打印列表

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

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

　　代码：

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

　　说明：

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

　　

　　运行结果：

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

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

4.4  获取列表长度

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

　　len(列表)

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

　　代码：

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

　　说明：

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

　　运行结果：

 列表student_names的长度为： 3

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

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

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

　　代码：

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

　　运行结果：

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

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

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

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

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

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

　　代码：

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

　　运行结果：

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

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

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

　　代码：

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

　　运行结果：

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

 2. 操作列表

2.1 遍历整个列表

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

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

　　代码：

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

　　说明：

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

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

　　运行结果：

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

2.2 避免缩进错误

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

2.2.1 忘记缩进循环体

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

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

　　代码：

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

　　运行结果：

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

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

2.2.2 忘记缩进额外的代码行

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

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

　　代码：

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

　　运行结果：

 ['Yun Qtian', 'Feng Kuang', 'Yu Bao']
 Yun Qtian
 Feng Kuang
 Yu Bao
 Welcome to Yu Bao!

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

　　正确的代码：

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

　　满足需要的运行结果：

 ['Yun Qtian', 'Feng Kuang', 'Yu Bao']
 Yun Qtian
 Welcome to Yun Qtian!
 Feng Kuang
 Welcome to Feng Kuang!
 Yu Bao
 Welcome to Yu Bao!

2.2.3  不需要的缩进

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

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

　　代码：

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

　　运行结果：

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

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

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

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

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

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

　　代码：

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

　　运行结果：

 Yun Qtian
 Welcome to new students!
 Feng Kuang
 Welcome to new students!
 Yu Bao
 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!" )

　　正确的运行结果：

 Yun Qtian
 Feng Kuang
 Yu Bao
 Welcome to new students!

2.2.5 遗漏了冒号

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

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

　　代码：

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

　　运行结果：

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

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

2.3 创建数值列表

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

2.3.1 函数range()的使用

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

　　（1）只指定一个数值

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

　　代码：

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

　　运行结果：

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

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

　　

　　（2）指定起始位置

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

　　代码：

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

　　运行结果：

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

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

　　（3）指定起始位置即步长

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

　　代码：

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

　　说明：

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

　　运行结果：

 1
 3
 5
 7
 9

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

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

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

　　运行结果：

 2
 4
 6
 8
 10

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

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

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

　　代码：

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

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

　　运行结果：

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

　　在Python中，两个星号（**）表示乘方运输。

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

　　代码：

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

　　说明：

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

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

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

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

　　运行结果：

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

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

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

　　在Python中，有几个专门处理数字列表的函数，最大值（max）；最小（min）;总和。

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

　　代码：

 list = []
 for i in range(10):
     list.append(i)
 print("列表list为：",list)
 print("列表list的最大值为：",max(list))
 print("列表list的最小值为：",min(list))
 print("列表list的总和为：",sum(list))

　　运行结果：

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

2.3.4 列表解析

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

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

　　代码：

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

　　运行结果：

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

2.4 使用列表的一部分

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

2.4.1 切片

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

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

　　代码：

 squares = [i**2 for i in range(1,11)]
 print(squares)
 print("----指定第一个索引和第二个索引-------")
 print(squares[0:6])
 print(squares[-3:9])
 print(squares[-3:-1])
 print("----不指定第一个索引-------")
 print(squares[:6])
 print(squares[:-3])
 print("----不指定第二个索引-------")
 print(squares[5:])
 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, 4, 9, 16, 25, 36, 49, 64, 81, 100]
 ----指定第一个索引和第二个索引-------
 [1, 4, 9, 16, 25, 36]
 [64, 81]
 [64, 81]
 ----不指定第一个索引-------
 [1, 4, 9, 16, 25, 36]
 [1, 4, 9, 16, 25, 36, 49]
 ----不指定第二个索引-------
 [36, 49, 64, 81, 100]
 [64, 81, 100]

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

2.4.2 遍历切片

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

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

　　代码：

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

　　说明：

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

　　运行结果：

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

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

2.4.3 复制列表

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

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

　　代码：

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

　　说明：

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

　　运行结果：

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

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

　　代码：

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

　　说明：

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

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

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

　　

　　运行结果：

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

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

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

　　代码：

 import copy

 squares = [i** for i in range(,)]
 print("原列表：",squares)
 new_squares = squares[:]
 new_squares2 = copy.copy(squares)
 new_squares3 = list(squares)
 print("新列表1：",new_squares)
 print("新列表2：",new_squares2)
 print("新列表3：",new_squares3)

　　说明：

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

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

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

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

　　

　　运行结果：

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

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

2.4.4 列表嵌套使用

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

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

　　代码：

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

　　说明：

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

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

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

　　

　　运行结果：

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

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

2.5 元组

2.5.1 元祖的定义

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

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

　　代码：

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

　　说明：

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

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

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

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

　　

　　运行结果：

 元组的第一个元素是： 100001
 元组的第二个元素是： 100002
 元组的所有的元素是： (100001, 100002, 100003, 100004, 100005)

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

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

　　代码：

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

　　说明：

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

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

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

　　运行结果：

 元组： (100001, 100002, 100003, 100004, 100005)
 元组的第一个元素是： 100001
 元组的第二个元素是： 100002
 元组的所有的元素是： (100001, 100002, 100003, 100004, 100005)
 元组的前三个元素是： (100001, 100002, 100003)
 元组的后三元素是： (100003, 100004, 100005)
 元组的第二个元素到第三个元素是： (100002, 100003)

2.5.2 遍历元组

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

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

　　代码：

 emp_nos = (100001,100002,100003,100004,100005)
 print("元组：",emp_nos)
 print("工号如下：")
 for emp_no in emp_nos:
     print(emp_no)

　　运行结果：

 元组： (100001, 100002, 100003, 100004, 100005)
 工号如下：
 100001
 100002
 100003
 100004
 100005

2.5.3 修改元组变量

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

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

　　代码：

 emp_nos = (100001,100002,100003,100004,100005)
 print("修改元组变量前的：",emp_nos)
 print("工号如下：")
 for emp_no in emp_nos:
     print(emp_no)

 emp_nos = (600001,600002,600003,600004,600005)
 print("修改元组变量后的：",emp_nos)
 print("工号如下：")
 for emp_no in emp_nos:
     print(emp_no)

　　运行结果：

 修改元组变量前的： (100001, 100002, 100003, 100004, 100005)
 工号如下：
 100001
 100002
 100003
 100004
 100005
 修改元组变量后的： (600001, 600002, 600003, 600004, 600005)
 工号如下：
 600001
 600002
 600003
 600004
 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 还有很多其他的格式设置指南，但这些指南针对的程序大多比目前的提到的复杂。如：文档编排、文档描述、空格的使用、注释、命名规范、编码建议等等。