18 Python之初识面向对象

1. 类与对象

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

#造车
c = Car() #类名()  #创建对象
##出场之后进行改装
c.color = "红色"  #对象属性  . : 的  当属性不存在的时候相当于添加一个属性
c.pai = "冀F8888" #   对象属性
c.pailiang = "1.5T"

print(c.color)  #此车是红颜色
print(c.pai)
print(c.pailiang)

c.color = "绿颜色"  #当属性存在时候是修改属性信息

#对象.属性 = xxx  设置属性信息

print(c.color)

#相当于字典的改的操作

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

　　　　#__init__方法是一个特殊的方法.初始化的方法.(构造方法)

　　　　#在创建对象的时候会有自动的调用 __init__()

　　　　#self就是你创建出来的那个对象

class Car:
    def __init__(self,color,pai,pailiang): init初始化方法.在创建对象的时候.
    self.color = color
    self.pai = pai
    self.pailiang = pailiang

#跑:动作,功能 -> 函数
#在类中写的函数 -> 方法
#self 当前类的对象
    def pao(self):
        print('%s是我的车,能跑' % self.color)

    def jump(self):
        print('哈哈 搞笑')

c = Car('红色','冀F88888','1.5T')  #创建Car类型对象.此时self参数不需要我们管
c2 = Car("蓝色",'冀F66666','1.8T')
print(c.color)
print(c2.color)
c.pao() #车c 跑
c2.jump()  #c2跳

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

    def call(self,ren):
        print('使用手机给%s打电话' % ren)

    def play(self):
        print('电话可以打游戏')

sj = Phon('黑色',''5W'','','9W欧元')
sj.call('嫂子')
sj.play()

2. 练习

# 1. 创建⼀个武松. 武松可以打老虎, 杀嫂⼦, 替天⾏道
# 2. ⽤⾯向对象的思维来模拟LOL⾥的盖伦上阵杀敌.
# 3. ⽤⾯向对象的思维来完成⽤户登录.

1.
class Haohan:
    def __init__(self,waihao,name,adress)
    self.waihao = waihao
    self.name = name
    self.adress = adress

    def dalaohu():
        print("打老虎")

    def shashaozi():
        print("这个人喜欢杀嫂子")

    def titianxingdao():
        print("替天行道")

ws = Person('行者','武松','景阳冈')
ws.dalaohu()
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("拿着宝剑DuangDuang跑")

    def w(self)
        print("护盾")

    def e(self)
        print("电风扇")

    def r(self)
        print("大宝剑")

qw = Hero("德玛西亚之力",'盖伦','5000年之前盖伦拿着一个破棍子捅破....')

qw.q()
qw.w()
qw.r()

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

    def q(self):
        print("拿着宝剑DuangDuang跑")

    def w(self)
        print("护盾")

    def e(self)
        print("电风扇")

    def r(self)
        print("大宝剑")

qw = Hero("德玛西亚之力",'盖伦','5000年之前盖伦拿着一个破棍子捅破....')

qw.q()
qw.w()
qw.r()

3.
#用户的登陆问题 逻辑是活的

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
u.login()

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

　　面向过程更多的是写一些功能简单的脚本语言,不需要构思整个程序的概况

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

　　面向对象编程,对整个系统进行分析,分析出需要哪些对象.然后给对象进行分类.先写类.然后使用类创建对象.最后用对象去执行相关的操作

　　函数侧重的是功能 类侧重的是归类.使用类不需要像以前一样传递一样的参数了,结果相对清晰.　　

　　缺点:代码量比原来大,上手太难

如果写一个定时任务, 半夜12点. 给老板发送财务报表(一张图)
# class Messager:
#     def __init__(self, name, title, content):
#         self.name = name
#         self.title = title
#         self.content = content
#
#     def send_email(self, address):
#         print("发送邮件")
#
#     def send_wechat(self, wechat_num):
#         print("发送微信")
#
#     def send_chat(self, phone_num):
#         print("发送短信")
#
#     def send_dd(self, dd_num):
#         print("发送钉钉")
#
#     def send_oa(self, oa_num):
#         print("发送OA")

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

python同时支持面向对象和面向过程

java : 纯面向对象 => 可以把一个微型项目. 做成巨型项目

4. 封装

　　1.对属性的封装

　　2.对功能的封装

　　3.模块(将很多类写在一个py文件中)

　　4.包(讲很多的py文件放到一起)

5.继承

　　子类自动拥有父类除了私有的内容外的其他所有内容

　　目的:对父类进行扩展

当出现xxx是一种yyy类型的东西. 可以使用继承关系

class Foo:
#     def getMoney(self):
#         print("拿钱")
#
#
# class Bar(Foo):
#     pass
#
#
# b = Bar()
# b.getMoney() # 此时调用的是父类中的方法

# python支持多继承
class Foo1:
    def getMoney(self):
        print('给你个大嘴巴子')

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

class Foo2:
    def getMoney(self):
        print('给多点儿')

class Bar(Foo1, Foo2): # 离当前类最近的是亲爹, 后面的是干爹.
    pass

b = Bar()  # 就近原则, MRO的C3算法
b.getMoney() # Foo1里的

6. 多态

　　多态性: 同一个对象. 多种形态.
　　 python支持的是鸭子类型. 会嘎嘎叫的东西就是鸭子
　　为了程序能够正常执行. 本来需要传递进来一只鸭子. 但是我只需要传递一个会嘎嘎叫的东西就可以了

class Animal:
#     def chi(self):
#         print("会吃")
#
# class GoldenMonkey(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 = GoldenMonkey()
# e = Elephant()
#
# wei_animal(t)
# wei_animal(m)
# wei_animal(e)

python中万事万物都是对象,object(对象)