巨蟒python全栈开发-第16天 核能来袭-初识面向对象

一.今日内容总览(上帝视角,大象自己进冰箱,控制时机)
    #转换思想(从面向过程到面向对象)

    1.初识面向对象
        面向过程:
            一切以事物的发展流程为中心.
        面向对象:
            一切以对象为中心,一切皆为对象,具体的某一个事务就是对象
        作用:两者(面向过程&面向对象)是相辅相成的作用

        打比方:(开车去新疆)
            大象进冰箱
                步骤:1.开门,2.装大象,3.关门

                面向对象:大象,你进冰箱
                    此时主语是大象,我操纵的就是大象,此时的大象就是对象

    2.类,对象
        (1)类:就是图纸,创建对象的第一步,先画图纸,先写类
        　 对象:对象就是车,通过图纸造出来的具体的东西,通过类来创建对象

        (2)类与对象的关系:
            A.类是对xxx事物的抽象归类.
                写:
                __init__(self,参数)   参数一般作为属性设置给对象,对象就是self,对属性的封装

                def 方法(self,参数):#方法:第一个参数默认是self,当前类的对象,一般也不起其他的
                    pass

            B.对象是xxx类型的一个具体.
                创建对象: 类名()

        (3)创建类:(最实际的东西)
        class 类名:
            def __init__(self):  #初始化方法,又被称为构造方法(这里暂时这样记忆)
            self.属性=值
            self.属性=值
            self.属性=值

            def fangfa(self):
                方法体(函数体,return)

        (4)创建对象:
            变量=类名()     #实例化<=>创建对象

            变量.属性   #访问对象的属性信息
            变量.方法()   #访问类中的方法

    3.面向对象和面向过程的对比
        如果写一些比较小的程序用面向过程.
        程序很复杂,很庞大建议用面向对象.
        (前面的东西都是基础,基础就是铺垫,但是那才是核心,现在是进一步升华)

    4.面向对象的三大特征
        (1)封装
            1.对属性的封装(__init__())
                self.xxx=xxx

            2.对方法和功能的封装

       (2)继承
            子类自动拥有父类中出了私有内容外的其他所有内容

            class Bar(Foo):     #Bar对Foo进行了扩展
                pass

            当出现x是一种y的时候,推荐使用继承关系
            python支持多继承,查找顺序:先找离他近的.(就近原则)

        (3)多态(python原生直接就是多态)
            鸭子模型:python(其他很多语言也是)更多的支持的是鸭子模型,只要会嘎嘎叫的就是鸭子

二.今日内容大纲

1.类与对象

2.面向对象和面向过程

3.封装

4.继承

5.多态

三.今日内容详解

1.类与对象

(1)

class Car:  #好习惯类名首字母大写,严格遵守驼峰命名规范
    pass
#造车
c=Car() #类名()  #创建对象
#出厂之后进行改装
c.color='红颜色'   #对象.属性    点:的
c.pai='京A888'     #对象.属性
c.pailiang='666L'   #排量

print(c.color)      #红颜色
print(c.pai)        #京A888
print(c.pailiang)   #666L

c.color='绿颜色'   #当属性存在的时候是修改属性信息
#对象.属性=xxxx   设置属性信息
print(c.color)      #绿颜色

# 对比:
dic={}
dic['jay']='周杰伦'
print(dic)
dic['jay']='alex'
print(dic)

#对象其实内部机制就是字典

(2)

class Car:  #好习惯类名首字母大写,严格遵守驼峰命名规范
    pass

#造车
c=Car() #类名()  #创建对象
#出厂之后进行改装
c.color='红颜色'   #对象.属性    点:的 当属性不存在的时候,添加一个属性
c.pai='京A888'     #对象.属性
c.pailiang='666L'   #排量

c2=Car()
c2.color='蓝色'
c2.pai='京B66666'
c2.pailiang='1.6T'

c3=Car()
c3.color='蓝色'
c3.pai='上A99999'
c3.pailiang='3.0L'

(3)

class Car:  #好习惯  类名首字母大写,严格遵守驼峰命名规范
    #__init__方法是一个特殊的方法,初始化方法(暂时这么记忆,构造方法)
    #在创建对象的时候回自动的调用__init__()
    #self就是你创建出来的那个对象
    def __init__(self,color,pai,pailiang):  #init初始化方法,在创建对象的时候,默认执行这个函数
        # print('我是init')   #结果:我是init
        # print('self=',self) #结果:self= <__main__.Car object at 0x000001B82F177550>
        # self.color='红色' #在出厂的时候都是红色
        self.color=color
        self.pai=pai
        self.pailiang=pailiang
        # c.color = "红色"

