[Python]-4-元组列表与字典

Posted 2021-09-14 海

引言

这篇文章介绍python中的三种组合数据类型，文章后半段会介绍如何在这些组合数据类型中使用"分片"取出数据。

文章目录

0×1.元组
0×2.列表
0×3.字典
0×4.数据分片实例

0×1.元组

在python中，元组（Tuple）使用中括号来创建，如果括号中仅包含一个元素，需要在元素末尾添加一个逗号（不添加逗号数据会被创建成字符串或数值数据类型），元组在创建后，不能添加删除其中的元素，其值的指向是固定不变的，请看下面的实例：

#创建三个元组，b元组仅包含一个字符串元素，所以末尾需要添加一个逗号，否则b将被创建为字符串对象，c元组是一个多维元组，包含了a和b元组
>>> a=(1,2,3,4,5)
>>> b=("www.qingsword.com",)
>>> c=(a,b)

#分别打印出三个元组中的元素
>>> print(a)
(1, 2, 3, 4, 5)
>>> print(b)
(\'www.qingsword.com\',)
>>> print(c)
((1, 2, 3, 4, 5), (\'www.qingsword.com\',))

#打印出a元组第一个元素，python的索引起始是从0开始的
>>> print(a[0])
1

#打印出a元组中最后一个元素，len()函数将得到a元组元素的个数，因为索引是从0开始的，所以元素个数减一，就是最后一个元素的索引号
>>> print(a[len(a)-1])
5

#另一种简便的获取元组中最后一个元素的方法，直接使用-1，以此类推，获取倒数第二个元素就使用-2作为索引值
>>> print(a[-1])
5
>>> print(a[-2])
4

#获取多维元组中，第0个元素（a元组）中索引位置为2的值，也就是a子元组中的3了
>>> print(c[0][2])
3

#再来看下面这个实例，在元组中包含了一个列表，然后使用索引修改元组中列表的两个元素的值，上面所说的元组的元素不可变指的是引用的位置不变（内存地址），在本例中，元组t1索引位置为2的元素指向了一个列表所在的内存地址，我们只是改变了列表中的元素，而并没有改变元组的这个指向，而如果将这个指向更改成另外的列表或元素，就会产生一个错误
>>> t1=(1,2,["x","y"])
>>> print(t1)
(1, 2, [\'x\', \'y\'])
>>> t1[2][0]="a"
>>> t1[2][1]="b"
>>> print(t1)
(1, 2, [\'a\', \'b\'])

#甚至还可以使用列表的方法对元组中包含的列表添加和删除数据，列表的相关操作将在本文第2部分介绍
>>> t1[2].append("c")
>>> print(t1)
(1, 2, [\'a\', \'b\',\'c\'])

0×2.列表

python中，可以使用中括号创建列表，在上面的元组实例中的大部分操作都适用于列表，只需要将圆括号替换成中括号即可，不同点是，列表中仅包含一个元素时，不需要在末尾添加逗号，另外，列表可以添加或删除元素，请看下面的实例：

#创建三个列表，其中c为多维列表，包含a和b
>>> a=[1,2,3,4,5]
>>> b=["www.qingsword.com"]
>>> c=[a,b]

#打印出三个列表中的元素
>>> print(a)
[1, 2, 3, 4, 5]
>>> print(b)
[\'www.qingsword.com\']
>>> print(c)
[[1, 2, 3, 4, 5], [\'www.qingsword.com\']]

#使用list.append()方法，给a列表添加一个元素6
>>> a.append(6)
>>> print(a)
[1, 2, 3, 4, 5, 6]

#append()方法一次只能添加单个元素，而list.extend()方法一次可以添加多个元素
>>> a.extend([7,8,9])
>>> print(a)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

#利用extend()方法的特性，可以将一个列表中的元素完全复制给另外一个列表，下面创建了一个空列表d，然后将c列表中的元素复制给d，这里有个很奇怪的地方，在创建c的时候，包含的a列表只有前五位，现在c列表的第一个元素变成了9位，这是因为c列表第一个元素只是指向a列表的内存地址，a列表改变时，c读取到的数据也会改变
>>> d=[]
>>> d.extend(c)
>>> print(d)
[[1, 2, 3, 4, 5, 6, 7, 8, 9], [\'www.qingsword.com\']]

#使用list.remove()方法可以删除列表中的元素，这个方法接收的不是索引值，而是元素值（本例直接删除了a列表中的元素1和2）
>>> a.remove(1)
>>> a.remove(2)
>>> print(a)
[3, 4, 5, 6, 7, 8, 9]

#list.pop()方法接收一个索引值，如果不指定索引值则默认为最后一位元素的索引值，这个方法将取出并返回对应元素给调用者，然后从列表中删除这个元素
>>> print(a.pop())
9
>>> print(a)
[3, 4, 5, 6, 7, 8]

#删除索引值为0的元素
>>> print(a.pop(0))
3
>>> print(a)
[4, 5, 6, 7, 8]

python提供了一个set()函数用于处理列表中的重复元素，将他们合并成一个元素，例如：

#使用set()去除列表中的重复值
>>> lst1=set([1,2,3,3,4,4])
>>> lst2=set([3,4,5,5,6,6])
>>> lst3=set(["a","a","b","c","c"])

>>> print(list(lst1))
[1, 2, 3, 4]
>>> print(list(lst2))
[3, 4, 5, 6]
>>> print(list(lst3))
[\'a\', \'c\', \'b\']

#set类型的列表因为不存在重复值，所以可用于科学计算，例如求交集和并集
>>> print(list(lst1&lst2))
[3, 4]
>>> print(list(lst1|lst2))
[1, 2, 3, 4, 5, 6]

除了手动输入每个列表的元素外，python还提供了一个列表高级特性——"列表生成式"，配合for循环能够自动生成列表，例如：

#"列表生成式"语法：[元素结果表达式 for循环 判断语句或嵌套循环]
#执行顺序为，先运行"for循环"，然后执行"判断语句或嵌套循环"，将"for循环 判断语句或嵌套循环"这一部分得到的每一个值，放入"元素结果表达式"进行计算，最后将结果保存到列表中

#生成1~10中每位数字平方的列表
>>> L0=[x*x for x in range(1,11)]
>>> print(L0)
[1, 4, 9, 16, 25, 36, 49, 64, 81,100]

#从0~9中逐个读取数字，如果读取的数字能够整除2，则执行x*x并将结果保存到列表中
>>> L1=[x*x for x in range(0,10) if x%2==0]
>>> print(L1)
[0, 4, 16, 36, 64]

#嵌套循环，实现全组合，x相当于外层循环，y相当于嵌套的子循环，每个x都将得到3个y值，每个结果都将执行x+y并将结果保存到列表中
>>> L2=[x+y for x in "ABC" for y in "abc"]
>>> print(L2)
[\'Aa\', \'Ab\', \'Ac\', \'Ba\', \'Bb\', \'Bc\', \'Ca\', \'Cb\', \'Cc\']

#大小写转换
>>> L3=[x.upper() for x in "abc"]
>>> print(L3)
[\'A\', \'B\', \'C\']
>>> L3=[x.lower() for x in "ABC"]
>>> print(L3)
[\'a\', \'b\', \'c\']

#使用a和b变量读取字典{"one":1,"two":2}中的每一个元素的键和值，最后将他们用等号连接保存到列表中
>>> L4=[a+"="+str(b) for a,b in {"one":1,"two":2}.items()]
>>> print(L4)
[\'two=2\', \'one=1\']

#有时候我们在生成一组列表的时候，如果使用了大小写转换函数，但生成式中却包含了数值类型，就会触发异常，例如
 L5=[x.lower() for x in ["A","B",1,2]]

#可以使用下面的方法解决这个问题，isinstance函数接收两个参数，第一个参数是传入的值，第二个参数是比对类型，当传入的值和比对类型匹配的时候返回True，在下面这个列表生成式中，根据python中and和or的返回原理，当isinstance(x,str)为真时，返回x.lower()，即如果x是字符串，将其转换成小写，而当isinstance(x,str)为假时"isinstance(x,str) and x.lower()"为假，返回or后面的x，即将x不做任何修改添加到列表中
>>> L5=[isinstance(x,str) and x.lower() or x for x in ["A","B",1,2]]
>>> print(L5)
[\'a\', \'b\', 1, 2]

上面使用的"列表生成式"在创建列表的时候就已经计算出了列表的所有成员并储存在内存中了，这其实并不科学，有时我们创建的生成式会计算出很多元素，如果元素过多就会占用大量的内存，而我们仅需要访问列表中部分元素，这个时候就可以使用另外一种方式创建列表——"列表生成器"（generator）；

与"列表生成式"不同，"列表生成器"保存的仅仅是列表生成算法本身，只有当我们去迭代这个"列表生成器"对象的时候，才执行算法计算出我们访问的值，请看下面的实例：

#创建"列表生成器"而不是"列表生成式"仅需要将中括号改成圆括号即可
>>> L6=(x*x for x in range(0,10) if x%2==0)
>>> print(L6)
<generator object <genexpr> at 0x7faec4938410>

#有两种方法来让生成器执行算法，第一种方法是使用next()函数，如果next()已经获取完所有值，则会抛出一个StopIteration异常
>>> print(next(L6))
0
>>> print(next(L6))
4
>>> print(next(L6))
16
>>> print(next(L6))
36
>>> print(next(L6))
64
>>> print(next(L6))
Traceback (most recent call last):
    print(next(L6))
StopIteration

#但实际应用中很少使用next()函数，而是使用for循环迭代
>>> L6=(x*x for x in range(0,10) if x%2==0)
>>> for a in L6:
        print(a)   
0
4
16
36
64

0×3.字典

python中，使用大括号能够创建字典，字典中每个元素都是以"键值对"的形式储存的，请看下面的实例：

#有两种方法可以创建字典，第一种直接创建一个空的字典，然后逐个添加键值
>>> a={}
>>> a["早餐"]="牛奶鸡蛋"
>>> a["午餐"]="可乐牛排"
>>> a["晚餐"]="水果沙拉"
>>> print(a)
{\'早餐\': \'牛奶鸡蛋\', \'晚餐\': \'水果沙拉\', \'午餐\': \'可乐牛排\'}

#第二种方法创建字典，一次性添加所有的键值，用冒号分隔每一组元素，冒号前为"键"，冒号后为"值"
>>> a={\'早餐\': \'牛奶鸡蛋\', \'晚餐\': \'水果沙拉\', \'午餐\': \'可乐牛排\'}

#python允许不同的键拥有相同的值，所以下面的语法是正确的
b={"one":"qing","two":"qing"}

#有两种方法可以读取字典中的值，直接使用"字典[键]"来读取值，或使用"字典.get(键)"来读取值，在使用get()方法取出值的时候，如果get的键不存在，get()方法会返回一个"None"，或我们指定的值
>>> print(a["早餐"])
牛奶鸡蛋
>>> print(a.get("午餐"))
可乐牛排
>>> print(a.get("233"))
None
#如果字典中不存在"233"返回本站网址
>>> print(a.get("233","www.qingsword.com"))
www.qingsword.com

#判断字典中是否存在某个键值对，除了使用get()方法看返回是否为"None"外，还能用关键字in，如果存在就返回True，否则返回False
>>> "早餐" in a
TRUE

#读取字典keys和values列表
>>> print(a.keys())
dict_keys([\'早餐\', \'晚餐\', \'午餐\'])
>>> print(a.values())
dict_values([\'牛奶鸡蛋\', \'水果沙拉\', \'可乐牛排\'])

#除此之外，可以使用items()方法读取字典中每一组"键值对"
>>> for z in a.items():
        print(z)
(\'晚餐\', \'水果沙拉\')
(\'早餐\', \'牛奶鸡蛋\')
(\'午餐\', \'可乐牛排\')

#如果使用两个参数，就能获取每一组键值对中单个键和值数据
>>> for x,y in a.items():
        print(x,y)
午餐 可乐牛排
早餐 牛奶鸡蛋
晚餐 水果沙拉

#如果想删除字典中的某个"键值对"，可以使用pop()方法，向这个方法传递字典中的一个键名称，就可以取出并删除对应的"键值对"
>>> a.pop("早餐")
>>> print(a)
{ \'晚餐\': \'水果沙拉\', \'午餐\': \'可乐牛排\'}

0×4.数据分片实例

在python中能够通过数据分片，实现读取某段字符串中单个字符的目的，这种思想同样适用于元组和列表，如果列表中储存的为字符串，就可以通过分片技术取出某个元素的第几个字符，这种方法在某些环境中会非常实用，请看下面的实例：

#首先来看python对字符串数据的分片提取方法，本例取出a指向的字符串数据中，索引位置为2的单个字符
>>> a="abcdefg"
>>> print(a[2])
c

#在列表数据中，可以将每个字符串元素看做一个子列表，使用多维列表的思想，提取子列表中对应索引位置的值
>>> b=["www.qingsword.com","abcdefg","12345678"]
>>> print(b[0][4])
q

#提取b中索引位置为2的元素的最后一位字符
>>> print(b[2][-1])
8

使用字符串分片技术，将一组列表中的每个元素的首字母提取出来作为字典的键，并对应这个元素的值，下面是一段比较完整的程序：

#!/usr/bin/env python3
#创建一个名称列表
a=["Qingsword","John","Tom","George","Kali","Eva"]
x=0
#创建一个空字典
b={}
#当x值小于a列表元素个数时循环
while x<len(a):
    b[a[x][0]]=a[x]
    x+=1  
print(b)   

#程序输出
{\'E\': \'Eva\', \'G\': \'George\', \'Q\': \'Qingsword\', \'K\': \'Kali\', \'J\': \'John\', \'T\': \'Tom\'}

除了上面介绍的简单切片技术外，python还提供了一种特殊的切片技术——"分号切片"，请看下面的实例：

#分号切片同样适用于字符串或元组列表，语法为"[起始索引:结束索引(不包含)]"

#从字符串a索引为2（3）的位置开始切片，直到索引6（7）的位置，截取这其中的数据输出（包含起始索引值，不包含结束索引值）
>>> a="123456789"
>>> print(a[2:6])
3456

#从b中索引为3（d）的位置开始，直到索引为5（f）的位置
>>> b=["a","b","c","d","e","f","g"]
>>> print(b[3:5])
[\'d\', \'e\']

#再来看几个实例，创建一个包含元素1~9的列表
>>> L=list(range(1,10))
>>> print(L)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

#取出列表中从倒数第三个元素直到末尾的全部元素
>>> print(L[-3:])
[7, 8, 9]

#取出列表中从倒数第三个元素到倒数第一个元素（不包含最后一个元素）
>>> print(L[-3:-1])
[7, 8]

#如果从第一个元素开始取，可以省略冒号前的0
>>> print(L[:3])
[1, 2, 3]

#从第1到6个元素中，每隔一个元素取一个（步长为2）
>>> print(L[:6:2])
[1, 3, 5]

#全部列表元素，每隔一个元素取一个
>>> print(L[::2])
[1, 3, 5, 7, 9]

#中括号中什么都不写，只有一个冒号，就是取全部的元素
>>> print(L[:])
[1, 2, 3, 4, 5, 6, 7, 8, 9]

#同样的分片操作也适用于元组和字符串
>>> T=tuple(range(1,10))
>>> print(T[::2])
(1, 3, 5, 7, 9)
>>> s="www.qingsword.com"
>>> print(s[::2])
\'wwqnsodcm\'