python基础之面向对象

本节主要内容:
    1.⾯向对象和面向过程
    2.⾯向对象如何编写
    3.⾯向对象和面向过程大PK
    4.面向对象的三大特征

1.⾯向对象和面向过程

1.1 面向过程: 一切以事物的流程为核心. 核心是"过程"二字, 过程是指解决问题的步骤,
即, 先干什么, 后干什么. 基于该思想编写程序就好比在编写一套流水线. 是一种机械式的编程思维
    优点: 负责的问题流程化, 编写相对简单
    缺点: 可扩展性差

1.2. 面向对象: 一切以对象为中心.
总结: 具有相同属性和动作的结合体叫对象. 面向对象思维, 要⾃己建立对象. ⾃己建立场景.
你是就是面向对象世界中的上帝. 你想让车干嘛就干嘛. 你想让人干嘛人就能干嘛.
    优点: 可扩展性强
    缺点: 编程的复杂度⾼高于⾯面向过程

1.3 面向对象如何编写

1.3.1 使用实例
类名首字母大写.
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("吃鸡")


1.3.2 ⽤⾯向对象的思维来完成⽤户登录.
class User:
    def __init__(self, username, password):
        self.username = username
        self.password = password

    def login(self, uname, upws):
        if uname == self.username and upws == self.password:
            return True
        else:
            return False

u1 = User("alex", "123")
ret = u1.login(input("请输入你的用户名"), input("请输入密码"))
print(ret)

总结: 类与对象的关系: 类是对事物的总结. 抽象的概念念. 类用来描述对象. 对象是类的实例
化的结果. 对象能执行哪些方法. 都由类来决定. 类中定义了了什么. 对象就拥有什么.


3. 面向对象和面向过程大PK
看看对比
3.1 面向过程编程

 #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", "菜刀", "动感光波")


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

    # 对方法进行封装
    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.函数式编程. 简单的基本功能还是函数式编程更加好用
    3.面向对象: 如果功能非常复杂的时候.编程会比较容易编写.


4.面向对象的三大特征 封装 继承 多态
4.1 封装
概念:封装: 把很多数据封装到一个对象中. 把固定功能的代码封装到⼀个代码块, 函数, 对象, 打包成模块. 这都属于封装的思想.
    具体的情况具体分析. 比如. 你写了了一个很牛B的函数. 那这个也可以被称为封装.
    在面向对象思想中. 是把⼀些看似⽆无关紧要的内容组合到一起统⼀进行存储和使用. 这就是封装.
实例1:
class DBUtil:
    def __init__(self, ip, username, password):
        #对属性的封装(对IP 端口,密码等的封装)
        self.ip = ip
        self.username = username
        self.password = password

   # 对功能的封装(对数据库的增删改操作)
    def test_connect(self):
        pass
    def connect(self):
        pass
    def add(self):
        pass
    def upd(self):
        pass
    def remove(self):
        pass
    def sel(self):
        pass

4.2 继承
概念. 继承: 子类可以⾃自动拥有父类中除了私有属性外的其他所有内容.
实例1:
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()

实例2:依旧是数据库相关的
class DBUtil:

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

#(因为各种数据库操作模式不一样,需要子类来进行功能封装,但仍可以继承一些端口,ip等通用信息)
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


4.3 多态

在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):   #该类没有teng(),但因为继承了yaoguai的teng()也可以用
    def fangundeteng(self): 
        print("爆炸的疼")
class SunWuKong:
    def da(self, yg):    #此处的yg各class YaoGuai JinJiaoDaWang  BaiGuJing 都能直接由yg代理引用,便包含了多态,只要有teng()就行
        yg.teng() #  只要包含了xxx功能的内容都可以试用. 鸭子模型  ->  多态性

sun = SunWuKong()
sun.da(HeiXiongJing)
sun.da(ZhiZhuJing)
sun.da(JinJiaoDaWang)



4.4 多继承(补充)
class Foo1:       #爹1
    def money(self):
        print("有钱")
class Foo2:       #爹2
    def play(self):
        print("玩儿")
    def money(self):
        print("没钱")
class Bar(Foo2, Foo1):   # 谁靠近BAR谁就是亲爹,优先级更高
    pass
b = Bar()
b.money()