Python中的列表与元组的相关内容

列表

列表用来存储一系列的数据。其中，列表可以存放任意的字符串类型，每个列表里的元素也可以不一样。
本图为列表在内存中的存储示意图，从图中可以看出来，列表中的每个元素都随机分布在内存中，在整合到一起，最后返回整合在一起后的内存块地址。

列表的创建

先看一下列表的存储方法：

1、用[]方法进行创建

a = [1,2,3,'123']
print(a)	#结果为：[1, 2, 3, '123']

2、用list()方法进行创建
list()，括号里面是可迭代对象或者括号里面内容为空
（1）什么是可迭代对象
Python中的可迭代对象可以理解为：能放到for循环里面的内容，比如：range()函数、元组、列表、字符串。如果要判断一个对象是否是可迭代对象，我们可以用collections库里面的isinstance（元素类型，Iterable ）方法，返回值为True或者False，比如：

from collections import Iterable
print( isinstance( [] , Iterable )  )  #True
print( isinstance( {} , Iterable )  )　#True
print( isinstance( () , Iterable )  )　　#True
print( isinstance( 1 , Iterable )  )　　#False

（2）用list（）创建列表的几种方法

a = list()    #此时a为一个空列表
b = list('abc')    #a内容为：['a','b','c'] 自动分割成单字符
c = list([1,2,3])    #c的内容为：[1,2,3]

（3）用range函数创建整数序列
range(start: end: step) start、step可以不写，默认start=0，step=1，但是end必须有。range所产生的整数范围是 [ 开始数；结束数) 注意不是从start到end

a = list(range(5))   #结果为 [0,1，2,3，4]
b = list(range(-5, -10 , 1))    #结果为[]
c = list(range(-5, -10, -1))    #结果为[-5,-6,-7,-8,-9]
d = list(range(10,5,-1))    #结果为[10,9,8,,7,6]

（4）推导式生成list序列

a = list(x-2 for x in range(5))   
 #结果为[0,2,4,6,8]

列表的增加和删除操作

在学习列表的增加和删除时，列表的该操作类似于顺序表的增加和删除。每次无论删除还是增加操作，都要对元素进行平移。
1、列表的增加
（1）用append()方法。
append()只能在列表尾部添加一个元素，该元素可以是任何数据类型。

a = list(range(2))    #结果为[0,1]
a = a.append([9,8])    #结果为[0,1,[9,8]] 
a = a.append('fadsf')   #结果为[0,1,[9,8],'fadsf']

（2）利用insert（）方法
insert()方法可以在指定位置插入某个数。指定位置的序号与下标一样，从0开始计算。该方法不适用于数据量较多的列表，会影响性能。

a = list(range(3))
a = a.insert(2,8) #结果为[0,8,2]

（3）+运算符
该运算符的功能是将两个列表合并成一个新的列表。之前也提到过，+两边只能是数据类型相同的。

a = list(range(2))
b = list(ange(3))
c = a + b     结果为[0,1,0,1,2]

（4）使用extend()方法
extend()方法的效果与+效果相同，但是效率比+要高，列表数据比较多时，推荐使用。

a = list(range(5))
b = list(range(3))
a = a.extend(b)    #结果为[0,1,2,3,4,0,1,2]

附：列表的各种方法
2、列表的删除
（1）用del 方法
del为关键字， 可以删除 一个对象，也可以删除列表中的一个元素。格式为：del a[x] 删除列表a中下标为x的元素

a = [100,200,888,300,400]
del a[2]  #结果为[100,200,300,400]

操作如图所示：（列表所有的删除方法都是这个原理）
第一步

第二步

（2）用pop()方法
pop()方法返回的删除元素的值
直接使用pop()时，默认删除最后一个元素

a = [100,200,300,400]
a.pop()    #a得结果为[100,200,300]，输出结果为400

pop(x) x为下标

a = [100,200,300,500]
a.pop(3)    #a的结果为[100,200,300]，输出结果为500

（3）使用remove()方法
remove(t) 删除列表中值为t的第一个元素

