Python教程正在更新中：
查看Python教程目录
之前的学习中介绍了Python的int和string等数据类型，接下来我们讲介绍Python中具有非常强大功能的数据类型——list(翻译为列表)
在之前的学习中我们学习了变量，在Python中变量不需要提前声明，但是在某些语言中需要提前声明变量才能使用(比如：Java，C++)，Python使用时用的时候命名即可。
列表的定义
再Python中用 [ ] 来定义一个列表，在方括号里的数据可以是字符串，数字等所有类型的数据。
我们先来尝试定义一个空的列表
name = []
这样我们就成功定义了一个空的列表，列表就类似于数组，里面有很多格子，每个格子都可以装内容，并且这样的数组里面可以装的数据是没有类型限制的，每个格子里装的内容都是随用户需求的，所以这样的列表功能是非常强大的。
之后我们再来尝试检测name变量的类型和是否为空，分别可以用函数type()和函数bool()来解决，这一点上和之前的内容很相似，下面我们来尝试操作。
name = []
print(type(name))
print(bool(name))
print(name)
输出内容是：
<class 'list'>
False
[]
第一行检测name的类型，输出结果告诉我们这是一个list类型对象，第二行检测这个对象是否非空，输出False，表示这个对象里面是空的，并没有元素，如果这个对象不为空那么这里的输出结果为True，第三行输出这个对象，由于这个对象里面是空的，所以输出内容为[ ]。
知道了这么多，我们应该开始定义一个非空的list类型的对象，演示如下：
name = ['Python', 3.7, True, 'Lpy_Now']
print(type(name))
print(bool(name))
print(name)
用这样的形式我们定义了一个list类型的对象，这个对象内部的元素有，string类型的Python和Lpy_Now，以及bool类型的True，和float类型的3.7。执行这个程序，可以得到结果为：
<class 'list'>
True
['Python', 3.7, True, 'Lpy_Now']
第一行表明这个对象的类型为list型的，第二行表示这个对象并不为空，第三行输出了这个对象中的所有元素。
因此Python中的list类型理论上是无线大的，用户理论可以在这个对象中添加无数个元素，当然在计算机硬件条件允许的条件下。
list元素的索引(index)
在讲解string的时候讲过string的索引，就是将string字符串中的每一个字符都分开，并且从头开始每一个数字位置对应一个字符，这就是string类型字符串的索引(index)。同理，我们当前正在学习的list类型也有这样的索引，只不过不同的是string类型的索引是以字符为单位分割，而list类型的索引则是以其中的元素为单位进行索引。以Python for Beginners为例，我们来探索list类型的索引：
name = ['Python', 'for', 'Beginners']
对于这样一个list类型的对象，我们用表格来对应元素和位置之间的索引：
| Python | for | Beginners |
|---|---|---|
| 0 | 1 | 2 |
这样我们可以清晰的看到list中元素和位置之间的对应关系，与string类型类似，访问其中对应元素的方法也大同小异，演示如下：
name = ['Python', 'for', 'Beginners']
print(name[0])
print(name[1])
print(name[2])
这样就完成了对name的访问，输出内容如下：
Python
for
Beginners
同样也能完成对范围的访问，具体演示如下：
name = ['Python', 'for', 'Beginners']
print(name[0:2])
print(name[1:])
print(name[:2])
print(name[:])
print(name[-3:-1])
通过以上的代码就完成了对这个对象的一个范围元素的访问，具体输出结果如下：
['Python', 'for']
['for', 'Beginners']
['Python', 'for']
['Python', 'for', 'Beginners']
['Python', 'for']
这样的访问同样是左闭右开的
第一行访问的是0，1两个元素
第二行访问的是1，2两个元素
第三行访问的是0，1两个元素
第四行访问的是0，1，2三个元素
这里同样支持负数，但是不同的是这里如果取负数，那么左边的数字必须小于右边的数字，否则返回空，这里访问的是0，1两个元素
同样我们也可以用index函数输出每个元素对应的位置，具体操作如下：
name = ['Python', 'for', 'Beginners']
print(name.index('Python'))
print(name.index('for'))
print(name.index('Beginners'))
index()函数返回了元素的位置，所以可以查询到元素所在的位置，同样如果这个元素在这个对象中并不存在，那么程序就会报错。
list类型对象的反转
有时我们需要对所求得的对象中的内容进行反转，比如说我们求得的中间量为[1, 2, 3, 4]，但是结果需要的是[4, 3, 2, 1]那么此时我们就需要对一串元素进行反转，操作如下：
number = [1, 2, 3, 4]
print(number)
number = number[::-1]
print(number)
输出结果为：
[1, 2, 3, 4]
[4, 3, 2, 1]
使用::-1就可以对这个对象进行反转。同理，这个也可以运用于string类型的字符串。
同时reserved()函数也可以实现这个功能，操作示范如下：
number = [1, 2, 3, 4]
print(number)
number = list(reversed(number))
print(number)
经过这样的操作，同样将这个对象内的元素进行了反转
list中的函数和基本操作
1.len()
在string中我们可以用len(object)来获得字符串的长度，同样我们也可以在这里用len函数来获得对象的长度(即对象中元素的个数)，示范如下：
name = ['Python', 'for', 'Beginners']
print(len(name))
输出结果为3，输出的是对象name中的元素数量为3。
2.’+'运算符
和string类型很相似，list类型的对象也满足 + 运算符，也就是将两个list类型的对象按顺序拼接起来，具体操作演示如下：
name = ['Python', 'for', 'Beginners']
Python = ['Python', 3.7]
print(name + Python)
这样输出结果为：[‘Python’, ‘for’, ‘Beginners’, ‘Python’, 3.7]
也就是将两个对象拼接起来。
3.’ * '运算符
在string类型中满足 ’ * '运算符，是将字符串重复多遍，同样，list也满足这个功能，就是将对象中的元素重复多遍，具体演示如下：
name = ['Python', 'for', 'Beginners']
print(name * 3)
name = name * 3
print(name)
这段程序输出结果为：两个[‘Python’, ‘for’, ‘Beginners’, ‘Python’, ‘for’, ‘Beginners’, ‘Python’, ‘for’, ‘Beginners’]
就是将这三个元素重复三遍后得到的结果。
4.in函数
in函数可以判断给定的元素是否在对象中，如果在返回True，否则返回False，具体操作演示如下：
name = ['Python', 'for', 'Beginners']
print('Python' in name)
print('Jonson' in name)
一个返回True，一个返回False
5.max()和min()函数
list类型的对象中元素之间也可以比较大小，通过ASCII逐位比较可以得到一个对象中最大的元素或者最小的元素，使用方法如下：
name = ['Python', 'for', 'Beginners']
print(max(name))
print(min(name))
输出结果分别为：for和Beginners，也就是说name对象中经过ASCII比较后最大的元素为for,最小的元素为Beginners
6.cmp()
cmp(object_1, object_2)函数是将object_1和object_2的各个元素逐位进行比较，如果object_1小则返回负数，如果相等返回0，如果object_2小返回正数，示范如下：
name_1 = ['Python', 'for', 'Beginners']
name_2 = ['Python', 3.7]
print cmp(name_1, name_2)
由于Python3.X中已经没有cmp函数所以这个函数的用法不再赘述
7.append()和extend()
list类型的对象并不是我们在定义之后就一直不变的常量，而是可以根据使用增加元素的，这时候就需要用到Python函数中的append(object)函数，这个函数可以在原来的对象的最后添加任意类型的元素，使用方法如下：
name = ['Python', 'for', 'Beginners']
name.append('Lpy_Now')
name.append(0)
print(name)
这样就在name对象后增加了string类型的 ‘Lpy_Now’ 和int类型的 0
最后的输出结果是：[‘Python’, ‘for’, ‘Beginners’, ‘Lpy_Now’, 0]
在官方文档中描述list.append(object)方法如下：
list.append(object)
Add an item to the end of the list; equivalent to list[len(list):] = [object]
大概意思就是说可以在最后追加元素，同样最后也给我们提供了追加元素的新方法，list.append(object) = list[len(list):] = object具体使用方法如下：
name = ['Python', 'for', 'Beginners']
name[len(name):] = ['Lpy_Now']
name[len(name):] = 'Lpy_Now'
print(name)
输出结果为：[‘Python’, ‘for’, ‘Beginners’, ‘Lpy_Now’, ‘L’, ‘p’, ‘y’, ‘_’, ‘N’, ‘o’, ‘w’]
输出后结果发现如果将插入的元素加上方括号，就是将这个元素整体插入到原来的对象之后，如果插入的元素不加方括号，就是将这个元素拆分成单个字符插入到原来的对象之后，如果一个数字不加方括号，则程序会报错，也就是说如果要在原来对象的末尾加上数字的话只能在数字外面加上方括号这样的形式，除此之外，两种方法的作用是相同的。
在Python中可以在一个list后插入一个元素，同样也可以在list后插入一个对象，这样就用到了Python中的extend()函数，在官方文档中描述list.extend()函数如下：
list.extend(X)
Extend the list by appending all the items in the given list; equlvalent to list[len(list):] = X
操作过程如下：
name_1 = ['Python', 'for', 'Beginners']
name_2 = ['Python', 3.7, 'Lpy_Now']
name_1.extend(name_2)
print(name_1)
输出结果为：[‘Python’, ‘for’, ‘Beginners’, ‘Python’, 3.7, ‘Lpy_Now’]
也就是将对象name_2添加到对象name_1后就是将name_2中的所有元素全部添加到name_1后
在尝试另一种方法：
name_1 = ['Python', 'for', 'Beginners']
name_2 = 'Lpy_Now'
name_3 = 3.7
name_1.extend(name_2)
print(name_1)
name_1.extend(name_3)
print(name_1)
如果说在name_1后添加非list类型的对象，这个对象是string类型的，那么在添加的过程中会将这个字符串打散分成单个字符添加到原来对象的末尾，而添加数字的时候就会报错，这里和append函数事类似的，这里的输出结果为：
['Python', 'for', 'Beginners', 'L', 'p', 'y', '_', 'N', 'o', 'w']
Traceback (most recent call last):
File "D:/PythonProject/Hello World.py", line 18, in <module>
name_1.extend(name_3)
TypeError: 'float' object is not iterable
原因是，extend函数也可以将另外的元素增加到已知的列表中，但是元素必须是iterable(可迭代的)
迭代在维基百科中的解释如下：
迭代是重复反馈过程的活动，其目的通常是为了接近并到达所需的目标或结果。每一次对过程的重复被称为一次“迭代”，而每一次迭代得到的结果会被用来作为下一次迭代的初始值。
在数学中
一个五边形的迭代。将对角用直线段连起来得到一个五角星，后者中心围成了一个倒过来的小五边形。迭代地执行这一过程会产生一系列嵌套的五边形和五角星。
数学中的迭代可以指函数迭代的过程，即反复地运用同一函数计算，前一次迭代得到的结果被用于作为下一次迭代的输入。即使是看上去很简单的函数，在经过迭代之后也可能产生复杂的行为，派生出具有难度的问题。这样的例子可以参见考拉兹猜想和杂耍者序列（Juggler sequence）。又如一个简单的二次变换x→x(1-x)，它的迭代将形成一个具有混沌性质的动力系统。迭代在数学中的另一应用是迭代法，用来对特定数学问题作数值解估计。牛顿法就是迭代法的一个例子。
在计算机中
参见：迭代式开发
在计算机科学中，迭代是程序中对一组指令（或一定步骤）的重复。它既可以被用作通用的术语（与“重复”同义），也可以用来描述一种特定形式的具有可变状态的重复。在第一种意义下，递归是迭代的一个例子，但是通常使用一种递归式的表达。比如用0!=1，n!=n*(n-1)!来表示阶乘。而迭代通常不是这样写的。
而在第二种（更严格的）意义下，迭代描述了在指令式编程语言中使用的编程风格。与之形成对比的是递归，它更偏向于声明式的风格。
我们可以用Python自带的函数hasattr()来判断是否是可迭代的，使用方法如下：
name_1 = ['Python', 'for', 'Beginners']
name_2 = 'Lpy_Now'
name_3 = 3.7
print(hasattr(name_1, '__iter__'))
print(hasattr(name_2, '__iter__'))
print(hasattr(name_3, '__iter__'))
上面的操作给出了hasattr函数的使用方法，可以得知满足可迭代的的对象是可以被添加到一个list对象之后的，但是不可迭代的对象是不能添加到一个list类型的对象之后的，这三个返回的分别是True，True，False。
在之前的内容中讲过函数id()可以返回这个对象的在内存中的位置，那么不妨看一下在添加元素前后的对象在内存中的位置是否发生变化：
name_1 = ['Python', 'for', 'Beginners']
name_2 = ['Python', 3.7, 'Lpy_Now']
print(id(name_1))
name_1.extend(name_2)
print(id(name_1))
执行程序后，输出结果为：
2482069328456
2482069328456
也就是说对象在执行操作后，在内存中的位置是不变的，也就是说修改是在原地修改，同样，append的修改也是在原地进行修改。
8.count()
在之前的学习中我们介绍了len()函数，这个函数可以给出这个list类型的对象，也就是给出这个对象中元素的数量，有时候，我们对这个对象的操作并不限于仅仅求得对象中元素的多少，有时候我们还需要知道对象中某个元素出现的次数，这时候Python中同时内置了count()函数来求得某个元素在这个对象中出现的次数，具体使用如下：
name = ['Python', 'for', 'Beginners', 'Python', 3.7, 'Lpy_Now']
print(name.count('Python'))
print(name.count('Lpy_Now'))
print(name.count(1))
输出结果为：2，1，0也就是将对象中某个元素重复出现的次数统计出来，并返回给用户。
9.insert()
之前我们学习了在list类型的对象末尾插入一个新的元素，同样，我们可以用函数insert在对象之间插入一个元素，object_1.insert(index, object_2)是将object_2插入到index对应的元素之前的位置，也就是将新的元素添加到index所对应的位置，具体操作如下：
name_1 = ['Python', 'for', 'Beginners']
name_1.insert(1, 'Lpy_Now')
print(name_1)
输出结果为：[‘Python’, ‘Lpy_Now’, ‘for’, ‘Beginners’]，也就是将元素：Lpy_Now插入到了index=1的位置，这个函数实现了list的任意部分的插入
10.pop()和remove()
在前面的内容中讲过在list的对象中的任意位置插入元素，同样在应用中，我们也需要对对象中的某些元素进行删除，这两个函数都需要传入参数，但是传入的参数的类型是不同的，pop(index)，remove(object)也就是说pop函数传入的是元素在对象中的位置，删除的就是对应位置的元素，但是remove函数删除的对象中对应的元素，也就是传入的参数是对应的元素名称，具体操作示范如下：
name = ['Python', 'for', 'Beginners']
print(name.pop(1))
print(name)
输出结果为
for
['Python', 'Beginners']
也就是这个函数在删除index对应的元素的同时也会返回这个被删除的元素。但是如果这个index在原来的对象中不存在，这个程序就会报错，比如这里的传入的参数是7，在原来的对象中并不存在这个位置，所以程序就会报错；
name = ['Python', 'for', 'Beginners']
print(name.remove('for'))
print(name)
这里的输出结果为
None
['Python', 'Beginners']
也就是说remove这个函数在删除对应元素的同时并不会有返回值，只是删去了这个对应的元素，并且如果这个对象中有多个相同的元素，remove函数只会删除第一个元素，同样如果这个元素在对象中不存在那个元素，那么这个程序将报错。如果需要先判断这个元素是否在对象中，我们需要其他手段，在之后的内容中将会介绍到。
11.sort()
如果我们需要对对象中的元素进行排序，如果采用最原始的元素间逐个交换的方法，并不优秀，同样Python中为我们自带了可以供list类型的对象排序的sort()函数，我们看一下Python文档中对sort的解释，提炼出一小段话如下：
sort(…)
L.sort(cmp = None, key = None, reverse = False) – stable sort IN PLACE; cmp(x, y) -> -1, 0, 1
由于原文较长此处就不再摘录了，可以通过链接查看原文档.
可以发现sort函数是有参数的，但是这个参数是有默认参数，默认情况为函数从小到大进行排序，操作如下：
number = [1, 2, 3, 4, 5]
number.sort()
print(number)
输出结果为：[1, 2, 3, 4, 5]
同样sort()函数也可以对字符串进行排序，默认情况下是逐渐比较元素中ASCII的大小来确定大小位置，从小到大进行排序，操作如下：
name = ['Python', 'for', 'Beginners', 'Lpy_Now']
name.sort()
print(name)
输出结果为：[‘Beginners’, ‘Lpy_Now’, ‘Python’, ‘for’]
但是如果其中含有数字和字符串，这样的程序就会报错。
如果我们需要将数字或者字符从大到小排序，那么sort函数中的参数reverse就起到了作用，函数中默认reverse = False也就是默认排序结果不进行反转，我们只需要将函数的reverse参数改为True就可以了，示范如下：
number = [1, 2, 3, 4, 5]
number.sort(reverse = True)
print(number)
name = ['Python', 'for', 'Beginners', 'Lpy_Now']
name.sort(reverse = True)
print(name)
输出结果为：
[5, 4, 3, 2, 1]
['for', 'Python', 'Lpy_Now', 'Beginners']
将参数改变后，排序的结果就从大到小了。
在前面的介绍中，sort函数还有默认的参数key = None，我们同样可以更改参数，比如将对象中的元素按照长度进行排序，操作如下：
name = ['Python', 'for', 'Beginners', 'Lpy_Now']
name.sort(key = len)
print(name)
name.sort(key = len, reverse = True)
print(name)
输出结果为：
['for', 'Python', 'Lpy_Now', 'Beginners']
['Beginners', 'Lpy_Now', 'Python', 'for']
这里将对象按照长度从小到大进行了排序，同时两个参数同时改变也对对象进行了排序，这里的关键字key有很多，在这里不全部介绍，在之后的运用中会逐个介绍。
sort函数中的另一个关键字cmp，就是自定义排序规则，让sort函数的功能更强大，比如可以将关键字设置为student_tuples，student_objects等等，这都是Python中自带的模块可以自由使用，在这里不再赘述，之后的应用中会逐渐讲解，这些模块也让sort函数的功能变得很强大，更加实用。
查看上一篇：Python-----Strings字符串
查看下一篇：
查看目录：查看Python教程目录