python初识面向对象

类与对象的关系
类: 就是创建对象的第一步,先写类
对象: 通过类来创建对象

类是对某事物的归类(类就是对属性和方法的封装)
    __init__(self, 参数): 参数一般作为属性设置给对象,对象就是self,对属性的封装,(根据需要,如果在类中传参就用__init__,如果不需要传参,就直在类里定义函数即可)
    def 方法(self, 参数): 方法,第一个参数一般是固定的self,当前类的对象
创建类:
    class 类名:

对象是某类型的一个具体
创建对象:
    变量 = 类名()   #实例化 <-> 创建对象
    变量.属性       #访问对象的属性信息
    变量.方法()     #访问类中的方法

class 类名:
    def __init__(self,值1,值2): # __init__(初始化方法,又被成为构造方法)
        self.属性 = 值1
        self.属性 = 值2

    def 方法(self):
        方法体
    def 方法2(self):
        方法体2

对象名 = 类名(值1,值2)
对象名.方法()
对象名.方法2()

创建类

class Car:  #类名首字母大写,严格遵守变量命名规则
    pass
c = Car()             #创建对象,对象名=类名()
c.color = ‘红色‘      # 对象.属性(.意思就是‘的‘)当属性不存在的时候,添加一个属性
c.pai = ‘京A88888‘
c.color = ‘黑色‘      # 当属性存在的时候是修改属性信息(类似于字典根据key修改value)
print(c.color)
print(c.pai)
结果
红色
黑色
京A88888

创建一个类并调用这个类
__init__方法是一个特殊的方法,初始化方法(构造方法),在创建对象的时候,默认执行这个函数
在创建对象的时候会自动的调用__init__()
self就是创建出来的对象

class Car:
    def __init__(self,color,pai):
        self.a = color
        self.pai = pai
    def pao(self):          #在类中写的函数就是方法,self当前类的对象
        print(‘我%s的%s车能跑‘%(self.a,self.pai))
    def jump(self):
        print(‘我的%s车能飞‘%self.pai)
c=Car(‘红色‘,‘京A88888‘)   # 创建Car类型对象,self参数不需要管
c.pao()
c.jump()
c2 = Car(‘黑色‘,‘京B66666‘)
c2.pao()
c2.jump()
结果
我红色的京A88888车能跑
我的京A88888车能飞
我黑色的京B66666车能跑
我的京B66666车能飞

事例2,对象传参
class Car:
    def __init__(self,color,pai):
        self.a = color
        self.pai = pai
    def pao(self,ret):
        print(‘我%s的%s车能跑%s‘%(self.a,self.pai,ret))
    def jump(self):
        print(‘我的%s车能飞‘%self.pai)
c=Car(‘红色‘,‘京A88888‘)
c.pao(‘太空‘)
c.jump()
结果
我红色的京A88888车能跑太空
我的京A88888车能飞

练习
用向对象的思维来模拟LOL里的盖伦上阵杀敌
class Hero:
    def __init__(self,name,nickname):
        self.name = name
        self.nickname = nickname
    def synopsis(self):
        print(‘%s外号%s‘%(self.name,self.nickname))
    def q(self):
        print(‘拎着大宝剑嗷嗷跑‘)
    def w(self):
        print(‘护盾‘)
    def r(self):
        print(‘大宝剑‘)
gw = Hero(‘盖伦‘,‘德玛西亚之力‘)
gw.synopsis()
gw.q()
gw.w()
gw.r()
结果
盖伦外号德玛西亚之力
拎着大宝剑嗷嗷跑
护盾
大宝剑

用向对象的思维来完成用户登录
class People:
    def __init__(self,user,pwd):
        self.user = user
        self.passwd = pwd
    def login(self):
        use = input(‘user:‘)
        password = input(‘passwd:‘)
        if use == self.user and password == self.passwd:
            print(‘登陆成功‘)
        else:
            print(‘登陆失败‘)
Lgin = People(‘bob‘,‘123‘)
Lgin.login()

面向对象和面向过程对比
脚本:(简单)
一切以事务的发展流程为中心
根据业务逻辑从上到下写垒代码

print(‘开冰箱门‘)
print(‘装大象‘)
print(‘关闭冰箱‘)

函数式(比脚本麻烦)
将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可

def kai():
    print(‘开冰箱门‘)
def zhuang():
    print(‘装大象‘)
