面向对象:类 class 和 对象 object:

01. 什么是对象:

对象是指现实中的物体或实例

02. 什么是面向对象:

把一切看成对象（实例),对象和对象之间用方法（行为）建立关联关系

面向过程是一件事怎么去一步一步实现, 面向对象是一件事有谁(实例)去实现

03. 什么是类:

拥有相同属性和行为的对象分为一组, 即为一个类

类是用来描述对象的工具

04. 面向对象示意:

车(类) ----->> BYD E6(京A.88888) 对象(实例)

狗(类) ----->> 小京巴(户籍号: 00001) 对象(实例)

int(类) ----->> 100(对象,实例)

05. 类的创建语法:

class 类名(继承列表):

"""类文档字符串"""

实例方法(类内的函数methd) 的定义

类变量(class variable) 定义

类方法(@classmethod)定义

静态方法(@staticmethod)定义

06. 类的作用：

可以用类创建一个或多个此类的对象（实例)

类内的变量和方法能被此类所创建的所有实例所共同拥有

说明:

类名必须是标识符(与变量名命名规则相同, 建议首字母大写)

类名实质上就是变量, 它绑定一个类实例

类的定义最后面要加两个空格以告诉解释执行器, 类的定义已经结束

示例:

class Dog:

pass

术语:

类 对象 　实例

class object instance

07. 构造函数:

构造函数的调用表达式:　

　　类名([创建传参列表])

[] 里的内容代表可省略

作用：

　　创建这个类的实例对象, 并返回此实例对象的引用关系

示例:

class Dog: # 定义一个狗类

pass

dog1 = Dog() # 用类来创建一个对象用dog1绑定

print(id(dog1)) # 打印dog1所在的内存地址

dog2 = Dog() # 创建第二个对象 用dog2绑定

print(id(dog2))

print(dog1 is dog2) # 判断两只狗是不是同一条狗, False

实例说明:

实例有自己的作用域或名字空间, 可以为该实例添加实例变量(也叫属性)

实例可以调用类的方法

实例可以访问类中的类变量

08. 实例变量(属性 attribute):

每个实例可以有自己的变量, 称为实例变量(属性)

属性的使用语法:

实例.属性名

01. 属性的赋值规则：

(同变量规则相同)

01. 首次为属性赋值则创建此属性

02. 再次为属性赋值则改变属性的绑定关系

示例:

class Dog:

pass

dog1 = Dog()

dog1.kinds = "京巴" #为dog1绑定的实例添加kinds属性

dog1.color = "白色" # 添加属性

print(dog1.kinds, dog1.color) #　访问属性

dog1.color = '黄色' # 修改dog1.color 的绑定关系

print(dog1.color)

02. 删除属性:

del 语句

语法:

del 对象.属性名

示例:

class Student:

pass

stu = Student()

stu.name = 'xiaozhang' # 创建属性

print(stu.name)

del stu.name # 删除此属性

print(stu.name) # 属性错误,因为属性已经不存在了

03. 查找顺序:

对象.属性 : 先从对象空间找,如果找不到,再从类空间找,再找不到,再从父类找....

类名.属性 : 先从本类空间找,如果找不到,再从父类找....

09. 实例方法 method:

语法:

class 类名(继承列表):

def 实例方法名(self, 参数1, 参数2, ....):

语句块

作用：

用于描述一个对象的行为,让此类型的全部对象都拥有相同的行为

说明:

实例方法的实质是函数, 是定义在类内的函数

实例方法的第一个参数代表调用这个方法的实例, 一般命名为'self'

实例方法的调用语法:

实例.实例方法名(调用参数)

或

类名.实例方法名(实例, 调用参数)

初始化方法:

作用：

对新创建的对象添加属性等必须的资源

语法形式:

class 类名:

# [] 代表其中内容可省略

def __init__(self[, 参数列表]):

语句块

说明:

初始化方法名必须为 __init__ 不可改变

初始化方法会在构造函数创建实例后自动调用, 且将实例自身通过第一个参数 self 传入 __init__ 方法

构造函数的实参将通过 __init__ 方法的参数列表传到 __init__ 方法中

初始化方法内如果需要 return 语句返回, 则必须返回 None

示例:

# 此示例示意初始化方法的定义方法和调用过程

class Car:

"""小汽车类"""

def __init__(self, c, b, m):

self.color = c # 颜色

self.brand = b # 品牌

self.model = m # 型号

self.wheel = 4

print("__init__方法被调用")

def run(self, speed):

print(self.color, '的', self.brand,

self.model, '正在以', speed,

'公里/小时的速度行驶')

def change_color(self, c):

self.color = c

a4 = Car('红色', '奥迪', 'A4')

a4.run(199)

a4.change_color("白色")

a4.run(280)

x5 = Car('蓝色', '宝马', 'x5')

x5.run(188)

10. 析构方法:

作用：

在对象被销毁之前被调用,主要负责清理对象所占用的资源

语法形式:

class 类名:

def __del__(self):

语句块

说明:

Python建议尽可能少的在析构方法内做事情, 因为销毁时间难以确定

示例:

class FileManage:

"""定义一个文件管理员类"""

def __init__(self, filename='a.txt'):

self.file = open(filename, 'w')

def writeline(self, string):

self.file.write(string)

self.file.write('\n')

def __del__(self):

"""析构方法会在对象销毁前自动调用"""

self.file.close()

print("文件已关闭")

fm = FileManage()

fm.writeline("hello world")

fm.writeline("这是中文写的第二行")

del fm

while True: # 死循环永远不退出, del不调用一直不关闭文件

pass

print("程序结束")

11. 预置的实例属性:

__dict__ 属性:

用于绑定一个存储此实例自身变量的字典

__class__ 属性:

用于绑定创建此实例的类

示例:

class Dog:

pass

dog1 = Dog()

print(dog1.__dict__) # {}

dog1.color = "白色"

print(dog1.__dict__) # {'color': '白色'}

print(dog1.__class__) # <class '__main__.Dog'>

12. 用于类的函数:

isintance(obj, class_or_tuple)

返回这个对象obj是否是某个类的对象, 或者某些类中的一个类的对象, 如果是则返回True, 否则返回False

type(obj) 返回对象的类

对象:

属性(对象拥有的名词) 用实例变量存储

行为(对象拥有的动作) 用方法表示

13. 类变量:

类变量是类的属性, 此属性属于类, 不属于此类创建的实例

说明：

类变量,可以通过该类直接访问

类变量可以通过该类的实例直接访问

类变量可以通过此类的对象的 '__class__'属性间接访问

示例1:

class Human:

total_count = 0 # 类变量, 用于记录对象的个数

print(Human.total_count)

h1 = Human()

print(h1.total_count) # 0 # 不会出错

Human.total_count = 1 # 修改类变量

h1.total_count = 2 #添加了自己的实例属性total_count

h1.__class__.total_count = 3 # 间接修改类变量

示例2:

class Human:

total_count = 0 # 类变量，用于记录对象的个数

def __init__(self, name):

self.name = name

self.__class__.total_count += 1 # 人数加1

print(name, "对象创建")

def __del__(self):

self.__class__.total_count -= 1 # 总人数减1

print("当前对象的个数是:", Human.total_count) # 0

h1 = Human("张飞")

h2 = Human("赵云")

print("当前对象的个数是:", Human.total_count) # 2

del h2 # 或 h2 = None

print("当前对象的个数是:", Human.total_count) # 1

14. 类的 __slots__ 属性:

作用：

限定一个类创建的实例只能有固定的属性(实例变量)

说明:

__slots__ 属性是一个列表, 列表的值是字符串

含有 __slots__ 属性的类所创建的对象没有__dict__字典

示例:

class Student:

# 限定此的类创建的对象只能有name和age两个属性

__slots__ = ['name', 'age']

def __init__(self, n, a):

self.name = n

self.age = a

s1 = Student("小张", 20)

s1.Age = 21 # 此时是错写了age为Age, 会报错

print(s1.__dict__) # 出错，因为没有__dict__字典

15. 类方法 @classmethod:

类方法是操作类的方法, 类方法属于类, 不属于该类创建的对象

说明:

类方法需要使用@classmethod装饰器定义

类方法的第一个参数用来绑定类, 约定写为cls

类和对象实例都可以调用类方法

类方法不能访问此类创建的对象的属性

示例:

class A:

v = 0 # 类变量

@classmethod

def get_v(cls): #此方法不是实例方法, 是类方法

return cls.v

a = A()

a.get_v() # 0

A.get_v() # 0

a.__dict__ # {}

16. 静态方法 @staticmethod:

静态方法是定义在类的内部的函数, 此函数作用域是类的内部

说明:

静态方法需要使用@staticmethod装饰器定义　

静态方法与普通函数的定义相同, 不需要传入self和cls

静态方法只能凭借该类和实例来调用

静态方法不能访问类变量和实例变量

示例：

　　class A:

@staticmethod

def myadd(a, b):

return a + b

print(A.myadd(100, 200)) # 300

a = A()

print(a.myadd(300, 400)) # 300

17. 继承 inheritance 和 派生 derived:

什么是继承 / 派生

继承是从已有类中派生出新类, 新类具有原类的数据属性和行为,并能扩展新的能力

派生就是从一个已有的类衍生出新类, 在新的类上添加新的属性和行为

作用：

01. 用继承派生机制, 可以将一些共有功能加在基类中, 实现代码的共享

02. 在不改变超类的代码的基础上, 改变原有的功能

名词:

