路飞学城Python-Day19
【23.绑定方法与非绑定方法介绍】
再类的内部的定义的函数分为两大类：
1.绑定方法：
绑定到对象的方法：直接用def做的函数属性，类内部定义的函数，如果没有绑定装饰器，就是给对象使用的函数，绑定给谁就给谁来调用
绑定到类的方法
2.非绑定方法：不与类或者对象绑定
# 绑定对象的方法,类去访问自己的函数属性的时候就是一个普通的函数，没有自动调用的方式
# 绑定给谁，就应该谁来调用就会把调用者当做第一个参数自动传入
# class Foo:
# def __init__(self, name):
# self.name = name
#
# def tell(self):
# print('名字是%s' %self.name)
#
# f = Foo('panda')
# print(f.tell)
# -------------------------------------------------------------------
# 绑定到类:在类的内部定义的，被装饰器classmethod修饰的方法
# class Foo:
# def __init__(self, name):
# self.name = name
#
# def tell(self):
# print('名字是%s' %self.name)
#
# @classmethod
# def func(cls):
# print(cls)
#
# Foo.func()
# print(Foo)
# -------------------------------------------------------------------
# 非绑定方法:不与类或者对象绑定,没有自动传值，谁都可以用，就相当于普通函数，一点都没有绑定关系
# 就是类中定义的普通工具
class Foo:
def __init__(self, name):
self.name = name
def tell(self):
print('名字是%s' %self.name)
@staticmethod
def func1(x,y):
return x+y
f = Foo('panda')
print(Foo.func1(1,2))
print(f.func1(1,3))
【24.绑定方法与非绑定方法】
什么场景下使用绑定方法和非绑定方法
import settings
class People:
def __init__(self,name, age, sex):
self.name = name
self.age = age
self.sex = sex
self.id = self.create_id()
def tell_info(self): #绑定到对象的方法
print('Name %s Age %s Sex %s' % (self.name, self.age, self.sex))
@classmethod
def from_conf(cls):
obj = cls(
settings.name,
settings.age,
settings.sex
)
return obj
@staticmethod
def create_id():
import hashlib
import time
m = hashlib.md5(str(time.time()).encode('utf-8'))
return m.hexdigest()
# p1 = People('panda', 18, '男')
# 绑定给对象就由对象来调用，自动将对象本身当做第一个参数传入
# p1.tell_info() #tell_info(p1)
# 新需求：从配置文件里读取信息来实例化对象
# p2 = People(settings.name, settings.age, settings.sex)
# p2.tell_info()
#---------------------------------------------------#
# 绑定给类
# p = People.from_conf()
# p.tell_info()
#---------------------------------------------------#
# 非绑定方法，不与类或者对象绑定，谁都可以调用，没有自动传入值的功能
# p1 = People('panda',20,'male')
# p2 = People('pandaboy',10,'male')
# print(p1.id)
# print(p2.id)
【25.反射】
用户的输入就会变成字符串,input方法就是会转换成字符串的形式
如果通过用户的输入，让用户通过字符串调用类的属性
反射：通过字符串来映射到对象的属性
# class People:
# county = 'China'
# def __init__(self,name, age):
# self.name = name
# self.age = age
# def talk(self):
# print('%s is talking' %self.name)
#
# obj = People('panda', 10)
# print(obj.name)
# obj.talk()
# 用户的输入就会变成字符串,input方法就是会转换成字符串的形式
# 如果通过用户的输入，让用户通过字符串调用类的属性
# 1.hasattr(obj,str)>>判断obj下到底有没有str的参数属性，本质上就是判断字典里有没有str的属性(obj.__dict__(str))>>返回的值是布尔值(True/False)(判断有没有)
# 2.getattr(obj,str,default)>>直接显示str属性的结果，如果没有就报错,default就是直接赋值None(设置)
# 3.setattr(obj,'sex','male')>>等同于obj.sex = male设置对象的值(修改和新增)
# 4.delattr(obj, 'age')>>等同于del obj.age删除对象的值(删除)
# print(getattr(People,'county'))
反射的应用
class Service:
def run(self):
while True:
cmd = input('>>>').strip()
print(cmd)
if hasattr(self,cmd):
func = getattr(self,cmd)
func()
def get(self):
print('get.....')
def put(self):
print('put.....')
obj = Service()
obj.run()
【26.内置方法介绍】
isinstance(obj,cls)检查是否obj是否是类 cls 的对象
对象到底是不是类的实例
class Foo:
pass
obj = Foo()
print(isinstance(obj,Foo))
issubclass(sub, super)检查sub类是否是 super 类的派生类
class Foo:
pass
class Bar(Foo):
pass
print(issubclass(Bar,Foo))
Item系列
把对象模拟成python的字典类型的数据实现访问的格式，会把obj模拟成字典的形式
class Foo:
def __init__(self,name):
self.name = name
def __getitem__(self, item):
# print('Get item.....')
# print(item)
return self.__dict__.get(item)
def __setitem__(self, key, value):
# print('Set item.....')
# print(key,value)
self.__dict__[key] = value
def __delitem__(self, key):
self.__dict__.pop(key)
obj = Foo('panda')
#实现obj.name的实现方式,
# 查看属性
print(obj['name'])
#设置赋值方式,设置属性
obj['sex'] = 'male'
print(obj['sex'])
# 删除属性
del obj['name']
print(obj['name'])
__str__方法改变对象的字符串显示，会在打印对象的时候触发，把返回结果（必须是字符串）返回
class People:
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return '<name %s age %s>' % (self.name, self.age)
obj = People('panda',10)
print(obj)
__del__方法：如果在类的内部调用了__del__方法，这个方法就会绑定给对象，在对象被删除的时候会自动先触发，就会调用垃圾回收机制，即使你不调用，也会在删除对象的时候自动触发__del__方法，
# ___模拟打开文件的操作，在python内部结束了以后，会自动触发__del__的操作，自动回收操作系统资源
class Open:
def __init__(self, filename):
print('open file...')
self.filename = filename
def __del__(self):
print('Finish ！')
f = Open('test.txt')
print('At the end')
【27.元类介绍】
面向对象高级难点：元类（metaclass）
储备知识exec--->把字符串里的内容提取出来直接执行
参数1：字符串形式的命令
参数2：全局作用域（字典形式），可以定制一个全局作用域（如果不指定，默认使用globals()）
参数3：局部作用域（字典形式），如果不指定默认就使用loacals()
实例化了元类得到了元类的对象，元类的对象实际上就是利用class声明的一个类
g = {
'x':1,
'y':2,
}
l = {}
exec('''
global x,m
x = 10
m = 100
z = 3
''',g, l)
print(g.get('m'))
print(l)
# python中一切皆对象，对象可以怎么使用？
# 1.都可以被引用，x = obj
# 2.都可以当做函数的参数传入
# 3.都可以当做函数的返回值
# 4.都可以当做容器类型的元素，l = [func, time, obj, 1]
# 产生类的类称之为元类,默认所有用class定义的类，他们得元类就是type
# 定义类有两种实现方式
# 1.class关键字的方式
# class Chinese:
# country = 'China'
# def __init__(self,name, age):
# self.name = name
# self.age = age
# def talk(self):
# print('%s is talking' % self.name)
# 2.type元类的产生
# 定义类的三要素
# 1.类的类名
# 2.类的继承，python3中默认继承object
# 3.类必须要有自己的名称空间，里面定义了自己的数据属性和函数属性
class_name = 'Chinese'
class_bases = (object, )
class_body = """
country = 'China'
def __init__(self,name,age):
self.name = name
self.age = age
def talk(self):
print('%s is taking'%self.name)
"""
class_dic = {}
exec(class_body, globals(), class_dic)
Chinese = type(class_name, class_bases, class_dic)
print(class_dic)
【28.自定义元类控制类的创建】
如何自己定制元类来控制class的行为
# # 自定义元类最好指定type，因为你只是重写一部分类的方法，本身更多的类的属性还是从type中来的
#
#
# class Mymeta(type):
# def __init__(self,class_name, class_bases, class_dic):
# if not class_name.istitle():
# raise TypeError('类型错误，类名的首字母必须大写')
# super(Mymeta,self).__init__(class_name,class_bases,class_dic)
#
#
# class Chinese(object, metaclass=Mymeta):
# country = 'China'
#
# def __init__(self,name, age):
# self.name = name
# self.age = age
#
# def talk(self):
# print('%s is talking' % self.name)
# # Chinese = Mymeta(class_name,class_bases,class_dic)
class Foo:
'''
注释
'''
pass
print(Foo.__dict__)
print(Foo.__doc__)
【29.自定义元类控制类的实例化行为】
补充知识点：调用方法__call__
对象实例化以后调用__call__
1.先造一个空对象（object.__new__(self)）
2.初始化(self.__init__(obj,*args,**kwargs))
3.返回(return obj)
# class Foo:
# def __call__(self, *args, **kwargs):
# print(self)
# print(args)
# print(kwargs)
#
#
# obj = Foo()
# obj(1,1,3,a=1,b=2)
# 调用对象实际上会触发__call__这个内置方法，不同的值会存成不同的形式保存
# 元类内部也是有一个__call__方法，会在调用Foo时触发执行
# Foo(1,2,x=1) Foo.__call__(Foo,1,2,x=1)
class Mymeta(type):
def __init__(self,class_name, class_bases, class_dic):
if not class_name.istitle():
raise TypeError('类型错误，类名的首字母必须大写')
if '__doc__' not in class_dic or not class_dic['__doc__'].strip():
raise TypeError('必须有注释，且注释不能为空')
super(Mymeta,self).__init__(class_name,class_bases,class_dic)
def __call__(self, *args, **kwargs):
print('>>>>')
class Chinese(object, metaclass=Mymeta):
'''
注释
'''
country = 'China'
def __init__(self,name, age):
self.name = name
self.age = age
def talk(self):
print('%s is talking' % self.name)
# # Chinese = Mymeta(class_name,class_bases,class_dic)
obj = Chinese('panda', 20) # 实际上就是执行Chinese.__call__(Chinese,'panda',20)
【30.自定义元类控制类的实例化行为的应用】
#单例模式:默认参数一样的情况下，就不会生成新的内存空间了，用公用的就行(实际就是一种优化的策略)
#单例模式:默认参数一样的情况下，就不会生成新的内存空间了，用公用的就行(实际就是一种优化的策略)
class MySQL:
__instance = None
def __init__(self):
self.host = '127.0.0.1'
self.port = 3306
@classmethod
def singleton(cls):
if not cls.__instance:
obj = cls()
cls.__instance = obj
return cls.__instance
def find(self):
pass
def update(self):
pass
obj1 = MySQL.singleton()
obj2 = MySQL.singleton()
print(id(obj1))
print(id(obj2))
# #单例模式:默认参数一样的情况下，就不会生成新的内存空间了，用公用的就行(实际就是一种优化的策略)
# class MySQL:
# __instance = None
# def __init__(self):
# self.host = '127.0.0.1'
# self.port = 3306
# @classmethod
# def singleton(cls):
# if not cls.__instance:
# obj = cls()
# cls.__instance = obj
# return cls.__instance
#
# def find(self):
# pass
#
# def update(self):
# pass
#
#
# obj1 = MySQL.singleton()
# obj2 = MySQL.singleton()
#
# print(id(obj1))
# print(id(obj2))
# ---------------------------------------#
# 实现方式二：元类的方式
class Mymeta(type):
def __init__(self,class_name, class_bases, class_dic):
if not class_name.istitle():
raise TypeError('类型错误，类名的首字母必须大写')
super(Mymeta,self).__init__(class_name,class_bases,class_dic)
self.__instance=None
def __call__(self, *args, **kwargs):
if not self.__instance:
obj = object.__new__(self)
self.__init__(obj)
self.__instance = obj
return self.__instance
class Mysql(object,metaclass=Mymeta):
def __init__(self):
self.host = '127.0.0.1'
self.port = 3306
def find(self):
pass
def update(self):
pass
obj1 = Mysql()
obj2 = Mysql()
obj3 = Mysql()
print(id(obj1))
print(id(obj2))
print(id(obj3))
【31.面向对象的软件开发与作业介绍】
【32.什么是异常处理】
【32.try...except...详细方法】