类与对象

一，类

　　个人理解，类是以函数为基础，通过__init__(self)，把一些重复使用的参数加以打包于一起，以达到简化工程的目的。（可以最后看这句话）

1 def CarInfo(type,price):
 2     print "the car's type %s,price:%d"%(type,price)
 3 
 4 
 5 CarInfo('passat',250000)
 6 CarInfo('ford',280000)
 7 
 8 
 9 
10 
11 class Car:   #定义了一个类
12     def __init__(self,type,price):   #在类中编写了一个对象
13         self.type = type
14         self.price = price
15 
16     def printCarInfo(self):
17         print "the car's Info in class:type %s,price:%d"%(self.type,self.price)
18 
19 carOne = Car('passat',250000)  #创建了一个对象或者说实例化了一个对象
20 carTwo = Car('ford',250000)     
21 carOne.printCarInfo()  #通过对象调用其中一个方法
22 carTwo.printCarInfo()

 fnction_class_CompareCode

　　运行代码可知，两者结果相同，我想说的是，函数都可以转化为类。下面这个例子是类利用比较好的例子。

class UserInfo:

    def __init__(self):
        self.name = None

    def info(self):
        print('当前用户名称:%s' %(self.name,))

    def account(self):
        print('当前用户%s的账单是:....' %(self.name,))

    def shopping(self):
        print('%s购买了一个人形抱枕' %(self.name,))

    def login(self):
        user = input('请输入用户名:')
        pwd = input('请输入密码:')
        if pwd == 'sb':
            self.name = user
            while True:
                print("""
                    1. 查看用户信息
                    2. 查看用户账单
                    3. 购买抱枕
                """)
                num = int(input('请输入选择的序号:'))
                if num == 1:
                    self.info()
                elif num ==2:
                    self.account()
                elif num == 3:
                    self.shopping()
                else:
                    print('序号不存在,请重新输入')
        else:
            print('登录失败')

obj = UserInfo()
obj.login()

 二，类的三大特性

1. 封装，就是将函数的参数封装到self中

   

    

   self 是一个形式参数，当执行 obj1 = Foo('wupeiqi', 18 ) 时，self 等于 obj1

                                 当执行 obj2 = Foo('alex', 78 ) 时，self 等于 obj2

   所以，内容其实被封装到了对象 obj1 和 obj2 中，每个对象中都有 name 和 age 属性，在内存里类似于下图来保存。

   

    

   例子，游戏场景，分别：

   • 草丛战斗，消耗200战斗力
   • 自我修炼，增长100战斗力
   • 多人游戏，消耗500战斗力

   • # -*- coding:utf-8 -*-
     
     # #####################  定义实现功能的类  #####################
     
     class Person:
     
         def __init__(self, na, gen, age, fig):
             self.name = na
             self.gender = gen
             self.age = age
             self.fight =fig
     
         def grassland(self):
             """注释：草丛战斗，消耗200战斗力"""
     
             self.fight = self.fight - 200
     
         def practice(self):
             """注释：自我修炼，增长100战斗力"""
             
             self.fight = self.fight + 200
     
         def incest(self):
             """注释：多人游戏，消耗500战斗力"""
             
             self.fight = self.fight - 500
     
         def detail(self):
             """注释：当前对象的详细情况"""
     
             temp = "姓名:%s ; 性别:%s ; 年龄:%s ; 战斗力:%s"  % (self.name, self.gender, self.age, self.fight)
             print temp
     
             
     # #####################  开始游戏  #####################
     
     cang = Person('苍井井', '女', 18, 1000)    # 创建苍井井角色
     dong = Person('东尼木木', '男', 20, 1800)  # 创建东尼木木角色
     bo = Person('波多多', '女', 19, 2500)      # 创建波多多角色
     
     cang.incest() #苍井空参加一次多人游戏
     dong.practice()#东尼木木自我修炼了一次
     bo.grassland() #波多多参加一次草丛战斗
     
     
     #输出当前所有人的详细情况
     cang.detail()
     dong.detail()
     bo.detail()
     
     
     cang.incest() #苍井空又参加一次多人游戏
     dong.incest() #东尼木木也参加了一个多人游戏
     bo.practice() #波多多自我修炼了一次
     
     #输出当前所有人的详细情况
     cang.detail()
     dong.detail()
     bo.detail()
     游戏人生

      