基类(base class) / 超类(super class) / 父类(father class)

派生类(derived class) / 子类(child class)

单继承:

语法:

class 类名(超类名):

语句块

示例:

class Human: # 人

def say(self, what): # 说话的行为

print("说: ", what)

def walk(self, distance): # 走路的行为

print("走了", distance, "公里")

h1 = Human()

h1.say("今天天气不错!")

h1.walk(5)

class Student(Human):

# def say(self, what): # 说话的行为

# print("说: ", what)

# def walk(self, distance): # 走路的行为

# print("走了", distance, "公里")

def study(self, subject):

print("正在学习", subject)

s1 = Student()

s1.say("今天晚饭吃什么？")

s1.walk(3)

s1.study("python")

继承说明:

任何类都直接或间接的继承自object类

object类是一切类的超类

18. 类内的　__base__属性:

此属性用来记录此类的基类

示例:

In [9]: class A:

...: pass

...:

In [10]: class B(A):

...: pass

...:

In [11]: B.__base__

Out[11]: __main__.A

In [12]: A.__base__

Out[12]: object

19. 覆盖: override:

什么是覆盖

覆盖是指在有继承派生关系的类中, 子类中实现了与基类(超类)同名的方法

在子类实例调用方法时, 实际调用的是子类中的覆盖版本, 这种现象叫做覆盖

示例:

class A:

def work(self):

print("A类的work方法被调用")

class B(A):

def work(self):

print("B类的work方法被调用")

b = B()

b.work() # 子类已经覆盖了父类的方法

20. super函数:

super(type, obj) 返回绑定超类的实例（要求obj必须为type类型的实例)

super() 返回绑定超类的实例, 等同于super(__class__, 实例的第一个参数), 且必须在方法内调用

作用：

　　返回超类的实例, 用超类实例来调用其自身的方法

说明：

　　当子类实现了__init__方法后, 父类的__init__方法将被覆盖

即不再会主动调用父类的__init__方法, 会引起父类的属性得不到初始化

此时需要显式调用父类的初始化方法

示例1:

# 此示例示意用super函数访问父类的覆盖方法

class A:

def work(self):

print("A类的work方法被调用")

class B(A):

def work(self):

print("B类的work方法被调用")

def doworks(self):

# self.work() # 调用B类的

super(B, self).work() # 调用超类的方法

super().work() # 一样会调用超类的方法

# super(__class__, self).work()

b = B()

b.work() # B类的work方法被调用

print("-----以下用b调用覆盖版本的方法----")

# A.work(b) # A类的work方法被调用

super(B, b).work()

b.doworks()

示例2:

# 此示例示意显式调用基类的初始化方法

class Human:

def __init__(self, n, a):

self.name = n

self.age = a

print("Human类的 __init__被调用")

def show_info(self):

print("姓名:", self.name)

print("年龄:", self.age)

class Student(Human):

""""""

def __init__(self, n, a, s=0):

super().__init__(n, a) # 显式调用基类的初始化方法

self.score = s

print("Student类的 __init__被调用")

def show_info(self):

super().show_info()

print("成绩:", self.score)

s1 = Student('coco', 20)

s1.show_info()

21. issubclass 函数:

issubclass(cls, class_or_tuple)

判断一个类是否是继承自其它的类, 如果此类cls是class或tuple中的一个派生子类则返回True,否则返回False

示例:

class A:

pass

class B(A):

pass

class C(B):

pass

class D(B):

pass

issubclass(B, A) # True

issubclass(C, B) # True

issubclass(D, C) # False

issubclass(C, (int, str)) False

22. 封装 enclosure:

封装是指隐藏类的实现细节．让使用者不关心这些细节;

封装的目的是让使用者通过尽可能少的使用实例变量名(属性)操作对象

私有属性和方法

python类中以双下划线('__')开头, 不以双下划线结尾的标识符为私有成员

私有成员只能被方法调用, 不能在子类或其它地方使用

私有成员有两种:

私有属性

私有方法

示例:

class A:

def __init__(self):

self.__p1 = 100 # 创建私有属性

def __m1(self):

print("A类的私有方法被调用!")

def test(self):

print(self.__p1) # 可以访问

self.__m1() # 可以访问!

a = A()

# print(a.__p1) #　　出错, 不可以访问

# a.__m1() # 出错, 在类外部不能调用类的私有方法

a.test() # 用方法来操作私有属性和私有方法

a.__dict__ # {'_A__p1': 100}

a._A__p1 # 100

示例2:

class Parent:

def __func(self):

print('in Parent func')

def __init__(self):

self.__func()

class Son(Parent):

def __func(self):

print('in Son func')

son1 = Son() # in Parent func

23. 多态　 polymorphic:

字面意思：多种状态

多态是指在有继承／派生关系的类中,调用基类对象的方法,实际能调用子类的覆盖方法的现象叫多态

多态说明:

多态调用方法与对象相关, 不与类相关

python的全部对象只有"运行时状态(动态)", 没有"C++/Java"里的"编译时状态（静态）"

面向对象编程语言的特征:

封装

继承

多态

面向对象的语言: C++/Java/Python/Swift/C#

示例1:

class Shape:

def draw(self):

pass

class Point(Shape):

def draw(self):

print("正在画一个点")

class Circle(Point):

def draw(self):

print("正在画一个圆")

def my_draw(s):

s.draw() # 在运行时动态决定调用的方法

s1 = Circle()

s2 = Point()

my_draw(s1) # 正在画一个圆

my_draw(s2) # 正在画一个点

示例2:

class MiniOS(object):

"""MiniOS 操作系统类 """

def __init__(self, name):

self.name = name

self.apps = [] # 安装的应用程序名称列表

def __str__(self):

return "%s 安装的软件列表为 %s" % (self.name, str(self.apps))

def install_app(self, app):

# 判断是否已经安装了软件

if app.name in self.apps:

print("已经安装了 %s，无需再次安装" % app.name)

else:

app.install()

self.apps.append(app.name)

class App(object):

def __init__(self, name, version, desc):

self.name = name

self.version = version

self.desc = desc

def __str__(self):

return "%s 的当前版本是 %s - %s" % (self.name, self.version, self.desc)

def install(self):

print("将 %s [%s] 的执行程序复制到程序目录..." % (self.name, self.version))

class PyCharm(App):

pass

class Chrome(App):

def install(self):

print("正在解压缩安装程序...")

super().install()

linux = MiniOS("Linux")

print(linux)

pycharm = PyCharm("PyCharm", "1.0", "python 开发的 IDE 环境")

chrome = Chrome("Chrome", "2.0", "谷歌浏览器")

linux.install_app(pycharm)

linux.install_app(chrome)

linux.install_app(chrome)

print(linux)

24. 多继承 multiple inheritance:

多继承是指一个子类继承自两个或两个以上的基类

语法:

class 类名(超类名1, 超类名2, ...):

pass

示例:

class Car:

def run(self, speed):

print("汽车以", speed, "km/h的速度行驶")

class Plane:

def fly(self, height):

print("飞机以海拔", height, "米的高度飞行")

class PlaneCar(Car, Plane):

"""飞行汽车类， 时继承 自Car和 Plane"""

pass

p1 = PlaneCar()

p1.fly(10000) # 飞机以海拔 10000 米的高度飞行

p1.run(299) # 汽车以 299 km/h的速度行驶

多继承的问题（缺陷）

标识符(名字空间)冲突的问题

要谨慎使用多继承

示例:

# 小张写了一个类A

class A:

def m(self):

print("A.m()被调用")

# 小李写了一个类B:

class B:

def m(self):

print("B.m() 被调用")

# 小王感觉小张和小李写的两个类自己可以用

class AB(A, B):

pass

ab = AB()

ab.m() # 调用A类中的m方法

25. 多继承的 MRO (Method Resolution Order)问题:

MRO 方法搜索顺序问题

python 3 广度优先: 一条路走到倒数第二级,判断,如果其他路能走到终点,则返回走另一条路.如果不能,则走到终点.

python 2 深度优先: 一条路走到底.

单独调用父类的方法示例:

print("******多继承使用类名.__init__ 发生的状态******")

class Parent(object):

def __init__(self, name):

print('parent的init开始被调用')

self.name = name

print('parent的init结束被调用')

class Son1(Parent):

def __init__(self, name, age):

print('Son1的init开始被调用')

self.age = age

Parent.__init__(self, name)

print('Son1的init结束被调用')

class Son2(Parent):

def __init__(self, name, gender):

print('Son2的init开始被调用')

self.gender = gender

Parent.__init__(self, name)

print('Son2的init结束被调用')

class Grandson(Son1, Son2):

def __init__(self, name, age, gender):

print('Grandson的init开始被调用')

Son1.__init__(self, name, age) # 单独调用父类的初始化方法

Son2.__init__(self, name, gender)

print('Grandson的init结束被调用')

gs = Grandson('grandson', 12, '男')

print('姓名：', gs.name)

print('年龄：', gs.age)

print('性别：', gs.gender)

print("******多继承使用类名.__init__ 发生的状态******\n\n")

多继承中super调用有所父类的被重写的方法示例:

print("******多继承使用super().__init__ 发生的状态******")

class Parent(object):

def __init__(self, name, *args, **kwargs): # 为避免多继承报错，使用不定长参数，接受参数

print('parent的init开始被调用')

self.name = name

print('parent的init结束被调用')

class Son1(Parent):

def __init__(self, name, age, *args, **kwargs): # 为避免多继承报错，使用不定长参数，接受参数

