python拓展内容

python高级语法

---

GIL（全局解释器锁）

• 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锁

---

---

深拷贝、浅拷贝

在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。

浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复制

深拷贝：外围和内部元素都进行了拷贝对象本身，而不是引用。也就是，把对象复制一遍，并且该对象中引用的其他对象我也复制。

作用

1、 减少内存的使用
2、以后在做数据的清洗、修改或者入库的时候，对原数据进行复制一份，以防数据修改之后，找不到原数据。

---

浅拷贝copy.copy

浅拷贝是对于一个对象的顶层拷贝

通俗的理解是：拷贝了引用，并没有拷贝内容

相当于指向了与被拷贝的同一个的列表

• 个人理解：浅拷贝是指向了同一个地址，a的列表改变 b的列表也跟着改变

• 浅拷贝对不可变类型(元组))和可变类型的copy不同
• copy.copy对于可变类型，会进行浅拷贝
• copy.copy对于 不可变类型，不会拷贝，仅仅是指向

---

深拷贝copy.deepcopy

深拷贝是对于一个对象所有层次的拷贝(递归)

相当于复制/拷贝了另一个数据一样的列表

深拷贝就是对对象的完全拷贝，不管你有多少层，数据都不会共享。

• 个人理解：深拷贝是将其内容拷贝到一个新的地址。a地址里的内容添加东西，c里面不添加。（a和c指向的地址不同）

总结

1、深浅拷贝都是对源对象的复制，占用不同的内存空间。

2、不可变类型的对象，对于深浅拷贝毫无影响，最终的地址值和值都是相等的。

3、可变类型：
=浅拷贝： 值相等，地址相等 copy浅拷贝：值相等，地址不相等 deepcopy深拷贝：值相等，地址不相等

好的还是不懂 多理解吧

---

---

私有化

• xx 公有变量
• _x 单前置下划线,私有化属性或方法，from somemodule import *禁止导入,类对象和子类可以访问
• __xx 双前置下划线,避免与子类中的属性命名冲突，无法在外部直接访问(名字重整所以访问不到)
• __ xx __ 双前后下划线,用户名字空间的魔法对象或属性。例如: __ init __ , __ 不要自己发明这样的名字
• xx_ 单后置下划线,用于避免与Python关键词的冲突
  通过name mangling（名字重整(目的就是以防子类意外重写基类的方法或者属性)如：_Class__object）机制就可以访问private了。

class Person(object):
    def __init__(self, name, age, taste):
        self.name = name
        self._age = age 
        self.__taste = taste

    def showperson(self):
        print(self.name)
        print(self._age)
        print(self.__taste)

    def dowork(self):
        self._work()
        self.__away()


    def _work(self):
        print('my _work')

    def __away(self):
        print('my __away')

class Student(Person):
    def construction(self, name, age, taste):
        self.name = name
        self._age = age 
        self.__taste = taste

    def showstudent(self):
        print(self.name)
        print(self._age)
        print(self.__taste)

    @staticmethod
    def testbug():
        _Bug.showbug()

# 模块内可以访问，当from  cur_module import *时，不导入
class _Bug(object):
    @staticmethod
    def showbug():
        print("showbug")

s1 = Student('jack', 25, 'football')
s1.showperson()
print('*'*20)

# 无法访问__taste,导致报错
# s1.showstudent() 
s1.construction('rose', 30, 'basketball')
s1.showperson()
print('*'*20)

s1.showstudent()
print('*'*20)

Student.testbug()

总结

• 父类中属性名为__名字的，子类不继承，子类不能访问
• 如果在子类中向__名字赋值，那么会在子类中定义的一个与父类相同名字的属性
• _名的变量、函数、类在使用 from xxx import * 时都不会被导入

---

---

封装、继承、多态

封装、继承、多态 是面向对象的3大特性

封装的好处

