python基础学习-面向对象高级

一、反射

1、什么是反射？

指的是在程序运行过程中可以"动态 (不见棺材不掉泪)"获取对象的信息

2、为什么要用反射？

在不清楚对方程序提供的obj值对其进行分析处理时，不知道从什么地方获取，也不清楚这个值得属性的情况下 就需要用到反射进行动态获取进行分析

3、如何实现反射？

#举例：
class People:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print(‘<%s:%s>‘ %(self.name,self.age))

obj=People(‘辣白菜同学‘,18)

#3.1 实现反射机制的步骤
#1、先通过多dir：查看出某一个对象下可以.出哪些属性来
print(dir(obj))

#2、可以通过字符串反射到真正的属性上，得到属性值
print(obj.__dict__[dir(obj)[-2]])

#3.2  四个内置函数的使用:通过字符串来操作属性值
#1、hasattr()
print(hasattr(obj,‘name‘))
print(hasattr(obj,‘x‘))

#2、getattr()
print(getattr(obj,‘name‘))

#3、setattr()
setattr(obj,‘name‘,‘EGON‘) # obj.name=‘EGON‘
print(obj.name)

#4、delattr()
delattr(obj,‘name‘) # del obj.name
print(obj.__dict__)

res1=getattr(obj,‘say‘) # obj.say
res2=getattr(People,‘say‘) # People.say
print(res1)
print(res2)

obj=10
if hasattr(obj,‘x‘):
    print(getattr(10,‘x‘))
else:
    pass

print(getattr(obj,‘x‘,None))

if hasattr(obj,‘x‘):
    setattr(obj,‘x‘,111111111) # 10.x=11111
else:
    pass
# 小案例
class Ftp:
    def put(self):
        print(‘正在执行上传功能‘)

    def get(self):
        print(‘正在执行下载功能‘)

    def interactive(self):
        method=input(">>>: ").strip() # method=‘put‘

        if hasattr(self,method):
            getattr(self,method)()
        else:
            print(‘输入的指令不存在‘)

obj=Ftp()
obj.interactive()

二、内置方法

1、什么是内置方法？

定义在类内部，以开头并且以结尾的方法

特点：会在某种情况下自动触发执行

2、为何要使用内置方法？

为了定制化我们的类or对象

3、如何使用内置方法

# 常用：
# __str__:定制内置打印方法
class People:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def __str__(self):  #定制内置方法，一般用于定制打印操作
        # print(‘运行了。。。。。‘)
        return ‘<%s:%s>‘ %(self.name,self.age)

obj=People(‘辣白菜同学‘,18)

print(obj)  #打印显示是  内存地址     如果要显示<‘辣白菜同学‘：18>

obj1=int(10)
print(obj1)  #10   内置的类型做处理了

#__del__:在清理对象时触发，会先执行该方法
class People:
    def __init__(self,name,age):
        self.name=name
        self.age=age     #self.x占用的是操作系统的内存资源

    def __del__(self):  #删除对象之前进行回收资源，
        # print(‘run.....‘)
        # 发起系统调用，告诉操作系统回收相关的系统资源
        self.x.close()

obj = People(‘辣白菜同学‘, 18)
del obj #obj.__del__() 平时几乎不会用到这个方法
应用场景：应用程序结束后，操作系统不会清理内存空间，所以才需要内部自动触发，告诉操作系统，回收相关的系统资源



三、元类


1、 引入：


一切都源自于一句话：一切皆为对象




2、 什么是元类？


元类就是用来实例化产生类的类 关系：元类---实例化---->类（People）---实例化---->对象（obj）





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

    def say(self):
        print(‘%s:%s‘ %(self.name,self.name))

print(People.__dict__)
#如何得到对象
#obj=调用类()
obj=People(‘egon‘,18)
print(type(obj))
#如果说类也是对象
#People=调用类(。。。)

