Эта статья участвовала в третьем этапе тренировочного лагеря для создателей Nuggets. Подробности см.:Dig Li Project | Идет третий этап тренировочного лагеря создателя, «написание» личного влияния.
📖Предисловие
三毛曾经感慨:
«Что с сердцем? Оно похоже на лабиринт, растянувшийся на тысячи миль. Нет лодочника, который может пересечь людей.—— В потоке жизни, на протяжении всей жизни мы все учимся быть сами себе перевозчиками.
Об установке и локализации можно посмотреть в этой статье блогера"Скачивание, установка и китаизация VsCode"а такжеСерия Python: Windows10 настраивает среду разработки Python3.0!, перезапустите VsCode после установки!
本篇主要介绍类中定义的各种属性,例如类属性、实例属性、类的私有属性,以及各种方法,例如实例方法、类方法、静态方法以及property属性方法等相关知识。
🚀 иди
Эта статья в основном знакомит с магическими свойствами классов в объектно-ориентированном программировании.Эти магические свойства имеют свои специальные функции, то есть при выполнении определенных операций выполнение этих магических методов будет автоматически запускаться.Понимание этих магических методов может помочь вы лучше понимаете объектно-ориентированное программирование Принцип реализации программирования;
Прежде чем изучать магический метод, давайте рассмотрим два других метода:
isinstance()
а такжеissubclass()
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
'''
@File : demoOne.py
@Time : 2019/10/30 08:52:50
@Author : YongJia Chen
@Version : 1.0
@Contact : chen867647213@163.com
@License : (C)Copyright 2018-2019, Liugroup-NLPR-CASIA
@Desc : None
'''
# here put the import lib
class A(object):
pass
class B(A):
pass
b = B()
# isinstance(o,c) -- 判断前者是否为后者所创建的对象
print(isinstance(b,A)) # True
print(isinstance(b,B)) # True
# issubclass --判断前者是否为后者的子类
print(issubclass(B,A)) # True
отражение:hasattr、getattr、setattr、delattr
Четыре встроенные функции
- Рефлексия, также известная как самоанализ (саморефлексия), концепция была впервые предложена Смитом в 1982 году и в основном относится к способности программы получать доступ, обнаруживать и изменять свое собственное состояние или поведение;
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
'''
@File : fansheDemo.py
@Time : 2019/10/30 08:54:08
@Author : YongJia Chen
@Version : 1.0
@Contact : chen867647213@163.com
@License : (C)Copyright 2018-2019, Liugroup-NLPR-CASIA
@Desc : None
'''
# here put the import lib
class Programmer(object):
"""定义一个程序员类"""
character = "intelligent" # 特点:聪明
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
def write_code(self): # 写代码
pass
def debug(self): #调试
pass
p = Programmer("Mr_Chen", 21, "male")
# hasttr - 查看该对象是否可以使用该属性或者方法
print(hasattr(p, "name"))
print(hasattr(p, "debug"))
# getattr - 获取对象属性
print(
getattr(p, "write_code")
) #<bound method Programmer.write_code of <__main__.Programmer object at 0x0000016F87ABBFD0>>
print(getattr(p, "character")) # == p.character
# 可以指定第三个参数,当属性不存在时返回该值,而不会报错
# print(getattr(p,"balabala")) # 报错
print(getattr(p, "balabala", "不存在的"))
# setattr -修改对象属性
setattr(Programmer, "character",
"handsome") # == Programmer.character = "handsome"
print(p.character) # handsome
# delattr - 删除该属性
delattr(p, "name") # == del p.name
print(p.__dict__) #{'age': 21, 'gender': 'male'},name没啦
delattr(Programmer, "debug")
print(Programmer.__dict__) #debug属性没啦
Преимущества отражения: Может быть реализован подключаемый механизм. Например, в процессе разработки реального проекта несколько программистов обычно сотрудничают друг с другом для завершения большого проекта. Если программисту А необходимо использовать программистов в процессе разработки. Определенный класс B, но программист B взял отпуск, чтобы сопровождать свою жену, чтобы родить ребенка, и код не был завершен.В это время программист B может использовать механизм отражения, чтобы продолжить завершение своего собственного кода, например:
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
'''
@File : yuanDemo1.py
@Time : 2019/10/30 08:56:26
@Author : YongJia Chen
@Version : 1.0
@Contact : chen867647213@163.com
@License : (C)Copyright 2018-2019, Liugroup-NLPR-CASIA
@Desc : None
'''
# here put the import lib
# 程序员A --moduleA
class A(object):
def __init__(self, x, y):
self.x = x
self.y = y
# ---------------------------------------------------------
# 程序员B
from moduleA import A
a = A(10, 20)
if hasattr(a, "cal"): # 判断是否有该计算方法,不管有没有不影响我其他逻辑的书写和调试
print(a.cal())
else:
print("该计算方法没有定义")
print("继续执行其他的逻辑")
магический метод
__doc__ 查看类的描述信息
class Foo(object):
"""这是一段关于该类的介绍和描述"""
pass
print(Foo.__doc__) #这是一段关于该类的介绍和描述
__module__ 和 __class__
前者查看当前操作的类所在模块,后者查看当前对象的类是什么;
class Bar(object):
pass
b1 = Bar()
print(Bar.__module__) # __main__ ----》当前文件所在模块
print(Bar.__class__) # <class 'type'>
print(b1.__class__) # <class '__main__.Bar'>
# 注:从上述结果可以看出,类也是对象,该Bar类对象其是由type类实例化得到的,而对象b1是由当前模块的Bar类实例化得到的
__init__ 构造方法
当通过类实例化成对象时,自动触发执行__init__方法。
该方法下定义的属性即为实例属性,即会自动开辟一个内存空间,
用来存放该实例对象的属性和类方法的指针。
class Foo(object):
# 构造方法
def __init__(self,name):
self.name =name
print("in the init")
foo = Foo("sunny chen") # in the init
__del__ 方法
当由该类创建的实例对象,被删除或者说在内存中被释放时,将会自动触发执行。
class Foo(object):
# 析构方法
def __del__(self):
print("in the __del__")
foo = Foo()
del foo # in the __del__
Этот метод вообще не нужно определять, потому что Python — язык высокого уровня, программистам не нужно заботиться о выделении и освобождении памяти при его использовании, потому что эту работу выполняет интерпретатор Python, поэтому деструктор вызывается интерпретатором.Выполнение автоматически запускается сборщиком мусора во время сборки мусора. Конечно, когда я повторно уничтожаю описанный выше метод, память не может быть восстановлена, и многие функции, реализованные внизу, будут инкапсулированы.
5.
__call__ 对象后面加括号,触发执行。
class Bar(object):
pass
bar = Bar()
# bar() # TypeError: 'Bar' object is not callable
# 当一个类中有__call__,其实例化得到的对象便是可调用的即callable
class Foo(object):
def __call__(self):
print("in the call")
foo = Foo()
foo() # in the call
Выполнение конструктора запускается созданием объекта, то есть: object = classname(); в то время как дляcallВыполнение метода запускается добавлением круглых скобок после объекта, а именно: object() или class()()
__dict__ 类或者实例的属性字典
类或这实例的属性字典,用来存放类或者实例的属性和方法;
class Bar(object):
gender = "male"
def __init__(self,name):
self.name = name
def tt(self):
pass
bar = Bar("sunny chen")
print(Bar.__dict__)
# 输出为:{'__module__': '__main__', 'gender': 'male', '__init__': <function Bar.__init__ at 0x0000020F94F10B70>, 'tt': <function Bar.tt at 0x0000020F94F10BF8>, '__dict__':
# <attribute '__dict__' of 'Bar' objects>, '__weakref__': <attribute '__weakref__' of 'Bar' objects>, '__doc__': None}
print(bar.__dict__)
#{'name': 'sunny chen'}
В словаре атрибутов атрибуты объекта класса и соответствующие им значения, методы и соответствующие им указатели методов хранятся в виде пар ключ-значение.
__str__方法
class Bar(object):
def __str__(self):
return "<bar object <Bar> at 000000xxxx>"
# 如果一个类中定义了__str__方法,那么在打印对象 时,默认输出该方法的返回值。
bar = Bar()
print(bar) # <bar object <Bar> at 000000xxxx>
# 其实在其他的对象中也是这样实现,当打印该对象给用户一些提示信息
import threading
def test():
pass
t = threading.Thread(target=test)
print(t) #<Thread(Thread-1, initial)>
Когда пользователь не знает, что такое объект экземпляра, этот метод автоматически выполняет внутренний метод __str__ класса, печатая, чтобы предоставить пользователю определенную подсказку.
__getattr__、__setattr__、__delattr__
Изучая эти три волшебных метода, давайте сначала разберемся с концепцией, называемой отражением, которая достигается с помощью четырех встроенных функций, а именно
hasattr、getattr、setattr、delattr
; На самом деле, когда мы вызываем последние три метода, выполняется магический метод в классе, например:
#---------------- copy---------------
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.__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
__getitem__、__setitem__、delitem__
Использование очень похоже на три вышеприведенных, но метод запуска отличается.Вышеупомянутый магический метод attr запускается точкой «.», в то время как последний магический метод элемента запускается методом словаря «[]»; например:
class Foo:
def __init__(self,name):
self.name=name
def __getitem__(self, item):
print(self.__dict__[item])
def __setitem__(self, key, value):
print("in the setitem.")
self.__dict__[key]=value
def __delitem__(self, key):
print('in the delitem..')
self.__dict__.pop(key)
def __delattr__(self, item):
print('in the delattr..')
self.__dict__.pop(item)
# obj.["key"]的方式触发__xxxitem__魔法方法
f1=Foo("sunny chen")
ret = f1["name"] # 触发__getitem__执行
f1["age"]=18 # 触发__setattr__执行
del f1['age'] # 触发__delitem__执行
f1['name']='sunny'
del f1.name # 触发__delattr__执行
print(f1.__dict__)
- Есть конечноитераторы и генераторы;
快去动手试试吧!
🎉 Наконец-то
-
Дополнительные справочные сообщения в блоге см. здесь:Блог Чен Юнцзя
-
Друзья, которым нравятся блогеры, могут подписаться, поставить лайк и продолжать обновлять, хе-хе!