python 列表，元组，字典，set(5)

list

Python 内置的一种数据类型是列表：list。list 是一种有序的集合，可以

随时添加和删除其中的元素

如： 

  classmates = ['Michael', 'Bob', 'Tracy']

 len(classmates) 计算个数

 

访问

>>> classmates[0]

'Michael'

>>> classmates[1]

'Bob'

>>> classmates[2]

'Tracy

 

还可以用 -1 做索引，直

接获取最后一个元素：

>>> classmates[-1]

'Tracy'

 

当索引超出了范围时，Python 会报一个 IndexError 错误，所以，要确保

索引不要越界，记得最后一个元素的索引是 len(classmates) - 1 。

 

添加

 1 classmates.append('Adam')

>>> classmates

['Michael', 'Bob', 'Tracy', 'Adam']

append  往 list 中追加元素到末尾

 

2 classmates.insert(1, 'Jack')

>>> classmates

['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

 

Insert 把元素插入到指定的位置，比如索引号为 1 的位置

 

删除

 1 classmates.pop()

'Adam'

>>> classmates

['Michael', 'Jack', 'Bob', 'Tracy']

 

 pop ()删除 list 末尾的元素  删除指定位置的元素，用 pop(i) 方法，其中 i 是索引位置

 

 

修改

 classmates[1] = 'Sarah'

>>> classmates

['Michael', 'Sarah', 'Tracy']

 

 

list 里面的元素的数据类型也可以不同，比如：

>>> L = ['Apple', 123, True]

 

list 元素也可以是另一个 list，比如：

>>> s = ['python', 'java', ['asp', 'php'], 'scheme']

获取的方式  s[2][1]

 

 

Python列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

如下所示：

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print x,	1 2 3	迭代

 

Python列表截取与拼接

Python的列表截取与字符串操作类型，如下所示：

L=['Google', 'Runoob', 'Taobao']

操作：

Python 表达式	结果	描述
L[2]	'Taobao'	读取第三个元素
L[-2]	'Runoob'	从右侧开始读取倒数第二个元素: count from the right
L[1:]	['Runoob', 'Taobao']	输出从第二个元素开始后的所有元素

 

Python列表函数&方法

Python包含以下函数:

序号	函数
1	len(list) 列表元素个数
2	max(list) 返回列表元素最大值
3	min(list) 返回列表元素最小值
4	list(seq) 将元组转换为列表

Python包含以下方法:

序号	方法
1	list.append(obj) 在列表末尾添加新的对象
2	list.count(obj) 统计某个元素在列表中出现的次数
3	list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj) 将对象插入列表
6	list.pop(obj=list[-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj) 移除列表中某个值的第一个匹配项
8	list.reverse() 反向列表中元素
9	list.sort([func]) 对原列表进行排序
10	list.clear() 清空列表
11	list.copy() 复制列表

 

 

 

 

tuple

另一种有序列表叫元组：tuple。tuple 和 list 非常类似，但是 tuple 一旦

初始化就不能修改，

如：

tup1 = ('Google', 'Runoob', 1997, 2000);

创建空元组

tup1 = ();

元组中只包含一个元素时，需要在元素后面添加逗号

tup1 = (50,);

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

访问元组

tup1 = ('Google', 'Runoob', 1997, 2000)

tup2 = (1, 2, 3, 4, 5, 6, 7 )

print ("tup1[0]: ", tup1[0])print ("tup2[1:5]: ", tup2[1:5])

以上实例输出结果：

tup1[0]:  Google

tup2[1:5]:  (2, 3, 4, 5)

修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

#!/usr/bin/python3

 

tup1 = (12, 34.56);

tup2 = ('abc', 'xyz')

# 以下修改元组元素操作是非法的。# tup1[0] = 100

# 创建一个新的元组

tup3 = tup1 + tup2;print (tup3)

以上实例输出结果：

(12, 34.56, 'abc', 'xyz')

 

删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

#!/usr/bin/python3

 

tup = ('Google', 'Runoob', 1997, 2000)

print (tup)

del tup;

print ("删除后的元组 tup : ")print (tup)

以上实例元组被删除后，输出变量会有异常信息，输出如下所示：

删除后的元组 tup : Traceback (most recent call last):

  File "test.py", line 8, in 

    print (tup)NameError: name 'tup' is not defined

 

元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print x,	1 2 3	迭代

 

元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：

元组：

L = ('Google', 'Taobao', 'Runoob')

Python 表达式	结果	描述
L[2]	'Runoob!'	读取第三个元素
L[-2]	'Taobao'	反向读取；读取倒数第二个元素
L[1:]	('Taobao', 'Runoob!')	截取元素，从第二个开始后的所有元素。

运行实例如下：

>>> L = ('Google', 'Taobao', 'Runoob')>>> L[2]'Runoob'>>> L[-2]'Taobao'>>> L[1:]('Taobao', 'Runoob')

 

元组内置函数

Python元组包含了以下内置函数

序号	方法及描述	实例
1	len(tuple) 计算元组元素个数。	>>> tuple1 = ('Google', 'Runoob', 'Taobao')>>> len(tuple1)3>>>
2	max(tuple) 返回元组中元素最大值。	>>> tuple2 = ('5', '4', '8')>>> max(tuple2)'8'>>>
3	min(tuple) 返回元组中元素最小值。	>>> tuple2 = ('5', '4', '8')>>> min(tuple2)'4'>>>
4	tuple(seq) 将列表转换为元组。	>>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu']>>> tuple1=tuple(list1)>>> tuple1('Google', 'Taobao', 'Runoob', 'Baidu')

 

Python list和tuple的相互转换

List转为tuple：

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

将temp_list进行强制转换：tuple(temp_list)

查看是否转换成功：print type(temp_list)

 

tuple 转为list：

temp_tuple = (1,2,3)

方法类似，也是进行强制转换即可：list(temp_tuple)

查看是否转换成功：print type(temp_tuple)

 list 特点

 

1. 查找和插入的时间随着元素的增加而增加；

2. 占用空间小，浪费内存很少

 

 

 

List  和tuple 区别

   不同点：

             1 定义的方式

                 list[]     tuple()

             2 是否可变

                list可变   tuple() 不可变

             3 list中有 append()，insert() 函数，tuple中没有

相同点：

      都是有序的集合

 

 

 

 

 

dict

Python 内置了字典：dict 的支持，dict 全称 dictionary，在其他语言中也

称为 map，使用键-值（key-value）存储，具有极快的查找速度

如：

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}

