Python小白学习笔记六 （面向对象 1 ）

面向对象 Object Oriented

概述

面向过程

1.分析出解决问题的步骤，然后逐步实现。
例如：婚礼筹办

– 发请柬（选照片、措词、制作）

– 宴席（场地、找厨师、准备桌椅餐具、计划菜品、购买食材）

– 婚礼仪式（定婚礼仪式流程、请主持人）

2.公式：程序 = 算法 + 数据结构
3.优点：所有环节、细节自己掌控。
4.缺点：考虑所有细节，工作量大。

面向对象

1.找出解决问题的人，然后分配职责。
例如：婚礼筹办

– 发请柬：找摄影公司（拍照片、制作请柬）

– 宴席：找酒店（告诉对方标准、数量、挑选菜品）

– 婚礼仪式：找婚庆公司（对方提供司仪、制定流程、提供设备、帮助执行）

2.公式：程序 = 对象 + 交互
3.优点
(1)思想层面：
– 可模拟现实情景，更接近于人类思维。

– 有利于梳理归纳、分析解决问题。

(2)技术层面：
– 高复用：对重复的代码进行封装，提高开发效率。

– 高扩展：增加新的功能，不修改以前的代码。

– 高维护：代码可读性好，逻辑清晰，结构规整。

4.缺点：学习曲线陡峭。

类和对象

1.类：一个抽象的概念，即生活中的”类别”。
2.对象：类的具体实例，即归属于某个类别的”个体”。
3.类是创建对象的”模板”。
– 数据成员：名词类型的状态。

– 方法成员：动词类型的行为。

4.类与类行为不同，对象与对象数据不同。

语法
定义类
1.代码

class 类名:
	“””文档说明”””
	def _init_(self,参数列表):
		self.实例变量 = 参数
方法成员

2.说明

	-- 类名所有单词首字母大写.
	--  _init_ 也叫构造函数，创建对象时被调用，也可以省略。
	--  self 变量绑定的是被创建的对象，名称可以随意。

创建对象(实例化)

变量 = 类名(参数列表)

实例成员
实例变量

1.语法
(1)定义：对象.变量名
(2)调用：对象.变量名
2.说明
(1)首次通过对象赋值为创建，再次赋值为修改.

	w01 = Wife()
	w01.name = “丽丽”
	w01.name = “莉莉”

(2)通常在构造函数(init)中创建。

	w01 = Wife(“丽丽”,24)
	print(w01.name)

(3)每个对象存储一份，通过对象地址访问。
3.作用：描述某个对象的数据。
4.dict：对象的属性，用于存储自身实例变量的字典。

"""
    实例成员
        字面意思：对象(具体)的 变量 与 方法
        实例变量:自己的数据
            价值：每个对象都有一份
            创建：
                 对象.变量名 = 数据
            使用：
                　对象.变量名
        实例方法:操作实例变量
            创建：
                def 方法名(self,参数)
                    方法体
            使用：
            	对象.方法名(参数)
"""
class Wife:
    def __init__(self, name):
        self.name = name
    def print_self(self):
        print("我是：", self.name)
w01 = Wife("丽丽")  # dict01 = {"name":"丽丽"}
w01.name = "莉莉"  # dict01["name"] = "莉莉"
print(w01.name)  # print(dict01["name"])
w01.print_self()
print(w01.__dict__)  # {"name":"丽丽"}

# 支持动态创建类成员
# 类中的成员应该由类的创造者决定
class Wife:
    pass
w01 = Wife()
w01.name = "莉莉"
print(w01.name)#对象.变量名


# 实例变量的创建要在构造函数中__init__
class Wife:
    def set_name(self,name):
        self.name = name
w01 = Wife()
w01.set_name("丽丽")
print(w01.name)

实例方法

1.语法
(1) 定义：

	def 方法名称(self, 参数列表):
		    方法体

(2) 调用：对象地址.实例方法名(参数列表)

	  不建议通过类名访问实例方法

2.说明
(1) 至少有一个形参，第一个参数绑定调用这个方法的对象,一般命名为"self"。
(2) 无论创建多少对象，方法只有一份，并且被所有对象共享。
3.作用：表示对象行为。
类成员

"""
    类成员
       类变量:大家的数据
            创建：
                在类中,方法外
                    变量名 = 数据
            使用：
                通过类名访问
                    类名.变量名
        类方法:操作类变量
            创建：
                @classmethod
                def 方法名(cls,参数):
                    方法体
            使用：
                通过类名访问
                   类名.方法名(参数)
"""
class ICBC:
    """
        工商银行
    """
    # 类变量：总行的钱
    total_money = 1000000
    # 类方法：操作类变量
    @classmethod
    def print_total_money(cls):
        # print("总行的钱：", ICBC.total_money)
        print("总行的钱：", cls.total_money)
    def __init__(self, money=0):
        # 实例变量：支行的钱
        self.money = money
       # 总行的钱因为创建一家支行而减少
        ICBC.total_money -= money
