python之面向对象的程序开发

最新推荐文章于 2024-06-01 13:00:35 发布

chinaherolts2008

最新推荐文章于 2024-06-01 13:00:35 发布

阅读量197

点赞数

分类专栏： python基础教程文章标签： python

原文链接：https://www.cnblogs.com/shuaiyao666/p/16049472.html

版权

python基础教程专栏收录该内容

638 篇文章 52 订阅

订阅专栏

oop面向对象的程序开发

用几大特征表达这一类事务称为一个类,类更像是一张图纸,表达的是一个抽象概念

对象是类的具体实现,更像是由这种图纸产出的具体物品,类只有一个,但对象可以通过这个类实例化出多个

对象是类的实例,类是对象的模板

*类中的成员只有方法和属性,不要裸露的把判断和循环直接写在类中,而是用方法包起来

(1)类的定义

# 1
class Car:
    pass
    
# 2 推荐
class Car():
    pass
    
# 3.
class Car(object):
    pass

(2)类的实例化

class Car():
    pass
    
obj = Car()
print(obj)

(3)类的基本结构

class Car():
    # 成员属性
    color = "白色"
    # 成员方法
    def didi():
        print("小车会嚓嚓的叫")
        

# 语法上不报错,但是严禁使用,破坏了类中的结构,不要裸露的把判断和循环直接写在类中,而是用方法包起来
class Car():
    if 5 ==5 :
        print(11223344)

(4)类的命名

"""类的命名 : 推荐使用大驼峰命名法,每个单词的首字母都要大写"""
"""
mycar => MyCar
zhangbaozhang => ZhangBaoZhang
"""

面向对象三大特征: 封装继承多态

封装:对类中成员属性和方法的保护,控制外界对内部成员的访问,修改,删除等操作
继承:一个类除了自身所拥有的属性方法之外,还获取了另外一个类的成员属性和方法
多态:不同的子类对象,调用相同的父类方法,产生不同的执行结果

面向对象的封装 - 对象的操作

封装:
　　1.私有 : 在类内可以互相访问,在类外不能访问
　　2.公有 : 在类内或者类外都可以访问

类中成员:
　　1.成员属性
　　2.成员方法

绑定方法:
　　1.绑定到对象 : 当对象去调用类中成员方法时,系统会默认把该对象当成参数传递给该方法
　　2.绑定到类 : 当对象或者类去调用类中成员方法时,系统会默认把该类当成参数传递给该方法

使用方式:
　　对象.成员属性
　　对象.成员方法

class MyCar():
    # 公有属性
    logo = "布加迪威龙"
    
    # 私有属性
    __price = "2000万"
    
    # 公有方法
    def run(self):
        print("百公里油耗300L,logo={} , price={}".format(self.logo, self.__price))

    # 私有方法
    def __info(self):
        print("车主信息保密,据说是某个房地产大佬的儿子")

# 实例化对象(类的实例化)
obj = MyCar()

# (1)实例化的对象访问成员属性和方法
# 公有
print(obj.logo)
obj.run()

# 私有 (私有成员无法在类外访问,类内可以)
# obj.__price error
# obj.run()
# obj.__info() error


#(2)实例化的对象动态添加公有成员属性
obj.color = "尿黄色"
obj.logo = "五菱宏光" 
print(obj.color)
print(obj.logo)

# __dict__ 获取类对象的内部成员
print(obj.__dict__)
print(MyCar.__dict__)

#(3)实例化的对象动态添加公有成员方法

# 1.无参方法
def dahuangfeng():
    print("请加我大黄蜂")

obj.dahuangfeng = dahuangfeng
obj.dahuangfeng()

# 2.有参方法
# 基本版
def qingtianzhu(name):
    print("请叫我一柱擎天么,{}".format(name))
    
obj.qingtianzhu = qingtianzhu
obj.qingtianzhu("擎天柱")

# 升级版
def qingtianzhu(obj,name):
    print("请叫我一柱擎天么,{},我的颜色是{}".format(name,obj.color))

obj.qingtianzhu = qingtianzhu
obj.qingtianzhu(obj,"擎天柱")

# 究极版
"""如果要创建绑定方法,参数的顺序,self对象本身要放到第一位."""
def qingtianzhu(obj,name):
    print("请叫我一柱擎天么,{},我的颜色是{}".format(name,obj.color))

import types
# 创建绑定方法,系统自动把该对象当成参数传递给方法;
# types.MethodType(方法,对象) => 绑定方法   
res = types.MethodType(qingtianzhu,obj)
print(res)

obj.qingtianzhu = types.MethodType(qingtianzhu,obj)
obj.qingtianzhu("擎天柱")

# 3.lambda表达式
obj.weizhentian = lambda : print("我是威震天")
obj.weizhentian()

面向对象的封装 - 类的操作

使用方式:
　　类.成员属性
　　类.成员方法

class MyCar():
    
    # 公有成员属性
    platenum = "京A7758BB"
    
    # 私有成员属性
    __earning = "月收入6000"
    
    # 公有成员方法
    def car_info():
        print("牌照信息可以公开")
        print("<======>")
        MyCar.__money_info()
    
    # 私有成员方法
    def __money_info():
        print( "收入信息保密" , MyCar.__earning )
        