2. 继承，父类中的函数可以被子类调用

   

   class Animal:
   
       def eat(self):
           print "%s 吃 " %self.name
   
       def drink(self):
           print "%s 喝 " %self.name
   
       def shit(self):
           print "%s 拉 " %self.name
   
       def pee(self):
           print "%s 撒 " %self.name
   
   
   class Cat(Animal):
   
       def __init__(self, name):
           self.name = name
           self.breed ＝ '猫'
   
       def cry(self):
           print '喵喵叫'
   
   class Dog(Animal):
       
       def __init__(self, name):
           self.name = name
           self.breed ＝ '狗'
           
       def cry(self):
           print '汪汪叫'
           
   
   # ######### 执行 #########
   
   c1 = Cat('小白家的小黑猫')
   c1.eat()
   
   c2 = Cat('小黑的小白猫')
   c2.drink()
   
   d1 = Dog('胖子家的小瘦狗')
   d1.eat()
   
   代码实例

   多继承，子类可以继承多个父类的函数，寻找时优先左继承

   class D(object):
   
       def bar(self):
           print 'D.bar'
   
   
   class C(D):
   
       def bar(self):
           print 'C.bar'
   
   
   class B(D):
   
       def bar(self):
           print 'B.bar'
   
   
   class A(B, C):
   
       def bar(self):
           print 'A.bar'
   
   a = A()
   # 执行bar方法时
   # 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
   # 所以，查找顺序：A --> B --> C --> D
   # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
   a.bar()
   
   新式类多继承

3. 多态，python因为带多态，可以不用多深就。

 三，类的成员

　　类可以分为三大类，字段，方法和属性。

 　　字段分为静态字段和普通字段。普通字段可以理解为类中的函数，而静态字段则不是。

　　　　区别：访问区别，静态字段可以不通过对象直接访问，普通字段则需要创建实例，通过实例进行访问。

• 普通字段属于对象
• 静态字段属于类

输出结果为，1和12

因为这个访问是从对象上进行访问，所以是先访问普通字段，然后在访问静态字段。

 

class Province:

    # 静态字段
    country ＝ '中国'

    def __init__(self, name):

        # 普通字段
        self.name = name


# 直接访问普通字段
obj = Province('河北省') #创建实例
print obj.name

# 直接访问静态字段
Province.country

字段的定义和使用

方法有三种：

• 普通方法，由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self
• 静态方法，由类调用；无默认参数
• 类方法，由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls

• class Foo:
  
      def __init__(self, name):
          self.name = name
  
      def ord_func(self):
          """ 定义普通方法，至少有一个self参数 """
  
          # print self.name
          print '普通方法'
  
      @classmethod
      def class_func(cls):
          """ 定义类方法，至少有一个cls参数 """
  
          print '类方法'
  
      @staticmethod
      def static_func():
          """ 定义静态方法 ，无默认参数"""
  
          print '静态方法'
  
  
  # 调用普通方法
  f = Foo()
  f.ord_func()
  
  # 调用类方法
  Foo.class_func()
  
  # 调用静态方法
  Foo.static_func()
  
  方法的定义和使用

   

• 

属性

　　　　

　　13题的输出结果与14题的输出结果都为 <class '__main__.Foo'>。

　　这表示访问类方法，不但可以从对象上进行访问，也可以从类进行访问。

Python中的属性其实是普通方法的变种。

　　　　对于属性，有以下三个知识点：

• • • 属性的基本使用
    • 属性的两种定义方式
    • 调用时，无需括号
                 方法：foo_obj.func()
                 属性：foo_obj.prop

 　　　　属性由方法变种而来，如果Python中没有属性，方法完全可以代替其功能。