print('Son1的init开始被调用')

self.age = age

super().__init__(name, *args, **kwargs) # 为避免多继承报错，使用不定长参数，接受参数

print('Son1的init结束被调用')

class Son2(Parent):

def __init__(self, name, gender, *args, **kwargs): # 为避免多继承报错，使用不定长参数，接受参数

print('Son2的init开始被调用')

self.gender = gender

super().__init__(name, *args, **kwargs) # 为避免多继承报错，使用不定长参数，接受参数

print('Son2的init结束被调用')

class Grandson(Son1, Son2):

def __init__(self, name, age, gender):

print('Grandson的init开始被调用')

# 多继承时，相对于使用类名.__init__方法，要把每个父类全部写一遍

# 而super只用一句话，执行了全部父类的方法，这也是为何多继承需要全部传参的一个原因

# super(Grandson, self).__init__(name, age, gender)

super().__init__(name, age, gender)

print('Grandson的init结束被调用')

print(Grandson.__mro__)

gs = Grandson('grandson', 12, '男')

print('姓名：', gs.name)

print('年龄：', gs.age)

print('性别：', gs.gender)

print("******多继承使用super().__init__ 发生的状态******\n\n")

单继承中super示例:

print("******单继承使用super().__init__ 发生的状态******")

class Parent(object):

def __init__(self, name):

print('parent的init开始被调用')

self.name = name

print('parent的init结束被调用')

class Son1(Parent):

def __init__(self, name, age):

print('Son1的init开始被调用')

self.age = age

super().__init__(name) # 单继承不能提供全部参数

print('Son1的init结束被调用')

class Grandson(Son1):

def __init__(self, name, age, gender):

print('Grandson的init开始被调用')

super().__init__(name, age) # 单继承不能提供全部参数

print('Grandson的init结束被调用')

gs = Grandson('grandson', 12, '男')

print('姓名：', gs.name)

print('年龄：', gs.age)

#print('性别：', gs.gender)

print("******单继承使用super().__init__ 发生的状态******\n\n")

26. 函数重写 overwrite:

什么是函数重写

在自定义的类中,通过添加特定的方法,让自定义的类生成的对象(实例) 能象内建对象一样进行内建函数操作

对象转字符串函数重写

repr(obj) 返回一个能代表此对象的字符串,通常:eval(repr(obj)) == obj

str(obj) 通过给定的对象返回一个字符串(这个字符串通常是给人阅读的)

换句话说:

repr(obj) 返回的字符串是给python用的

str(obj) 返回字符串是给人看的

示例:

class B:

def __str__(self):

return 'str : class B'

def __repr__(self):

return 'repr : class B'

b=B()

print('%s'%b) # str : class B

print('%r'%b) # repr : class B

27. 重写方法:

repr(obj) 函数的重写方法 def __repr__(self)

str(obj) 函数的重写方法 def __str__(self)

当对象没有 __str__方法时, 则返回__repr__(self)的值

01. 内建函数重写:

obj.__abs__() 方法对应 abs(obj)

obj.__len__() 方法对应 len(obj)

obj.__reversed__() 方法对应 reversed(obj)

obj.__round__() 方法对应 round(obj)

示例:

# 此示例示意abs(obj) 函数的重写方法 obj.__abs__() 方法的使用

class MyInteger:

def __init__(self, value):

self.data = value

def __repr__(self):

return 'MyInteger(%d)' % self.data

def __abs__(self):

if self.data < 0:

return MyInteger(-self.data) # 创建一个新的以对象并返回

return MyInteger(self.data)

def __len__(self):

'''len(x)函数规定只能返回整数值，

因此此方法不能返回字符串等其它类型的值'''

return 100

I1 = MyInteger(-10)

print(I1) # <-- 此处等同于print(str(I1))

I2 = abs(I1) # I2 = MyInteger(10)

print(I2) # MyInteger(10)

print(len(I1)) # I1.__len__()

02. 数值转换函数重写:

obj.__complex__() 对应 complex(obj)

obj.__int__() 对应 int(obj)

obj.__float__() 对应 float(obj)

obj.__bool__() 对应 bool(obj)

03. 布尔测试函数的重写:

格式:

def __bool__(self):

pass

作用：

1. 用于bool(obj)函数取值

2. 用于if语句真值表达式中

3. 用于while语句真值表达式中

说明:

布测试式方法的查找顺序是 __bool__方法, 其次是__len__方法

如果没有以上方法则返回True

示例:

# 此示例示意 bool 真值测试函数的重写

class MyList:

'''定义一个容器类，用于存储任意类型的数据

其内部的存储方式用list实现

'''

def __init__(self, iterable):

self.data = [x for x in iterable]

def __repr__(self):

return 'MyList(%s)' % self.data

def __len__(self):

print("__len__ 方法被调用!")

return len(self.data) # 返回列表的长度

def __bool__(self):

print('__bool__方法被调用')

'''此方法用于bool(obj) 函数取值，优先取此函

数的返回值，此方法用于定义bool(obj)的取值规则'''

# 规则，所有元素的和为0,则返回False否则返回True

return sum(self.data) != 0

myl = MyList([1, -2, 5, -4])

print(myl) # MyList([1, -2, 5, -4])

print('bool(myl) =', bool(myl))

if myl:

print('myl 的布尔值为True')

else:

print('myl 的布尔值为False')

04. 自定制格式化字符串__format__ :

format_dict={

'nat':'{obj.name}-{obj.addr}-{obj.type}',#学校名-学校地址-学校类型

'tna':'{obj.type}:{obj.name}:{obj.addr}',#学校类型:学校名:学校地址

'tan':'{obj.type}/{obj.addr}/{obj.name}',#学校类型/学校地址/学校名

}

class School:

def __init__(self,name,addr,type):

self.name=name

self.addr=addr

self.type=type

def __repr__(self):

return 'School(%s,%s)' %(self.name,self.addr)

def __str__(self):

return '(%s,%s)' %(self.name,self.addr)

def __format__(self, format_spec):

# if format_spec

if not format_spec or format_spec not in format_dict:

format_spec='nat'

fmt=format_dict[format_spec]

return fmt.format(obj=self)

s1=School('oldboy1','北京','私立')

print('from repr: ',repr(s1))

print('from str: ',str(s1))

print(s1)

'''

str函数或者print函数--->obj.__str__()

repr或者交互式解释器--->obj.__repr__()

如果__str__没有被定义,那么就会使用__repr__来代替输出

注意:这俩方法的返回值必须是字符串,否则抛出异常

'''

print(format(s1,'nat'))

print(format(s1,'tna'))

print(format(s1,'tan'))

print(format(s1,'asfdasdffd'))

28. 迭代器(高级):

什么是迭代器

可以通过 next(obj) 函数取值的对象, 就是迭代器

迭代器协议:

迭代器议是指对象能够使用next函数获取下一项数据, 在没有下一项数据时触发一个StopIteration异常来终止迭代的约定

迭代器协议的实现方法:

在类内需要定义 __next__(self)方法来实现迭代器协议

语法形式:

class MyIterator:

def __next__(self):

迭代器协议

return 数据

什么是可迭代对象

是指能用iter(obj)函数返回迭代器的对象(实例)

可迭代对象的内部要定义 __iter__(self)方法来返回迭代器对象

29. 属性管理函数(反射):

getattr(obj, name[, default]) 从一个对象得到对象的属性；getattr(x, 'y') 等同于x.y; 当属性不存在时,如果给出default参数,则返回default,如果没有给出default 则产生一个AttributeError错误

hasattr(obj, name) 用给定的name返回对象obj是否有此属性,此种做法可以避免在getattr(obj, name)时引发错误

setattr(obj, name, value) 给对象obj的名为name的属性设置相应的值value, set(x, 'y', v) 等同于 x.y = v

delattr(obj, name) 删除对象obj中的name属性, delattr(x, 'y') 等同于 del x.y

示例1:

# 类反射

class Student:

ROLE = 'STUDENT'

@classmethod

def check_course(cls):

print('查看课程了')

@staticmethod

def login():

print('登录')

# 反射查看属性

print(Student.ROLE) # STUDENT

print(getattr(Student,'ROLE')) # STUDENT

# 反射调用方法

getattr(Student,'check_course')() # 查看课程了

getattr(Student,'login')() # 登录

num = input('>>>') # login

if hasattr(Student,num):

getattr(Student,num)() # 登录

示例2:

# 对象放射

class Foo:

f = '类的静态变量'

def __init__(self,name,age):

self.name=name

self.age=age

def say_hi(self):

print('hi,%s'%self.name)

obj=Foo('egon',73)

#检测是否含有某属性

print(hasattr(obj,'name'))

print(hasattr(obj,'say_hi'))

#获取属性

n=getattr(obj,'name')

print(n)

func=getattr(obj,'say_hi')

func()

print(getattr(obj,'aaaaaaaa','不存在啊')) #报错

#设置属性

setattr(obj,'sb',True)

setattr(obj,'show_name',lambda self:self.name+'sb')

print(obj.__dict__)

print(obj.show_name(obj))

#删除属性

delattr(obj,'age')

delattr(obj,'show_name')

delattr(obj,'show_name111')#不存在,则报错

print(obj.__dict__)

示例3:

# 类反射

class Foo(object):

staticField = "old boy"

def __init__(self):

self.name = 'wupeiqi'

def func(self):

return 'func'

@staticmethod

def bar():

return 'bar'

print getattr(Foo, 'staticField')

