Python第三节容器

Python中所有的东西 都是类！

Python 更强调的是应用是否一致，鸭子类型—是基于接口的，而不是有明确的继承关系的。区别于 Java的继承关系————在迭代器 一部分展现的特别好. 关于作业 ：翻转一个字符：

def reverse(str_list, start, end):
while( start < end ):
str_list[start],str_list[end] = str_list[end],str_list[start]
start += 1
end -= 1
setence = ‘Hello, how are you? Fine. ‘
str_list = list(setence)
i = 0
while i < len(str_list):
if str_list[i] != ‘ ‘: #即不是空格
start = i
end = start + 1
while ( end < len(str_list) ) and str_list[end] != ‘ ‘:
end += 1
reverse(str_list, start, end-1)
i = end
else:
i+=1
str_list.reverse()
print(“”.join(str_list))

字符串反转——先进行正向的每个word的翻转—再进行整个str_list的反转—最后把list

                                            # list join 为string

第三节

—-本节要点：

• 容器
• list/tuple
• dict
• set
• 切片
• 列表推导
• 生成器
• 迭代器

—-list 列表 序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。列表的数据项不需要具有相同的类型

• tuple 元组（只读列表,不能写）

li = [1, 2, 3, ‘456’, [1, 2, 3], {1: ‘one’, 2: ‘two’}] #这个是list元素中的
print(type(list))
print(type(li))
# 元素访问
print(li[0])
print(li[-1]) # li[len(li) - 1]
print(li[-2]) # li[len(li) - 2]
# 查找元素位置
print(li.index(‘456’))
print(li.index([1, 2, 3]))
# print(li.index(-1)) #会返回错误 不存在 -1，所以此时最好用 try catch 抛出异常尝试下.
# 添加元素
l_a = [1, 2, 3]
l_a.append(4)
l_a.append(5)
l_b = [6, 7, 8]
l_a.extend(l_b) # 试下用append是什么结果
print(l_a)
l_a = []
if not l_a:
print(‘Empty’) # not XX和is None不是一回事 所以应该为空 == False这样判断才对。
if len(l_a) == 0:
print(‘Empty’)
for i in li:
print(i)
for i in range(len(li)):
print(li[i])
t = (1, 2, 3, ‘456’)
print(type(t))
# t[0] = ‘a’ #tuple元组 只读 不可改变！
# t.append(‘x’)
del(li[-1]) # del(list[index])
del(li[1])
del(li[-2])
print(li)

• dict 字典 （key/value）
• 字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中。
• set 集合
• 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算。

---容器 - list/tuple基本操作

• 创建
• 添加元素（list only）：append, extend
• 删除元素（list only）：del, pop
• 根据索引读写（tuple只读）
• 判断容器是否为空
• 字符串转换
• 容器元素数量
• 遍历
• 参考代码：lesson_03_list_tuple.py 见上方

---容器 - dict基本操作

• 初始化
• 访问
• 添加元素
• 修改元素
• 删除元素
• 判断key是否存在
• 判断容器是否为空
• 容器元素数量
• 遍历
• 参考代码：lesson_03_dict.py

d = {‘a’: 1, ‘b’: 2, 1: ‘one’, 2: ‘two’, 3: [1, 2, 3]}
print(type(dict))
print(type(d))
print(d)
# 访问元素
print(d[‘a’])
print(d[1])
print(d[3])
# 判断key是否存在
print(‘two’ in d)
print(3 in d)
del(d[3]) # del(dict[key])
print(len(d))
d[3] = [1, 2, 3, 4] #相当于添加了一项，所以dict里面是无序的
d[3] = ‘1234’
# 遍历
for key in d:
print(d[key])
print(‘…’)
for k, v in d.items():
print(k, v)
print(‘…’)
keys = d.keys()
print(type(keys))
print(keys)

—-set 集合基本操作：

• 并/交/差集：|/union, &/intersection, -/difference
• 对称差集：^/symmetric_difference（不同时出现在2个集合中的项）
• 包含关系：>=/issuperset
• 添加元素
• 更新元素
• 删除元素
• 元素是否存在
• 容器元素数量
• 遍历
• 参考代码：lesson_04_set.py

s_a = set([1, 2, 2, 3, 4, 5, 6])
s_b = set([4, 5, 6, 7, 8, 9])
print(s_a)
print(s_b)
# 判断元素是否存在
print(5 in s_a)
print(10 in s_b)
# 并集
print(s_a | s_b)
print(s_a.union(s_b))
# 交集
print(s_a & s_b)
print(s_a.intersection(s_b))
# 差集 A - (A & B)
print(s_a - s_b)
print(s_a.difference(s_b))
# 对称差 (A | B) - (A & B)
print(s_a ^ s_b)
print(s_a.symmetric_difference(s_b))
# 修改元素
s_a.add(‘x’)
s_a.update([4, 5, 60, 70])
print(s_a)
s_a.remove(70)
print(s_a)
# s_a.remove(100)
print(len(s_a))
for i in s_a:
print(i)
testSet = {-1 , 1}
print(testSet)
print(type(testSet))
—-结果—-
{1, 2, 3, 4, 5, 6, 7, 8, 9}
{1, 2, 3, 4, 5, 6, 7, 8, 9}
{4, 5, 6}
{4, 5, 6}
{1, 2, 3}
{1, 2, 3}
{1, 2, 3, 7, 8, 9}
{1, 2, 3, 7, 8, 9}
{1, 2, 3, 4, 5, 6, 70, ‘x’, 60}
{1, 2, 3, 4, 5, 6, ‘x’, 60}
8
1
2
3
4
5
6
x
60
{1, -1}

