Python內置函數delattr的具體用法

更新時間：2017年11月23日 11:33:41 作者：LZ_Luzhuo

本篇文章主要介紹了Python內置函數delattr的具體用法，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧

delattr 函數用于刪除屬性。

delattr(x, 'foobar') 相等于 del x.foobar。

語法

setattr 語法：delattr(object, name)

參數

object -- 對象。
name -- 必須是對象的屬性。

英文文檔：

delattr(object, name)　

This is a relative of setattr(). The arguments are an object and a string. The string must be the name of one of the object's attributes. The function deletes the named attribute, provided the object allows it. For example, delattr(x, 'foobar') is equivalent to del x.foobar.說明：　

定義類

#coding=utf-8
# class_my.py 定義類 (新式類)

# 定義類
class Person:
  # 類屬性 (class) (注:類/類方法 能修改類屬性; 對象不能修改類屬性,更改的只是實例屬性)
  name = "name" # 公共屬性
  __adress = "adress" # 私有屬性 (__屬性 表示私有)

  # 構造方法(對象創(chuàng)建調用) (__init__ 表示構造)
  def __init__(self, name, address = "地球"):
    # 實例屬性
    self.name = name # (注:類屬性與實例屬性名稱相同時用實例屬性,實例屬性被刪除后使用類屬性)
    self.__adress = address
    Person.setData(self)

  # 析構方法(對象銷毀調用) (__del__ 表示析構)
  def __del__(self):
    print("對象被銷毀.")

  # toString()
  def __str__(self):
    return "Person.class"

  # 實例方法 (this)
  def setName(self, name): # self可為其他字符串 (this)
    self.name = name; # 修改 實例屬性 (不存在自動添加)

  # 類方法 (static)
  @classmethod
  def setName_cls(cls, name):
    cls.name = name # 修改 類屬性

  # 靜態(tài)方法 (tools)
  @staticmethod
  def setName_sta(name): # (注:參數部分)
    return name

  def getName(self):
    return self.name

  def setData(self):
    # 實例屬性
    self.__age = 21 # 私有屬性
    self.sex = "女" # 公共屬性

  def show(self):
    print("Hello! %s"%self.name)
    print("Address:%s"%self.__adress) # 使用自身私有屬性
    self.__eat() # 使用自身私有方法

  def __eat(self): # 私有方法
    print("eat")



# ======= 函數調用 ======
if __name__ == "__main__":
  # - 創(chuàng)建對象 -
  ps = Person("LY")

  # --- 調用方法 ---
  # 調用實例方法
  ps.setName("LY") # 實例調用 實例方法
  ps.show()

  # 調用類方法
  Person.setName_cls("Person") # 類調用 類方法
  ps.setName_cls("Person") # 實例調用 類方法

  # 調用靜態(tài)方法 ()
  print(ps.setName_sta("Per")) # 實例調用 靜態(tài)方法
  print(Person.setName_sta("Per")) # 類調用 靜態(tài)方法

  # --- 訪問屬性 ---
  print(ps.getName())
  print(ps.name) # 訪問 類屬性 的公共屬性值
  print(ps.sex) # 訪問 實例屬性 的公共屬性值

  # --- 修改屬性 ---

  # 修改實例屬性
  ps.name = "123" # 修改 類屬性 (注:并非真修改,只是向對象中創(chuàng)建了一個實例屬性)
  del ps.name # 刪除 實例屬性 (注:實例不能(非類方法)刪除 類屬性, 只是刪除了對象中創(chuàng)建的實例屬性,類屬性依然存在)
  del ps.sex # 刪除 實例屬性 (注:真刪除,刪除后不能訪問)

  # 修改類屬性
  Person.name = "Person" # 修改類屬性
  Person.setName_cls("Person") # 類 調用 類方法 修改 類屬性 (注:類不能調用實例方法)
  ps.setName_cls("Person") # 對象 通過 類方法 修改 類屬性
  del Person.name # 刪除類屬性

  # - 刪除對象 -
  del ps
  # > Less is more! "靜態(tài)方法"和"類方法/屬性"同級都可理解為"靜態(tài)",靜態(tài)方法適合做工具箱,類方法/屬性可認為在靜態(tài)區(qū),隨手拿來即用,而實例則需要實例化才能使用. (--本人的個人理解)