print getattr(Foo, 'func')

print getattr(Foo, 'bar')

示例4:

# 反射当前模块成员

import sys

def s1():

print 's1'

def s2():

print 's2'

this_module = sys.modules[__name__]

hasattr(this_module, 's1')

getattr(this_module, 's2')

示例5:

# 导入其他模块，利用反射查找该模块是否存在某个方法

def test():

print('from the test')

"""

程序目录：

module_test.py

index.py

当前文件：

index.py

"""

import module_test as obj

#obj.test()

print(hasattr(obj,'test'))

getattr(obj,'test')()

30. 异常(高级):

with语句

语法：

with 表达式1 [as 变量名1], 表达式2 [as 变量名2], ...

作用:

用于对资源访问的场合, 确保使用过程中不管是否发生异常, 都会执行必要有"清理"操作, 并释放资源.

如:

文件打开后自动关闭, 线程中锁的自动获取和释放

说明:

with语句与try-finally相似, 并不会必变异常状态

as 子句用于绑定表达式创建的对象

示例:

# 打开文件读取文件数据(with来实现关闭文件)

def read_file():

try:

# f = open("abcd.txt")

with open('abcd.txt') as f:

while True:

s = f.readline()

if not s:

break # return

int(input("请输入任意数字打印下一行:"))

print(s)

print("文件已经关闭")

except IOError:

print("出现异常已经捕获!")

except ValueError:

print("程序已转为正常状态")

read_file()

print("程序结束")

31. 环境管理器(上下文管理器):

1. 类内有__enter__ 和 __exit__方法的类被称为环境管理器

2. 能够用with进行管理的对象必须是环境管理器

3. __enter__ 将在进入with语句时被调用, 并返回由as变量管理的对象

4. __exit__ 将在离开with语句时被调用, 且可以用参数来判断离开with语句时是否出现异常并做出相应的处理

示例:

# 本程序示意自定义的类作为环境管理器使用

class FileWriter:

def __init__(self, filename):

self.filename = filename # 此属性用于记住文件名

def writeline(self, s):

'''此方法用于向文件内写入字符串，同时自动添加换行'''

self.file.write(s)

self.file.write('\n')

def __enter__(self):

'''此方法用于实现环境管理器'''

self.file = open(self.filename, 'w')

print("已进入__enter__方法，文件打开成功")

return self # 返回值向用于 with中的as 绑定

def __exit__(self, exec_type, exec_value, exec_tb):

'''

exec_type 为异常类异,没有异常发生时为None

exec_value 为错误的对象,没有异常时为None

exec_tb 为错误的traceback对象

'''

self.file.close()

print("文件", self.filename, "已经关闭")

if exec_type is None:

print("退出with时没有发生异常")

else:

print("退出with时，有异常，类型是", exec_type,

"错误是", exec_value)

print("__exit__法被调用,已离开with语句")

try:

with FileWriter('log.txt') as fw:

while True:

s = input("请输入一行: ")

if s == 'exit':

break

if s == 'error':

raise ValueError("故意制造的值错误")

fw.writeline(s)

except:

print("有错误发生，已转为正常")

print("这是with语句之外，也是程序的最后一条语句")

32. 运算符重载:

什么是运算符重载

让自定义的类生成的对象（实例）能够使用运算符进行操作

作用：

让实例象数学表达式一样进行运算操作

让程序简洁易读

说明:

运算符重载方法的参数已经有固定的含义, 不建议改变原有的含义

01. 算术运算符:

方法名 运算符

__add__ 加法 +

__sub__ 减法 -

__mul__ 乘法 *

__truediv__ 除法 /

__floordiv__ 地板除 //

__mod__ 取模(求余) %

__pow__ 幂 **

二元运算符重载方法格式:

def __xxx__(self, other):

....

示例:

# 此程序示意运算符重载

class MyNumber:

def __init__(self, v):

self.data = v

def __repr__(self):

return "MyNumber(%d)" % self.data

def __add__(self, other):

print("__add__方法被调用")

obj = MyNumber(self.data + other.data)

return obj

def __sub__(self, other):

return MyNumber(self.data - other.data)

n1 = MyNumber(100)

n2 = MyNumber(200)

# n3 = n1.__add__(n2)

n3 = n1 + n2 # 等同于 n1.__add__(n2)

print(n3)

n4 = n2 - n1

print('n4 =', n4) # MyNumber(100)

02. 反向算术运算符:

方法名 运算符

__radd__ 加法 +

__rsub__ 减法 -

__rmul__ 乘法 *

__rtruediv__ 除法 /

__rfloordiv__ 地板除 //

__rmod__ 取模(求余) %

__rpow__ 幂 **

示例:

# 此示例示意返向算术运算符的重载

class MyList:

def __init__(self, iterable):

self.data = [x for x in iterable]

def __repr__(self):

return 'MyList(%r)' % self.data

def __mul__(self, rhs):

return MyList(self.data * rhs)

def __rmul__(self, lhs):

print("__rmul__被调用, lhs=", lhs)

return MyList(self.data * lhs) # lhs (left hand side)

L1 = MyList([1, 2, 3])

L2 = MyList(range(4, 7))

L4 = L1 * 2 # 实现乘法运算

print('L4 =', L4) # MyList([1,2,3,1,2,3])

L5 = 2 * L1

print(L5)

03. 复合赋值运算符重载:

方法名 运算符

__iadd__ 加法 +=

__isub__ 减法 -=

__imul__ 乘法 *=

__itruediv__ 除法 /=

__ifloordiv__ 地板除 //=

__imod__ 取模(求余) %=

__ipow__ 幂 **=

示例:

# 此示例示意复合赋值算术运算符的重载

class MyList:

def __init__(self, iterable):

self.data = [x for x in iterable]

def __repr__(self):

return 'MyList(%r)' % self.data

def __add__(self, rhs):

print("__add__方法被调用")

return MyList(self.data + rhs.data)

def __iadd__(self, rhs):

print("__iadd__方法被调用")

self.data.extend(rhs.data)

return self

L1 = MyList([1, 2, 3])

L2 = MyList(range(4, 7))

print("id(L1) =", id(L1))

L1 += L2 # 相当于 L1 = L1 + L2

print('L1 =', L1)

print("id(L1) =", id(L1))

问题:

# 解法1

a = [100]

def test(x):

x = x + x

print(x)

test(a) # [100, 100]

print(a) # [100]

# 解法2

a = [100]

def test(x):

x += x # 此处与上题不同。结果也会不同

print(x)

test(a) # [100, 100]

print(a) # [100, 100]

04. 比较的运算符的重载:

__lt__ < 小于

__le__ <= 小于等于

__gt__ > 大于

__ge__ >= 大于等于

__eq__ == 等于

__ne__ != 不等于

注:

比较运算符通常返回True或False

05. 位运算符重载:

__inert__ ~ 取反(一元运算符)

__and__ & 位与(交集)

__or__ | 位或(并集)

__xor__ ^ 位异或(对称补集)

__lshift__ << 左移

__rshift__ >> 右移

06. 反向位运算符重载:

同算术运算符相同

__rand__ & 位与(交集)

__ror__ | 位或(并集)

__rxor__ ^ 位异或(对称补集)

__rlshift__ << 左移

__rrshift__ >> 右移

07. 复合赋值运算符重载:

__iand__ &= 位与(交集)

__ior__ |= 位或(并集)

__ixor__ ^= 位异或(对称补集)

__ilshift__ <<= 左移

__irshift__ >>= 右移

08. 一元运算符的重载:

__neg__ - 负号

__pos__ + 正号

__invert__ ~ 按位取反

格式:

def __xxx__(self):

....

示例:

# 此示例示意一元运算符的重载

class MyList:

def __init__(self, iterable):

self.data = [x for x in iterable]

def __repr__(self):

return 'MyList(%r)' % self.data

def __neg__(self):

print("__neg__方法被调用!")

L = (-x for x in self.data)

return MyList(L)

L1 = MyList([1, -2, 3, -4, 5])

print("L1 =", L1)

L2 = -L1

print("L2 =", L2)

09. in / not in 运算符的重载:

格式:

def __contains__(self, e): # e代表元素

...

说明:

not in 相当于 in取反, 所有只需要重载in 即可

# 此示例示意in / not in 运算符的重载

class MyList:

def __init__(self, iterable):

self.data = [x for x in iterable]

def __repr__(self):

return 'MyList(%r)' % self.data

def __contains__(self, e): # e 代表测试元素

print("__contains__被调用")

for x in self.data:

if e == x: # 如果相同，则说明e在列表中

return True

return False

L1 = MyList([1, -2, 3, -4, 5])

if 2 in L1: # 需要重载 __contains__方法

print("2在L1中")

else:

print("2 不在L1中")

10.索引和切片运算符的重载:

重载方法:

__getitem__(self, i) 用于索引/切片取值

__setitem__(self, i) 用于索引/切片赋值

__delitem__(self, i) 用于del语句删除索引操作

作用：

让自定义的类型的对象能够支持索引和切片操作

示例:

# 此示例示意索引 index 和切片 slice 运算符的重载

class MyList:

def __init__(self, iterable):

self.data = [x for x in iterable]

def __repr__(self):

return 'MyList(%r)' % self.data

def __getitem__(self, i):

print("__getitem__被调用", i)

return self.data[i]

def __setitem__(self, i, v):

self.data[i] = v

L1 = MyList([1, -2, 3, -4, 5])

print(L[0:2]) # [1, -2]