def guan():
    print(‘关闭冰箱‘)
kai()
zhuang()
zhuang()
guan()

面向对象:
一切以对象为中心,一切皆为对象,具体的某一个事务就是对象
对函数进行分类和封装,让开发"更快更好更强..."
对整个系统进行分析,分析出需要哪些对象,然后给对象进行归类
先写类,然后使用类创建对象,最后用对象去执行相关的操作

class Elephant:
    def __init__(self):
        print(‘创建大象‘)
    def kai(self):
        print(‘开冰箱门‘)
    def zhuang(self):
        print(‘装大象‘)
    def guan(self):
        print(‘关闭冰箱‘)
e = Elephant()
e.kai()
e.zhuang()
e.guan()

总结
脚本简单,不需要构思整个程序的概况
函数侧重的是功能,对功能有了概况
面向对象侧重的是归类
面向过程: 代码非常的冗余. 尤其是参数
面向对象的程序:
优点: 不需要像原来一样传递同样的参数了,结果相对清晰,可维护性好
缺点: 代码量比原来大,上手太难
应用场景:
如果写一些比较小的程序用面向过程
程序很复杂,很庞大建议用面向对象
   
python同时支持面向对象和面向过程:
面向过程: 应用程序相对比较小,不需要大规模的设计
面向对象: 程序非常大,项目管理维护成本很高,此时更适合用面向对象(结构)

封装
1. 对属性的封装
2. 对功能的封装
3. 模块的封装
4. 包的封装

class Game:
    def login(self):
        print("登录")
    def recharge(self):
        print("充钱")
    def uninstall(self):
        print("卸载")
    def zhaoduixiang(self):
        print("找对象")

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

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

g = Game2()
g.uninstall()
结果
卸载

继承
子类自动拥有父类中除了私有内容外的其他所有内容
继承目的: 对父类进行扩展

class Foo:
    def getmoney(self):
        print(‘多花钱‘)
class Bar(Foo):
    pass
b = Bar()
b.getmoney()
结果
多花钱

事例2
class Animal:
    def dong(self):
        print(‘动物会叫‘)
class Cat(Animal):
    def an(self):
        print(‘猫捉老鼠‘)
c = Cat()
c.dong()
c.an()          #子类可以执行子类和父类中的方法

c = Animal()    #父类的对象不能执行子类中的功能
c.dong()
# c.an()        # 创建的是Animal,所以不能执行子类中的方法

事例3
class Animal:
    def dong(self):
        print(‘动物会叫‘)
class Cat(Animal):      # 子类其实是对父类的一种扩展
    def dong(self):     # 子类中写了和父类一模一样的方法. 这个叫方法的覆盖, 重写
        print(‘猫捉老鼠‘)
    def cat(self):
        print(‘猫上蹿下跳‘)
c = Cat()
c.dong()    # 类中的方法的查询顺序,先找自己,然后再找父类
结果
猫捉老鼠

python支持多继承
class Foo1:
    def dong(self):
        print(‘动物会叫‘)
    def cat(self):
        print(‘猫上蹿下跳‘)
class Foo2:
    def dong(self):
        print(‘猫捉老鼠‘)
class Bar(Foo2,Foo1):   #哪个类在前优先使用哪个类
    pass
b = Bar()   # 就近原则
b.dong()
结果
猫捉老鼠

多态(同一个对象. 多种形态)
优点:超强的可扩展性,面向对象的核心就是多态

class Animal:
    def chi(self):
        print("会吃")
class Tiger(Animal):
    def chi(self):
        print("老虎吃肉")
class Elephant(Animal):
    def chi(self):
        print("大象吃香蕉")
def wei_animal(ani):
    ani.chi()

t = Tiger()
e = Elephant()

wei_animal(t)
wei_animal(e)
结果
老虎吃肉
大象吃香蕉

原文地址:https://www.cnblogs.com/wangm-0824/p/10199597.html

时间: 2024-10-06 17:51:58

python初识面向对象的相关文章

python 初识面向对象

一.初识面向对象 面向过程的程序设计的核心是过程(流水线式思维),过程即解决问题的步骤,面向过程的设计就好比精心设计好一条流水线,考虑周全什么时候处理什么东西. 优点是:极大的降低了写程序的复杂度,只需要顺着要执行的步骤,堆叠代码即可. 缺点是:一套流水线或者流程就是用来解决一个问题,代码牵一发而动全身. 应用场景:一旦完成基本很少改变的场景,著名的例子有Linux內核,git,以及Apache HTTP Server等. 面向对象的程序设计的核心是对象(上帝式思维),要理解对象为何物,必须把自

