描述器

get(self, instance, owner)

访问属性时调用

set(self, instance, value)

当对属性赋值时调用

delete(self, instance)

删除属性时调用
- self指代当前实例
- instance是owner的实例
- owner是属性的所属的类
描述器实现前提是描述器类实例作为类属性
当只实现get时（非数据描述符），属性查找顺序是本实例优先，get方法次之
当实现get和set时（数据描述符），属性查找顺序是get方法优先

本质

给类添加描述器时可以显示添加类属性，或者用setattr注入
注意所谓的类属性不仅仅类似与x=A()的属性，类中定义的函数也是类属性

模拟staticmethod与classmethod

from functools import partial

class StaticMethod:
    def __init__(self, fn):
        self.fn = fn

    def __get__(self, instance, owner):
        return self.fn

class ClassMethod:
    def __init__(self, fn):
        self.fn = fn

    def __get__(self, instance, owner):
        return partial(self.fn, owner)

class Test:

    @StaticMethod
    def s_mtd():  # s_mtd = StaticMethod(s_mtd)
        print('s_mtd')

    @ClassMethod
    def c_mtd(cls):  # c_mtd = ClassMethod(c_mtd)
        print('c_mtd', cls)

if __name__ == '__main__':
    Test.s_mtd()
    Test.c_mtd()

模拟property

class Property:
    def __init__(self, fget=None, fset=None):
        self.fget = fget
        self.fset = fset

    def __get__(self, instance, owner):
        return self.fget(instance)

    def __set__(self, instance, value):
        self.fset(instance, value)

    def getter(self):
        pass

    def setter(self, fset):
        self.fset = fset
        return self

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

    @Property
    def name(self):  # name=Property(name)
        return self._name

    @name.setter
    def name(self, value):  # name=Property(name).setter(name)    (value)
        self._name = value

    @Property
    def age(self):  # name=Property(name)
        return self._age

    @age.setter
    def age(self, value):  # name=Property(name).setter(name)    (value)
        self._age = value

校验参数类型

普通装饰器

import inspect

class TypeCheck:
    def __init__(self, key, type):
        print('TC init')
        self.key = key
        self.type = type

    def __get__(self, instance, owner):
        print('TC get')
        if instance is not None:
            return instance.__dict__[self.key]
        return self

    def __set__(self, instance, value):
        print('TC set')
        if not isinstance(value, self.type):
            raise TypeError
        instance.__dict__[self.key] = value

def typeassert(cls):
    params = inspect.signature(cls).parameters
    for name, type in params.items():
        if type != type.empty:
            setattr(cls, name, type.annotation)
    return cls

@typeassert
class Person:
    name = TypeCheck('name', str)
    age = TypeCheck('age', int)

    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

tom = Person('tom', 12)
print(tom.name)

类装饰器

import inspect

class TypeCheck:
    def __init__(self, key, type):
        print('TC init')
        self.key = key
        self.type = type

    def __get__(self, instance, owner):
        print('TC get')
        if instance is not None:
            return instance.__dict__[self.key]
        return self

    def __set__(self, instance, value):
        print('TC set')
        if not isinstance(value, self.type):
            raise TypeError
        instance.__dict__[self.key] = value

class TypeAssert:
    def __init__(self, cls):
        self.cls = cls

    def __call__(self, name, age):
        params = inspect.signature(self.cls).parameters
        for key, type in params.items():
            if type != type.empty:
                setattr(self.cls, key, TypeCheck(key, type.annotation))
        return self.cls(name, age)

@TypeAssert
class Person:  # Person = TypeAssert(Person)
    name = TypeCheck('name', str)
    age = TypeCheck('age', int)

    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

tom = Person('tom', '12')
print(tom.name)

链表

class Node:
    """
    Description: Node Class

    attr item: current Node`s data
    attr next: points to the next Node
    attr past: points to the last Node
    """

    def __init__(self, item: object):
        self.__item = item
        self.__next = None
        self.__past = None

    @property
    def item(self):
        return self.__item

    @item.setter
    def item(self, value):
        self.__item = value

    @property
    def next(self):
        return self.__next

    @next.setter
    def next(self, value: object):
        self.__next = value

    @property
    def past(self):
        return self.__past

    @past.setter
    def past(self, value: object):
        self.__past = value

class LinkedList:
    """
    Description: Base class LinkedList

    """

    def __init__(self):
        self.cur = None
        self.head = None
        self.length = 0

    def append(self, no: object):
        raise Exception('Base Method')

    def iternodes(self):
        raise Exception('Base Method')

    def pop(self):
        raise Exception('Base Method')

    def insert(self, position: int, value: object):
        raise Exception('Base Method')

    def remove(self, value: object):
        raise Exception('Base Method')

