python基础之面向对象

属性引用(类名属性)
class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def walk(self):  #人都可以走路，也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法，注意，这里不是在调用

实例化
class A:                
    role='人'
    def __init__(self,name):
        self.name=name
    def walk(self):
        print('我要飞得更高')
a=A('路飞')                  #实例化一个对象
print(a.walk())          #  调用方法

from math  import  pi
class Circle:                      ------类类名
      def__init__(self,r):         ------对象实例
            self.r=r
      def  zc (self):               
           return  2*pi*self.r
      def mj   (self):
            return  pi*self.r**2
a=Circle(5)                          ----实例化
print(a.zc())

class Person:  # 定义一个人类
    role = 'person'  # 人的角色属性都是人

    def __init__(self, name, aggressivity, life_value):
        self.name = name  # 每一个角色都有自己的昵称;
        self.aggressivity = aggressivity  # 每一个角色都有自己的攻击力;
        self.life_value = life_value  # 每一个角色都有自己的生命值;

    def attack(self,dog):
        # 人可以攻击狗，这里的狗也是一个对象。
        # 人攻击狗，那么狗的生命值就会根据人的攻击力而下降
        dog.life_value -= self.aggressivity

class Dog:  # 定义一个狗类
    role = 'dog'  # 狗的角色属性都是狗

    def __init__(self, name, breed, aggressivity, life_value):
        self.name = name  # 每一只狗都有自己的昵称;
        self.breed = breed  # 每一只狗都有自己的品种;
        self.aggressivity = aggressivity  # 每一只狗都有自己的攻击力;
        self.life_value = life_value  # 每一只狗都有自己的生命值;

    def bite(self,people):
        # 狗可以咬人，这里的狗也是一个对象。
        # 狗咬人，那么人的生命值就会根据狗的攻击力而下降
        people.life_value -= self.aggressivity

egg = Person('egon',10,1000)  #创造了一个实实在在的人egg
ha2 = Dog('二愣子','哈士奇',10,1000)  #创造了一只实实在在的狗ha2
print(ha2.life_value)         #看看ha2的生命值
egg.attack(ha2)               #egg打了ha2一下
print(ha2.life_value)         #ha2掉了10点血

class BirthDate:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day

class Couse:
    def __init__(self,name,price,period):
        self.name=name
        self.price=price
        self.period=period

class Teacher:
    def __init__(self,name,gender,birth,course):
        self.name=name 
        self.gender=gender
        self.birth=birth
        self.course=course
    def teach(self): 
        print('teaching')

p1=Teacher('egon','male', 
            BirthDate('1995','1','27'), 
            Couse('python','28000','4 months')
           ) 

print(p1.birth.year,p1.birth.month,p1.birth.day) 

print(p1.course.name,p1.course.price,p1.course.period)
''' 
运行结果: 
1 27 
python 28000 4 months 
'''

from math import pi

class Circle:
    '''
    定义了一个圆形类；
    提供计算面积(area)和周长(perimeter)的方法
    '''
    def __init__(self,radius):
        self.radius = radius

    def area(self):
         return pi * self.radius * self.radius

    def perimeter(self):
        return 2 * pi *self.radius


circle =  Circle(10) #实例化一个圆
area1 = circle.area() #计算圆面积
per1 = circle.perimeter() #计算圆周长
print(area1,per1) #打印圆面积和周长

class Ring:
    '''
    定义了一个圆环类
    提供圆环的面积和周长的方法
    '''
    def __init__(self,radius_outside,radius_inside):
        self.outsid_circle = Circle(radius_outside)
        self.inside_circle = Circle(radius_inside)

    def area(self):
        return self.outsid_circle.area() - self.inside_circle.area()

    def perimeter(self):
        return  self.outsid_circle.perimeter() + self.inside_circle.perimeter()


ring = Ring(10,5) #实例化一个环形
print(ring.perimeter()) #计算环形的周长
print(ring.area()) #计算环形的面积

import pickle
class Course:
    def __init__(self,name,price):
        self.name=name
        self.price=price
class Student:
    def __init__(self,name,price):
        self.name = name
        self.price = price
python=Course('python',19800)
with open('Courses','wb') as f:
    pickle.dump(python,f)
with open('Courses','rb')as  f:
    pickle.load(f)
print(Course)

class A:
        def eat()self):
             pass
class B :
         def eat(self):
               pass
def   eat(obj):
           obj.eat()

from abc import ABCMeta,abstractmethod #(抽象方法)
class Payment(metaclass=ABCMeta):   # metaclass 元类  metaclass = ABCMeta表示Payment类是一个规范类
    @abstractmethod      # @abstractmethod表示下面一行中的pay方法是一个必须在子类中实现的方法
    def pay(self):pass

    @abstractmethod
    def back(self):pass  # 退款功能

class AliPay(Payment):
    def __init__(self,name):
        self.name = name
    def pay(self,money):
        # 支付宝提供了一个网络上的联系渠道
        print('%s通过支付宝消费了%s元'%(self.name,money))
    def back(self):
        print('退款')
class WeChatPay(Payment):
    def __init__(self,name):
        self.name = name
    def pay(self,money):
        # 微信提供了一个网络上的联系渠道
        print('%s通过微信消费了%s元'%(self.name,money))
    def back(self):
        print('退款')
class ApplePay(Payment):
    def __init__(self,name):
        self.name = name
    def pay(self,money):
       print('%s通过苹果支付消费了%s元'%(self.name,money))

    def back(self):
        print('退款')
# 归一化设计 : 从原来的面向对象编程 -->面向函数编程.降低了用户的使用成本
def pay_func(person,payway,money):
    if payway == 'alipay':
        per = AliPay(person)
    elif payway == 'wechatpay':
        per = WeChatPay(person)
    elif payway == 'ApplePay':
        per = ApplePay(person)
    per.pay(money)



pay_func('lufei','alipay',200)
pay_func('nazha','wechatpay',100)