面向对象之绑定方法和非绑定方法、反射、内置方法

一、绑定方法和非绑定方法

类中定义函数分为了两大类:

1、 绑定方法

特殊之处: 绑定给谁就应该由谁来调用,谁来调用就会将谁当做第一个参数自动传入

绑定给对象的方法: 在类中定义函数没有被任何装饰器修饰的情况下,默认就是绑定对象的。

绑定给类的方法: 为类中定义函数添加一个装饰器classmethod,就是绑定类的

2.、非绑定方法

特殊之处: 非绑定方法就是一个普通函数,既不与类绑定又不与对象绑定,意味着类与对象都可以调用,但是无论谁来调用都是一个普通函数,没有自动传值效果

非绑定方法: 为类中定义函数添加一个装饰器staticmethod,就是非绑定方法

绑定给对象的方法：绑定给对象的,应该由对象来调。

绑定给类的方法（classmethod）

　　classmehtod是给类用的，即绑定到类，类在使用时会将类本身当做参数传给类方法的第一个参数（即便是对象来调用也会将类当作第一个参数传入），python为我们内置了函数classmethod来把类中的函数定义成类方法。

在类内部用（staticmethod）装饰的函数即非绑定方法，就是普通函数

statimethod不与类或对象绑定，谁都可以调用，没有自动传值效果

# class Foo:
#     def func1(self):
#         print('func1',self)
#
#     @classmethod
#     def func2(cls):
#         print('func2',cls)
#
#     @staticmethod
#     def func3(x,y):
#         print('func3',x,y)
#
# obj=Foo()

一.绑定给对象的方法
# 绑定给对象的,应该由对象来调,
# obj.func1()
# print(obj)

# 绑定给对象的方法,类也可以调用,但是类调用就是一个普通函数,没有自动传值的效果
# print(obj.func1)
# print(Foo.func1)
# Foo.func1(obj)

二.绑定给类的方法
# 绑定给类的,应该由类来调,
# print(Foo.func2)
# print(obj.func2)
# Foo.func2()
# obj.func2()

三.非绑定方法
# print(obj.func3)
# print(Foo.func3)

# obj.func3(1,2)
# Foo.func3(1,3)

eg：

HOST='127.0.0.1'
PORT=3306
DB_PATH=r'C:\Users\Administrator\PycharmProjects\test\面向对象编程\test1\db'

import settings
class MySQL:
    def __init__(self,host,port):
        self.host=host
        self.port=port

    @classmethod
    def from_conf(cls):
        print(cls)
        return cls(settings.HOST,settings.PORT)

print(MySQL.from_conf) #<bound method MySQL.from_conf of <class '__main__.MySQL'>>
conn=MySQL.from_conf()

conn.from_conf() #对象也可以调用，但是默认传的第一个参数仍然是类

二、反射

 python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）

class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def tell_info(self):
        print('%s:%s' %(self.name,self.age))

obj=Foo('egon',18)

四个可以实现自省的函数

下列方法适用于类和对象（一切皆对象，类本身也是一个对象）

#hasattr   判断object中有没有一个name字符串对应的方法或属性
# print(hasattr(obj,'name')) #obj.name
# print(hasattr(obj,'tell_info')) #obj.tell_info

#getattr   获取属性
# res=getattr(obj,'name') #res=obj.name
# print(res)
# res=getattr(obj,'xxx',None)
# print(res)

#setattr   设置属性
# setattr(obj,'age',38)
# setattr(obj,'sex','male')
# print(obj.__dict__)
# print(obj.sex)

#delattr   删除属性
# delattr(obj,'name')
if hasattr(obj,'xxxxe'):
    delattr(obj,'xxxxe')
# print(obj.__dict__)

如果是作用于类：

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')   # old boy
print getattr(Foo, 'func')   #<function Foo.func at 0x0000000002270620>
print getattr(Foo, 'bar')    #<function Foo.bar at 0x00000000022706A8>

类也是对象

三、内置方法（最常用）

isinstance(obj,cls)和issubclass(sub,super)

# print(isinstance([],list)) #type([]) is list
# class Foo:
#     pass
# obj=Foo()
# print(isinstance(obj,Foo))

# issubclass()
# class Foo:
#     pass
#
# class Bar(Foo):
#     pass
# print(issubclass(Bar,Foo))

__str__: 会在对象被打印时自动触发,然后将返回值返回给print功能进行打印

# class People:
#     def __init__(self,name,age):
#         self.name=name
#         self.age=age
#
#     def __str__(self):
#         return '<%s:%s>' %(self.name,self.age)
#
# peo=People('egon',18)
# print(peo) #print(peo.__str__())
#
# l=list([1,2,3])
# print(l)

__del__: 会在对象被删除时自动触发执行,用来在对象被删除前回收系统资源

# class Foo:
#     def __del__(self):
#         print('===>')
#
# obj=Foo()
# # del obj
# print('其他代码...')

class Bar:
    def __init__(self,x,y,filepath):
        self.x=x
        self.y=y
        self.f=open(filepath,'r',encoding='utf-8')
    def __del__(self):
        # 写回收系统资源相关的代码
        self.f.close()

obj=Bar(10,20)
del obj