面向对象的结尾

最新推荐文章于 2024-08-23 16:53:34 发布
最新推荐文章于 2024-08-23 16:53:34 发布
阅读量172 收藏
点赞数
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64178950/article/details/124103164
版权

面向对象的结尾

1 > 反射的实际案例

  编写利用面向对象编写系统终端功能


'''编写不同系统的终端功能'''
class WinCmd(object):
	def ls(self):
        print('windows系统正在执行ls命令')
    def dir(self):
        print('windows系统正在执行dir命令')
    def cd(self):
        print('windows系统正在执行cd命令')
class LinuxCmd(object):
	def ls(self):
        print('windows系统正在执行ls命令')
    def dir(self):
        print('windows系统正在执行dir命令')
    def cd(self):
        print('windows系统正在执行cd命令')
 # 简易版本
	obj = WinCmd()
 	obj1 = LinuxCmd()
 	while True:
 		cmd = input('请输入你想执行的指令 >>>>>:').strip()
 		# 利用反射判断类当中是否有该方法
 		if hasattr(obj, cmd):
 			func_name = getattr(obj, cmd)
 			func_name()
 		else:
 			print('cmd command not found')
 # 函数版本
 	obj = WinCmd()
 	obj1 = LinuxCmd()
 	def run(obj1)
 		while True:
 			cmd = input('请输入你想执行的指令 >>>>>:').strip()
 			# 利用反射判断类当中是否有该方法
 			if hasattr(obj, cmd):
 				func_name = getattr(obj, cmd)
 				func_name()
 			else:
 				print('cmd command not found')
 	run(obj)   # 进入window系统
 	run(obj1)  # 进入Linux系统

2 > 面向对象的双下方法

   面向对象的双下方法被有些人称之为是魔法方法，意思就是有些双下方法不需要刻意调用达到某个条件会自动触发，例如__init__ 就是在对象实例化的时候自动触发。

2.1 > str

   该方法是当对象被执行打印(print 、前端展示)操作的时候自动触发，该方法必须返回字符串类型的数据，很多时候可以用来更加精准的描述对象，操作如下：

class MyClass(object):
	def __init__(self, name):
		self.name = name
	del __str__(self)
		return 'MyClass产生的对象%s'%self.name
obj = MyClass('bob')
print(obj)
# 打印 MyClass产生的对象:bob

2.2 > del

   该方法当对象被执行(被动，主动)删除之后自动触发操作


class MyClass(object):
	def __init__(self, name):
		self.name = name
	def __del__(self)
		return '正在执行del方法'

obj = MyClass('bob')
print('打印功能执行中')     # 当程序运行结束obj会被动删除
# 打印 
'''
 打印功能执行中
 正在执行del方法
 
'''

print(obj)    # 主动删除操作
def obj
'''
正在执行del方法
打印功能执行中
'''

2.3 > getattr

  该方法当对象查找时当对象不存在名字的时候自动触发。


class MyClass(object):
	def __init__(self, name):
		self.name = name
	del __getattr__(self, item)
		return 'MyClass类中没有%s 这个名字'%item

obj = MyClass('bob')
print(obj.name)  # bob
print(obj.age)   # MyClass类中没有age 这个名字

2.4 > setattr

  对象在执行添加属性操作的时候自动触发 例如 obj.变量名 = 变量值


class MyClass(object):
	def __init__(self, name):
		self.name = name
	def __setattr__(slef, key, value):
		print(key, value)
		# 加入限制
		if key ==  'age':
			print('你不能拥有%s属性'% key)
		super().__setattr__(key, value)

obj = MyClass('bob')
obj.age = 18
print(obj__dict__)
# 打印 
'''
name bob
你不能拥有age属性
{'name': 'bob'}
'''

2.5 > call

  对象被加括号调用的时候自动触发


class MyClass(object):
	def __init__(self, name):
		self.name = name
	def __call__(self, *args, **Kwargs):
		print('__call__方法', *args, **kwargs)
		return '开始执行call方法'
obj = MyClass('bob')
obj(123)
print(obj(123))

'''
__call__方法 (123, ) {}
开始执行call方法	

'''

2.6 > enter

  对象被执行with上下文管理语法开始自动触发，一般与__exit__ 一起使用。该方法返回什么as后面的变量名就会得到什么


class MyClass(object):
	def __init__(self, name):
		self.name = name
	def __enter__(self):
		print('__enter__方法')
	def __exit__(self, exc_type, exc_val, exc_tb):
		print('__exit__ 方法')
obj = MyClass('bob')
with obj as f:
	print(111)
print(222)

# 打印
'''
__enter__方法
111
__eixt__方法
222

'''

2.7 > exit

  对象被执行with上下文管理语法结束之后自动触发


class MyClass(object):
	def __init__(self, name):
		self.name = name
	def __enter__(self):
		print('__enter__方法')
	def __exit__(self, exc_type, exc_val, exc_tb):
		print('__exit__ 方法')
obj = MyClass('bob')
with obj as f:
	print(111)
print(222)

# 打印
'''
__enter__方法
111
__eixt__方法
222

'''

2.8 > getattribute

  只要对象查找名字无论名字是否存在都会执行该方法
  如果类中有__getattribute__方法 那么就不会去执行__getattr__方法


class MyClass(object):
	def __init__(self, name):
		self.name = name
	def __getattr__(self, item):
		print('__getattr__方法')
	def __getattribute__(self, item):
		print('__getattribute__方法')

obj = MyClass('bob')

print(obj.name)
print(obj.age)

'''
__getattribute__方法
None
__getattribute__方法
None
'''

3 > 笔试题

3.1 > 字典具备句点符相应功能

  让字典具备句点符查找名字的功能和用句点符添加键值对功能。


class MyDict(dict):
	def __getattr__(self, item):
		return self.item
	def __setattr__(self, key, value)
		self[key] = value

obj = MyDict({'name': 'bob', 'age':18})
print(obj.name)
print(obj.age)
obj.pwd = 123
print(obj.pwd)

# 打印
'''
bob
18
123

'''

3.2 > 补全语法

  补全下列代码语法，使其不报错。


class Context:
	pass

with Context() as ctx:
	ctx.do_something



class Context:
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        pass

    def do_something(self):
        pass

with Context() as ctx:
    print(ctx)
    ctx.do_something()

4 > 元类

4.1 > 间接

  元类即产生类的类

'''前面我们学过可以用type查看数据的数据类型'''
print(type(123))
print(type([11, 22, 33, 44]))
print(type({'name': 'bob', 'pwd': 123})

'''
<class 'int'>
<class 'list'>
<class 'dict'>
'''

'''其实我们查看到的是当前对象所属的类的名称'''
class MyClass(object):
    pass
obj = MyClass()
print(type(obj))
'''
<class '__main__.MyClass'>
'''
print(type(obj))
'''
<class 'type'>
'''

'''所以type就是所有类默认的元类'''

4.2 > 产生类的两种表现形式(本质是一种)

4.2.1 > class关键字


class C1(object):
	pass
print(C1)  # <class '__main__.C1'>

4.2.2 > type元类


type(类名,父类,类的名称空间)
  	res = type('C1', (), {})
		print(res)

4.3 > 元类的基本使用

  使用元类控制类的一些具体的行为，例如使类名的首字母必须是大写:


class MyTypeClass(type):
    def __init__(cls, cls_name, cls_bases, cls_dict):
    '''现在就限制了类名首字母必须是大写'''
        if not cls_name.istitle():
            raise Exception('类名的首字母必须是大写')
        super().__init__(cls_name, cls_bases, cls_dict)
class C1(metaclass=MyTypeClass):
	school = '清华大学'
''' 创建一个为a的类 '''
class a(metaclass = MyTypeClass):
	pass
'''这时候执行程序就会报错'''

'''
Traceback (most recent call last):
  File "D:/Py Projiect/Day_4.11/元类.py", line 22, in <module>
    class a(metaclass=MyTypeClass):
  File "D:/Py Projiect/Day_4.11/元类.py", line 17, in __init__
    raise Exception('类名的首字母必须是大写')
Exception: 类名的首字母必须是大写

'''

4.4 > 元类进阶操作

   一个对象的产生不仅仅是通过类当中的__init__ 方法 而是先通过元类当中的__call__ 方法再进入类当中的__init__ 方法产生一个对象。


class MyTypeClass(type):
	def __call__(self, *args, **kwargs):
	print('__call__run')
	super().__call__(*args, **kwargs)
	
class MyClass(metaclass=MyTypeClass):
	def __init__(self, name):
		print('__init__ run')
		self.name = name
		
obj = MyClass('bob')

   元类当中的__call__ 方法当中的 args, 与Kwargs,分别是用来接收位置参数和关键字参数的，那么我们想要高度定制这个对象的产生过程，让在实例化产生对象的时候只能通过关键字来传入数据。那么我们就可以通过重新 call 方法。操作如下：


class MyTypeClass(type):
	def __call__(self, *args, **kwargs):
	if args:
		raise Exception('必须全部采用关键字参数')
		return super().__call__(*args, **kwargs)
	
class MyClass(metaclass=MyTypeClass):
	def __init__(self, name):
		self.name = name
		
obj = MyClass('bob')
'''
Traceback (most recent call last):
  File "D:/Py Projiect/Day_4.11/元类进阶.py", line 11, in <module>
    obj = MyClass('bob')
  File "D:/Py Projiect/Day_4.11/元类进阶.py", line 4, in __call__
    raise Exception('必须是关键字参数')
Exception: 必须是关键字参数
'''
obj = MyClass(name = 'bob')
print(obj.name)
'''
bob
'''

   以上我们可以得出一个总结就是：
   如果我们想高度定制类的产生过程：就要编写元类当中的__init__方法
   如果我们想高度定制对象的产生过程：就要编写元类中的__call__方法

5 > 双下new方法

   _ new _ 方法用于产生一个空对象，然后由_ init _ 来进行一个实例化。


注意:并不是所有的地方都可以直接调用__new__ 该方法过于底层
	如果是在元类的__new__里面 可以直接调用
		class Meta(type):
      def __new__(cls, *args, **kwargs):
          obj = type.__new__(cls,*args,**kwargs)
          return obj
	如果是在元类的__call__里面 需要间接调用
		class Mate(type):
    	def __call__(self, *args, **kwargs):
         obj = object.__new__(self) # 创建一个空对象
         self.__init__(obj,*args,**kwargs) # 让对象去初始化
         return obj
乔治我的M4呢？
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python面向对象
herosunly的博客
10-11 1万+
1. 关于类与对象操作的BIFs 1.1 打印对象的所有属性 2. 面向对象OOP 2.1 类的创建与内部结构 2.2 类的继承与多态 2.3 OOP三大特性总结 3. 模块与包
python面向对象编程
qq_45691413的博客
08-14 1734
小白如何成为python数据分析师 第 十五 天---->面向对象编程 你有对象吗？下次遇到有人这样问，你就可以直接回答他，谁都有对象，因为一切皆为对象。 我们之前的编程都是指令式编程，即输入指令一条一条的执行，程序简单时没有任何问题，但是随着问题复杂性的增加，指令式编程将会明显不能更好的支持我们解决问题。为了能更好的解决复杂的问题，我们用到了面向对象编程。 “程序是指令的集合”，运行程序时，程序中的语句会变成一条或多条指令，然后由CPU（中央处理器）去执行。为了简化程序的设计，我们用到了函数，把相对
面向对象基本概念
热门推荐
Superme
02-06 18万+
面向对象就是：把数据及对数据的操作方法放在一起，作为一个相互依存的整体——对象。对同类对象抽象出其共性，形成类。类中的大多数数据，只能用本类的方法进行处理。类通过一个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。对象即为人对各种具体物体抽象后的一个概念，人们每天都要接触各种各样的对象，如手机就是一个对象。 面向对象编程（OOP：object-orie...
面向对象面试题
chaizongyuan的博客
01-09 1万+
1) 面向对象的优点？ 答案 Icon 易扩展 易维护,面向对象三大特征(封装,继承,多态....) 2) 如何声名一个静态块？静态块有什么好处 答案 Icon 在类中方法外声明 static关键字+代码块, 对于一些必须要初始化的代码,必须是写在静态块里面,如果写在构造器里面,有多个构造器的时候不一定执行初始化. 3) 接口与
C++面向对象
qq_45806136的博客
02-13 3968
*从存储空间的角度考虑：**构造函数是在实例化对象的时候进行调用，如果此时将构造函数定义成虚函数，需要通过访问该对象所在的内存空间才能进行虚函数的调用（因为需要通过指向虚函数表的指针调用虚函数表，虽然虚函数表在编译时就有了，但是没有虚函数的指针，虚函数的指针只有在创建了对象才有），但是此时该对象还未创建，便无法进行虚函数的调用。所以构造函数不能定义成虚函数。**从使用的角度考虑：**虚函数是基类的指针指向派生类的对象时，通过该指针实现对派生类的虚函数的调用，构造函数是在创建对象时自动调用的。
python面向对象实验报告_Python 面向对象 | 菜鸟教程
weixin_33966205的博客
01-13 2727
Python 面向对象Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一些基本特征，在头脑里头形成一个基本的面向对象的概念，这样有助于你更容易的学习Python的面向对象编程。接下来我们先来简单的了解下面向对象的一些基...
python面向对象
pywin
01-18 5592
Python 面向对象Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一些基本特征，在头脑里头形成一个基本的面向对象的概念，这样有助于你更容易的学习Python的面向对象编程。接下来我们先来简单的了解下面向对象的一些基
java面向对象程序设计 论文_基于JAVA面向对象程序设计
weixin_28687251的博客
02-13 1414
内容介绍原文档由会员 xiaowei 发布基于JAVA面向对象程序设计------------科学养兔项目分析2.3万字 31页摘要 本文报道了对面向对象程序设计思想的基本阐述，就科学养兔项目的开发以及开发过程中所遇到的关于JAVA面向对象程序设计的问题作出详细的报道。一个系统作为一个对象来进行分析，由多个部分组成，作好系统分析工作再进一步确定各个对象的功能以及各个对象之间的关系，利用...
面向对象编程之接口
顺其自然~专栏
11-07 1984
一、什么叫接口 接口表示一种能力，即能干什么，具体怎么干由实现类决定。接口表示一种约定，即一种规范，对实现类的一种规范，至少要实现某些功能，同时命名要符合规范。 个人认为接口是一种规范，实现接口即实现规范，接口适合复杂程序。从理解上而言，接口应该是一种连通器。它实现将用户需要的一些东西传送到用户想要存放的地方，并且在执行上是相对简单的。比如：电脑上的USB接口，可以让...
Java面向对象总结
Zzh1110的博客
11-10 2220
Java面向对象总结 1.封装 （1）作用:属性封装(private)，即包装，不给外部看见。 （2）被封装的属性必须用setter 和getter方法来设置和取得内容。 （3）可以用setter设置属性,限制。(比如setAge，年龄限制在多少) 2.继承 （1）作用:解决代码重复(重用)的问题。 （2）格式:class 子类 extends 父类{} 扩充一个类已有的功能，比如子类扩充了父类所...
面向对象二
12-20
面向对象编程是编程的一种核心概念，它以对象作为程序的基本单元，强调数据和操作数据的方法。在Python中，面向对象编程包含三个主要特征：封装、继承和多态。本篇我们将重点讨论“面向对象二”中的类的特殊方法...
Python基础-面向对象OOP
12-21
面向对象编程（Object-Oriented Programming，简称OOP）是Python中重要的编程范式之一，它基于类（Class）和对象（Object）的概念，强调数据和功能的封装，以及代码的重用性。 在OOP中，类是抽象的模板，它定义了一...
Python 面向对象编程
05-02
Python的面向对象编程是其强大的特性之一，它允许开发者通过创建和使用类来构建复杂的软件结构。面向对象编程（OOP）的核心理念是封装、继承和多态，这些概念在Python中得到了很好的实现。 1. **类的定义** 在...
Python面向对象特殊成员
09-21
Python的面向对象编程中，特殊成员（也称为魔术方法）是具有特定名称的函数，它们在特定场景下被自动调用，提供了对类和对象行为的底层控制。这些方法通常是双下划线开头和结尾（如`__init__`、`__call__`等），它们...
Python-面向对象(二)
12-20
面向对象编程是Python的核心特性之一，它通过模拟现实世界中的对象和行为来组织代码，使得程序更加模块化、可维护。本节主要讨论了两个面向对象的重要概念：特殊方法（魔术方法）和封装。 首先，特殊方法（魔术方法...
如何在Python中使用IP代理
最新发布
IPIPGO的博客
08-23 362
通过以上步骤，你应该已经学会了如何在Python中使用IP代理。无论是单个代理IP、带认证的代理IP，还是批量使用代理IP，这些方法都能帮助你在实际项目中灵活应用。希望这篇文章对你有所帮助，如果你有任何问题或建议，欢迎在评论区留言，我们会尽力为你解答。t=N7T8。
常见面试问题(Python)
jiao_mrswang的博客
08-23 160
5、GIL全局解释锁。
Android笔试面试题AI答之Kotlin（20）
学无止境，止于至善
08-21 736
Elvis操作符（?:）是Kotlin（以及一些其他编程语言）中用于处理可空表达式的一种简洁方式。它允许在表达式的值为null时提供一个默认值，从而简化了空值的处理。在Kotlin中，构造函数（Constructor）是类的一个特殊方法，它用于初始化新创建的对象。与Java不同，Kotlin中的构造函数不是通过名称来定义的，而是与类名相同，并且没有返回类型（即使是void）。Kotlin支持主构造函数和次构造函数（也称为辅助构造函数或二级构造函数）。
零基础学习人工智能—Python—Pytorch学习（六）
kiba518的博客
08-21 875
前言 本文主要讲神经网络的上半部分。 这篇文章开始有很多公式了，这些公式都很简单，但是如果是不经常在脑海里思考公式的人，那可能需要多花点时间做一下自我训练，个人感觉，也就几天时间，就能把自己感觉给调整出来。 习惯了公式看下面内容就会轻松很多，另外如果要深入学习人工智能，熟练的认知公式也是个必须的事情。 另外，我发现我前面文章写的有歧义的地方还是挺多，虽然，已经改了一部分，但，可能还有没发现的，大...
面向对象技术：抽象类与密封类解析
"本文主要介绍了抽象类与密封类在面向对象技术中的概念和应用，以及面向对象技术的发展历史和基本内涵。" 在面向对象编程中，抽象类是一种用于定义派生类基础形态的关键工具。抽象类允许开发者声明方法，但不提供...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值