python元组和列表都支持的方法是_python_列表和元组

1.1.列表定义

列表是python中内置有序可变序列，列表的所有元素放在一对中括号“[]”中，并使用逗号分隔开；

一个列表中的数据类型可以各不相同，可以同时分别为整数、实数、字符串等基本类型，甚至是列表、字典以及其他自定义类型的对象。

例如：

[1, 2, 3, 2.4, 5]

[0.01, "zhangsan", [1,2,3]]

创建

使用“=”直接将一个列表赋值给变量即可创建列表对象。例如：a_list = [], b_list = [1, 2, 3]

使用list()函数将元组、range对象、字符串或其他类型的可迭代对象类型的数据转换为列表。

例如：a_list = list("Hello")将字符串"hello"转换成列表['H', 'e', 'l', 'l', 'o']

删除 当不再使用时，使用del命令删除整个列表 例如：

>>>x = [1, 2, 3]

>>>del x[1] #删除指定位置元素

>>>x

[1, 3]

>>>del x #删除整个列表

>>>x

Traceback (most recent call last):

File "", line 1, in

x

NameError: name 'x' is not defined

1.2.列表元素的增加

1.2.1.append()

向列表尾部追加一个元素，不改变其内存首地址，属于原地操作。例如：

x = [1, 2, 3]

x.append(4)

print(x)

输出：

[1, 2, 3, 4]

1.2.2.insert()

向列表任意位置插入一个元素，不改变其内存首地址，属于原地操作。

例如：

x = [1,3,4]

x.insert(1,2)

print(x)

输出：

[1, 2, 3, 4]

1.2.3.extend()

将另一个迭代对象的所有元素添加至该列表对象尾部，不改变其内存地址，属于原地操作。

例如：

x = [1,2]

x.extend([3,4])

print(x)

输出：

[1, 2, 3, 4]

1.3.运算符"+"和"*"

并不是真的为列表添加元素，而是创建一个新列表，不属于原地操作，而是返回新列表。

x = [1,2,3]

y = x + [4]

print(y)

y = x*2

print(y)

输出：

[1, 2, 3, 4]

[1, 2, 3, 1, 2, 3]

此时x保持不变，依旧是[1,2,3]

1.4.列表元素的删除

1.4.1.pop()

使用列表的pop()方法删除并返回指定(默认为最后一个)位置上的元素，如果给定的索引超出了列表的范围，则抛出异常。

x = [1,2,3,4]

print(x.pop())

print(x.pop(1))

输出：

4

2

1.4.2.remove()

删除首次出现的指定元素，如果列表中不错在要删除的元素，则抛出异常。

例如：

x = [1,2,3,4]

x.remove(2)

print(x)

输出：

[1, 3, 4]

1.4.3.del

删除列表中的指定位置上的元素。

例如：

x = [1,2,3,4]

del x[1]

print(x)

输出：

[1, 3, 4]

1.5.列表元素访问与计数

1.5.1.count()

统计指定元素在列表对象中出现的次数。

例如：

x = [1,2,3,3,4,5]

print(x.count(3))

print(x.count(0))

输出：

2

0

1.5.2.index()

获取指定元素首次出现的下标，若列表对象中不存在指定元素，则抛出异常。

例如：

x = [1,2,3,2,2,4]

print(x.index(2))

输出：

1

1.5.3.in

测试列表中是否存在某元素

例如：

x = [1,2,3,4]

print(3 in x)

print(5 in x)

输出：

True

False

1.6.列表排序

1.6.1.sort()

按照指定规则对所有元素进行排序，默认规则是直接比较规则大小。

例如：

aList = [3,4,5,6,7,9,11,13,15,17]

import random

random.shuffle(aList) #随机降序

print(aList)

aList.sort() #默认是升序排序

aList.sort(reverse = True) #降序排序

print(aList)

输出：

[15, 4, 13, 11, 5, 17, 9, 3, 7, 6]

[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]

1.6.2.reverse()

将列表中所有元素原地逆序排列。

例如：

x = [6,4,2,4,1]

print(sorted(x))

print(sorted(x,reverse = True))

print(x)

输出：

[1, 2, 4, 4, 6]

[6, 4, 4, 2, 1]

[6, 4, 2, 4, 1]

1.6.4.reversed()

返回一个逆序排列后的迭代对象，不对原列表做任何修改。

例如：

x = [1,5,3,6,2]

print(list(reversed(x)))

print(x)

输出：

[2, 6, 3, 5, 1]

[1, 5, 3, 6, 2]

1.7.用语序列操作的常用内置函数