class SingleLinkedList(LinkedList):
    """
    Description:

    attr head: head Node
    attr cur: current Node

    method append(): append Node
    """

    def __init__(self):
        super().__init__()

    def __iter__(self):
        cur_node = self.head

        while True:
            yield cur_node.item
            if not cur_node.next:
                break
            cur_node = cur_node.next

    def __getitem__(self, item):
        cur_node = self.head

        if isinstance(item, slice):
            pass
        else:
            for _ in range(item):
                cur_node = cur_node.next
            return cur_node.item

    def __setitem__(self, key, value):
        cur_node = self.head

        for _ in range(key):
            cur_node = cur_node.next
        cur_node.item = value

    def append(self, no: object):
        if self.length == 0:
            self.cur = Node(no)
            self.head = self.cur
        else:
            self.cur.next = Node(no)
            self.cur = self.cur.next
        self.length += 1

sl = SingleLinkedList()
sl.append(1)
sl.append(2)
for i in sl:
    print(i)
sl[1] = 999
sl[0] = 234
for i in sl:
    print(i)

class DoubleLinkedList(LinkedList):
    """
    Description:

    attr head:
    attr cur:

    method append:
    method pop:
    method insert:
    method remove:
    method iternodes:
    """

    def __init__(self):
        super().__init__()

    def __iter__(self):
        cur_node = self.head

        while True:
            yield cur_node.item
            if not cur_node.next:
                break
            cur_node = cur_node.next

    def __reversed__(self):
        cur_node = self.cur

        while True:
            yield cur_node.item
            if not cur_node.past:
                break
            cur_node = cur_node.past

    def __getitem__(self, item):
        cur_node = self.head

        if isinstance(item, slice):
            pass
        else:
            for _ in range(item):
                cur_node = cur_node.next
            return cur_node.item

    def __setitem__(self, key, value):
        cur_node = self.head

        for _ in range(key):
            cur_node = cur_node.next
        cur_node.item = value

    def append(self, no: object):
        if self.length == 0:
            self.cur = Node(no)
            self.head = self.cur
        else:
            temp = self.cur
            self.cur.next = Node(no)
            self.cur = self.cur.next
            self.cur.past = temp
        self.length += 1

    def pop(self):
        pop_node = self.cur
        pop_node.past.next = None
        self.cur = self.cur.past

        self.length -= 1
        return pop_node

    def insert(self, position: int, value: object):
        cur_node = self.head
        new_node = Node(value)

        for _ in range(position - 1):
            cur_node = cur_node.next

        next_node = cur_node.next

        cur_node.next = new_node
        new_node.past = cur_node

        new_node.next = next_node
        next_node.past = new_node

    def remove(self, value: object):
        cur_node = self.head

        while True:
            if cur_node.item == value:
                cur_node.past.next = cur_node.next
                cur_node.next.past = cur_node.past
                break
            elif not cur_node.next:
                raise Exception('NodeNotFound')
            cur_node = cur_node.next

    def iternodes(self, *, reverse=False):
        if not reverse:
            cur_node = self.head

            while True:
                yield cur_node.item
                if not cur_node.next:
                    break
                cur_node = cur_node.next
        else:
            cur_node = self.cur

            while True:
                yield cur_node.item
                if not cur_node.past:
                    break
                cur_node = cur_node.past

异常处理

产生异常

raise 异常实例

Python解释器自己检测到异常并引发它

异常捕获

try:
待捕获异常的代码块
except [异常类型] as e:
异常的处理代码块
else:
...
finally：
...

e为异常的实例
可写多个except
else 没有任何异常发生则执行
finally语句块无论如何都会执行

BaseException

所有内建异常类的基类

SystemExit

sys.exit()引发的异常，异常不捕获处理，直接交给Python解释器，解释器退出

KeyboardInterrupt

命令行使用Ctrl+C终端操作

Exception

所有内建、非系统退出的异常的基类，自定义异常需要继承它

SyntaxError语法错误

此错误不可捕获

ArithmeticError

算术计算错误，子类有除零异常等

LookupError

使用映射的键或序列的索引无效时引发的异常的基类：IndexError，KeyError

模块化

import ... 与import ... as ...

找到制定的模块，加载和初始化它，生成模块对象
在import所在的作用域的局部命名空间中，增加名称和上一步创建的对象关联
导入顶级模块，其名称会加入到本地名词空间中（dir()），并绑定到其模块对象
导入非顶级模块，至将其顶级模块名称加入到本地名词空间中，导入的模块必须用完全限定名访问
如果使用as，as后的名称直接绑定到导入的模块对象中，并将该名称加入到本地名词空间中

from ... import ...与from ... import ... as ...

from后指定的模块名只加载并初始化，不导入
对于import子句后的名称
先查from导入的模块是否具有该名称属性，如果不是，则尝试导入该名称的子模块

自定义模块

命名规范
全小写，下划线来分割

模块搜索顺序

sys.path

返回列表
可被修改，追加新路径

路径查找顺序

sys.modules

返回字典
记录所有加载的模块

模块运行

name

模块名，如不指定就是文件名
解释器初始化时会初始化sys.module字典，创建builtins模块、main模块、sys模块，sys.path

if name == 'main'

用于模块功能测试
避免主模块变更的副作用

