python中的类（二）

python中的类（二）

六、类的成员

字段：普通字段，静态字段

eg：

class Province():
 
      country=’中国’  #静态字段，保存在类中，执行时可以通过类或对象访问
 
      def __init__(self,name):
 
             self.name=name             #普通字段，保存在对象中，只能通过对象访问
 
print(Province.country)         #中国，通过类访问
 
obj=Province(‘河南’)
 
print (obj.name)                    #河南，通过对象访问
 
print（obj.country）             #中国，通过对象访问

方法：普通方法，静态方法，类方法

应用场景：

普通方法：对象中需要保存一些值，执行某功能时，需要使用对象中的值

静态方法：不需要任何对象中的值

eg：

class Foo():
 
      def f1(self):         #普通方法，保存在类中，由对象调用，形参self指调用的对象
 
             print(123)
 
      @staticmethod
 
      def f2(a1):    #静态方法，self不是必须的形参，保存在类中，可以通过类直接调用
 
             print(a1)
 
      @classmethod
 
      def f3(cls):   #类方法，形参cls指当前类名，所以可以通过类访问
 
             print

属性

属性实际是方法，只是在在调用时不像调用方法那样在方法名后加括号。

class Foo():
 
      @propery           #用于执行obj.f4
 
      def f4(self):
 
             print (789)
 
      return 1
 
      @f4.settr                    #用于执行obj.f4=123
 
      def f4(self,val)
 
             print(val)
 
      @f4.deleter        #用于执行del obj.f4
 
      def f4(self):
 
             print(111)
 
调用：
 
obj=Foo()          #创建对象
 
r=obj.f4                    #调用属性
 
print (r)              #
 
                           #
 
obj.f4=123         #
 
del obj.f4                  #

成员修饰符

类的成员分为共有成员和私有成员。共有成员可以直接访问，而私有成员不可以外部直接访问。

共有成员：

以前创建的成员均为共有成员。

私有成员：

在创建成员时，在成员名前添加两个下划线即可。私有成员虽然外部无法直接访问，但是可以在类的内部访问。父类中的私有成员，子类也不可直接使用。

class Person ( ):
 
      def __init__(self,name,age):
 
             self.name=name      #共有成员
 
             self.__age=age  #私有成员
 
      def show():
 
             print ( self.__age)
 
F=Person(‘tom’,18)
 
F.show()                    #18,通过类内部访问
 
F.name              #tom，通过外部访问

特殊成员

__call__

class Call:
 
    def __call__(self, *args, **kwargs):
             print (‘ok’)
 
#调用方法一
 
F=Call()
 
F()         #执行__call__方法，输出ok
 
#调用方法二
 
Call()()         #执行__call__方法，输出ok

__str__

一般在print时使用。若不加此方法，print该类的对象时，显示的是该类的内存地址。

eg：

class F（）：
 
      def __init__(self,n,a):
 
             self.name=n
 
             self.age=a
 
      def __str__(self):
 
             return self.name
 
#调用
 
      A=F（’tom’,18）
 
      print (A)              #tom,执行时类似于print(str(A)),str(A)会自动调用F中的str方法，并获取其返回值

__del__(析构方法)

在该类的对象被销毁时，执行。

__getiterm__

通过索引取值。

eg：

class Person():
    def __init__(self, name, age):
        self.name = name
        self.__age = age
    def __getitem__(self, item):
        return item+10
F=Person('tom',18)
print (F[2])   #12,自动执行F对象类中__getitem__方法。

__setiterm__

通过索引赋值。

eg：

class Person():
 
    def __init__(self, name, age):
 
        self.name = name
 
        self.__age = age
 
    def __setitem__(self, key, value):
 
    print (key,value)
 
F=Person('tom',18)
F[3]=222  #3 222，自动执行F对象类中__setitem__方法。

__iter__

如果类中有__iter__方法，则该对象时可迭代对象

对象.__iter__()的返回值是迭代器

for循环遇到可迭代对象，则自动执行对象.__iter__()，生成迭代器，进行for循环。

eg：

class Person():
 
    def __init__(self, name, age):
 
        self.name = name
 
        self.__age = age
 
    def __iter__(self):
 
        return iter([11, 22, 33])
F=Person('tom',18)
for i in F:
    print(i)

metaclass

class F1(type):
    def __init__(self,what,bases=None,dict=None):
        super(F1, self).__init__(what,bases,dict)
        print (1)
    def __call__(self):
        print (2)
        self.__new__(self)
        self.__init__(self)
class S(object,metaclass=F1):
    def __new__(cls, *args, **kwargs):
        pass
    def __init__(self):
        print (3)

输出结果为：

1

2

3