一、isistance(obj,cls)和issubclass(sub,supper)
isistance(obj,cls)检查obj是否是类cls的对象
class Foo(object): pass obj = Foo() isinstance(obj, Foo)
issubclass(sub, super)检查sub类是否是 super 类的派生类
class Foo(object): pass class Bar(Foo): pass issubclass(Bar, Foo)
二、反射
一)什么是反射
反射的概念式有Smith在1982年首次提出的,主要是指程序可以访问、检测和修改它本身状态或行为的一种能力(自省)。
二)Python中面向对象中的反射
通过字符串的形式操作对象先关的属性。Python中的一切事物都是对象,都可以使用反射。
1、反射相关的四个函数(适用于类和对象:Python中一切皆对象,类本身也是一个对象)
1、hasattr(object,name) 判断object中有没有一个name字符串对应的方法或属性 2、getattr(object, name, default=None) def getattr(object, name, default=None): # known special case of getattr """ getattr(object, name[, default]) -> value Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y. When a default argument is given, it is returned when the attribute doesn't exist; without it, an exception is raised in that case. """ pass 3、setattr(x, y, v) def setattr(x, y, v): # real signature unknown; restored from __doc__ """ Sets the named attribute on the given object to the specified value. setattr(x, 'y', v) is equivalent to ``x.y = v'' """ pass 4、delattr(x, y) def delattr(x, y): # real signature unknown; restored from __doc__ """ Deletes the named attribute from the given object. delattr(x, 'y') is equivalent to ``del x.y'' """ pass
2、使用实践
应用:可以判断使用模块或者类中是否包含某个属性或方法,有则执行,没有告知。
- 类:反射静态属性,类方法
- 对象:反射方法和属性
- 模块:反射方法、变量
- 本模块:反射函数、变量
1 # 通过输入的内容,找到相应的值 2 class Person: 3 role = 'Person' 4 country = 'China' 5 6 def __init__(self,name,age): 7 self.name = name 8 self.age = age 9 10 def func(self): 11 print('%s in func' %self.name) 12 alex = Person('alex',20) 13 # # 通过反射调用类中的属性 14 # name = input('属性名:') 15 # 判断类中是否有相应的属性,有的话,返回结果;没有的话,什么都不做 16 # person.role 17 if hasattr(Person,name): 18 print(getattr(Person,name)) 19 20 # 通过输入字符串的形式,访问类中的变量 alex.name alex.age 21 if hasattr(alex,'age'): 22 print(getattr(alex,'age')) 23 24 # 通过反射调用类中的方法 25 if hasattr(alex,'func'): 26 func = getattr(alex,'func') 27 func() 28 29 30 def func2(self): 31 print('%s in func2' % self.name) 32 # # setattr 33 # alex.sex = None 34 # setattr(alex,'sex','不详') 35 # print(alex.sex) 36 37 # setattr(alex,'func2',func2) ##setattr绑定方法是一个假的,在使用的时候必须要手动传self 38 # alex.func2(alex) 39 # print(alex.func) 40 41 42 # delattr 43 # delattr(alex,'name') #等价于del alex.name ##删除属性
三)使用反射的好处
好处一:实现可插拔机制
有俩程序员,一个lili,一个是egon,lili在写程序的时候需要用到egon所写的类,但是egon去跟女朋友度蜜月去了,还没有完成他写的类,lili想到了反射,使用了反射机制lili可以继续完成自己的代码,等egon度蜜月回来后再继续完成类的定义并且去实现lili想要的功能。
总之反射的好处就是,可以事先定义好接口,接口只有在被完成后才会真正执行,这实现了即插即用,这其实是一种‘后期绑定’,什么意思?即你可以事先把主要的逻辑写好(只定义接口),然后后期再去实现接口的功能
1 class FtpClient:
2 'ftp客户端,但是还么有实现具体的功能'
3 def __init__(self,addr):
4 print('正在连接服务器[%s]' %addr)
5 self.addr=addr
好处二:动态导入模块(基于反射当前模块成员)
三、类中的装饰器property、classmethod和staticmethod
一:绑定方法(绑定给谁,谁来调用就自动将它本身当作第一个参数传入):
1. 绑定到类的方法:用classmethod装饰器装饰的方法。
为类量身定制
类.boud_method(),自动将类当作第一个参数传入
(其实对象也可调用,但仍将类当作第一个参数传入)
2. 绑定到对象的方法:没有被任何装饰器装饰的方法。
为对象量身定制
对象.boud_method(),自动将对象当作第一个参数传入
(属于类的函数,类可以调用,但是必须按照函数的规则来,没有自动传值那么一说)
二:非绑定方法:用staticmethod装饰器装饰的方法
1. 不与类或对象绑定,类和对象都可以调用,但是没有自动传值那么一说。就是一个普通工具而已
注意:与绑定到对象方法区分开,在类中直接定义的函数,没有被任何装饰器装饰的,都是绑定到对象的方法,可不是普通函数,对象调用该方法会自动传值,而staticmethod装饰的方法,不管谁来调用,都没有自动传值一说
一)property 将功能属性转化为数据属性
1、计算圆的周长和面积
1 # area和perimeter方法伪装成属性 2 from math import pi 3 class Circle: 4 def __init__(self,r): 5 self.r = r 6 @property 7 def perimeter(self): 8 return self.r*pi*2 9 @property 10 def area(self): 11 return pi*self.r**2 12 c1 = Circle(5) 13 print(c1.area) 14 print(c1.perimeter)
2、在类的外面访问类的私有属性
1 class A: 2 def __init__(self,name): 3 self.__name = name 4 5 @property 6 def name(self): 7 return self.__name 8 a = A('alex') 9 print(a.name)
3、在外面可以访问私有属性,又可以修改私有属性
名字必须要相同
1 class A: 2 def __init__(self,name): 3 self.__name = name 4 5 @property 6 def name(self): 7 return self.__name 8 @name.setter 9 def name(self,new_name): ##可以做出限制 10 if type(new_name) is str: 11 self.__name = new_name 12 a = A('alex') 13 # print(a.name) 14 a.name = 'alex_sb' 15 print(a.name)
二)classmethod绑定给类的方法
classmehtod是给类用的,即绑定到类,类在使用时会将类本身当做参数传给类方法的第一个参数(即便是对象来调用也会将类当作第一个参数传入),python为我们内置了函数classmethod来把类中的函数定义成类方法
settings.py
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 # __author__ = "wzs"
4 #2017/11/6
5
6 HOST='127.0.0.1'
7 PORT=3306
8 DB_PATH=r'G:\data\PyCharm_Project\Python\s19\day8\面向对象编程\db'
db.py
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 # __author__ = "wzs"
4 #2017/11/6
5
6 import settings
7 class MySQL:
8 def __init__(self,host,port):
9 self.host=host
10 self.port=port
11
12 @classmethod
13 def from_conf(cls):
14 print(cls)
15 return cls(settings.HOST,settings.PORT)
16
17 print(MySQL.from_conf) #<bound method MySQL.from_conf of <class '__main__.MySQL'>>
18 conn=MySQL.from_conf()
19
20 conn.from_conf() #对象也可以调用,但是默认传的第一个参数仍然是类
三)staticmethod
在类内部用staticmethod装饰的函数即非绑定方法,就是普通函数(将外面的函数想放在类中使用,需要放到相关的类中,前面加上@staticmethod)
staticmethod不与类或对象绑定,谁都可以调用,没有自动传值效果
应用场景:完全的面向对象编程——需将所有的方法代码都必须写类里,只能把原来的函数写进类里(原本又只是函数,所以就加上一个staticmethod装饰器)
staticmethod
1 import hashlib
2 import time
3 class MySQL:
4 def __init__(self,host,port):
5 self.id=self.create_id()
6 self.host=host
7 self.port=port
8 @staticmethod
9 def create_id(): #就是一个普通工具
10 m=hashlib.md5(str(time.time()).encode('utf-8'))
11 return m.hexdigest()
12
13
14 print(MySQL.create_id) #<function MySQL.create_id at 0x0000000001E6B9D8> #查看结果为普通函数
15 conn=MySQL('127.0.0.1',3306)
16 print(conn.create_id) #<function MySQL.create_id at 0x00000000026FB9D8> #查看结果为普通函数
四)classmethod与staticmethod的区别
简单
1 class A:
2 country = 'China'
3 #必须先是实例化才能调用对象的方法且可以使用示例的属性
4 def func(self):
5 self.name = 'alex'
6
7 @classmethod #类方法:不需要传具体的对象,但是可以使用类的静态属性
8 def c_method(cls):
9 print('in class method')
10 print(cls.country)
11
12 @staticmethod ##静态方法:不需要传任何参数,但是也不能使用任何属性
13 def s_method():
14 print('in the static method')
15
16 A.c_method()
17 A.s_method()
深入:mariadb是mysql
1 import settings
2 class MySQL:
3 def __init__(self,host,port):
4 self.host=host
5 self.port=port
6
7 @staticmethod
8 def from_conf():
9 return MySQL(settings.HOST,settings.PORT)
10
11 # @classmethod #哪个类来调用,就将哪个类当做第一个参数传入
12 # def from_conf(cls):
13 # return cls(settings.HOST,settings.PORT)
14
15 def __str__(self):
16 return '就不告诉你'
17
18 class Mariadb(MySQL):
19 def __str__(self):
20 return '<%s:%s>' %(self.host,self.port)
21
22
23 m=Mariadb.from_conf()
24 print(m) #我们的意图是想触发Mariadb.__str__,但是结果触发了MySQL.__str__的执行,打印就不告诉你:
五)练习
1、定义MySQL类
1.对象有id、host、port三个属性
2.定义工具create_id,在实例化时为每个对象随机生成id,保证id唯一
3.提供两种实例化方式,方式一:用户传入host和port 方式二:从配置文件中读取host和port进行实例化
4.为对象定制方法,save和get_obj_by_id,save能自动将对象序列化到文件中,文件路径为配置文件中DB_PATH,文件名为id号,保存之前验证对象是否已经存在,若存在则抛出异常,;get_obj_by_id方法用来从文件中反序列化出对象
创建唯一id之UUID
Python官方Doc:《20.15. uuid — UUID objects according to RFC 4122》
UUID的算法介绍:《A Universally Unique IDentifier (UUID) URN Namespace》
概述:
UUID是128位的全局唯一标识符,通常由32字节的字符串表示。
它可以保证时间和空间的唯一性,也称为GUID,全称为:
UUID —— Universally Unique IDentifier Python 中叫 UUID
GUID —— Globally Unique IDentifier C# 中叫 GUID
它通过MAC地址、时间戳、命名空间、随机数、伪随机数来保证生成ID的唯一性。
UUID主要有五个算法,也就是五种方法来实现:
1、uuid1()——基于时间戳
由MAC地址、当前时间戳、随机数生成。可以保证全球范围内的唯一性,
但MAC的使用同时带来安全性问题,局域网中可以使用IP来代替MAC。
2、uuid2()——基于分布式计算环境DCE(Python中没有这个函数)
算法与uuid1相同,不同的是把时间戳的前4位置换为POSIX的UID。
实际中很少用到该方法。
3、uuid3()——基于名字的MD5散列值
通过计算名字和命名空间的MD5散列值得到,保证了同一命名空间中不同名字的唯一性,
和不同命名空间的唯一性,但同一命名空间的同一名字生成相同的uuid。
4、uuid4()——基于随机数
由伪随机数得到,有一定的重复概率,该概率可以计算出来。
5、uuid5()——基于名字的SHA-1散列值
算法与uuid3相同,不同的是使用 Secure Hash Algorithm 1 算法
使用方面:
首先,Python中没有基于DCE的,所以uuid2可以忽略;
其次,uuid4存在概率性重复,由无映射性,最好不用;
再次,若在Global的分布式计算环境下,最好用uuid1;
最后,若有名字的唯一性要求,最好用uuid3或uuid5。
编码方法:
# -*- coding: utf-8 -*-
import uuid
name = "test_name"
namespace = "test_namespace"
print uuid.uuid1() # 带参的方法参见Python Doc
print uuid.uuid3(namespace, name)
print uuid.uuid4()
print uuid.uuid5(namespace, name)
settings.py
1 #settings.py内容
2 '''
3 HOST='127.0.0.1'
4 PORT=3306
5 DB_PATH=r'E:\CMS\aaa\db'
6 '''
7 import settings
8 import uuid
9 import pickle
10 import os
11 class MySQL:
12 def __init__(self,host,port):
13 self.id=self.create_id()
14 self.host=host
15 self.port=port
16
17 def save(self):
18 if not self.is_exists:
19 raise PermissionError('对象已存在')
20 file_path=r'%s%s%s' %(settings.DB_PATH,os.sep,self.id)
21 pickle.dump(self,open(file_path,'wb'))
22
23 @property
24 def is_exists(self):
25 tag=True
26 files=os.listdir(settings.DB_PATH)
27 for file in files:
28 file_abspath=r'%s%s%s' %(settings.DB_PATH,os.sep,file)
29 obj=pickle.load(open(file_abspath,'rb'))
30 if self.host == obj.host and self.port == obj.port:
31 tag=False
32 break
33 return tag
34 @staticmethod
35 def get_obj_by_id(id):
36 file_abspath = r'%s%s%s' % (settings.DB_PATH, os.sep, id)
37 return pickle.load(open(file_abspath,'rb'))
38
39 @staticmethod
40 def create_id():
41 return str(uuid.uuid1())
42
43 @classmethod
44 def from_conf(cls):
45 print(cls)
46 return cls(settings.HOST,settings.PORT)
47
48 # print(MySQL.from_conf) #<bound method MySQL.from_conf of <class '__main__.MySQL'>>
49 conn=MySQL.from_conf()
50 conn.save()
51
52 conn1=MySQL('127.0.0.1',3306)
53 conn1.save() #抛出异常PermissionError: 对象已存在
54
55
56 obj=MySQL.get_obj_by_id('7e6c5ec0-7e9f-11e7-9acc-408d5c2f84ca')
57 print(obj.host)
2、其他练习
1 class Date:
2 def __init__(self,year,month,day):
3 self.year=year
4 self.month=month
5 self.day=day
6 @staticmethod
7 def now(): #用Date.now()的形式去产生实例,该实例用的是当前时间
8 t=time.localtime() #获取结构化的时间格式
9 return Date(t.tm_year,t.tm_mon,t.tm_mday) #新建实例并且返回
10 @staticmethod
11 def tomorrow():#用Date.tomorrow()的形式去产生实例,该实例用的是明天的时间
12 t=time.localtime(time.time()+86400)
13 return Date(t.tm_year,t.tm_mon,t.tm_mday)
14
15 a=Date('1987',11,27) #自己定义时间
16 b=Date.now() #采用当前时间
17 c=Date.tomorrow() #采用明天的时间
18
19 print(a.year,a.month,a.day)
20 print(b.year,b.month,b.day)
21 print(c.year,c.month,c.day)
22
23
24 #分割线==============================
25 import time
26 class Date:
27 def __init__(self,year,month,day):
28 self.year=year
29 self.month=month
30 self.day=day
31 @staticmethod
32 def now():
33 t=time.localtime()
34 return Date(t.tm_year,t.tm_mon,t.tm_mday)
35
36 class EuroDate(Date):
37 def __str__(self):
38 return 'year:%s month:%s day:%s' %(self.year,self.month,self.day)
39
40 e=EuroDate.now()
41 print(e) #我们的意图是想触发EuroDate.__str__,但是结果为
42 '''
43 输出结果:
44 <__main__.Date object at 0x1013f9d68>
45 '''
46 因为e就是用Date类产生的,所以根本不会触发EuroDate.__str__,解决方法就是用classmethod
47
48 import time
49 class Date:
50 def __init__(self,year,month,day):
51 self.year=year
52 self.month=month
53 self.day=day
54 # @staticmethod
55 # def now():
56 # t=time.localtime()
57 # return Date(t.tm_year,t.tm_mon,t.tm_mday)
58
59 @classmethod #改成类方法
60 def now(cls):
61 t=time.localtime()
62 return cls(t.tm_year,t.tm_mon,t.tm_mday) #哪个类来调用,即用哪个类cls来实例化
63
64 class EuroDate(Date):
65 def __str__(self):
66 return 'year:%s month:%s day:%s' %(self.year,self.month,self.day)
67
68 e=EuroDate.now()
69 print(e) #我们的意图是想触发EuroDate.__str__,此时e就是由EuroDate产生的,所以会如我们所愿
70 '''
71 输出结果:
72 year:2017 month:3 day:3
73 '''