您的位置: 首页  >  IT文章  >  python之面向对象

python之面向对象

分类: IT文章 • 2023-11-14 14:01:12

 

 

 一、面向对象介绍 

1、面向对象和面向过程
    面向过程：核心过程二字，过程即解决问题的步骤，就是先干什么后干什么
    基于该思想写程序就好比在这是一条流水线，是一种机械式的思维方式
    优点：复杂的过程流程化
    缺点：扩展性差

    面向对象：核心是对象二字，对象指特征与技能的结合体
    基于该思想编写程序就好比在创造一个世界，世界是由一个个对象组成，是一种‘上帝式’的思维方式
    优点：可扩展性强
    缺点：变成复杂度高，极容易出现过度设计的问题


2、类
    对象是特征与技能的结合体，类就是一系列对象相似的特征与技能的结合体
    在现实生活中：一定是先有一个个具体的对象，后总结出类
    在程序中：一定是先定义类，后产生对象
#类体代码在类的定义阶段就会立刻执行
class Students:
    school = '宏福教育'
    def run(self):
        # return 'running......'
        print('running....')
stu1 = Students()

stu2 = Students()
stu3 = Students()
print(Students.school)#数据属性 
print(Students.run)#函数属性 


print(stu1.school)#查询属性 
stu1.contry = '中国'#添加属性 
del stu1.contry#删除类属性 
stu1.school = '宏福'#修改属性
#实例化出不同属性的对象
class Students:
    school = '宏福教育'
    def __init__(self,name, age, job):
        self.name = name
        self.age = age
        self.job = job
    def run(self):
        # return 'running......'
        print('running....')
stu1 = Students('张三', 18, 'IT')
stu2 = Students('王二', 16, 'student')
stu3 = Students('赵五', 19, 'teacher')

面向对象一共有三大特性：

二、面向对象之封装

 1、封装是面向对象一大特点

 2、面向对象编辑的第一步，将属性和方法封装到一个抽象的类当中

 3、外界使用类创建对象，然后让对象调用方法

 4、对象方法的细节都被封装在类的内部

示例1：小明爱跑步

需求：

1）小明体重75公斤

2）小明每次跑步都会减肥0.5公斤

3）小明每次吃东西体重都会增加1公斤

python之面向对象

class Person:
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight

    def run(self):
        self.weight -= 0.5

    def eat(self):
        self.weight += 1

    def __str__(self):
        return '名字:%s
体重:%s
' % (self.name, self.weight)

xm = Person('小明', 75)
xm.eat()
xm.run()
print(xm)

#当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据
View Code

 示例2：

　需求：

1）房子有户型，总面积，家具名称列表

　　房子没有任何家具

2）家具有名字和占地面积，其中

　　席梦思(bed):4平米

　　衣柜(chest): 2平米

　　餐桌(table): 1.5平米

3）将以上三个家具添加到房子中

4）打印房子中，要求输出：户型，总面积，剩余面积，家具名称列表

class Items(object):
    def __init__(self, name, area):
        self.name = name
        self.area = area

    def __str__(self):
        return '家具名称:%s
占地面积:%s
' % (self.name, self.area)

class House(object):
    def __init__(self, house_type, total_area):
        self.house_type = house_type
        self.total_area = total_area
        self.free_area = total_area
        self.items = []

    def add_item(self, item):
        self.free_area = self.free_area - item.area
        self.items.append(item.name)

    def __str__(self):
        return '房子类型:%s
房子总大小:%s
房间剩余面积:%s
家具列表:%s
' % (self.house_type, self.total_area, self.free_area, self.items)


bed = Items('席梦思', 10)
chest = Items('餐桌', 5)
house = House('两室一厅', 100)
house.add_item(bed)
house.add_item(chest)
print(house)
View Code

示例3：

属性可以是另一个类创建的对象

 python之面向对象

class Gun:#创建枪类
    def __init__(self,gun_type):
        self.gun_type = gun_type#初始化枪的型号
        self.bullet = 0#初始化子弹的数量

    def add_count(self, count):#添加子弹
        self.bullet += count

    def shoot(self):#射击
        if self.bullet > 0:#假如子弹数量大于0
            self.bullet -= 1# 那就射击，并且减少子弹数量
            print('开火.......%s' % self.bullet)
        else:
            print('没有子弹啊，兄弟，别这么坑我啊？？？')#否则没有就显示没有子弹


