标签：last 字典 python code def 变量 就是 括号 most
生成器>> g = (x*x for x in range(10))
>> next(g)
0
>> 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)
...
0
1
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:
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
标签：last 字典 python code def 变量 就是 括号 most
原文地址：http://blog.51cto.com/13496943/2299176
