Python基础：Python类（真累~）

标签：单词   inf   lin   new   dict   自定义   obb   row   存在   

一、类的属性

（私有属性和公有属性）

（类属性）

二、类的方法

（构造方法、析构方法、自定义方法、特殊成员方法）

（静态方法、类方法、类属性）

三、类的继承

（方法和属性的继承，方法的重构）

（抽象类，多重继承）

四、类的多态

（实现接口的重用）

五、类的特殊装饰

（@staticmethod、@classmethod、@property）

六、类的来源和原类（metaclass）

七、反射

• 类的声明

  使用class声明类，建议类名单词首字母大写。

  “新式类”和“经典类”的区分在Python 3之后就已经不存在，在Python 3.x之后的版本，因为所有的类都派生自内置类型object(即使没有显示的继承object类型)，即所有的类都是“新式类”。

  新式类：

class Management(object):

    def add():
        pass

      经典类：

class Management:
    pass

• 类的属性 

  类的属性就是类定义的变量值。

       公有属性：在类里直接定义的属性，它在类名下面直接定义。

                        调用：1、类中调用：类名.属性名 ，更改原公有属性值

                                   2、实例调用：实例.属性名

class Management(object):
    num = 10

    def add(self):
        Management.num +=10            # 类中调用公有属性并更改值，num=11
        pass

s1 = Management()
s2 = Management()

# 第一种情况：s1实例中调用公有属性，s2实例没有调用公有属性
s1.num +=1
Management.num += 2
"""
<结果>
s1不变，s2和Management都改变了
s1_num:11   s2_num:12   Manage_num:12
"""

# 第二种情况：先调用s1实例公有属性，再通过S1调用add更改，然后再使用类更改
s1.num +=1
s1.add()
Management.num += 2
"""
<结果>
先调用的s1实例num依然不变，s2和Management都被修改了
s1_num:11   s2_num:22   Manage_num:22

"""

 问题：为什么修改num的值以后，实例s1和实例s2会有不同的结果呢 ？

            因为公有属性查找的顺序是：先找实例的公有属性，没找到再找类里的公有属性

            可以这样理解：Management相当于一个微信群，num是群里发的一张照片，S1和S2是群里面的两个人。

            情况1：S1把照片存到本地，P了个双眼皮，S2说太难看了，我也不会P图，不保存。这个时候发照片的Management说我也觉得难看，把图撤回，重新发了一个P的图。S2就只能保存最新的图片。

            情况2：S1找到Management说你的图太丑了，重新改一下吧，Management说好！撤回图片修改了~

       私有属性：加两个下划线，__membername,编译的时候自动加上类名，变成_classname__membername，这种技术叫变量名压缩(mangling)，以达到外部不能调用的目的。实际使用_classname__membername是可以调用的，但是不符合规定。标准方法是通过定义函数来获取。

class Classname(object):
 '''this is a demo!'''
 def __init__(self):
  self.__membername = 88

 def read_membername(self):            # 标准的外部访问方法,使用函数来读取私有属性。
  return self.__membername

s= Classname()
print(s._Classname__membername)
print(s.read_membername())
'''
<结果>
88
88
------像下面的调用，会出现AttributeError错误------
print(s.__membername)
'''

       类属性：  类自带的属性,需要注意的是实例化的类属性，和原类的类属性不同。用上面的例子作演示。

• 类的方法

  类的方法就是类里面定义的函数。类的构造方法、析构方法、自定义类方法、静态方法、类方法、属性方法、特殊成员方法。

  构造方法：__init__

  实例化类的时候就会运行的函数。希望初始化的参数放置在init下面。(个人觉得，这个初始化参数可以是一切对象！)

class A(object):
 def instense(self):
  print("init obj A")
  
class B(object):
 def __init__(self, para):
  self.init_para = para
  self.obj_A = A()
  self.num = 1
 
 def show(self):
  print(self.init_para)
  self.obj_A.instense()
  print(self.num)
haha = B("this is para")
haha.show()


----------
this is para

init obj A

1

   析构方法：

   __del__：销毁实例时，方法才会执行。

class Hello(object):
    def __del__(self):
        print("你删除了实例")
# 在python上测试
instance = Hello()
del instance
# 当然也可以使用实例调用，但没有这么用的~~
instance.__del__()

  自定义方法：

  除去类中自带的以_下划线开头的函数，在类中定义一个函数，实现相应的功能。

class Person(object):
    def __init__(self,person_name, person_age)

   静态方法：

    @staticmethod，不需要访问类里的任何参数。所带的参数都是从外部传入的。

class Person(object):
    def __init__(self,person_name, person_age):
        self.name = person_name
        self.age = person_age
        
    @staticmethod
    def info(country):
        print(country)

   类方法：

   @classmethod,第一个参数必须是类属性。

class Person(object):
    country = "china"
    def __init__(self,person_name, person_age):
        self.name = person_name
        self.age = person_age
        
    @classmethod
    def info(country):
        print(country)

    属性方法：

    @property把一个函数变成一个静态属性

    直接调用函数名字，不需要加括号，就能获取到函数返回值。一般用在不注重过程，只要结果的情况!

class Person(object):
    country = "china"
    def __init__(self,person_name, person_age):
        self.name = person_name
        self.age = person_age

    @property
    def health_point(self):
        print("HP:【{}】".format(self.age*2))
        return self.age*2

P = Person("laowang",23)
P.health_point                # 不需要括号，看起来完全是一个属性，这就是属性方法

    特殊成员方法：

'''例子一call\str\getitem\setitem\delitem方法'''
class Person(object):
 def __call__(self):
  print("print call")
 
 def __str__(self):
  print("print str:",end='')
  return "1"
  
 def __getitem__(self,key):  
  print("getitem:",key)
  
 def __setitem__(self,key,value):
  print('setitem:',key,value)
 
 def __delitem__(self,key):
  print('delitem:',key)
  
p = Person()
p()
print(p)
print('-----------')
get = p['name']
p['name'] = 'David'
del p['name']

'''例子二：__new__/__init__'''
class Person(object):

 def __init__(self):

  print('this is init!')
  

 def __new__(self):

  print("this is new!")

  self.__init__(self)        # 如果去掉这一行，init不能执行
  
p = Person()

    类的来源和元类：

    http://blog.jobbole.com/21351/中文版详细解答。下面写一个自己理解的简版的。

    首先，类也是对象，可以：

    1)   你可以将它赋值给一个变量

    2)   你可以拷贝它

    3)   你可以为它增加属性

    4)   你可以将它作为函数参数进行传递

    类也是是由type()这个函数创建的，type是类的类，类的爹。学名叫元类！

    也许有人会问那为啥type()能查看到数据类型呢？因为数据类型在Python中都是类定义的，这也说明了，为什么数字，字符等等全是对象。

    type格式：

    type(类名,(父类元组),{属性字典},{方法词典})  ,  父类元组可以没有；后面两个典省略时，默认值为None。

'''一言不合就上例子'''
class Person(object):
    country = 'china'

Person = type('Person',('object',),{'country':china})

未完待续。。。

• 类的继承

• 类的多态

• 反射

Python基础：Python类（真累~）

标签：单词   inf   lin   new   dict   自定义   obb   row   存在   

原文地址：http://blog.51cto.com/yishi/2072182