第十二章：面向对象编程

知识点：

class Privileges():
    def __init__(self, privileges):
        self.privileges = privileges

    def show_privilege(self):
        for privilege in privileges:
            print(privilege)


class Admin():
    def __init__(self):
        self.privi = Privileges(privileges)


privileges = ['add', 'dele', 'update', 'watch']
admin = Admin()
admin.privi.show_privilege()

1、类（class）:类定义了对象，每个对象都是类的实例。可以使用语法：class [类名]: 代码主体来定义类。代码主体可以是方法的复合语句。

class Orange():          #定义类
    def __init__(self):  #定义一个方法作为代码主体。self为方法的参数。__init__代表初始化。注意下划线是两个，单个会报错。

2、定义实例变量：语法：self.变量名 =  变量值

class Orange():          
    def __init__(self,w,c):
        #定义实例变量
        self.weight=w
        self.color=c

3、创建对象的语法：对象名=类名（参数）

class Orange():          
    def __init__(self,w,c):
        #定义实例变量
        self.weight=w
        self.color=c

#创建一个对象orange
orange=Orange(10,"yellow")

4、获取对象的值：对象名.变量名

class Orange():          
    def __init__(self,w,c):
        #定义实例变量
        self.weight=w
        self.color=c

#创建一个对象orange
orange=Orange(10,"yellow")

#获取对象的值
print(orange.weight)
print(orange.color)

课后习题：

1、定义一个Apple的类，创建4个实例变量，表示苹果的4种属性。

class Apple():
    def __init__(self,w,c,local):
        self.weight=w
        self.color=c
        self.local=local




    def rot(self,days,temp):
        self.rot = days*temp

apple = Apple(10,"red","beijing")
print(apple.weight)
print(apple.color)
print(apple.local)

apple.rot(10,98)
print(apple.rot)

2、创建一个叫Circle的类，创建area方法计算面积。然后创建一个Circle对象，调用area方法，打印结果。

import math

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

    def area(self):
        return self.r**2*math.pi
    
Circle=Circle(3)
print(Circle.area())

 3、创建一个Triangle的类，创键area 方法计算并返回其面积。然后创建一个Triangle的对象，调用area方法，打印结果。

import math
class Triangel():
    def __init__(self,a,b,c):
        self.a=a
        self.b=b
        self.c=c
        self.p=1/2*(a+b+c)

    def area(self):
        return math.sqrt(self.p*(self.p-self.a)*(self.p-self.b)*(self.p-self.c))
       
    
Triangel = Triangel(3,4,5)
print(Triangel.area())

 3.1、定义一个叫Hexagon的类，创建一个calculate_perimeter方法计算周长。然后创建一个Hexagon的对象，调用其calculate_perimeter方法打印结果。

class Hexagon:
    def __init__(self,l):
        self.l = l

    def calculate_perimeter(self):
        return self.l*6


hexagon = Hexagon(5)
print(hexagon.l)
print(hexagon.calculate_perimeter())

#改变对象的值
hexagon.l=20
print(hexagon.l)
print(hexagon.calculate_perimeter())

4、创建Squre类，定义一个叫change_size的方法，支持传入一个数字，增加或减少Squre对象的边长。

class Squre():
    def __init__(self,l):
        self.l = l
   
    def change_size(self,new_size):
        self.l +=new_size
         
a_squre = Squre(10)
print(a_squre.l)


a_squre.change_size(20)
print(a_squre.l)

5、创建Rectangle和Squre类，使他们均有一个叫做calculate_perimeter的方法，计算其所表示图形的周长。创建Rectangle和Squre对象，并调用二者周长的计算方法。

class Rectangle():
    def __init__(self,s1,s2):
        self.s1 = s1
        self.s2 = s2

    def calculate_perimeter(self):
        return (self.s1+self.s2)*2


class Squre():
    def __init__(self,s3):
        self.s3 = s3


    def calculate_perimeter(self):
        return self.s3*4

a_rectangle = Rectangle(10,20)
print(a_rectangle.calculate_perimeter())

a_squre = Squre(30)
print(a_squre.calculate_perimeter())

6、创建一个叫Shape的类。在其中定义一个叫what_am_i 的方法，被调用时打印“i am a shape”。创建Squre和Rectangle类，继承Shape类。创建Squre和Rectangle对象，调用方法         打印“i am a shape”。

class Shape():
    def what_am_i(self):
        print("I am  a shape")


class Squre(Shape):
    pass


class Rectangle(Shape):
    pass