print(L1[2]) # 3

L1[1] = 2

print(L1) # MyList([1, 2, 3, -4, 5])

33. 组合:

给一个类的对象封装一个属性,这个属性是另一个类的对象

示例1:

class GameRole:

"""英雄人物类"""

def __init__(self, name, ad, hp):

self.name = name

self.ad = ad

self.hp = hp

def attack(self,p):

p.hp = p.hp - self.ad

print('%s 攻击 %s,%s 掉了%s血,还剩%s血' %(self.name,p.name,p.name,self.ad,p.hp))

def armament_weapon(self,wea):

self.wea = wea

class Weapon:

"""武器属性类"""

def __init__(self,name,ad):

self.name = name

self.ad = ad

def fight(self,p1,p2):

p2.hp = p2.hp - self.ad

print('%s 用%s打了%s,%s 掉了%s血,还剩%s血'\

% (p1.name,self.name,p2.name,p2.name,self.ad,p2.hp))

p1 = GameRole('coco',20,500)

p2 = GameRole('cat',50,200)

axe = Weapon('三板斧',60)

broadsword = Weapon('屠龙宝刀',100)

p1.armament_weapon(axe) # 给coco装备了三板斧这个对象.

p1.wea.fight(p1,p2)

示例2:

# 组合实现与类的关联

class School:

def __init__(self, name, addr):

self.name = name

self.addr = addr

class Course:

def __init__(self, name, price, school):

self.name = name

self.price = price

self.school = school

s1 = School("coco", "成都")

s2 = School("coco", "广州")

msg = """

1 coco 成都

2 coco 广州

"""

while True:

print(msg)

menu = {

"1": s1,

"2": s2

}

choice = input("请选择学校>>>:")

school_obj = menu[choice]

name = input("课程名：")

price = input("课程费用：")

new_course = Course(name, price, school_obj)

print("课程 %s 属于 %s 学校" % (new_course.name, new_course.school.name))

34. 接口类, 抽象类:

定制一个规范, 让其子类必须按照此规范实现

示例:

from abc import ABCMeta, abstractmethod

class Payment(metaclass=ABCMeta): # 抽象类(接口类):

@abstractmethod

def pay(self): # 制定了一个规范

pass

class Alipay(Payment):

def __init__(self,money):

self.money = money

def pay(self):

print('使用支付宝支付了%s' %self.money)

class Jdpay(Payment):

def __init__(self, money):

self.money = money

def pay(self):

print('使用京东支付了%s' % self.money)

class Wechatpay(Payment):

def __init__(self,money):

self.money = money

def pay(self):

print('使用微信支付了%s' % self.money)

def pay(obj):

obj.pay()

w1 = Wechatpay(200)

a1 = Alipay(200)

j1 = Jdpay(100)

pay(a1) # 归一化设计

pay(j1)

35. 静态属性:

将方法伪装成一个属性,代码上没有什么提升,只是更合理

语法:

@property

@属性名.setter

@属性名.deleter

示例1:

class Person:

def __init__(self,name,age):

self.name = name

if type(age) is int:

self.__age = age

else:

print( '你输入的年龄的类型有误,请输入数字')

@property

def age(self):

return self.__age

@age.setter

def age(self,a1):

'''判断,你修改的年龄必须是数字'''

if type(a1) is int:

self.__age = a1

else:

print('你输入的年龄的类型有误,请输入数字')

@age.deleter

def age(self):

del self.__age

p1 = Person('帅哥',20)

print(p1.age) # 20

print(p1.__dict__) # {'name': '帅哥', '_Person__age': 20}

p1.age = 23

print(p1.age) # 23

del p1.age

示例2:

# 使用property取代getter和setter方法

class Money(object):

def __init__(self):

self.__money = 0

# 使用装饰器对money进行装饰，那么会自动添加一个叫money的属性，当调用获取money的值时，调用装饰的方法

@property

def money(self):

return self.__money

# 使用装饰器对money进行装饰，当对money设置值时，调用装饰的方法

@money.setter

def money(self, value):

if isinstance(value, int):

self.__money = value

else:

print("error:不是整型数字")

a = Money()

a.money = 100

print(a.money)

36. 单例:

如果一个类 从头到尾只能有一个实例,说明从头到尾之开辟了一块儿属于对象的空间,那么这个类就是一个单例类

示例1:

class Single:

__ISINCTANCE = None

def __new__(cls, *args, **kwargs):

if not cls.__ISINCTANCE:

cls.__ISINCTANCE = object.__new__(cls)

return cls.__ISINCTANCE

def __init__(self,name,age):

# self.name = name

# self.age = age

print(self)

s1 = Single('coco',23)

s2 = Single('gogo',40)

示例2:

class MusicPlayer(object):

# 记录第一个被创建对象的引用

instance = None

# 记录是否执行过初始化动作

init_flag = False

def __new__(cls, *args, **kwargs):

# 1.判断类属性是否是空对象

if cls.instance is None:

# 2.调用父类方法，为第一个对象分配空间

cls.instance = super().__new__(cls)

# 3.返回类属性保存的对象引用

return cls.instance

def __init__(self):

# 1.判断是否执行过初始化动作

if MusicPlayer.init_flag:

return

# 2.没有执行过，再执行初始化动作

print("初始化播放器")

# 3.修改类属性标记

MusicPlayer.init_flag = True

player1 = MusicPlayer() # 初始化播放器

print(player1) # <__main__.MusicPlayer object at 0x0000000006AA28D0>

player2 = MusicPlayer()

print(player2) # <__main__.MusicPlayer object at 0x0000000006AA28D0>

37. __new__ 构造方法:

class Single:

def __new__(cls, *args, **kwargs):

# print('在new方法里')

obj = object.__new__(cls)

print('在new方法里',obj)

return obj

def __init__(self):

print('在init方法里',self)

01.开辟一个空间,属于对象的

02.把对象的空间传给self,执行init

03.将这个对象的空间返回给调用者

obj = Single()

single的new,single没有,只能调用object的new方法

new方法在实例化之后,__init__ 之前先执行new来创建一块空间

38. __call__ 方法:

__call__ 相当于 对象()

class A:

def __call__(self, *args, **kwargs):

print('执行call方法了')

def call(self):

print('执行call方法了')

class B:

def __init__(self,cls):

print('在实例化A之前做一些事情')

self.a = cls()

self.a()

print('在实例化A之后做一些事情')

a = A()

a() # 对象() == 相当于调用__call__方法

a.call()

A()() # 类名()() ,相当于先实例化得到一个对象,再对对象(),==>和上面的结果一样,相当于调用__call__方法

B(A)

39. item 系列方法:

item系列 和对象使用[]访问值有联系

示例1:

obj = {'k':'v'}

print(obj) # 字典的对象

print(obj['k'])

class B:

def __getitem__(self, item):

return getattr(self,item)

def __setitem__(self, key, value):

setattr(self,key,value*2)

def __delitem__(self, key):

delattr(self,key)

b = B()

# b.k2 = 'v2'

# print(b.k2)

b['k1'] = 'v1' # __setitem__

print(b['k1']) # __getitem__

del b['k1'] # __delitem__

print(b['k1'])

示例2:

class Foo:

def __init__(self,name):

self.name=name

def __getitem__(self, item):

print(self.__dict__[item])

def __setitem__(self, key, value):

self.__dict__[key]=value

def __delitem__(self, key):

print('del obj[key]时,我执行')

self.__dict__.pop(key)

def __delattr__(self, item):

print('del obj.key时,我执行')

self.__dict__.pop(item)

f1=Foo('sb')

f1['age']=18

f1['age1']=19

del f1.age1 # del obj.key时,我执行

del f1['age'] # del obj[key]时,我执行

f1['name']='coco'

print(f1.__dict__) # {'name': 'coco'}

40. __eq__ 方法:

class A:

def __init__(self,name,age):

self.name = name

self.age = age

def __eq__(self, other):

if self.name == other.name and self.age == other.age:

return True

a = A('gogo',83)

aa = A('gogo',83)

aa2 = A('gogo',83)

aa3 = A('gogo',83)

aa4 = A('gogo',83)

print(a,aa)

print(aa3 == aa == aa4) # ==这个语法 是完全和__eq__

41. 面向对象设计:

def dogs(name, gender, type):

# 狗的属性

def init(name, gender, type):

dog = {

"name": name,

"gender": gender,

"type": type,

"run": run

}

return dog

# 狗的方法

def run(dog):

print("一条狗%s正在跑" % dog["name"])

return init(name, gender, type)

d1 = dogs("wangcai", "公", "中华田园犬")

d2 = dogs("xiaoqiang", "公", "哈士奇")

print("面向对象设计", d1)

d1["run"](d1)

print(d2["name"])

# 面向对象编程-->用面向对象独有的class语法实现面向对象设计

class Dog:

"""定义一个狗类"""

def __init__(self,name, gender, type):

self.name = name

self.gender = gender

self.type = type

def run(self):

print("一条狗%s正在跑" % self.name)

dog1 = Dog("wangcai", "公", "中华田园犬")

dog2 = Dog("xiaoqiang", "公", "哈士奇")

print("面向对象编程", dog1.__dict__) # __dict__ 查看属性字典

print(dog1.__dict__["type"]) # 中华田园犬

# 创建出的实例只有数据属性，函数属性实际是调的类的函数属性

dog1.run()

print(dog2.name)

# 查看类的名字

print(Dog.__name__) # Dog

# 查看文档说明

