Python列表（list）详解

Python 内置的四种经常使用数据结构：列表（list）、元组（tuple）、字典（dict）以及集合（set）。

这四种数据结构一但均可用于保存多个数据项，这对于编程而言是很是重要的，由于程序不只须要使用单个变量来保存数据，还须要使用多种数据结构来保存大量数据，而列表、元组、字典和集合就可知足保存大量数据的需求。

列表（list）和元组（tuple）比较类似，它们都按顺序保存元素，每一个元素都有本身的索引，所以列表和元组均可经过索引访问元素。两者的区别在于元组是不可修改的，但列表是可修改的。

字典（dict）和集合（set）相似，它们存储的数据都是无序的，其中字典是用 key-value 的形式保存数据

 

python 序列详解

所谓序列，指的是一块可存放多个值的连续内存空间，这些值按必定顺序排列，可经过每一个值所在位置的编号（称为索引）访问它们。

不管是采用正索引值，仍是负索引值，均可以访问序列中的任何元素。

注意，在使用负值做为列序中各元素的索引值时，是从 -1 开始，而不是从 0 开始。

[root@kube list]# cat demo1.py 
str="Py序列化详解"
print(str[0],"---",str[-6]) print(str[5],"---",str[-1]) [root@kube list]# py demo1.py 
P --- y 详 --- 解 [root@kube list]#

 

序列切片

切片操做是访问序列中元素的另外一种方法，它能够访问必定范围内的元素，经过切片操做，能够生成一个新的序列。

序列实现切片操做的语法格式以下：

sname[start : end : step]

其中，各个参数的含义分别是： sname：表示序列的名称； start：表示切片的开始索引位置（包括该位置），此参数也能够不指定，会默认为 0，也就是从序列的开头进行切片； end：表示切片的结束索引位置（不包括该位置），若是不指定，则默认为序列的长度； step：表示在切片过程当中，隔几个存储位置（包含当前位置）取一次元素，也就是说，若是 step 的值大于 1，则在进行切片去序列元素时，会“跳跃式”的取元素。若是省略设置 step 的值，则最后一个冒号就能够省略。

 

 

[root@kube list]# cat demo2.py
str="py序列切片"
print(str[:0]) #end 为0 表示结束索引位置可是不包括该位置,所以为空 print(str[:1]) print(str[:2]) print(str[1:2]) num="123456789"
print(num[1:5:2]) #在1-5 的区间中隔两位取一个值 [root@kube list]# py demo2.py 
 p py y 24 [root@kube list]#

 

 

 序列相加

Python 中，支持两种类型相同的序列使用“+”运算符作相加操做，它会将两个序列进行链接，但不会去除重复的元素。

里所说的“类型相同”，指的是“+”运算符的两侧序列要么都是序列类型，要么都是元组类型，要么都是字符串。

root@kube list]# cat demo3.py 
print("你好"+"我好"+"dajiahao") [root@kube list]# py demo3.py 
你好我好dajiahao [root@kube list]#

 

序列相乘

Python 中，使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次的结果

[root@kube list]# cat demo3.py 
str="你好"+"我好"+"dajiahao"
print(str*3) [root@kube list]# py demo3.py 
你好我好dajiahao你好我好dajiahao你好我好dajiahao [root@kube list]#

 

 

 检查元素是否包含在序列中

Python 中，可使用 in 关键字检查某元素是否为序列的成员，其语法格式为：

value in sequence

和 in 关键字用法相同，但功能刚好相反的，还有 not in 关键字，它用法检查某个元素是否不包含在指定的序列中

value not in sequence

 

[root@kube list]# cat demo4.py  #coding:utf-8
 str="test.com.cn"
print('e' in str) print('e' not in str) [root@kube list]# py demo4.py 
True False [root@kube list]#

 

和序列相关的内置函数

Python提供了几个内置函数（表 3 所示），可用于实现与序列相关的一些经常使用操做

表 3 序列相关的内置函数

函数	功能
len()	计算序列的长度，即返回序列中包含多少个元素。
max()	找出序列中的最大元素。注意，对序列使用 sum() 函数时，作加和操做的必须都是数字，不能是字符或字符串，不然该函数将抛出异常，由于解释器没法断定是要作链接操做（+ 运算符能够链接两个序列），仍是作加和操做。
min()	找出序列中的最小元素。
list()	将序列转换为列表。
str()	将序列转换为字符串。
sum()	计算元素和。
sorted()	对元素进行排序。
reversed()	反向序列中的元素。
enumerate()	将序列组合为一个索引序列，多用在 for 循环中。

 

[root@kube list]# cat demo5.py 
str="test.com.cn"
print(max(str)) print(min(str)) print(len(str)) print(list(str)) [root@kube list]# py demo5.py 
t . 11 ['t', 'e', 's', 't', '.', 'c', 'o', 'm', '.', 'c', 'n'] [root@kube list]#

python list 列表

Python 中没有数组，可是加入了更增强大的列表。若是把数组看作是一个集装箱，那么 Python 的列表就是一个工厂的仓库。

 从形式上看，列表会将全部元素都放在一对中括号 [] 中，相邻元素之间用逗号分隔，格式中，element1~elementn 表示列表中的元素，个数没有限制，只要是 Python 支持的数据类型就能够。以下所示