#查看内置的元类：
#1、type是内置的元类
#2、我们用class关键字定义的所有的类以及内置的类都是由元类type实例化产生
print(type(People))
print(type(int))



3、class关键字创造类People的步骤



# 类有三大特征：类名、类的基类、执行类体代码拿到类的名称空间
# 1、类名
class_name="People"
# 2、类的基类
class_bases=(object,)
# 3、执行类体代码拿到类的名称空间
class_dic={}
class_body="""
def __init__(self,name,age):
    self.name=name
    self.age=age

def say(self):
    print(‘%s:%s‘ %(self.name,self.name))
"""
exec(class_body,{},class_dic)
# print(class_dic)

# 4、调用元类
print(type(class_name,class_bases,class_dic))   #得到一个类
# People=type(class_name,class_bases,class_dic)    #产生一个类，自己造一个类，也就是class关键字做的事)



4、如何自定义元类来控制类的产生


4.1 需求：自定义类控制类名必须大写，没有就报错(抛出异常) #报错rais方法



class Mymeta(type): # 只有继承了type类的类才是元类
    # 传过来4个参数，空对象,"People",(object,),{...}
    def __init__(self,x,y,z):  #xyz此处表示变量名，可以是class_name、class_bases、class_dic
        # print(‘run....‘)
        # print(self)
        # print(x)
        # print(y)
        # print(z)
        print(self.__bases__)  #object
        if not x.istitle():
            raise NameError(‘类名的首字母必须大写啊！！！‘)

    def __new__(cls, *args, **kwargs):#自定义new方法，当前所在的类，调用类所传入的参数
        print(‘run111.....‘)
        #造Mymeta的对象
        print(cls,args,kwargs)
        # return super().__new__(cls,*args, **kwargs)
        return type.__new__(cls,*args, **kwargs)  #两种都可

# People=Mymeta("People",(object,),{...})
# 调用Mymeta发生三件事
# 1、先造一个空对象=>People，调用类内的__new__方法，初始化属性
# 2、调用Mymeta这个类内的__init__方法，完成初始化对象的操作（调用init方法之前先执行其他的）
# 3、返回初始化好的对象

class People(metaclass=Mymeta):   #定义类名小写就会报错

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

    def say(self):
        print(‘%s:%s‘ %(self.name,self.name))



4.2 需求：自定义类控制类体必须有文档注释并且不为空，不是就抛出异常



class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
    def __init__(self,class_name,class_bases,class_dic):
        # print(self) #<class ‘__main__.StanfordTeacher‘>
        # print(class_bases) #(<class ‘object‘>,)
        # print(class_dic) #{‘__module__‘: ‘__main__‘, ‘__qualname__‘: ‘StanfordTeacher‘, ‘school‘: ‘Stanford‘, ‘__init__‘: <function StanfordTeacher.__init__ at 0x102b95ae8>, ‘say‘: <function StanfordTeacher.say at 0x10621c6a8>}
        super(Mymeta, self).__init__(class_name, class_bases, class_dic)  # 重用父类的功能

        # if class_name.islower():
        #     raise TypeError(‘类名%s请修改为驼峰体‘ %class_name)

        if ‘__doc__‘ not in class_dic or len(class_dic[‘__doc__‘].strip(‘ \n‘)) == 0:
            raise TypeError(‘类中必须有文档注释，并且文档注释不能为空‘)

# StanfordTeacher=Mymeta(‘StanfordTeacher‘,(object),{...})
class StanfordTeacher(object,metaclass=Mymeta):
    """
    类StanfordTeacher的文档注释
    """
    school=‘Stanford‘

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

    def say(self):
        print(‘%s says welcome to the Stanford to learn Python‘ %self.name)

# 强调：只要是调用类，那么会一次调用
# 1.类内的__new__
# 2.类内的__init__



5、__call__方法



class Foo:
    def __call__(self, *args, **kwargs):
        print(self)
        print(args)
        print(kwargs)

