Python中类的全面分析(上)

  • A+
所属分类:Python 数据挖掘

面向对象重要的概念就是类(Class)和实例(Instance),类是抽象的模板,而实例是根据类创建出来的一个个具体的“对象”,每个对象都拥有相同的方法,但各自的数据可能不同。

先回顾下 OOP 的常用术语:

  • 类:对具有相同数据和方法的一组对象的描述或定义。
  • 对象:对象是一个类的实例。
  • 实例(instance):一个对象的实例化实现。
  • 实例属性(instance attribute):一个对象就是一组属性的集合。
  • 实例方法(instance method):所有存取或者更新对象某个实例一条或者多条属性的函数的集合。
  • 类属性(classattribute):属于一个类中所有对象的属性,不会只在某个实例上发生变化
  • 类方法(classmethod):那些无须特定的对象实例就能够工作的从属于类的函数。

类概述

Python中,定义类是通过class关键字:

  1. class Student(object):
  2.     pass

class后面紧接着是类名,即Student,类名通常是大写开头的单词,紧接着是(object),表示该类是从哪个类继承下来的。通常,如果没有合适的继承类,就使用object类,这是所有类最终都会继承的类。

定义好了Student类,就可以根据Student类创建出Student的实例,创建实例是通过类名+()实现的:

  1. >>> bart = Student()
  2. >>> bart
  3. <__main__.Student object at 0x10a67a590>
  4. >>> Student
  5. <class '__main__.Student'>

可以看到,变量bart指向的就是一个Student的object,后面的0x10a67a590是内存地址,每个object的地址都不一样,而Student本身则是一个类。

可以自由地给一个实例变量绑定属性,比如,给实例bart绑定一个name属性:

  1. >>> bart.name = 'Bart Simpson'
  2. >>> bart.name
  3. 'Bart Simpson'

由于类可以起到模板的作用,因此,可以在创建实例的时候,把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的init方法,在创建实例的时候,就把name,score等属性绑上去。

  1. class Student(object):
  2.     def __init__(self, name, score):
  3.         self.name = name
  4.         self.score = score

注意到init方法的第一个参数永远是self,表示创建的实例本身,因此,在init方法内部,就可以把各种属性绑定到self,因为self就指向创建的实例本身。

有了init方法,在创建实例的时候,就不能传入空的参数了,必须传入与init方法匹配的参数,但self不需要传,Python解释器自己会把实例变量传进去:

  1. >>> bart = Student('Bart Simpson', 59)
  2. >>> bart.name
  3. 'Bart Simpson'
  4. >>> bart.score
  5. 59

和普通的函数相比,在类中定义的对象函数(还有静态方法,类方法)只有一点不同,就是第一个参数永远是实例变量self,并且,调用时不用传递该参数。

新式类、旧式类

python的新式类是2.2版本引进来的,之前的类叫做经典类或者旧类。Python 2.x 中如果一个类继承于一个基类(可以是自定义类或者其它类)或者继承自 object,则该类为新式类;没有继承的类为经典类。Python 3.x 则全部为新式类。

新式类被赋予了很多新的特性(如:统一了types和classes),并改变了以往经典类的一些内容(如:改变了多继承下方法的执行顺序)。

关于统一类(class)和类型(type),具体看下面的例子

  1. class OldClass():
  2.     pass
  3. o = OldClass()
  4. print o.__class__   # __main__.OldClass
  5. print type(o)       # <type 'instance'>
  6. class newClass(object):
  7.     pass
  8. n = newClass()
  9. print n.__class__   # <class '__main__.newClass'>
  10. print type(n)       # <class '__main__.newClass'>

对象属性

Python 中对象的属性包含对象的所有内容:方法和数据,注意方法也是对象的属性。查找对象的属性时,首先在对象的__dict__ 里面查找,然后是对象所属类的dict,再往后是继承体系中父类(MRO解析)的dict,任意一个地方查找到就终止查找,并且调用 __getattribute__(也有可能是__getattr__) 方法获得属性值。

方法

在 Python 类中有3种方法,即静态方法(staticmethod),类方法(classmethod)和实例方法:

  • 对于实例方法,在类里每次定义实例方法的时候都需要指定实例(该方法的第一个参数,名字约定成俗为self)。这是因为实例方法的调用离不开实例,我们必须给函数传递一个实例。假设对象a具有实例方法 foo(self, *args, **kwargs),那么调用的时候可以用 a.foo(*args, **kwargs),或者 A.foo(a, *args, **kwargs),在解释器看来它们是完全一样的。
  • 类方法每次定义的时候需要指定类(该方法的第一个参数,名字约定成俗为cls),调用时和实例方法类似需要指定一个类。
  • 静态方法其实和普通的方法一样,只不过在调用的时候需要使用类或者实例。之所以需要静态方法,是因为有时候需要将一组逻辑上相关的函数放在一个类里面,便于组织代码结构。一般如果一个方法不需要用到self,那么它就适合用作静态方法。

