4.1.1-4.6.4Python提高

1、GIL（全局解释器锁）：
每个线程在执行的过程都需要先获取GIL，保证同一时刻只有一个线程可以执行代码。
Python使用多进程是可以利用多核的CPU资源的。
多线程爬取比单线程性能有提升，因为遇到IO阻塞会自动释放GIL锁。

2、深拷贝、浅拷贝
1）浅拷贝
浅拷贝是对于一个对象的顶层拷贝
通俗的理解是：拷贝了引用，并没有拷贝内容
2）深拷贝
深拷贝是对于一个对象所有层次的拷贝(递归)
3）拷贝的其他方式
分片表达式可以赋值一个序列，如d = c[:]
字典的copy方法可以拷贝一个字典
注意点
浅拷贝对不可变类型和可变类型的copy不同
1）copy.copy对于可变类型，会进行浅拷贝
2）copy.copy对于不可变类型，不会拷贝，仅仅是指向

3、私有化
xx: 公有变量
_x: 单前置下划线,私有化属性或方法，from somemodule import *禁止导入,类对象和子类可以访问
_xx：双前置下划线,避免与子类中的属性命名冲突，无法在外部直接访问(名字重整所以访问不到)
xx:双前后下划线,用户名字空间的魔法对象或属性。例如:init , __ 不要自己发明这样的名字
xx:单后置下划线,用于避免与Python关键词的冲突

通过name mangling（名字重整(目的就是以防子类意外重写基类的方法或者属性)如：_Class__object）机制就可以访问private了。
私有化总结
1)父类中属性名为__名字的，子类不继承，子类不能访问
2)如果在子类中向__名字赋值，那么会在子类中定义的一个与父类相同名字的属性
3)_名的变量、函数、类在使用from xxx import *时都不会被导入

4、import导入模块
已经导入的模块有更新，不能重新导入，要reload
注意区别：
import 模块名：此种方式要使用模块中的变量需要加模块名.，并且会修改原模块的变量值
from 模块名 import 变量名：此种方式修改的变量不能改变原模块中的变量值。

5、多继承以及MRO顺序
多继承中super调用有所父类的被重写的方法
如果2个子类中都继承了父类，当在子类中通过父类名调用时，parent被执行了2次
如果2个子类中都继承了父类，当在子类中通过super调用时，parent被执行了1次
总结
1）super().__init__相对于类名.init，在单继承上用法基本无差
2）但在多继承上有区别，super方法能保证每个父类的方法只会执行一次，而使用类名的方法会导致方法被执行多次，具体看前面的输出结果
3）多继承时，使用super方法，对父类的传参数，应该是由于python中super的算法导致的原因，必须把参数全部传递，否则会报错
4）单继承时，使用super方法，则不能全部传递，只能传父类方法所需的参数，否则会报错。super().init(name)
5）多继承时，相对于使用类名.__init__方法，要把每个父类全部写一遍, 而使用super方法，只需写一句话便执行了全部父类的方法，这也是为何多继承需要全部传参的一个原因
super().init(name, *args, **kwargs)

6、静态方法和类方法
1）类属性、实例属性
它们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同，
实例属性属于对象
类属性属于类
class Province(object):
# 类属性
country = ‘中国’

def __init__(self, name):
    # 实例属性
    self.name = name

创建一个实例对象

obj = Province(‘山东省’)

直接访问实例属性

print(obj.name)

直接访问类属性

Province.country
由上述代码可以看出【实例属性需要通过对象来访问】【类属性通过类访问】，在使用上可以看出实例属性和类属性的归属是不同的。

类属性在内存中只保存一份
实例属性在每个对象中都要保存一份
通过类创建实例对象时，如果每个对象需要具有相同名字的属性，那么就使用类属性，用一份既可

2）实例方法、静态方法和类方法
方法包括：实例方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。
实例方法：由对象调用；至少一个self参数；执行实例方法时，自动将调用该方法的对象赋值给self；
类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类赋值给cls；
静态方法：由类调用；无默认参数；
对比
相同点：对于所有的方法而言，均属于类，所以 在内存中也只保存一份
不同点：方法调用者不同、调用方法时自动传入的参数不同。

