组合、反射、内置方法

已于 2023-10-13 16:57:47 修改
阅读量74 收藏
点赞数
文章标签： python 开发语言
于 2023-10-10 16:17:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53842456/article/details/133746804
版权

目录

一、组合

1、什么是组合?

2、什么场景下使用继承? 什么场景下使用组合? 

二、反射

三、内置方法之魔术方式 

__init__

__str__,__repr__

__del__

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

 __doc__

__enter__和__exit__

__setattr__,__delattr__,__getattr__ 

__setitem__,__getitem,__delitem__

__call__

一、组合

组合不是一个新的技术栈，它是对象的另外一种用法

1、什么是组合?

在一个类中以另外一个类的对象作为数据属性，称为类的组合。组合与继承都是用来解决代码的重用性问题。不同的是：继承是一种“是”的关系，比如老师是人、学生是人，当类之间有很多相同的之处，应该使用继承；而组合则是一种“有”的关系，比如老师有生日，老师有多门课程，当类之间有显著不同，并且较小的类是较大的类所需要的组件时，应该使用组合。

组合就是，一个对象拥有一个属性，该属性的值是另外一个对象。

class Foo:
    def __init__(self, m):
        self.m = m

class Bar():
    def __init__(self, n):
        self.n = n

"""一个对象拥有一个属性，该属性的值是另外一个对象"""
obj = Bar(20)
obj1 = Foo(10)
# 超级对象，通过一个属性可以访问到另外一个对象的值

obj.x = obj1 # 这就是一种组合的用法
print(obj.x.z) # obj1.z

2、什么场景下使用继承? 什么场景下使用组合? 

继承一般情况用在：什么是什么的情况 ----> is
组合一般用在：什么有什么的情况 ----> has

class People():
    school = 'SH'

    def __init__(self, name, age, gender, course_name=None, 
course_price=None, course_period=None):
        self.name = name
        self.age = age
        self.gender = gender
        self.course_name = course_name
        self.course_price = course_price
        self.course_period = course_period


class Admin(People):
    def __init__(self, name, age, gender):
        super().__init__(name, age, gender)


class Course():
    def __init__(self, name, price, period):
        self.name = name
        self.price = price
        self.period = period


python = Course('python', 10000, '6mon')
linux = Course('linux', 20000, '5mon')


print(python.name)  # python
print(python.price)  # 10000
print(python.period)  # 6mon


class Student(People):
    def __init__(self, name, age, gender, course=None):
        super().__init__(name, age, gender)
        if course is None:
            course = []
        self.course = course


stu = Student('kevin', 20, 'male')
stu.course.append(python.name)
stu.course.append(linux.name)
print(stu.course)  # ['python', 'linux']
# stu.course: []
for i in stu.course:
    print(i)


class Teacher(People):
    def __init__(self, name, age, gender, level):
        super().__init__(name, age, gender)
        self.level = level


tea = Teacher('ly', 19, 'female', 10)
print(tea.course_name)  # None
tea.course = linux

print(tea.course.name)  # linux
print(tea.course.price)  # 20000

二、反射

在Python中，反射指的是通过字符串来操作对象的属性，涉及到四个内置函数的使用（Python中一切皆对象，类和对象都可以用下述四个方法）。

四个内置函数：
    getattr：获取属性（用的最多）
    setattr：设置属性
    hasattr：判断是否有某个属性
    delattr：删除

class Student():
    school = 'SH'

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

    def func(self):
        print('from func')

    def index(self):
        print('from index')


stu = Student('kevin', 20)
attr = input('请输入你要操作的属性名：')
print(stu.school)

1、getattr（获取属性）

"""当你查询的属性不存在的时候，如果给了第三个参数，就返回第三个参数"""
"""如果你给了第三个参数，查询的属性也存在，那就直接返回属性对应的值，
默认值就没用了"""

