面向对象
1.oop 面向对象的程序开发
# 1.类的定义
"""
用几大特征表达一类事物称为一个类
对象是类的实例,类是对象的模板
"""
class MyCar():#推荐使用
pass
class MyCar:
pass
class MyCar(object):
pass
# 2.类的实例化/实例化对象
class MyCar():
pass
# 实例化对象
obj=MyCar()
print(obj) #<__main__.MyCar object at 0x7f2627114a90>
# 3.类的结构
"""
成员属性: 类里面的变量
成员方法: 类里面的函数
"""
# 4.类的命名
"""推荐使用大驼峰命名法"""
2.面向对象的特征--封装
2.1 对象的相关操作
# 面向对象的特征--封装(对象的相关操作)
"""
封装等级:
1.公有 public: 在类的内部和外部都可以访问到
2.私有 private: 只能在类的内部使用,外部无法访问(属性和方法前加两个下划线__)
调用 :
1.对象.成员属性
2.对象.成员方法
绑定方法:
1.绑定到对象: 对象.类中方法时,系统会自动把对象当成参数传递到方法中
2.绑定到类: 类.方法时,系统会自动把类当成参数传递到方法中
"""
# 定义一个类
class Car():
color="黄色"
__price="80万"
def run(self):
print("120mai")
def info(self):
print(self.color)
print(self.__price)
obj = Car() #实例化对象
# 1.实例化对象访问公有成员属性和成员方法
print(obj.color) #访问成员属性
obj.info() #访问成员方法
# 2.实例化对象动态添加公有成员属性和方法
"""
实例化对象在调用时,先调用自己的,没有再去调用类中的,都没有报错
__dict__查看对象或者类中的内部成员,返回字典
"""
# 2.1 添加成员属性
obj.color="花色"
print(obj.color) #花色 ,先调用自己
print(obj.__dict__) #{'color': '花色'}
print(Car.__dict__)
# 2.2 添加成员方法
# 1.添加无参方法
"""
注意: 调用添加的方法时,系统不会自动把对象当成参数传递到该方法中
"""
def chelun():
print("我是车轮")
obj.chelunzi=chelun #添加方法
obj.chelunzi() #调用 "我是车轮"
print(obj.__dict__) #查看成员
# 2.添加有参方法
# 基本版
def fangxiangpan(name):
print("我是{}".format(name))
obj.fangxiangpan=fangxiangpan
obj.fangxiangpan("方向盘") #我是方向盘
# 升级版(手动添加obj)
def fangxiangpan(obj,name):
print("车的颜色{}".format(obj.color),"我是{}".format(name))
obj.fangxiangpan=fangxiangpan
obj.fangxiangpan(obj,"方向盘") #车的颜色花色 我是方向盘
# 终极版 (自动添加obj)
"""
需要到入模块types
MethodType(函数,obj对象) : 创建绑定方法(绑定到对象),让系统自动添加对比到方法中
"""
import types
obj.fangxiangpan=types.MethodType(fangxiangpan,obj)
obj.fangxiangpan("方向盘") #车的颜色花色 我是方向盘
# 3.添加匿名方法
obj.chezhu=lambda:print("我是车主")
obj.chezhu() #我是车主
2.2 类的相关操作
# 面向对象的特征 ->封装(类的相关操作)
# 定义一个类
class Taxi():
color="黄色"
def lake():
print("出租车拉人~")
obj=Taxi()
print(Taxi.color) #黄色
print(obj.color) #黄色
Taxi.lake() #无参方法只能类调用
# 1.添加公有成员属性
Taxi.chepai="京A jd7876"
print(Taxi.chepai) #京A jd7876
print(obj.chepai) #京A jd7876
print(Taxi.__dict__) #字典后面会有添加的成员
# 2.添加公有成员方法
# 2.1 无参方法
def chelun():
print("我是车轮")
Taxi.chelun=chelun
Taxi.chelun() #我是车轮
# 2.2. 有参方法
def chezhu(name):
print("我是车主:{}".format(name))
Taxi.chezhu=chezhu
Taxi.chezhu("贾英贺")#我是车主:贾英贺
def color(self):
print("我是{}".format(self.color))
Taxi.color1=color #类中的成员属性和方法不要重名,
obj.color1() #我是黄色
# 2.3 匿名方法
Taxi.zuoyi=lambda:print("座椅")
Taxi.zuoyi() #座椅
# 对象和类之间的区别
"""
1.对象去调用类中方法时,系统都会默认传递对象到方法中
2.对象可以默认调用类中的公有成员,反过来不可以
3.一个类可以创建多个对象,而对象和对象之间是彼此独立的
"""
3.访问删除私有成员
# 定义一个类
class Plane():
captain="贾英贺"
__airsister="空姐"
def fly(self):
print("我要飞的更高")
def __price(self):
print("价格保密")
def info1(self): #对象操作
print(self.__airsister)
def info2(): #类操作
print(Plane.__airsister)
obj = Plane() #实例化对象
# 1.访问私有成员
# 方法一:python私有化的实现方式 : 把属性和方法改名了(不推荐属性)
print(obj._Plane__airsister) #对象查看私有成员属性
print(Plane._Plane__airsister) #类查看私有成员属性
obj._Plane__price() #价格保密 ,对象查看方法
Plane._Plane__price("a") #价格保密 ,类查看方法
# 2.删除类和对象中公有成员属性
"""
删除成员时,一定要注意该成员属于谁,对象对类中的成员只有使用权,没有删除修改的权利
"""
# 2.1 删除对象中的成员属性和方法
obj.captain="胜利" #添加属性
obj.func=lambda:print("我是方法") #添加方法
del obj.captain #删除属性
del obj.func #删除方法
# 2.删除类中的属性方法
del Plane.captain #删除属性
del Plane.fly #删除方法
# obj.fly() fly方法被删除了
4.init 构造方法
# 魔术方法
"""
系统自动调用的方法,按照触发机制调用
"""
# __init__ : 构造方法
"""
触发机制 : 实例化对象,初始化时触发
功能 : 为对象添加成员
参数 : 至少一个self参数
返回值: 无
"""
# 1.基本使用
class Class():
def __init__(self):
print("构造方法被触发")
self.name="熊大"
obj = Class() #实例化对象,init被触发
print(obj.__dict__) #查看obj对象成员 {'name': '熊大'}
print(obj.name) #熊大
# 2.带有参数的构造方法
"""
在实例化对象时,给予构造方法参数
"""
# 传入一个参数
class Class():
def __init__(self,name):
self.name=name
obj = Class("贾英贺") #实例化传参
print(obj.__dict__) #{'name': '贾英贺'}
print(obj.name) #贾英贺
# 传入多个参数
class People():
def __init__(self,name,skin):
self.name=name
self.skin=skin
def info(self):
print("姓名:{},肤色:{}".format(self.name,self.skin))
obj = People("舒畅","黄色")
print(obj.__dict__) #{'name': '舒畅', 'skin': '黄色'}
obj.info() #姓名:舒畅,肤色:黄色
