Python列表元祖字典详解

一、列表（List）

1、列表可以用来存储不同的数据类型，使用 [ ]

e.g.

1 service = ['http','ssh','ftp']

?

?2、列表是有索引的，也就是可以通过下标来访问数据

?

?

?

3、切片访问和连接（两个列表可以直接相加）

1 print(service[1:])   ##打印第一个元素之后的内容
2 print(service[:-1])  ##打印最后一个元素之前的内容
3 print(service[::-1])  ##倒序输出

4、列表里可以嵌套列表

1 service2 = [['abc','def','www'],[1,2,3],['mike','tony','sun']]
2 
3 对其索引：print(service2[2][1])   ##第三个元素中的第二个元素
4 对其切片：print(service2[:][1])   ##第二个元素

?

?

?

5、列表的增删改查

1 1.print(service + ['firewalld'])   ##用连接的方式
3 2.service.append('firewalld')   print(service)    ##append:追加一个元素到列表中
4 
5 3.extend:拉伸 追加多个元素到列表中  service.extend(['MysqL','firewalld'])
6 
7 4.service.insert(1,'samba')  ###在指定索引位置插入元素  ##在第二个元素的位置插入samba作为第二个元素

赋值：

1 1.service[0] = 'MysqL'   ##通过索引 重新赋值
3 2.service[:2] = ['samba','iscsi']  ##通过切片给前两个元素重新赋值

6、查看出现的次数：

1 service.count('ssh')
3 #查看索引值
4 service.index('iscsi')    ###最小索引值
5 service.index('ssh',1,3)   ###从1-3中查找【第二个元素和第三个元素之间】【不取上限】

列表可以排序

二、元祖

首先元祖是不可变的，这使得它可以作为 dict 的 key，或者扔进 set 里，而 list 则不行。

1、元祖的创建