class Soldier:#创建一个士兵的类
    def __init__(self, name,gun=None):
        self.name = name#初始化士兵的姓名
        self.gun = gun#初始化枪

    def fire(self):#开火方法
        if self.gun:#假如有枪
            self.gun.shoot()#那就射击
        else:#不然就显示没有枪
            print('没有枪啊，兄弟，你让我去送死吗？？')

ak47 = Gun('AK47')#创建一个枪的对象叫ak47
ak47.add_count(10)#添加10颗子弹
xsd = Soldier('许三多')#实例化一个许三多的士兵对象
xsd.gun = ak47#把枪交到许三多手中
xsd.fire()#开火
View Code

 

三、面向对象之继承

　目标：

　　　　单继承：一个类只继承一个父类

　　　　多继承：一个类继承多个父类

　　　　继承：继承实现代码的重用，相同的代码不需要重复的编写

python之面向对象

class Anamal:
    def eat(self):
        print('吃')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')
class Dog(Anamal):
    def bark(self):
        print('汪汪叫')

class XiaoTianQuan(Dog):
    def fly(self):
        print('我会飞啦！！！！')
dog = XiaoTianQuan()
dog.eat()
dog.run()
dog.sleep()
dog.drink()
dog.bark()
dog.fly()

   方法的重写

python之面向对象

#重写哮天犬叫唤的方法
class Anamal(object):
    def eat(self):
        print('吃')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')
class Dog(Anamal):
    def bark(self):
        print('汪汪叫')

class XiaoTianQuan(Dog):
    def fly(self):
        print('我会飞啦！！！！')

    def bark(self):
        print('牛逼的叫.......')

dog = XiaoTianQuan()
dog.eat()
dog.run()
dog.sleep()
dog.drink()
dog.bark()
dog.fly()

对父类的方法进行扩展

　　　　1.在子类中重写父类的方法

　　　　2.在需要的位置使用super().父类方法来调用父类方法的执行

　　　　3.代码其他的位置针对子类的需求，编写子类特有的代码实现

　　关于super

　　　　在python中super是一个特殊的类

　　　　super()就是使用super类创建出来的对象

　　　　最常使用的场景就是在重写父类方法时，调用在父类中封装的方法实现

#用super继承父类的方法并扩展新内容
class Anamal(object):
    def eat(self):
        print('吃')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')
class Dog(Anamal):
    def bark(self):
        print('汪汪叫')

class XiaoTianQuan(Dog):
    def fly(self):
        print('我会飞啦！！！！')

    def bark(self):
        print('牛逼的叫.......')
        super().bark()
        print('%*#*@^$*(@')

dog = XiaoTianQuan()
dog.eat()
dog.run()
dog.sleep()
dog.drink()
dog.bark()
dog.fly()

多继承：如果父类中有相同的项，谁在前面读取谁

#重写哮天犬叫唤的方法
class Anamal(object):
    def eat(self):
        print('吃')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')
class Cat(Anamal):
    def bark(self)
        print('喵喵叫')
class Dog(Anamal):
    def bark(self):
        print('汪汪叫')

class XiaoTianQuan(Dog,Cat):
    def fly(self):
        print('我会飞啦！！！！')

    def bark(self):
        print('牛逼的叫.......')

dog = XiaoTianQuan()
dog.eat()
dog.run()
dog.sleep()
dog.drink()
dog.bark()
dog.fly()

四、面向对象之多态

　面向对象的三大特性：

　　1.封装根据职责将属性和方法封装到一个抽象的类中

　　2.继承实现代码的重用，相同的代码不需要重复的编写

　　3.多态不同的子类对象调用相同的父类方法，产生不同的执行结果

　　　　1.多态可以增加代码的灵活度

　　　　2.以继承和重写父类方法为前提

　　　　3.是调用方法的技巧，不会影响到类的内部设计

python之面向对象

#多态的特性：让不同的子类对象调用相同的代码产生不同的结果
class Dog(object):
    def __init__(self, name):
        self.name = name

    def game(self):
        print('%s 开开心心去玩耍.....' % self.name)

class XiaoTianQuan(Dog):
    def game(self):
        print('%s 开开心心去玩耍.....' % self.name)

class Person(object):
    def __init__(self, name):
        self.name = name

    def game_with_dog(self, dog):
        print('%s 和 %s 正在开开心心的玩耍......' % (self.name, dog.name))
        dog.game()
#创建人对象
xiaoming = Person('小明')
#创建狗对象
dog = Dog('旺财')
#让小明跟狗玩耍
xiaoming.game_with_dog(dog)

相关推荐