python 易学,语法简单,但是想要精通还是比较困难的,语法太灵活了…

1.python装饰器

#!/usr/bin/env python
"""
python decorator
比较好奇flask hello world app.route('/') 自己实现一个
装饰器就是接收一个函数对象返回一个函数对象
带参数的装饰器其实就是一个普通函数接收参数 返回一个装饰器
"""

from functools import wraps


end = []
url=[]

def decorator(f):
    end.append(f)
    def wrapper():
        return f()
    return wrapper
#定义最简单装饰器decorator 接收一个函数对象 返回一个函数对象


def app(path):
    url.append(path)
    return decorator
#一个普通函数接收一个参数 返回一个装饰器

@decorator
def home():
    print("i am home")

# 等价 home = decorator(home)

print(home.__name__) #home 变wrapper了
#如果想让home 函数名不变 在定义装饰器的时候用@wraps(f)修饰wrapper

@app("/")
def home2():
    print("i am home2")

#等价 home2 = app('/')(home) #把app('/') 想象成一个普通函数立即执行返回装饰器函数对象decorator
print(home2.__name__) #home2 变wrapper了



print(dict(zip(url,end)))
#{'/': <function home at 0x7fb676eac9d8>}

2 python类

基类object的方法

__init____del__

__init__对象创建时调用 相当于java的构造函数 __del__对象销毁时调用 相当于析构函数 一个例子

import time
class Student(object):
    def __init__(self,name):
        self.name = name
        print(name)

    def __del__(self):
        print("__del__",self.name)

a = Student("yang")

time.sleep(1)

#yang
#__del__ yang

__str____repr__ __format__

__str__对象被str()函数调用时执行 __repr__对象被repr()函数调用时执行 __format__ 对象被 string.format()函数调用时执行 直接看例子

class Student(object):
    def __str__(self):
        return "student"

    def __repr__(self):
        return "repr - student"
    def __format__(self,x):
        return "format- student"
a = Student()

print(a)
print(str(a))
print(repr(a))
print(format(a))
print("%s" % a)
print("%r" % a)
print("{0}".format(a)) #调用__format__格式化 {}里可以使用点取属性{0.__class__}
print("{0!r}".format(a)) #调用__repr__格式化
print("{0!s}".format(a)) #调用__str__格式化
print(Student == a.__class__)

#out

student
student
repr - student
format- student
student
repr - student
format- student
repr - student
student
True

__enter____exit__直接看例子

class Student(object):
    def __enter__(self):
        print("enter")
        return "f"
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("exit")
        return self

a = Student()

with a as f:
    print(f)
    print("entered")
print("exited")

enter
f
entered
exit
exited

还有很多的

让类可以作用于for in 实现iter 切片 索引

python 如何创建类

class A(object):
    def __init__(self,name):
        print(A,name)

code="""
class B(object):
    def __init__(self,name):
        print(B,name)
"""
exec(code)

C = type("C",(object,),{"__init__":A.__init__})

a= A(11)
b=B(22)
c=C(33)
print(a,b,c)

11 22 33 <main.A object at 0x7f8b96596080> <main.B object at 0x7f8b96596128> <main.C object at 0x7f8b96596160>

python 类装饰器

修饰类 让类的实例是单例模式

def singleton(cls):
    def wrap(*args,**kw):
        o = getattr(cls,"__instance__",None)
        if o:
            return o
        else:
            o = cls(*args,**kw)
            cls.__instance__ = o
            return o
    return wrap

def singleton(cls):
    class wrap(cls):
        def __new__(cls, *args, **kwargs):
            o = getattr(cls, "__instance__", None)
            if not o:
                o = object.__new__(cls)
                cls.__instance__ = o
            return o
    return wrap

@singleton
class A(object):
    def __init__(self,name):
        print(A,name)

a , b = A(1),A(2)

print(a is b)

3 python 描述符Descriptor

描述符协议: >get(self, instance, owner) –> return value set(self, instance, value) delete(self, instance)

• 实现 getset 方方法,称为 data descriptor。 • 仅有 get 方方法的,称为 non-data descriptor。 • get 对 owner_class、owner_instance 访问有效。 • setdelete 仅对 owner_instance 访问有效。

4 python 元类 metaclass

创建类型的类型

class Data(object):
    pass

print("Data类型的父类是:",Data.__bases__)

print("Data的类型是:",Data.__class__)

