Python3笔试实际操作基础3.md

#!/usr/bin/python3
#鸭子类型案例了解

class Duck:
    def quack(self): 
        print("Duck 类 呱呱呱！")
    def feathers(self): 
        print("Duck 类  这个鸭子拥有灰白灰白的羽毛。")

class Person:
    def quack(self):
        print("Person 类 你才是鸭子你们全家人是鸭子！")
    def feathers(self): 
        print("Person 类  这个人穿着一件鸭绒大衣。")

def in_the_forest(duck):
    duck.quack()
    duck.feathers()

#入口
def game():
    '''Duck Typing 类型测试'''
    donald = Duck()
    john = Person()
    in_the_forest(donald)  #实际动态调用了Duck类定义的方法
    in_the_forest(john)

print("###########",game.__doc__,"#################")
game()


#案例2：鸭子类型
def calc(a, b, c):
        return (a + b) * c

>>> a = calc(1, 2, 3)
>>> b = calc([1, 2, 3], [4, 5, 6], 2)
>>> c = calc('love', 'FishC', 3)
>>> print(a)
9
>>> print(b)
[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]
>>> print(c)
loveFishCloveFishCloveFishC


########### Duck Typing 类型测试 #################
# Duck 类 呱呱呱！
# Duck 类  这个鸭子拥有灰白灰白的羽毛。
# Person 类 你才是鸭子你们全家人是鸭子！
# Person 类  这个人穿着一件鸭绒大衣。

#!/usr/bin/python3
#[扩展阅读] 如何使用静态方法、类方法或者抽象方法

#1.Python 方法的运作
class Pizza(object):
    def __init__(self, size):
        self.size = size
    def get_size(self):
        return self.size

print(Pizza.get_size)  #Python3中 归属于一个类的函数不再被看成未绑定方法（unbound method），但是作为一个简单的函数(返回函数地址)
                       #Python2中 类Pizza的属性get_size是一个非绑定的方法

print("Pizza类地址：",Pizza(12).get_size)    #实例化对象与方法绑定,在 Python3 中bound原理是一样的，模型被简化了
print("get_size() 获取方法后值：",Pizza(12).get_size())  #实例化对象调用get-size方法

## 但是如何知道已绑定的方法被绑定在哪个对象上？技巧如下：
m = Pizza(42).get_size
print("Pizza对象",m.__self__,"nPizza对象get_size方法地址即是bound method Pizza.get_size 类地址：",m == m.__self__.get_size)

############################## 执行结果 #######################################
# <function Pizza.get_size at 0x000002BF0D9C9598>
# Pizza类地址： <bound method Pizza.get_size of <__main__.Pizza object at 0x000002BF0D9F2978>>
# get_size() 获取方法后值： 12
# Pizza对象 <__main__.Pizza object at 0x000002BF0D9F2978>
# Pizza对象get_size方法地址即是bound method Pizza.get_size地址： <bound method Pizza.get_size of <__main__.Pizza object at 0x000002BF0D9F2978>>


#2.静态方法
# 静态方法避免了这样的情况：
# - 降低了阅读代码的难度：看到 @staticmethod 便知道这个方法不依赖与对象本身的状态；
# - 允许我们在子类中重载mix_ingredients方法。
# 如果我们使用在模块最顶层定义的函数 mix_ingredients，一个继承自 SPizza 的类若不重载 cook，可能不可以改变混合成份（mix_ingredients）的方式。

class SPizza(object):
    @staticmethod   #@ 修饰器 
    def mix_ingredients(x, y):
        return x + y
    
    #将方法 mix_ingredients 作为一个非静态的方法也可以 work，但是给它一个 self 的参数将没有任何作用。
    def cook(self):  
        return self.mix_ingredients(self.cheese, self.vegetables)

print(SPizza().mix_ingredients(1,2))  # 3 
print(SPizza.cook is SPizza().cook)  # False 是因为前者是 类的方法  后者是实例化对象的方法嘛，

