2020-10-21 DAY 7 面向对象一

目录

简介

面向对象思考方式

类和对象的关系

构造函数__init__()

实例属性和实例方法 实例属性

类对象、类属性、类方法、静态方法

__del__方法(析构函数)和垃圾回收机制

call__方法和可调用对象

@property 装饰器

 

---

简介

面向对象（Object oriented Programming，OOP）编程的思想主要是针对大型 软件设计而来的。面向对象编程使程序的扩展性更强、可读性更好，使的编程可以像搭 积木一样简单。面向对象编程将数据和操作数据相关的方法封装到对象中，组织代码和数据的方式 更加接近人的思维，从而大大提高了编程的效率。

面向对象思考方式

遇到复杂问题，先从问题中找名词（面向过程更多的是找动词），然后确立这些名词哪 些可以作为类，再根据问题需求确定的类的属性和方法，确定类之间的关系。

类和对象的关系

类是现实世界或思维世界中的实体在计算机中的反映，它将数据以及这些数据上的操作封装在一起。对象就是将类实例化后产生的，是类的具体实体。

我们通过类定义数据类型的属性（数据）和方法（行为）,也就是说，“类将行为和状态打 包在一起”。

从一个类创建对象时，每个对象会共享这个类的行为（类中定义的方法），但会有自己的属 性值（不共享状态）。更具体一点：“方法代码是共享的，属性数据不共享”。

定义类的语法格式如下：

class 类名：

     类体

要点：

1.  类名必须符合“标识符”的规则；一般规定，首字母大写，多个单词使用“驼峰原则”。
2.  类体中我们可以定义属性和方法。
3.  属性用来描述数据，方法(即函数)用来描述这些数据相关的操作。

一个典型的类定义

class Student:
    def __init__(self,name,score):    #构造函数
        self.name=name                #实例属性
        self.score=score

    def say_score(self):               #实例方法
        print(self.name,"的分数是：",self.score)
s1=Student("张三",80)       #s1是实例对象，自动调用__init__（）方法
s1.say_score()

构造函数__init__()

作用：用于执行“实例对象的初始化工作”，即对象创建后，初始化当前对象的相关属性，无返回值。

__init__()的要点如下：

1. 名称固定，必须为：__init__()

2. 第一个参数固定，必须为：self(self名字可以任意修改)。 self 指的就是刚刚创建好的实例对象。

3. 构造函数通常用来初始化实例对象的实例属性，如下代码就是初始化实例属性：name 和 score。 

#定义构造函数
def __init__(self,name,score):
    self.name = name          #实例属性(也称为实例变量）
    self.score 

 

实例属性和实例方法 实例属性

实例属性

实例属性是从属于实例对象的属性，也称为“实例变量”。他的使用有如下几个要点：

1. 实例属性一般在__init__()方法中通过如下代码定义： self.实例属性名 = 初始值
2. 在本类的其他实例方法中，也是通过 self 进行访问： self.实例属性名
3. 创建实例对象后，通过实例对象访问：

                obj01 = 类名()                           #创建对象，调用__init__()初始化属性

                obj01.实例属性名 = 值              #可以给已有属性赋值，也可以新加属性

实例方法

实例方法是从属于实例对象的方法。实例方法的定义格式如下：

        def 方法名(self [, 形参列表])：

               函数体

 方法的调用格式如下：

      对象.方法名([实参列表])

要点：

• 定义实例方法时，第一个参数必须为 self。和前面一样，self 指当前的实例对象。
• 调用实例方法时，不需要也不能给 self 传参。self 由解释器自动传参。

类对象、类属性、类方法、静态方法

类对象

我们在前面讲的类定义格式中，“class 类名：”。实际上，当解释器执行 class 语句时， 就会创建一个类对象。

class Student:
    pass       #空语句
print(type(Student))
s1 = Student()     

运行结果：
<class 'type'>

类属性

类属性是从属于“类对象”的属性，也称为“类变量”。由于，类属性从属于类对象，可以 被所有实例对象共享。

类方法

类方法是从属于“类对象”的方法。类方法通过装饰器@classmethod 来定义，格式如下：

@classmethod

def 类方法名(cls [，形参列表]) ：

    函数体

要点：

1. @classmethod 必须位于方法上面一行
2.  第一个参数 必须是cls；cls 指的就是“类对象”本身；
3. 调用类方法：“类名.类方法名(参数列表)”。 参数列表中，不需要也不能给 cls 传 值。
4. 类方法中访问实例属性和实例方法会导致错误
5. 子类继承父类方法时，传入 cls 是子类对象，而非父类对象

   class Student:
       company = "SXT" #类属性（也称类变量）
       @classmethod
       def printCompany(cls):
           print(cls.company)   #打印类变量
   Student.printCompany()
   
   运行结果：
   SXT

    

静态方法

Python 中允许定义与“类对象”无关的方法，称为“静态方法”。静态方法通过装饰器@staticmethod 来定义，格式如下：

@staticmethod

def 静态方法名([形参列表]) ：

    函数体

要点如下：

1.  @staticmethod 必须位于方法上面一行
2. 调用静态方法格式：“类名.静态方法名(参数列表)”。
3. 静态方法中访问实例属性和实例方法会导致错误

