PYTHON基础知识学习笔记（七）

面向对象

Python从设计之初就已经是一门面向对象的语言，相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法。
步骤如下：
1、OOA面向对象分析：在完成某一个需求前先确定职责——要做的事(方法) ；
2、OOD面向对象设计：根据职责确定不同的对象，在对象内部封装不同的方法(多个) ；
3、OOP面向对象编程：最后完成代码，就是顺序的让不同的对象调用不同的方法 。
例：



面向对象的思想有如下特点：
1、注重对象和职责，不同的对象承担不同的职责 ；
2、更加适合对复杂的需求变化，是专门应对复杂项目的开发，提供的固定套路；
3、需要在面向过程的基础上，再学习一些面向对象的语法。

面向对象技术简介

1、类(Class)：用来描述具有相同的属性和方法的对象的集合，它定义了该集合中每个对象所共有的属性和方法，对象是类的实例。
2、对象：通过类定义的数据结构实例，对象包括两个数据成员（类变量和实例变量）以及方法。
3、类变量：类变量在整个实例化的对象中是公用的，类变量定义在类中且在函数体之外，类变量通常不作为实例变量使用。
4、实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
5、方法:类中定义的函数。
6、实例化：创建一个类的实例，类的具体对象。

封装

对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象 中，然后通过对象直接或者self间接获取被封装的内容。

#定义一个名为Book的类
class Book:
    def __init__(self,title,price,author):
        self.title = title
        self.price = price
        self.author = author
 
#实例化
 book1 = Book('python',29.9,'Tom')

#使用
print(book1.title)
print(book1.price)
print(book1.author)

#运行结果
python
29.9
Tom

类的参数可以设置默认值，若实例化时未赋值，则采用默认值。

#定义类
class Book:
    def __init__(self,title,price = 0.0,author = None):
        self.title = title
        self.price = price
        self.author = author

#实例化
 book1 = Book('python')

#使用
print(book1.title)
print(book1.price)
print(book1.author)

#运行结果
python
0.0
None

类中也可以定义函数，称为方法。

#定义类
class Book:
    def __init__(self,title,price,author):
        self.title = title
        self.price = price
        self.author = author
    def print_info(self):
        print('这本书信息如下：')
        print('标题：{}'.format(self.title))
        print('定价：{}'.format(self.price))
        print('作者：{}'.format(self.author))

#实例化
book1 = Book('python',29.9,'Tom')

#使用
book1.print_info()

#运行结果
这本书信息如下：
标题：python
定价：29.9
作者：Tom

如果直接打印实例化的对象，显示的是其在内存中的位置。

print(book1)

#运行结果
<__main__.Book object at 0x000001C4496B9208>

若想打印实例化的对象时显示想要的信息，可以通过__repr__()函数以及__str__()函数实现。

class Book:
    def __init__(self,title,price = 0.0,author = None):
        self.title = title
        self.price = price
        self.author = author
    def __repr__(self):
        return '<图书{}>'.format(self.title)
    def __str__(self):
        return '<图书{}>,价格{}'.format(self.title,self.price)

book1 = Book('python',29.9)
print(book1)

#运行结果
<图书python>,价格29.9         #__str__()函数返回值
        
#在交互式提示符中
>>> book1
<图书python>                 #__repr__()函数返回值
>>> print(book1)
<图书python>,价格29.9         #__str__()函数返回值

继承

继承实现代码的重用，相同的代码不需要重复的编写。当子类继承父类后，子类就会拥有父类的所有方法。
例：程序员属于员工，一些员工共有的属性（如部门、年龄、月薪······）程序员自然也具有，此外程序员还有自己特有的属性（如专长、项目······）。在已经定义员工这一类后，再定义程序员这一类时可以通过继承获得员工的所有属性。

import datetime

#定义父类
class Employee:
    def __init__(self,department,name,birthdata,salary):
        self.department = department
        self.name = name
        self.birthdata = birthdata
        self.salary = salary
    def give_raise(self,percent,bonus=.0):
        self.salary = self.salary * (1 + percent + bonus)
    def __str__(self):
        return '<员工：{}>'.format(self.name)
    def working(self):
        print('员工：{}，在工作...'.format(self.name))

#定义子类
class Programer(Employee):
    def __init__(self,department,name,birthdata,salary,specialty,project):
        super().__init__(department,name,birthdata,salary)
        self.specialty = specialty
        self.project = project
    def working(self):
        print('程序员：{}在开发项目：{}'.format(self.name,self.project))

#实例化子类
p = Programer('技术部','Peter',datetime.date(1990,3,1),8000,'Python','CRM')

#使用
print(p)
print(p.name)
print(p.project)
p.working()
print('月薪：{}'.format(p.salary))
p.give_raise(.2,.1)
print('实发工资：{}'.format(p.salary))

#运行结果
<员工：Peter>
Peter
CRM
程序员：Peter在开发项目：CRM
月薪：8000
实发工资：10400.0

多态

不同的子类对象调用相同的父类方法，产生不同的执行结果。

#定义父类
class Employee:
    def __init__(self,department,name,salary):
        self.department = department
        self.name = name
        self.salary = salary
    def working(self):
        print('{}员工{}在工作...'.format(self.department,self.name))

#定义子类1
class Programer(Employee):
    def __init__(self,department,name,salary,specialty,project):
        super().__init__(department,name,salary)
        self.specialty = specialty
        self.project = project
    def working(self):
        print('程序员：{}在开发项目：{}'.format(self.name,self.project))

#定义子类2
class Hr(Employee):
    def __init__(self,department,name,salary):
        super().__init__(department,name,salary)
    def working(self):
        print('人事：{}在考核员工'.format(self.name))


#实例化子类
p = Programer('技术部','Peter',8000,'Python','CRM')
h = Hr('人事部','Tom',7000)

#使用
p.working()
h.working()

#运行结果
程序员：Peter在开发项目：CRM
人事：Tom在考核员工

面向对象的各种方法

静态方法

静态函数，逻辑上与实例无关。

#定义类
class Book:
    def __init__(self,title,price,author):
        self.title = title
        self.price = price
        self.author = author

    #静态函数
    def static_method():
        print('静态函数，逻辑上与实例无关')


#实例化
book1 = Book('python',29.9,'Tom')



#使用：通过类名使用
Book.static_method()
#运行结果
静态函数，逻辑上与实例无关




#使用：通过实例名使用
book1.static_method()
#运行结果
Traceback (most recent call last):
  File "E:/software/pycharm/project/main.py", line 17, in <module>
    book1.static_method()
TypeError: static_method() takes 0 positional arguments but 1 was given

通过@staticmethod也可以设置静态方法，并可以通过实例名调用。

#定义类
class Book:
    def __init__(self,title,price,author):
        self.title = title
        self.price = price
        self.author = author

    #静态函数
    @staticmethod
    def func():
        print('静态函数，逻辑上与实例无关')


#实例化
book1 = Book('python',29.9,'Tom')

#使用
Book.func()
book1.func()

#运行结果
静态函数，逻辑上与实例无关
静态函数，逻辑上与实例无关

属性方法

把一个方法变成一个静态属性。

import datetime

#定义类
class Student:
    def __init__(self,name,birthdate):
        self.name = name
        self.birthdate = birthdate

    @property
    def age(self):
        return datetime.date.today().year - self.birthdate.year

#实例化
s = Student('Tom',datetime.date(1992,3,1))

#使用
print(s.birthdate)
print(s.age)

#运行结果
1992-03-01
28

未完待续！