# >>> Pizza().mix_ingredients is Pizza().mix_ingredients
# True
# >>> Pizza().mix_ingredients is Pizza.mix_ingredients
# True

# >>> Pizza()
# <__main__.Pizza object at 0x10314b410>



#3.类方法
#类方法一般用于下面两种：
#- 工厂方法，被用来创建一个类的实例，完成一些预处理工作,如果我们使用一个 @staticmethod 静态方法，我们可能需要在函数中硬编码 Pizza 类的名称，使得任何继承自 Pizza 类的类不能使用我们的工厂用作自己的目的。
class Pizza(object):
    def __init__(self, ingredients):
        self.ingredients = ingredients

    @classmethod #类方法
    def from_fridge(cls, fridge):
        return cls(fridge.get_cheese() + fridge.get_vegetables())

#- 静态方法调静态方法：如果你将一个静态方法分解为几个静态方法，你不需要硬编码类名但可以使用类方法
class Pizza(object):
 def __init__(self, radius, height):
     self.radius = radius
     self.height = height

 @staticmethod  #静态方法
 def compute_circumference(radius):
      return math.pi * (radius ** 2)

 @classmethod  #类方法
 def compute_volume(cls, height, radius):
      return height * cls.compute_circumference(radius)  #可以调用静态方法

 def get_volume(self):
     return self.compute_volume(self.height, self.radius)


#4.抽象方法
class Pizza(object):
 def get_radius(self):
     raise NotImplementedError  #任何继承自 Pizza 的类将实现和重载 get_radius 方法，否则会出现异常。

# >>> Pizza()
# <__main__.Pizza object at 0x106f381d0>

# >>> Pizza().get_radius()
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# File "<stdin>", line 3, in get_radius
# NotImplementedError

#有种提前引起错误发生的方法，那就是当对象被实例化时，使用 Python 提供的 abc 模块。
import abc
class BasePizza(object):
 __metaclass__ = abc.ABCMeta

 @abc.abstractmethod
 def get_radius(self):
     """Method that should do something."""
# 使用 abc 和它的特类，一旦你试着实例化 BasePizza 或者其他继承自它的类，就会得到 TypeError：
# >>> BasePizza()
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# TypeError: Can't instantiate abstract class BasePizza with abstract methods get_radius

def get_primes(number):
    while True:
        if is_prime(number):
            number = yield number   #如普通函数return一样将值返回给调用则
        number += 1

def print_successive_primes(iterations, base=10):
    prime_generator = get_primes(base)
    prime_generator.send(None)  #必须调用设置None才能 通过 send 方法来将一个值“发送”给生成器。
    for power in range(iterations):
        print(prime_generator.send(base ** power))  #发生send值

# 首先我们打印的是 generator.send 的结果是OK的，因为 send 在发送数据给生成器的同时还返回生成器通过 yield 生成的值（就如同生成器中 yield 语句做的那样）。
# 看一下 prime_generator.send(None) 这一行，当你用 send 来“启动”一个生成器时（就是从生成器函数的第一行代码执行到第一个 yield 语句的位置），你必须发送 None。这
# 不难理解，根据刚才的描述，生成器还没有走到第一个 yield 语句，如果我们发生一个真实的值，这时是没有人去“接收”它的。一旦生成器启动了，我们就可以像上面那样发送数据了。

import random
 
def get_data():
    """返回0到9之间的3个随机数"""
    return random.sample(range(10), 3)
 
def consume():
    """显示每次传入的整数列表的动态平均值"""
    running_sum = 0
    data_items_seen = 0
 
    while True:
        data = yield  #生成器接收点 关键点
        data_items_seen += len(data)   # 每次调用值将会保留，下次执行的时候将会调用该值
        running_sum += sum(data)       #
        print('The running average is {}'.format(running_sum / float(data_items_seen)))
 
def produce(consumer):
    """产生序列集合，传递给消费函数（consumer）"""
    while True:
        data = get_data()
        print('Produced {}'.format(data))
        consumer.send(data) #关键点   #通过 send 方法来将一个值“发送”给生成器。
        yield  #设置生成器
 