7、property属性
一种用起来像是使用的实例属性一样的特殊属性，可以对应于某个方法
property属性的定义和调用要注意一下几点：
定义时，在实例方法的基础上添加 @property 装饰器；并且仅有一个self参数
调用时，无需括号
方法：foo_obj.func()
property属性：foo_obj.prop
Python的property属性的功能是：property属性内部进行一系列的逻辑计算，最终将计算结果返回。

property属性的有两种方式
1）装饰器 即：在方法上应用装饰器，在类的实例方法上应用@property装饰器
Python中的类有经典类和新式类，新式类的属性比经典类的属性丰富。
经典类中的属性只有一种访问方式，其对应被 @property 修饰的方法
新式类中的属性有三种访问方式，并分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法
2）类属性 即：在类中定义值为property对象的类属性，当使用类属性的方式创建property属性时，经典类和新式类无区别
property方法中有个四个参数
第一个参数是方法名，调用 对象.属性 时自动触发执行方法
第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
第四个参数是字符串，调用 对象.属性.doc ，此参数是该属性的描述信息
BAR = property(get_bar, set_bar, del_bar, “description…”)
obj = Foo()
obj.BAR # 自动调用第一个参数中定义的方法：get_bar
obj.BAR = “alex” # 自动调用第二个参数中定义的方法：set_bar方法，并将“alex”当作参数传入
desc = Foo.BAR.doc # 自动获取第四个参数中设置的值：description…
print(desc)
del obj.BAR # 自动调用第三个参数中定义的方法：del_bar方法

8、魔法属性
1）doc ：表示类的描述信息
2） module 和 class
module 表示当前操作的对象在那个模块
class 表示当前操作的对象的类是什么
3） init
初始化方法，通过类创建对象时，自动触发执行
4）del
当对象在内存中被释放时，自动触发执行。
5） call
对象后面加括号，触发执行。
注：__init__方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 call 方法的执行是由对象后加括号触发的，即：对象() 或者
6） dict
类或对象中的所有属性
7） str
如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。
8）getitem、setitem、delitem
用于索引操作，如字典。以上分别表示获取、设置、删除数据
9）getslice、setslice、delslice
该三个方法用于分片操作，如：列表

9、with与“上下文管理器”
关闭一个文件的方式对比：
普通版：
def m1():
f = open(“output.txt”, “w”)
f.write(“python之禅”)
f.close()
这样写有一个潜在的问题，如果在调用 write 的过程中，出现了异常进而导致后续代码无法继续执行，close 方法无法被正常调用，因此资源就会一直被该程序占用者释放。那么该如何改进代码呢？

进阶版：
def m2():
f = open(“output.txt”, “w”)
try:
f.write(“python之禅”)
except IOError:
print(“oops error”)
finally:
f.close()
改良版本的程序是对可能发生异常的代码处进行 try 捕获，使用 try/finally 语句，该语句表示如果在 try 代码块中程序出现了异常，后续代码就不再执行，而直接跳转到 except 代码块。而无论如何，finally 块的代码最终都会被执行。因此，只要把 close 放在 finally 代码中，文件就一定会关闭。

高级版：
def m3():
with open(“output.txt”, “r”) as f:
f.write(“Python之禅”)
一种更加简洁、优雅的方式就是用 with 关键字。open 方法的返回值赋值给变量 f，当离开 with 代码块的时候，系统会自动调用 f.close() 方法， with 的作用和使用 try/finally 语句是一样的。那么它的实现原理是什么？在讲 with 的原理前要涉及到另外一个概念，就是上下文管理器（Context Manager）。

10、上下文管理器
任何实现了 enter() 和 exit() 方法的对象都可称之为上下文管理器，上下文管理器对象可以使用 with 关键字。显然，文件（file）对象也实现了上下文管理器。
with File(‘out.txt’, ‘w’) as f:
print(“writing”)
f.write(‘hello, python’)