1. 在使用面向过程编程时，当需要对数据处理时，需要考虑用哪个模板中哪个函数来进行操作，但是当用面向对象编程时，因为已经将数据存储到了这个独立的空间中，这个独立的空间（即对象）中通过一个特殊的变量（class）能够获取到类（模板），而且这个类中的方法是有一定数量的，与此类无关的将不会出现在本类中，因此需要对数据处理时，可以很快速的定位到需要的方法是谁
   这样更方便
2. 全局变量是只能有1份的，多很多个函数需要多个备份时，往往需要利用其它的变量来进行储存；而通过封装 会将用来存储数据的这个变量 变为了对象中的一个“全局”变量，只要对象不一样那么这个变量就可以再有1份，所以这样更方便
3. 代码划分更清晰

继承

1. 能够提升代码的重用率，即开发一个类，可以在多个子功能中直接使用
2. 继承能够有效的进行代码的管理，当某个类有问题只要修改这个类就行，而其继承这个类的子类往往不需要就修改

---

多继承以及MRO顺序

• 在Python中，所有的 函数名 和 方法名 实际都只是 变量名

在多继承中调用父类被重写的方法：

• 父类名.方法名(self, name)

  • 注：需传递参数 self

• super.方法名(name, *args, **kwargs)

  • 注：super 不需要传递 self
  • super 不只是简单的调用父类的方法，它的调用顺序是由 C3算法 来决定的，如若想查看其顺序，可用 __mro__ 来查看

• super(类名, self).方法名(xxx, xxx)

这中方式是指定要调用的类名，实则它是拿着这个类名去上面的 MRO 顺序表中去找

print(Grandson.__mro__)
    
####查看结果#####
(<class '__main__.Grandson'>, <class '__main__.Son1'>, <class '__main__.Son2'>, <class '__main__.Parent'>, <class 'object'>)

这是 C3算法 算出来的调用顺序

尝试做题理解一下

class Parent(object):
    x = 1

class Child1(Parent):
    pass

class Child2(Parent):
    pass

print(Parent.x, Child1.x, Child2.x)
Child1.x = 2
print(Parent.x, Child1.x, Child2.x)
Parent.x = 3
print(Parent.x, Child1.x, Child2.x)

使你困惑或是惊奇的是关于最后一行的输出是 3 2 3 而不是 3 2 1。为什么改变了 Parent.x 的值还会改变 Child2.x 的值，但是同时 Child1.x 值却没有改变？

这个答案的关键是，在 Python 中，类变量在内部是作为字典处理的。如果一个变量的名字没有在当前类的字典中发现，将搜索祖先类（比如父类）直到被引用的变量名被找到（如果这个被引用的变量名既没有在自己所在的类又没有在祖先类中找到，会引发一个 AttributeError 异常 ）。

因此，在父类中设置 x = 1 会使得类变量 x 在引用该类和其任何子类中的值为 1。这就是因为第一个 print 语句的输出是 1 1 1。

随后，如果任何它的子类重写了该值（例如，我们执行语句 Child1.x = 2），然后，该值仅仅在子类中被改变。这就是为什么第二个 print 语句的输出是 1 2 1。

最后，如果该值在父类中被改变（例如，我们执行语句 Parent.x = 3），这个改变会影响到任何未重写该值的子类当中的值（在这个示例中被影响的子类是 Child2）。这就是为什么第三个 print 输出是 3 2 3。

不定长参数

• 为避免多继承报错，使用不定长参数，接受参数

• *args =====> 元组

• **kwargs =====> 字典

• 不定长参数不仅可当作形参，也可以当作当作实参进行传递，当然传递时要加上 * 号，不然，传递时只填 (a, args, kwargs) 的话，args 和 kwargs 会被当作一个元组传递

---

---

类属性、实例属性

• 实例属性属于对象
• 类属性属于类
• 类属性在内存中只保存一份
• 实例属性在每个对象中都要保存一份

实例方法、静态方法和类方法

三种方法在内存中都归属于类，区别在于调用方式不同。

• 实例方法：由对象调用；至少一个self参数；执行实例方法时，自动将调用该方法的对象赋值给self；
• 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类赋值给cls；
• 静态方法：由类调用；无默认参数；