print(Dog.__doc__) # 定义一个狗类

# 查看第一个父类

print(Dog.__base__) # <class 'object'>

# 查看所有父类，构成元组

print(Dog.__bases__) # (<class 'object'>,)

# 查看类的属性,返回一个字典

print(Dog.__dict__)

# 查看类定义所在的模块

print(Dog.__module__) # __main__

# 查看实例对应的类

print(Dog.__class__) # <class 'type'>

42. 静态属性, 类方法, 静态方法:

@property @classmethod @staticmethod

综合示例:

class Room(object):

tag = 1

def __init__(self, wight, length):

self.wight = wight

self.length = length

@property

def car_area(self):

return self.length * self.wight + self.tag

@classmethod

def tell_info(cls):

print(cls)

print("-->", cls.tag)

@staticmethod

def run(a, b):

print("%s %s 正在跑步" % (a, b))

# 静态属性：将类的函数属性@property装饰后，是对象以数据属性的方式调用

# 只和实例对象绑定-->即可以访问实例属性也可以访问类的属性

p1 = Room(10, 20)

print("类属性", p1.tag)

print("实例对象调用静态属性", p1.car_area)

# 类方法：将类的函数属性@classmethod装饰后，不用创建实例对象,调用类的函数属性

# 只和类绑定-->可以访问类属性，不能访问实例属性

Room.tell_info()

# 静态方法：将类的函数属性@staticmethod装饰后，不创建和创建实例对象,都可以调用类的函数属性

# 即不和类绑定也不和实例对象绑定-->不能访问类属性，也不能访问实例属性，是类的工具包

Room.run("co1", "co2")

p2 = Room(20, 20)

p2.run("co3", "co4")

43. 包装标准类型:

基于标准数据类型来定制我们自己的数据类型，新增/改写方法

# 包装=继承+派生

class List(list):

# 定义一个方法取列表中间值

def show_midlle(self):

min_index = int(len(self)/2)

return self[min_index]

# 重写列表的append方法，限制只允许添加字符串

def append(self, p_object):

if type(p_object) is str:

super().append(p_object)

else:

print("类型错误，只允许添加字符串")

l1 = List("helloworld")

print(l1, type(l1))

print("列表%s的中间值是%s" %(l1, l1.show_midlle()))

l1.append("coco")

l1.append(123)

print(l1)

44. 重写反射方法:

class Foo():

x = 1

def __init__(self):

self.y = 1

def __getattr__(self, item):

print("你要找的%s属性不存在" % item)

# 重写内置删除方法，限制删除条件

def __delattr__(self, item):

print("执行了删除%s属性的操作" % item)

self.__dict__.pop(item)

# 重写内置设置方法，限制设置条件

def __setattr__(self, key, value):

print("你执行了设置%s属性值为%s的操作" %(key, value))

self.__dict__[key] = value

f1 = Foo()

f1.x = 10

f1.name = "coco" # 设置属性时会触发__setattr__

print(f1.z) # 属性不存在时，会自动触发__getattr__

del f1.y # 删除属性时，会触发__delattr__

print(f1.__dict__)

45. 授权:

授权是包装的一个特性, 包装一个类型通常是对已存在的类型的一些定制,这种做法可以新建,修改或删除原有产品的功能,其它的则保持原样。

授权的过程,即是所有更新的功能都是由新类的某部分来处理,但已存在的功能就授权给对象的默认属性

实现授权的关键点就是覆盖__getattr__方法

示例1:

# 授权-->是组合的运用

class Open:

def __init__(self,filename, mode="r", encoding="utf-8"):

self.filename = filename

self.file = open(filename, mode, encoding=encoding)

self.mode = mode

self.encoding = encoding

def write(self, line):

t = time.strftime("%Y-%m-%d %X")

self.file.write("%s %s" % (t, line))

def __getattr__(self, item):

return getattr(self.file, item, "没有找到%s" % item)

f1 = Open("a.txt", "r+")

print(f1.file)

print(f1.reads)

print(f1.read)

f1.write("hello world\n")

f1.seek(0) # 移动文件指针到文件开头

print("读文件%s内容是%s" % (f1.filename, f1.read()))

示例2:

#加上b模式支持

import time

class FileHandle:

def __init__(self,filename,mode='r',encoding='utf-8'):

if 'b' in mode:

self.file=open(filename,mode)

else:

self.file=open(filename,mode,encoding=encoding)

self.filename=filename

self.mode=mode

self.encoding=encoding

def write(self,line):

if 'b' in self.mode:

if not isinstance(line,bytes):

raise TypeError('must be bytes')

self.file.write(line)

def __getattr__(self, item):

return getattr(self.file,item)

def __str__(self):

if 'b' in self.mode:

res="<_io.BufferedReader name='%s'>" %self.filename

else:

res="<_io.TextIOWrapper name='%s' mode='%s' encoding='%s'>" %(self.filename,self.mode,self.encoding)

return res

f1=FileHandle('b.txt','wb')

# f1.write('你好啊啊啊啊啊') #自定制的write,不用在进行encode转成二进制去写了

f1.write('你好啊'.encode('utf-8'))

print(f1)

f1.close()

示例3:

class List:

def __init__(self,seq):

self.seq=seq

def append(self, p_object):

' 派生自己的append加上类型检查，覆盖原有的append'

if not isinstance(p_object,int):

raise TypeError('must be int')

self.seq.append(p_object)

@property

def mid(self):

'新增自己的方法'

index=len(self.seq)//2

return self.seq[index]

def __getattr__(self, item):

return getattr(self.seq,item)

def __str__(self):

return str(self.seq)

l=List([1,2,3])

print(l)

l.append(4)

print(l)

# l.append('3333333') #报错，必须为int类型

print(l.mid)

#基于授权，获得insert方法

l.insert(0,-123)

print(l)

46. 双下方法其它补充, 示例说明:

示例1:

# isinstance(obj,cls)检查是否obj是否是类 cls 的对象

class Foo():

def __getattr__(self, item):

print("执行了getattr查找%s" % item)

# 无论是否找到属性都会执行getattribute

def __getattribute__(self, item):

print("执行了getattribute查找%s" % item)

raise AttributeError("抛出异常")

f1 = Foo()

print(isinstance(f1, Foo)) # 判断对象是否是类实例化出来的 True

# issubclass(sub, super)检查sub类是否是 super 类的派生类

class Bar():

# 只针对字典方式操作触发

def __getitem__(self, item):

print("%s getitem" % item)

return self.__dict__[item]

# 只针对字典方式操作触发

def __setitem__(self, key, value):

print("%s:%s setitem" % (key, value))

self.__dict__[key] = value

# 只针对字典方式操作触发

def __delitem__(self, key):

print("%s delitem" % key)

self.__dict__.pop(key)

print(issubclass(Bar, Foo)) # 判断子类是否是由父类继承来的 True

f1.x # 执行了 __getattribute__ 查找x -->执行了 __getattr__ 查找x

f2 = Bar()

f2["name"] = "coco"

print(f2["name"])

f2["age"] = "18"

print(f2.__dict__)

del f2["age"]

print(f2.__dict__)

示例2:

# __str__ 与 __repr__ 示例

class Foo1():

# 运用在print打印时触发

def __str__(self):

return "自定义打印信息"

# 运用在解释器时触发

def __repr__(self):

return "自定义打印信息2"

l2 = Foo1()

print(l2) # 自定义打印信息

print(l2) # 自定义打印信息,__str__和 __repr__共存，print先找str没有再找repr

示例3:

# __format__ 格式化方法示例

format_dic = {

"ymd": "{0.year}{0.mon}{0.day}",

"m-d-y": "{0.mon}-{0.day}-{0.year}",

}

class Date:

def __init__(self, year, mon, day):

self.year = year

self.mon = mon

self.day = day

def __format__(self, format_spec):

print("-->", format_spec)

if not format_spec or format_spec not in format_dic:

format_spec = "ymd"

fm=format_dic[format_spec]

return fm.format(self)

d1 = Date(2019, 4, 13)

print("{0.year}{0.mon}{0.day}".format(d1)) # 2019413

print(format(d1, "ymd")) # 2019413

print(format(d1, "m-d-y")) # 4-13-2019

示例4:

class Foo2:

"文档描述"

# __slost__取代了类的__dict__使实例化除的属性没有__dict__方法

__slots__ = ["name", "age"]

class Foo3(Foo2):

def __del__(self):

print("回收实例时触发")

def __call__(self, *args, **kwargs):

print("__call__方法让实例对象可以加()执行")

f3 = Foo2

print("f3", f3.__slots__)

# __doc__记录类的文档描述信息

print(Foo2.__doc__) # 文档描述

# __doc__无法被子类继承，应为子类一旦定义就有属于自己的__doc__

print(Foo3.__doc__) # None

print(Foo3.__dict__)

# __module__查看f3来自于哪个模块

print(f3.__module__) # __main__

# __class__查看f3来自于哪个类

print(f3.__class__) # <class 'type'>

# __del__析构函数，回收实例时触发

f3 = Foo3()

f3() # __call__方法让实例对象可以加()执行

示例5:

# 描述符__get__ __set__ __delete__

class Foo4():

def __get__(self, instance, owner):

print("get")

def __set__(self, instance, value):

print("set")

def __delete__(self, instance):

print("delete")

class Foo5(Foo4):

name = Foo4()

f5 = Foo5()

f5.name # get

f5.name = 1 # set

del f5.name # delete

示例6:

# 上下文管理器 实现 __enter__ __exit__