# ======= 函數調用 ======

繼承

#coding=utf-8
# class_extend.py 繼承(新式類)

# --- 單繼承 ---
# 父類
class Animal(object):

  def __init__(self, name = "動物"):
    self.name = name

  def run(self):
    print("%s在跑."%self.name)

# 子類
class Cat(Animal): # 繼承 (父類寫()內)

  def __init__(self, name, ot = ""):
    super(Cat, self).__init__(name)

  def miao(self):
    print("喵")



# --- 多繼承 ---
class Donkey: # 驢
  def walk(self):
    print("walk")

  def eat(self):
    print("Donkey.eat")

class Horse: # 馬
  def run(self):
    print("run")

  def eat(self):
    print("Horse.eat")

class Mule(Donkey, Horse): # 騾(驢+馬)
  pass



# === 多態(tài) ====
def animalRun(animal): # 參數接收自己及其自己的子類
  animal.run()




# ======= 函數調用 ======
if __name__ == "__main__":
  # - 單繼承調用 -
  ani = Animal()
  ani.run()

  cat = Cat("貓")
  cat.run()
  cat.miao()


  # - 多繼承調用 -
  mule = Mule()
  mule.walk()
  mule.run()
  mule.eat() # 多個父類中有相同的方法時,調用()內最前面的父類(Donkey)的方法


  # - 多態(tài)調用 -
  ani = Animal()
  animalRun(ani)

  cat = Cat("貓")
  animalRun(cat)
# ======= 函數調用 ======

重寫

#coding=utf-8
# class_rewrite.py 重寫(新式類)

class Animal(object):

  def run(self):
    print("Animal.run")

  def eat(self, food = "食物"):
    print("eat:%s"%food)


class Cat(Animal):

  # 子類重寫了父類的方法
  def run(self):
    print("Cat.run")

  def eat(self):
    # 調用父類的方法
    super(Cat, self).eat("貓糧")



# ======= 函數調用 ======
if __name__ == "__main__":
  ani = Animal()
  ani.run()
  ani.eat()
  cat = Cat()
  cat.run()
  cat.eat()
# ======= 函數調用 ======

屬性方法

#!/usr/bin/env python
# coding=utf-8
__author__ = 'Luzhuo'
__date__ = '2017/5/13'
# class_propertiemethod.py 屬性方法
# 屬性方法: 把方法變成靜態(tài)屬性


# 寫法1
class PM_1(object):
  def __init__(self):
    self.__name_str = "PropertieMethod_1"

  # 獲取
  @property
  def name(self): # 注意,方法名相同
    return self.__name_str

  # 設置
  @name.setter
  def name(self, name):
    self.__name_str = name

  # 刪除
  @name.deleter
  def name(self):
    del self.__name_str


if __name__ == "__main__":
  pm = PM_1()
  print(pm.name)
  pm.name = "PM"
  print(pm.name)
  del pm.name
  # print(pm.name)

# ==========================================================


# 寫法2
class PM_2(object):
  def __init__(self):
    self.__name_str = "PropertieMethod_2"

  # 獲取
  def getname(self):
    return self.__name_str

  # 設置
  def setname(self, name):
    self.__name_str = name

  # 刪除
  def delname(self):
    del self.__name_str

  # property(fget=None, fset=None, fdel=None, doc=None) # 返回一個property 屬性, 實現(xiàn)原理見 內置函數 文章 property_my 塊代碼(http://blog.csdn.net/rozol/article/details/70603230)
  name = property(getname, setname, delname)


if __name__ == "__main__":
  p = PM_2()
  print(p.name)
  p.name = "PM2"
  print(p.name)
  del p.name
  # print(p.name)

反射

#!/usr/bin/env python
# coding=utf-8
__author__ = 'Luzhuo'
__date__ = '2017/5/13'
# class_reflection.py 反射
# 通過反射機制,可動態(tài)修改程序運行時的狀態(tài)/屬性/方法
# Python的反射機制性能如何? 在Android中Java的反射產生垃圾而執(zhí)行gc,從而導致UI不流暢,而且性能低
# Python的反射性能(1億次測試): 直接獲取屬性值:反射獲取屬性值 = 1:1.164 ;直接設置屬性值:反射設置屬性值 = 1:1.754

