目录
- 列表(list)
- 元祖(tuple)
- 字典(dict)
- 集合(set)
- 高级特性
- 序列
- 切片
- 列表生成器
List Comprehensions
- 生成器
- 迭代器
列表(list)
list
是一种 有序 的集合,可以随时添加和删除其中的元素;同时,list
里面的元素的 数据类型 也可以不同。
list
的声明classmates = [] classmates = ['Michael', 'Bob', 'Tracy']
添加元素
#向末尾添加元素 classmates.append('Adam') #向指定的索引位添加元素 classmates.insert(1, 'Jack')
移除元素
# 将list中的末尾元素移除 classmates.pop() # 将list中指定的索引位元素移除 classmates.pop(1)
获取元素
# 获取list中指定索引的元素 classmates[i] # 反向获取元素(如果要取最后一个元素,可以用-1做索引) classmates[-i]
替换指定索引位的元素
classmates[1] = 'Sarah'
获取
list
元素个数list_len = len(classmates)
元祖(tuple)
特性
tuple
是 有序 列表,类似list
;tuple
一旦初始化就不能修改;tuple
不可变,在定义时,元素就必须被确定下来,所以没有append()
,insert()
方法;- 元素不能再赋值,即
classmates_tuple[1] = 'Sarah'
不可行;
元祖的声明
# 注意:如果元祖只有1个元素,则第一个元素后面必须加一个逗号,来消除歧义;否则,会误解成数学计算意义上的括号 classmates_tuple = (a, ) classmates_tuple = (a, b, c)
元素的获取
# 获取tuple中指定索引的元素 classmates_tuple[i] # 反向获取元素(如果要取最后一个元素,可以用-1做索引) classmates_tuple[-i]
tuple不可变的意义?
因为tuple不可变,所以代码更安全。如果可能,能用tuple代替list就尽量用tuple。
字典(dict)
dict
字典(Java中为Map),使用键-值对(key-value)存储,查找速度快;
1. 使用pop(key)
移除字典中的元素
dict = {
'key1' : 'value1',
'key2' : 'value2'
}
dict.pop('key1')
2. 判断 dict
中是否存在指定的元素
如果 key 不存在, dict
就会报错,要避免key不存在的错误,有两种办法:
通过
in
判断key
是否存在:dict = { 'key1' : 'value1', 'key2' : 'value2' } print('key1' in dict) #True
通过
dict
提供的get()
方法,如果key不存在,可以返回None,或者自己指定的value:dict = { 'key1' : 'value1', 'key2' : 'value2' } print(dict.get('key1')) #value1 print(dict.get('key3') print(dict.get('key3', -1) #-1
注意: 返回None的时候Python的交互式命令行不显示结果。
3. dict
VS list
比较
名称 | dict | list |
---|---|---|
查找速度 | 快 | 慢 |
插入速度 | 快 | 慢 |
内存占用 | 大 | 小 |
小结:dict
是用空间来换取时间的一种方法
集合Set
特性
set
和dict
类似,是一组key
的集合,但不存储value
;key
不能重复;
set
声明list = [1, 2, 3] set = set(list) #set([1, 2, 3])
注意: 参数传入
list
;添加元素
add(key)
set = set([1, 2, 3]) set.add(4) #set([1, 2, 3, 4])
移除元素
remove(key)
set = set([1, 2, 3]) set.remove(3) #set([1, 2])
两个set之间的操作(交集、并集等)
set1 = set([1, 2, 3]) set2 = set([2, 3, 4]) # 交集 print(set1 & set2) #{2, 3} # 并集 print(set1 | set2) #{1, 2, 3, 4}
set
&dict
异:
set
没有value
,而dict
又对应的value
;
同:
key
不可以放入可变对象,因为无法判断两个可变对象是否相等,也就无法保证set内部“不会有重复元素”;
高级特性
1. 序列
序列: 特点是可以索引,可以切片操作;
哪些属于序列
- 列表
- 元组
- 字符串
如何判断一个对象是都是可迭代的?
from collections import Iterable #1. str是否可迭代 flag1 = isinstance('abc', Iterable) print(flag1) # True #2. list是否可迭代 flag2 = isinstance([1,2,3], Iterable) print(flag2) # True #3. tuple是否可迭代 flag3 = isinstance((1,2,3), Iterable) print(flag3) # True #4. 整数是否可迭代 flag4 = isinstance(123, Iterable) print(flag4) # False
list
如何实现实现Java一样的fori
迭代#使用 enumerate 函数 for index, value in enumerate(['a','b','c']): print('index: %d, value: %s' % (index, value))
输出:
index: 0, value: a
index: 1, value: b
index: 2, value: c
2. 切片(list
、tuple
、字符串)
# =========== list =============
# 先创建一个0-99的数列:
L = range(100)
print(L) #[0, 1, 2, 3, ..., 99]
L[:10] # 取前10个数
L[-10:] # 后10个数
L[10:20] # 前11-20个数
L[:10:2] # 前10个数,每两个取一个
L[::5] # 所有数,每5个取一个
L[:] # 原样复制一个list
# =========== tuple =============
# tuple也是一种list,tuple用切片操作,结果仍是tuple:
tuple = (0, 1, 2, 3, 4, 5)[:3]
print(tuple) #(0, 1, 2)
# =========== 字符串 =============
# 字符串切片操作,结果仍是字符串(类似Java中的String截取操作):
print('ABCDEFG'[:3]) #'ABC'
print('ABCDEFG'[::2]) #ACEG
3. 列表生成器List Comprehensions
单个变量:
li = list(range(1, 11))
print(li) #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#需求1:生成[1x1, 2x2, 3x3, ..., 10x10]的一个list
li = [x * x for x in range(1, 11)]
print(li) #[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
#需求2:过滤列表中的奇数
li = [x * x for x in range(1, 11) if x % 2 == 0]
print(li) #[4, 16, 36, 64, 100]
#需求3:嵌套for循环
li = [m + n for m in 'ABC' for n in 'XYZ']
print(li) #['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
多个变量:(字典)
# dict.items()可以同时迭代key和value;
dict = {'x': 'A', 'y': 'B', 'z': 'C' }
for key, value in dict.items():
print(key, '=', value)
#使用列表生成器
dict = {'x': 'A', 'y': 'B', 'z': 'C' }
li = [k + '=' + v for k, v in d.items()]
print(li)
输出:
y = B
x = A
z = C
4. 生成器
在Python中,一边循环一边计算的机制,称为生成器:generator。
创建一个generator的方法:
方法一: 把一个列表生成式的 [] 改成 () ,就创建了一个generator;
L = [x * x for x in range(10)] print (L) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] g = (x * x for x in range(10)) print (g) #<generator object <genexpr> at 0x10a3646d0>
方法二: 如果一个函数定义中包含yield关键字,那么这个函数就不再是一个普通函数,而是一个generator;
5. 迭代器 Iterable
迭代器:可以被next()
函数调用并不断返回下一个值的对象称为迭代器Iterator
;
生成器:既可以作用于for循环,还可以被next()函数调用,而作用于for循环的都是可迭代的对象Iterable
;
判断一个对象是否是迭代器?
from collections import Iterator flag1 = isinstance((x for x in range(10)), Iterator) print(flag1) #True flag1 = isinstance([], Iterator) print(flag1) #False flag1 = isinstance({}, Iterator) print(flag1) #False flag1 = isinstance('abc', Iterator) print(flag1) #False
结论:
名称 Iterable Iterator list True False dict True False str True False set True False generator生成器 True True 带 yield
的generator functionTrue True 生成器都是
Iterator
对象,但list
、dict
、str
虽然是Iterable
,却不是Iterator
。如何转换成一个迭代器?
# 使用 iter() 函数把list、dict、str 等 Iterable 变成 Iterator; flag1 = isinstance(iter([]), Iterator) print(flag1) #True flag2 = isinstance(iter('abc'), Iterator) print(falg2) #True