Python基础(四) — 数据结构

目录

1. 列表（list）
2. 元祖（tuple）
3. 字典（dict）
4. 集合（set）
5. 高级特性
   
   1. 序列
   2. 切片
   3. 列表生成器List Comprehensions
   4. 生成器
   5. 迭代器

---

列表（list）

list是一种 有序 的集合，可以随时添加和删除其中的元素；同时，list里面的元素的 数据类型 也可以不同。

1. list的声明

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

2. 添加元素

    #向末尾添加元素
   classmates.append('Adam')
    #向指定的索引位添加元素
   classmates.insert(1, 'Jack')

3. 移除元素

    # 将list中的末尾元素移除
   classmates.pop()
   
    # 将list中指定的索引位元素移除
   classmates.pop(1)

4. 获取元素

    # 获取list中指定索引的元素
   classmates[i]
   
    # 反向获取元素（如果要取最后一个元素，可以用-1做索引）
   classmates[-i]

5. 替换指定索引位的元素

   classmates[1] = 'Sarah'

6. 获取list 元素个数

   list_len = len(classmates)

---

元祖（tuple）

1. 特性

   1. tuple 是 有序 列表，类似list；
   2. tuple 一旦初始化就不能修改；
   3. tuple 不可变，在定义时，元素就必须被确定下来，所以没有append(), insert()方法；
   4. 元素不能再赋值，即classmates_tuple[1] = 'Sarah'不可行；

2. 元祖的声明

    # 注意：如果元祖只有1个元素，则第一个元素后面必须加一个逗号，来消除歧义；否则，会误解成数学计算意义上的括号
   classmates_tuple = (a, )
   classmates_tuple = (a, b, c)

3. 元素的获取

    # 获取tuple中指定索引的元素
   classmates_tuple[i]
   
    # 反向获取元素（如果要取最后一个元素，可以用-1做索引）
   classmates_tuple[-i]

4. 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不存在的错误，有两种办法：

1. 通过 in 判断 key 是否存在：

   dict = {
       'key1' : 'value1',
       'key2' : 'value2'
   }
   print('key1' in dict) #True

2. 通过 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

1. 特性

   1. set 和 dict 类似，是一组 key 的集合，但不存储 value；
   2. key 不能重复；

2. set 声明

   list = [1, 2, 3]
   set = set(list) #set([1, 2, 3])

   注意： 参数传入 list；

3. 添加元素add(key)

   set = set([1, 2, 3])
   set.add(4) #set([1, 2, 3, 4])

4. 移除元素remove(key)

   set = set([1, 2, 3])
   set.remove(3) #set([1, 2])

5. 两个set之间的操作（交集、并集等）

   set1 = set([1, 2, 3])
   set2 = set([2, 3, 4])
    # 交集
   print(set1 & set2) #{2, 3}
    # 并集
   print(set1 | set2) #{1, 2, 3, 4}

6. set & dict

   异：
   set 没有 value ，而 dict 又对应的 value；
   同：
   key 不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”；

---

高级特性

1. 序列

序列： 特点是可以索引，可以切片操作；

1. 哪些属于序列

   1. 列表
   2. 元组
   3. 字符串

2. 如何判断一个对象是都是可迭代的？

   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

3. 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的方法：

1. 方法一： 把一个列表生成式的 [] 改成 () ，就创建了一个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>

2. 方法二： 如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator；

5. 迭代器 Iterable

迭代器：可以被next()函数调用并不断返回下一个值的对象称为迭代器Iterator；
生成器：既可以作用于for循环，还可以被next()函数调用，而作用于for循环的都是可迭代的对象Iterable；

1. 判断一个对象是否是迭代器?

   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 function	True	True

   生成器都是 Iterator 对象，但list、dict、str虽然是 Iterable，却不是 Iterator。

2. 如何转换成一个迭代器？

    # 使用 iter() 函数把list、dict、str 等 Iterable 变成 Iterator;
   flag1 = isinstance(iter([]), Iterator)
   print(flag1) #True
   
   flag2 = isinstance(iter('abc'), Iterator)
   print(falg2) #True