一面向对象

类和对象都是面向对象重要的概念。面向对象是一种变成思想，即按照真实世界思维方式构建软件系统。

二定义类

python中的数据类型都是类，我们可以自定义类，即创建一种新的数据类型。
class Car(object):
#类体
pass

三创建对象

类相当于一个模板，依据这样的模板创建对象，就是类的实例化。
class Car(object):
#类体
pass
car = Car()

四类的成员

类的成员：
1.成员变量，保存了类或对象的数据
2.构造方法：用于初始化成员变量
3.成员方法：在类中定义函数
4.属性：对类进行封装提供的特殊的方法

4.1实例变量

init（）是构造方法，构造方法用来初始化实例变量。

class Dog:
def init(self,name,age):
self.name = name
self.age = age

d = Dog(‘球球’,2)

4.2构造方法

init（）是构造方法，第一个参数应该是self，之后的参数用来初始化实例变量。
class Dog:
def init(self,name,age,sex=“雌性”):
self.name = name
self.age = age
self.sex = sex

d1 = Dog(‘球球’,2)
d2 = Dog(‘大黄’,2,“雄性”)
d3 = Dog(name=‘小黑’,sex=“雄性”,age=2)
print(“{0}:{1}岁{2}”.format(d1.name,d1.age,d1.sex))
print(“{0}:{1}岁{2}”.format(d2.name,d2.age,d2.sex))
print(“{0}:{1}岁{2}”.format(d3.name,d3.age,d3.sex))

4.3实例方法

实例方法与实例变量一样，都是实例某个个体特有的方法。

4.4类变量

类变量是共享的变量，它属于类，不属于单个对象。

4.5类方法

类方法与类变量类似，属于类，不属于单个个体。
注意：定义类方法需要装饰器，装饰器以@开头 修饰函数 、方法和类，用来约束它们。
class Account:
interest_rate = 0.012 # 类利率
def init(self,owner,amount):
self.owner = owner
self.amount = amount

#类方法
@classmethod 
def interest_by(cls,amt):
	return cls.interest_rate*amt
1
2
3
4

interest = Account.interest_by(12000.0)

print(“计算利息：{0}”.format(interest))

五封装性

封装性是面向对象重要的基本特征之一，封装性隐藏了对象的内部细节，只保留有限的对外接口，外部调用者不用关心对象的内部细节，使得操作对象变的简单。

5.1私有变量

为了防止外部调用者随意存取类的内部数据，内部数据会被封装成“私有变量”。
在默认情况下，python的变量默认为共有的。如果想让他们成为私有的变量，在前面加上双__

后两句错误会发生，在类的内部可以访问私有变量，在外部不可以。

5.2私有方法

私有方法与私有变量类似，在方法前加上__就是私有方法啦。

5.3使用属性

为了实现对象的封装，在一个类中不应该有共有的成员变量。这些成员变量应该被设计为私有的，然后通过公有的set赋值 和get取值：
class Dog:
#构造方法
def init(self,name,age,sex=“雌性”):
self.name = name
self.__age = age
self.sex = sex
#实例方法
def run(self):
print(“{0}再跑******”.format(self.name))
#get方法
def get_age(self):
return self.__age
#set方法
def set_age(self,age):
self.__age = age
dog = Dog(‘球球’,2)
print(“狗狗年龄：{}”.format(dog.get_age()))
dog.set_age(3)
print(“修改后狗狗的年龄：{}”.format(dog.get_age()))

在上面的事例中，当外部调用者通过两个公有方法 访问被封装的私有成员变量时，会比较麻烦，有没有更好的办法？
我们可以在类中定义属性，属性可以代替get()和set()这两个方法。

定义age属性的get方法@property 装饰器进行修饰，方法名就是属性名

可以通过属性取值，访问形式为实例.属性

六继承性

6.1继承

继承性也是面向对象重要的特征之一。
在面向对象中，动物是一般的类。猫是特殊的类，被称为"子类"。特殊的类拥有一般类的全部的数据和操作，可以称为子类继承父类。
class Animal:
def init(self,name):
self.name = name

def show_info(self):
	return("动物的名字：{0}".format(self.name))

def move(self):
	print("动一动****")
1
2
3
4
5

class Cat(Animal):

def __init__(self,name,age):
	super().__init__(name)#调用父类的构造方法，初始化父类的成员变量
	self.age = age #实例变量
1
2
3

cat = Cat(“Tom”,2)
cat.move()
print(cat.show_info())

在子类构造方法中会调用父类构造方法，这个过程有些复杂，能解释一下吗？
构造方法的作用是初始化类的实例成员变量，在初始化子类时，也初始化父类的实例成员变量。
在创建cat时调用Cat类构造方法，调用父类的构造方法，初始化父类的实例成员变量，初始化子类的实例成员变量。

6.2多继承

在python中，当子类继承多个父类时，如果在多个父类中有相同的成员方法或变量，则子类优先继承左边父类的成员方法或变量：
class Horse:
def init(self,name):
self.name = name #实例变量 name

def show_info(self):
	return "马的名字：{0}".format(self.name)

def run(self):
	print("马跑")
1
2
3
4
5

class Donkey:
def init(self,name):
self.name = name
def show_info(self):
return “驴的名字：{0}”.format(self.name)

def run(self):
	print("驴跑***")
	
def roll(self):
	print("驴打滚***")
1
2
3
4
5

class Mule(Horse,Donkey):
def init(self, name,age):
super().init(name)
self.age =age

m = Mule(“骡子A”,1)
m.run() #继承父类Horse 的方法
m.roll() #继承父类Donkey的方法
print(m.show_info())#继承父类Horse 的方法

6.3方法重写

如果子类的方法名与父类的方法名重名，则在这种情况下，子类的方法会重写父类的同名方法。
class Horse:
def init(self,name):
self.name = name #实例变量 name

def show_info(self):
	return "马的名字：{0}".format(self.name)

def run(self):
	print("马跑")
1
2
3
4
5

class Donkey:
def init(self,name):
self.name = name
def show_info(self):
return “驴的名字：{0}”.format(self.name)

def run(self):
	print("驴跑***")
	
def roll(self):
	print("驴打滚***")
1
2
3
4
5

class Mule(Horse,Donkey):
def init(self, name,age):
super().init(name)
self.age =age

def show_info(self):
	return "驴的名字：{0},{1}岁".format(self.name,self.age)
1
2

m = Mule(“骡子A”,1)
m.run() #继承父类Horse 的方法
m.roll() #继承父类Donkey的方法
print(m.show_info())#调用子类mule自己的方法