Python面向对象编程

Python面向对象编程

• 类和类的属性、方法
• __repr__方法与__str__方法
• 静态属性
• 实例方法、类方法与静态方法
• 类的property属性
• 类的继承
• 类的属性为另一个类的实例

类和类的属性、方法

import datetime


class Book:
    def __init__(self,
                 title,
                 price=0.0,
                 author='',
                 pubate=datetime.date.today()): # 构造方法，可以给属性赋默认值
        self.title = title # self代表类的实例
        self.price = price
        self.author = author
        self.pubate = pubate

    def print_info(self): # 类的一般方法
        print('本书信息如下：')
        print('标题:{}'.format(self.title))
        print('价格:{}'.format(self.price))
        print('作者:{}'.format(self.author))
        print('出版日期:{}\n'.format(self.pubate))


book1 = Book('Python', 29.9, 'Tom', datetime.date(2016, 3, 1))
book1.print_info()
print(book1)

输出：
本书信息如下：
标题:Python
价格:29.9
作者:Tom
出版日期:2016-03-01

<__main__.Book object at 0x000001B63E26E848>

类的名称以大写字母开头，且不要含有下划线

__repr__方法与__str__方法

class Book:
    def __init__(self, title, price=0.0, author=''):
        self.title = title
        self.price = price
        self.author = author

    def __repr__(self):  # 定义在控制台直接输入类的实例对象再回车时的输出;若没使用__str__()方法,则也是使用print()打印的输出
        return '<图书{}>'.format(self.title)

    def __str__(self):  # 定义使用print()打印类的实例对象时的输出
        return '[图书{}]'.format(self.title)


book1 = Book('Python', 29.9, 'Tom')
print(book1)

输出：
[图书Python]

静态属性

class Book:
    count = 0  # 静态属性

    # 创建对象初始化时执行
    def __init__(self, title, price=0.0, author=''):
        self.title = title
        self.price = price
        self.author = author
        Book.count += 1

    # 删除对象时执行
    def __del__(self):
        Book.count -= 1


book1 = Book('Python')
book2 = Book('C语言')
book3 = Book('Java')
print(Book.count)
del (book3)  # 删除对象
print(Book.count)

输出:
3
2

定义由多个实例决定的属性时可以使用静态属性，由于Python并没有statiic关键字，其类属性就相当于静态属性

class Book:
    count = 0  # 静态属性

    # 创建对象初始化时执行
    def __init__(self, title, price=0.0, author=''):
        self.title = title
        self.price = price
        self.author = author
        Book.count += 1

    # 删除对象时执行
    def __del__(self):
        Book.count -= 1


book1 = Book('Python')
book2 = Book('C语言')
book3 = Book('Java')

print(Book.count)
print(book2.count)  # 静态属性可以通过实例对象调用（不推荐）

book2.count = 99
print(Book.count)
print(book2.count)

输出:
3
3
3
99

静态属性可以通过实例对象调用，实例对象也可以改变自身独有的“静态属性”，但不影响类的静态属性。

实例方法、类方法与静态方法

class Book:
    # 创建对象初始化时执行
    def __init__(self, title, price=0.0, author=''):
        self.title = title
        self.price = price
        self.author = author

    def print_info(self):  # 实例方法
        pass

    def cls_method(cls):  # 类方法，与实例无关，传递的参数可以是类或者类的实例（Python2遗留下来）
        print('类方法')

    def static_method():  # 静态方法，逻辑上与实例无关（Python3支持)
        print('静态方法')

    @staticmethod # 使静态方法可通过实例对象调用
    def static_method1():
        print('静态方法，可通过实例对象调用')


if __name__ == '__main__':
    book1 = Book('Python')
    Book.cls_method(Book)
    Book.cls_method(book1)

    Book.static_method() # 通过类名称调用
    book1.static_method1() # 通过类的实例对象调用


输出:
类方法
类方法数
静态方法
静态方法，可通过实例对象调用

类的property属性

import datetime


class Stuent:

    def __init__(self, name, birthday):
        self.name = name
        self.birthday = birthday

    # def get_age(self):  # 使用方法计算获得年龄
    #     return datetime.date.today().year - self.birthday.year

    @property  # 定义property属性
    def age(self):
        return datetime.date.today().year - self.birthday.year

    @age.setter
    def age(self, value):
        raise AttributeError('禁止赋值年龄')

    @age.deleter
    def age(self):
        raise AttributeError('禁止删除年龄')


if __name__ == '__main__':
    s = Stuent('Tom', datetime.date(1999, 3, 1))
    print(s.birthday)
    print(s.age)

    s.birthday = datetime.date(1998, 3, 1)  # 可以修改生日birthday，但不能修改年龄age
    print(s.age)

    del (s.birthday)  # 可以删除生日birthday，但不能删除年龄age

输出:
1999-03-01
21
22

类的继承

import datetime

# 定义父类
class Employee:
    def __init__(self, name, birthday, salary):
        self.name = name
        self.birthday = birthday
        self.salary = salary

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

    def __repr__(self):
        return '<员工：{}>'.format(self.name)

    def salary_raise(self, percent, bonus=0):
        self.salary = self.salary * (1 + percent) + bonus

    def working(self):
        print('员工：{}工作中'.format(self.name))


# 定义子类继承父类
class Progammer(Employee):
    def __init__(self, name, birthday, salary, speciality, project):
        # 对父类属性初始化
        Employee.__init__(self, name, birthday, salary)
        #或者使用super()
        # super().__init__(name, birthday, salary)
        self.speciality = speciality
        self.project = project

    def working(self): #方法重写
        print('程序员：{}在开发项目：{}'.format(self.name, self.project))


if __name__ == '__main__':
    p = Progammer('Tom', datetime.date(1998, 3, 1), 8000, 'Python', 'CRM')
    p.working()
    print(p.salary)
    p.salary_raise(.2, 2000) # 用子类实例调用父类方法
    print(p.salary)
    print(p.age) # 用子类实例调用父类属性
    
输出:
程序员：Tom在开发项目：CRM
8000
11600.0
22

类的属性为另一个类的实例

class Department:
    def __init__(self, department, manager):
        self.department = department
        self.manager = manager

    # def __repr__(self):
    #     return '<部门：{}>'.format(self.department)


class Employee:
	# 可读性更好的写法：def __init__(self, department：Department, name, salary):
    def __init__(self, department, name, salary):
        self.department = department
        self.name = name
        self.salary = salary


if __name__ == '__main__':
    dep = Department('技术部', '张三')
    
	# 将Department类的实例对象赋给Employee类的department属性
    p = Employee(dep, 'Tom', 8000)
    
    print(p.department)
    print(p.department.department)
    print(p.department.manager)

输出:
<__main__.Department object at 0x000001738345F788>
技术部
张三

来源：CSDN

作者：Z_Kai_

链接：https://blog.csdn.net/qq_36536933/article/details/104103383