　　属性的两种定义方法

• 装饰器 即：在方法上应用装饰器
• 静态字段 即：在类中定义值为property对象的静态字段

装饰器方式：在类的普通方法上应用@property装饰器

# ############### 定义 ###############    
class Goods:

    @property
    def price(self):
        return "wupeiqi"
# ############### 调用 ###############
obj = Goods()
result = obj.price  # 自动执行 @property 修饰的 price 方法，并获取方法的返回值

　　新式类，具有三种@property装饰器

# ############### 定义 ###############
class Goods(object):

    @property
    def price(self):
        print '@property'

    @price.setter
    def price(self, value):
        print '@price.setter'

    @price.deleter
    def price(self):
        print '@price.deleter'

# ############### 调用 ###############
obj = Goods()

obj.price          # 自动执行 @property 修饰的 price 方法，并获取方法的返回值

obj.price = 123    # 自动执行 @price.setter 修饰的 price 方法，并将  123 赋值给方法的参数

del obj.price      # 自动执行 @price.deleter 修饰的 price 方法

　　由于新式类中具有三种访问方式，我们可以根据他们几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除

class Goods(object):

    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    @property
    def price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    @price.setter
    def price(self, value):
        self.original_price = value

    @price.deltter
    def price(self, value):
        del self.original_price

obj = Goods()
obj.price         # 获取商品价格
obj.price = 200   # 修改商品原价
del obj.price     # 删除商品原价

实例

　　

静态字段方式，创建值为property对象的静态字段

当使用静态字段的方式创建属性时，经典类和新式类无区别

class Foo:

    def get_bar(self):
        return 'wupeiqi'

    BAR = property(get_bar)

obj = Foo()
reuslt = obj.BAR        # 自动调用get_bar方法，并获取方法的返回值
print reuslt

property的构造方法中有个四个参数

• 第一个参数是方法名，调用 对象.属性 时自动触发执行方法
• 第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
• 第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
• 第四个参数是字符串，调用 对象.属性.__doc__ ，此参数是该属性的描述信息

  class Foo：
  
      def get_bar(self):
          return 'wupeiqi'
  
      # *必须两个参数
      def set_bar(self, value): 
          return return 'set value' + value
  
      def del_bar(self):
          return 'wupeiqi'
  
      BAR ＝ property(get_bar, set_bar, del_bar, 'description...')
  
  obj = Foo()
  
  obj.BAR              # 自动调用第一个参数中定义的方法：get_bar
  obj.BAR = "alex"     # 自动调用第二个参数中定义的方法：set_bar方法，并将“alex”当作参数传入
  del Foo.BAR          # 自动调用第三个参数中定义的方法：del_bar方法
  obj.BAE.__doc__      # 自动获取第四个参数中设置的值：description...

  由于静态字段方式创建属性具有三种访问方式，我们可以根据他们几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除

   

   注意：Python WEB框架 Django 的视图中 request.POST 就是使用的静态字段的方式创建的属性

   

  所以，定义属性共有两种方式，分别是【装饰器】和【静态字段】，而【装饰器】方式针对经典类和新式类又有所不同。

四，类成员的修饰符

　　　　

类的所有成员在上一步骤中已经做了详细的介绍，对于每一个类的成员而言都有两种形式：

• 公有成员，在任何地方都能访问
• 私有成员，只有在类的内部才能方法

私有成员和公有成员的定义不同：私有成员命名时，前两个字符是下划线。（特殊成员除外，例如：__init__、__call__、__dict__等）

1 2 3 4 5

class C:       def __init__(self):         self.name = '公有字段'         self.__foo = "私有字段"

 

 

 

私有成员和公有成员的访问限制不同：

静态字段

• 公有静态字段：类可以访问；类内部可以访问；派生类中可以访问
• 私有静态字段：仅类内部可以访问；

 

 

普通字段

