Python高级语法
内容
- 解析顺序表MRO
- GIL锁
- 深拷贝，浅拷贝
- 私有化
- 私有属性
- 魔法属性
- 上下文管理器
解析顺序表MRO
-
多继承以及MRO顺序
*注意：重写和重载不是一个含义，Python里方法重载用的很少！
重写：整个方法重新写覆盖。
重载：方法名一样形参不一样。
-
Python中多继承时可能导致父类方法调用N次！
可以通过super()（super原理:通过C3算法使父类方法只调用一次）改变多继承导致的调用过多造成资源浪费，通过__mro__可以看到多继承调用方法的顺序。
- *args、**kwargs的另外用处拆包
GIL锁（全局解释器锁）
GIL面试题如下
描述Python GIL的概念， 以及它对python多线程的影响？编写一个多线程抓取网页的程序，并阐明多线程抓取程序是否可比单线程性能有提升，并解释原因。
参考答案:
-
Python语言和GIL没有半毛钱关系。仅仅是由于历史原因在Cpython虚拟机(解释器)，难以移除GIL。
-
GIL：全局解释器锁。每个线程在执行的过程都需要先获取GIL，保证同一时刻只有一个线程可以执行代码。
-
线程释放GIL锁的情况： 在IO操作等可能会引起阻塞的system call之前,可以暂时释放GIL,但在执行完毕后,必须重新获取GIL Python 3.x使用计时器（执行时间达到阈值后，当前线程释放GIL）或Python 2.x，tickets计数达到100
-
Python使用多进程是可以利用多核的CPU资源的。
-
多线程爬取比单线程性能有提升，因为遇到IO阻塞会自动释放GIL锁
计算密集型：使用进程（多核进行）
IO密集型：线程，协程（单核进行）
- Python调用C语言
以下通过特殊命令把C语言文件编译成.so文件供python使用
深拷贝，浅拷贝
-
（拷贝就是复制：可以理解为深拷贝就是复制变量数据出来一份，浅拷贝就是复制变量存储路径）
-
浅拷贝：
import copy a = [11,22] b = [33,66] d = copy.copy(c) id(c) id(d)
结果c，d的id结果一样
-
-
深拷贝：
import copy a = [11,22] b = [33,66] d = copy.deepcopy(c) id(c) id(d)结果c，d的id结果不一样
注意：deep copy和copy拷贝元组()都是浅拷贝,以下是另一种特殊情况：
- 切片属于浅拷贝
- 字典的copy方法也是浅拷贝
私有化
- xx: 公有变量
- _x: 单前置下划线,私有化属性或方法，from somemodule import *禁止导入,类对象和子类可以访问
- __xx：双前置下划线,避免与子类中的属性命名冲突，无法在外部直接访问(名字重整所以访问不到)
- –xx–前后下划线,用户名字空间的魔法对象或属性。例如:–init-- __ 不要自己发明这样的名字
- xx_:单后置下划线,用于避免与Python关键词的冲突
通过name mangling（名字重整(目的就是以防子类意外重写基类的方法或者属性)如：_Class__object）机制就可以访问private了。
总结
- 父类中属性名为__名字的，子类不继承，子类不能访问
- 如果在子类中向__名字赋值，那么会在子类中定义的一个与父类相同名字的属性
- _名的变量、函数、类在使用from xxx import *时都不会被导入
魔法属性
1. doc
-
表示类的描述信息
class Foo: """ 描述类信息，这是用于看片的神奇 """ def func(self): pass print(Foo.__doc__) #输出：类的描述信息
2. module 和 class
- module 表示当前操作的对象在那个模块
- class 表示当前操作的对象的类是什么
test.py
# -*- coding:utf-8 -*-
class Person(object):
def __init__(self):
self.name = 'laowang'
main.py
from test import Person
obj = Person()
print(obj.__module__) # 输出 test 即：输出模块
print(obj.__class__) # 输出 test.Person 即：输出类
3. init
-
初始化方法，通过类创建对象时，自动触发执行class Person:
def __init__(self, name): self.name = name self.age = 18obj = Person(‘laowang’) # 自动执行类中的 init 方法
4. del
-
当对象在内存中被释放时，自动触发执行。
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，__del__的调用是由解释器在进行垃圾回收时自动触发执行的。class Foo: def __del__(self): pass
5. call
-
对象后面加括号，触发执行。注：__init__方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 call 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()class Foo:
def __init__(self): pass def __call__(self, *args, **kwargs): print('__call__') obj = Foo() # 执行 __init__ obj() # 执行 __call__
6. dict
-
类或对象中的所有属性
类的实例属性属于对象；类中的类属性和方法等属于类，即：class Province(object): country = 'China' def __init__(self, name, count): self.name = name self.count = count def func(self, *args, **kwargs): print('func') # 获取类的属性，即：类属性、方法、 print(Province.__dict__) # 输出：{'__dict__': <attribute '__dict__' of 'Province' objects>, '__module__': '__main__', 'country': 'China', '__doc__': None, '__weakref__': <attribute '__weakref__' of 'Province' objects>, 'func': <function Province.func at 0x101897950>, '__init__': <function Province.__init__ at 0x1018978c8>} obj1 = Province('山东', 10000) print(obj1.__dict__) # 获取 对象obj1 的属性 # 输出：{'count': 10000, 'name': '山东'} obj2 = Province('山西', 20000) print(obj2.__dict__) # 获取 对象obj1 的属性 # 输出：{'count': 20000, 'name': '山西'}
7. str
-
如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。
class Foo: def __str__(self): return 'laowang' obj = Foo() print(obj) # 输出：laowang
8、getitem、setitem、delitem
-
用于索引操作，如字典。以上分别表示获取、设置、删除数据# -- coding:utf-8 --
class Foo(object): def __getitem__(self, key): print('__getitem__', key) def __setitem__(self, key, value): print('__setitem__', key, value) def __delitem__(self, key): print('__delitem__', key) obj = Foo() result = obj['k1'] # 自动触发执行 __getitem__ obj['k2'] = 'laowang' # 自动触发执行 __setitem__ del obj['k1'] # 自动触发执行 __delitem__
9、getslice、setslice、delslice
-
该三个方法用于分片操作，如：列表# -- coding:utf-8 --
class Foo(object): def __getslice__(self, i, j): print('__getslice__', i, j) def __setslice__(self, i, j, sequence): print('__setslice__', i, j) def __delslice__(self, i, j): print('__delslice__', i, j) obj = Foo() obj[-1:1] # 自动触发执行 __getslice__ obj[0:1] = [11,22,33,44] # 自动触发执行 __setslice__ del obj[0:2] # 自动触发执行 __delslice__
with与“上下文管理器”
对于系统资源如文件、数据库连接、socket 而言，应用程序打开这些资源并执行完业务逻辑之后，必须做的一件事就是要关闭（断开）该资源。
def m3():
with open("output.txt", "r") as f:
f.write("Python之禅")
简洁、优雅的方式就是用 with 关键字。open 方法的返回值赋值给变量 f，当离开 with 代码块的时候，系统会自动调用 f.close() 方法， with 的作用和使用 try/finally 语句是一样的。那么它的实现原理是什么？在讲 with 的原理前要涉及到另外一个概念，就是上下文管理器（Context Manager）。
上下文管理器
任何实现了 enter() 和 exit() 方法的对象都可称之为上下文管理器，上下文管理器对象可以使用 with 关键字。显然，文件（file）对象也实现了上下文管理器。
那么文件对象是如何实现这两个方法的呢？我们可以模拟实现一个自己的文件类，让该类实现 enter() 和 exit() 方法。
class File():
def __init__(self, filename, mode):
self.filename = filename
self.mode = mode
def __enter__(self):
print("entering")
self.f = open(self.filename, self.mode)
return self.f
def __exit__(self, *args):
print("will exit")
self.f.close()
enter() 方法返回资源对象，这里就是你将要打开的那个文件对象，exit() 方法处理一些清除工作。因为 File 类实现了上下文管理器，现在就可以使用 with 语句了。
with File('out.txt', 'w') as f:
print("writing")
f.write('hello, python')
这样，你就无需显示地调用 close 方法了，由系统自动去调用，哪怕中间遇到异常 close 方法也会被调用。
实现上下文管理器的另外方式
Python 还提供了一个 contextmanager 的装饰器，更进一步简化了上下文管理器的实现方式。通过 yield 将函数分割成两部分，yield 之前的语句在 enter 方法中执行，yield 之后的语句在 exit 方法中执行。紧跟在 yield 后面的值是函数的返回值。
from contextlib import contextmanager
@contextmanager
def my_open(path, mode):
f = open(path, mode)
yield f
f.close()
调用
with my_open('out.txt', 'w') as f:
f.write("hello , the simplest context manager")
总结
Python 提供了 with 语法用于简化资源操作的后续清除操作，是 try/finally 的替代方法，实现原理建立在上下文管理器之上。此外，Python 还提供了一个 contextmanager 装饰器，更进一步简化上下管理器的实现方式。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
