本文目录：

一、类的绑定与非绑定方法

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

    1. 绑定方法

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

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

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

    2. 非绑定方法

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

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

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)

import settings

class MySQL:

    def __init__(self,ip,port):

        self.id=self.create_id()

        self.ip=ip

        self.port=port

    def tell_info(self):

        print('<%s:%s:%s>' % (self.id,self.ip, self.port))

    @classmethod

    def from_conf(cls):

        return cls(settings.IP, settings.PORT)

    @staticmethod

    def create_id():

        import uuid

        return uuid.uuid4()

obj=MySQL('1.1.1.1',3306)

# obj1=MySQL('1.1.1.2',3406)

obj.tell_info()

# obj1.tell_info()

# obj2=MySQL.from_conf()

# obj2.tell_info()

二、反射

什么是反射

反射的概念是由Smith在1982年首次被提出主要是指程序可以访问、监测和修改它本身状态或行为的一种能力（自省）。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究，它首先被程序语言的设计领域所采用，并在Lisp和面向对象方面取得了成绩。

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

四个可以实现自省的函数：hasattr\getattr\serattr\delattr

class MyClass():

    e = 5

    def __init__(self,x,y):

        self.x = x

        self.y = y

    def func1(self):

        print(self.x + self.y)

obj = MyClass("","")

# 判断类实例化对象中是否有z这个属性或方法名返回True或False

print(hasattr(obj,'z'))

print(hasattr(obj,'func1'))

# 对象调hasattr也可以查看类属性

print("obj有e这个属性",hasattr(obj,'e'))

hasattr

class MyClass():

    e = 5

    def __init__(self,x,y):

        self.x = x

        self.y = y

    def func1(self):

        print(self.x + self.y)

obj = MyClass("","")

# 获取类实例化对象中的属性或方法，如果是存在方法返回该方法的对象，如果不存在就会报错

print(getattr(obj,"y"))

# 也可以通过类实例化对象获取类的e属性

print("对象获取类的属性",getattr(obj,"e"))

getattr

class MyClass():

    e = 5

    def __init__(self,x,y):

        self.x = x

        self.y = y

    def func1(self):

        print(self.x + self.y)

obj = MyClass("","")

# setattr新增属性，参数（对象，属性，值）

setattr(obj,"z",3)

print(obj.__dict__)

# setattr新增方法，参数（对象，属性，值）

setattr(obj,'show_name',lambda self:self.y + "个傻逼")

print(obj.__dict__)

print(obj.show_name(obj))

# setattr修改原有的值

setattr(obj,"y","")

print(obj.__dict__)

print(obj.show_name(obj))

# 对象setattr修改类的属性，对象中的e值发生改变，可类中的e是不发生变化的还是5

setattr(obj,"e",10)

print("对象调用setattr修改类的属性e，用对象查看结果：",obj.__dict__)

print("对象调用setattr修改类的属性e，用类查看结果",MyClass.__dict__)

setattr

class MyClass():

    e = 5

    def __init__(self,x,y):

        self.x = x

        self.y = y

    def func1(self):

        print(self.x + self.y)

obj = MyClass("","")

# delattr删除属性

delattr(obj,"z")

print(obj.__dict__)

# delattr删除方法

delattr(obj,'show_name')

print(obj.__dict__)

# delattr删除对象原有的属性

delattr(obj,"x")

print(obj.__dict__)

# delattr删除类原有的属性，对象中的e被删除调了，可类中的e还是存在的

delattr(obj,'e')

print("对象调用delattr删除类的属性e，用对象查看结果",obj.__dict__)

print("类调用delattr删除类的属性e，用对象查看结果",MyClass.__dict__)

delattr

'''

反射指的是通过字符串来操作属性

'''

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

# 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__)

三、内置方法

# 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

巴特西

python面向编程；类的绑定与非绑定方法、反射、内置方法

一、类的绑定与非绑定方法

二、反射

什么是反射

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

三、内置方法

最新文章

热门文章