Day8 Python学习笔记&关键注意点

 Part 1：Python学习笔记

===================

8.3. 特征

8.3.1.封装：将对象的所具备的行为写在函数里面。简单的说，一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。

• 示例1

class Book:
    count = 0

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

    # Delete the object function
    def __del__(self):
        Book.count -= 1

    def __repr__(self):
        return '<Book:{} at 0x{}>'.format(self.title,id(self))

    def __str__(self):
        return '[Book:{},Price:{}]'.format(self.title,self.price)

    def print_info(self):
        print(self.title,self.price,self.author)

    def cls_method(cls):
        print('Class Function')

    # @static method
    def static_method():
        print('Static Function, have no relationship with instance in logic')


if __name__ == '__main__':
    book = Book('Python Classic',price=29.0,author='Tom')
    book2 = Book('Flask')
    book3 = Book('ASP.net')

    # del(book3)

    # print('Book Number:{}'.format(Book.count))
    # print('Book Number:{}'.format(book2.count))
    #
    # book2.count = 99
    # print('Book Number:{}'.format(Book.count))
    # print('Book Number:{}'.format(book2.count))

    Book.cls_method(book2)
    Book.static_method()
    # book2.static_method() #This will work if enable @staticmethod in line 27

• 示例2: @property-定义：将一个方法伪装成一个属性，这里有提供了两种对私有的修改和删除方法，修改：方法名.setter 删除：方法名.deleter，具体的实例如下：

import datetime

class Student:

    def __init__(self,name,birthdate):
        self.name = name
        # self.age = age
        self.birthdate = birthdate

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

    @age.setter
    def age(self,value):
        raise AttributeError('Stop setting age!!!')

    @age.deleter
    def age(self):
        raise AttributeError('Cannot delete age!!!')


    # 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.age)
    print(s.birthdate)
    print(s.age)

    s.birthdate = datetime.date(1982,8,2)
    # s.age = 20  #Cannot setting age that was defined in line 14-16
    # print(s.birthdate)
    # print(s.age)

    del(s.name)
    print(s.name)

    # del(s.age)
    # print(s.age) #Cannot delete age that was defined in line 18-20

8.3.2.继承：指提供了同一类对象共性的处理方法，子类继承父类共性的东西。这样有利于代码的复用性，即子类拥有父类的方法。如果多个类之间有重叠部分，在概念上有重叠和继承的关系，一定程度上利用代码重用。

8.3.3.多态：属于同一类型的不同实例，对同一个消息做出不同的响应。且以封装和继承为前提。

• 示例1

import math

class Circle:
    def __init__(self,radius):
        self.radius = radius

    @property
    def area(self):
        return math.pi * self.radius **2

    #
    # def get_area(self):
    #     return math.pi * self.radius **2


c = Circle(4.0)

print('Circle area is:{}'.format(c.area))

• 示例2

# Sample 2: Ji Cheng
import datetime

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

    def __repr__(self):
        return '<Department:{}>'.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

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

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

    def __repr__(self):
        return'<Employee:{}>'.format(self.name)

    def working(self):
        print('Employee:{},is working...'.format(self.name))


class Programer(Employee):
    def __init__(self,department,name,birthdate,salary,specialty,project):
        super().__init__(department,name,birthdate,salary)
        self.specialty = specialty
        self.project = project

    def working(self):
        print('Programer:{} is developing a project:{}...'.format(self.name,self.project))


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

    def working(self):
        print('HR:{} is interview new employee...'.format(self.name))


if __name__ == '__main__':
    # p = Programer('R&D department','Peter',datetime.date(1990,3,3),8000.00,'Flask','CRM')
    # print(p)
    # print(p.department)
    # print(p.salary)
    # p.give_raise(.2,.1)
    # print(p.salary)
    # p.working()
    # print(p.age)
    #
    # hr = HR('HR Department','Marry',datetime.date(1992,4,4),6000,qualification_level=3)
    # hr.give_raise(.1)
    # print(hr.salary)
    # hr.working()

    dep = Department('R&D','010-87718391','Zhang da Shan')
    p = Programer(dep,'Peter',datetime.date(1990,3,3),8000,'Python,Flask','Xmall')
    p.give_raise(.2,.1)
    print(p.salary)
    print(p.department)
    print(p.department.department)
    print(p.department.phone)
    print(p.department.manager)

 

Part 2：Python学习注意点

=====================

总结面向对象的三大特征： 

1.封装:

• 面向对象第一步 ： 将属性和方法封装到一个抽象的类中
• 外界使用类创建对象，然后让对象调用方法
• 对象方法的细节都封装在类的内部

2.继承:

• 实现代码的重用，相同的代码不需要重复写
• 子类继承自父类，具有传递性，可以继承父类的所有属性和方法，并且直接使用父类中已经封装好的方法
• 子类针对自己特有的需求，编写特定的代码，封装子类特有的属性和方法
• 如果子类重写了父类的方法，在运行中，只会调用在子类中重写的方法而不会调用父类方法

3.多态：

• 不同的子类对象调用相同的方法，产生不同的执行结果
• 多态可以增加代码的灵活度
• 以继承和重写父类的方法为前提
• 调用方法，不会影响到类的内部设计