python学习 day15打卡 初识面向对象

本节主要内容:

1.面向对象和面向过程

2.面向对象如何编写

3.面向对象和面向过程的对比

4.面向对象的三大特征

一.面向对象和面向过程(重点理解)

1.面向过程:一切以事物的流程为核心.核心是"过程"二字,过程是指解决问题的步骤,即先干什么,

后干什么.基于该思想编写程序就好比在编写一套流水线.是一种机械式的编程思维

优点:负责的问题流程化,编写相对简单

缺点:可扩展性差

2.面向对象:一切以对象为中心.

优点:可扩展性强

缺点:编程的复杂程度高于面向过程

二.面向对象如何编写

先创建类: 归类,对某些事物进行总结. 相当于图纸

使用类可以创建对象:

class 类名(object)
    def __init__(self, name, age): # 构造方法. 创建对象的时候自动调用这个方法
        self.name = name
        self.age = age

    def 方法名(self, 参数);
        方法体(return)    

创建对象:

变量(引用,类似于文件操作的句柄) = 类名(参数)

#访问对象的属性信息

对象.属性

#方法的访问

对象.方法()

创建一个类
# Car 类名. 类是对事物的定义. 归类
class Car:
    pass

c = Car() # 把类概念进行实例化. 通过类来创建对象
# # 对象 = 类()

c.lunzi = "圆的"  # 属性
c.color = "骚红色"
c.pailiang = "6.3T"
c.paizhao = "京A66666"
# . 的
print(c.pailiang)
print(c.color)
print(c.paizhao)
print(c.lunzi)

# 类名首字母大写.
class Computer:

    # 构造方法. 在创建的对象的时候由系统自动访问这个方法
    # self: 自己. 自身. 类的对象. 当前正在创建的对象
    def __init__(self, pinpai, price, cpu, neicun): # 谁在调用, self就是谁, self 由python自动传递
        self.pinpai = pinpai
        self.price = price
        self.cpu = cpu
        self.neicun = neicun

    # 方法. 该类型的对象能够执行哪些操作
    def dayouxi(self, game): # 谁调用的这个方法. self就是谁
        # 我用我的self.pinpai的调用. 利用很牛B的self.cpu来完成吃鸡操作
        print("我要打游戏, 我要%s" % game)

c = Computer("微软",25000,"i9","5T") # 创建对象
c.dayouxi("吃鸡")

 总结:类与对象的关系:类是对事物的总结.抽象的概念.类用来描述对象.对象是类的实例化的结果,对象能执行哪些方法.

都是由类来决定.类中定义了什么,对象就拥有什么.

练习题:

用面向对象的思维来完成用户登录.

class User:
    def __init__(self,username,password):
        self.username =username
        self.password = password

    def login(self,usern,upsw):
        if usern == self.username and upsw == self.password :
            return "登录成功"
        else:
            return "账户或密码错误"

p1 = User("afly","")
ret=p1.login(input("请输入你的账户"),input("请输入你的密码"))
print(ret)

三.面向对象和面向过程的对比

各自有各自的优缺点, 得看需求.

大型项目更适合面向对象,而小型脚本程序更适合面向过程

要把大象装冰箱
def open():
    print("开门")
def zhuang():
    print("装大象")
def close():
    print("关门")

open()
zhuang()
close()

class DaXiang:
    def open(self):
        print("开门")
    def jinbingxiang(self):
        print('进冰箱')
    def guanmen(self):
        print("关门")

dx = DaXiang()
dx.open()
dx.jinbingxiang()
dx.guanmen()

通过上面的例子可以发现:

# 主语发生了改变
# 函数式编程. 简单的基本功能还是函数式编程更加好用
# 面向对象: 如果功能非常复杂的时候.

#  alex大战奥特曼

#面向过程:
def daZhanAoTeMan(name, wuqi, jineng):
    print("%s 使用 %s 配合 %s技能狂怼奥特曼" % (name, wuqi, jineng))
# alex大战哥斯拉
def daZhanGeSiLa(name, wuqi, jineng):
    print("%s 使用 %s 配合 %s技能狂怼哥斯拉" % (name, wuqi, jineng))
# alex大战蝙蝠侠
def daZhanBianFuXia(name, wuqi, jineng):
    print("%s 使用 %s 配合 %s技能狂怼蝙蝠侠" % (name, wuqi, jineng))

daZhanAoTeMan("alex", "菜刀", "动感光波")
daZhanGeSiLa("alex", "菜刀", "动感光波")
daZhanBianFuXia("alex", "菜刀", "动感光波")