if __name__ == '__main__':
    consumer = consume()
    consumer.send(None)  #启动生成器
    producer = produce(consumer)
 
    for _ in range(3):
        print('Producing...')
        next(producer)

########### 执行结果 ################
# 传递进去的值不会随着函数接收而消失,而是暂时进行了保存（以供下次使用）;
# Producing...
# Produced [0, 9, 8]
# The running average is 5.666666666666667
# Producing...
# Produced [2, 3, 1]
# The running average is 3.8333333333333335
# Producing...
# Produced [3, 5, 2]
# The running average is 3.666666666666666

def __setattr__(self, name, value):
        self.name = value + 1  #每当属性被赋值的时候， __setattr__() 会被调用，而里边的 self.name = value + 1 语句又会再次触发 __setattr__() 调用，导致无限递归。

        self.__dict__[name] = value + 1  #方法1
        super().__setattr__(name, value+1) #方法2


>>> dir(super) #注意超类没有 __getattr__ 方法
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__self_class__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__thisclass__']

class Counter:
        def __init__(self):
                super().__setattr__('counter', 0)
        def __setattr__(self, name, value):
                super().__setattr__('counter', self.counter + 1) #关键点
                super().__setattr__(name, value)
        def __delattr__(self, name):
                super().__setattr__('counter', self.counter - 1)  #关键点
                super().__delattr__(name)


#值得学习
class MyDes:
        def __init__(self, value = None):
                self.val = value
        def __get__(self, instance, owner):
                return self.val ** 2

class Test(MyDes):
        x = MyDes(3)
    #注意不能下面这样进行调用
        def  __init__(self):
            self.x = myDes(3)

test = Test()
print(test.x)  # 9 

######### 属性访问 ##############
# >>> c = Counter()
# >>> c.x = 1
# >>> c.counter
# 1
# >>> c.y = 1
# >>> c.z = 1
# >>> c.counter
# 3
# >>> del c.x
# >>> c.counter
# 2

 # a.py
from b import y
def x():
    print('x')

# b.py
from a import x
def y():
    print('y')

>>>  #这个是循环嵌套导入问题，都会抛出 ImportError 异常
Traceback (most recent call last):
  File "/Users/FishC/Desktop/a.py", line 1, in <module>
    from b import x
  File "/Users/FishC/Desktop/b.py", line 1, in <module>
    import a
  File "/Users/FishC/Desktop/a.py", line 1, in <module>
    from b import x
ImportError: cannot import name 'x'
#这是因为在执行其中某一个文件（a.py）的加载过程中，会创建模块对象并执行对应的字节码。但当执行第一个语句的时候需要导入另一个文件（from b import y），因此 CPU 会转而去加载另一个文件（b.py）。同理，执行另一个文件的第一个语句（from a import x）恰好也是需要导入之前的文件（a.py）

# 执行 b.py -> import a -> 查找 a 模块 -> 未发现 a 模块对象 -> 导入 a.py -> import b -> 查找 b 模块 -> 发现 b 模块对象 -> 接着往下执行字节码（import a 已执行过，Python 有机制确保不重复导入，因而不会再执行） -> a.x() -> 在 a 模块中找不到 x()，因为 a 还没有被完全导入嘛……

#解决方法
# a.py
import b
def x():
    print('x')

if __name__ == "__main__":
    b.y()

# b.py
import a
def y():
    print('y')

if __name__ == "__main__":
    a.x()

# 该模块用于让 Python 支持常量操作
class Const:    
    def __setattr__(self, name, value):
        if name in self.__dict__:
            raise TypeError('常量无法改变！')
            
        if not name.isupper():
            raise TypeError('常量名必须由大写字母组成！')

        self.__dict__[name] = value

'''
sys.modules 是一个字典，它包含了从 Python 开始运行起，被导入的所有模块。键就是模块名，值就是模块对象。
'''
import sys
sys.modules[__name__] = Const()


