Python随笔——下篇

序 

        随着上下两篇的学习，已对Python之基本内容有一浅显理解，可进行简单应用。实际上，无论Java，亦或Python，再或是C++以至于C，均是异曲同工，正所谓，一事通而万事通，正是如此。

        言归于Python，这门语言的优点有很多，不再赘述，而在使用过程中，显而易见的，这门语言很“随便”，或者说很巧妙。之所以这样说，其一，语言格式相对轻快，即简短精悍；其二，更为灵活，即对代码并无过多强制性的要求，只要符合规则即可。

        综上，天下语言，均为一家，无好坏之分，又何来孰强孰弱之理。最后，想分享一言：“且放下功利之心，但行好事”，与诸君共勉。

1.OOP 

随着学习继续，来到了面向对象，其思想（一切皆为对象）、文法、语句、特点均别无二致，故不再赘言，只对Python中较特别的点稍做记录。

1.1 对象的bool值

# 以下对象的布尔值为False：
# False、数值0、None、空字符串、空列表、空元祖、空字典、空集合。

# 测试对象的布尔值
print("---------------以下对象的布尔值都为False--------------")
print(bool(False))
print(bool(0))
print(bool(None))
print(bool(''))
print(bool(""))
print(bool([]))  # 空列表
print(bool(list()))  # 空列表
print(bool(()))  # 空元祖
print(bool(tuple))  # 空元祖
print(bool({}))  # 空字典
print(bool(dict()))  # 空字典
print(bool(set()))  # 空集合

1.2 构造器 

构造方法/构造器：

• 只能实现一个构造方法
• 可动态添加成员方法/动态生成对象属性
• 构造方法不能由返回值

1.3 封装、继承、多态

封装：

• 私有化：只能在本类使用。提供公共的方法访问私有成员。

继承：

• 子类继承父类的公有成员
• object是所有类的父类  （ctrl+h查看类的继承关系）
• python支持多重继承 -> 一个子类可继承多个父类 -> 如有同名成员，遵守从左到右的继承优先级
• 调用父类成员：（1）通过父类名访问父类成员：（2）super().父类成员。注意：建议使用super()

多态：

• 多态：不同的子类调用相同的方法，表现出不同的状态。
• 子类对象可以传递给父类类型
• isinstance()   用于判断对象是否为某个类或其子类的对象
• 当调用对象成员的时候，会和对象本身动态关联

1.4 魔术方法 

 

• __str__     默认打印对象地址，可重写返回属性信息
• __eq__      使用==时自动调用。 未重写前，比较的是对象的内存地址；可重写以比较对象内容。

"""
魔术方法重写
"""
class Person:

    def __init__(self,name,gender,age):
        self.name = name
        self.gender = gender
        self.age = age

    def __str__(self):
        return f"{self.name} , {self.gender} , {self.age}"

    def __eq__(self, other):
        if isinstance(other,Person):
            return other.name == self.name and \
            other.gender == self.gender and \
            other.age == self.age
        return False

    def __lt__(self, other):
        if isinstance(other, Person):
            return self.age < other.age
        return f"类型不一致，无法比较！"

class Dog:

    def __init__(self, name, gender, age):
        self.name = name
        self.gender = gender
        self.age = age

# 测试
person1 = Person("tom","男",10)
person2 = Person("tom","男",10)
person3 = Person("tom","男",12)
dog = Dog("tom","男",10)
print(person1)  # 信息
print(dog)  #地址
print(f"person1 == person2 , {person1 == person2}")
print(f"person1 == dog , {person1 == dog}")
print(f"person1 < person3 , {person1 < person3}")
print(f"person1 < dog , {person1 < dog}")

 1.5 类对象和静态方法

• 类本身就是一个对象，可以直接调用属性/方法
• 静态方法不接受self参数 

1.6 抽象类

• 抽象类不能被实例化
• 抽象类需要继承ABC类，并且至少需要一个抽象方法
• 抽象类中可以有普通方法
• 如果一个类继承了抽象类，则它必须实现其所有抽象方法，否则它仍然是一个抽象类。 

from abc import ABC, abstractmethod

class Employee(ABC):
   
    def __init__(self,name,id,salary):
        self.id = id
        self.name = name
        self.salary = salary

    @abstractmethod
    def work(self):
        pass

    def __str__(self):
        return f"{self.name}, {self.id}, {self.salary}"

class Manager(Employee):

    def __init__(self,name,id,salary,bonus):
        super(Manager, self).__init__(name,id,salary)
        self.bonus = bonus

    def work(self):
        print(f"经理 {self.name} 工作中...")

    def __str__(self):
        return f"{self.name}, {self.id}, {self.salary}, {self.bonus}"

class CommonEmployee(Employee):

    # 构造器与父类相同，可直接调用。

    def work(self):
        print(f"普通员工 {self.name} 工作中...")

# 测试
manager = Manager("张三","m-01",100000,200000)
common = CommonEmployee("jim","c-01",20000)
common.work()
manager.work()
print(manager)
print(common)

 

1.7 模板设计模式 

from abc import ABC, abstractmethod
import time

class Template(ABC):

    @abstractmethod
    def job(self):
        pass

    def cal_time(self):
        start = time.time() * 1000
        self.job()
        end = time.time() * 1000
        print(f"运行时间: {end - start}")

class AA(Template):

    def job(self):
        sum = 0
        for i in range(1000000):
            sum += i

class BB(Template):

    def job(self):
        num_list = []
        for i in range(1000000):
            num_list.append(i)

class CC(Template):

    def job(self):
        count = 0
        for i in range(1000000):
            count += 1

if __name__ == '__main__':
    aa = AA()
    bb = BB()
    cc = CC()
    aa.cal_time()
    bb.cal_time()
    cc.cal_time()