Python面向对象特殊成员

类的特殊成员之call

  1. #!/usr/bin/env python
  2. # _*_coding:utf-8 _*_
  3. class SpecialMembers:
  4.    # 类的构造方法
  5.    def __init__(self):
  6.        print("My Blog is Url: http://yw666.blog.51cto.com")
  7.    # 对象的构造方法
  8.    def __call__(self):
  9.        print("My Name is: Yangwen")
  10. # 创建一个对象,并且执行类的构造方法
  11. obj = SpecialMembers()
  12. # 执行对象的构造方法
  13. obj()
  14. # 先执行类的构造方法,然后在执行对象的构造方法
  15. SpecialMembers()()

输出

  1. [email protected]:~$ python3 /home/yangwen/文档/Python_code/sublime/Week06/Day04/s2.py
  2. My Blog is Url: http://yw666.blog.51cto.com
  3. My Name is: Yangwen
  4. My Blog is Url: http://yw666.blog.51cto.com
  5. My Name is: Yangwen

类的特殊成员之getitem、setitem、delitem

  1. #!/usr/bin/env python
  2. # _*_coding:utf-8 _*_
  3. class SpecialMembers:
  4.    # 当执行obj[‘value‘]的时候就会自动执行__getitem__方法,并且把对象括号内的值当做__getitem__的值
  5.    def __getitem__(self, item):
  6.        print(item)
  7.    def __setitem__(self, key, value):
  8.        print(key, value)
  9.    def __delitem__(self, key):
  10.        print(key)
  11. # 创建一个对象
  12. obj = SpecialMembers()
  13. # 自动执行__getitem__方法
  14. obj[‘value‘]
  15. # 自动执行__setitem__方法
  16. obj[‘k1‘] = "values"
  17. # 自动执行__delitem__方法
  18. del obj[‘key‘]

输出

  1. [email protected]:~$ python3 /home/yangwen/文档/Python_code/sublime/Week06/Day04/s2.py
  2. value
  3. k1 values
  4. key

特殊的

  1. #!/usr/bin/env python
  2. # _*_coding:utf-8 _*_
  3. class SpecialMembers:
  4.    # 当执行obj[‘value‘]的时候就会自动执行__getitem__方法,并且把对象括号内的值当做__getitem__的值
  5.    def __getitem__(self, item):
  6.        print(item, type(item), "__getitem__")
  7.    def __setitem__(self, key, value):
  8.        print(key, value)
  9.    def __delitem__(self, key):
  10.        print(key)
  11. # 创建一个对象
  12. obj = SpecialMembers()
  13. # 自动执行__getitem__方法
  14. obj[1:3]  # __getslice__/__getitem__
  15. # 自动执行__setitem__方法
  16. obj[1:3] = [11, 22, 33]  # __setslice__/__setitem__
  17. # 自动执行__delitem__
  18. del obj[1:3]  # __delslice__/__delitem__

输出

  1. [email protected]:~$ python3 /home/yangwen/文档/Python_code/sublime/Week06/Day04/s2.py
  2. slice(1, 3, None) <class ‘slice‘> __getitem__
  3. slice(1, 3, None) [11, 22, 33]
  4. slice(1, 3, None)

类的特殊成员之dict

获取类或对象中的所有成员

  1. #!/usr/bin/env python
  2. # _*_coding:utf-8 _*_
  3. class SpecialMembers:
  4.    """
  5.    类的注释
  6.    """
  7.    def __init__(self):
  8.        self.Name = "Ansheng"
  9.        self.Blog = "http://yw666.blog.51cto.com"
  10. # 获取类中的成员
  11. print(SpecialMembers.__dict__)
  12. # 创建一个对象
  13. obj = SpecialMembers()
  14. # 获取对象中的成员
  15. print(obj.__dict__)