1.7.1.len()

返回列表中的元素个数，同样适用于元组、字典、集合、字符串等。

1.7.2.max()、min()

返回列表中的最大或最小元素，同样适用于元组、集合、range对象等。

1.7.3.sum()

对列表的元素进行求和运算。

1.7.4.zip()

返回可迭代的zip对象。

例如：

aList = [1, 2, 3]

bList = [4, 5, 6]

cList = zip(aList, bList)

print(cList)

print(list(cList))

输出：

[(1, 4), (2, 5), (3, 6)]

1.7.5.enumerate()

枚举列表元素，返回枚举对象，其中每个元素为包含下标和值的元组。该函数对元组、字符串同样有效。

例如：

for item in enumerate('abcdef'):

print(item)

输出：

(0, 'a')

(1, 'b')

(2, 'c')

(3, 'd')

(4, 'e')

(5, 'f')

1.8.遍历列表的三种方式

a = ['a','b','c','d','e','f']

for i in a:

print(i)

for i in range(len(a)):

print(i,a[i])

for i,ele in enumerate(a):

print(i,ele)

输出：

a

b

c

d

e

f

0 a

1 b

2 c

3 d

4 e

5 f

0 a

1 b

2 c

3 d

4 e

5 f

1.9.列表推导式

列表推导式使用非常简洁的方式来快速生成满足特定需求的列表，代码具有非常强的可读性。

语法形式：[表达式 for 变量 in 序列或迭代对象]

列表推导式在逻辑上相当于一个循环，知识形式更加简洁。

lis = [i for i in range(100)]

print(lis)

使用列表推导式实现嵌套列表的平铺

ves = [[1,2,3],[4,5,6],[7,8,9]]

print([num for elem in ves for num in elem])

输出：

[1, 2, 3, 4, 5, 6, 7, 8, 9]

过滤不符合条件的元素，从列表中选择符合条件的元素组成新的列表

aList = [-1,-4,6,7.5,-2.3,9,-11]

print([i for i in aList if i>0])

[6, 7.5, 9]

在列表推导式中使用多个循环，实现多序列元素的任意组合，并且可以结合条件语句过滤特定元素

print([(x,y) for x in range(3) for y in range(3)])