class Open():

def __init__(self, name):

self.name = name

def __enter__(self):

print("执行了enter")

return self

def __exit__(self, exc_type, exc_val, exc_tb):

print("执行了exit")

print(exc_type) # 异常类型

print(exc_val) # 异常值

print(exc_tb) # 异常追踪信息

with Open("a.txt") as f:

print(f) # <__main__.Foo6 object at 0x000000000358E0F0>

print(f.name) # a.txt

print("结束") # 结束

示例7:

# __hash__

class A:

def __init__(self):

self.a = 1

self.b = 2

def __hash__(self):

return hash(str(self.a)+str(self.b))

a = A()

print(hash(a))

示例8:

# __len__

class B:

def __len__(self):

print(666)

b = B()

len(b) # len 一个对象就会触发 __len__方法。

class A:

def __init__(self):

self.a = 1

self.b = 2

def __len__(self):

return len(self.__dict__)

a = A()

print(len(a))

示例9:

# __iter__

用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__

class Foo(object):

def __init__(self, sq):

self.sq = sq

def __iter__(self):

return iter(self.sq)

obj = Foo([11,22,33,44])

for i in obj:

print i

示例10:

分片操作 __getslice__ __setslice__ __delslice__

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__

47. 描述符的应用与优先级:

描述符本质就是一个新式类,在这个新式类中,至少实现了__get__(),__set__(),__delete__()中的一个,这也被称为描述符协议

__get__():调用一个属性时,触发

__set__():为一个属性赋值时,触发

__delete__():采用del删除属性时,触发

数据描述符：至少实现了__get__()和__set__()

非数据描述符：没有实现：__set__()

描述符应用示例:

class Typed:

def __init__(self,key,expected_type):

self.key=key

self.expected_type=expected_type

def __get__(self, instance, owner):

print('get方法')

# print('instance参数【%s】' %instance)

# print('owner参数【%s】' %owner)

return instance.__dict__[self.key]

def __set__(self, instance, value):

print('set方法')

# print('instance参数【%s】' % instance)

# print('value参数【%s】' % value)

# print('====>',self)

if not isinstance(value,self.expected_type):

# print('你传入的类型不是字符串，错误')

# return

raise TypeError('%s 传入的类型不是%s' %(self.key,self.expected_type))

instance.__dict__[self.key]=value

def __delete__(self, instance):

print('delete方法')

# print('instance参数【%s】' % instance)

instance.__dict__.pop(self.key)

class People:

name=Typed('name',str) #t1.__set__() self.__set__()

age=Typed('age',int) #t1.__set__() self.__set__()

def __init__(self,name,age,salary):

self.name=name

self.age=age

self.salary=salary

p1=People("coco", 13, 13.3)

print(p1.__dict__)

描述符的优先级:

类属性 > 数据描述符 > 实例属性 > 非数据描述符 > 找不到的属性触发__getattr__()

01. 类属性 > 数据描述符:

#描述符Str

class Str:

def __get__(self, instance, owner):

print('Str调用')

def __set__(self, instance, value):

print('Str设置...')

def __delete__(self, instance):

print('Str删除...')

class People:

name=Str()

def __init__(self,name,age): #name被Str类代理,age被Int类代理,

self.name=name

self.age=age

# 在一个类中定义描述符它就是一个类属性,存在于类的属性字典中,而不是实例的属性字典

# 描述符被定义成了一个类属性,直接通过类名也可以调用

People.name #调用类属性name,本质就是在调用描述符Str,触发了__get__()

People.name='coco' # 赋值并没有触发__set__()

del People.name # del也没有触发__delete__()

'''

原因:描述符在使用时被定义成另外一个类的类属性,因而类属性比二次加工的描述符伪装而来的类属性有更高的优先级

People.name # 调用类属性name,找不到就去找描述符伪装的类属性name,触发了__get__()

People.name='coco' # 直接赋值了一个类属性,它拥有更高的优先级,相当于覆盖了描述符,不会触发描述符的__set__()

del People.name #同上

'''

02. 数据描述符 > 实例属性:

#描述符Str

class Str:

def __get__(self, instance, owner):

print('Str调用')

def __set__(self, instance, value):

print('Str设置...')

def __delete__(self, instance):

print('Str删除...')

class People:

name=Str()

def __init__(self,name,age): #name被Str类代理,age被Int类代理,

self.name=name

self.age=age

p1=People('angels',18)

# 如果描述符是一个数据描述符(即有__get__又有__set__),那么p1.name的调用与赋值都是触发描述符的操作,于p1本身无关了,相当于覆盖了实例的属性

p1.name='coco'

p1.name

print(p1.__dict__) # 实例的属性字典中没有name,因为name是一个数据描述符,优先级高于实例属性,查看/赋值/删除都是跟描述符有关,与实例无关了

del p1.name

03. 实例属性 > 非数据描述符:

class Foo:

def __set__(self, instance, value):

print('set')

def __get__(self, instance, owner):

print('get')

class Room:

name=Foo()

def __init__(self,name,width,length):

self.name=name

self.width=width

self.length=length

#name是一个数据描述符,因为name=Foo()而Foo实现了get和set方法,因而比实例属性有更高的优先级

#对实例的属性操作,触发的都是描述符的

r1=Room('厕所',1,1)

r1.name

r1.name='厨房'

 

class Foo:

def __get__(self, instance, owner):

print('get')

class Room:

name=Foo()

def __init__(self,name,width,length):

self.name=name

self.width=width

self.length=length

#name是一个非数据描述符,因为name=Foo()而Foo没有实现set方法,因而比实例属性有更低的优先级

#对实例的属性操作,触发的都是实例自己的

r1=Room('厕所',1,1)

r1.name

r1.name='厨房'

04. 非数据描述符 > 找不到:

class Foo:

def func(self):

print('func被调用')

def __getattr__(self, item):

print('找不到就调用getattr',item)

f1=Foo()

f1.xxx # 找不到就调用getattr xxx

48. 类装饰器应用:

01. 类的装饰器无参数示例:

def decorate(cls):

print('类的装饰器开始运行啦------>')

return cls

@decorate #无参:People=decorate(People)

class People:

def __init__(self,name,age,salary):

self.name=name

self.age=age

self.salary=salary

p1=People('egon',18,3333.3)

02. 类的装饰器有参数示例:

示例1:

def typeassert(**kwargs):

def decorate(cls):

print('类的装饰器开始运行啦------>',kwargs)

return cls

return decorate

@typeassert(name=str,age=int,salary=float) #有参:1.运行typeassert(...)返回结果是decorate,此时参数都传给kwargs 2.People=decorate(People)

class People:

def __init__(self,name,age,salary):

self.name=name

self.age=age

self.salary=salary

p1=People('egon',18,3333.3)

示例2:

class Test(object):

def __init__(self, func):

print("---初始化---")

print("func name is %s"%func.__name__)

self.__func = func

def __call__(self):

print("---装饰器中的功能---")

self.__func()

#说明：

#1. 当用Test来装作装饰器对test函数进行装饰的时候，首先会创建Test的实例对象

# 并且会把test这个函数名当做参数传递到__init__方法中

# 即在__init__方法中的属性__func指向了test指向的函数

#2. test指向了用Test创建出来的实例对象

#3. 当在使用test()进行调用时，就相当于让这个对象()，因此会调用这个对象的__call__方法

#4. 为了能够在__call__方法中调用原来test指向的函数体，所以在__init__方法中就需要一个实例属性来保存这个函数体的引用

# 所以才有了self.__func = func这句代码，从而在调用__call__方法中能够调用到test之前的函数体

@Test

def test():

print("----test---")

test()

showpy()#如果把这句话注释，重新运行程序，依然会看到"--初始化--"

03. 描述符装饰器综合运用示例:

class Typed:

def __init__(self,key,expected_type):

self.key=key

self.expected_type=expected_type

def __get__(self, instance, owner):

print('get方法')

# print('instance参数【%s】' %instance)

# print('owner参数【%s】' %owner)

return instance.__dict__[self.key]

def __set__(self, instance, value):

print('set方法')

# print('instance参数【%s】' % instance)

# print('value参数【%s】' % value)

# print('====>',self)

if not isinstance(value,self.expected_type):

# print('你传入的类型不是字符串，错误')

# return

raise TypeError('%s 传入的类型不是%s' %(self.key,self.expected_type))

instance.__dict__[self.key]=value

def __delete__(self, instance):

print('delete方法')

# print('instance参数【%s】' % instance)

instance.__dict__.pop(self.key)

def deco(**kwargs):

def wrapper(obj):

for key,val in kwargs.items():

print("-->", key, val)

setattr(obj, key, Typed(key, val))

return obj

return wrapper

@deco(name=str, age=int)

class People:

def __init__(self,name,age,salary):

self.name=name

self.age=age

self.salary=salary

p1=People('coco',13, 13.3)

print(p1.__dict__)

49. 用描述符定制 @property, @classmethod, @staticmethod:

01. 定制@property:

class Lazyproperty:

def __init__(self,func):

print('==========>',func)

self.func=func

def __get__(self, instance, owner):

print('get')

# print(instance)

# print(owner)

if instance is None:

return self

res=self.func(instance)

setattr(instance,self.func.__name__,res)

return res

class Room:

def __init__(self,name,width,length):

self.name=name

self.width=width

self.length=length

# @property #area=property(area)

@Lazyproperty #area=Lazypropery(area)

def area(self):

return self.width * self.length