# c=Car('红','鲁A111','3.0L') #创建Car类型对象,此时self参数不需要我们管
# print('C=',c)   #结果:C= <__main__.Car object at 0x000001B82F177550>
#总结:c和self是同一个对象
c=Car('红色','京A88888','555L')    #创建Car类型对象,此时self参数不需要我们管
c2=Car('蓝色','京B66666','1.6T')
print(c.color)
print(c2.color)

#self对应一块内存地址

(4)

#车需要跑:动作,功能=>函数
#在类中写的函数=>方法

class Car:  #好习惯  类名首字母大写,严格遵守驼峰命名规范
    def __init__(self,color,pai,pailiang):  #init初始化方法,在创建对象的时候,默认执行这个函数
        self.color=color
        self.pai=pai
        self.pailiang=pailiang

    # 跑: 动作, 功能 -> 函数
    # 在类中写的函数 -> 方法
    # self 当前类的对象.

    def pao(self):      #self是自动传递的,不用管它
        print('%s,我的车能跑'%self.color)
    def jump(self):
        print('%s,you jump,I jump'%self.color)
c=Car('红色','京A88888','555L')    #创建Car类型对象,此时self参数不需要我们管
c2=Car('蓝色','京B66666','1.6T')
print(c.color)
print(c2.color)
c.pao()       #车c跑
c2.pao()
c.jump()

(5)

class Phone:
    def __init__(self,color,dianchi,num,price):
        self.color=color
        self.dianchi=dianchi
        self.num=num
        self.price=price

    def call(self,ren):
        print('使用我的%s颜色价格%s的电话打个%s'%(self.color,self.price,ren))
    def play(self):
        print('电话可以打游戏')

sj=Phone('黑色','5WmA','','9w欧元')
sj.call('嫂子')
sj.play()

(6)练习1版本

(1)
#创建一个武松,武松可以打老虎,杀嫂子,替天行道
class haohan():
    def __init__(self,name,nickname):
        self.name=name
        self.nickname=nickname
        print('好汉%s,绰号%s'%(self.name,self.nickname))
    def play(self,ren):
        print('%s 可以打老虎,杀嫂子,替天行道'%ren)
hh=haohan('武松','行者')
hh.play('武松')
(2)
#⽤⾯向对象的思维来模拟LOL⾥的盖伦上阵杀敌.
class hero():
    def __init__(self,name):
        self.name=name
        print('英雄是:%s'%(self.name))
    def skill(self,Q,W,E,R):
        print("Q技能是%s,W技能是%s,E技能是%s,R技能是%s"%(Q,W,E,R))
        # print("名字%s,Q技能是%s,W技能是%s,E技能是%s,R技能是%s"%(self,Q,W,E,R))
h=hero('盖伦')
h.skill('快溜','转子','双倍打击','大保健')

# hero.skill('盖伦','快溜','转子','双倍打击','大保健')
# hero.skill('艾希','快溜','转子','双倍打击','大保健')
(3)#编写和尚类. ⾃⼰⾃由发挥和尚有哪些属性和⽅法.

class monk():
    def __init__(self,name,home,fahao):
        self.name=name
        self.home=home
        self.fahao=fahao
    def action(self,ren):
        print('%s,吃狗肉,敲木鱼,念经,吃斋'%(ren))
m=monk('济公','灵隐寺','道济')
m.action('济公')

(4)
#用面向对象的思维来完成用户登录
class user_login():
    def __init__(self,name,pwd):
        self.name=name
        self.pwd=pwd
    def login(self):
        if self.name=='alex'and self.pwd=='ab':
            print('登录成功')
        else:
            print('登录失败')
ul=user_login('alex','ab')
ul.login()

2版本

#类就是对属性和动作的封装
'''
1. 创建⼀个武松. 武松可以打老虎, 杀嫂⼦, 替天⾏道
2. ⽤⾯向对象的思维来模拟LOL⾥的盖伦上阵杀敌.
3. 编写和尚类. ⾃⼰⾃由发挥和尚有哪些属性和⽅法
4. ⽤⾯向对象的思维来完成⽤户登录.
'''
#属性和方法
(1)
class Person:
    #属性
    def __init__(self,waihao,name,address):
        self.waihao=waihao
        self.name=name
        self.address=address
    #动作
    def dalaohu(self):
        print("%s%s%s打老虎"%(self.waihao,self.name,self.address))

    def shasaozi(self):
        print('这个人,喜欢杀嫂子')

    def titianxingdao(self):
        print('替天行道')