>>> d['Michael']

95

 

 

赋值

一个 key 只能对应一个 value，所以，多次对一个 key 放入 value，

后面的值会把前面的值冲掉

 

获取

如果 key 不存在，dict 就会报错避免 key 不存在的错误，有两种办法

1 'Thomas' in d

  False

2 通过 dict 提供的 get 方法，如果 key 不存在，可以返回 None，或者

自己指定的 value：

>>> d.get('Thomas')

>>> d.get('Thomas', -1)

-1

 

添加

d[‘test’] =’adfds’

 

 

删除

删除一个 key，用 pop(key) 方法，对应的 value 也会从 dict 中删除：

>>> d.pop('Bob')

75

>>> d

{'Michael': 95, 'Tracy': 85}

注意，dict 内部存放的顺序和 key 放入的顺序是没有关系的

 

 

遍历字典方式

1 for key in user.keys():

print("key:",key)

print("value:",user[key])

 

2

for key,value in user.items():

print(key,value)

 

 

字典内置函数&方法

Python字典包含了以下内置函数：

序号	函数及描述	实例
1	len(dict) 计算字典元素个数，即键的总数。	>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}>>> len(dict)3
2	str(dict) 输出字典，以可打印的字符串表示。	>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}>>> str(dict)"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"
3	type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。	>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}>>> type(dict)<class 'dict'>

Python字典包含了以下内置方法：

序号	函数及描述
1	radiansdict.clear() 删除字典内所有元素
2	radiansdict.copy() 返回一个字典的浅复制
3	radiansdict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4	radiansdict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
5	key in dict 如果键在字典dict里返回true，否则返回false
6	radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组
7	radiansdict.keys() 以列表返回一个字典所有的键
8	radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里
10	radiansdict.values() 以列表返回字典中的所有值
11	pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
12	popitem() 随机返回并删除字典中的一对键和值。

 

 

 

 

 key 必须是 不可变对象？ str number 元组

这是因为 dict 根据 key 来计算 value 的存储位置，如果每次计算相同的

key 得出的结果不同，那 dict 内部就完全混乱了。这个通过 key 计算位

置的算法称为哈希算法（Hash）。要保证 hash 的正确性，作为 key 的对象就不能变。在 Python 中，字符串、整数等都是不可变的，因此，可以放心地作为 key。而 list 是可变

的，就不能作为 key

 

 

 

 

Dict特点：

 

1：查找和插入的速度极快，不会随着 key 的增加而增加

 

2：浪费空间

 

3：key不可以重复，且不可变

 

4：数据无序排放

 

 

 

 

 

set

set 和 dict 类似，也是一组 key 的集合，但不存储 value。由于 key 不能

重复，所以，在 set 中，没有重复的 key。

 

创建一个 set，需要提供一个 list 作为输入集合：

>>> s = set([1, 2, 3])

>>> s

{1, 2, 3}

重复元素在 set 中自动被过滤

 

 

添加

  通过 add(key) 方法可以添加元素到 set 中

   >>> s.add(4)

>>> s

{1, 2, 3, 4}

删除

 remove(key) 方法可以删除元素

 

两个 set 可以做数学意义上的交集、并集等操作：

>>> s1 = set([1, 2, 3])

>>> s2 = set([2, 3, 4])

>>> s1 & s2

{2, 3}

>>> s1 | s2

{1, 2, 3, 4}

set 和dict区别

set 和 dict 的唯一区别仅在于没有存储对应的 value，但是，set 的原理和

dict 一样，所以，同样不可以放入可变对象，因为无法判断两个可变对

象是否相等，也就无法保证 set 内部“不会有重复元素”。

 

 

总结

list:列表,有序的项目, 通过索引进行查找,使用方括号”[]”;

tuple:元组,元组将多样的对象集合到一起,不能修改,通过索引进行查找, 使用括号”()”;

dict:字典,字典是一组键(key)和值(value)的组合,通过键(key)进行查找,没有顺序, 使用大括号”{}”;

set:集合,无序,元素只出现一次, 自动去重,使用”set([])”

dict的创建、访问时间一定是大于tuple的,但是在python中，dict是做过极度优化的，其效率已经非常高了所以在实际编程中，一般我们只根据实际需求来考虑使用什么数据结构 (dict, list, set, tuple)，而不是根据不同数据结构的访问速度差别。

 

应用场景:

list, 简单的数据集合,可以使用索引;

tuple, 把一些数据当做一个整体去使用,不能修改;

dict,使用键值和值进行关联的数据;

set,数据只出现一次,只关心数据是否出现, 不关心其位置;