def setname(self, name):
  self.name = name

class Clazz(object):
  def __init__(self):
    self.name = "Clazz"

  def getname(self):
    return self.name



if __name__ == "__main__":
  c = Clazz()

  # --- 方法 ---
  if hasattr(c, "getname"):
    # 獲取
    method = getattr(c, "getname", None)
    if method:
      print("setname_ref: {}".format(method())) # 獲取方法對象并執(zhí)行

  if not hasattr(c, "setname"):
    # 添加
    setattr(c, "setname", setname) # 添加方法
    method = getattr(c, "setname", None)
    if method:
      method(c, "Reflection")
    print("setname_raw: {}".format(c.getname()))

  if hasattr(c, "setname"):
    # 刪除
    delattr(c, "setname")
    # c.setname(c, "Demo")


  # --- 屬性 ---
  if not hasattr(c, "age"):
    # 添加
    setattr(c, "age", 21) # 添加方法
    var = getattr(c, "age", None)
    print("age_ref: {}".format(var))
    print("age_raw: {}".format(c.age))

  if hasattr(c, "age"):
    # 獲取
    var = getattr(c, "age", None)
    print("age_ref: {}".format(var))

  if hasattr(c, "age"):
    # 刪除
    delattr(c, "age")
    # print("age_raw: {}".format(c.age))

文檔注釋

#!/usr/bin/env python
# coding=utf-8
__author__ = 'Luzhuo'
__date__ = '2017/5/13'
# class_doc.py 文檔注釋
# 文檔注釋的編寫

class Foo(object):
  '''
  這是一個類
  '''

  def method(self, data):
    '''
    這是一個方法
    :param data: 需要的數據
    :return: 返回的數據
    '''
    return "method"


def func(data):
  '''
  這是一個函數
  :param data: 需要的數據
  :return: 返回的數據
  '''
  return "func"



if __name__ == "__main__":
  # 打印文檔
  print(Foo.__doc__)
  print(Foo().method.__doc__)

  print(func.__doc__)

創(chuàng)建類的原理

#!/usr/bin/env python
# coding=utf-8
__author__ = 'Luzhuo'
__date__ = '2017/5/13'
# class_origin.py 類的由來
# 類由type類實例化產生, 而type由解釋器產生

age = 21

def __init__(self):
  self.name = "origin"

def getname(self):
  return self.name

def setname(self, name):
  self.name = name

def delname(self):
  del self.name


if __name__ == "__main__":
  # 用type創(chuàng)建類(類名, 基類元組, 類成員字典)
  Foo = type('Foo', (object,), {'__init__' : __init__, "getname" : getname, "setname" : setname,
                 "delname": delname, "age" : age})
  # 實例化類
  f = Foo()
  # 使用
  print(f.age)
  print(f.getname())
  f.setname("ClassOrigin")
  print(f.getname())
  f.delname()
  # print(f.getname())

# ==================================================================================





# 元類 (type創(chuàng)建類原理)
# 元類是用于創(chuàng)建所有類的類, Python中是type類 (注意,類也是對象,也是被創(chuàng)建出來的,即萬物皆對象), 下面將演示type類的功能

# __call__ 的調用 (__new__在__init__之前調用, __call__在什么時候調用呢)
class Foobar(object):
  def __call__(self, *args, **kwargs):
    print("Foobar __call__")

if __name__ == "__main__":
  fb = Foobar()
  fb() # 只有在這個時候才會調用__call__屬性

  Foobar()() # 等同于該方式

# ------


# metaclass指定類有誰來創(chuàng)建
# Python創(chuàng)建類時會尋找__metaclass__屬性,(包括父類)沒有找到將使用內建元類type
class MyType(type):
  def __init__(self, *args, **kwargs):
    print("MyType __init__")

  def __call__(self, *args, **kwargs):
    print("MyType __call__")
    obj = self.__new__(self)
    self.__init__(obj, *args, **kwargs)
    return obj

  def __new__(cls, *args, **kwargs):
    print("MyType __new__")
    return type.__new__(cls, *args, **kwargs)