a = [1000,22,3000,'p','l',22',p']
a = a.remove(22)    #结果为[1000,3000,'p','l',22,'p']
a = a.remove(‘p’)    #结果为[1000,3000,'l',22,'p']o

列表元素的访问和计数

1、通过索引直接访问元素
索引区间号为0~len-1 超过这个范围就会报告异常

2、用index()方法进查找
index()方法可以获取指定元素首次出现的索引位置。语法格式为：index(value, start, end)，返回的是该元素的索引位置。其中start是以列表首元素为标准。

a = [0,10,20,30,40,20,50,66,10]
a.index(20,3) #从索引为3开始查找元素20，结果为5

3、通过count（）方法获得指定元素在列表中出现的次数

a = [100,100,0,99,100]
a.count(100)    #结果为3

4、len()返回列表的长度

a = ['l']
len(a)    #结果为1

5、成员资格判断
方法一：使用count()函数。如果计数结果大于0，则存在，如果没有，则不存在
方法二：使用 in（not in）返回的结果为rue(False)则存在，反之则不存在T

a = [0,2,333,44,777,606]
100 in a    #False
606 in a    #True

6、 列表的切片方法
用slice()，用法与字符串中的切片是一样的。注意：如果起始位置和终止位置不在0~len-1 范围内也不报错。

a = [10,20,30,40,50,60]
a[::1]

7、列表的遍历
for obj in listObj:
print(obj)

列表排序

1、在原有列表上进行排序

a = [10,30,20,100,70,60]
a.sort()            #默认升序排列
a.sort(reverse=True)    #降序排列

import random
a = [10,20,50,30,100,90,60,70]
random.shuffle(a)         #随机将列表a打乱

2、新建一个列表保存排序的结果
内置函数sorted()进行排序

a = [20,10,40,30]
id(a)   #1513230033992

a = sorted(a)
id(a)    #1513230034760

用reversed()返回迭代器

a = [20,10,40,30]
c = reversed(a)   #c的类型为迭代器
list(c)   #[30,40,10,20]
list(c)   #[]  迭代器只能用一次

3、max
max用于返回列表中最大值
max(a)
4、min
min返回列表中最小值
min(a)
5、sum
只能适用于数值型的列表，如果有其它类型则会报错。

二维列表

列表的元素为列表。帮助我们存储表格信息，非常方便（这样使用的话类似于c++中的结构体）。

a = ['小明',15,80]
b = ['小红',14,95]
c = ['小李',16,98]
x = [a,b,c]    

""" x 的值为 """
[['小明', 15, 80], ['小红', 14, 95], ['小李', 16, 98]]

元组tuple

元组属于不可变系列，所以没有增加元素、删除元素、修改元素相关方法
元组只需要学习创建、元组删除、元素访问和计数。

元组的创建与删除

1、通过()创建

a = (10,20,30)
b = 30,50,40
c = (20,) #元组，type(c)为tuple
d = (90)  #整数，type(d)为int

2、通过tuple()创建 ，括号内为可迭代对象
将其他内容或者课迭代对象转为元组

str = 'fadsfds'
a = tuple(str)

3、生成器推导式创建元组
与列表不同的点：
（1）元组使用（）而列表使用[ ]
（2）元组生成的是一个生成器对象，而列表则是生成一个列表对象

s = (x*2 for x in range(5))    #s为生成器对象
tuple(s) #（0,2，4,6，8）
list(s)  #只能访问一次，结果为[]

"""解释"""
s = (x*2 for x in range(5))
s.__next__()  # 0
s.__next__()  # 2
s.__next__()  # 4
s.__next__()  # 6
s.__next__()  # 8
s.__next__()  # 报错

元组的其它操作

1、删除

del a

2、元素访问与计数
可以通过索引、切片等操作，和列表一样
3、排序
元组没有自己的排序函数，只能使用内置函数sorted进行排序，返回一个新列表对象
4、zip操作
zip(列表1，列表2，……，列表n）将多个列表变为元组再合并到一起，返回的类型为zip。

a = [1,2,3]
b = [4,5,6]
c = [7,8,9]
d = zip(a,b,c)   type(d)：zip
list(d)   #type(d) list