• 公有普通字段：对象可以访问；类内部可以访问；派生类中可以访问
• 私有普通字段：仅类内部可以访问；

ps：如果想要强制访问私有字段，可以通过 【对象._类名__私有字段明 】访问（如：obj._C__foo），不建议强制访问私有成员。

 

 

方法、属性的访问于上述方式相似，即：私有成员只能在类内部使用

ps：非要访问私有属性的话，可以通过 对象._类__属性名

五，嵌套

 类可以通过嵌套将两者类练习到一起。

class School(object):
    def __init__(self, name, address):
        self.name = name
        self.address = address

    def speech(self):
        print('讲课')

obj1 = School('老男孩北京校区', '美丽富饶的沙河')
obj2 = School('老男孩上海校区', '浦东新区')
obj3 = School('老男孩深圳校区', '南山区')
class Teacher(object):
    def __init__(self, name, age, salary):
        self.name = name
        self.age = age
        self.__salary = salary
        self.school = None

t1 = Teacher('李杰', 19, 188888)
t2 = Teacher('艳涛', 18, 60)
t3 = Teacher('女神',16, 900000)
# ############## 老师分配校区
t1.school = obj1  #t1与obj是来自两个不同的类，但是通过school练习到了一起。
t2.school = obj1
t3.school = obj2
# ####################################
# 查看t1老师,所在的校区名称/地址
print(t1.school.name) 
print(t1.school.address)
print(t1.name)
print(t1.age)
t1.school.speech()

 六，主动调用其他类的函数

　　当子类的缺少函数时会被动的在父类那里找。但如果想主动的去父类找，则需要一些方法。

 ########### 方式一
# class Base(object):
#
#     def f1(self):
#         print('5个功能')
#
# class Foo(object):
#
#     def f1(self):
#         print('3个功能')
#         Base.f1(self)  
#
# obj = Foo()
# obj.f1()


# ########### 方式二:按照类的继承顺序,找下一个.
"""
class Base(object):
    def f1(self):
        print('5个功能')

class Foo(Base):
    def f1(self):
        super().f1()
        print('3个功能')
        
obj = Foo()
obj.f1()
"""

# ########### 方式二:按照类的继承顺序,找下一个.
class Foo(object):
    def f1(self):
        super().f1() #此时内部的self是Info
        print('3个功能')

class Bar(object):
    def f1(self):
        print('6个功能')

class Info(Foo,Bar):
    pass

# obj = Foo()
# obj.f1()

obj = Info()
obj.f1()

七，类的特殊成员

1. __doc__

　　表示类的描述信息

class Foo:
    """ 描述类信息，这是用于看片的神奇 """

    def func(self):
        pass

print Foo.__doc__
#输出：类的描述信息

 

2. __module__ 和  __class__ 

　　__module__ 表示当前操作的对象在那个模块

　　__class__     表示当前操作的对象的类是什么

#!/usr/bin/env python
# -*- coding:utf-8 -*-

class C:

    def __init__(self):
        self.name = 'wupeiqi'
复制代码

from lib.aa import C

obj = C()
print obj.__module__  # 输出 lib.aa，即：输出模块
print obj.__class__      # 输出 lib.aa.C，即：输出类

3. __init__

　　构造方法，通过类创建对象时，自动触发执行。类+（）会自动执行init

class Foo:

    def __init__(self, name):
        self.name = name
        self.age = 18


obj = Foo('wupeiqi') # 自动执行类中的 __init__ 方法

 

4. __del__

　　析构方法，当对象在内存中被释放时，自动触发执行。

注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

5. __call__

　　类+（）会执行init，而对象+（）会执行call。　　

　　对象后面加括号，触发执行。

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

class Foo:

    def __init__(self):
        pass
    
    def __call__(self, *args, **kwargs):

        print '__call__'


obj = Foo() # 执行 __init__
obj()       # 执行 __call__

 

6. __dict__

　可以获取封装的内容，以字典的形式呈现出来

class Province:

    country = 'China'

    def __init__(self, name, count):
        self.name = name
        self.count = count

    def func(self, *args, **kwargs):
        print 'func'