a_rectangle = Rectangle()
a_rectangle.what_am_i()
    
    
a_squre = Squre()
a_squre.what_am_i()

 7、创建一个叫Hores的类，以及一个叫Rider的类。使用组合，表示一批有骑手的马。

class Horse():
    def __init__(self,horse_name,owner):
        self.horse_name = horse_name
        self.owner = owner


class Rider():
    def __init__(self,rider_name):
        self.rider_name = rider_name



rider_name =Rider("jack")
horse_name = Horse("qilima",rider_name)

print(horse_name.owner.rider_name)

 8、向Squre类中添加一个squre_list类变量，要求每次新创建一个Squre对象时，新对象会被自动添加到列表中。

class Squre:
    squre_list=[]

    def __init__(self,l):
        self.l = l
        self.squre_list.append(self.l)


l1 = Squre(1)
l2 = Squre(2)
l3 = Squre(3)

print(Squre.squre_list)

9、修改Squre类，要求在打印Squre对象时，打印信息为图形4个边的长度。例如，假设创建一个Squre(29), 则打印29 by 29 by 29 by 29.

class Squre:

    def __init__(self,l):
        self.l = l
        

    def __repr__(self):
        print("{} by {} by {} by {}".format(self.l,self.l,self.l,self.l))


r1 = Squre(29)
r1.__repr__()

 10、@property包装器   来包装getter和setter，从而访问和修改私有属性。

class Screen(object):
    @property
    def width(self):
        return self._width

    @property
    def height(self):
        return self._height

    
    @width.setter
    def width(self,width):
        self._width = width

    @height.setter
    def height(self, height):
        self._height = height

    @property
    def resolution(self):
        return self.width*self.height




s = Screen()
s.width = 1024
s.height = 768
print("resolution=", s.resolution)

class Person(object):
    def __init__(self,name,age):
        #变量前加 '_' 定义私有属性
        self._name = name
        self._age = age

    #访问器--getter方法
    @property
    def name(self):
        return self._name

    @property
    def age(self):
        return self._age


    #修改器—setter方法
    @age.setter
    def age(self,age):
        self._age = age

    @name.setter
    def name(self,name):
        self._name = name


    def play(self):
        if self._age<=16:
            print("%s正在玩飞行棋。"  %self._name)
        else:
            print("%s正在御剑飞行。"  %self._name)



def main():
    person = Person("王大锤", 12)
    person.play()
    person = Person("丁仙人",200)
    person.play()



if __name__=="__main__":
    main()

11、静态方法@staticmethod，通过给类发消息来调用：可用静态方法验证先行条件，验证通过再进行下一步动作。例如 要计算三角形的周长和面积，要先验证三边长能否构成三角形。

import math

class Triangle(object):
    def __init__(self,a,b,c):
        self._a = a
        self._b = b
        self._c = c
        self._p = 1/2*(a+b+c)

    #静态方法
    @staticmethod
    def is_valid(a,b,c):
        return a+b>c and a+c>b and b+c>a


    def perimeter(self):
        return self._a+self._b+self._c

    def area(self):
        return math.sqrt(self._p*(self._p-self._a)*(self._p-self._b)*(self._p-self._c))
    



def main():
    a,b,c =3,4,5
    #静态方法是给类发消息来调用
    if Triangle.is_valid(a,b,c):
        t = Triangle(a,b,c)
        print(t.perimeter())
        print(t.area())

    else:
        print("不能构成三角形")
    
        
    
if __name__=="__main__":
    main()

12、类方法@classmethod：第一个参数约定为 cls .代表的是当前类相关的信息的对象（类本身也是一个对象，有的地方也称之为类的元数据对象），通过这个参数我们可以获取和类 相关的信息并且可以创建出类的对象.

from time import time, localtime, sleep

class Clock(object):
    def __init__(self,hour=0,minute=0,second=0):
        self.hour =hour
        self.minute = minute
        self.second = second

    #定义类方法获取当地时间
    @classmethod
    def now(cls):
        ctime = localtime(time())
        return cls(ctime.tm_hour, ctime.tm_min, ctime.tm_sec)


    def run(self):
        self.second +=1
        if self.second==60:
            self.second==0
            if self.minute==60:
                self.minute==0
                if self.hour==24:
                    self.hour==0


    def show(self):
         return "%02d:%02d:%02d"  %(self.hour, self.minute, self.second)



def main():
    # 通过类方法创建对象并获取系统时间
    clock = Clock.now()
    while True:
        print(clock.show())
        sleep(1)
        clock.run()


if __name__=="__main__":
    main()