[element1,element2,element3,...,elementn]

 

 

[root@kube list]# cat demo6.py
lt=['c.test.com',1,[2,3],2.34,'aa'] print(lt) print(type(lt)) [root@kube list]# py demo6.py 
['c.test.com', 1, [2, 3], 2.34, 'aa'] <class 'list'> [root@kube list]#

建立列表

[root@kube list]# cat demo7.py
lt=[1,'x.test.com',[2,3]] # = 号赋值使用 [] 括起来 str="1234test"
print(type(lt)) print(type(str)) lt2=list(str) #使用 list() 函数转换 print(lt2) print(type(lt2)) [root@kube list]# py demo7.py 
<class 'list'>
<class 'str'> ['1', '2', '3', '4', 't', 'e', 's', 't'] <class 'list'> [root@kube list]#

 

 

 python  访问和删除列表

[root@kube list]# cat demo8.py
vol=[1,'test.com',[3,4,5],44,'fff','ee'] print(vol[:1]) print(vol[:2]) print(vol[2:4]) del vol print(vol) [root@kube list]# py demo8.py 
[1] [1, 'test.com'] [[3, 4, 5], 44] Traceback (most recent call last): File "demo8.py", line 6, in <module>
    print(vol) NameError: name 'vol' is not defined [root@kube list]#

 

 

python list 列表添加元素的三种方法

append() 方法用于在列表的末尾追加元素，该方法的语法格式以下：

listname.append(obj)

固然，若是但愿不将被追加的列表或元组当成一个总体，而是只追加列表中的元素，则可以使用列表提供的 extend() 方法。extend()方法的语法格式以下：

listname.extend(obj)

 

 若是但愿在列表中间增长元素，则可以使用列表的 insert() 方法，此方法的语法格式为：

listname.insert(index , obj)

其中，index 参数指的是将元素插入到列表中指定位置处的索引值。

使用 insert() 方法向列表中插入元素，和 append() 方法同样，不管插入的对象是列表仍是元组，都只会将其总体视为一个元素。

[root@kube list]# cat demo9.py
a_list=['test.com.cn',2,[2,'a']] a_list.append('b') print(a_list) a_list.extend([9,8,7]) print(a_list) a_list.insert(4,'MM') print(a_list) [root@kube list]# py demo9.py 
['test.com.cn', 2, [2, 'a'], 'b'] ['test.com.cn', 2, [2, 'a'], 'b', 9, 8, 7] ['test.com.cn', 2, [2, 'a'], 'b', 'MM', 9, 8, 7] [root@kube list]#

 

 

python list 列表删除元素的三种方法

在列表中删除元素，主要分为如下 3 种应用场景：

1. 根据目标元素所在位置的索引值进行删除，可以使用 del 语句；
2. 根据元素的值进行删除，可以使用列表（list类型）提供的 remove() 方法；
3. 将列表中全部元素所有删除，可以使用列表（list类型）提供的 clear() 方法。

[root@kube list]# cat demo10.py 
a_list=[1,2,"a.b.c",[4,5],(2,4)] print(a_list) del a_list[-2] print(a_list) a_list.remove(2) print(a_list) a_list.clear() print(a_list) [root@kube list]# py demo10.py 
[1, 2, 'a.b.c', [4, 5], (2, 4)] [1, 2, 'a.b.c', (2, 4)] [1, 'a.b.c', (2, 4)] [] [root@kube list]#

 

python list 修改元素

列表的元素至关于变量，所以程序能够对列表的元素赋值，这样便可修改列表的元素

slice 分片一样可使用

[root@kube list]# cat demo11.py 
a_list=list(range(0,10))       #list() 函数转换为列表
print(a_list) a_list[2]='a'                  #替换序列为2 的值
print(a_list) a_list[-1]='ffff'              #替换序列为-1 的值
print(a_list) a_list[3:4]=['s','d']          #替换分片3-4 的值
print(a_list) a_list[4:6]=[] #把 4-6 的值替换为空 print(a_list) a_list[1:3]='test' #对列表使用 slice 语法赋值时，不能使用单个值；若是使用字符串赋值，Python 会自动把字符串当成序列处理，其中每一个字符都是一个元素。
print(a_list) a_list[2:6:2]=['MM','NN'] #在使用 slice 语法赋值时，也可指定 step 参数。但若是指定了 step 参数，则要求所赋值的列表元素个数与所替换的列表元素个数相等 print(a_list) [root@kube list]# py demo11.py 
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] [0, 1, 'a', 3, 4, 5, 6, 7, 8, 9] [0, 1, 'a', 3, 4, 5, 6, 7, 8, 'ffff'] [0, 1, 'a', 's', 'd', 4, 5, 6, 7, 8, 'ffff'] [0, 1, 'a', 's', 5, 6, 7, 8, 'ffff'] [0, 't', 'e', 's', 't', 's', 5, 6, 7, 8, 'ffff'] [0, 't', 'MM', 's', 'NN', 's', 5, 6, 7, 8, 'ffff'] [root@kube list]#

 

