列表、元组与字典

列表、元组与字典

列表

• 定义：是可变的序列，也是一种可以存储各种数据类型的集合，用中括号[]表示开始和结束，元素之间用’,'分割。列表为每个元素提供一个对应的下标

基本表示

test1 = []
len(test1) # 0

test2 = [1,2,3,4,5]
len(test2) # 5
print(test2) # [1,2,3,4,5]

可以存放不同数据类型的元素成员

tests = ['A','B','C']
text  = [1,2,tests]
len(text) # 3
print(text) #  [1,2,['A','B','C']]
print(text[0]) # 1：支持按下标访问

列表基本操作

append

• 在列表尾部添加元素，无论列表是否非空；可在尾部添加单个元素，如字符、数字等，也可以是列表、元组等

lists = []
lists.append(1)
print(lists) # [1]
listss = [2]
lists.append(listss)
print(listss) # [1,[2]]

insert

• append方法只能在最后添加，insert()方法可以在任意一个位置添加元素

#在append基础上继续
lists.insert(0,'A')
print(lists) # ['A', 1, [2]]	
lists.insert(1,'B')
print(lists) # ['A', 'B', 1, [2]]

• 如果insert插入的元素下标越界，默认插入到最后

lists.insert(100,'C')
print(lists) # ['A', 'B', 1, [2], 'C']

index

• L.index(value,[start[,stop]])，其中value为待查找的元素，start为从列表中开始查找的下标数，stop为查找结束的下标数。若查到，返回从左到右第一个元素与value相等的下标，若未查到返回ValueError信息。

lists = ['Tom',1,2,3,1]
lists.index('Tom') # 0
lists.index(1) # 1 （返回第一个下标）
lists.index(1,2) # 3 （从下标2开始查找1元素）

in

• 判断指定元素是否在列表中（好处是不会产生出错信息）

lists = ['Tom',1,2,3,1]
'a' in lists # False

读取

• 下标读取（注意越界错误）

lists = ['Tom',1,2,3,1]
lists[2] # 2

• 切片读取

lists = ['Tom',1,2,3,1]
lists[1:] # [1,2,3,1]

修改

• 与字符串相比，列表可修改，灵活性更高

lists = ['Tom',1,2,3,1]
lists[0] = 'Jack'
print(lists)

clear

• 清空列表所有元素，使列表变成空列表

lists = [1,2,3,4,5]
len(lists) # 5
lists.clear()
len(lists) # 0
print(lists) # []

pop

• L.pop([index])，L表示列表对象，index为可选参数；当指定该参数时，从index位置弹出并删除对应元素；否则默认从表尾弹出并删除一个元素

lists = ['A','B','C']
one = lists.pop()
print(one,' ',lists) # C ['A','B']
two = lists.pop(0)
print(two,' ',lists) # A ['B']
lists.pop(2) # 越界错误

remove

• L.remove(value)删除列表中值为value的元素，若有多个删除最左边的那个。若value不存在，报错

lists = [1,2,3]
lists.remove(2)
print(lists) # [1,3]

del

• 可以用来删除列表中指定的元素，也可以删除整个列表对象

lists = [1,2,3,4]
del(lists[2]) # [1,2,4]
del lists
lists # 报错

合并

l1 = [1,2,3]
l2 = [4,5,6]
l1.extend(l2) #合并用extend
print(l1) # [1,2,3,4,5,6]

也可以

l1 = [1,2,3]
l2 = [4,5,6]
l1 = l1 + l2
print(l1)

两者不同之处是用’+'会导致l1内存地址变化，相当于l1被合并后被重新定义了。而采用extend()方法，不会导致对象地址变化。

sort

• L.sort(key = None,reverse = False)，L为列表对象；key为可选参数，用于指定在作比较之前，调用何种函数对列表元素进行处理，如key = str.lower表示在比较之前把所有字母转为小写；reverse为可选参数，若为True表示降序排序

fruit = ['banana','pear','apple','peach']
fruit1 = fruit.copy()
fruit1.sort()
print(fruit1) # ['apple', 'banana', 'peach', 'pear']
fruit.sort(reverse = True)
print(fruit) # ['pear', 'peach', 'banana', 'apple']

❓sort和sorted区别

sort是修改自己本身，sorted是生成一个新的排序过的列表

copy

• L.copy()形成一个和原本列表内容相同的新的列表对象
• 赋值方法与之不同的是赋值方法指向的地址是相同的

count

• L.count(e)统计列表中e的数量

reverse

• L.reverse()将列表反转，反转前后列表地址不变

列表解析

Nums = [i **2 for i in range(11) if i > 0]
# 等价于
Nums = []
for i in range(11)
	Nums.append(i ** 2)

元组

• 定义：是不可变的序列，也是一种可以存储各种数据类型的集合

与列表区别

• 元组不能对其元素进行变动，而列表允许
• 元组用小括号表示（()），而列表用中括号（[]）表示

基本用法

test1 = ()
len(test1) # 0
test2 = (1,2,2,'1','a') #可重复，多类型
test3 = (1)
type(test3) # int

当元组变量赋值一个元素时，不能用上述方式，Python会把1两边的括号看作数学公式的括号，结果为1。若给元组赋值一个元素，并消除小括号歧义，则

test3 = ('1',)
type(test3) # tuple
print(test3) # ('1',)

省略小括号的元组定义及应用

>>name,age = 'tom',19
>>(name,age) # ('tom',19)
>>name,age # ('tom',19)
>>test4 = ('A',10)
>>name1,age1 = test4
>>name1 # 'A'
>>age1 # 10

元组基本操作

“添加”元素

• 元组定义了不能改变，需要添加元素只能重新定义

tuple = (1,2,3)
tuple1 = tuple + (4,)

index

• 同列表index

count

• 同列表count

删除元组

• del tuple

合并元组

• t3 = t1 + t2

转换元组

list1 = ['A','B','C']
l_to_t = tuple(list1)
type(l_to_t) # tuple
t_to_l = list(l_to_t)
type(t_to_l) # list

字典

• 定义：字典是可变的无序集合，同时是一种键值对为基本元素的可以存储各种数据类型的集合，用{}表示字典的开始和结束，中间用’,'分割

基本用法

d1 = {'tom':29,'jack':41}
len(d1) # 2

键值设置要求

• 唯一性：一个字典对象里所有的键必须唯一

d3 = {1:'car',2:'bus',2:'bus'}
len(d3) # 2
print(d3) # {1:'car',2:'bus'} 相同键值对元素只保留一个
d4 = {1:'car',2:'bus',2:'train'}
len(d4) # 2
print(d4) # {1:'car',2:'train'} 保留最后一个键值对元素