# 获取类的成员，即：静态字段、方法、
print Province.__dict__
# 输出：{'country': 'China', '__module__': '__main__', 'func': <function func at 0x10be30f50>, '__init__': <function __init__ at 0x10be30ed8>, '__doc__': None}

obj1 = Province('HeBei',10000)
print obj1.__dict__
# 获取 对象obj1 的成员
# 输出：{'count': 10000, 'name': 'HeBei'}

obj2 = Province('HeNan', 3888)
print obj2.__dict__
# 获取 对象obj1 的成员
# 输出：{'count': 3888, 'name': 'HeNan'}

 

 7. __str__

　　如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。

class Foo:

    def __str__(self):
        return 'wupeiqi' #只能填写字符串


obj = Foo()
print obj #将内存地址换成了字符串
# 输出：wupeiqi

8、__getitem__、__setitem__、__delitem__

用于索引操作，如字典。以上分别表示获取、设置、删除数据

#!/usr/bin/env python
# -*- coding:utf-8 -*-
 
class Foo(object):
 
    def __getitem__(self, key):
        print '__getitem__',key
 
    def __setitem__(self, key, value):
        print '__setitem__',key,value
 
    def __delitem__(self, key):
        print '__delitem__',key
 
 
obj = Foo()
 
result = obj['k1']      # 自动触发执行 __getitem__
obj['k2'] = 'wupeiqi'   # 自动触发执行 __setitem__
del obj['k1']           # 自动触发执行 __delitem__

 

9、__getslice__、__setslice__、__delslice__

 该三个方法用于分片操作，如：列表

#!/usr/bin/env python
# -*- coding:utf-8 -*-
 
class Foo(object):
 
    def __getslice__(self, i, j):
        print '__getslice__',i,j
 
    def __setslice__(self, i, j, sequence):
        print '__setslice__',i,j
 
    def __delslice__(self, i, j):
        print '__delslice__',i,j
 
obj = Foo()
 
obj[-1:1]                   # 自动触发执行 __getslice__
obj[0:1] = [11,22,33,44]    # 自动触发执行 __setslice__
del obj[0:2]                # 自动触发执行 __delslice__

 

10. __iter__ ，可以通过加入iter使不可迭代对象变成可迭代的。

用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__ 

复制代码
class Foo(object):
    pass


obj = Foo()

for i in obj:
    print i
    
# 报错：TypeError: 'Foo' object is not iterable
复制代码

复制代码
#!/usr/bin/env python
# -*- coding:utf-8 -*-

class Foo(object):
    
    def __iter__(self):
        pass

obj = Foo()

for i in obj:
    print i

# 报错：TypeError: iter() returned non-iterator of type 'NoneType'
复制代码

复制代码
#!/usr/bin/env python
# -*- coding:utf-8 -*-

class Foo(object):

    def __init__(self, sq):
        self.sq = sq

    def __iter__(self):
        return iter(self.sq)

obj = Foo([11,22,33,44])

for i in obj:
    print i

以上步骤可以看出，for循环迭代的其实是  iter([11,22,33,44]) ，所以执行流程可以变更为：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
 
obj = iter([11,22,33,44])
 
for i in obj:
    print i

 

11. __new__ 和 __metaclass__

阅读以下代码：

class Foo(object):
 
    def __init__(self):
        pass
 
obj = Foo()   # obj是通过Foo类实例化的对象

 

上述代码中，obj 是通过 Foo 类实例化的对象，其实，不仅 obj 是一个对象，Foo类本身也是一个对象，因为在Python中一切事物都是对象。

如果按照一切事物都是对象的理论：obj对象是通过执行Foo类的构造方法创建，那么Foo类对象应该也是通过执行某个类的 构造方法 创建。

1 2	print type(obj) # 输出：<class '__main__.Foo'>     表示，obj 对象由Foo类创建 print type(Foo) # 输出：<type 'type'>              表示，Foo类对象由 type 类创建

