基本数据类型：列表

1. 列表的介绍

列表也是python的基础的数据类型之一，类似于Java中的数组一样，可以存放很多元素。列表是用括号括起来的一组数据，每个元素之间用‘,’来分割，其中元素可以是python支持的各种数据类型，创建列表的方法如下：

In [32]: l1 = [13, 56, 'python', True]      # 列表里面可以存放各种不同的数据类型（如数字、字符串等等）
In [33]: l2 = [-1, ['abc', 11.2]]           # 列表中还可以嵌套列表
In [34]: l3 = list()                        # 创建一个空列表

2. 列表的索引和切片

列表也可以和字符串一样使用索引和切片，具体使用的方法如下：

In [35]: l1[-1]                     # 列表的使用索引获取元素
Out[35]: True
In [36]: l1[1:]                     # 跟字符串一样，列表也可以使用切片
Out[36]: [56, 'python', True]
In [38]: l1[2][2:]
Out[38]: 'thon'

3. 列表的操作

• 增加元素：增加列表元素的方法有3种

  • append： 把元素添加到列表末尾
  • insert：接收一个索引位置的参数，把元素插入到指定索引位置的前面，后面的元素往索引都加1
  • extend： 往列表里面添加多个元素，其参数必须是一个可迭代对象

In [39]: l3.append('a')
In [40]: l3.append(15)              # 把元素15添加到列表l3末尾
In [41]: l3
Out[41]: ['a', 15]
In [42]: l3.insert(1, '篮球')       # 在l3列表索引为1的位置插入元素'篮球'
In [43]: l3
Out[43]: ['a', '篮球', 15]
In [44]: l3.extend(l2)              # 把列表l2中的元素添加到l3中
In [45]: l3
Out[45]: ['a', '篮球', 15, -1, ['abc', 11.2]]

• 删除元素：删除元素也有3中方法操作

  • pop： 默认删除列表中最后一个元素，并返回删除的元素，如果指定索引则删除索引位置的元素
  • remove： 移除指定的元素
  • clear： 清空列表

In [46]: l4 = [111, 1, 23, 45, 1, -3434, 43624356, 234, 45]
In [47]: l4.pop()                       # 默认删除列表中最后一个元素
Out[47]: 45
In [48]: l4.pop(1)                      # 也可以删除指定索引位置的元素
Out[48]: 1
In [49]: l4.remove(1)                   # 删除指定的元素
In [50]: l4
Out[50]: [111, 23, 45, -3434, 43624356, 234]
In [51]: l4.clear()                     # 清空列表
In [52]: l4
Out[52]: []

• 修改元素

In [54]: l3
Out[54]: ['a', '篮球', 15, -1, ['abc', 11.2]]
In [55]: l3[2] = '学校'                             # 找到元素并对重新赋值（修改）
In [56]: l3
Out[56]: ['a', '篮球', '学校', -1, ['abc', 11.2]]
In [57]: l3[2:] = ['老师', '学生', '校园']          # 也可以切片修改
In [59]: l3
Out[59]: ['a', '篮球', '老师', '学生', '校园']

• 查找元素：

  • index： 使用index查找元素的索引位置
  • 使用for循环遍历列表查找

In [62]:  l3                                   
Out[62]: ['a', '篮球', '老师', '学生', '校园']         
                                               
In [63]:  l3.index('篮球')
Out[63]: 1                     
                                     
In [64]: for i in range(len(l3)):
    ...:     if l3[i] == '篮球':                 
    ...:         print(i, l3[i])               
1 篮球                

• 其他方法：列表还有其他的集中方法

  • count： 统计某个元素出现列表的个数
  • sort： 对列表做排序
  • reverse： 对列表反转排序

In [65]: l4 = [45, 43624356, -3434, 1, 45, 23, 1, 111, 45, 56, 90]
In [66]: l4.count(45)                   # 计算45在列表l4中出现的次数
Out[66]: 3
In [67]: l4.sort()                      # 把列表按从小到大的顺序排列
In [68]: l4
Out[68]: [-3434, 1, 1, 23, 45, 45, 45, 56, 90, 111, 43624356]
In [69]: l4.reverse()                   # 把列表按原来的顺序倒叙排列（**没有排序的功能**）
In [70]: l4
Out[70]: [43624356, 111, 90, 56, 45, 45, 45, 23, 1, 1, -3434]

基本数据类型：元组

元组跟列表非常类似，它也可以存储多个元素，也可以存放不同的数据类型的元素，但是元组最大的特征就是：元组中的元素是不可修改的，因此元组只有查询的方法，下面是元组的使用：

In [71]: t1 = ('redhat', 'centos', 'fedora', 'ubuntu')          # 创建一个元组，如果是空元祖要使用`t = (,)`来创建
In [72]: t1
Out[72]: ('redhat', 'centos', 'fedora', 'ubuntu')
In [73]: t1[1]                                                  # 跟列表和字符串一样，也支持索引和切片
Out[73]: 'centos'
In [74]: for ele in t1:                                         # 循环遍历元组中的元素
    ...:     print(ele)
redhat
centos
fedora
ubuntu
In [75]:

补充知识

1. range的使用

如果只是使用for循环遍历元素虽然可以取到每个元素的值，但是却没有元素的索引，如果结合range使用就会方便的多：

In [83]: t1
Out[83]: ('redhat', 'centos', 'fedora', 'ubuntu')
In [84]: for index in range(len(t1)):           # 通过range来创建列表和元组的索引，可以同时获取索引和元素
    ...:     print(index, t1[index])
0 redhat
1 centos
2 fedora
3 ubuntu
In [86]: for i in range(2, 10, 2):              # range也可以设置起始和结束位置，和step步长的设置，能满足各种需求
    ...:     print(i)               
2                                   
4                                   
6                                   
8                                   
                                    
In [87]:                            

2. 列表推导式

列表推导式为从序列中创建列表提供了一个简单的方法。如果没有列表推导式，一般都是这样创建列表的：通过将一些操作应用于序列的每个成员并通过返回的元素创建或添加到列表，或者通过满足特定条件的元素创建子序列，如下，我们创建一个的序列：

In [77]: l5 = []
In [78]: for ele in range(10):
    ...:     l5.append(ele ** 2)            # 通过循环，把得到的结果追加到列表末
In [79]: l5
Out[79]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

但是如果使用列表推导式创建，就会简单的多：

In [81]: l6 = [x **2 for x in range(10) ]
In [82]: l6
Out[82]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]