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"
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"
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 的列表就是⼀个⼯⼚的仓库。
从形式上看，列表会将所有元素都放在⼀对中括号 [] 中，相邻元素之间⽤逗号分隔，格式中，element1~elementn 表⽰列表中的元素，个数没有限制，只要是 Python ⽀持的数据类型就可以。如下所⽰
[element1,element2,element3,...,elementn]
[root@kube list]# cat demo6.py
lt=['c.test',1,[2,3],2.34,'aa']
print(lt)
print(type(lt))
[root@kube list]# py demo6.py
['c.test', 1, [2, 3], 2.34, 'aa']
<class'list'>
[root@kube list]#
创建列表
[root@kube list]# cat demo7.py
lt=[1,'x.test',[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',[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']
[[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()⽅法的语法格式如下：d(obj)
如果希望在列表中间增加元素，则可使⽤列表的 insert() ⽅法，此⽅法的语法格式为：
listname.insert(index , obj)
其中，index 参数指的是将元素插⼊到列表中指定位置处的索引值。
使⽤ insert() ⽅法向列表中插⼊元素，和 append() ⽅法⼀样，⽆论插⼊的对象是列表还是元组，都只会将其整体视为⼀个元素。
[root@kube list]# cat demo9.py
a_list=['test',2,[2,'a']]
a_list.append('b')
print(a_list)
d([9,8,7])
print(a_list)
a_list.insert(4,'MM')
print(a_list)
[root@kube list]# py demo9.py
['test', 2, [2, 'a'], 'b']
['test', 2, [2, 'a'], 'b', 9, 8, 7]
['test', 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)
ve(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 语法赋值时，不能使⽤单个值；如果使⽤字符串赋值，会⾃动把字符串当成序列处理，其中每个字符都是⼀个元素。
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']python 定义数组
[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() ⽅法，此⽅法⽤于统计列表中某个元素出现的次数
index() ⽅法⽤于定位某个元素在列表中出现的位置（也就是索引），如果该元素没有出现，则会引发 ValueError 错误。此⽅法的基本语法格式为listname.index(obj,start,end)
同 count() ⽅法不同，index() ⽅法还可传⼊ start、end 参数，⽤于在列表的指定范围内搜索元素。
pop() ⽅法会移除列表中指定索引处的元素，如果不指定，默认会移除列表中最后⼀个元素。该⽅法的基本语法格式为：
listname.pop(index)
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))

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。