1、定义类
定义类的语法:
class 类名 [(父类)]:
类体
2、构造方法
__init__() #定义__init__()方法时，它的第一个参数应该是self，之后的参数用来初始化实例变量。调用构造方法时不需要传入self参数
示例代码:
class Dog:
def __init__(self, name, age, sex='雌性'): #构造方法
self.name = name
self.age = age
self.sex = sex
def __str__(self):
return f'{self.name}, {self.age}岁, {self.sex}'
d1 = Dog('球球', 2) #创建对象并调用构造方法
d2 = Dog('贝贝', 3, '雄性')
d3 = Dog(name='黑子', sex='雄性', age='4')
print(d1)
print(d2)
print(d3)
3、实例变量
示例代码:
class Dog:
def __init__(self, name, age, sex='雌性'):
self.name = name #初始化实例变量name
self.age = age #初始化实例变量age
self.sex = sex #初始化实例变量sex
4、实例方法
示例代码:
class Dog:
def __init__(self, name, age, sex='雌性'):
self.name = name
self.age = age
self.sex = sex
def run(self): #定义实例方法，只有一个self参数
print("{}在跑".format(self.name))
def speak(self, sound): #定义实例方法，第1个参数是self,第2个参数是sound
print("{}在叫".format(self.name, sound))
d1 = Dog('贝贝', 2) #创建对象并调用构造方法
d1.run() #调用时采用“对象.实例方法”形式，不需要传递参数
d1.speak('旺、旺、旺') #传递第一个参数sound
5、类变量
类变量是属于类的变量，不属于单个对象
实例代码：
class Account:
interest_rate = 0.43 #定义类变量
def __init__(self, ower, amount):
self.ower = ower
self.amount = amount
account = Account('Tony', 6666)
print("账户名：{0}".format(account.ower)) #对实例变量，通过“对象.实例变量”形式访问
print("金额：{0}".format(account.amount)) #对实例变量，通过“对象.实例变量”形式访问
print("利率：{0}".format(Account.interest_rate)) #对类变量，通过“类名.类变量”形式访问
6、类方法
类方法和类变量相似，都属于类，不属于个体实例。定义类方法时，它的第一个参数不是self，而是类本身。
示例代码：
class Account:
interest_rate = 0.43
def __init__(self, owner, amount):
self.owner = owner
self.amount = amount
@classmethod
def interest_by(cls, amt): #cls代表类自身
return cls.interest_rate * amt
interest = Account.interest_by(10000) #对类方法可以通过“类名.类方法”形式访问
print("计算的利息：{}".format(interest))
7、私有变量
变量前加上双下划线(__)即可
示例代码：
class Account:
__interest_rate = 0.48 #定义私有类变量
def __init__(self, owner, amount):
self.owner = owner
self.__amount = amount #初始化私有实例变量
account = Account('Tony', 6666)
print("账户名：{0}".format(account.owner))
print("账户金额：{0}".format(account.__amount)) #报错。原因：不可以访问私有变量
print("利率：{0}".format(account.__interest_rate)) #报错。原因：不可以访问私有变量
8、私有方法
私有方法和私有变量的封装是一样的，在方法前加上双下划线(__)就是私有方法了。
示例代码：
class Account:
__interest_rate = 0.48 #定义私有变量
def __init__(self, owner, amount):
self.owner = owner #初始化实例变量
self.__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', 6666)
account.__get_info() #报错，原因：类的外部不能调用私有方法
account.desc()
9、使用属性
class Dog:
def __init__(self, name, age, sex='雌性'):
self.name = name
self.__age = age #初始化私有化实例变量
def get_age(self): #定义get()方法。返回私有实例变量__age
return self.__age
def set_age(self, age): #定义set()方法，通过age参数更新私有实例变量__age
self.__age = age
dog = Dog('贝贝', 2)
print('狗狗的年龄：{}'.format(dog.get_age()))
dog.set_age(3)
print('修改后的狗狗年龄：{}'.format(dog.get_age()))
-----------------------------------------------------------
class Dog:
def __init__(self, name, age, sex='雌性'):
self.name = name
self.__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 #通过属性赋值，访问形式为“对象.属性”
print('修改后的狗狗年龄：{}'.format(dog.age))
10、继承性
声明子类继承父类，语法很简单，定义类时在类的后面使用一对小括号指定它的父类就可以了。不过，只能继承公有的成员变量和方法。
示例代码：
class Animal:
def __init__(self, name):
self.name = name
def show_info(self):
return "动物的名称：{0}，年龄：{1}".format(self.name, self.age)
class Cat(Animal):
def __init__(self, name, age):
super().__init__(name) #调用父类的构造方法，初始化父类的成员变量
self.age = age #初始化子类的实例成员变量age
cat = Cat('Tom', 3) #创建对象并调用构造方法
print(cat.show_info())
11、多继承
当子类继承多个父类时，如果在多个父类中有相同的成员方法或成员变量时，则子类优先继承左边父类的成员方法或成员变量，从左到右继承级别从高到底
实例代码：
class Horse:
def __init__(self,name):
self.name = name
def show_info(self):
return "马的名字：{0}".format(self.name)
def run(self):
print("马跑...")
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("驴打滚...")
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()方法
12、重写方法
如果子类的方法名和父类的方法名相同，则在这种情况下，子类的方法会重写(override)父类的同名方法
实例代码：
class Horse:
def __init__(self,name):
self.name = name
def show_info(self):
return "马的名字：{0}".format(self.name)
def run(self):
print("马跑...")
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("驴打滚...")
class Mule(Horse, Donkey):
def __init__(self, name, age):
super().__init__(name) #调用父类的构造方法，初始化父类的成员变量
self.age = age #初始化子类的实例成员变量age
def show_info(self): #重写父类的show_info()方法
return "骡的名字：{0}，年龄：{1}".format(self.name, self.age)
m = Mule('骡宝莉', 1)
m.run() #继承父类的Horse()方法
m.roll() #继承父类的Donkey()方法
print(m.show_info())
13、继承与多态
在多个子类继承父类并重写父类的方法后，这些子类所创建的对象之间就是多态的。这些对象采用不用的方式实现父类的方法
示例代码：
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()
14、鸭子类型测试与多态
鸭子类型测试指：若看到一只鸟走起来像鸭子，游起来像鸭子，叫起来也像鸭子，那么这只鸟可以被称为鸭子
python解释器不检查发生多态的对象是否继承了同一个父类，只要它们有相同的行为(方法)。它们之间就是多态的
示例代码：
def start(obj): #接收的obj对象具有的speak()方法
obj.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('小车：嘀嘀嘀...')
start(Dog())
start(Cat())
start(Car())
发表回复