活动地址：CSDN21天学习挑战赛
举个例子来理解一下类与对象
类：大学
对象：清华大学、北京大学、浙江大学…
面对对象介绍
面对对象是一种编程思想，即按照真实世界的思维方式构建软件系统。
定义类、创建对象
class 类名[(父类)]:
类体
父类可省略。
例：
# Car是类
class Car(object):
# 类体
pass
car = Car() # car是对象
类的成员
成员对象
- 实例变量
就是对象个体特有的 ’ 数据 ‘ ，例：人的名字和年龄
class People:
def __init__(self,name,age):
self.name = name # 创建和初始化实例变量name
self.age = age # 创建和初始化实例变量age
people = People("张三",27)
print('{0}:{1}岁'.format(people.name,people.age))
- 类变量
类变量属于类的变量，不属于单个对象。
class Account:
interest_rate = 0.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))
构造方法
类中的__init__()方法是一个特殊的方法，用来创建和初始化实例变量
注意：是左右两个下划线 _
class People:
def __init__(self,name,age):
self.name = name # 创建和初始化实例变量name
self.age = age # 创建和初始化实例变量age
成员方法
1. 实例方法
实例方法与实例变量一样，都是某个实例（或对象）个体特有的方法。
class People:
# 构造方法
def __init__(self,name,age):
self.name = name # 创建和初始化实例变量name
self.age = age # 创建和初始化实例变量age
# 实例方法
def run(self):
print('{}'.format(self.name))
people = People("张三",27)
people.run()
- 类方法
类方法与类变量类似，属于类，不属于个体实例。
class Account:
interest_rate = 0.0568 # 类变量利率interest_rate
def __init__(self,owner,amount):
self.owner = owner # 创建和初始化实例变量owner账户名
self.amount = amount # 创建和初始化实例变量amount账户金额
# 类方法
@classmethod
def interest_by(cls,amt):
return cls.interest_rate * amt
interest = Account.interest_by(12000.0)
print('计算利息：{0：.4f}'.format(interest))
属性（property）
封装性
封装隐藏了对象的内部细节，只保留有限的对外接口，外部调用者不用关心对象的内部细节，使得操作对象变得简单。
- 私有变量
为了防止外部调用者随意存取类的内部数据（成员变量），内部数据（成员变量）会被封装为 “ 私有变量 ”。
私有变量，则在变量前会加上双下划线__
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)
account = Account('Tony',800000.0)
account.desc()
print('账户名：{0}'.format(account.owner))
print('账户金额：{0}'.format(account.__amount)) # 错误
print('利率：{0}'.format(Account.__interest_rate)) # 错误
- 私有方法
私有方法与私有变量的封装是类似的，在方法前加上双下划线 __ 就是私有方法了。
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.__amount,Account.__interest_rate)
def desc(self):
print(self.__get_info())
account = Account('Tony',800000.0)
account.desc()
account.__get_info() # 错误
- 使用属性
为了实现对象的封装，在一个类中不应该有公有的成员变量，这些成员变量应该被设计为私有的，然后通过公有的set（赋值）和get（取值）方法访问。
class People:
# 构造方法
def __init__(self,name,age):
self.name = name # 创建和初始化实例变量name
self.__age = age # 创建和初始化实例变量age
# 实例方法
def run(self):
print('{}'.format(self.name))
# get方法
def get_age(self):
return self.__age
# set方法
def set_age(self,age):
self.__age = age
people = People("张三",27)
print('修改前的年龄：{}'.format(people.get_age()))
people.set_age(30)
print('修改后的年龄：{}'.format(people.get_age()))
改进：
class People:
# 构造方法
def __init__(self,name,age):
self.name = name # 创建和初始化实例变量name
self.__age = age # 创建和初始化实例变量age
# 实例方法
def run(self):
print('{}'.format(self.name))
# get方法
@property
def age(self): # 替代get_age(self)
return self.__age
# set方法
@age.setter
def age(self,age): # 替代set_age(self,age)
self.__age = age
people = People("张三",27)
print('修改前的年龄：{}'.format(people.age))
people.age = 30 # people.set_age(30)
print('修改后的年龄：{}'.format(people.age))
私有变量__age，对应的属性名应该去除前面双下画线之后的名称，即age
.
定义age属性的get()方法，使用@property装饰器进行修饰，方法名就是属性名，即age
.
定义age属性的set()方法，使用@age。setter装饰器进行修饰，age是属性名
继承性
- 继承性也是面对对象重要的基本特征之一。在现实世界中继承关系无处不在。
- 在面对对象中的一般类，被称为 “ 父类 ”；特殊类，被称为 “ 子类 ”。特殊类拥有一般类的全部数据和操作，可称之为子类继承父类。
- Python中的继承
class Animal:
def __init__(self,name):
self.name = name # 实例变量name
def show_info(self):
return "动物的名字：{0}".format(self.name)
def move(self):
print("run run run")
class Cat(Animal):
def __init__(self,name,age):
super().__init__(name)
self.age = age # 实例变量age
cat = Cat('Tom',2)
cat.move()
print(cat.show_info())
- 多继承
class Horse:
def __init__(self,name):
self.name = name # 实例变量name
def show_info(self):
return "马的名字：{0}".format(self.name)
def run(self):
print("马：run run run")
class Donkey:
def __init__(self,name):
self.name = name # 实例变量name
def show_info(self):
return "馿的名字：{0}".format(self.name)
def run(self):
print("馿：run run run")
def roll(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.roll() # 继承父类Donkey方法
print(m.show_info()) # 继承父类Horse方法
- 方法重写
多态性
- 继承与多态
class Horse:
def __init__(self,name):
self.name = name # 实例变量name
def show_info(self):
return "马的名字：{0}".format(self.name)
def run(self):
print("马：run run run")
class Donkey:
def __init__(self,name):
self.name = name # 实例变量name
def show_info(self):
return "馿的名字：{0}".format(self.name)
def run(self):
print("馿：run run run")
def roll(self):
print("驴打滚")
class Mule(Horse,Donkey):
def __init__(self,name,age):
super().__init__(name)
self.age = age # 实例变量age
def show_info(self):
return "骡：{0},{1}岁。".format(self.name,self.age)
m = Mule('马宝丽',1)
m.run() # 继承父类Horse方法
m.roll() # 继承父类Donkey方法
print(m.show_info()) # 子类Mule自己方法
- 鸭子类型测试与多态
- 鸭子类型测试指：若看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟可以被称为鸭子。
- Python支持鸭子类型测试，Python解释器不检查发生多态的对象是否继承了同一个父类，只要它们有相同的行为（方法），它们之间就是多态的。
1、设计一个函数start()，它接收具有“叫”speak()方法的对象：
def start(obj): # 接收obj对象具有speak()的方法
obj.speak()
2、定义了几个类，它们都有speak()方法：
class Animal:
def speak(self):
print('谁在叫？')
class Dog(Animal):
def speak(self):
print('狗叫')
class Cat(Animal):
def speak(self):
print('猫叫')
3、start()可以接收所有speak()方法对象，代码如下：
start(Dog())
start(Cat())
本文含有隐藏内容，请 开通VIP 后查看