res = getattr(stu, 'x') # 直接拿到结果
res = getattr(stu, 'x1', 666) # 直接拿到结果
"""必须掌握!!!!!!"""
res = getattr(stu, 'func1', stu.index)
print(res)  # # 直接拿到结果函数的内存地址
# <bound method Student.func of <__main__.Student object at 0x000001963F5C5A60>>
res()  # from index

# 补充
getattr(Student,'x')
getattr(time,'time')() # 时间戳
getattr(random, 'randint')(0,9) # 生成0-9的随机数
...

2、setattr

setattr(stu, 'x', 666)  # stu.x = 666
print(stu.__dict__)  # {'name': 'kevin', 'age': 20, 'x': 666}

3、hasattr（判断是否存在）

print(hasattr(stu, 'func'))  # True
if hasattr(stu, 'func'):
    getattr(stu, 'func')()  # from func
else:
    ...

4、delattr（删除）

delattr(stu, 'name')
del stu.name
print(stu.__dict__)

补充：

time=__import__('time') # 通过字符串的形式可以导入一些模块
random=__import__('random') # 通过字符串的形式可以导入一些模块
import time
random.randint(0,9) # 不提示，就自己写，不错，只要你别写错

三、内置方法之魔术方式 

它的特点就是双下划线开头的方法，其满足一定的条件就会自动触发，简称魔法。

__init__

__str__,__repr__

1. 打印对象的时候，输出对象的时候会自动触发类中的__str__方法
2. 返回值必须是字符串形式
3. 如果__init__跟__repr__方法同时存在，__str__的优先级更高

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

    def __str__(self):  # 这个用的是最多的
        print('str')
        return 'from str'

    def __repr__(self):
        print('repr')
        return 'from repr'


stu = Student('ly', 20)
print(stu)  # <__main__.Student object at 0x00000226AC4F5A60>

print('repr:', repr(stu))  # repr: from repr
print('str:', str(stu))  # str: from str

__del__

1.一般用在回收系统资源的时候用，比如：关闭文件，关闭链接等

2.当你使用del删除对象的时候会触发__del__的执行
3. 当整个脚本的程序都执行完毕的时候，也会触发__del__的执行 

class MySQL:
    def __init__(self, ip, port):
        self.ip = ip
        self.port = port
        self.f = open('a.txt', 'w')


    def __del__(self):
        print('from _del')
        self.f.close()


mysql = MySQL('127.0.0.1', 3306)
print('1223')

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

isinstance(obj,cls) ---> 检查是否obj是否是类 cls 的对象

issubclass(sub, super) ---> 检查sub类是否是 super 类的派生类

print(isinstance(123, str))  # False
print(type(123) is int)  # True


class Foo:
    pass


class Bar(Foo):
    pass


class Bar1():
    pass


print(issubclass(Bar1, Foo))  # False

 __doc__

查看类中得注释内容，这个属性不会继承类父类

class Foo:
    """
    '我是描述信息asdasd'
    '我是描述信息asdasd'
    '我是描述信息asdasd'
    """

    pass


class Bar(Foo):
    pass


print(Bar.__doc__)  # 该属性无法继承给子类
# None

__enter__和__exit__

我们知道在操作文件对象的时候可以这么写

with open('a.txt') as f:
　　pass

with它可以用在很多地方，但是，出现with语句后面的对象中的类必须要声明__enter__和__exit__

class Open:
    def __init__(self, name):
        self.name = name

    def __enter__(self):
        print('出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量')
        # return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('with中代码块执行完毕时执行我啊')
        print(exc_type)  # 异常类型
        print(exc_val)  # 异常值
        print(exc_tb)  # 追溯信息
        return True  # 如果你在这个方法里面返回了True，with代码块中出现了异常，就相当于没有出现异常


with Open('a.txt') as f:
    print('=====>执行代码块')
    print('=====>执行代码块')
    print('=====>执行代码块')
    print('=====>执行代码块')
    print('=====>执行代码块')
    # print(f,f.name)

如果with代码块中出现了异常，则with语句之后的代码都不能正常执行