ws=Person('行者','武松','景阳县')
ws.dalaohu()
ws.shasaozi()
ws.shasaozi()
ws.titianxingdao()

(2)
class Hero:
    def __init__(self,waihao,name,story):
        self.waihao=waihao
        self.name=name
        self.story=story

    def q(self):
        print('拎着宝剑嗷嗷跑')
    def w(self):
        print('护盾')
    def e(self):
        print('电风扇')
    def r(self):
        print('大保健')

gw=Hero('德玛西亚之力','盖伦','500年前盖伦拿一个破棍子捅破玉皇大帝...')
gw.w()
gw.e()
gw.q()
gw.r()

(3)
class HeShang:
    def __init__(self, fh, name, miao):
        self.fahao = fh
        self.name = name
        self.miao = miao

    def nianjing(self):
        print("和尚会念经")

    def huayuan(self):
        print("和尚会化缘")

lzs = HeShang("花和尚", "鲁智深", "梁山水庙")

lzs.nianjing()
lzs.huayuan()
(4)
#用户登录的问题,逻辑是活的

#我的版本:把所有的逻辑都写在类中
class User:
    def __init__(self,username,password):
        self.username=username
        self.password=password
    def login(self):
        uname=input('请输入你的用户名')
        upwd=input('请输入你的密码')

        if uname==self.username and upwd==self.password:
            print("登录成功")
        else:
            print("登录失败")

u = User("alex", "")
u.login()

2.面向对象和面向过程

(1)

#大象装冰箱
# print('开门')
# print('装大象')
# print('关门')

(2)

#脚本,此时代码是最简单的,不需要构思整个程序的概况

(3)

函数式编程,比脚本麻烦,对功能有了'概况'

(4)

def kai():
    print('开门')
def zhuang():
    print('装大象')
def guan():
    print('关门')
kai()
zhuang()
guan()

第一回合
脚本胜
函数侧重的是功能
面向对象侧重的是:归类

(5)

PK2

# PK2!!!!!!!!
#小猪佩奇,使用嘴巴嘟嘟技能攻击 超人
#小猪佩奇,使用嘴巴嘟嘟技能攻击 蝙蝠侠
#小猪佩奇,使用嘴巴嘟嘟技能攻击 蜘蛛侠

#面向过程:代码非常的冗余,尤其是参数
def fight_superman(name,jineng):
    print('%s使用%s攻击超人'%(name,jineng))
def fight_spiderman(name,jineng):
    print('%s使用%s攻击蜘蛛侠'%(name,jineng))
def fight_batman(name, jineng):
    print('%s使用%s攻击蝙蝠侠' % (name, jineng))

fight_superman('小猪佩奇','嘴巴嘟嘟')
fight_spiderman('小猪佩奇','嘴巴嘟嘟')
fight_batman('小猪佩奇','嘴巴嘟嘟')

class Pig:
    def __init__(self,name,jineng):
        self.name=name
        self.jineng=jineng

    def fight_superman(self):
        print('%s使用%s攻击超人' % (self.name, self.jineng))

    def fight_spiderman(self):
        print('%s使用%s攻击蜘蛛侠' % (self.name, self.jineng))

    def fight_batman(self):
        print('%s使用%s攻击蝙蝠侠' % (self.name, self.jineng))

#不需要像原来一样传递一样的参数了
#面向对象的程序:结果相对清晰.缺点:代码量比原来大,上手太难
pg=Pig('小猪佩奇','嘴巴嘟嘟')
pg.fight_batman()
pg.fight_superman()
pg.fight_spiderman()

#学完之后,再学java才真正明白

(6)

#如果写一个定时任务,半夜12点,给老板发送财务报表(一张图)
# def send_email(address,name,title,content):
#     print('发送邮件')
# def send_chat(address,name,title,content):
#     print('发送短信')
# def send_wechat(address,name,title,content):
#     print('发送微信')
# def send_dd(address,name,title,content):
#     print('发送钉钉')
# def send_oa(address,name,title,content):
#     print('发送OA')

# send_dd()
# send_email()
# send_oa()
# send_wechat()
# send_chat()
#
#
# class Messager:
#     def __init__(self,name,title,content):
#         self.name=name
#         self.title=title
#         self.content=content
#
#     def send_email(address, name, title, content):
#         print('发送邮件')
#
#     def send_wechat(address, name, title, content):
#         print('发送微信')
#
#     def send_chat(address, name, title, content):
#         print('发送短信')
#
#     def send_dd(address, name, title, content):
#         print('发送钉钉')
#
#     def send_oa(address, name, title, content):
#         print('发送OA')

#用面向对象就比面向过程稍微好一些
    #可维护性比原来好

