4. Python3的基本类型（列表）

1.简述列表[list]，元组[tuple]，字典[dict]

1-1 python内置三种常用的数据结构：list，tuple，dict，都可用于保存多个数据项。
1-2 列表和元组比较相似，都按照顺序保存元素，每个元素都有自己的索引，可以通过索引来访问元素。二者区别在于元组是不可修改的，但列表是可以修改的。
1-3 字典则以key-value的形式保存数据。

2. 了解一下序列

2-1 序列就是指一种包含多项数据的数据结构，序列包含的多个数据项（也叫成员）按顺序排列，可通过索引来访问成员。
2-2 常见的序列类型有字符串，列表和元组。
2-3 在具体的编程中，如果只是固定保存多个数据项（不需要修改），此时应该用tuple，反之亦然，使用序列。还有，在某些时候，程序需要使用不可变的对象，举例：python要求字典的key必须是不可变的，此时程序只能使用元组。
2-4 序列都可以进行的操作包括索引，切片，加，乘，检查成员。
备注：序列和元组的关系就是可变与不可变。

3. List（列表）

1-1 Python中使用最频繁的数据类型->List(列表)
1-2 列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
1-3 列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
1-4 与字符串相同，可以通过索引和截取访问，列表被截取后返回一个包含所需元素的新列表。
列表截取的语法格式如下：
变量[头下标:尾下标]
创建列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。
创建列表的语法格式：[element1, element2, element3, …]

1-5 访问列表中的值
使用下标索引来访问列表中的值和使用方括号的形式截取字符
举例：

In [1]: mylist1= ['Baidu', 'Google', 1900, 2019] #创建列表
In [2]: mylist2 = [1, 2, 3, 4, 5, 6, 7]  #创建列表
In [4]: print ('mylist1[3]:',mylist1[3]) #打印输出
mylist1[3]: 2019

In [5]: print ('mylist2[1:6:2]',mylist2[1:6:2]) 打印输出从索引1到6，步长是2的值
mylist2[1:6:2] [2, 4, 6]

1-6 修改列表
对列表的数据项进行修改或更新，和使用append()方法来添加列表项

In [8]: print ('第1个元素是:',mylist1[0])
第1个元素是: Baidu
In [9]: mylist1[0] = 'baidu.com'
In [10]: print ('修改后的第1个元素是:',mylist1[0])
修改后的第1个元素是: baidu.com

1-7 列表元素的删除
使用 del 语句来删除列表的的元素

In [11]: print ('原始mylist1的列表值：',mylist1)
原始mylist1的列表值： ['baidu.com', 'Google', 1900, 2019]
In [12]: del mylist1[1] 
In [13]: print ('删除mylist1[1]后的mylist1的值:',mylist1)
删除mylist1[1]后的mylist1的值: ['baidu.com', 1900, 2019]

1-8 列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

1-9 列表截取与拼接

In [15]: List1 = ['A', 'B', 'C', 'D']

In [16]: List1[2]
Out[16]: 'C'

In [17]: List1[-2]
Out[17]: 'C'

In [18]: List1[1:]
Out[18]: ['B', 'C', 'D']

#拼接操作
In [19]: L1 = [1, 3, 4, 8]

In [20]: L1 += [11, 33, 34, 99]

In [21]: L1
Out[21]: [1, 3, 4, 8, 11, 33, 34, 99]

1-10 嵌套列表
即在列表里创建其它列表

In [22]: al = ['AA', 'BB', 'CC']

In [23]: nl = [11, 22, 33]

In [24]: anl = [al, nl]

In [25]: anl
Out[25]: [['AA', 'BB', 'CC'], [11, 22, 33]]

In [26]: anl[0]
Out[26]: ['AA', 'BB', 'CC']

In [27]: anl[1][1]
Out[27]: 22

1-11 列表函数
len(list)：列表元素个数
max(list)：返回列表元素最大值
min(list)：返回列表元素最小值
list(seq)：将元组转换为列表

In [28]: listf = [1, 6, 4, 8, 6, 9]

In [29]: len(listf)
Out[29]: 6

In [30]: max(listf)
Out[30]: 9

In [31]: min(listf)
Out[31]: 1

In [32]: tuple1 = (3, 5, 7, 9)

In [33]: tuple1
Out[33]: (3, 5, 7, 9)

In [34]: list(tuple1)
Out[34]: [3, 5, 7, 9]

1-12 列表的方法
list.append(obj)：在列表末尾添加新的对象

In [36]: list11 = ['Hello', '-', 'world']

In [37]: list11
Out[37]: ['Hello', '-', 'world']

In [38]: list11.append('!!!!')

In [39]: list11
Out[39]: ['Hello', '-', 'world', '!!!!']

list.count(obj)：统计某个元素在列表中出现的次数

In [40]: listcount = [1, 1, 2, 2, 4, 5, 7, 8, 2]

In [41]: listcount.count(2)
Out[41]: 3

list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） #参数seq – 元素列表，可以是列表、元组、集合、字典，若为字典,则仅会将键(key)作为元素依次添加至原列表的末尾。

In [42]: a1 = ['A', 'B', 'C']

In [43]: a2 = list(range(3)) #创建一个0到2的列表

In [44]: a1.extend(a2)

In [45]: a1
Out[45]: ['A', 'B', 'C', 0, 1, 2]

list.index(obj)：从列表中找出某个值第一个匹配项的索引位置

In [47]: a1.index('B')
Out[47]: 1

list.insert(index, obj)：将对象插入列表

In [48]: a1
Out[48]: ['A', 'B', 'C', 0, 1, 2]

In [49]: a1.insert(0, 'a')

In [50]: a1
Out[50]: ['a', 'A', 'B', 'C', 0, 1, 2]

list.pop([index=-2])：移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

In [52]: a1.pop(-2) #移除倒数第二个值
Out[52]: 1

In [53]: a1
Out[53]: ['a', 'A', 'B', 'C', 0, 2]

list.remove(obj)：移除列表中某个值的第一个匹配项

In [57]: list_remove = [1, 1, 2, 3, 5, 6, 5]

In [58]: list_remove.remove(5)

In [59]: list_remove
Out[59]: [1, 1, 2, 3, 6, 5]

list.reverse()：反向列表中元素

In [60]: list_reverse = [10, 11, 12, 14]

In [61]: list_reverse.reverse()

In [62]: list_reverse
Out[62]: [14, 12, 11, 10]

list.sort( key=None, reverse=False)：对原列表进行排序
备注：key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。

In [63]: list_sort = ['ABC', 'AAV', 'EEA', 'RTA']
In [64]: list_sort.sort()

In [65]: list_sort
Out[65]: ['AAV', 'ABC', 'EEA', 'RTA']

In [66]: list_sort.sort(reverse=True)

In [67]: list_sort
Out[67]: ['RTA', 'EEA', 'ABC', 'AAV']

list.clear()：清空列表

In [69]: list_sort
Out[69]: []

list.copy()：复制列表

In [70]: listc = [1, 5, 7]
In [72]: listc1 = listc.copy()

In [73]: listc1
Out[73]: [1, 5, 7]

1-12 补充：列表也可以使用slice（切片，分片）
语法: [start: end: step]
说明：start，end是索引值，可以为正或为负，其中为负数就是从倒数开始，step表示步长。