# 实际案例1:
# const 模块就是这道题要求我们自己写的
# const 模块用于让 Python 支持常量操作
import const

const.NAME = "FishC"  #定义一个常量
print(const.NAME)

try:
    # 尝试修改常量
    const.NAME = "FishC.com"
except TypeError as Err:
    print(Err)

try:
    # 变量名需要大写
    const.name = "FishC"
except TypeError as Err:
    print(Err)

#实现一个功能与 reversed() 相同（内置函数 reversed(seq) 是返回一个迭代器，是序列 seq 的逆序显示）的生成器
>>> for i in myRev("FishC"):
    print(i, end='')

ChsiF
def myRev(data):
    # 这里用 range 生成 data 的倒序索引
    # 注意，range 的结束位置是不包含的
    for index in range(len(data)-1, -1, -1):
        yield data[index]

>>> D.__mro__
(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

class A():
    def __init__(self):
        print("进入A…")
        print("离开A…")

class B(A):
    def __init__(self):
        print("进入B…")
        super().__init__() #超类
        print("离开B…")
        
class C(A):
    def __init__(self):
        print("进入C…")
        super().__init__() #超类
        print("离开C…")

class D(B, C):
    def __init__(self):
        print("进入D…")
        super().__init__() #超类
        print("离开D…")

############## 执行结果  ###############
# >>> d = D()
# 进入D…
# 进入B…
# 进入C…
# 进入A…
# 离开A…
# 离开C…
# 离开B…
# 离开D…

#设点 A(X1,Y1)、点 B(X2,Y2)，则两点构成的直线长度 |AB| = √((x1-x2)^2+(y1-y2)^2)
# Python 中计算开根号可使用 math 模块中的 sqrt 函数
# 直线需有两点构成，因此初始化时需有两个点（Point）对象作为参数

#!/usr/bin/python3
#方法1：继承
import math

class Point:
    #初始化坐标
    def __init__(self,x1=0,y1=0,x2=0,y2=0):
        self.X1 = x1
        self.X2 = x2
        self.Y1 = y1
        self.Y2 = y2

class Line(Point):
    msg = ''
    def __init__(self,msg,x1, y1, x2, y2):
        super().__init__(x1, y1, x2, y2)
        self.msg = msg
        print("坐标信息 (%d,%d), (%d,%d)" %(self.X1,self.Y1,self.X2,self.Y2))
    def getLen(self):
        print("当前Tips:%s,计算中....." %self.msg)
        return math.sqrt((self.X1 - self.X2) * (self.X1 - self.X2) + (self.Y1 - self.Y2) * (self.Y1 - self.Y2))

zhixian = Line('计算两点之间距离',1,1,4,5)
print(zhixian.getLen())

#方法2：传入对象类似于继承(值得学习)
class Point1():
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def getX(self):
        return self.x

    def getY(self):
        return self.y

class Line1():
    def __init__(self, p1, p2):
        self.x = p1.getX() - p2.getX()
        self.y = p1.getY() - p2.getY()
        self.len = math.sqrt(self.x*self.x + self.y*self.y)

    def getLen(self):
        return self.len

############## 执行结果  ###############
# 坐标信息 (1,1), (4,5)
# 当前Tips:计算两点之间距离,计算中.....
# 5.0

#!/usr/bin/python3
#功能：采用字典的方式来扩展对象方法 （值得学习）

class PlugIn(object): #注意这里的参数
    def __init__(self):
        self._exported_methods = []
        
    def plugin(self, owner):   #owner 即 我们combine 实例化的对象
        for f in self._exported_methods:
            print("类方法名 ："+f.__name__," 类方法地址：",f)             #实际是AFeature/BFeature 方法名/方法地址地址
            owner.__dict__[f.__name__] = f                              #在实例化对象c的字典之中加入将其他类方法

    def plugout(self, owner):
        for f in self._exported_methods:
            del owner.__dict__[f.__name__]

#注意这里是扩展的Plugin类
class AFeature(PlugIn):
    def __init__(self):
        super(AFeature, self).__init__()                #使用超类进行父类初始化
        self._exported_methods.append(self.get_a_value) #初始化的时候讲本类的方法地址传入到父类的列表之中 （重点）

    def get_a_value(self):
        print("c可以被调用 a feature.")

#注意这里是扩展的Plugin类
class BFeature(PlugIn):
    def __init__(self):
        super(BFeature, self).__init__()
        self._exported_methods.append(self.get_b_value)

    def get_b_value(self):
        print("c可以被调用 b feature.")

class Combine:
  pass

c = Combine()
print("Plugin 中 owner 即是传入的 c 对象地址：",c)
AFeature().plugin(c)   #作为插件 将A类中方法通过插件 加入到 c 对象中
BFeature().plugin(c)   #同上
c.get_a_value()
c.get_b_value()

#######################执行结果###########################
# >python demo3.6.py
# Plugin 中 owner 即是传入的 c 对象地址： <__main__.Combine object at 0x000001D024DBDC18>
# 类方法名 ：get_a_value  类方法地址： <bound method AFeature.get_a_value of <__main__.AFeature object at 0x000001D024DBDCC0>>
# 类方法名 ：get_b_value  类方法地址： <bound method BFeature.get_b_value of <__main__.BFeature object at 0x000001D024DBDC88>>
# c可以被调用 a feature.
# c可以被调用 b feature.

#!/usr/bin/python3
#功能：采用魔术方法实现定时器
import time as t

class MyTimer:
    def __init__(self):
        self.prompt = "未开始计时！"
        self.lasted = 0.0
        self.begin = 0
        self.end = 0
        self.default_timer = t.perf_counter
    
    def __str__(self):
        return self.prompt

    __repr__ = __str__

    def __add__(self, other):
        result = self.lasted + other.lasted
        prompt = "总共运行了 %0.2f 秒" % result
        return prompt
    
    # 开始计时
    def start(self):
        self.begin = self.default_timer()
        self.prompt = "提示：请先调用 stop() 停止计时！"
        print("计时开始...")

    # 停止计时
    def stop(self):
        if not self.begin:
            print("提示：请先调用 start() 进行计时！")
        else:
            self.end = self.default_timer()
            self._calc()
            print("计时结束！")

    # 内部方法，计算运行时间
    def _calc(self):
        self.lasted = self.end - self.begin
        self.prompt = "总共运行了 %0.2f 秒" % self.lasted
        
        # 为下一轮计时初始化变量
        self.begin = 0
        self.end = 0

    # 设置计时器(time.perf_counter() 或 time.process_time())
    def set_timer(self, timer):
        if timer == 'process_time':
            self.default_timer = t.process_time
        elif timer == 'perf_counter':
            self.default_timer = t.perf_counter
        else:
            print("输入无效，请输入 perf_counter 或 process_time")

a = MyTimer()
b = MyTimer()

a.Start()
b.Start()

t.sleep(5)

a.Stop()
b.Stop()
print("a 对象", a," b 对象" ,b)
print(a + b)


# 实现程序运行计时 (实例化的时候传入 func)
class FuncTimer:
    def __init__(self, func, number=1000000):
        self.prompt = "未开始计时！"
        self.lasted = 0.0
        self.default_timer = t.perf_counter
        self.func = func
        self.number = number
    
    def __str__(self):
        return self.prompt

    __repr__ = __str__

    def __add__(self, other):
        result = self.lasted + other.lasted
        prompt = "总共运行了 %0.2f 秒" % result
        return prompt

    # 内部方法，计算运行时间
    def timing(self):
        self.begin = self.default_timer()
        for i in range(self.number):
            self.func()
        self.end = self.default_timer()
        self.lasted = self.end - self.begin
        self.prompt = "总共运行了 %0.2f 秒" % self.lasted
        
    # 设置计时器(time.perf_counter() 或 time.process_time())
    def set_timer(self, timer):
        if timer == 'process_time':
            self.default_timer = t.process_time
        elif timer == 'perf_counter':
            self.default_timer = t.perf_counter
        else:
            print("输入无效，请输入 perf_counter 或 process_time")

######## 执行结果 #############
# 计时开始...
# 计时开始...
# 计时停止!
# 计时停止!
# a 对象 总共运行了5秒  b 对象 总共运行了5秒
# 总共运行了10秒

#!/usr/bin/python3
#温湿度类实现：摄氏度,华氏度

#摄氏度类
class Celsius:
    #初始化构造方法
    def __init__(self,value = 26.0):
        self.value = float(value)

    def __get__(self,instance,owner):
        return self.value

    def __set__(self,instance,value):
        self.value =float(value)

#华氏度类
class Fahrenheit:
    def __get__(self,instance,owner):
        return instance.cel * 1.8 + 32            #返回华氏度 关键点

    def __set__(self,instance,value):
        instance.cel = (float(value) - 32) / 1.8  #返回摄氏度  关键点

#温度类
class Tempareture:
    cel = Celsius()     #摄氏度类
    fah = Fahrenheit()  #华氏度类


temp = Tempareture()
temp.cel = 37.5                                              #进行赋值的时候 cel 对象 value 属性 = 37.5
print("摄氏度 ：%.2f  , 华氏度 ：%.2f" %(temp.cel,temp.fah))  #temp.fah 进行请求触发 华氏度类 __get__  => 返回华氏度的计算后的值
temp.fah = 75.0
print("摄氏度 ：%.2f  , 华氏度 ：%.2f" %(temp.cel,temp.fah))


############ 执行结果 #############
# 摄氏度 ：37.50  , 华氏度 ：99.50
# 摄氏度 ：23.89  , 华氏度 ：75.00

#1. 只需要重载 __lshift__ 和 __rshift__ 魔法方法即可
class Nstr(str):
    def __lshift__(self, other):
        return self[other:] + self[:other]    #值得学习 LED 液晶显示平

    def __rshift__(self, other):
        return self[-other:] + self[:-other]  #

############### 执行结果 #############
# >>> a = Nstr('I love FishC.com!')
# >>> a << 3
# 'ove FishC.com!I l'
# >>> a >> 3
# 'om!I love FishC.c'


#2.  定义一个类 Nstr，当该类的实例对象间发生的加、减、乘、除运算时，将该对象的所有字符串的 ASCII 码之和进行计算：
# 注意我们必须要用到 __new__ 方法，因为 str 是不可变类型
# 所以我们必须在创建的时候将它初始化
class Nstr(int):
    def __new__(cls, arg=0):
        if isinstance(arg, str):
            total = 0
            for each in arg:
                total += ord(each)  #转换成ascii码
            arg = total
        return int.__new__(cls, arg)  #返回实例初始化处理后的结果

############### 执行结果 #############
# >>> a = Nstr('FishC')
# >>> b = Nstr('love')
# >>> a + b
# 899
# >>> a - b
# 23
# >>> a * b
# 201918
# >>> a / b
# 1.052511415525114
# >>> a // b
# 1

class CountList(list):
    def __init__(self, *args):
        super().__init__(args)
        self.count = []
        for i in args:
            self.count.append(0)

    def __len__(self):
        return len(self.count)

    def __getitem__(self, key):
        self.count[key] += 1
        return super().__getitem__(key)

    def __setitem__(self, key, value):
        self.count[key] += 1
        super().__setitem__(key, value)

    def __delitem__(self, key):
        del self.count[key]
        super().__delitem__(key)

    def counter(self, key):
        return self.count[key]

    def append(self, value):
        self.count.append(0)
        super().append(value)

    def pop(self, key=-1):
        del self.count[key]
        return super().pop(key)

    def remove(self, value):
        key = super().index(value)
        del self.count[key]
        super().remove(value)

    def insert(self, key, value):
        self.count.insert(key, 0)
        super().insert(key, value)

    def clear(self):
        self.count.clear()
        super().clear()

    def reverse(self):
        self.count.reverse()
        super().reverse()