八，构造方法

创建类就可以有两种方式：

a). 普通方式

class Foo(object):
 
    def func(self):
        print 'hello wupeiqi'
b).特殊方式（type类的构造函数）


def func(self):
    print 'hello wupeiqi'
 
Foo = type('Foo',(object,), {'func': func})
#type第一个参数：类名
#type第二个参数：当前类的基类
#type第三个参数：类的成员

 

 

＝＝》 类 是由 type 类实例化产生

那么问题来了，类默认是由 type 类实例化产生，type类中如何实现的创建类？类又是如何创建对象？

答：类中有一个属性 __metaclass__，其用来表示该类由 谁 来实例化创建，所以，我们可以为 __metaclass__ 设置一个type类的派生类，从而查看 类 创建的过程。

 1 真正的构造方法
 2 # class Foo(object):
 3 #     def __init__(self, a1, a2):     # 初始化方法
 4 #         """
 5 #         为空对象进行数据初始化
 6 #         :param a1:
 7 #         :param a2:
 8 #         """
 9 #         self.a1 = a1
10 #         self.a2 = a2
11 #
12 #     def __new__(cls, *args, **kwargs): # 构造方法
13 #         """
14 #         创建一个空对象
15 #         :param args:
16 #         :param kwargs:
17 #         :return:
18 #         """
19 #         return object.__new__(cls) # Python内部创建一个当前类的对象(初创时内部是空的.). #必须有return
20 #
21 # obj1 = Foo(1,2)
22 # print(obj1)

九，函数补充（issubclass、type）

• class Base(object):
      pass
  
  class Foo(Base):
      pass
  
  class Bar(Foo):
      pass
  
  print(issubclass(Bar,Base)) # 检查第一个参数是否是第二个参数的 子子孙孙类

  判断类之间是否有父类与子类的关系

• class Foo(object):
      pass
  
  obj = Foo()
  
  print(obj,type(obj)) # 获取当前对象是由那个类创建。
  if type(obj) == Foo:
      print('obj是Foo类型')

  判断对象与类时候有关系（不包括类的父类）（更加精准）

• class Base(object):
      pass
  
  class Foo(Base):
      pass
  
  obj1 = Foo()
  print(isinstance(obj1,Foo))  # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。
  print(isinstance(obj1,Base)) # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。
  
  
  obj2 = Base()
  print(isinstance(obj2,Foo))  # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。
  print(isinstance(obj2,Base)) # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。

  判断对象与类时候有关系（包括类的父类）（更加模糊）

十，易错点

　　在类中可以分为静态字段与普通字段。并且静态字段属于类，普通字段属于对象。而，两者的更深层次的区分原因是两者的在执行时所在的内存地址不同。属于类的静态字段会在类的内存上创建，而属于对象的普通字段会在对象的内存中创建。下面三题由浅到深的进行了讲解。

第一题：

class StarkConfig(object):
    list_display = []

    def get_list_display(self):
        self.list_display.insert(0,33)
        return self.list_display


s1 = StarkConfig()#进行对象化

result1 = s1.get_list_display()
print(result1) # 33

result2 = s1.get_list_display()
print(result2) # 33 33

 我们可以看出静态字段是在类StarkConfig的内存地址中。

 

class StarkConfig(object):
   3 
    def get_list_display(self):
        self.list_display.insert(0,33)
        return self.list_display


s1 = StarkConfig()
s2 = StarkConfig()

result1 = s1.get_list_display()
print(result1)

result2 = s1.get_list_display()
print(result2)

 

 创建完对象后会执行_init_函数，此时会在对象地址上进行创建。

class StarkConfig(object):
    list_display = []

    def get_list_display(self):
        self.list_display.insert(0,33)
        return self.list_display


s1 = StarkConfig()
s2 = RoleConfig()

result1 = s1.get_list_display()
print(result1) #33

result2 = s2.get_list_display()
print(result2) #33

会在两个内存地址个创建一个列表进行填数。