class Student:
    company = "SXT" # 类属性
    @staticmethod   #静态方法
    def add(a, b): 
        print("{0}+{1}={2}".format(a,b,(a+b)))
        return a+b
Student.add(20,30)      #调用静态方法

运行结果：
20+30=50

__del__方法(析构函数)和垃圾回收机制

__del__方法称为“析构方法”，用于实现对象被销毁时所需的操作。比如：释放对象 占用的资源

class Person:
    def __del__(self):
        print("销毁对象：{0}".format(self))
p1 = Person()
p2 = Person()
print(p1)
print(p2)

运行结果：
<__main__.Person object at 0x00000143E49CC3C8>
<__main__.Person object at 0x00000143E4951908>
销毁对象：<__main__.Person object at 0x00000143E49CC3C8>
销毁对象：<__main__.Person object at 0x00000143E4951908>
#程序执行完后自动清除所有对象

call__方法和可调用对象

定义了__call__方法的对象，称为“可调用对象”，即该对象可以像函数一样被调用。

class SalaryAccount:
    '''工资计算类'''
    def __call__(self, salary):
        print("算工资啦...")
        yearSalary = salary*12
        daySalary = salary//21.75
        hourSalary = daySalary//8
        return dict(monthSalary=salary,yearSalary=yearSalary,daySalary=daySalary,hourSalary=hourSalary)
s = SalaryAccount()
s(5000)         #可以像调用函数一样调用对象的__call__方法
print(s(5000))  #输出返回值字典里的内容

运行结果：
算工资啦...
算工资啦...
{'monthSalary': 5000, 'yearSalary': 60000, 'daySalary': 229.0, 'hourSalary': 28.0}

方法没有重载

Python 中，方法的的参数没有声明类型（调用时确定参数的类型），参数的数量也可以由 可变参数控制。因此，Python 中是没有方法的重载。定义一个方法即可有多种调用方式， 相当于实现了其他语言中的方法的重载。 如果我们在类体中定义了多个重名的方法，只有最后一个方法有效。

#Python 中没有方法的重载。定义多个同名方法，只有最后一个有效
class Person:
    def say_hi(self):      #无效的方法
        print("hello")
    def say_hi(self,name):
        print("{0},hello".format(name))
p1 = Person()
#p1.say_hi() #不带参，报错：TypeError: say_hi() missing 1required positional argument: 'name'
p1.say_hi("高淇")

方法的动态性

Python 是动态语言，我们可以动态的为类添加新的方法，或者动态的修改类的已有的方法。

class Person:
    def work(self):
        print("努力上班！")
def play_game(s):
    print("{0}玩游戏".format(s))

p=Person()
Person.play=play_game
p.work()
p.play()

运行结果：
努力上班！
<__main__.Person object at 0x000001FE303DEBC8>玩游戏

私有属性和私有方法(实现封装)

Python 对于类的成员没有严格的访问控制限制，这与其他面向对象语言有区别。关于私有 属性和私有方法，有如下要点：

1. 约定以两个下划线开头的属性是私有的(private)（前后都双下滑线是class的内置方法，与私有属性不同）。其他为公共的(public)。
2. 类内部可以访问私有属性(方法)
3. 类外部不能直接访问私有属性(方法)
4. 类外部可以通过“对象名_类名__私有属性(方法)名”访问私有属性(方法)

#测试私有属性、私有方法
class Employee:
    __company = "百战程序员"               #私有类属性. 通过 dir 可以查到_Employee__company
    def __init__(self,name,age):   
        self.name = name
        self.__age = age #私有实例属性
    def say_company(self):
        print("我的公司是：",Employee.__company)            #类内部可以直接访问私有属性
        print(self.name,"的年龄是：",self.__age)
        self.__work()
    def __work(self):               #私有实例方法 通过 dir 可以查到_Employee__work
        print("工作！好好工作，好好赚钱，娶个媳妇！")
p1 = Employee("高淇",32)
print(p1.name)
print(dir(p1))         #查看对象p1的所有属性。方法
p1.say_company()
print(p1._Employee__age)    #类外部通过这种方式访问私有属性

 

@property 装饰器

@property 可以将一个方法的调用方式变成“属性调用”。

#测试@property的用法
class Employee:
    def __init__(self,name,salary):
        self.name = name
        self.__salary = salary
    @property
    def salary(self):
        return self.__salary
    @salary.setter   #针对salary属性的设置
    def salary(self, salary):
        if 1000 < salary < 50000:
            self.__salary = salary
        else:
            print("录入错误！薪水在1000-50000这个范围")
'''
不使用装饰器的情况下，实现该功能
    def get_salary(self):
        return self.__salary
    def set_salary(self,salary):
        if 1000<salary<50000:
            self.__salary=salary
        else:
            print("录入错误！薪水在1000-50000这个范围")
            '''
emp1 = Employee("高淇",1000)
# print(emp1.get_salary())
# emp1.set_salary (-2000)
# print(emp1.get_salary())
print(emp1.salary)
emp1.salary=-2000
print(emp1.salary)