具体的例子如下:

  1. def foo(x):
  2.     print "executing foo(%s)"%(x)
  3. class A(object):
  4.     def foo(self):
  5.         print "executing foo(%s)" % self
  6.     @classmethod
  7.     def class_foo(cls):
  8.         print "executing class_foo(%s)" % cls
  9.     @staticmethod
  10.     def static_foo():
  11.         print "executing static_foo()"
  12. a = A()
  13. print a.foo
  14. print A.foo
  15. print a.class_foo
  16. print A.class_foo
  17. print A.static_foo
  18. print a.static_foo
  19. print foo
  20. # <bound method A.foo of <__main__.A object at 0x10d5f90d0>>
  21. # <unbound method A.foo>
  22. # <bound method type.class_foo of <class '__main__.A'>>
  23. # <bound method type.class_foo of <class '__main__.A'>>
  24. # <function static_foo at 0x10d5f32a8>
  25. # <function static_foo at 0x10d5f32a8>
  26. # <function foo at 0x10d5f1ed8>

在访问类方法的时候有两种方法,分别叫做 未绑定的方法(unbound method) 和 绑定的方法(bound method):

  • 未绑定的方法:通过类来引用实例方法返回一个未绑定方法对象。要调用它,你必须显示地提供一个实例作为第一个参数,比如 A.foo。
  • 绑定的方法:通过实例访问方法返回一个绑定的方法对象。Python自动地给方法绑定一个实例,所以调用它时不用再传一个实例参数,比如 a.foo。

数据属性

下面创建了一个Student的类,并且实现了这个类的初始化函数"__init__":

  1. class Student(object):
  2.     count = 0
  3.     books = []
  4.     def __init__(self, name, age):
  5.         self.name = name
  6.         self.age = age

在上面的Student类中,count, books, name 和 age 都被称为类的数据属性,但是它们又分为类数据属性和实例数据属性。直接定义在类体中的属性叫类属性,而在类的方法中定义的属性叫实例属性。

首先看下面代码,展示了对类数据属性和实例数据属性的访问:

  1. Student.books.extend(["python""javascript"])
  2. print "Student book list: %s" %Student.books
  3. # class can add class attribute after class definition
  4. Student.hobbies = ["reading""jogging""swimming"]
  5. print "Student hobby list: %s" %Student.hobbies
  6. print dir(Student)
  7. # class instance attribute
  8. wilber = Student("Wilber", 28)
  9. print "%s is %d years old" %(wilber.name, wilber.age)
  10. # class instance can add new attribute
  11. "gender" is the instance attribute only belongs to wilber
  12. wilber.gender = "male"
  13. print "%s is %s" %(wilber.name, wilber.gender)
  14. # class instance can access class attribute
  15. wilber.books.append("C#")
  16. print wilber.books

通过内建函数dir(),或者访问类的字典属性__dict__,这两种方式都可以查看类或者实例有哪些属性。对于类数据属性和实例数据属性,可以总结为:

  • 类数据属性属于类本身,可以通过类名进行访问/修改;
  • 类数据属性也可以被类的所有实例访问/修改;
  • 在类定义之后,可以通过类名动态添加类数据属性,新增的类属性也被类和所有实例共有;
  • 实例数据属性只能通过实例访问;
  • 在实例生成后,还可以动态添加实例数据属性,但是这些实例数据属性只属于该实例;

再看下面的程序

  1. class Person:
  2.     name="aaa"
  3. p1=Person()
  4. p2=Person()
  5. p1.name="bbb"
  6. print p1.name  # bbb
  7. print p2.name  # aaa
  8. print Person.name  # aaa

上面程序中,p1.name="bbb"是实例调用了类变量,p1.name一开始是指向的类变量name="aaa",但是在实例的作用域里把类变量的引用改变了,就变成了一个实例变量。self.name不再引用Person的类变量name了。

  1. class Person:
  2.     name=[]
  3. p1=Person()
  4. p2=Person()
  5. p1.name.append(1)
  6. print p1.name  # [1]
  7. print p2.name  # [1]
  8. print Person.name  # [1]

特殊的类属性

对于所有的类,都有一组特殊的属性:

Python中类的全面分析(上)

通过这些属性,可以得到 Student类的一些信息,如下:

Python中类的全面分析(上)

 

数学建模教材(包括十大算法、matlab、lingo、spss、exce以及多种实例模型)
中国大数据生态图谱&大数据交易市场专题研究报告
MySQL必知必会
深入浅出数据分析(中文版)

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: