切片:彻底搞懂Python切片操作
yield关键字
def fab(max):
n, a, b = 0, 0, 1
while n < max:
#print(b)
yield b
a, b = b, a + b
n = n + 1
# fab(5)
'''
yield 的作用就是把一个函数变成一个 generator,
带有 yield 的函数不再是一个普通函数,Python 解释器会将其视为一个 generator,
调用 fab(5) 不会执行 fab 函数,而是返回一个 iterable 对象!
在 for 循环执行时,每次循环都会执行 fab 函数内部的代码,
执行到 yield b 时,fab 函数就返回一个迭代值,下次迭代时,
代码从 yield b 的下一条语句继续执行,而函数的本地变量看起来和
上次中断执行前是完全一样的,于是函数继续执行,直到再次遇到 yield。
'''
def fun_with_yeild():
print("I'am here!")
yield 5
print("again print")
yield 23
# 用于读取文件 通过固定长度的缓冲区不断读文件,
# 防止一次性读取出现内存溢出的例子:
def read_file(path):
size = 1024
with open(path,'r') as f:
while True:
block = f.read(SIZE)
if block:
yield block
else:
return
for n in fab(5):
print(n)
'''
一个函数中出现多个yield则next()会停止在下一个yield前
'''
hh = fun_with_yeild()
hh.__next__() # I'am here! 第一次运行暂停这里
#hh.__next__() # again print
print(hh.__next__()) # 23
yield 的作用就是把一个函数变成一个 generator,带有 yield 的函数不再是一个普通函数,Python 解释器会将其视为一个 generator,
调用 fab(5) 不会执行 fab 函数,而是返回一个 iterable 对象!在 for 循环执行时,每次循环都会执行 fab 函数内部的代码,执行到 yield b 时,fab 函数就返回一个迭代值,下次迭代时,代码从 yield b 的下一条语句继续执行,而函数的本地变量看起来和上次中断执行前是完全一样的,于是函数继续执行,直到再次遇到 yield。
python的赋值,深拷贝和浅拷贝的区别
在python中,对象赋值实际上是对象的引用。当创建一个对象,然后把它赋给另一个变量的时候,python并没有拷贝这个对象,而只是拷贝了这个对象的引用
深拷贝是将对象本身复制给另一个对象, deepcopy(),如果对对象的副本进行更改时不会影响原对象
浅拷贝是将对象的引用复制给另一个对象。因此,如果我们在副本中进行更改,则会影响原对象。使用 copy()函数进行浅拷贝
(1)直接赋值,默认浅拷贝传递对象的引用而已,原始列表改变,被赋值的b也会做相同的改变
(2)copy浅拷贝,没有拷贝子对象,所以原始数据改变,子对象会改变
(3)深拷贝,包含对象里面的自对象的拷贝,所以原始对象的改变不会造成深拷贝里任何子元素的改变
整体如下:
列表和元祖有什么不同
要区别在于列表是可变的,元祖是不可变的,其中的值
一旦你创建了一个列表,你就可以添加,删除,或者是搜索列表中的项目。由于你可以增加或删除项目,我们说列表是可变的数据类型,即这种类型是可以被改变的,并且列表是可以嵌套的
元祖和列表十分相似,不过元组是不可变的。即你不能修改元组。元组通过圆括号中用逗号分隔的项目定义。元组通常用在使语句或用户定义的函数能够安全的采用一组值的时候,即被使用的元组的值不会改变。元组可以嵌套。
Python 中如何实现多线程
Python 是一种多线程语言,它有一个多线程包。Python并不支持真正意义上的多线程。Python中提供了多线程包,但是如果你想通过多线程提高代码的速度,使用多线程包并不是个好主意
GIL(全局解释器锁)确保一次执行单个线程。一个线程保存 GIL 并在将其传递给下一个线程之前执行一些操作,这就产生了并行执行的错觉。但实际上,只是线程轮流在 CPU 上。当然,所有传递都会增加执行的开销。
Python中多线程相关的模块包括:thread,threading,Queue。
thread:多线程的底层支持模块,一般不建议使用【本文暂不涉及】
threading:对thread进行了封装,将一些线程的操作对象化
Queue:实现了多生产者(Producer)、多消费者(Consumer)的队列
从Thread类派生一个子类,重写run方法(推荐的方法)
猴子”(monkey patching)指的是什么?这种做法好吗?
答案:
“猴子”就是指,在函数或对象已经定义之后,再去改变它们的行为。
举个例子:
import datetime
datetime.datetime.now = lambda: datetime.datetime(2012, 12, 12)
大部分情况下,这是种很不好的做法 - 因为函数在代码库中的行为最好是都保持一致。打“猴子补丁”的原因可能是为了测试。mock
包对实现这个目的很有帮助
zip() 函数
用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表。
>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b) # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c) # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped) # 与 zip 相反,*zipped 可理解为解压,返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]
- *arg会把多出来的位置参数转化为tuple
- **kwarg会把关键字参数转化为dict
可变对象-不可变对象
在Python中不可变对象指:一旦创建就不可修改的对象,包括字符串,元祖,数字
在Python中可变对象是指:可以修改的对象,包括:列表、字典
>>> L1 = [2,3,4] #L1变量指向的是一个可变对象:列表
>>> L2 = L1 #将L1值赋给L2后,两者共享引用同一个列表对象[1,2,3,4]
>>> L1[0] = 200 #因为列表可变,改变L1中第一个元素的值
>>> L1; L2 #改变后,L1,L2同时改变,因为对象本身值变了
[200, 3, 4]
[200, 3, 4]
如果不想改变列表L2的值,有两种方法:切片 和 copy模块
>>> L1 = [2,3,4]
>>> L2 = L1
>>> id(L1);id(L2) #共享引用一个可变对象
45811784L
45811784L
>>> L2 = L1[:] #切片操作
>>> id(L1);id(L2) #切片后,对象就不一样了
45811784L
45806920L
>>> L1[0] = 200
>>> L1;L2 #L1发生改变,L2没有变化
[200, 3, 4]
[2, 3, 4]
- 深浅拷贝都是对源对象的复制,占用不同的内存空间
- 如果源对象只有一级目录的话,源做任何改动,不影响深浅拷贝对象
- 如果源对象不止一级目录的话,源做任何改动,都要影响浅拷贝(只影响其子对象),但不影响深拷贝
- 序列对象的切片其实是浅拷贝,即只拷贝顶级的对象
切片技术应用于所有的序列,包括:列表、字符串、元祖
但切片不能应用于字典。对字典只能使用D.copy()方法或D.deepcopy()方法.
深浅拷贝,即可用于序列,也可用于字典
一行代码实现99乘法表
print ("\n".join("\t".join(["%s*%s=%s" %(x,y,x*y) for y in range(1, x+1)]) for x in range(1, 10)))
==================================================
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81