class Foo(object, metaclass=MyType): # (Python3.x寫法) metaclass 用于創(chuàng)建類, Python創(chuàng)建類時會尋找__metaclass__屬性,(包括父類)沒有找到將使用內建元類type

  # __metaclass__ = MyType # Python2.x寫法

  def __init__(self):
    print("Foo __init__")

  def __new__(cls, *args, **kwargs): # 用于實例化對象
    print("Foo __new__")
    return object.__new__(cls) # 必須是返回

  def show(self):
    print("Foo show")


if __name__ == "__main__":
  print("start")
  f = Foo()
  f.show()
  # MyType __new__ => MyType __init__ => 'start' => MyType __call__ => Foo __new__ => Foo __init__ => 'Foo show'

其他的一些補充

#!/usr/bin/env python
# coding=utf-8
__author__ = 'Luzhuo'
__date__ = '2017/5/13'
# class_other.py 關于類的一些補充


class Demo(object):
  def show(self):
    print("Demo show")

if __name__ == "__main__":
  # __module__ 該對象的模塊名
  # __class__ 該對象的類對象
  print(Demo.__module__) # 該對象的模塊名 => __main__
  print(Demo.__class__) # 該對象的類對象 => <class 'type'>

  obj = Demo()
  print(obj.__module__) # 該對象的模塊名 => __main__
  print(obj.__class__) # 該對象的類對象 => <class '__main__.Demo'>
  obj.__class__.show(obj) # 類對象可被使用

  # ============================

  # __dict__ 類或對象中的所有成員
  print(Demo.__dict__) # 類屬性
  print(obj.__dict__) # 實例屬性

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持腳本之家。

您可能感興趣的文章:

python的json包位置及用法總結
在本篇內容里小編給大家分享了關于python的json包用法詳解內容，需要的朋友們跟著學習下吧。
2020-06-06
python中的路徑拼接問題
這篇文章主要介紹了python中的路徑拼接問題，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教
2023-03-03
詳解Python2.x中對Unicode編碼的使用
這篇文章主要介紹了詳解Python2.x中對Unicode編碼的使用,Python3中Unicode被作為默認的編碼來使用,而在目前仍被廣泛應用的Python2的版本中Unicode卻是一個在使用中需要注意的地方,需要的朋友可以參考下
2015-04-04
Python實例方法、類方法、靜態(tài)方法區(qū)別詳解
這篇文章主要介紹了Python實例方法、類方法、靜態(tài)方法區(qū)別詳解,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下
2020-09-09
詳解Python 多線程 Timer定時器/延遲執(zhí)行、Event事件
這篇文章主要介紹了Python 多線程 Timer定時器/延遲執(zhí)行、Event事件的相關知識，本文給大家介紹的非常詳細，具有一定的參考借鑒價值,需要的朋友可以參考下
2019-06-06
Python按條件刪除Excel表格數據的方法(示例詳解)
本文介紹基于Python語言,讀取Excel表格文件,基于我們給定的規(guī)則,對其中的數據加以篩選,將不在指定數據范圍內的數據剔除,保留符合我們需要的數據的方法,感興趣的朋友跟隨小編一起看看吧
2024-08-08
python批量修改圖片后綴的方法(png到jpg)
今天小編就為大家分享一篇python批量修改圖片后綴(png到jpg)，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧
2018-10-10
Python小知識之幾種推導式用法示例
Python推導式是一種獨特的數據處理方式,可以從一個數據序列構建另一個新的數據序列的結構體,下面這篇文章主要給大家介紹了關于Python小知識之幾種推導式用法的相關資料,需要的朋友可以參考下
2023-01-01
pytorch 把MNIST數據集轉換成圖片和txt的方法
這篇文章主要介紹了pytorch 把MNIST數據集轉換成圖片和txt的方法，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧
2018-05-05
python中字符串的操作方法大全
這篇文章主要給大家介紹了關于python中字符串操作方法的相關資料，文中通過示例代碼詳細介紹了關于python中字符串的大小寫轉換、isXXX判斷、填充、子串搜索、替換、分割、join以及修剪：strip、lstrip和rstrip的相關內容，需要的朋友可以參考下
2018-06-06

欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

Python內置函數delattr的具體用法

相關文章

最新評論

大家感興趣的內容

最近更新的內容

常用在線小工具