@property #test=property(test)

def area1(self):

return self.width * self.length

r1 = Room("coco", 10, 10) # ==========> <function Room.area at 0x0000000006AC4C80>

print(r1.area1) # 100

#先从自己的属性字典找,没有再去类的中找,然后触发了area的__get__方法

print(r1.area) # 先打印get, 再打印100

#先从自己的属性字典找,找到了,是上次计算的结果,这样就不用每执行一次都去计算

print(r1.area) # 先打印100, 再打印get

print(Room.area) # <__main__.Lazyproperty object at 0x0000000005AE52B0>

print(Room.area1) # <property object at 0x00000000052F1458>

02. 定制@classmethod:

class ClassMethod:

def __init__(self,func):

self.func=func

def __get__(self, instance, owner): #类来调用,instance为None,owner为类本身,实例来调用,instance为实例,owner为类本身,

def feedback():

print('在这里可以加功能啊...')

return self.func(owner)

return feedback

class People:

name='coco'

@ClassMethod # say_hi=ClassMethod(say_hi)

def say_hi(cls):

print('你好啊,world %s' %cls.name)

People.say_hi()

p1=People()

p1.say_hi()

class ClassMethod:

def __init__(self,func):

self.func=func

def __get__(self, instance, owner): #类来调用,instance为None,owner为类本身,实例来调用,instance为实例,owner为类本身,

def feedback(*args,**kwargs):

print('在这里可以加功能啊...')

return self.func(owner,*args,**kwargs)

return feedback

class People:

name='linhaifeng'

@ClassMethod # say_hi=ClassMethod(say_hi)

def say_hi(cls,msg):

print('你好啊,world %s %s' %(cls.name,msg))

People.say_hi('每天都是充满希望的一天')

p1=People()

p1.say_hi('每天都是充满希望的一天')

03. 定制@staticmethod:

class StaticMethod:

def __init__(self,func):

self.func=func

def __get__(self, instance, owner): #类来调用,instance为None,owner为类本身,实例来调用,instance为实例,owner为类本身,

def feedback(*args,**kwargs):

print('在这里可以加功能啊...')

return self.func(*args,**kwargs)

return feedback

class People:

@StaticMethod# say_hi=StaticMethod(say_hi)

def say_hi(x,y,z):

print('------>',x,y,z)

People.say_hi(1,2,3)

p1=People()

p1.say_hi(4,5,6)

50. 自定义元类:

元类就是用来创建这些类（对象）的，元类就是类的类, type就是Python在背后用来创建所有类的元类

作用: 拦截类的创建, 修改类, 返回修改之后的类

类中有一个属性 __metaclass__，其用来表示该类由 谁 来实例化创建，所以，我们可以为 __metaclass__ 设置一个type类的派生类，从而查看 类 创建的过程

示例1:

class MyType(type):

def __init__(self, a, b, c):

print(a) # Foo

print(b) # ()

print(c) # {'__module__': '__main__', '__qualname__': 'Foo', '__init__': <function Foo.__init__ at 0x00000000056307B8>}

print("元类构造执行完成") # 元类构造执行完成

def __call__(self, *args, **kwargs):

print(args, kwargs) # ('coco', 18) {}

obj = object.__new__(self) # object.__new__(Foo)-->f1

self.__init__(obj, *args, **kwargs) # Foo.__init__(f1, *args, **kwargs)

return obj

class Foo(metaclass=MyType): # Foo=MyType(Foo, "Foo", (), {})-->__init__

def __init__(self, name, age):

self.name = name

self.age = age

f1 = Foo("coco", 18)

print(f1) # <__main__.Foo object at 0x00000000055BF6A0>

print(f1.__dict__) # {'name': 'coco', 'age': 18}

示例2:

class MyType(type):

def __init__(self, what, bases=None, dict=None):

super(MyType, self).__init__(what, bases, dict)

def __call__(self, *args, **kwargs):

obj = self.__new__(self, *args, **kwargs)

self.__init__(obj)

class Foo(object):

__metaclass__ = MyType

def __init__(self, name):

self.name = name

def __new__(cls, *args, **kwargs):

return object.__new__(cls, *args, **kwargs)

# 第一阶段：解释器从上到下执行代码创建Foo类

# 第二阶段：通过Foo类创建obj对象

obj = Foo()

示例3:

class UpperAttrMetaClass(type):

# __new__ 是在__init__之前被调用的特殊方法

# __new__是用来创建对象并返回之的方法

# 而__init__只是用来将传入的参数初始化给对象

# 你很少用到__new__，除非你希望能够控制对象的创建

# 这里，创建的对象是类，我们希望能够自定义它，所以我们这里改写__new__

# 如果你希望的话，你也可以在__init__中做些事情

# 还有一些高级的用法会涉及到改写__call__特殊方法，但是我们这里不用

def __new__(cls, class_name, class_parents, class_attr):

# 遍历属性字典，把不是__开头的属性名字变为大写

new_attr = {}

for name, value in class_attr.items():

if not name.startswith("__"):

new_attr[name.upper()] = value

# 方法1：通过'type'来做类对象的创建

return type(class_name, class_parents, new_attr)

# 方法2：复用type.__new__方法

# 这就是基本的OOP编程，没什么魔法

# return type.__new__(cls, class_name, class_parents, new_attr)

# python3的用法

class Foo(object, metaclass=UpperAttrMetaClass):

bar = 'bip'

# python2的用法

# class Foo(object):

# __metaclass__ = UpperAttrMetaClass

# bar = 'bip'

print(hasattr(Foo, 'bar'))

# 输出: False

print(hasattr(Foo, 'BAR'))

# 输出:True

f = Foo()

print(f.BAR)

# 输出:'bip'

51. 元类实现ORM:

ORM释义:

ORM 是 python编程语言后端web框架 Django的核心思想，“Object Relational Mapping”，即对象-关系映射，简称ORM

创建一个实例对象，用创建它的类名当做数据表名，用创建它的类属性对应数据表的字段，当对这个实例对象操作时，能够对应MySQL语句

作用:

ORM就是让开发者在操作数据库的时候，能够像操作对象时通过xxxx.属性=yyyy一样简单

示例1:

# 通过元类简单实现ORM中的insert功能

class ModelMetaclass(type):

def __new__(cls, name, bases, attrs):

mappings = dict()

# 判断是否需要保存

for k, v in attrs.items():

# 判断是否是指定的StringField或者IntegerField的实例对象

if isinstance(v, tuple):

print('Found mapping: %s ==> %s' % (k, v))

mappings[k] = v

# 删除这些已经在字典中存储的属性

for k in mappings.keys():

attrs.pop(k)

# 将之前的uid/name/email/password以及对应的对象引用、类名字

attrs['__mappings__'] = mappings # 保存属性和列的映射关系

attrs['__table__'] = name # 假设表名和类名一致

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

class User(metaclass=ModelMetaclass):

uid = ('uid', "int unsigned")

name = ('username', "varchar(30)")

email = ('email', "varchar(30)")

password = ('password', "varchar(30)")

# 当指定元类之后，以上的类属性将不在类中，而是在__mappings__属性指定的字典中存储

# 以上User类中有

# __mappings__ = {

# "uid": ('uid', "int unsigned")

# "name": ('username', "varchar(30)")

# "email": ('email', "varchar(30)")

# "password": ('password', "varchar(30)")

# }

# __table__ = "User"

def __init__(self, **kwargs):

for name, value in kwargs.items():

setattr(self, name, value)

def save(self):

fields = []

args = []

for k, v in self.__mappings__.items():

fields.append(v[0])

args.append(getattr(self, k, None))

args_temp = list()

for temp in args:

# 判断入如果是数字类型

if isinstance(temp, int):

args_temp.append(str(temp))

elif isinstance(temp, str):

args_temp.append("""'%s'""" % temp)

sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(args_temp))

print('SQL: %s' % sql)

u = User(uid=12345, name='Michael', email='test@orm.org', password='my-pwd')

# print(u.__dict__)

u.save()

示例2:

# 抽取到基类中

class ModelMetaclass(type):

def __new__(cls, name, bases, attrs):

mappings = dict()

# 判断是否需要保存

for k, v in attrs.items():

# 判断是否是指定的StringField或者IntegerField的实例对象

if isinstance(v, tuple):

print('Found mapping: %s ==> %s' % (k, v))

mappings[k] = v

# 删除这些已经在字典中存储的属性

for k in mappings.keys():

attrs.pop(k)

# 将之前的uid/name/email/password以及对应的对象引用、类名字

attrs['__mappings__'] = mappings # 保存属性和列的映射关系

attrs['__table__'] = name # 假设表名和类名一致

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

class Model(object, metaclass=ModelMetaclass):

def __init__(self, **kwargs):

for name, value in kwargs.items():

setattr(self, name, value)

def save(self):

fields = []

args = []

for k, v in self.__mappings__.items():

fields.append(v[0])

args.append(getattr(self, k, None))

args_temp = list()

for temp in args:

# 判断入如果是数字类型

if isinstance(temp, int):

args_temp.append(str(temp))

elif isinstance(temp, str):

args_temp.append("""'%s'""" % temp)

sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(args_temp))

print('SQL: %s' % sql)

class User(Model):

uid = ('uid', "int unsigned")

name = ('username', "varchar(30)")

email = ('email', "varchar(30)")

password = ('password', "varchar(30)")

u = User(uid=12345, name='Michael', email='test@orm.org', password='my-pwd')

# print(u.__dict__)

u.save()