10.1 基本概念

• 类 : 具有相同方法和属性的一类事物
• 对象、实例 : 一个拥有具体属性值和动作的具体个体
• 实例化 ：从一个类得到一个具体对象的过程

10.2 oop面向对象的程序开发

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

# 2.类的定义
# 第一种方法:
class Car:
    pass

# 第二种方法:(推荐使用)
class Car():
    pass

# 第三种方法:
class Car(object):
    pass


# 3.类的实例化
class Car():
    pass

obj = Car()
print(obj)


# 4.类的基本结构
"""
类中俩样东西:
    (1)成员属性
    (2)成员方法
"""

class Car():
    # 成员属性
    color = "白色"
    
    # 成员方法
    def didi():
        print("小车会咔咔的叫")
       
# 5.特殊:语法上不报错,但是严谨使用,破坏了类中的结构
class Car:
    if 5 == 5:
        print(123)

10.3 对象的相关操作

# ### 面向对象的封装 - 对象的操作
"""
封装:
    1.私有:在类内可以互相访问,在类外不能访问
    2.公有:在类内或者类外都可以访问
    
类中成员:
    1.成员属性
    2.成员方法
    
绑定方法:
    1.绑定到对象:当对象去调用类中成员方法时,系统会默认把该对象当成参数传递给该方法
    2.绑定到类
"""


class MyCar():
    # 公有的属性
    logo = "布加迪威龙"
    # 私有的属性
    __price = "2000万"

    # 公有的方法
    def run(self):
        print("百公里油耗300L,logo={}".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__)


# (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, "擎天柱")


# 终极版
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()

10.4 类的相关操作

"""
类调用的方式:
    类.成员属性
    类.成员方法
类中的无参方法只能是类来调用.
"""
class MyCar():
    # 公有属性
    oil = "2.0T"
    # 私有属性
    __price = "5000千万"
    # 公有方法
    def oil_info():
        print("百公里油耗是500升",MyCar.color)
    # 私有方法
    def __price_info():
        print("我的油耗信息是保密的")

# 1、定义的类访问公有成员属性和方法
# 访问公有成员属性
print(MyCar.oil)
# MyCar.__price     error # 无法在类外访问私有成员属性

# 访问公有成员方法
MyCar.oil_info()
# MyCar.__price_info() error # 无法在类外访问私有成员方法

# 2、定义的类动态添加公有成员属性和方法

# 2.1、添加成员属性
MyCar.color = "屎绿色"
print(MyCar.color)
# 查看类对象内部成员使用__dict__,返回的是字典
print(MyCar.__dict__)
# MyCar.oil_info()

# 2.2添加成员方法
# 无参方法
def fangxiangpan():
    print("改造方向盘的方法")
MyCar.fangxiangpan = fangxiangpan
MyCar.fangxiangpan()

print(MyCar.__dict__)


# 有参方法
def fadongji(engin):
    print("动力引擎改成{}".format(engin))
MyCar.fadongji = fadongji
MyCar.fadongji("三缸发动机")

# 3.lambda 表达式
MyCar.luntai = lambda name : print("使用{}的轮胎".format(name))
MyCar.luntai("米其林")

print(MyCar.__dict__)


obj = MyCar()
# obj.logo = "柯尼塞格"
# print(MyCar.logo) error 类不能返回来调用对象中的成员

MyCar.logo = "别摸我,我是宝马bwm"
obj.logo = "柯尼塞格"
print(obj.__dict__)
print(obj.logo)

"""
# 类和对象之间的区别
对象可以调用类中的成员属性和方法,返过来,类不能调用对象中的成员.
类中的成员属性和方法归属于类本身,对象可以使用,但是没有修改和删除的权利.
对象在调用相应成员时,先看看自己有没有
    如果有,调用自己的
    如果没有,调用类中的成员
    如果类中成员也没有,直接报错.
"""

10.5 类和对象的删除操作

# ### 如何在类外访问私有成员
class Plane():
    # 公有成员
    captian = "Tom"
    # 私有成员
    __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._Plane__air_sister)
print(Plane.__dict__)

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

# ### 使用类对象删除相应的成员
"""
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)

10.6 构造方法__init

# ### __init__ 构造方法
"""
    触发时机:实例化对象,初始化的时候触发
    功能:为对象添加成员
    参数:参数不固定,至少一个self参数
    返回值:无
"""


class MyClass():
    def __init__(self):
        print("构造方法被触发")
        self.color = "蓝色"


# 实例化对象
obj = MyClass()
print(obj.color)


# (2) 带有多个参数的构造方法
class MyClass():
    def __init__(self, color):
        self.color = color


obj1 = MyClass("黄色")
print(obj1.color)

obj2 = MyClass("绿色")
print(obj2.color)


# (3) 类可以是一个,对象可以是多个,创造的对象彼此是独立的
class Children():
    def __init__(self, name, skin):
        self.name = name
        self.skin = skin

    def cry(self):
        print("小孩一下生就哇哇的哭")

    def la(self):
        print("小孩一下生就拉粑粑")

    def __eat(self):
        print("小孩一下生就要喝奶")

    def info(self):
        print("小孩子的名字:{}, 小孩的肤色:{}".format(self.name, self.skin))

    def info2(self, name, skin):
        print("小孩子的名字:{}, 小孩的肤色:{}".format(name, skin))


# 实例化对象
afanda = Children("阿凡达", "啊")
afanda.cry()
afanda.info()

wangbaoqiang = Children("王宝强", "绿色")
wangbaoqiang.info()
# wangbaoqiang.__eat() # error

wangbaoqiang.info2("王保国","蓝色")