　　创建和访问一个元组如果创建一个空元组，直接使用小括号即可；
　　如果要创建的元组中只有一个元素，要在它的后面加上一个逗号‘，’。

 1 >>> temp = ()
 2 >>> type(temp)
 3 ? ? ?<class 'tuple'>
 4 >>> temp = (1,)
 5 >>> 6 ? ? <class 'tuple'>
 7 >>> temp = (1 8 >>> 9 ? ? <class 'int'>
10 >>> 8 * (811 ? ? 64
12 >>> 8 * (813 ? ? (8,8,8)

2、元祖的更新和删除

　　理论上是不可以完成的，但是可以通过切片复制连接一个新的元祖来实现。

 1 __author__ = 'Administrator'
 2  
 3 # -*- coding:utf-8 -*-
 4  
 5 temp = ("龙猫","泰迪","叮当猫" 6 temp = temp[:2] + ("小猪佩奇",)+temp[2:]
 7 print(temp)
 8 """
 9 ('龙猫','泰迪','小猪佩奇','叮当猫')
10 Process finished with exit code 0
11 """

　　删除

 5 temp = ('龙猫','叮当猫' 6 temp = temp[:2] + temp[311 """

3、成员关系操作符 in 和 not in 也可以直接应用在元组上，这跟列表是一样的。

 6 a ="泰迪"
 7 c = ('泰迪','小猪佩奇' 8 b = a in temp
 9 d =c 10 f =c not 11 print(b)
12 print(d)
13 print(f)
14 """
15 True
16 False
17 18 19 """

4、列表转化元祖

1 >>> list1= ['Google','Taobao','Runoob','Baidu']
2 >>> tuple1=tuple(list1)
3 >>> tuple1
4 ('Google','Baidu')

5、元组中元素最大值和最小值

1 >>> tuple2 = ('5','4','8'2 >>> max(tuple2)
3 '8'
5 >>> tuple2 = ('5',1)">6 >>> min(tuple2)
7 '4'

6、元祖长度

1 >>> tuple1 = ('Google','Taobao' len(tuple1)
3 3

7、Tuple 与 list 的转换

　　Tuple 可以转换成 list，反之亦然。内置的 tuple 函数接收一个 list，并返回一个有着相同元素的 tuple。

　　而 list 函数接收一个 tuple 返回一个 list。

　　从效果上看，tuple 冻结一个 list，而 list 解冻一个 tuple。

?

三、字典

由于字典中的 key 是非常关键的数据，而且程序需要通过 key 来访问 value，因此字典中的 key 不允许重复。

程序既可使用花括号语法来创建字典，也可使用 dict() 函数来创建字典。实际上，dict 是一种类型，它就是 Python 中的字典类型。
在使用花括号语法创建字典时，花括号中应包含多个 key-value 对，key 与 value 之间用英文冒号隔开；多个 key-value 对之间用英文逗号隔开。

1 scores = {'语文': 89,数学': 92,1)">英语': 93}
2 print(scores)
# 空的花括号代表空的dict
4 empty_dict = {}
5 (empty_dict)
6  使用元组作为dict的key
7 dict2 = {(20,30):good',30:bad'8 print(dict2)

上面程序中第 1 行代码创建了一个简单的 dict，该 dict 的 key 是字符串，value 是整数；

第 4 行代码使用花括号创建了一个空的字典；第 7 行代码创建的字典中第一个 key 是元组，

第二个 key 是整数值，这都是合法的。

需要指出的是，元组可以作为 dict 的 key，但列表不能作为元组的 key。

这是由于 dict 要求 key 必须是不可变类型，但列表是可变类型，

因此列表不能作为元组的 key。

?

在使用 dict() 函数创建字典时，可以传入多个列表或元组参数作为 key-value 对，

每个列表或元组将被当成一个 key-value 对，因此这些列表或元组都只能包含两个元素。

例如如下代码：

1 vegetables = [(celerybrocolilettuce)]
 创建包含3组key-value对的字典 列表里[ ]里面可以放多个 [ ] 列表 或者多个 ( ) 元祖
3 dict3 = dict(vegetables)
4 print(dict3)  {'celery': 1.58,'brocoli': 1.29,'lettuce': 2.19}
5 cars = [[BMWBENSAUDI 创建包含3组key-value对的字典
7 dict4 = dict(cars)
print(dict4)  {'BMW': 8.5,'BENS': 8.3,'AUDI': 7.9}

如果不为 dict() 函数传入任何参数，则代表创建一个空的字典。例如如下代码：

1  创建空的字典
2 dict5 = dict()
print(dict5)  {}

还可通过为 dict 指定关键字参数创建字典，此时字典的 key 不允许使用表达式。例如如下代码：

 使用关键字参数来创建字典
2 dict6 = dict(spinach = 1.39,cabbage = 2.59print(dict6)  {'spinach': 1.39,'cabbage': 2.59}

?

常用操作：

• 通过 key 访问 value 。
• 通过 key 添加 key-value 对。
• 通过 key 删除 key-value 对。
• 通过 key 修改 key-value 对。
• 通过 key 判断指定 key-value 对是否存在。
• 通过 key 访问 value 使用的也是方括号语法，就像前面介绍的列表和元组一样，只是此时在方括号中放的是 key，而不是列表或元组中的索引。

1、访问：

': 89 通过key访问value
print(scores['])

?

2、添加

 对不存在的key赋值，就是增加key-value对
2 scores['] = 93
3 scores[92] = 5.7
print(scores)  {'语文': 89,'数学': 93,92: 5.7}

?

3、删除

 使用del语句删除key-value对
del scores[ {92: 5.7}

?

4、如果要判断字典是否包含指定的 key，则可以使用 in 或 not in 运算符。需要指出的是，

　　对于 dict 而言，in 或 not in 运算符都是基于 key 来判断的。例如如下代码：

 判断cars是否包含名为'AUDI'的key
print(' in cars)  True
 判断cars是否包含名为'PORSCHE'的key
PORSCHE False
LAMBORGHINInot  True

通过上面介绍可以看出，字典的 key 是它的关键。换个角度来看，

字典的 key 就相当于它的索引，

只不过这些索引不一定是整数类型，字典的 key 可以是任意不可变类型。

可以这样说，字典相当于索引是任意不可变类型的列表：

而列表则相当于 key 只能是整数的字典。

因此，如果程序中要使用的字典的 key 都是整数类型，

则可考虑能否换成列表。

此外，还有一点需要指出，列表的索引总是从 0 开始、连续增大的；

但字典的索引即使是整数类型，也不需要从 0 开始，而且不需要连续。

因此，列表不允许对不存在的索引赋值：

但字典则允许直接对不存在的 key 赋值，

这样就会为字典增加一个 key-value 对。

列表不允许对不存在的索引赋值，但字典则允许直接对不存在的 key 赋值。

?

?

?

get()方法

get() 方法其实就是根据 key 来获取 value，它相当于方括号语法的增强版，

当使用方括号语法访问并不存在的 key 时，字典会引发 KeyError 错误；

但如果使用 get() 方法访问不存在的 key，该方法会简单地返回 None，

不会导致错误。例如如下代码：

1 cars = {': 8.5,1)">': 8.3,1)">': 7.9 获取'BMW'对应的value
print(cars.get('))  8.5
 None
print(cars['])  KeyError

?

update()方法

update() 方法可使用一个字典所包含的 key-value 对来更新己有的字典。

在执行 update() 方法时，如果被更新的字典中己包含对应的 key-value 对，

那么原 value 会被覆盖；如果被更新的字典中不包含对应的 key-value 对，

则该 key-value 对被添加进去。例如如下代码：

2 cars.update({':4.5,1)">': 9.3})
print(cars)

items()、keys()、values()

items()、keys()、values() 分别用于获取字典中的所有 key-value 对、所有 key、所有 value。

这三个方法依次返回 dict_items、dict_keys 和 dict_values 对象，

Python 不希望用户直接操作这几个方法，

但可通过 list() 函数把它们转换成列表。如下代码示范了这三个方法的用法：

?

 1 cars = { 2  获取字典所有的key-value对，返回一个dict_items对象
 3 ims = cars.items()
 4 print(type(ims))  <class 'dict_items'>
 5  将dict_items转换成列表
 6 print(list(ims))  [('BMW',8.5),('BENS',8.3),('AUDI',7.9)]
 访问第2个key-value对
 8 print(list(ims)[1])  ('BENS',8.3)
 获取字典所有的key，返回一个dict_keys对象
10 kys = cars.keys()
print(type(kys))  <class 'dict_keys'>
 将dict_keys转换成列表
print(list(kys))  ['BMW','BENS','AUDI']
14  访问第2个key
print(list(kys)[1])  'BENS'
 获取字典所有的value，返回一个dict_values对象
17 vals = cars.values()
 将dict_values转换成列表
19 print(type(vals))  [8.5,8.3,7.9]
20  访问第2个value
21 print(list(vals)[1])  8.3

在 Python 2.x 中，items()、keys()、values() 方法的返回值本来就是列表，

完全可以不用 list() 函数进行处理。当然，使用 list() 函数处理也行，列表被处理之后依然是列表。

?

pop方法

pop() 方法用于获取指定 key 对应的 value，并删除这个 key-value 对。如下方法示范了 pop() 方法的用法：

': 7.9,1)">': 8.5(cars)
 弹出字典底层存储的最后一个key-value对
print(cars.popitem())  ('AUDI',7.9)
print(cars) 因此程序完全可以通过序列解包的方式用两个变量分别接收 key 和 value。

例如如下代码：

 将弹出项的key赋值给k、value赋值给v
2 k,v = cars.popitem()
print(k,v)  BENS 8.3

setdefault()方法
setdefault() 方法也用于根据 key 来获取对应 value 的值。但该方法有一个额外的功能，
即当程序要获取的 key 在字典中不存在时，
该方法会先为这个不存在的 key 设置一个默认的 value，然后再返回该 key 对应的 value。

总之，setdefault() 方法总能返回指定 key 对应的 value；如果该 key-value 对存在，则直接返回该 key 对应的 value；
如果该 key-value 对不存在，则先为该 key 设置默认的 value，然后再返回该 key 对应的 value。

如下代码示范了 setdefault() 方法的用法：

 设置默认值，该key在dict中不存在，新增key-value对
print(cars.setdefault( 9.2
 设置默认值，该key在dict中存在，不会修改dict内容
7 print(cars)

fromkeys()方法
fromkeys() 方法使用给定的多个 key 创建字典，这些 key 对应的 value 默认都是 None；
也可以额外传入一个参数作为默认的 value。该方法一般不会使用字典对象调用（没什么意义），
通常会使用 dict 类直接调用。例如如下代码：

 使用列表创建包含2个key的字典
2 a_dict = dict.fromkeys([abprint(a_dict)  {'a': None,'b': None}
 使用元组创建包含2个key的字典
5 b_dict = dict.fromkeys((13,17))
print(b_dict)  {13: None,17: None}
 使用元组创建包含2个key的字典，指定默认的value
8 c_dict = dict.fromkeys((13,17),1)">9 print(c_dict)  {13: 'good',17: 'good'}

使用字典格式化字符串
前面章节介绍过，在格式化字符串时，如果要格式化的字符串模板中包含多个变量，
后面就需要按顺序给出多个变量，这种方式对于字符串模板中包含少量变量的情形是合适的，
但如果字符串模板中包含大量变量，这种按顺序提供变量的方式则有些不合适。
可改为在字符串模板中按 key 指定变量，然后通过字典为字符串模板中的 key 设置值。

例如如下程序：

 字符串模板中使用key
2 temp = 教程是:%(name)s,价格是:%(price)010.2f,出版社是:%(publish)s'
3 book = {name':Python基础教程price': 99,1)">publish': C语言中文网 使用字典为字符串模板中的key传入值
print(temp % book)
6 book = {C语言小白变怪兽':159,1)">print(temp % book)

输出：

教程是:Python基础教程,价格是:0000099.00Tomorrow?the birds will sing.
                        
（编辑：北几岛）
【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!