Python 初识面向对象#学习猿地

> 面向对象编程——Object Oriented Programming,简称`OOP`,是一种**以对象为中心**的程序设计思想. > > 面向过程编程——Procedure Oriented Programming,简称`POP`,是一种**以过程为中心**的程序设计思想. ## 理解面向过程与面向对象思想 大家先思考一个问题:把大象装进冰箱,需要几步? 小品给出的答案:三步 第一步:打开冰箱门 第二步:把大象装进去 第三步:关上冰箱门 ##### 用面向过程去理解 > 上面

8、python全栈之路-初识面向对象

八.初识面向对象 http://www.cnblogs.com/Eva-J/articles/7293890.html#_label1 1.楔子 #面向对象编程 #面向对象的思想 #对象就是一个实实在在的,可以准确描述出来的实体,比如说egg,alex #面向对象的编程是一种上帝视角的切换 #之前你使用的面向过程的编程是面向结果去编程,一个流水线下来有固定的结果 #好想  可扩展性差 容易引起代码的安全问题 #面向对象 #类:具有相同属性和方法的一类事物 #对象:具有具体的属性的事物 2.初识类

python之路---16 初识面向对象

三十五.初识面向对象 一 .面向对象和面向过程比较 ①面向过程:一切以事物的发展流程为核心    优点:负责的问题流程化,编写相对简单 缺点:可扩展性差 ②面向对象:一切以对象为中心. 一切皆为对象. 具体的某一个事务就是对象 优点:可扩展性强 缺点:编程的复杂度高于面向过程 二.类和对象 ①类:就是图纸,创建对象的第一步     对象:通过类造出来的具体事物, ②基本格式 class  类名:            #创建类    类名用驼峰格式 def __init__(self,参数): 

Python之面向对象(一)面向对象初识

6.2 面向对象初识 面向对象初识 回顾面向过程编程VS函数式编程 面向过程编程 # 面向过程编程 测量对象的元素个个数. s1 = 'fjdsklafsjda' count = 0 for i in s1: count += 1 l1 = [1,2,3,4] count = 0 for i in l1: count += 1 #面向过程编程 函数式编程 def func(s): count = 0 for i in s: count += 1 return count func('fdsafd

Python初识与简介【第一篇】

Python初识 由于是开篇,着实有点儿小激动......此处省略一万字,虽然写博客很伤脑细胞也费时费电,但大王说了,这是牛13的开始.    其实我接触Python的一个契机是在做Nagios监控的时候,发现了Python语言的强大,也可以实现高度的自动化,所以才开始慢慢的触及它,最近看到学好Python还可以成为全栈工程师,全栈是什么,就是什么都能做,能写后端.前端.GUI.科学运算.网络编程.大数据开发等等,掌握了这个工具利器,就有能力成为一名全栈程序员,想想都牛13,故心动不已. Pyt

Day7 初识面向对象,面向对象之继承与派生

一.面向对象引言 一.面向对象的程序设计的由来 详述见:http://www.cnblogs.com/linhaifeng/articles/6428835.html 二.面向对象引子 写一个简单程序:人狗大战 角色:人.狗 人角色特性:攻击力.生命值.名字.等级 狗角色特性:攻击力.生命值.名字.品种 1.用函数实现功能:角色和技能分别定义不同的函数 1 def person(attack,life_value,name,level): 2 person_dic = {'attack':att

Python初识对象

一 楔子 你现在是一家游戏公司的开发人员,现在需要你开发一款叫做<人狗大战>的游戏,你就思考呀,人狗作战,那至少需要2个角色,一个是人, 一个是狗,且人和狗都有不同的技能,比如人拿棍打狗, 狗可以咬人,怎么描述这种不同的角色和他们的功能呢? 你搜罗了自己掌握的所有技能,写出了下面的代码来描述这两个角色 def person(name,age,sex,job): data = { 'name':name, 'age':age, 'sex':sex, 'job':job } return data

My way to Python - Day05 - 面向对象-思维导图

My way to Python - Day05 - 面向对象 思维导图