# (1)定义的类访问公有成员属性和方法
print(MyCar.platenum)
MyCar.car_info()

# MyCar.__money_info() error
    
# (2)定义的类动态添加公有成员属性
MyCar.oil = "1000L"
print(MyCar.oil)
print(MyCar.__dict__)

# (3)定义的类动态添加公有成员方法
# 1.无参方法
def car_light():
    print("我是造车灯的方法")
MyCar.car_light = car_light
MyCar.car_light()

# 2.有参方法
def car_engine(name):
    print("我是造{}发动机的方法".format(name))
MyCar.car_engine = car_engine
MyCar.car_engine("三缸发动机")

# 3.lambda表达式
MyCar.luntai = lambda : print("我是造轮胎的方法")
MyCar.luntai()


# 对比 对象和类之间的不同
"""
1.类中的无参方法默认只能类来调用,对象无法调取
2.对象可以调用类中的成员,反过来,类不能调用对象中的成员
3.每创建一个对象都会在内存中占用一份空间,对象之间是彼此独立的;
"""
obj = MyCar()
# obj.car_info() error
MyCar.car_info()


obj.price = "10万"
print(MyCar.price)

python对成员的保护分为两个等级

私有的: private
　　在本类内部可以访问,类的外部不可以访问.(python中属性或者方法前面加上两个下划线__)
公有的: public
　　在本类的内部和外部都可以访问.
在其他高级语言当中,如java php c++等语言,有三个等级 private public protected

私有成员的改名策略 [_类名__成员名]
对象的相关操作
　　(1)实例化的对象访问公有成员属性和方法
　　(2)实例化的对象动态添加公有成员属性和方法
　　(3)实例化的对象删除公有成员属性和方法
类的相关操作
　　(1)定义的类访问公有成员属性和方法
　　(2)定义的类动态添加公有成员属性和方法
　　(3)定义的类删除公有成员属性和方法

普通方法: 没有任何参数传递,只能类调用
绑定方法: 把默认传参的方法叫做绑定方法,绑定到对象(默认传对象),绑定到类(默认传类)
非绑定方法:静态方法(无需传任何参数,对象和类都能调用)

私有的：只能载类或者对象的结构中访问
公有的：可以载任何位置访问
受保护：可以载当前类或者对象和子类或者子类对象中访问

类内子类中类外部
公有的： √ √ √
私有的： √ X X
受保护： √ √ X (python语言不支持)

1.如何在类外访问私有成员

class Plane():
    # 公有成员
    captian = "赵沈阳"
    
    # 私有成员
    __air_sister = "3名空姐"
    
    # 公有绑定方法
    def fly(self):
        print("飞机要非要平流层,才能减少震动",self.__air_sister)
        
    # 私有绑定方法
    def __age(self):
        print("空姐年龄保密")
        
    # 公有无参方法
    def fly2():
        print("航天飞机飞到天空层,翱翔太空")
    
    # 私有无参方法
    def __earn():
        print("机长的收入保密")
        
    def pub_get1(self):
        print(self.__air_sister)
        self.__age()
        
    def pub_get2():
        print(Plane.__air_sister)
        Plane.__earn()

# 实例化对象
obj = Plane()

# 方法一.访问私有成员 (不推荐)
# python私有化: 采取了改名策略 =>  _类名 + __air_sister
# print(obj.__air_sister)
print(obj._Plane__air_sister)
print(Plane.__dict__)
"""
{'__module__': '__main__', 'captian': '赵沈阳', 
'_Plane__air_sister': '3名空姐', 
'fly': <function Plane.fly at 0x7f2774616158>, '_Plane__age': <function Plane.__age at 0x7f27746161e0>, 'fly2': <function Plane.fly2 at 0x7f2774616268>, '_Plane__earn': <function Plane.__earn at 0x7f27746162f0>, '__dict__': <attribute '__dict__' of 'Plane' objects>, '__weakref__': <attribute '__weakref__' of 'Plane' objects>, '__doc__': None}
"""

# 方法二.访问私有成员 (使用类中的公有方法,间接访问私有成员) (推荐)
obj = Plane()
obj.pub_get1()
Plane.pub_get2()

2.使用类对象删除相应的成员

1.对象可以访问类中的公有成员,但是无权修改或者删除该类中的成员
2.对象在访问成员时,优先访问该对象自己的成员,如果没有在访问类的,类如果也没有直接报错;

# 删除对象成员属性
obj.captian = "赵世超"
del obj.captian
print(obj.captian)

# 删除对象成员方法
obj.basketball = lambda : print("我的私人飞机可以在天上打篮球")
print(obj.__dict__)
obj.basketball()
del obj.basketball
print(obj.__dict__)
# obj.basketball() error

# 删除类中成员属性
del Plane.captian
print(Plane.__dict__)
# Plane.captian
# print(obj.captian) error

# 删除类中成员方法
del Plane.fly2
# Plane.fly2() error

# 注意: 对象无法调无参方法!! 返回来,类可以调用对象的绑定方法么? 可以!!
Plane.fly(obj)