生成器 和推导列表定义类似，但是使用()定义，而不是使用[] 使用方式1：用括号定义 next(g)访问元素
g = (x*x for x in range(10))
next(g)
next(g) 1
next(g) 4
next(g) 9
next(g) 16
next(g) 25
next(g) 36
next(g) 49
next(g) 64
next(g) 81
next(g) Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration
遍历生成器
g = (x**2 for x in range(5)) for v in g: ... print(v) ... 01 4 9 16
习题3：用生成器生成10以内的奇数
g = (x for x in range(1,10,2)) for n in g: ... print(n) ... 1 3 5 7 9
使用方式2：用yield定义
def odd(): print ('step 1') yield 1 print ('step 2') yield 3 print ('step 3') yield 5 o = odd() print (next(o)) print (next(o)) print (next(o)) print (next(o))
#for i in o:
print i
def g(): print("a") yield 1 print("b") yield 2 print("c") yield 3 print("d")
g = g() for i in g: print(i)
深、浅拷贝
import copy lst_1 = [1,2,3,["a","b"]] lst_2 = copy.copy(lst_1) lst_3 = copy.deepcopy(lst_1)
lst_1.append(4) lst_1[3].append("c")
print(lst_1) print(lst_2) print(lst_3)
直接赋值、浅拷贝和深度拷贝解析 直接赋值：其实就是对象的引用（别名）。 浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。 深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。 字典浅拷贝实例 实例1：
a = {1: [1,2,3]} b = a.copy() a, b ({1: [1, 2, 3]}, {1: [1, 2, 3]})
a[1].append(4) a, b ({1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]}) 深度拷贝需要引入 copy 模块：
实例
import copy c = copy.deepcopy(a) a, c ({1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]})
a[1].append(5) a, c ({1: [1, 2, 3, 4, 5]}, {1: [1, 2, 3, 4]}) 解析 1、b = a: 赋值引用，a 和 b 都指向同一个对象。
2、b = a.copy(): 浅拷贝, a 和 b 是一个独立的对象，但他们的子对象还是指向统一对象（是引用）。
3、b = copy.deepcopy(a): 深度拷贝, a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。
实例2： 列表的深浅拷贝 以下实例是使用 copy 模块的 copy.copy（ 浅拷贝 ）和（copy.deepcopy ）:
实例
#!/usr/bin/python # -*-coding:utf-8 -*- import copy
a = [1, 2, 3, 4, ['a', 'b']] #原始对象
b = a #赋值，传对象的引用
c = copy.copy(a) #对象拷贝，浅拷贝
d = copy.deepcopy(a) #对象拷贝，深拷贝
a.append(5) #修改对象a
a[4].append('c') #修改对象a中的['a', 'b']数组对象
print( 'a = ', a )
print( 'b = ', b )
print( 'c = ', c )
print( 'd = ', d )
以上实例执行输出结果为：
('a = ', [1, 2, 3, 4, ['a', 'b', 'c'], 5])
('b = ', [1, 2, 3, 4, ['a', 'b', 'c'], 5])#因为b和a指向同一个内存地址，是同一个对象，对a的任何改动都会影响到b
('c = ', [1, 2, 3, 4, ['a', 'b', 'c']])#c是浅拷贝，只影响对子对象元素的修改，其他元素是独立的
('d = ', [1, 2, 3, 4, ['a', 'b']])#每个元素都是独立的，修改互不影响
通过list实现一个简单的堆栈
#encoding=utf-8
stack_list = []
stack_list.append(1)
print(stack_list)
stack_list.append(2)
print(stack_list)
stack_list.append(3)
print(stack_list)
print(stack_list)
print(stack_list.pop())
print(stack_list)
print(stack_list.pop())
print(stack_list)
print(stack_list.pop())
print('*'*30)
for i in range(1,6):
stack_list.append(i)
print(stack_list)
for i in range(5):
stack_list.pop()
print(stack_list)
通过list实现一个简单的队列
#encoding=utf-8
stack_list = []
for i in range(5):
stack_list.append(i)
print(stack_list)
for j in range(5):
print(stack_list)
print(stack_list.pop(0))
from collections import deque
queue = deque([1,2,3,4,5,6])
queue.append(7)
queue.append(8)
print(queue.popleft())
print(queue.popleft())
print(queue)
元组 元素只能访问其元素，不能进行修改、删除，适用元素固定的情况
创建元组 创建空元组
t = ()
创建只有一个元素的元组
t = (1,)
t = 2,3 t (2, 3) 访问元组元素 元组属于序列，可通过下标访问元素
t = (1,2,3,4,5) t[0] 1
t[3] 4
通过切片访问元组
t[:] (1, 2, 3, 4, 5)
t[-1] 5
t[:3] (1, 2, 3)
t[:3:2] (1, 3)
t[::-1] (5, 4, 3, 2, 1)
t[-3:-1:-1] ()
t[-3:-1:1] (3, 4)
倒序start 要大于end
t[-1:-3:-1] (5, 4)
t[-1:-4:-1] (5, 4, 3)
t (1, 2, 3, 4, 5)
for i in range(len(t)-1,-1,-1):#倒序遍历start要大于end，因为要全部取end =-1 ... print(t[i]) ... 5 4 3 2 1
连接元组 +
t (1, 2, 3, 4, 5)
t2 = ("a","b") t + t2 (1, 2, 3, 4, 5, 'a', 'b')
复制元组 *
t2 * 3 ('a', 'b', 'a', 'b', 'a', 'b')
查看元组类型
type(t) <class 'tuple'>
元组赋值给变量
a,b = ("name","sex") a 'name'
b 'sex'
a,b = 3,4 a 3
b 4
函数返回元组
def fun(a,b): ... return a,b ...
s = fun(2,3) print(s) (2, 3)
tuple()工厂函数 转换元组
列表转元组
tuple([1,2,3]) (1, 2, 3)
字符串转元组
tuple("abc") ('a', 'b', 'c')
字典转元组，只转key
tuple({1:2,3:4}) (1, 3)
t = [1,2,3,4,5,6] len()
len(t) 6 min()
min(t) 1 max()
max(t) 6