输出

  1. [email protected]:~$ python3 /home/yangwen/文档/Python_code/sublime/Week06/Day04/s2.py
  2. {‘__weakref__‘: <attribute ‘__weakref__‘ of ‘SpecialMembers‘ objects>, ‘__doc__‘: ‘\n    类的注释\n    ‘, ‘__module__‘: ‘__main__‘, ‘__dict__‘: <attribute ‘__dict__‘ of ‘SpecialMembers‘ objects>, ‘__init__‘: <function SpecialMembers.__init__ at 0x7ff2af2d7598>}
  3. {‘Blog‘: ‘http://yw666.blog.51cto.com‘, ‘Name‘: ‘Yangwen‘}

类的特殊成员之iter

一个对象如果可以被for循环迭代时,说明对象中又__iter__方法,且方法中有yield值。

  1. #!/usr/bin/env python
  2. # _*_coding:utf-8 _*_
  3. class SpecialMembers:
  4.    def __iter__(self):
  5.        yield 1
  6.        yield 2
  7.        yield 3
  8. # 创建一个对象
  9. obj = SpecialMembers()
  10. # 如果执行for循环对象时,自动会执行对象的__iter__方法,此时的__iter__就是一个生成器
  11. for i in obj:
  12.    print(i)

输出

  1. [email protected]:~$ python3 /home/yangwen/文档/Python_code/sublime/Week06/Day04/s2.py
  2. 1
  3. 2
  4. 3
时间: 2024-11-03 05:40:52

Python面向对象特殊成员的相关文章

python面向对象之类成员

一.概述 上篇<python面向对象OOP>介绍了python面向对象的基础初级入门部分,提到了类的定义,使用,类的三大特性;经典类,新式类在查找时的区别等,有了前面的基础,本文接着描述面向对象中类成员;先整体描述下,类中的成员分以下几部分: #类成员  #字段(属性):      普通字段  属于对象,保存在对象中,只能通过对象访问      静态字段  属于类,保存(一份)在类中(所有对象共享的字段属性),执行时可以是类访问也可以是对象访问  #方法:      普通方法  保存在类中,又

Python面向对象-类成员

类的成员可以分为三大类:字段.方法和属性: 注:所有成员中,只有普通字段的内容保存对象中,即:根据此类创建了多少对象,在内存中就有多少个普通字段.而其他的成员,则都是保存在类中,即:无论对象的多少,在内存中只创建一份. (一)字段 字段包括:普通字段和静态字段,他们在定义和使用中有所区别,而最本质的区别是内存中保存的位置不同 1 class Province: 2 # 静态字段 3 country = "China" 4 5 def __init__(self, name): 6 #

Python面向对象类成员特性

特性的存在就是将方法伪装成字段. property 把类方法当做普通字段去调用,即用对象调用的时候后面不用加括号 #!/usr/bin/env python # _*_coding:utf-8 _*_ class Foo:    @property    def Characteristic(self):        print("类方法的特性") # 创建一个对象 obj = Foo() # 调用类方法的时候方法后面不用加括号 obj.Characteristic 输出 /usr/

python面向对象的成员、属性等

#类成员: #字段 self.xy =qq . xy=qq #普通字段 (保存在对象里面) #直接通过点(.)+ 字段 进行调用 #静态字段 (保存在类里面) #静态字段属于类,在内存只保留一份 . 把公共的字段 放到类中 ,节省内存等好处 #代码从上到下解释到类就创建了 #可以通过 类.静态字段 进行访问 #方法 def xx() # (保存在类里面) #通过点(.) + 方法名 + 括号 进行调研 #通过 类 点(.) 方法名也可以调用 . 还是要在前面先实例化一个对象 #静态字段class

python面向对象之成员

成员在类中写的所有内容都是类的成员 变量实例变量: 由对象去访问的变量 class Person: def __init__(self,name,birth): self.name = name # 实例变量,对象里的变量(对象.属性) self.birth = birth p = Person('bob','1900') print(p.name) print(p.birth) p.birth = 1937 print(p.birth) 结果 bob 1900 1937 类变量: 变量属于类,

Python面向对象之类的成员

Python面向对象的编程过程中,我们为类实例化了对象,并通过对象指针来访问类中对应的资源,那么这些资源大体分为三大部分,分别是字段.方法和属性,我们将这三大块统称为类的成员. 一.字段 字段可以分为静态字段.动态字段,下面通过代码展示类中的两种字段 class MyClass:     # 静态字段,属于类,多个对象共用一个静态字段     leader = "abuve"       def __init__(self):         # 动态字段,属于对象,也可以叫普通的字段

Python面向对象进阶及类成员

再次了解多继承 先来一段代码 #!/usr/bin/env python # _*_ coding:utf-8 _*_ class A:    def bar(self):        print("BAR")        self.f1() class B(A):    def f1(self):        print("B") class C:    def f1(self):        print("C") class D(C,

python 面向对象和类成员和异常处理

python 面向对象 你把自己想象成一个上帝,你要创造一个星球,首先你要把它揉成一个个球,两个直径就能创造一个球 class star: '''名字(name),赤道直径(equatorial diameter),极直径(polar diameter)''' def __init__(self,name,eqDiameter,poDiameter): self.name=name self.eqDiameter=eqDiameter #赤道直径 self.poDiameter=poDiamet

Python面向对象之结构与成员

1.面向对象结构分析: ----面相对象整体大致分为两块区域: --------第一部分:静态字段(静态变量)部分 --------第二部分:方法部分 --每个大区域可以分为多个小部分: class A: cooname = 'Jake' # 静态变量(静态字段) __cooage = 20 # 私有静态变量(私有静态字段) def __init__(self, name, age): # 普通方法(构造方法) self.name = name # 对象属性(普通字段) self.__age =