亿豪的python学习 day11

今天的学习内容

三大特征

封装

数据角度讲
1. 定义：
将一些基本数据类型复合成一个自定义类型。
2. 优势：
将数据与对数据的操作相关联。
代码可读性更高（类是对象的模板）。
行为角度讲
1. 定义：
类外提供必要的功能，隐藏实现的细节。
2. 优势：
简化编程，使用者不必了解具体的实现细节，只需要调用对外提供的功能。
3. 私有成员：
(1) 作用：无需向类外提供的成员，可以通过私有化进行屏蔽。
(2) 做法：命名使用双下划线开头。
(3) 本质：障眼法，实际也可以访问。
私有成员的名称被修改为：_类名_成员名，可以通过_dict_属性或dir函数查看。
4. 属性@property：
公开的实例变量，缺少逻辑验证。私有的实例变量与两个公开的方法相结合，又使调用者的操作略显复杂。而属性可以将两个方法的使用方式像操作变量一样方便。
(1) 定义：
@property
def 属性名(self):
return self._属性名
@属性名.setter
def 属性名(self, value):
self.__属性名= value
(2) 调用：
对象.属性名 = 数据
变量 = 对象.属性名
(3) 说明：
通常两个公开的属性，保护一个私有的变量。
@property 负责读取，@属性名.setter 负责写入
只写：属性名= property(None, 写入方法名)
设计角度讲
1. 定义：
(1) 分而治之
将一个大的需求分解为许多类，每个类处理一个独立的功能。
(2) 变则疏之
变化的地方独立封装，避免影响其他类。
(3) 高 内 聚
类中各个方法都在完成一项任务(单一职责的类)。
(4) 低 耦 合
类与类的关联性与依赖度要低(每个类独立)，让一个类的改变，尽少影响其他类。
2. 优势：
便于分工，便于复用，可扩展性强。

注：以上内容极难理解，需结合代码
关键在于理解思想，不在于代码

"""
    封装(保护)数据
        -- 通过两个公开方法(不建议)
"""
# 步骤
# 1. 私有化数据  --> 类外无法操作数据
# 2. 定义公开的读取方法 --> 在读取数据时做判定
# 3. 定义公开的写入方法 --> 在写入数据时做判定

class Wife:
    def __init__(self, name="", age=0):
        self.name = name
        # 目的:保护成员不被类外操作
        # 私有化:使用双下划线命名
        # 障眼法:实际是 _类名 + 私有变量名
        #       _Wife__age
        # self.__age = age
        self.set_age(age)

    def get_age(self):
        return self.__age

    def set_age(self,value):
        if 22 <= value <= 65:
            self.__age = value
        else:
            raise Exception("我不要")

w01 = Wife("锤锤",25)
w01.set_age(26)
print(w01.get_age())

注：上图代码中私有化数据从表面看仅仅是更改了实例变量的隐藏名字，实际上只是一个障眼法，并未实际将其彻底保护起来

"""
    封装(保护)数据
        -- 通过property
"""
# 步骤
# 1. 私有化数据  --> 类外无法操作数据
# 2. 定义公开的读取方法 --> 在读取数据时做判定
# 3. 定义公开的写入方法 --> 在写入数据时做判定
# 4. 类变量指向property对象 --> 将对数据的操作转为对方法的操作

class Wife:
    def __init__(self, name="", age=0):
        self.name = name
        # self.set_age(age)
        self.age = age

    def get_age(self):
        return self.__age

    def set_age(self,value):
        if 22 <= value <= 65:
            self.__age = value
        else:
            raise Exception("我不要")

    # 类变量 --> 覆盖实例变量
    # property --> 拦截
    age = property(get_age,set_age)

w01 = Wife("锤锤",25)
# w01.set_age(26)
w01.age = 26
print(w01.age)

注：通过property关键字和类变量的优先性达成对数据的保护。
raise Exception应该是属于异常的一种

"""
    封装(保护)数据
        -- 通过属性@property
    练习:exercise01.py
"""


# 步骤
# 1. 私有化数据  --> 类外无法操作数据
# 2. 定义公开的读取方法 --> 在读取数据时做判定
# 3. 定义公开的写入方法 --> 在写入数据时做判定
# 4. 使用@property修饰读取方法
#       @xxx.setter修饰写入方法
#             --> 将对数据的操作转为对方法的操作

class Wife:
    def __init__(self, name="", age=0):
        self.name = name
        self.age = age

    @property  # age =  property(get_age,None)
    def age(self):
        return self.__age

    @age.setter  # age.setter(set_age)
    def age(self, value):
        if 22 <= value <= 65:
            self.__age = value
        else:
            raise Exception("我不要")

w01 = Wife("锤锤", 25)
w01.age = 26
print(w01.age)

注：通过@property和@XXX.setter将属性的输入作出限制，只有符合条件的数据才可以赋值给实例变量

"""
    封装 - 设计角度
        练习:exercise02.py
            exercise03.py

"""

# 需求:老张开车去东北
"""
写法1: 每次去东北,都会创建新车.
class Person:
    def __init__(self, name=""):
        self.name = name

    def go_to(self, pos):
        print("去", pos)
        # 新车
        car = Car()
        car.run()

class Car:
    def run(self):
        print("汽车行驶...")

lz01 = Person("老张")
lz01.go_to("东北") 
"""

"""
写法2: 老张开着自己的车,去东北,去北京.
class Person:
    def __init__(self, name=""):
        self.name = name
        self.car = Car()

    def go_to(self, pos):
        print("去", pos)
        self.car.run()

class Car:
    def run(self):
        print("汽车行驶...")

lz01 = Person("老张")
lz01.go_to("东北")
lz01.go_to("北京")
"""

# 写法3:老张去东北的工具,依赖于外部传入.
class Person:
    def __init__(self, name=""):
        self.name = name

    def go_to(self,car, pos):
        print("去", pos)
        car.run()

class Car:
    def run(self):
        print("汽车行驶...")

lz01 = Person("老张")
bm = Car()
lz01.go_to(bm,"东北")

昨天复习内容

面向对象
    概述
        面向过程:考虑问题从具体(实现/步骤)出发
        面向对象:考虑问题从对象(谁?干嘛?)出发
    类和对象
        设计角度讲:对象  -抽象化->  类
        编码角度讲:类   -实例化->  对象
        语法:
            class 类名:
                # 数据
                def __init__(self,参数):
                    self.数据 = 参数
                # 行为
                def 方法名(self):
                    方法体
            变量名 = 类名(参数)
            print(变量名.数据)
            变量名.方法名()
    成员:
        实例成员: 对象.成员
        类成员: 类名.成员

“”"