[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

print([(x,y) for x in [1,2,3] for y in [3,1,4] if x != y])

[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

列表练习

写一个循环，不断地问用户想买什么，用户选择一个商品编号，就把相应的商品添加到购物车里，最终用户输入q退出时，打印购物车里的商品列表

products = [['iphone',6888],['三星',30000],['小米',2500]]

shopping_car = []

flag = True

while flag:

print("******商品列表******")

for index,i in enumerate(products):

print("%s, %s| %s" %(index,i[0],i[1]))

choice = input("请输出您想购买的商品的编号：")

if choice.isdigit():#isdigit()判断变量是什么类型

choice = int(choice)

if choice >= 0 and choice < len(products):

shopping_car.append(products[choice])

print("已经将%s加入购物车" % (products[choice]))

else:

print("该商品不存在")

elif choice == "q":

if len(shopping_car)>0:

print("您打算购买以下商品：")

for index,i in enumerate(shopping_car):

print("%s. %s| %s" %(index,i[0],i[1]))

else:

print("您的购物车中没有添加商品")

flag = False

输出：

******商品列表******

0, iphone| 6888

1, 三星| 30000

2, 小米| 2500

请输出您想购买的商品的编号：0

已经将['iphone', 6888]加入购物车

******商品列表******

0, iphone| 6888

1, 三星| 30000

2, 小米| 2500

请输出您想购买的商品的编号：1

已经将['三星', 30000]加入购物车

******商品列表******

0, iphone| 6888

1, 三星| 30000

2, 小米| 2500

请输出您想购买的商品的编号：2

已经将['小米', 2500]加入购物车

******商品列表******

0, iphone| 6888

1, 三星| 30000

2, 小米| 2500

请输出您想购买的商品的编号：q

您打算购买以下商品：

0. iphone| 6888

1. 三星| 30000

2. 小米| 2500

1.10.列表切片

使用索引获取列表的元素(随机读取)

列表元素支持用索引访问，正向所以从0开始

colors = ["red","blue","green"]

print(colors[0])

print(colors[1])

print(colors[2])

print(colors[-1])

red

blue

green

green

1.10.1.列表的切片操作

切片操作不是列表特有的，python中的有序序列都支持切片，如字符串，元组。

切片的返回结果类型和切片对象类型一致，返回的是切片对象的子序列，如：对一个列表切片返回一个列表，字符串切片返回字符串。

格式：li[start:end:step]

start是切片起点索引，end是切片终点索引，但切片结果不包括终点索引的值。step是步长默认是1。

li=["A","B","C","D"]

t=li[0:3] #起点的0索引可以省略

print(t)

t=li[2:] #省略end，则切到末尾

print(t)

t=li[1:3]

print(t)

t=li[0:4:2] #从li[0]到li[3]，设定步长为2.

print(t)

如何确定start和end，是什么关系？在step的符号一定的情况下，start和end可以混合使用正向和反向索引，无论怎样，你都要保证start和end之间有和step反向一致元素间隔，否则会切出空列表。

t=li[0:2]

t=li[0,-2]

t=li[-4,-2]

t=li[-4,2]

上面的结果都是一样的：t为["A","B"]

t=li[-1:-3:-1]

t=li[-1:1:-1]

t=li[3:1:-1]

t=li[3:-3:-1]

上面的结果都是一样的：t为["D","C"]

t=li[-1:-3]

t=li[-1:1]

t=li[3:1]

t=li[3:-3]

都切出空列表

同时，step的正负决定了切片结果的元素采集的先后

省略start和end表示以原列表全部为目标

t=li[::-1] t--->["C","B","A"] #反向切，切出全部

t=li[:] t--->["A","B","C","D"] #正向切全部

1.10.2.使用切片来原地修改列表内容

aList = [3,5,7]

aList[len(aList):] = [9] #在尾部追加元素

print(aList)

aList[:3] = [1,2,3] #替换前3个元素

print(aList)

aList[:3] = [] #删除前3个元素

print(aList)

[3, 5, 7, 9]

[1, 2, 3, 9]

[9]

1.10.3.使用del与切片结合来删除列表元素

aList = [3,5,7,9,11]

del aList[:3] #删除前3个元素

print(aList)

bList = [3,5,7,9,11]

del bList[::2] #删除偶数位置上的元素

print(bList)

[9, 11]

[5, 9]

1.10.4.切片返回的是列表元素的浅复制

所谓浅复制，是指生成一个新的列表，并且把原列表中所有元素的引用都复制到新列表中。

例如：

aList = [3,5,7]

bList = aList #bList与aList指向同一个内容

print(bList)

bList[1] = 8 #修改其中一个对象会影响另一个

print(aList)

print(aList == bList) #判断两个列表的元素是否完全一致

print(aList is bList) #判断两个列表是同一个对象

print(id(aList)) #内存地址

aList = [3,5,7]

bList = aList[::] #切片，浅复制

print(aList == bList) #两个列表的元素完全一致

print(aList is bList) #两个列表不是同一个对象

print(id(aList) == id(bList)) #内存地址不一致

bList[1] = 8

print(bList)

print(aList)

[3, 5, 7]

[3, 8, 7]

True

True

2340905449608

True

False

False

[3, 8, 7]

[3, 5, 7]

1.11.元组

元组属于不可变序列，一旦常见，用任何方法都不可以修改其元素。从形式上，元组的所有元素放在一对圆括号中，元素之间用逗号分隔。

1.11.1.元组的创建与删除

创建 使用“=”将一个元组赋值给变量

例如：

x = (1,2,3) #直接把元组赋值给一个变量

print(x)

创建只有一个元素的元组

x = (3)

print(type(x))

x = (3,)

print(type(x))

创建空元组的方法

x = ()

print(x)

x = tuple()

print(x)

()

()

使用tuple函数将其他序列转换为元组

print(tuple(range(5)))

print(tuple('abcdefg')) #把字符串转换为元组

aList = [-1,-4,6,7.5,-2.3,9,-11]

print(tuple(aList)) #把列表转换为元组

(0, 1, 2, 3, 4)

('a', 'b', 'c', 'd', 'e', 'f', 'g')

(-1, -4, 6, 7.5, -2.3, 9, -11)

删除 使用del可以删除元组对象，不能删除元组中的元素

1.11.2.元组与列表的区别

元组中的数据一旦定义就不允许更改。

元组没有append()、expend()和insert()等方法，无法向元组中添加元素

元组没有remove()或pop()方法，也无法对元组元素进行del操作，不能从元组中删除元素。

从效果上看，tuple()冻结列表，而list()融化元组。

1.12.元组的优点

元组的速度比列表更快

元组对不需要改变的数据进行“写保护”将使得代码更加安全。

元组可用作字典键(特别是包含字符串、数值和其他元组这样的不可变数据的元组)。元组有时还作为函数的返回值返回(返回多个值)。