#python同时支持面向对象和面向过程:
#面向过程:应用程序相对比较小,不需要大规模的设计
#面向对象:程序非常大,项目管理,维护成本很高,此时更适合用面向对象(结构)

#tornado
#java:纯面向对象 =>可以把一个微小项目,做成巨大项目

3.封装

1.对属性的封装
2.对功能的封装
3.模块 (在一个模块中封装了很多类)
4.包
(1)

class Student:  #封装需要的就可以了
    def __init__(self,num,name,clazz):
        self.num=num
        self.name=name
        self.clazz=clazz
        # print()

stu=Student('','曹宝宝','三年级二班')  #把多个信息(值),保存在一个对象里面
stu2=Student('','王迪','三年级一班')

def kill_stu(s):   #这是就是对属性进行封装
    print('杀%s'%(s.name))
kill_stu(stu2)

(2)

class Game:
    def login(self):
        print('登录')

    def recharge(self):
        print('充钱')

    def uninstall(self):
        print('卸载')#冲多了就卸了

    def zhaoduixiang(self):
        print('找对象')
g=Game()        #强行安装一个主语
g.recharge()

(3)

class Game1:
    def recharge(self):
        print("充钱")
    def uninstall(self):
        print("卸载")

class Game2:
    def recharge(self):
        print("充钱")
    def uninstall(self):
        print("卸载")

g = Game2()
g.uninstall()

4.继承

子类自动拥有父类中除了私有内容外的其他所有内容
老婆不能继承,年龄不能继承(这些都属于'私有内容')

王思聪(熊猫tv)=>王健林(年龄)
getmoney 拿钱

继承的目的:对父类进行扩展

(1)

class Foo:
    def getMoney(self):
        print('拿钱')

class Bar(Foo):
    pass
b=Bar()
b.getMoney()    #此时调用的是父类中的方法

#当出现xxx是一种yyy类型的东西,可以使用继承关系
#猫是一种动物

(2)

class Animal:
    def dong(self):
        print('动物会动,雇佣')
class Cat(Animal):  #子类其实是对父类的一种扩展
    def catchMouse(self):
        print('猫很皮,抓老鼠')

c=Cat()
c.dong()
c.catchMouse()

a=Animal()        #父类的对象不能执行子类中的功能
a.dong()
a.catchMouse()  #父类不能对子类的方法操作,这句话会报错
                    #创建的是动物,动物不能执行抓老鼠

(3)

class Animal:
    def dong(self):
        print('动物会动,雇佣')
class Cat(Animal):      #子类其实是对父类的一种扩展
    def dong(self):     #子类中写了和父类一模一样的方法,这个叫方法的覆盖,重写
        print('猫上蹿下跳')

    def catchMouse(self):
        print('猫很皮,抓老鼠')

c=Cat()     #创建的是猫
c.dong()    #类中的方法的查询顺序,先找自己,然后再找父类

(4)

#python支持多继承

class Foo1:
    def getMoney(self):
        print('给钱,给你个大嘴巴子')
class Foo2:
    def getMoney(self):
        print('给多点儿')

    def play(self):
        print('玩儿')
class Bar(Foo1,Foo2):   #离当前类最近的是亲爹,后面的是干爹
    pass
a=Bar()         #就近原则,MRO的C3算法
a.getMoney()    #Foo2里的

5.多态

多态性：同一个对象，多种形态
python支持的是鸭子类型,只要会嘎嘎叫的东西就是鸭子
(哪怕不是鸭子//哪怕是鸭子,不会叫,也不行,也不能叫鸭子)

为了程序能够正常执行,本来需要传递进来一只鸭子,但是我只需要传递一个会嘎嘎叫的东西就可以了

(1)归一化设计

class Animal(object):
    def chi(self):
        print('会吃')
class GlodenMonkey(Animal):
    def chi(self):
        print('用手拿着吃,五花八门')
class Tiger(Animal):
    def chi(self):
        print('老虎吃肉')
class Elephant(Animal):
    def chi(self):
        print('大象吃香蕉')
class qie(Animal):
    def chi(self):
        print('企鹅吃人民币')

#以下代码是饲养员
#优点:超强的可扩展性.面向对象的核心就是多态

def wei_animal(ani):    #传进来的东西要会吃就行
    ani.chi()

#动物园
t=Tiger()
m=GlodenMonkey()
e=Elephant()

wei_animal(t)
wei_animal(m)
wei_animal(e)

a=188
def cul(n):
    print(n)    #python中万事万物都是对象,object(对象)
cul(a)
cul('')

作业:???(记得补充)