Python-面向对象练习1

1、随机数生成类：

思路：
    1、考虑实例化，将这些参数传给具体的实例，这是最普的写法
    2、生成是一个工具类，只用来提供功能 ---这种要好好考虑
    3、因为是一个生成问题，可以使用生成器
    4、生成器返回的只是格式，参数还是会根据具体情况改变的

　　参考代码：　

# # 常规类实现：
import random

class RandomGen:
    def __init__(self, start=1, stop=10, patch=10):
        self.start = start
        self.stop = stop
        self.patch = 10

    def generate(self):
        return [random.randint(self.start, self.stop) for _ in range(self.patch)]

# 作为工具类来实现，提供方法
class RandomGen:
    @classmethod
    def generate(cls,start=1, stop=100, patch=10):
        return [random.randint(start, stop) for _ in range(patch)]

print(RandomGen.generate())
# 作为工具类的生成器类型:
class RandomGen:
    @classmethod
    def generate(cls,start=1, stop=100, patch=10):
        while True:
            yield [random.randint(start, stop) for _ in range(patch)]

for _ in range(3):
    print(next(RandomGen.generate()))


# 普通类 的生成器 类型：
class RandomGen:
    def __init__(self, start=1, stop=100, patch=10):
        self.start = start
        self.stop  = stop
        self.patch = patch
        self._gen = self._generate()

    def _generate(self):
        while True:
            yield  random.randint(self.start, self.stop)

    def generate(self, count=10):
        patch = self.patch if count <= 10 else count
        return [next(self._gen) for _ in range(patch)]

t = RandomGen()
print(t.generate())


print("---" * 40)
#
class RandomGen:
    def __init__(self, start=1, stop=100, patch=10):
        self.start = start
        self.stop  = stop
        self.patch = patch
        self._gen = self._generate()

    def _generate(self):
        while True:
            yield  [random.randint(self.start, self.stop) for _ in range(self.patch)]

    def generate(self, count=10):
        if count < 10:
            self.patch = count
        return next(self._gen)

t = RandomGen()
print(t.generate())
print(t.generate(5))

2、打印坐标，利用上题的结果，两两配对，打印出来，扩展，求两点之间的距离：

思路：
    1、可以设计一个坐标类，用来放着写坐标，以便以后用这些坐标计算，比如距离
    2、两两配对，首选zip（）方法
    3、尽量找到参与方，封装出类来。如果写出来的东西根函数没有什么区别，那就不是面向对象，要多想想
    4、求两点之间的距离----实现

　　参考代码：

import  math
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance(self, p): # 求两点之间的距离
        dis = math.sqrt(abs(self.y - p.y) ** 2 + abs(self.x - p.x) ** 2)
        return dis

points = [Point(x, y) for x, y in zip(range(5), range(5))]
print(points) # [<__main__.Point object at 0x0000000002122160>, <__main__.Point object at 0x0000000002226C50>, <__main__.Point object at 0x0000000002948048>, <__main__.Point object at 0x0000000002948400>, <__main__.Point object at 0x0000000002948320>]
for p in points:
    print(p.x, p.y)

 3、记录车的品牌，颜色，价格，速度等信息，实现增加车辆信息，并输出所有车辆信息

思路：
    1、增加车的信息，是类的功能，而不是车的功能，车可以显示自己的信息
    2、使用filter 过滤掉不可以显示的内容，__dict__
    3、获取所有车的信息，要提供参数，否则一下子把之前的所有的车的信息都显示了，比如：注册时间，等，用来过滤
        类似的额，只要get_all 这样的额，返回数据比较多的，一般都要过滤，或者一批一批显示
    4、往往都是yield，一批一批显示
    5、并不是所有的类都需要实例化，像CarInfo，只需要Car的实例的信息，最终显示的是所有车的信息，只需要一个类方法下来显示即可
    6、比如 三个车辆管理中心，可以联网，就可以值用一个类变量，如果没联网，可以只显示自己管辖区的

 

　　参考代码：

class Car:
    def __init__(self, color, mark , price, speed):
        self.color = color
        self.mark = mark
        self.price = price
        self.speed = speed
    def getcarinfo(self):
        return self.__dict__
    def __repr__(self):
        return '<{} {} {} {} {}>'.format(type(self).__name__, self.mark,
                                         self.color, self.price, self.speed)
class CarInfo:
    # info = []
    def __init__(self):
        self.info = []
    def addcar(self, car:Car):
        self.info.append(car)
    def getall(self):
        return self.info
car1 = Car('red', 'QQ', 20, 20)
# print(car1.getcarinfo())
c1 = CarInfo()
c1.addcar(car1)
print(car1) # <__main__.Car object at 0x0000000002998710>
print(c1.getall())

4、温度转换：华氏， 摄氏，开氏温度之间的相互转换：

 思路：

1、可能用到的值，先求出来，的用到时，直接给       或者， 先不求，等用到的时候，在求，再提供
2、因为常用到的是摄氏度，所以以摄氏度为中心，转换为其他的单位
3、既能当工具，追踪某种温度的转换，-----又能做转换，一下子全部返回
4、所以这个类设计的像一个工具类：
　　温度转换可以使用实例的方法，也可以使用类的方法，使用类方法的原因是，为了不创建对象，就可以直接换算

参考代码：

#像这样的思路是完成了一个 不仅仅只转换一个温度
# 比如只需要c2f ，通过类调用c2f 方法即可
# 如果需要 37摄氏度对应的其他所有温度，可以实例调用属性获取
# 此外，需要什么温度，算出什么温度，而不是，传入温度，都算出来
class Temparture:
    def __init__(self, t, unit='c'):
        self._c = None
        self._f = None
        self._k = None
        # 因为一般使用摄氏度的时候多，所以将传进来的温度，都转换为摄氏度
        if unit == 'f':
            self._f = t
            self._c = self.f2c(t)
        elif unit == 'k':
            self._k = t
            self._c = self.k2c(t)
        else:
            self._c = t
    #通过属性装饰器，调用保护变量，而且需要的时候才计算
    @property
    def c(self):
        return self._c
    @property
    def f(self):
        if self._f == None:
            self._f = self.c2f(self._c)
        return self._f
    @property
    def k(self):
        if self._k == None:
            self._k = self.c2k(self._c)
        return self._k

    @classmethod
    def c2f(cls, c):
        return 9 * c / 5 + 32
    @classmethod
    def f2c(cls, f):
        return 5 * (f - 32) / 9
    @classmethod
    def c2k(cls, c):
        return  c + 273.15
    @classmethod
    def k2c(cls, k):
        return k - 273.15
    @classmethod
    def f2k(cls, f):
        return cls.c2k(cls.f2c(f))
    @classmethod
    def k2f(cls, k):
        return cls.c2f(cls.k2c(k))

print(Temparture.c2f(40))

t = Temparture(37)
print(t.c, t.k, t.f)


t = Temparture(37, 'k')
print(t.c, t.k, t.f)

5、模拟购物车购物：

思想：

1. 购物车购物，分解得到两个对象，购物车，物品，一个操作购买
2. 购买不是购物车的行为，其实是人的行为，但是对于购物车来说就是增加add
3. 商品有很多种类，商品的属性多种多样，怎么解决？
4. 购物车可以加入很多不同的商品，如何实现？

 

　　参考代码：

class Color:
    RED = 0
    BLUE = 1
    GREEN = 2
    OTHER = 1000

# 货物类
class Item:
    def __init__(self, mark, price, **kwargs):
        self.mark = mark
        self.price = price
        self.__dict__.update(kwargs)

    def __repr__(self):
        return str(sorted(self.__dict__))

class Cart:
    def __init__(self):
        self.items = []
        
    def additem(self, item:Item):
        self.items.append(item)
        
    def getallitems(self):
        return self.items