python list 经常使用方法

除前面的增长元素、删除元素、修改元素方法以外，列表还包含了一些经常使用的方法。

count() 方法,此方法用于统计列表中某个元素出现的次数

listname.count(obj)

 

index() 方法用于定位某个元素在列表中出现的位置（也就是索引），若是该元素没有出现，则会引起 ValueError 错误。此方法的基本语法格式为

listname.index(obj,start,end)

 

同 count() 方法不一样，index() 方法还可传入 start、end 参数，用于在列表的指定范围内搜索元素。

 

pop() 方法会移除列表中指定索引处的元素，若是不指定，默认会移除列表中最后一个元素。该方法的基本语法格式为：

listname.pop(index)

reverse() 方法会将列表中全部元素反向存放。该方法的基本语法格式为：

listname.reverse()

sort() 方法用于对列表元素进行排序，排序后原列表中的元素顺序会方发生改变。sort() 方法的语法格式以下：

listname.sort(key=None, reserse=False)

listname.sort(key=None, reserse=False)

能够看到，和其余方法不一样，此方法中多了 2 个参数，它们的做用分别是： key 参数用于指定从每一个元素中提取一个用于比较的键。例如，使用此方法时设置 key=str.lower 表示在排序时不区分字母大小写。 reverse 参数用于设置是否须要反转排序，默认 False 表示从小到大排序；若是将该参数设为 True，将会改成从大到小排序。

下面代码示范了使用列表做为“栈”的示例：

stack = [] # 向栈中“入栈”3个元素
stack.append("fkit") stack.append("crazyit") stack.append("Charlie") print(stack) # ['fkit', 'crazyit', 'Charlie'] # 第一次出栈：最后入栈的元素被移出栈
print(stack.pop()) print(stack) # ['fkit', 'crazyit'] # 再次出栈
print(stack.pop()) print(stack) # ['fkit']

 

python range 快速初始化数字列表

ython range() 函数可以轻松地生成一系列的数字。例如，能够像以下这样使用 range() 来打印一系列数字：

[root@kube list]# cat demo14.py  #coding:utf-8
seq=[] for i in range(1,4): #求1-3 的乘积 vol=i**2 seq.append(vol) print(seq) print('----------------------------') print(type([1,2,3,4])) #range 的type 类型的转化 print(type(range(1,5))) [root@kube list]# py demo14.py 
[1, 4, 9] ----------------------------
<class 'list'>
<class 'range'> [root@kube list]#

 

 

python list 列表实现栈和队列

队列和栈是两种数据结构，其内部都是按照固定顺序来存放变量的，两者的区别在于对数据的存取顺序： 队列是，先存入的数据最早取出，即“先进先出”。 栈是，最后存入的数据最早取出，即“后进先出”。

考虑到 list 类型数据自己的存放就是有顺序的，并且内部元素又能够是各不相同的类型，很是适合用于队列和栈的实现。本节将演示如何使用 list 类型变量来实现队列和栈。

 

python list 列表实现

使用 list 列表模拟队列功能的实现方法是，定义一个 list 变量，存入数据时使用 insert() 方法，设置其第一个参数为 0，即表示每次都从最前面插入数据；读取数据时，使用 pop() 方法，即将队列的最后一个元素弹出。

[root@kube list]# cat demo15.py  #coding:utf-8

#定义一个空列表，当作队列
queue = [] #向列表中插入元素
queue.insert(0,"one") queue.insert(0,"two") queue.insert(0,"three") print(queue) print('取第一个元素:',queue.pop()) #pop() 默认取队列最后一位 print('取第二个元素:',queue.pop()) print('取第三个元素:',queue.pop()) [root@kube list]# py demo15.py 
['three', 'two', 'one'] 取第一个元素: one 取第二个元素: two 取第三个元素: three [root@kube list]#

 

python  实现栈

使用 list 列表模拟栈功能的实现方法是，使用 append() 方法存入数据；使用 pop() 方法读取数据。append() 方法向 list 中存入数据时，每次都在最后面添加数据，这和前面程序中的 insert() 方法正好相反。

 

[root@kube list]# cat demo16.py  #coding:utf-8

#定义一个list 当栈
stack = [] stack.append('one') stack.append('two') stack.append('three') print(stack) print('取第一个元素:',stack.pop()) print('取第二个元素:',stack.pop()) print('取第三个元素:',stack.pop()) [root@kube list]# py demo16.py 
['one', 'two', 'three'] 取第一个元素: three 取第二个元素: two 取第三个元素: one [root@kube list]#

collections模块实现栈和队列

queueAndStack = deque() queueAndStack.append(1) queueAndStack.append(2) queueAndStack.append("hello") print(list(queueAndStack)) #实现队列功能，从队列中取一个元素，根据先进先出原则，这里应输出 1
print(queueAndStack.popleft()) #实现栈功能，从栈里取一个元素，根据后进先出原则，这里应输出 hello
print(queueAndStack.pop()) #再次打印列表
print(list(queueAndStack))