#面向对象:
class Person:
    def __init__(self, name, wuqi, jineng, taopaoluxian):
        # 封装: 对属性的封装.
        self.name = name
        self.wuqi = wuqi
        self.jineng = jineng
        self.taopaoluxian = taopaoluxian

    # 对方法进行封装
    def daZhanAoTeMan(self):
        print("%s 使用 %s 配合 %s技能狂怼奥特曼" % (self.name, self.wuqi, self.jineng))

    # alex大战哥斯拉
    def daZhanGeSiLa(self):
        print("%s 使用 %s 配合 %s技能狂怼哥斯拉" % (self.name, self.wuqi, self.jineng))

    # alex大战蝙蝠侠
    def daZhanBianFuXia(self):
        print("%s 使用 %s 配合 %s技能狂怼蝙蝠侠" % (self.name, self.wuqi, self.jineng))

a1 = Person("alex", "菜刀", "动感光波", "打车跑")
a1.daZhanAoTeMan()
a1.daZhanBianFuXia()
a1.daZhanGeSiLa()

通过上面的案例发现,明显面向对象的思想更加清晰一些.代码也更容易编写,所以,用那种编程思想不是绝对的,得根据需求和需要来完成.

四.面向对象的三大特征

面向对象三大特征: 封装,继承,多肽.只要是面向对象编程语言.都有这三个特征.

1.封装:把很多数据封装到一个对象中.把固定功能的代码封装到一个代码块,函数,对象,打包成模块.这都属于封装的思想.具体的情况具体分析.

在面向对象思想中,是把一些看似无关紧要的内容组合到一起统一进行储存和使用.就是封装.

2.继承:子类可以自动拥有父类中除了私有属性外的其他所有内容.在python中实现继承非常简单.在声明类的时候,在类名后面添加一个小括号,

就可以完成继承关系.一个类可以同时继承多个父类,具体的MRO(method resolution order)算法.后面会聚义分析和讲解

3.多态:同一个对象,多种形态.

# 继承: 子类自动拥有父类中除了私有内容外的其他所有内容
# 现在我们写的内容没有私有的

class Niu:
    def da(self):
        print("牛魔王打架很厉害")

class HongHaiEer(Niu):
    def da(self):
        print("喷火")

hhl = HongHaiEer()
hhl.da()

class Animal:
    def chi(self):
        print("喜欢吃东西")

# 当程序中出现了 x是一种y. x可以继承y
class Cat(Animal):
    pass

class Foo:
    def a(self):
        pass

    def b(self):
        pass

class Bar(Foo): #  子类在父类的基础上扩展了一些功能. 派生
    def c(self):
        pass

b = Bar()
b.a()
b.b()
b.c()

class DBUtil:

    def __init__(self, ip, username, password):
        pass
    def test_connect(self):
        pass
    def connect(self):
        pass
    def close(self):
        pass

class Mysql_Util(DBUtil):

    def add(self):
        pass
    def delete(self):
        pass
    def update(self):
        pass

class Oracle_Util(DBUtil):

    def add(self):
        pass
    def delete(self):
        pass
    def update(self):
        pass

多继承

class Foo1:
    def money(self):
        print("有钱")

class Foo2:
    def play(self):
        print("玩儿")

    def money(self):
        print("没钱")

class Bar(Foo2, Foo1): # MRO c3算法
    pass

b = Bar()
b.money()

多态

# 同一个对象. 拥有多种形态 java c++
class Aniaml:
    def dong(self):
        print("动物可以动")

class Cat(Aniaml):
    def chi(self):
        print("猫喜欢吃鱼")

a = Cat()
a.chi() # 站在猫的角度. 可以吃
a.dong() # 站在动物的角度可以动

# 在python中多态的效果感受不够明确
class YaoGuai:
    def teng(self):
        print("妖怪一定会疼")

class ZhiZhuJing(YaoGuai):
    def teng(self):
        print("蜘蛛精很痛")

class HeiXiongJing(YaoGuai):
    def teng(self):
        print("黑熊精也很疼")

class BaiGuJing(YaoGuai):
    def teng(self):
        print("白骨精骨头很疼")

class JinJiaoDaWang(YaoGuai):
    def fangundeteng(self):
        print("爆炸的疼")

class SunWuKong:
    def da(self, yg):
        yg.teng() #  只要包含了xxx功能的内容都可以试用. 鸭子模型  ->  多态性

# 西游记开始
swk = SunWuKong()

hxj = HeiXiongJing()
swk.da(hxj)

bgj = BaiGuJing()
swk.da(bgj)

zzj = ZhiZhuJing()
swk.da(zzj)

alex = JinJiaoDaWang()
swk.da(alex)

多态的好处:程序具有超高的可拓展性.面向对象思想的核心与灵魂.python自带多态