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 <module>
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() |
|
4 |
radiansdict.get(key, default=None) |
|
5 |
key in dict |
|
6 |
radiansdict.items() |
|
7 |
radiansdict.keys() |
|
8 |
radiansdict.setdefault(key, default=None) |
|
9 |
radiansdict.update(dict2) |
|
10 |
radiansdict.values() |
|
11 |
pop(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,使用键值和值进行关联的数据; key value
set,数据只出现一次,只关心数据是否出现, 不关心其位置;