d = Data()

print("d的类型是:",d.__class__)

Data类型的父类是: (<class 'object'>,)
Data的类型是: <class 'type'>
d的类型是: <class '__main__.Data'>

d 实例的类型是 Data ,Data的类型是type,type的类型也是type

class = metaclass(…)! ! ! # 元类创建类型 instance = class(…)! ! ! # 类型创建实例 instance.class is class! ! # 实例的类型 class.class is metaclass! ! # 类型的类型

自定义元类通常都从 type 继承,习惯以 Meta 结尾,就像抽象元类 abc.ABCMeta 那样。代码很简 单,只需注意 newinit 方方法参数的区别就行行了

class ABCMeta(type):
    def __new__(cls, name, bases, attrs):
        print("__new__",locals())

        # return type(name,bases,attrs)
        return type.__new__(cls,name,bases,attrs)

    def __init__(self,name,bases,attrs):
        print("__init__",locals())
        type.__init__(self,name,bases,attrs)


class Data(object,metaclass=ABCMeta):
    a = 1
    b = 2
    c = 3
    pass


print("Data类型的父类是:",Data.__bases__)

print("Data的类型是:",Data.__class__)

d = Data()

__new__ {'name': 'Data', 'bases': (<class 'object'>,), 'cls': <class '__main__.ABCMeta'>, 'attrs': {'a': 1, '__qualname__': 'Data', '__module__': '__main__', 'b': 2, 'c': 3}}
__init__ {'name': 'Data', 'bases': (<class 'object'>,), 'self': <class '__main__.Data'>, 'attrs': {'a': 1, '__qualname__': 'Data', '__module__': '__main__', 'b': 2, 'c': 3}}
Data类型的父类是: (<class 'object'>,)
Data的类型是: <class '__main__.ABCMeta'>
d的类型是: <class '__main__.Data'>

两个python2的例子雨痕笔记 静态类 (static class): 不允许创建实例,通常作为工工具类 (Utility) 存在。

>>> class StaticClassMeta(type):
...
def __new__(cls, name, bases, attr):
...
t = type.__new__(cls, name, bases, attr)
...
...
def ctor(cls, *args, **kwargs):
...
raise RuntimeError("Cannot create a instance of the static class!")
...
t.__new__ = staticmethod(ctor)
...
...
return t
>>> class Data(object):
...
__metaclass__ = StaticClassMeta
>>> Data()
RuntimeError: Cannot create a instance of the static class!

密封类 (sealed class): 禁止止被继承

>>> class SealedClassMeta(type):
...
_types = set()
...
...
...
...
...
def __init__(cls, name, bases, attrs):
if cls._types & set(bases): !
!
# 判断当前类型基类是否是 sealed class。
raise SyntaxError("Cannot inherit from a sealed class!")
cls._types.add(cls)! !
!
!
# 将当前类型加入入到禁止止继承集合。
>>> class A(object):
...
__metaclass__ = SealedClassMeta
>>> class B(A): pass
SyntaxError: Cannot inherit from a sealed class!

5 python extend继承 mixin混入多继承

6 python 内建函数

baidu

python进制

0x开头表示16进制,0b开头表示2进制,0o开头表示8进制 表示的数字

In [1]: 0x41
Out[1]: 65

In [19]: hex(65)
Out[19]: '0x41'

In [9]: 0b1000001
Out[9]: 65

In [13]: oct(8)
Out[13]: '0o10'

In [14]: 0o10
Out[14]: 8

In [2]: "\x41"
Out[2]: 'A'

In [6]: ord('A')
Out[6]: 65

ascii码到字符
In [24]: chr(65)
Out[24]: 'A'

In [25]: chr(0x41)
Out[25]: 'A'


In [26]: ord('A')
Out[26]: 65

In [38]: ord('严')
Out[38]: 20005

In [39]: hex(20005)
Out[39]: '0x4e25'

In [40]: bin(20005)
Out[40]: '0b100111000100101'

In [41]: "\u4e25"
Out[41]: '严'

In [42]: ord('杨')
Out[42]: 26472

In [43]: ord('洋')
Out[43]: 27915

In [44]: hex(26472)
Out[44]: '0x6768'

In [45]: hex(27915)
Out[45]: '0x6d0b'

In [46]: "\u6768\u6d0b"
Out[46]: '杨洋'

学习资料