欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

python 初识面向对象

程序员文章站 2022-12-22 22:10:56
1. 类与对象 class Car: #类名首字母大写,严格遵守驼峰命名规范 #__init__方法是一个特殊的方法.初始化的方法.(构造方法) #在创建对象的时候会有自动的调用 __init__() #self就是你创建出来的那个对象 2. 练习 # 1. 创建⼀个武松. 武松可以打老虎, 杀嫂⼦ ......

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'','110','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(对象)