（八）python类与对象

一、面向对象：

  一种编程思想，即按照真实世界的思维方式构建软件系统。

二、类的定义：

  如果父类不写，就是直接继承object类（pass为例子保证代码完整性）

#coding=utf-8

class Car(object):
	#类体
	pass

三、创建对象：

  实体化类，创建对象。

#coding=utf-8

class Car(object):
	#类体
	pass

car = Car()

四、类的成员：

  实例变量代表是个体的，类变量是共有的。

五、 实例变量

  是对象个体特有的”数据”

#coding=utf-8

class Dog:
	def _init_(self, name, age):
		self.name = name #创建和初始化实例变量name
		self.age = age  #创建和初始化实例变量age

d = Dog('球球',2)
print('我们家狗狗名叫{0}，{1}岁了。'.format(d.name, d.age))

• def _ _init _ _（）方法是构造方法，构造方法用来初始化实例变量。注意： 是两个下划线。
• Dog：创建对象
• d.name: 对实例变量通过"对象 . 实例变量“的形式访问。

六、构造方法：

  创建和初始化实例成员变量

class Dog:
	def _init_(self, name, age, sex='雌性'）:
		self.name = name  #创建和初始化实例变量name
		self.age = age    #创建和初始化实例变量age
		self.sex = sex    #创建和初始化实例变量sex

d1 = Dog('球球',2)
d2 = Dog('哈哈',1,'雄性')
d3 = Dog(name='拖布',sex='雄性', age=3)

print('{0}: {1}岁{2}。'.format(d1.name,d1.age,d1.sex))
print('{0}: {1}岁{2}。'.format(d2.name,d2.age,d2.sex))

• self不需要传递

七、实列方法：

  与实例变量一样，都是某个示例（或对象）个体特有的方法。

class Dog:
#构造方法
	def __init_(self, name, age, sex='雄性):
		self.name = name #创建和初始化实例变量name
		self.age = age  #创建和初始化实例变量age
		self.sex =sex  #创建和初始化实例变量sex

	#实例方法
	def run(self):
		print("{}在跑...".format(self.name))

	#实例方法
	def speak(self,sound):
		print('{}在叫,"{}"!'.format(self.name,sound))

dog = Dog(球球',2)
dog.run()
dog.speak('旺旺旺')

八、类变量：

  属于类的变量，不属于单个对象；调用类变量要通过类名进行调用。

class Account:
	interest_rate = 8.0568  #类变量利率interest_rate

	def _init_(self,owner,amount):
		self.owner = owner    #创建并初始化实例变量owner
		self.amount = amount  #创建并初始化实例变量amount

account = Account('Tony',800000.0)

print('账户名: {0}'.format(account.owner))
print('账户金额:{0}'.format(account.amount))
print('利率: {0}'.format(Account.interest_rate))

• account . owner :对实例变量通过”对象 . 实例变量“形式访问
• Account . interest_rate : 对类变量通过”类名 . 类变量“形式访问

九、类方法：

  与类变量类似，属于类，不属于个体实例

class Account:
	interest_rate = 0.0668  #类变量利率

	def _init_(self, owner, amount):
		self.owner = owner  #定义实例变量账户名
		self.amount = amount  #定义实例变量账户金额

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

interest = Account.interest_by(12000.0)
print('计算利息：{0：.4f}'.format(interest))

• @classmethod: 为装饰器

十、封装性

1.封装：

  封装隐藏了对象的内部细节，只保留有限的对外接口，外部调用者不用关心对象的内部细节，使的操作变得简单。

2.私有变量

• 为了防止外部调用者随意存取类的内部数据（成员变量），内部数据（成员变量）会被封装为”私有变量“。
• 私有变量： 在变量前加上双下划线 _ _

class Account:
	_interest_rate = 0.0568  #类变量利率_interest_rate

	def -init-(self, owner, amount):
		self.owner = owner  #创建并初始化共有实例变量owner
		self._amount = amount  #创建并初始化私有实例变量_amount

	def desc(self):
		return "{0} 金额：{1} 利率：{2}。".format(self.owner, self._amount, Account._interest_rate)

3.私有方法

• 私有方法与私有变量的封装是类似的
• 私有方法：在方法前加上双下划线 _ _

class Account:
	_interest_rate = 0.0568  #类变量利率_interest_rate

	def _init_(self, owner, amount):
		self.owner = owner  #创建并初始化公有实例变量owner
		self._amount = amount  #创建并初始化私有实例变量_amount
	
	def _get_info(self):
		return "{0} 金额：{1} 利率：{2}。".format(self.owner, self._amoount, self._interest_rate)

	def desc(self):
		print(self._get_info())

4.使用属性

  为了实现对象的封装，在一个类中不应该有公有的成员变量，这些成员变量应该被设计为私有的，然后通过公有的set（赋值）和get（取值）方法访问。

class Dog:

	#构造方法
	def__init__(self, name, age, sex="雌性"):
		self.name = name  #创建和初始化实例变量name
		self._age = age  #创建和初始化私有实例变量_age

	#实例方法
	def run(self):
		print("{}在跑...".format(self.name))

	@property
	def age(self):  #替代get_age(self):
		return self._age
	
	@age.setter
	def age(self, age):    #替代set_age(self,age)
		self._age = age
	
dog =Dog('球球',2)
print('狗狗年龄:{}'.format(dog.age))
dog.age =3   #dog.set_age(3)
print('修改后狗狗年龄:{}'.format(dog.age))

• self._age: ;私有变量_ age，对应的属性名应该去除前面 的双下划线之后的名称，即age
• def age (self): 定义age属性的get（）方法，使用@property装饰器进行修饰，方法名就是属性名，即age
• def age(self,age): 定义age属性的set（）方法，使用@age.setter装饰器进行修饰，age是属性名。
• .format(dog.age) : 通过属性取值，访问形式为“实例 . 属性”

十一、继承性

1.父类&子类

  一般类称之为父类，特殊类被称为子类。

2.多继承：

  一个子类可以有多个父类。

class Horse:
	def _init_(self, name):
		self.name = name   #实例变量name

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

	def run(self):
		print("马跑...")

class Donkey :
	def __init_(self,name):
		self.name = name   #实例变量name
		
    def show_info(self):
		return "驴的名字:{0}".format(self.name)

	def run(self):
		print("驴跑...")
	
	def rol1(self):
		print("驴打滚...")

class Mule(Horse，Donkey) :
	def __init_(self,name, age):
		super()._init_(name)
		self.age = age   #实例变量age

m = Mule(“骡宝莉"，1)
m.run()   #推承父类Horse方法
m.ro11()  #继承父类Donkey方法
print(m.show_info())   #继承父类Horse方法

• 方法重写

def show_info(self):
	return "骡：{0}，{1}岁。".format(self.name, self.age)

3.多态性：

  对象可以表现多种形态。

4.继承与多态

  在多个子类继承父类，并重写父类方法后，这些子类所创建的对象之间就是多态。这些对象采用不同方式实现父类方法。

class Animal:
	def speak(self):
	print('动物叫,但不知道是哪种动物叫!')

class Dog(Animal):
	def speak(self):
		print(小狗:旺旺叫...')

class Cat(Animal):
	def speak(self):
	print('小猫:瞄瞄叫...')

an1 = Dog()
an2 = Cat()
an1.speak()
an2.speak()

  python解释器不检查发生多态的对象是否继承了同一个父类，只要他们有相同的行为（方法），他们之间就是多态。

#1.设计一个函数start（），它接收具有“叫”speak（）方法的对象：
def start(obj)  #
	obj.speak()

#2.定义了几个类，他们都有speak（）方法
class Animal:
	def speak(self):
		print('动物叫，但不知道是哪种动物叫！')

class Dog(Animal):
	def speak(self)
		print('小狗：汪汪叫...')

class Cat(Animal):
	def speak(self)
		print('小猫：喵喵叫...')

class Car:
	def speak(self)
		print('小汽车：滴滴叫...')

#3.start()可以接收所有speak（）方法对象。
start(Dog())
start(Cat())
start(Car())