class Open:
    def __init__(self,name):
        self.name=name

    def __enter__(self):
        print('出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量')

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('with中代码块执行完毕时执行我啊')
        print(exc_type) # 异常类型
        print(exc_val) # 异常值
        print(exc_tb) # 追溯信息
   


with Open('a.txt') as f:
    print('=====>执行代码块')
    print('=====>执行代码块')
    print('=====>执行代码块')
    print('=====>执行代码块')
    print('=====>执行代码块')
    # print(f,f.name)

with Open('a.txt') as f:
    print('=====>执行代码块')
    raise AttributeError('***着火啦,救火啊***')  # 抛出异常，主动报错
print('0'*100) #------------------------------->不会执行

如果__exit()返回值为True,那么异常会被清空，就好像啥都没发生一样，with后的语句正常执行 

class Open:
    def __init__(self,name):
        self.name=name

    def __enter__(self):
        print('出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量')

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('with中代码块执行完毕时执行我啊')
        print(exc_type) # 异常类型
        print(exc_val) # 异常值
        print(exc_tb) # 追溯信息
        return True # 如果你在这个方法里面返回了True，with代码块中出现了异常，就相当于没有出现异常


with Open('a.txt') as f:
    print('=====>执行代码块')
    print('=====>执行代码块')
    print('=====>执行代码块')
    print('=====>执行代码块')
    print('=====>执行代码块')
    # print(f,f.name)

with Open('a.txt') as f:
    print('=====>执行代码块')
    raise AttributeError('***着火啦,救火啊***')  # 抛出异常，主动报错
print('0'*100) #------------------------------->会执行

__setattr__,__delattr__,__getattr__ 

        必须是使用点语法

1. 使用对象.属性获取结果的时候，会自动触发__getattr__，如果不是点语法不会触发
2. 使用对象.属性 = 属性值的时候，会自动触发__setattr__
3. 使用 del 对象.属性的时候，会自动触发__delattr__的执行

        以上三个方法只是满足触发的条件，不会具体的给你获取值、设置值、删除值等操作，所以，需要自己在对应的方法里面做相关操作。

class Foo:
    x = 1

    def __init__(self, y):
        self.y = y


    def __getattr__(self, item):
        print('----> from getattr:你找的属性不存在')

    def __setattr__(self, key, value):
        print('----> from setattr')
        # self.key=value # self.a=20
        # self.key=value # 这就无限递归了,你好好想想
        self.__dict__[key] = value  # 应该使用它

    def __delattr__(self, item):
        print('----> from delattr')
        # del self.item # 无限递归了
        self.__dict__.pop(item)


# __setattr__添加/修改属性会触发它的执行
f1 = Foo(10)
print(f1.__dict__) 
# 因为你重写了__setattr__,凡是赋值操作都会触发它的运行,
# 你啥都没写,就是根本没赋值,除非你直接操作属性字典,否则永远无法赋值
f1.z = 3
print(f1.__dict__)

# __delattr__删除属性的时候会触发
f1.__dict__['a'] = 3 # 我们可以直接修改属性字典,来完成添加/修改属性的操作
del f1.a
print(f1.__dict__)

# __getattr__只有在使用点调用属性且属性不存在的时候才会触发
f1.xxxxxx

__setitem__,__getitem,__delitem__

        必须是使用中括号([]) obj.x----->obj['x']
1. 使用对象.属性获取结果的时候，会自动触发__getitem__，如果不是点语法不会触发
2. 使用对象.属性 = 属性值的时候，会自动触发__setitem__

3. 使用 del 对象.属性的时候，会自动触发__delitem__的执行

        以上三个方法只是满足触发的条件，不会具体的给你获取值、设置值、删除值等操作，所以，需要自己在对应的方法里面做相关操作。

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

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        self.__dict__[key]=value
    def __delitem__(self, key):
        print('del obj[key]时,我执行')
        self.__dict__.pop(key)
    def __delattr__(self, item):
        print('del obj.key时,我执行')
        self.__dict__.pop(item)

f1=Foo('sb')
f1['age']=18
f1['age1']=19
del f1.age1
del f1['age']
f1['name']='alex'
print(f1.__dict__)

__call__

当对象加括号的时候会触发__call__的执行 

class Foo:

    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):
        print('__call__')


obj = Foo()
print(obj) # 执行 __init__
# <__main__.Foo object at 0x0000021E99153A60>
obj() # 执行 __call_
# __call__

ζ浅安时光
关注
vue3组合式api
weixin_68658847的博客
04-04 1598
vue3组合式api
python内置方法
weixin_45440796的博客
09-25 1071
函数将一个数据集合（列表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。该方法接收两个参数，第一个为函数(有一个参数)，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。如果bool(x)对可迭代对象中的所有x值都为True，则返回True。
python 多态、组合、反射
chenchen5152的博客
01-05 1012
只要是动物就可以直接使用相同的方法！多态的存在其实也限制了子类的使用方法（抽象类也是可以限制子类），定义子类的时候，必须有speak()方法，这样才能算的上动物类，所以python推荐使用“鸭子类型”，是一种不依赖于继承，也可以实现不考虑对象类型而使用对象。
Python基础20 面向对象（3）多态、封装、反射、attr内置方法
weixin_42830015的博客
02-22 921
Python基础19 面向对象（3）多态、封装、反射
反射效果的实现总结
远行's Blog
12-02 4578
反射的实现原理分类 首先要说明下反射向量，指的是视线的镜面反射向量，如下图所示， 实际上，人眼看向一个物体表面的时候，在该位置（上图O点）的反射信息，来自于视线的反射方向，因为光线会从该反射方向打到物体表面，最终进入人眼。一般情况下，我们假定反射角和入射角相等。以下所有涉及到的反射向量， 都是指的视线反射向量，不是光线反射向量。 CubeMap 天空盒就是一个CubeMap，我们可以假定天空盒是一个环境反射来源，也可以指定另外的CubeMap，用反射向量采样这个CubeMap就能得到反射颜色。CubeMa
Shader Graph18-反射、折射函数
zhuziying99的专栏
05-21 1063
第二个参数是Surface Normal就是法线方向，第三个参数是入射介质为空气的折射值1，第四个参数是射出介质为玻璃折射值1.54，下面配个图看看。首先是看一下引擎内置的反射，Base Color设置为1是白色，Metallic设置为1金属强度为最大，Roughness为0粗糙度为最小，那么最后的结果球面上显示的就是周围环境。Lerp的作用是混合两个图的效果，但是我们想要的是边缘反射，中间折射的效果，所以增加Fresnel节点，Fresnel的作用是边缘接近于1，中间接近于0，正是我们需要的。
ProtoBuf（Google Protocol Buffers）—— 反射原理以及反射具体流程介绍
JMW1407的博客
07-09 6244
ProtoBuf—— 反射原理解析ProtoBuf—— 反射原理1、反射原理1.1、反射机制的背景1.2、定义1.3、反射原理关注的一些问题1.4、反射原理的优势和应用2、ProtoBuf反射原理——获取并改造 元信息2.1 、 .proto 文件2.2 、 反射原理过程2.3 、 反射相关的类和API2.3.1、google::protobuf::Message2.3.2、 google::protobuf::Descriptor2.3.3、 google::protobuf::Reflection2.
Blinn-Phong反射模型
CRMEB小程序商城的博客
02-24 6909
前言 在这一章中，实现光线与对象表面之间的相互作用。目的是在渲染流水线中增加着色功能，所以这里只讨论最基础的局部光照模型。与全局光照不同，在局部光照模型中，着色点的颜色值只取决于着色点表面的材质属性、表面的局部几何性质以及光源的位置与属性，而与场景中其他的表面无关。 渲染流程与场景定义 因为不考虑全局光照，只考虑从光源发出的光线，具体来说只考虑光源和表面之间的一次单独的相互作用。所以这个问题可分解为两个独立的部分： 定义场景中的光源（这里只介绍点光源） 定义一个描述材质和光线之间相互作用的反射模型（phon
Python：内置函数
BBJG_001的博客
03-12 2046
原文地址 内置函数总表 内置函数 __import__() abs() all() any() ascii() bin() bool() bytearray() bytes() callable() chr() classmethod() compile() complex() delattr() dict() dir() divmod() enumerat...
3D渲染技术分享：用实时反射Shader增强画面颜值
15 年专注游戏引擎与游戏开发，分享实用方案、经验与干货教程！
03-04 1956
实时反射可以用在非常多的领域用于增强场景氛围，建议必学！
电子政务-内置隔热、反射材料的温差电致冷器件.zip
09-15
在这个领域中，内置隔热、反射材料的温差电致冷器件是重要的一环，它涉及到能源管理、设备散热以及信息技术设备的稳定运行。 温差电致冷（Peltier Effect Cooling），又称热电冷却，是一种利用半导体材料的帕尔帖...
E07_新特性,网编,反射,注解复习.pdf
11-02
反射是Java提供的一种强大的工具，它允许程序在运行时检查类、接口、字段和方法的信息，并能动态地调用方法或访问字段。反射在许多场景下都很有用，如插件系统、序列化、对象的动态创建和方法调用等。 注解...
Python面向对象 #4 反射与内置方法
shiyaopeng11的博客
10-10 103
在上一篇文章中我们讲到了继承知道了继承是一种什么“是”什么的关系。然而类与类之间还有另一种关系，这就是组合。
在Android开发中WebView的详细使用方法
LLZjiayou的博客
10-25 1057
WebView是一个非常强大的工具，用于在应用内加载网页内容。通过使用和其他配置，可以实现丰富的网页交互功能，同时确保应用的安全性和稳定性。如果有特定功能需求，可以在 Android 官方文档中查阅的详细说明。
基于python的《C语言程序设计》课程成绩分析
weixin_51141489的博客
10-22 978
过程数据来源于两个班级（大约60人）《C语言程序设计》课程期间学习过程的真实记录，主要是对平时作业以及测验的收集；问卷数据来源于整个年级选该课程的同学（大约170人）的匿名回答，包括同学对该课程的看法以及学习该课程的一些建议。
代码随想录训练营第二十一天|669. 修剪二叉搜索树、108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树
qq_43487696的博客
10-22 233
【代码】代码随想录训练营第二十一天|669. 修剪二叉搜索树、108.将有序数组转换为二叉搜索树、538.把二叉搜索树转换为累加树。
Python数值计算（28）——理查森外推法
cdinten的专栏
10-22 318
理查森外推法( Richardson extrapolation)是一种提高某些数值过程精度的简单方法，在数值方法中广泛应用。理查森外推法的基本思想是通过对原函数进行多次求导，并在每一步求导的基础上进行线性组合，得到一个新的函数，这个新的函数与原函数的差距会逐渐减小，最终趋于零。理查森外推法的优点是简单易行，适用于各种数值计算。理查森外推法的一般步骤如下：1. 确定原函数的导数。2. 确定原函数的导数的导数。3. 利用导数的导数，构造新的函数。
Pyhon—openpyxl修改某个表头的样式&其余单元格加边框线
最新发布
weixin_42636075的博客
10-27 654
Pyhon—openpyxl修改某个表头的样式&其余单元格加边框线
python 发送邮件：添加文件名为中文的附件
eyeofeagle的博客
10-24 270
附件接收后，如图所示。
MATLAB实现反射阵天线单元相位补偿计算
资源摘要信息:"本文档主要介绍如何使用MATLAB软件来计算反射阵天线单元的...通过这些步骤和文件的组合使用，可以有效地在MATLAB环境下完成反射阵天线单元的相位补偿计算，为反射阵天线的设计和优化提供强有力的支持。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值