ttzh = ICBC(100000)
trtzh = ICBC(200000)
# print("总行的钱：", ICBC.total_money)
ICBC.print_total_money()

类变量

1.语法
(1)定义：在类中，方法外定义变量。

class 类名:
	  	 变量名 = 表达式

(2)调用：类名.变量名
不建议通过对象访问类变量

2.说明
(1) 存储在类中。
(2) 只有一份，被所有对象共享。
3.作用：描述所有对象的共有数据。

"""
    总结 - Python语言变量
"""
a = 10  # 全局变量:定义在文件中,整个文件可用
def func01():
    b = 20  # 局部变量:定义在函数中,整个函数可用
class MyClass:
    d = 40  # 类变量:定义在类中,通过类访问
    def __init__(self):
       self.c = 30  # 实例变量:定义在构造函数中,通过对象访问
"""
    私有化
      作用：
            类外无法访问
        做法：
            以双下划线命名   __data
        本质：障眼法
         单下划线+类名+私有变量名字 _MyClass__data
"""
class MyClass:
    def __init__(self, data):
        self.__data = data
    def __func01(self):
        print("func01执行了")
m01 = MyClass(10)
# print(m01.__data)
# print(m01._MyClass__data)
print(m01.__dict__)
# m01.__func01()
# m01._MyClass__func01()

"""
    属性
"""
# 需求：保障数据(年龄)在有效范围内(30-60)
class Wife:
    def __init__(self, name="", age=0):
        self.name = name
        self.age = age
w01 = Wife("双儿", 9999999999999)
print(w01.name)
print(w01.age)


# 注意：
# 1. 属性名与实例变量名相同
# 2. 属性操作私有变量

class Wife:
    def __init__(self, name="", age=0):
        self.name = name
        self.age = age
    @property # age = property(age)
    def age(self):
        return self.__age
    @age.setter # age = age.setter(age)
    def age(self, value):
        if 30 <= value <= 60:
            self.__age = value
        else:
            raise Exception("我不要")
w01 = Wife("双儿", 59)
w01.age = 31
print(w01.name)
print(w01.age)

"""
    属性原理
        目标：保护实例变量
        理念：拦截对变量的操作，改为对方法的调用.
        一个属性对象,包装了两个方法(负责读取 负责写入).
"""
class Wife:
   def __init__(self, name="", age=0):
        self.name = name
        self.age = age
        # self.set_age(age)
    def get_age(self):
        return self.__age
    def set_age(self, value):
        if 30 <= value <= 60:
            self.__age = value
        else:
            raise Exception("我不要")
    # @property 原理如下
    age = property(get_age)
    # age.setter 原理如下
    age = age.setter(set_age)
w01 = Wife("双儿", 59)
w01.age = 300
print(w01.name)
print(w01.age)

"""
    属性各种写法
"""

# 写法1：读写属性
# 快捷键：props + 回车
class MyClass:
   def __init__(self,data):
        self.data = data
    @property
    def data(self):
        return self.__data
    @data.setter
    def data(self, value):
        self.__data = value
m01 = MyClass(10)
print(m01.data)


# 写法2:只读属性
# 适用性：类中确定的数据,类外只能读取,不能修改
# 快捷键：prop + 回车
class MyClass:
    def __init__(self):
        self.__data = 10
    @property
    def data(self):
        return self.__data
m01 = MyClass()
# m01.data = 20# AttributeError: can't set attribute
print(m01.data)


# *写法3：只写属性
class MyClass:
    def __init__(self, data):
        self.data = data
    # data = property()
    # @data.setter
    # def data(self, value):
    #     self.__data = value
    def data(self, value):
        self.__data = value
    data = property(fset=data)
m01 = MyClass(10)
print(m01.data)  # AttributeError: unreadable attribute
m01.data = 20
print(m01.__dict__)

类方法

1.语法
(1)定义：

    @classmethod
    def 方法名称(cls,参数列表):
         方法体

(2)调用：

		类名.方法名(参数列表) 
  不建议通过对象访问类方法

2.说明
(1) 至少有一个形参，第一个形参用于绑定类，一般命名为’cls’

(2) 使用@classmethod修饰的目的是调用类方法时可以隐式传递类。

(3) 类方法中不能访问实例成员，实例方法中可以访问类成员。

3.作用：操作类变量。

静态方法

1.语法
(1)定义：

		    @staticmethod
		    def 方法名称(参数列表):
		            方法体

(2)调用：类名.方法名(参数列表)
不建议通过对象访问静态方法

2.说明
(1) 使用@ staticmethod修饰的目的是该方法不需要隐式传参数。

(2) 静态方法不能访问实例成员和类成员

3.作用：定义常用的工具函数。