模块的属性

file 源文件路径
cached 编译后的字节码文件路径
spec 显示模块规范
name 模块名
package 当模块是包，同name，否则可以设置为顶级模块的空字符串

包 Package

目录下有一个init.py文件，导入包时，此文件内容代表此包

子模块

模块和包总结

导入子模块一定会加载父模块，导入父模块一定不会导入子模块

包是特殊的模块，包含path属性

绝对导入，相对导入

绝对导入

总是去搜索模块搜索路径中找

相对导入

只能在包内使用，且只能用在from中
. 表示当前目录
.. 表示上一级目录
... 表示上上级目录

访问控制

from ... import *
- 使用此方法导入模块时，以_和__开头的属性不会导入
使用all
- 一个列表，每个元素都是模块内的变量名
- 定义all后，from ... import * 只导入all内的属性

包管理

setuptools
- 包管理的核心模块
pip
- 目前包管理的事实标准
wheel
- 以二进制安装，不需要本地编译

pip install wheel

创建setup.py文件

# from distutils.core import setup  # 可能失败
from setuptools import setup

setup(name='Distutils',
      version='1.0',
      description='Python Distribution Utilities',
      author='Greg Ward',
      author_email='[email protected]',
      url='https://www.python.org/sigs/distutils-sig/',
      packages=['distutils', 'distutils.command'],
     )

package内容是要管理的包

查询命令帮助

python setup.py cmd -help

build

python setup.py build

build得到的文件，直接拷贝到其他项目就可以用

install

python setup.py install

如果没有build，会先build编译，然后安装

sdist

python setup.py sdist

创建源代码的分发包
在其他地方解压缩这个文件，里面有setup.py，就可以使用python setup.py install安装，也可以
pip install XXX.zip直接使用pip安装这个压缩包

插件化开发

动态导入

运行时，根据用户需求，找到模块的资源动态加载起来
import(name, globals=None, locals=None, fromlist=(), level=0)
- import 本质上就是调用此函数（sys = impot('sys') 等价于import sys），但建议不直接使用，建议使用
- importlib.import_module(name, package=None)
- 支持绝对导入和相对导入，如果是相对导入，package必须设置

插件化编程技术

依赖的技术

反射：运行时获取类型的信息，可以动态维护类型数据
动态import：使用importlib
多线程：可以开启一个线程，等待用户输入，从而加载指定名称的模块

加载时机

程序启动时
程序运行中

如插件过多，会导致程序启动很慢，如果用户需要时再加载，如果插件太大或依赖多，插件也会启动慢。
因此先加载必须、常用插件，其他插件使用时，发现需要，动态载入

基础知识补充

slot

字典为了查询效率，必须用空间换时间
如果实例对象数量过大，那字典占用空间过大
如果类定义了slot,实例会省略建立dict
如果给实例增加不在slot的属性会抛出Attribute异常
slot可以定义为元组或列表，通常用元组，省空间
slot不会继承给子类

未实现和未实现异常

NotImplemented是个值，单值，是NotImplementedType类的实例
NotImplementedError是类型，是异常，返回type

运算符重载中的反向方法

当正向方法返回NotImplemented时调用反向方法

git服务器搭建

gogs

软件依赖

Mysql

安装

useradd git
su - git
tar xf gogs*
cd gogs
mysql -uroot -p < scripts/mysql.sql

grant all on gogs.* to 'gogs'@'%' identified by 'gogs';
flush privileges;

配置文件

mkdir -p custom/conf
cd custom/conf
touch app.ini

启动gogs

./gogs web
服务启动

cp /home/git/gogs/scripts/init/centos/gogs /etc/init.d/
chmod +x /etc/init.d/gogs
chkconfig gogs on
service gogs start

Python第九周 学习笔记（1）描述器链表异常处理模块化包管理插件化开发基础知识补充git服务器搭建

描述器

get(self, instance, owner)

set(self, instance, value)

delete(self, instance)

本质

模拟staticmethod与classmethod

模拟property

校验参数类型

普通装饰器

类装饰器

链表

异常处理

产生异常

异常捕获

BaseException

SystemExit

KeyboardInterrupt

Exception

SyntaxError语法错误

ArithmeticError

LookupError

模块化

import ... 与import ... as ...

from ... import ...与from ... import ... as ...

自定义模块

模块搜索顺序

sys.path

路径查找顺序

sys.modules

模块运行

name

if name == 'main'

模块的属性

包 Package

子模块

模块和包总结

绝对导入，相对导入

绝对导入

相对导入

访问控制

包管理

创建setup.py文件

查询命令帮助

build

install

sdist

插件化开发

动态导入

插件化编程技术

依赖的技术

加载时机

基础知识补充

slot

未实现和未实现异常

运算符重载中的反向方法

git服务器搭建

gogs

软件依赖

安装

配置文件

启动gogs

继续阅读

Python第九周学习笔记（1）描述器链表异常处理模块化包管理插件化开发基础知识补充git服务器搭建