面向对象（封装，继承，多态）

OOP类，对象，实例化：

name = 'Jock'  # 定义全局变量


class Ren(object):  # 定义类，class Ren或者class Ren()都可以
    name = '人'  # 定义公有属性
    __money = '我有十块钱'  # 定义私有属性

    def run(self):  # 定义方法（函数），必须要有一个形参，通常用self
        print('跑步')
        print(name)  # 调用全局变量name='Jock'
        print(self.name)  # 调用类属性name='人'

    def say(self):
        lie = "我很欣赏你"  # 定义局部变量，注意这个不是类的公有属性
        print(self.__money)  # 内部调用私有属性
        print(lie)  # 调用局部变量


if __name__ == '__main__':  # 直接调用则执行，被调用则不执行
    zhangsan = Ren()  # 实例化类，创建对象
    print(zhangsan.name)  # 调用类的公有属性name='人’
    zhangsan.name = '张三'  # 对实例zhangsan的name属性重新赋值为'张三'
    print(zhangsan.name)  # 输出>>>张三
    zhangsan.run()  # 调用成员函数fun()
    zhangsan.say()  # 调用成员函数say()
    print(zhangsan._Ren__money)  # 另外一种访问私有属性的方式，仅在测试时使用
    print('#' * 50)
    print(Ren.__dict__)  # 调用内置属性'__dict__'

 

 

class Book:
    count = 0

    def __init__(self, title, price=0.0, author=None):
        self.title = title
        self.price = price
        self.author = author
        Book.count += 1

    def __del__(self):
        Book.count -= 1

    def static_method():
        print('类函数，静态函数')

    def print_info(self):
        print('书名：{}'.format(self.title))


if __name__ == '__main__':
    book = Book('Python', price=19)
    book2 = Book('C经典', 29, 'Tom')
    book3 = Book('ASP')

    print('图书数量：{}'.format(Book.count))

    del (book3)
    print('图书数量：{}'.format(Book.count))

    Book.static_method()

 

OOP封装：

@desc:模块，OOP，函数及变量数据结构的混合应用（封装）
"""
# import datetime
#
#
# class Student:
#     def __init__(self, name, birthdate):
#         self.name = name
#         self.birthdate = birthdate
#
#     def get_age(self):
#         return datetime.date.today().year - self.birthdate.year
#
#
# if __name__ == '__main__':
#     s = Student('Tom', datetime.date(1992, 3, 1))
#     print(s.birthdate)
#     print(s.get_age())  ############# 将此处进行改进
# 总结：模块，OOP，函数及变量数据结构的混合理解（.运算符）

###############

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

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

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


if __name__ == '__main__':
    s = Student('Tom', datetime.date(1992, 3, 1))
    print(s.birthdate)
    print(s.age)

    # s.age = 50
    # print(s.age)

    del s.age

OOP继承：

@desc:模块，OOP，函数及变量数据结构的混合应用（继承）
"""
import datetime


class Employee:
    def __init__(self, department, name, birthdate, salary):
        self.department = department
        self.name = name
        self.birthdate = birthdate
        self.salary = salary

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

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

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

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


class Programmer(Employee):  # 继承
    def __init__(self, department, name, birthdate, salary, specially, projiect):
        super().__init__(department, name, birthdate, salary)  # super（）超链接作用
        self.specially = specially
        self.projiect = projiect

    def working(self):
        print('程序员{}在开发项目：{}...'.format(self.name, self.projiect))


if __name__ == '__main__':
    p = Programmer('技术部', 'Tom', datetime.date(1992, 5, 12), 8000, 'Falsk', 'CRM')
    print(p)
    print(p.department)
    print(p.salary)
    p.give_raise(.2, .1)
    print(p.salary)
    print(p.age)

OOP多态：

@desc:模块，OOP，函数及变量数据结构的混合应用（多态） （Programmer和HR 是多态）
"""
import datetime


class Employee:
    bn = 6

    def __init__(self, department, name, birthdate, salary):
        self.department = department
        self.name = name
        self.birthdate = birthdate
        self.salary = salary

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

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

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

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


class Programmer(Employee):  # 继承
    def __init__(self, department, name, birthdate, salary, specially, projiect):
        super().__init__(department, name, birthdate, salary)  # super（）超链接作用(可改写)
        self.specially = specially
        self.projiect = projiect

    def working(self):
        print('程序员{}在开发项目：{}...'.format(self.name, self.projiect))


class HR(Employee):
    an = 5
    name = 'vf'

    def __init__(self, department, name, birthdate, salary, qualification=1):
        Employee.__init__(self, department, name, birthdate, salary)
        self.qualification = qualification

    def working(self):
        print('人事：{}正在面试新员工'.format(self.name))


if __name__ == '__main__':
    p = Programmer('技术部', 'Tom', datetime.date(1992, 5, 12), 8000, 'Falsk', 'CRM')
    print(p)
    print(p.department)
    print(p.salary)
    p.give_raise(.2, .1)
    print(p.salary)
    print(p.age)

    hr = HR('人事部', 'Marry', datetime.date(1992, 4, 12), 6000, 3)
    hr.give_raise(.1)
    print(hr.salary)
    hr.working()
    print(HR.an)
    print(hr.an)
    print(hr.bn)

    print(HR.working(HR))  # 4.类--变量
    print(HR.working(hr))
    print(hr.working())

# 总结：1.类属性变量 ，类行为（成员函数）  2.对象实例化 3.对象属性变量，对象行为（成员函数） 4.类--变量--内存地址--数据结构

 

 

@desc:模块，OOP，函数及变量数据结构的混合应用(接test7)
"""
import datetime


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

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


class Employee:

    def __init__(self, department: Department, name, birthdate, salary):  ############改进
        self.department = department
        self.name = name
        self.birthdate = birthdate
        self.salary = salary

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

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

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

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


class Programmer(Employee):  # 继承
    def __init__(self, department, name, birthdate, salary, specially, projiect):
        super().__init__(department, name, birthdate, salary)  # super（）超链接作用(可改写)
        self.specially = specially
        self.projiect = projiect

    def working(self):
        print('程序员{}在开发项目：{}...'.format(self.name, self.projiect))


class HR(Employee):

    def __init__(self, department, name, birthdate, salary, qualification=1):
        Employee.__init__(self, department, name, birthdate, salary)
        self.qualification = qualification

    def working(self):
        print('人事：{}正在面试新员工'.format(self.name))


if __name__ == '__main__':
    dep = Department('技术部', '010-1542', '张大叔')
    p = Programmer(dep, 'Tom', datetime.date(1990, 3, 3), 800, 'Python', 'ded', )
    p.give_raise(.2, .1)
    print(p.salary)
    print(p.department)  # p.department==dep  (实质：变量) #####改写方法####
    print(dep)
    print(dep.department)
    # 总结：1.类属性变量 ，类行为（成员函数）
    #       2.对象实例化(实质就是一个具有对象（类）属性的变量（数据结构）)
    #       3.对象属性变量，对象行为（成员函数） 4.类--变量--内存地址--数据结构
    print(p.department.department)
    print(p.department.phone)
    print(p.department.manager)