class Foo(object):
    def __init__(self, name):
        self.name = name

    def ord_func(self):
        """ 定义实例方法，至少有一个self参数 """
        # print(self.name)
        print('实例方法')

    @classmethod
    def class_func(cls):
        """ 定义类方法，至少有一个cls参数 """
        print('类方法')

    @staticmethod
    def static_func():
        """ 定义静态方法 ，无默认参数"""
        print('静态方法')



f = Foo("中国")
# 调用实例方法
f.ord_func()

# 调用类方法
Foo.class_func()

# 调用静态方法
Foo.static_func()

相同点：对于所有的方法而言，均属于类，所以 在内存中也只保存一份
不同点：方法调用者不同、调用方法时自动传入的参数不同。

---

---

property属性

一种用起来像是使用的实例属性一样的特殊属性，可以对应于某个方法

############### 定义 ###############
class Foo:
    def func(self):
        pass

    # 定义property属性
    @property
    def prop(self):
        pass

############### 调用 ###############
foo_obj = Foo()
foo_obj.func()  # 调用实例方法
foo_obj.prop  # 调用property属性

• 定义时，在实例方法的基础上添加 @property 装饰器；并且仅有一个self参数
• 调用时，无需括号
• Python的property属性的功能是：property属性内部进行一系列的逻辑计算，最终将计算结果返回。

property属性的有两种方式

装饰器方式

• 新式类，具有三种@property装饰器

############### 定义 ###############
class Goods:
    """python3中默认继承object类
        以python2、3执行此程序的结果不同，因为只有在python3中才有@xxx.setter  @xxx.deleter
    """
    @property
    def price(self):
        print('@property')

    @price.setter
    def price(self, value):
        print('@price.setter')

    @price.deleter
    def price(self):
        print('@price.deleter')

############### 调用 ###############
obj = Goods()
obj.price          # 自动执行 @property 修饰的 price 方法，并获取方法的返回值
obj.price = 123    # 自动执行 @price.setter 修饰的 price 方法，并将  123 赋值给方法的参数
del obj.price      # 自动执行 @price.deleter 修饰的 price 方法

类属性方式，创建值为property对象的类属性

当使用类属性的方式创建property属性时，经典类和新式类无区别

class Foo:
    def get_bar(self):
        return 'laowang'

    BAR = property(get_bar)

obj = Foo()
reuslt = obj.BAR  # 自动调用get_bar方法，并获取方法的返回值
print(reuslt)

• property方法中有个四个参数

  • 第一个参数是方法名，调用 对象.属性 时自动触发执行方法
  • 第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
  • 第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
  • 第四个参数是字符串，调用 对象.属性. __ doc__ ，此参数是该属性的描述信息

class Foo(object):
    def get_bar(self):
        print("getter...")
        return 'laowang'

    def set_bar(self, value): 
        """必须两个参数"""
        print("setter...")
        return 'set value' + value

    def del_bar(self):
        print("deleter...")
        return 'laowang'

    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方法

---

---

魔法属性

__ doc__

• 表示类的描述信息

class Foo:
    """ 描述类信息，这是用于看片的神奇 """
    def func(self):
        pass

print(Foo.__doc__)
#输出：类的描述信息

__ module__ 和 __ class__

• __ module__ 表示当前操作的对象在那个模块
• __ class__ 表示当前操作的对象的类是什么

# -*- coding:utf-8 -*-

class Person(object):
    def __init__(self):
        self.name = 'laowang'
        
obj = Person()
print(obj.__module__)  # 输出 test 即：输出模块
print(obj.__class__)  # 输出 test.Person 即：输出类

__ init__

• 初始化方法，通过类创建对象时，自动触发执行

class Person:
    def __init__(self, name):
        self.name = name
        self.age = 18

obj = Person('laowang')  # 自动执行类中的 __init__ 方法

__ del__

• 当对象在内存中被释放时，自动触发执行。

__ call__

• 对象后面加括号，触发执行。

注：__init__方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 call 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

__ str__

• 如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。

class Foo:
    def __str__(self):
        return 'laowang'


obj = Foo()
print(obj)
# 输出：laowang