面向对象编程是一种程序设计思想，把对象作为程序的基本单元，一个对象里面包含了数据以及操作数据的方法，称为类的属性和方法。
基础-定义、实例化、实例属性
用class来定义对象，类名首字母大写，如果这个类没有父类，则参数使用object类（object可以省略不写）；如果这个类有父类，参数就是父类的名称。可以用一个特殊的方法__init()__方法来对类的属性进行定义。第一个参数固定是self，但是在创建实例的时候self是不需要传入的，self表示实例本身。类中还可以定义方法。第一个参数也是self，后面的参数和普通函数一样。要调用一个方法，只需要在实例变量上直接调用，除了self不用传递，其他参数正常传入。通过实例.方法的方式进行调用。
class Person(object): def __init__(self, name, age): self.name = name self.age = age def print_age(self): print('%s: %s' % (self.name, self.age))
>>>tt = Person('taoting',23) >>>tt.print_age() tt:23
在类定义中我们可以随时为类增加方法，而外部的代码不需要做改变。因此，面向对象的编程时非常方便进行扩展的。
方法中带外部参数的类示例：
注意区别：name和age参数是类固有的属性，在定义实例时就需要传入，而city是实例的方法的参数，只有调用类的方法时才传入
class Person(object): def __init__(self, name, age): self.name = name self.age = age def print_age(self, city): print('name: %s age: %s city: %s' % (self.name, self.age, city)) tt = Person('taoting',23) tt.print_age('shanghai') #结果：name: taoting age: 23 city: shanghai
类属性
类属性是直接在class中定义的属性，归类所有，类的所有属性都能访问。
class Person:
count = 0
def __init__(self, name, age):
self.name = name
self.age = age
Person.count = Person.count + 1 tt = Person('taoting', 23) print(tt.count)#1
访问权限
在实例中传入的参数是可以通过实例名.参数名进行修改的。有时我们想让内部的一些属性不被外部访问，就可以在属性名称前加上两个下划线__，将属性编程一个私有变量，外部无法访问。
class Person(object): def __init__(self, name, age): self.__name = name self.__age = age tt = Person('taoting',23) tt.__name #报错：AttributeError: 'Person' object has no attribute '__name'
那么要想在外部代码中访问内部的name和age变量怎么办呢？
答案：在类中增加方法，在方法中返回变量值。这样就确保了外部不能随便修改变量值，但还能访问到。
class Person(object): def __init__(self, name, age): self.__name = name self.__age = age def get_name(self): return self.__name def get_age(self): return self.__age tt = Person('taoting',23) print(tt.get_name()) #结果：taoting
进一步地，还是有办法能够修改变量值：通过在类中定义方法将要修改的值传入并赋值给__开头的变量：
class Person(object): def __init__(self, name, age): self.__name = name self.__age = age def set_name(self, name): self.__name = name return self.__name def set_age(self, age): self.__age = age return self.__age tt = Person('taoting',23) print(tt.set_name('tt')) #结果：tt print(tt.set_name(18)) #结果：18
通过先设置不能外部修改，再定义供外部程序修改的方法的方式，能够在方法中对参数做检测、处理、等等。
@property （静态属性） 还可以将一个方法变成一个属性，在调用的时候像调用一个属性一样，不需要加括号。相当于将一个方法进行了封装，调用者不会发现背后的逻辑。静态属性可以访问类属性和实例属性。我们可以在方法里面对属性进行判断，也可以将属性设置成可读可写和只可读：
#width、height和area方法通过@property变成了类的属性。 #width、height可以读和写，而area只读 class Area(object): @property def width(self): return self._width @width.setter def width(self,value): self._width = value @property def height(self): return self._height @height.setter def height(self,value): self._height = value @property def area(self): return self._width * self._height a = Area() a.width = 10 a.height = 8 print(a.area)#80 a.area = 100#AttributeError: can't set attribute #在可写的属性里面我们可以对传入的值进行检查 class Area(object): @property def width(self): return self._width @width.setter def width(self,value): if value < 0: raise ValueError('width must be greater than 0!') self._width = value @property def height(self): return self._height @height.setter def height(self,value): self._height = value @property def area(self): return self._width * self._height a = Area() a.width = -5#ValueError: width must be greater than 0!
对于实例化的对象，我们可以定义类的没有定义的属性，比如上例中，我们可以定义：a.length = 6。只对本实例化对象有效。
那么，在类中我们可以指定实例化对象中能够定义的属性，用__slots__实现：
class Area(object): __slots__ = ('name','color') @property def width(self): return self._width @width.setter def width(self,value): if value < 0: raise ValueError('width must be greater than 0!') self._width = value @property def height(self): return self._height @height.setter def height(self,value): self._height = value @property def area(self): return self._width * self._height a = Area() a.name = 'a' a.length = 6#AttributeError: 'Area' object has no attribute 'length'
当为实例新建一个属性时就会报错。a.length就是调用了setattr方法，也就是a.__dict__['length'] = 6。而定义了__slots__之后，实例就没有__dict__方法了，因此会报错。那么意味着__slots__指定了实例的所有属性。
这种方式的好处在于能够节省内存，当我们创建成千上万个实例时，如果不用__slots__，那么python会为每个实例创建一个属性字典，这样非常占用内存空间。当我们定义__slots__后，__slots__就会为实例使用一种更加紧凑的内部表示。实例通过一个很小的固定大小的数组来创建，而不是为每个实例定义一个属性字典。
@classmethod（类方法）可以定义只跟类相关的操作，定义不用实例化即可调用的函数。cls表示跟类绑定，是固定的参数。类方法可以访问类的数据属性和函数属性，但是不能访问实例的数据属性和函数属性。
class Person: tag = 2 def __init__(self, name, age): self.name = name self.age = age #将方法属性化，只跟类有关，不用实例化,cls就是类本身 @classmethod def attr(cls): print(cls.tag) Person.attr()#这样调用就可以做一些只跟类有关的操作
@staticmethod（静态方法），类的工具包，跟类没关系，也跟实例没关系。只是名义上属于类管理，但是不能访问类属性和实例属性。
class Person: def __init__(self, name, age): self.name = name self.age = age @staticmethod def run(a,b): print('%s and %s are runing...' % (a,b)) Person.run('tt','rr')#类可以直接调用 p1 = Person('tt',18)#实例也可以调用 p1.run('tt','rr')
继承
类的继承类似于动物-->猫的关系，猫是属于动物的，猫具有动物的特征。
在类的继承里，子类继承父类的属性和方法。父类又称为基类、超类
class Person(object): def __init__(self, name, age): self.name = name self.age = age def run(self): print('Person is runing...') print('name: %s age: %s' % (self.name, self.age)) def attr(self): print('This is a super method!') class Male(Person): def run(self): print('Male is runing...') print('name: %s age: %s' % (self.name, self.age)) tt = Person('taoting', 23) tt.run() #结果： #Person is runing... #name: taoting age: 23 ZL = Male('zhaoliang', 26) ZL.run() #结果： #Male is runing... #name: zhaoliang age: 26 ZL.attr() #结果：This is a super method!
从以上代码我们可以看到：
1.子类可以直接继承父类的属性和方法
2.当父类和子类中有相同的方法时，子类调用方法时优先在子类中搜索，所以上面子类调用run方法时，是调用的子类里面的run方法，而不是父类里面的
实例对象之间的交互
在面向对象的编程中，就是大量的实例对象之间的交互。
我们创建两个类Alien和Automan，再分别实例出两个角色：alien1和automan1，来模拟两者之间的交互。
class Alien: def __init__(self, name, life_value = 500): self.name = name self.life_value = life_value def attack(self, enemy): enemy.life_value -= 50 class Automan: def __init__(self, name, life_value = 1000): self.name = name self.life_value = life_value def attack(self, enemy): enemy.life_value -= 10 alien1 = Alien('怪兽') automan = Automan('迪迦') print(alien1.life_value)#500 print(automan.life_value)#1000 automan.attack(alien1) print(alien1.life_value)#450 print(automan.life_value)#1000
类的组合
在一个类中我们可以实例化另外一个类，作为这个类的属性，这叫类的组合：
class F1: def f1(self): print('F1.f1') class F2: def __init__(self): self.ff2 = F1() def f1(self): print('F2.f1') c1 = F2() c1.ff2.f1()#F1.f1
582
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