obj=Foo()
#1、要想让obj这个对象变成一个可调用的对象，需要在该对象的类中定义一个方法__call__方法，该方法会在调用对象时自动触发
#2、调用obj的返回值就是__call__方法的返回值
res=obj(1,2,3,x=1,y=2)



6、自定义元类控制类的调用=》类的对象的产生





class Mymeta(type): # 只有继承了type类的类才是元类
    def __call__(self, *args, **kwargs):
        # 1、Mymeta.__call__函数内会先调用People内的__new__
        people_obj=self.__new__(self)
        # 2、Mymeta.__call__函数内会调用People内的__init__
        self.__init__(people_obj,*args, **kwargs)

        # print(‘people对象的属性：‘,people_obj.__dict__)
        people_obj.__dict__[‘xxxxx‘]=11111
        # 3、Mymeta.__call__函数内会返回一个初始化好的对象
        return people_obj

# 类的产生：
# People=Mymeta()=》type.__call__=>干了3件事
# 1、type.__call__函数内会先调用Mymeta内的__new__
# 2、type.__call__函数内会调用Mymeta内的__init__
# 3、type.__call__函数内会返回一个初始化好的对象

class People(metaclass=Mymeta):
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print(‘%s:%s‘ %(self.name,self.name))

    def __new__(cls, *args, **kwargs):
        # 产生真正的对象
        return object.__new__(cls)

# 类的调用：
# obj=People(‘egon‘,18) =》Mymeta.__call__=》干了3件事
# 1、Mymeta.__call__函数内会先调用People内的__new__
# 2、Mymeta.__call__函数内会调用People内的__init__
# 3、Mymeta.__call__函数内会返回一个初始化好的对象

obj1=People(‘egon‘,18)
obj2=People(‘egon‘,18)
# print(obj)
print(obj1.__dict__)
print(obj2.__dict__)



四、属性的查找



# 属性查找的原则：对象-》类-》父类
# 切记：父类 不是 元类

class Mymeta(type):  #自定义一个元类
    n=444

    def __call__(self, *args, **kwargs): #self=<class ‘__main__.StanfordTeacher‘>
        obj=self.__new__(self) # StanfordTeacher.__new__
        # obj=object.__new__(self)
        print(self.__new__ is object.__new__) #True
        self.__init__(obj,*args,**kwargs)
        return obj

class Bar(object):
    # n=333

    # def __new__(cls, *args, **kwargs):
    #     print(‘Bar.__new__‘)
    pass

class Foo(Bar):
    # n=222

    # def __new__(cls, *args, **kwargs):
    #     print(‘Foo.__new__‘)
    pass

class StanfordTeacher(Foo,metaclass=Mymeta):
    # n=111

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

obj=StanfordTeacher(‘lili‘,18)
print(obj.__dict__)
# print(obj.n)
# print(StanfordTeacher.n)



 



原文地址：https://www.cnblogs.com/dingbei/p/12706602.html
				


				
时间： 2024-12-08 19:54:37 

		


		


	

	
	

		


		
python基础学习-面向对象高级的相关文章


								

		

			

                python基础之面向对象高级编程
			

		

		

									

				面向对象基本知识: 面向对象是一种编程方式,此编程方式的实现是基于对 类 和 对象 的使用 类 是一个模板,模板中包装了多个"函数"供使用(可以讲多函数中公用的变量封装到对象中) 对象,根据模板创建的实例(即:对象),实例用于调用被包装在类中的函数 面向对象三大特性:封装.继承和多态 本篇将详细介绍Python 类的成员.成员修饰符.类的特殊成员. 类的成员 类的成员可以分为三大类:字段.方法和属性 注:所有成员中,只有普通字段的内容保存对象中,即:根据此类创建了多少对象,在内存中就有			

		

	

				

		

			

                python基础学习shutil高级的文件，目录，压缩包处理模块
			

		

		

									

				shutil高级的文件,目录,压缩包处理模块import shutil 复制shutil.copyfileobj(f1,f2) #从一个文件对接复制到另一个文件对象,需要先打开文件shutil.copyfile() #拷贝文件shutil.copystat() #只拷贝文件状态信息 包括 modebits,atime,mtime,flagsshutil.copymode() #值拷贝权限.内容和组,用户均不改变shutil.copy() #拷贝文件和权限shutil.copy2() #同时拷贝文			

		

	

				

		

			

                python基础学习05（核心编程第二版）部分
			

		

		

									

				# -*- coding: utf-8 -*- # ==================== #File: python #Author: python #Date: 2014 #==================== __author__ = 'Administrator' #dict{键:值} #哈希 #注:字典是无顺序的,所以你懂的 #创建与赋值 dict1={} dict2={'name':'apply','avg':24,'sex':'man'} print dict1,dict2			

		

	

				

		

			

                Day6 - Python基础6 面向对象编程
			

		

		

									

				Python之路,Day6 - 面向对象学习 本节内容: 面向对象编程介绍 为什么要用面向对象进行开发? 面向对象的特性:封装.继承.多态 类.方法. 引子 你现在是一家游戏公司的开发人员,现在需要你开发一款叫做<人狗大战>的游戏,你就思考呀,人狗作战,那至少需要2个角色,一个是人, 一个是狗,且人和狗都有不同的技能,比如人拿棍打狗, 狗可以咬人,怎么描述这种不同的角色和他们的功能呢? 你搜罗了自己掌握的所有技能,写出了下面的代码来描述这两个角色 1 2 3 4 5 6 7 8 9 10 11			

		

	

				

		

			

                python基础学习12（核心编程第二版）部分
			

		

		

									

				# -*- coding: utf-8 -*- # ==================== #File: python #Author: python #Date: 2014 #==================== __author__ = 'Administrator' #python class #面向对象编程oop思想,3个特性:封装.继承.多态,在其他方面的功能,比如重载,模拟等,也可以自定义自己需要的类 #在python中,面向对象主要2个:类和类实例 #类与实例 #类与实例有关			

		

	

				

		

			

                python基础学习09（核心编程第二版）部分
			

		

		

									

				# -*- coding: utf-8 -*- # ==================== #File: python #Author: python #Date: 2014 #==================== __author__ = 'Administrator' #什么是函数 #就是引用,创建,使用 #例子 def foo(): print '233' foo() #返回与函数类型 def foo1():#是一个过程 print 'hello world!' foo1() foo			

		

	

				

		

			

                Python基础学习 总结篇
			

		

		

									

				Python基础学习总结 先附上所有的章节: Python学习(一)安装.环境配置及IDE推荐 Python学习(二)Python 简介 Python学习(三)流程控制 Python学习(四)数据结构(概要) Python学习(四)数据结构 —— int float Python学习(四)数据结构 —— str Python学习(四)数据结构 —— bool Python学习(四)数据结构 —— list tuple range Python学习(四)数据结构 —— set frozenset			

		

	

				

		

			

                python基础学习日志day5-各模块文章导航
			

		

		

									

				python基础学习日志day5---模块使用 http://www.cnblogs.com/lixiang1013/p/6832475.html python基础学习日志day5---time和datetime模块 http://www.cnblogs.com/lixiang1013/p/6848245.html python基础学习日志day5---random模块http://www.cnblogs.com/lixiang1013/p/6849162.html python基础学习日志da			

		

	

				

		

			

                Python 基础学习 网络小爬虫
			

		

		

									

				<span style="font-size:18px;"># # 百度贴吧图片网络小爬虫 # import re import urllib def getHtml(url): page = urllib.urlopen(url) html = page.read() return html def getImg(html): reg = r'src="(.+?\.jpg)" pic_ext' imgre = re.compile(reg) imgli