rt_01_类与对象.py
面向对象编程思想的基本单位:类与对象 类:具有相同特征和行为的一类事物的统称,理解成一张图纸,一个抽象的事物 对象:是根据类创建出来的具体存在的事物 结论:先有类,后有对象,对象是根据类创建出来的
需求:
洗衣机类:Washer
属性:宽度、高度、颜色、品牌
行为:wash,dry_water
# self关键字在定义类中的函数时,self会自动添加,在调用函数时self是不需要传参的
# self表示的就是当前根据类创建出的对象,就是其本身
# 新式类的定义
class Washer(object):
def wash(self):
"""洗衣服"""
print("washer-->",self)
print("洗衣机洗衣服。。。")
def dry_water(self):
"""洗衣机脱水"""
print("dry_water-->",self)
print("洗衣机脱水。。。")
if __name__ == '__main__':
# 根据类创建对象
haier = Washer()
# 输出当前对象在内存中的地址
print(haier)
haier.wash()
haier.dry_water()
# 再创建一台
# 可以根据类创建出多个不同的对象
xiaotianer = Washer()
print(xiaotianer)
xiaotianer.wash()
xiaotianer.dry_water()
输出:
rt_02_student类的设计.py
需求:
设计一个student类
属性:name,age,classes,address
方法:study,play_game
# 给对象添加属性的方式有两种:
# 1.在类的外部添加
# 2.在类的内部添加
class Student(object):
def study(self):
#print("好好学习,天天向上!")
print(f"{self.name}在{self.classes}班级好好学习,天天向上!")
def play_game(self):
print(f"{self.name}热爱生命,热爱游戏!")
if __name__ == '__main__':
xiaoming = Student()
# 在类的外部添加属性
xiaoming.name = "小明"
xiaoming.age = 18
xiaoming.classes = "Python"
print(xiaoming)
xiaoming.study()
xiaoming.play_game()
# 在类的外部给对象添加属性,属性仅仅属于当前对象
# 如果创建新的对象,也需要重新添加(不灵活,不推荐使用)
xiaoqiang = Student()
xiaoqiang.name = "小强"
xiaoqiang.age = 19
xiaoqiang.classes = "Java"
print(xiaoqiang)
xiaoqiang.study()
xiaoqiang.play_game()
输出:
rt_03_在类的内部添加属性.py
# 在类的内部添加属性
# 需要借助(重写)魔法函数init(构造方法)
class Student(object):
def __init__(self,name1,age1,classes1):
"""魔法函数init,每个类默认都是存在的
1、运行机制:创建对象时执行此方法
2、作用:一般用来做一些初始化操作(属性初始化)
"""
# 属性初始化时不能写成固定的值
# self.name = "如花"
# self.age =18
# self.classer = "Python"
#print("这是魔法函数init。。。")
self.name = name1
self.age = age1
self.classes = classes1
def study(self):
# print("好好学习,天天向上!")
print(f"{self.name}在{self.classes}班级好好学习,天天向上!")
def play_game(self):
print(f"{self.name}热爱生命,热爱游戏!")
if __name__ == '__main__':
ruhua = Student("如花",18,"Python")
ruhua.study()
ruhua.play_game()
输出:
rt_04_雇员类的设计.py
需求: 雇员类:Employee 属性:name,age,department,salary 行为:work
# 雇员类:Employee
# 属性:name,age,department,salary
# 行为:work
class Employee(object):
def __init__(self,name,age,department,salary):
self.name = name
self.age = age
self.department = department
self.salary = salary
def work(self):
print(f"{self.name}正在工作,是{self.department}部门的,工作很努力!")
def get_info(self):
print(f"name:{self.name},age:{self.age},department:{self.department},salary:{self.salary}")
# 重写魔法函数str,注意:有返回值,返回值字符串(是对当前对象的描述)
def __str__(self):
return f"name:{self.name},age:{self.age},department:{self.department},salary:{self.salary}"
# 魔法函数del,当对象被销毁时调用此方法,可以根据他的执行时机来做相应的业务处理
def __del__(self):
print("del被调用,当前对象被销毁")
if __name__ == '__main__':
# ruhua = Employee("如花",19,"财务",10000)
# ruhua.work()
xiaoli = Employee("小李",23,"开发部",15000)
# 如果没有重写魔法函数str,输出对象时
#
print(xiaoli)
# xiaoli.work()
# xiaoli.get_info()
laoli = Employee("老李", 38, "开发部", 38000)
print(laoli)
# laoli.work()
# laoli.get_info()
print("---end---")
输出:
rt_05_封装.py
面向对象三大特征:
封装:就是把属性和方法封装到类中的过程
特点:属性私有化,方法公有化
# 面向对象三大特征:
# 封装:就是把属性和方法封装到类中的过程
# 特点:属性私有化,方法公有化
# 继承:
# 多态:
class Student(object):
def __init__(self,name,age,address):
# self.name = name
# self.age = age
# self.address = address
self.__name = name
self.__age = age
self.__address = address
def get_info(self):
# print(f"name:{self.name},age:{self.age},addres:{self.address}")
print(f"name:{self.__name},age:{self.__age},addres:{self.__address}")
# get,获取私有属性的值
def get_age(self):
return self.__age
# set,给私有属性重新赋值
def set_age(self,age1):
if age1 < 15 and age1 > 0:
self.__age = age1
else:
print("您输入的年龄有误!")
if __name__ == '__main__':
ruhua = Student("如花",18,"山东泰安")
# 属性私有化,私有化后的属性只能在类的内部访问,不能被类访问
# 私有化属性:在属性的前面添加双下划线
# print(ruhua.age)
print(ruhua.get_age())
# ruhua.age = -18
# 就想在类的外部访问私有属性的值,可以在类的内部添加公共方法来访问私有属性的值
ruhua.get_info()
输出:
rt_06_继承.py
继承:指的是类与类之间存在的关系 一个类如果继承了另一个类,就拥有了这个类的所有资源,私有除外 Python中的继承主要有以下三种类型: 1.单继承 2.多继承 3.多层继承
# A类:父类型
# B类:子类型
# B类继承A类
class A(object):
def __init__(self):
self.num = 100000
self.__money = 5000
def test1(self):
print("这是A类中的test。。。")
class B(A):
pass
if __name__ == '__main__':
a = A()
print(a.num)
a.test1()
b = B()
print(b.num)
b.test1()
输出:
rt_07_单继承.py
单继承:一个子类只能继承一个父类
父类:Master(师傅类)
子类:Prentice(徒弟类)
class Master(object):
def __init__(self):
self.kongfu = "【古法煎饼果子配方】"
def make_cake(self):
print(f"运用{self.kongfu}制作煎饼果子!")
class Prentice(Master):
pass
if __name__ == '__main__':
ruhua = Prentice()
print(ruhua.kongfu)
ruhua.make_cake()
输出:
rt_08_多继承.py
# 多继承:一个子类可以继承多个父类
class Master(object):
def __init__(self):
self.kongfu = "【古法煎饼果子配方】"
def make_cake(self):
print(f"运用{self.kongfu}制作煎饼果子!")
# 父类型:School(煎饼果子培训学校)
class School(object):
def __init__(self):
self.kongfu = "【瑞通各种各样煎饼果子配方】"
def make_cake(self):
print(f"运用{self.kongfu}制作煎饼果子!")
class Prentice(School,Master):
# 当继承父类的方法不能满足子类需要时,子类可以重写父类的同名方法
def make_cake(self):
# 重写父类的同名方法后还想保留父类的代码,可以使用super来调用
super(Prentice, self).make_cake()
print("运用独创的煎饼果子配方制作煎饼果子")
pass
if __name__ == '__main__':
ruhua = Prentice()
print(ruhua.kongfu)
ruhua.make_cake()
# 当子类继承多个父类时,子类调用父类的同名属性和方法是怎样调用的?调用顺序?
# 借助魔法属性mro,查看当前子类的继承顺序
print(Prentice.__mro__)
输出:
rt_09_多态.py
多态:指的是一种事物的多种形态
注意:多态只存在继承体系中
需求:
警察携带警犬抓罪犯
父类:Dog(警犬类)
子类:DrugDog(缉拿毒贩的警犬)
子类:ArmyDog(追击敌人的警犬)警员类:Police
class Dog(object):
def work(self):
print("指哪打哪。。。")
class DrugDog(Dog):
def work(self):
"""重写父类的方法"""
print("协助警员缉拿毒贩。。。")
class ArmyDog(Dog):
def work(self):
print("协助警员追击敌人。。。")
class Police(object):
# def work_with_drug_dog(self,drug_dog):
# drug_dog.work()
#
# def work_with_army_dog(self,army_dog):
# army_dog.work()
# 需要定义一个公共方法,不管来了多少种类型的警犬都可以接收
def work_with_dog(self,dog):#dog:指的是警犬类的父类型
# 真正在调用时可以传入不同的子类
dog.work()
if __name__ == '__main__':
lijingguan = Police()
drug_dog = DrugDog()
#lijingguan.work_with_drug_dog(drug_dog)
lijingguan.work_with_dog(drug_dog)
army_dog=ArmyDog()
#lijingguan.work_with_army_dog(army_dog)
lijingguan.work_with_dog(army_dog)
输出: