Python入门篇-面向对象概述

　　　　　　　　　　　　　Python入门篇-面向对象概述

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

一.语言的分类

面向机器
　　抽象成机器指令，机器容易理解
　　代表:汇编语言

面向过程 
　　做一件事情，排出个步骤，第一步干什么，第二步干什么，如果出现情况A，做什么处理，如果出现了情况B，做什么处理。
　　问题规模小，可以步骤化，按部就班处理。
　　代表:C语言

面向对象OOP 
　　随着计算机需要解决的问题的规模扩大，情况越来越复杂。需要很多人、很多部门协作，面向过程编程不太适合了。
　　代表:C++、Java、Python等

二.面向对象三要素

1>.什么是面向对象

什么是面向对象呢?
　　一种认识世界、分析世界的方法论。将万事万物抽象为各种对象。

类class 
　　类是抽象的概念，是万事万物的抽象，是一类事物的共同特征的集合。 
　　用计算机语言来描述类，是属性和方法的集合。

对象instance、object
　　对象是类的具象，是一个实体。 
　　对于我们每个人这个个体，都是抽象概念人类的不同的实体。

举例:
　　你吃鱼：
　　　　你，就是对象;鱼，也是对象;吃就是动作
　　　　你是具体的人，是具体的对象。你属于人类，人类是个抽象的概念，是无数具体的人的个体的抽象。
　　　　鱼，也是具体的对象，就是你吃的这一条具体的鱼。这条鱼属于鱼类，鱼类是无数的鱼抽象出来的概念。
　　　　吃，是动作，也是操作，也是方法，这个吃是你的动作，也就是人类具有的方法。如果反过来，鱼吃人。吃就是鱼类的动作了。
　　　　吃，这个动作，很多动物都具有的动作，人类和鱼类都属于动物类，而动物类是抽象的概念，是动物都有吃的动作，但是吃法不同而已。
　　你驾驶车：
　　　　这个车也是车类的具体的对象(实例)，驾驶这个动作是鱼类不具有的，是人类具有的方法。

属性:
　　它是对象状态的抽象，用数据结构来描述。

操作:
　　它是对象行为的抽象，用操作名和实现该操作的方法来描述。
　　每个人都是人类的一个单独的实例，都有自己的名字、身高、体重等信息，这些信息是个人的属性，但是，这些信息不能保存在人类中，因为它是抽象的概念，不能保留具体的值。
　　而人类的实例，是具体的人，他可以存储这些具体的属性，而且可以不同人有不同的属性。

哲学
　　一切皆对象
　　对象是数据和操作的封装 对象是独立的，但是对象之间可以相互作用。 
　　目前OOP是最接近人类认知的编程范式。

2>.面向对象三要素

封装
　　组装:将数据和操作组装到一起。
　　隐藏数据:对外只暴露一些接口，通过接口访问对象。比如驾驶员使用汽车，不需要了解汽车的构造细节，只需要知道使用什么部件怎么驾驶就行，踩了油门就能跑，可以不了解其中的机动原理。
　　博主推荐阅读：https://www.cnblogs.com/yinzhengjie/p/11161519.html

继承
　　多复用，继承来的就不用自己写了
　　多继承少修改，OCP(Open-closed Principle)，使用继承来改变，来体现个性 
　　博主推荐阅读：https://www.cnblogs.com/yinzhengjie/p/11173836.html

多态
　　面向对象编程最灵活的地方，动态绑定
　　博主推荐阅读：https://www.cnblogs.com/yinzhengjie/p/11179289.html

举例：
　　人类就是封装; 
　　人类继承自动物类，孩子继承父母特征。分为单一继承、多继承; 
　　多态，继承自动物类的人类、猫类的操作”吃“不同。

三.Python的类

1>.Python类定义格式

class ClassName:
    语句块。

Python类定义格式如上所示，我们需要注意以下几点：
    1. 必须使用class关键字
    2. 类名必须是用大驼峰，本质上就是一个标识符
    3. 类定义完成后，就产生了一个类对象，绑定到了标识符ClassName上

2>.类对象及类属性

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

class MyClass:
    """ A Example Class."""
    CLASSNAME = "bigdata & devops"      #类属性，也可以称之为类的变量。需要注意它和实例变量的区别。实例变量是每一个实例自己的变量，是自己独有的;类变量是类的变量，是类的所有实例共享的属性和方法。一般来说，类变量可使用全大写来命名。即表示常量。

    """
        1>.通常，每次实例化后获得的实例，是不同的实例，即使是使用同样的参数实例化，也得到不一样的对象。和Java语法类似，Python类实例化过程中，
    首先会调用new方法进行实例化（可以理解为创建出对象），然后会自动调用 __init__ 方法（可以理解为对已经创建出的对象进行初厂设置）。这个方法第
    一个形式参数必须留给self，其它形式参数随意。
        2>.该方法可以不定义，如果定义会在实例化后隐式调用。它的作用就是对实例进行初始化。 
        3>.该方法不能有返回值，也就是只能return None。
    """
    def __init__(self,name:str,age:int):
        """
            我们知道self表示的是当前实例对象，我们这里为当前实例绑定2个实例变量（即name和age），它并不属于类属性，它属于实例对象。
        """
        self.name = name
        self.age = age

    """
        类的普通方法（method），也是类属性。本质上就是普通的函数对象function，它一般要求至少有一个参数。第一个形式参数可以是self(self只是个
    惯用标识符，可以换名字)，这个参数位置就留给了self。它指代当前实例本身。
        类实例化后，得到一个实例对象,实例对象会绑定到方法上,即会把方法的调用者实例作为第一参数self的实参传入。
    """
    def showme(self):             #类
        return self.name


print(MyClass)                     #不会调用"__init__"方法，因为咱们没有对MyClass类进行实例化操作。
print(MyClass.showme)
print(MyClass.__doc__)             #注意，这里的"__doc__"也是类的特殊属性。
print(MyClass.__name__)            #对象名
print(MyClass.__class__)           #对象的类型
print(MyClass.__dict__)            #对象的属性字典
print(MyClass.__qualname__)        #类的限定名

print("{0} {1} {0}".format("*"*10,"注意：Python中每一种对象都拥有不同的属性。函数是对象，类是对象，类的实例也是对象。"))

s1 = MyClass("Jason",18)           #实例化过程中会自动调用"__init__"方法进行初始化操作，然后类实例化后一定会获得一个类的实例，它就是实例对象s1。
print(s1.showme())                 #s1是Myclass类实例化后得到的一个实例对象，实例对象会绑定到方法上，因此我们这里就不需要为 showme(self)方法传参，直接调用即可，如果有2个或以上参数那调用时除了第一个参数不需要传递外，其他参数依旧是要传入的哟。
print(s1.__dict__)




#以上代码输出结果如下:
<class '__main__.MyClass'>
<function MyClass.showme at 0x10215fae8>
 A Example Class.
MyClass
<class 'type'>
{'__module__': '__main__', '__doc__': ' A Example Class.', 'CLASSNAME': 'bigdata & devops', '__init__': <function MyClass.__init__ at 0x10215f950>, 'showme': <function MyClass.showme at 0x10215fae8>, '__dict__': <attribute '__dict__' of 'MyClass' objects>, '__weakref__': <attribute '__weakref__' of 'MyClass' objects>}
MyClass
********** 注意：Python中每一种对象都拥有不同的属性。函数是对象，类是对象，类的实例也是对象。 **********
Jason
{'name': 'Jason', 'age': 18}

3>.实例属性的查找顺序 

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

"""
总结
    是类的，也是这个类所有实例的，其实例都可以访问到;
    是实例的，就是这个实例自己的，通过类访问不到。
    类变量是属于类的变量，这个类的所有实例可以共享这个变量。
    对象(实例或类)可以动态的给自己增加一个属性(赋值即定义一个新属性)。
    实例.__dict__[变量名] 和 实例.变量名 都可以访问到实例自己的属性(注意这两种访问是有本质区别的)。 实例的同名变量会隐藏掉类变量，或者说是覆盖了这个类变量。但是注意类变量还在那里，并没有真正被覆盖。

实例属性的查找顺序
    指的是实例使用 .点号 来访问属性，会先找自己的 __dict__ ，如果没有，然后通过属性 __class__ 找到自己的类，再去类的 __dict__ 中找
    注意:如果实例使用 __dict__[变量名] 访问变量，将不会按照上面的查找顺序找变量了，这是指明使用字典的key 查找，不是属性查找。
"""

class Person:
    age = 3         #一般来说，类变量可使用全大写来命名。我们这里为了实验效果，故意将类变量和实例变量命令部分重复以达到测试目的。
    height = 170

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


tom = Person("Tom")
jason = Person("Jason",20)

Person.age = 30
print(1,Person.age,tom.age,jason.age)
print(2,Person.height,tom.height,jason.height)

jason.height = 175      #动态为jason对象设置"height"属性
print(3,Person.height,tom.height,jason.height)

tom.height += 10        #其实等价于tom.height = tom.height + 10,由于tom的"__dict__"没有"height"属性，因此它会去Person类的"__dict__中找"
print(4,Person.height,tom.height,jason.height)

Person.height += 15
print(5,Person.height,tom.height,jason.height)

Person.weight = 70
print(6,Person.weight,tom.weight,jason.weight)

print(7,Person.__dict__)
print(8,tom.__dict__)
print(9,jason.__dict__)

print(10,tom.__dict__["height"])
# print(11,tom.__dict__["weight"])      #会抛出"KeyError: 'weight'"异常！



#以上代码输出结果如下:
1 30 18 20
2 170 170 170
3 170 170 175
4 170 180 175
5 185 180 175
6 70 70 70
7 {'__module__': '__main__', 'age': 30, 'height': 185, '__init__': <function Person.__init__ at 0x10205fae8>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None, 'weight': 70}
8 {'name': 'Tom', 'age': 18, 'height': 180}
9 {'name': 'Jason', 'age': 20, 'height': 175}
10 180

四.装饰一个类（即类装饰器）

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

"""
    需求，为一个类通过装饰，增加一些类属性。例如能否给一个类增加一个NAME类属性并提供属性值.
"""
def add_name(name):
    def wrapper(cls):
        cls.NAME = name
        return cls
    return wrapper

@add_name("Jason")
class Person:
    AGE = 18

print(Person.NAME)      #之所以能够装饰，本质上是为类对象动态的添加了一个属性，而Person这个标识符指向这个类对象。



#以上代码输出结果如下:
Jason

五.类方法和静态方法

1>.普通函数（最好禁止在类中定义无参函数）

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def normal_method():    #注意:在Python中虽然语法是对的，但是，没有人这么用，也就是说禁止这么写
        print("normal")


Person.normal_method()      #可以放在类中定义，因为这个方法只是被Person这个名词空间管理的一个普通的方法，normal_method是Person 的一个属性而已。类是可以调用的，但该类的实例不能调用该方法。

p1 = Person("Jason",18)

# p1.normal_method()       #由于normal_method在定义的时候没有指定形参self，所以不能完成实例对象的绑定，因此p1实例不能调用。只要一调用就会为normal_method传递一个self参数，而原方法是一个无参函数。只要一调用该方法就报错！！！

2>.类方法 

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    """
    类方法：(类似于C++、Java中的静态方法)
        1>.在类定义中，使用@classmethod装饰器修饰的方法 
        2>.必须至少有一个参数，且第一个参数留给了cls，cls指代调用者即类对象自身 
        3>.cls这个标识符可以是任意合法名称，但是为了易读，请不要修改
        4>.通过cls可以直接操作类的属性

    注意:无法通过cls操作类的实例。为什么?
    """
    @classmethod
    def class_method(cls):
        print("class = {0.__name__} ({0})".format(cls))
        print("class = {0.__dict__} ({0})".format(cls))


Person.class_method()           #使用类对象直接调用类方法，访问的是类的属性

jason = Person("Jason",18)
jason.class_method()            #使用类的实例化对象调用类方法，访问的还是类的属性



#以上代码输出结果如下:
class = Person (<class '__main__.Person'>)
class = {'__module__': '__main__', '__init__': <function Person.__init__ at 0x10215fae8>, 'class_method': <classmethod object at 0x1005aea58>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None} (<class '__main__.Person'>)
class = Person (<class '__main__.Person'>)
class = {'__module__': '__main__', '__init__': <function Person.__init__ at 0x10215fae8>, 'class_method': <classmethod object at 0x1005aea58>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None} (<class '__main__.Person'>)

3>.静态方法

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    @classmethod
    def class_method(cls):
        print("class = {0.__name__} ({0})".format(cls))
        cls.HEIGHT = 170
    """
    静态方法
        1>.在类定义中，使用@staticmethod装饰器修饰的方法
        2>.调用时，不会隐式的传入参数
        静态方法，只是表明这个方法属于这个名词空间。函数归在一起，方便组织管理。
    """
    @staticmethod
    def static_methd(cls):
        print(Person.HEIGHT)

Person.class_method()

jason = Person("Jason",18)

Person.static_methd(jason)          #使用类对象调用静态方法时，需要手动传入参数。

print(Person.__dict__)
print(jason.__dict__)

#以上代码执行结果如下:
class = Person (<class '__main__.Person'>)
170
{'__module__': '__main__', '__init__': <function Person.__init__ at 0x10205fae8>, 'class_method': <classmethod object at 0x102061208>, 'static_methd': <staticmethod object at 0x102061080>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None, 'HEIGHT': 170}
{'name': 'Jason', 'age': 18}

4>.方法的调用

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

"""
    类可以定义这么多种方法，究竟如何调用它们?
    总结：
        类除了普通方法都可以调用，普通方法需要类对象的实例作为第一参数。
        实例可以调用所有类中定义的方法(包括类方法、静态方法)，普通方法传入实例自身，静态方法和类方法需要找到实例的类(因为实例"__dict__"中没有
    静态方法和类方法属性，他得去实例的类中"__dict__"的去查找想要的属性)。
"""


class Person:
    """
        我们称没有用"classmethod"或"staticmethod"装饰器修饰的方法为普通方法。
        类几乎可以调用所有内部定义的方法，但是调用普通的方法时会报错，原因是第一参数必须是类的实例。
        实例也几乎可以调用所有的方法， 普通的函数的调用一般不可能出现，因为原则上不允许这么定义。
    """
    def method(self):
        print("{}'s method".format(self))

    @classmethod
    def class_method(cls):  # cls是什么
        print('class = {0.__name__} ({0})'.format(cls))
        cls.HEIGHT = 170

    @staticmethod
    def static_methd():
        print(Person.HEIGHT)

print("{0} {1} {0}".format("*"*10,"类访问"))
#print(1, Person.method())           #会抛出异常，因为咱们类调用普通方法需要手动传参数，而实例调用由于做了实例绑定，因此实例调用则不需要传参数哟。
print(2, Person.class_method())
print(3, Person.static_methd())



print("{0} {1} {0}".format("*"*10,"jason实例访问"))
jason = Person()
print(4, jason.method())
print(5, jason.class_method())
print(6, jason.static_methd())

print("{0} {1} {0}".format("*"*10,"对比类对象和类实例对象"))
print(7,"Person:{}	 Person实例:{}	".format(Person.method,jason.method))         #我们可以通过打印Person和Person实例的普通方法地址就可以看出点端倪，实例对象被普通方法做了实例绑定。
print(8,Person.__dict__)
print(9,jason.__dict__)


#以上代码输出结果如下:
********** 类访问 **********
class = Person (<class '__main__.Person'>)
2 None
170
3 None
********** jason实例访问 **********
<__main__.Person object at 0x102961208>'s method
4 None
class = Person (<class '__main__.Person'>)
5 None
170
6 None
********** 对比类对象和类实例对象 **********
7 Person:<function Person.method at 0x10295fae8>     Person实例:<bound method Person.method of <__main__.Person object at 0x102961208>>    
8 {'__module__': '__main__', '__doc__': '
        我们称没有用"classmethod"或"staticmethod"装饰器修饰的方法为普通方法。
        类几乎可以调用所有内部定义的方法，但是调用普通的方法时会报错，原因是第一参数必须是类的实例。
        实例也几乎可以调用所有的方法， 普通的函数的调用一般不可能出现，因为原则上不允许这么定义。
    ', 'method': <function Person.method at 0x10295fae8>, 'class_method': <classmethod object at 0x102907be0>, 'static_methd': <staticmethod object at 0x10294ff60>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, 'HEIGHT': 170}
9 {}

六.小试牛刀

1>.机整数生成类 

　　可以先设定一批生成数字的个数，可设定指定生成的数值的范围。运行时还可以调整每批生成数字的个数

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

import random

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

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


print(RandomGen().generate())
print(RandomGen(200,1000,5).generate())



#以上代码执行结果如下:
[25, 32, 14, 7, 15, 94, 41, 68, 85, 58]
[715, 428, 920, 954, 217]

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

import random

class RandomGen:

    @classmethod
    def generate(cls,start=1,stop=100,count=10):
        return [random.randint(start,stop) for i in range(count)]


print(RandomGen().generate())
print(RandomGen().generate(200,1000,5))



#以上代码执行结果如下:
[19, 21, 89, 86, 65, 58, 94, 29, 76, 71]
[461, 392, 229, 732, 575]

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

import random

class RandomGen:
    def __init__(self,start=1,stop=100,count=10):
        self.start = start
        self.stop = stop
        self.count = count
        self._gen = self._generate()

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

    def generate(self):
        return [next(self._gen) for i in range(self.count)]


print(RandomGen().generate())
print(RandomGen(200,1000,5).generate())



#以上代码执行结果如下:
[96, 15, 55, 87, 43, 21, 100, 55, 96, 81]
[501, 208, 657, 806, 499]

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

import random

class RandomGen:
    def __init__(self,start=1,stop=100,count=10):
        self.start = start
        self.stop = stop
        self.count = count
        self._gen = self._generate()

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

    def generate(self):
        yield from (next(self._gen) for i in range(self.count))


print(list(RandomGen().generate()))
print(list(RandomGen(200,400,5).generate()))


#以上代码执行结果如下:
[51, 25, 94, 2, 16, 75, 9, 20, 2, 21]
[285, 211, 249, 271, 309]

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

import random

class RandomGen:
    def __init__(self,start=1,stop=100,count=10):
        self.start = start
        self.stop = stop
        self.count = count
        self._gen = self._generate()

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

    def generate(self,count=0):             #可以后期在产生数据时控制个数。
        count = self.count if count <= 0 else count
        return [next(self._gen) for i in range(count)]


print(RandomGen().generate())
print(RandomGen(600,900).generate(5))


#以上代码执行结果如下:
[36, 84, 45, 26, 32, 91, 42, 75, 49, 36]
[647, 885, 642, 857, 852]

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

import random

class RandomGen:
    def __init__(self,start=1,stop=100,count=10):
        self.start = start
        self.stop = stop
        self._count = count      #保护变量
        self._gen = self._generate()

    def _generate(self):
        while True:     #一次yield一批
            yield [random.randint(self.start,self.stop) for _ in range(self._count)]

    def generate(self,count=0):             #可以后期在产生数据时控制个数。
        if count > 0:
            self._count = count
        return next(self._gen)

print(RandomGen().generate())
print(RandomGen(1000,2000).generate(5))


#以上代码执行结果如下:
[51, 20, 52, 31, 64, 47, 43, 75, 47, 98]
[1606, 1570, 1063, 1842, 1427]

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

import random

class RandomGen:
    def __init__(self,start=1,stop=100,count=10):
        self.start = start
        self.stop = stop
        self._count = count      #保护变量
        self._gen = self._generate()

    def _generate(self):
        while True:     #一次yield一批
            yield [random.randint(self.start,self.stop) for _ in range(self._count)]

    def generate(self):
        return next(self._gen)

    @property
    def count(self):
        return self._count

    @count.setter
    def count(self,count):
        self._count = count

r = RandomGen(100,200)
print(r.count)
print(r.generate())

r.count = 5
print(r.count)
print(r.generate())


#以上代码执行结果如下:
10
[130, 188, 174, 127, 180, 144, 189, 105, 146, 119]
5
[157, 145, 168, 131, 105]

2>.打印坐标 

　　使用上题中的类，随机生成20个数字，两两配对形成二维坐标系的坐标，把这些坐标组织起来，并打印输出

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

import random

class RandomGen:
    def __init__(self,start=1,stop=100,count=10):
        self.start = start
        self.stop = stop
        self._count = count      #保护变量
        self._gen = self._generate()

    def _generate(self):
        while True:     #一次yield一批
            yield [random.randint(self.start,self.stop) for _ in range(self._count)]

    def generate(self):
        return next(self._gen)

    @property
    def count(self):
        return self._count

    @count.setter
    def count(self,count):
        self._count = count

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

r = RandomGen()
points = [Point(x,y) for x,y in zip(r.generate(),r.generate())]

for p in points:
    print("{:2}:{:2}".format(p.x,p.y))


#以上代码执行结果如下:
44: 1
66:59
40: 3
92:73
90:73
22:67
98:47
82:10
17:69
36:39

3>.车辆信息 

　　记录车的品牌mark、颜色color、价格price、速度speed等特征，并实现车辆管理，能增加车辆、显示全部车辆的信息功能

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

class Car:
    def __init__(self,mark,speed,color,price):
        self.mark = mark
        self.speed = speed
        self.color = color
        self.price = price


class CarInfo:
    def __init__(self):
        self.__info = []

    def addcar(self,car:Car):
        self.__info.append(car)

    def getall(self):
        return self.__info


ci = CarInfo()
car = Car('audi',400,'red',100)
ci.addcar(car)


ci.getall()         #返回所有数据，此时再实现格式打印

4>.实现温度的处理 

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

class Temperature:
    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 is None:
            self._f = self.c2f(self._c)
        return self._f

    @property
    def k(self):        #开氏温度
        if self._k is 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 (f - 32 ) * 5 / 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(Temperature.c2f(30))
print(Temperature.f2c(108))
print(Temperature.c2k(30))
print(Temperature.k2c(520.13))
print(Temperature.f2k(108))
print(Temperature.k2f(520.13))

print("{0} 我是分割线 {0}".format("*" * 20))


t = Temperature(108,'f')
print(t.__dict__)
print(t.c,t.k,t.f)
print(t.__dict__)



#以上代码执行结果如下:
86.0
42.22222222222222
303.15
246.98000000000002
315.3722222222222
476.564
******************** 我是分割线 ********************
{'_c': 42.22222222222222, '_f': 108, '_k': None}
42.22222222222222 315.3722222222222 108
{'_c': 42.22222222222222, '_f': 108, '_k': 315.3722222222222}

5>. 模拟购物车购物 

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie


class Color:
    RED = 0
    BLUE = 1
    GREEN = 2
    GOLDEN = 3
    BLACK = 4
    OTHER = 1000


class Item:
    def __init__(self,**kwargs):
        self.__spec = kwargs

    def __repr__(self):
        return str(sorted(self.__spec.items()))


class Cart:
    def __init__(self):
        self.items = []

    def additem(self,item:Item):
        self.items.append(item)

    def getallitems(self):
        return self.items

mycart = Cart()
myphone = Item(mark="Huawei",color=Color.GOLDEN,memory="4G")
mycart.additem(myphone)

mycar = Item(mark="Red Flag",color = Color.BLACK,year=2019)
mycart.additem(mycar)

print(mycart.getallitems())



#以上代码执行结果如下:
[[('color', 3), ('mark', 'Huawei'), ('memory', '4G')], [('color', 4), ('mark', 'Red Flag'), ('year', 2019)]]