—-切片

• 存取序列（列表，元组，字符串）的任意一部分
• 格式：seq[开始索引:结束索引:步长]
• 默认值
• 负数索引
• 负数步长
• 参考代码：lesson_03_slice.py

大杀器 —— 关于 容器的切片

print(“””—-容器的 切片开始—-“””)
li = list(range(10))
print(li)
# 切片 [start:end:steps] >= start & < end
print(li[2:5]) # [2, 3, 4]
print(li[:4]) # [0, 1, 2, 3]
print(li[5:]) # [5, 6, 7, 8, 9]
print(li[0:20:3]) # [0, 3, 6, 9] 即超出索引大小，仍然按照自己的索引大小进行操作.
# 负值怎么处理？
print(li[5: -2]) # [5, 6, 7] <8 注意是不等号="" print(li\[9:0:-1\])="" #="" \[9,="" 8,="" 7,="" 6,="" 5,="" 4,="" 3,="" 2,1\]="" -1即="" <="9" and=""> 0
print(li[9::-1]) # [9 … 0]
print(li[::-2]) # [9, 7, 5, 3, 1]
# 切片生成一个新的对象
print(li) # 还是保持原样 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
re_li = li[::-1]
print(re_li) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

—-列表推导

• 问题的提出
• 快速简单的生成一个列表
• 对原有的列表进行简单的转换
• 一维列表推导
• 二维列表推导以及注意事项
• 参考代码：lesson_03_comprehensions.py

列表推导

print(“\\n—-列表推导—-“)
li = []
for i in range(20):
if (i % 2) == 0:
li.append(i)
print(li)
li = [1] 10 #区别于一维，一维这样是深拷贝
li[3] = 3
print(li) #[1, 1, 1, 3, 1, 1, 1, 1, 1, 1]
li = [i 2 for i in range(10)]
print(li)
‘’’
li_2d = [[0] 3] 3 #因为这里 把第一行改变了三次，所以只是浅拷贝了，第一个改其他两个也都跟着要改！
print(li_2d)
li_2d[0][0] = 100 #所以下面未注释的 为深拷贝
print(li_2d)
‘’’
li_2d = [[0] * 3 for i in range(3)]
li_2d[0][0] = 100
print(li_2d) #[[100, 0, 0], [0, 0, 0], [0, 0, 0]]
s = {x for x in range(10) if x % 2 == 0}
print(s) #{0, 2, 4, 6, 8}
d = {x: x % 2 == 0 for x in range(10)}
print(d) #{0: True, 1: False, 2: True, 3: False, 4: True,

       #5: False, 6: True, 7: False, 8: True, 9: False}

—-生成器

• 问题的提出
• 创建一个巨大的列表而仅仅需要访问其中少量几个元素
• 如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。
• 生成生成器：列表推导时用()替换[]（关于yield的使用后面再讲）
• 遍历：next或者for循环
• 参考代码：lesson_03_generator.py

# 平方表
print(“””—-平方表开始—-“””)
square_table = []
for i in range(5000): #计算太慢
square_table.append(i i)
for i in range(5):
print(square_table[i])
square_generator = (x x for x in range(50000))
print(type(square_generator))
for i in range(5): #当你真正的使用的时候生成器才进行计算.
print(next(square_generator))
def fib(limit):
n, a, b = 0, 0, 1
while n < limit:
yield b #python yield有关于线程.
a, b = b, a + b
n += 1
return ‘done’
import traceback
f = fib(5)
print(type(f))
print(next(f))
print(next(f))
print(next(f))
print(next(f))
print(next(f))
try:
print(next(f))
except StopIteration:
traceback.print_exc()
for i in fib(5):
print(i)

—-迭代器

• 问题的提出
• 可以直接作用于for循环的对象统称为可迭代对象：Iterable
• 可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator（表示一个惰性计算的序列）
• 集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
• 参考代码：lesson_03_iter.py

print(‘’’迭代器’’’)
from collections import Iterable
from collections import Iterator
print(isinstance([1, 2, 3], Iterable))
print(isinstance({}, Iterable))
print(isinstance(123, Iterable))
print(isinstance(‘abc’, Iterable)) # 1可迭代的可以在for中使用.但不是迭代器
print(isinstance([1, 2, 3], Iterator)) # 2迭代器 可以用next()——》可以惰性计算
g = (x * x for x in range(10))
print(type(g))
print(isinstance(g, Iterable))
print(isinstance(g, Iterator))
for i in g:
print(i)
def fib(limit): #1和2 区别是否可以进行惰性计算，只有2可以所以是迭代器.
n, a, b = 0, 0, 1 #Pyhon
while n < limit:
yield b
a, b = b, a + b
n += 1
return ‘done’
f = fib(6)
print(type(f))
print(isinstance(f, Iterable))
print(isinstance(f, Iterator))
for i in f:
print(i)