学习python的第四天

一、面向对象编程基础
1.类和对象
（1）定义类
class class_name(object):#标识 类名 object
print('Hello)
if name==“main”:
Joker = class_name()#()就相当于走了初始化
对象是类的实例

class class_name(object):
       def __init__(self):#self只是一个印记的作用，没有参数的作用
             self.a = 100
        def A(self):
              print(self.a)
              print('WWW')
 if __name__=="__main__":
         Joker = class_name()
         Joker.A()#在类中调用需要使用

(2)创建和使用对象

def main():
#创建学生对象并指定姓名和年龄
     stu1 = Student('罗昊',38)
# 给对象发study消息
     stu1.study('Python程序设计')
    # 给对象发watch_av消息
     stu1.watch_av()
     stu2 = Student('王大锤', 15)
     stu2.study('思想品德')
     stu2.watch_av()


if __name__ == '__main__':
    main()

运行进度条

import time
class Joker(object):
    def __init__(self):
        self.count = 1
    def jindutiao(self):
        for i in range(0,100):
            time.sleep(0.1)
            print('%d%%\r'%(i+1),end="",flush=True)
            if i%5 ==0:
                res = '#'*self.count
                print('%s %d%%\r'%(res,(i+5)),end="")
                self.count += 1
                print()
        
        
if __name__ ==" __main__":
    joker = Joker()
    joker.jindutiao()

class class_name:
      def __init__(self):
           self. __a = 1000#私有变量
       def A(self):
           print(self.__a)
  if __name__=="__main__":
            name = class_name()
            name.A()
            #print(name.__a)#私有变量不可外部调用

二、面向对象进阶
@property装饰器

class Joker(object):
        def __init__(self):
            self.__a = 1000
        @property装饰器
        def look(self):
              return self.__a
  if __name__=="__main__":
         name = Joker()
         #name.look()
         print(name.a)

__slots__魔法
_slots__的限定只对当前类的对象生效，对子类并不起任何作用

class joker:
     __slots__ =('uuu','hhh')
     def __init__(self):
          pass
if __name__ =='__main__':
     joker = joker()
     joker.uuu = 10000
     print(joker.uuu)

静态方法和类方法

from math import sqrt
class Triangle(object):
    def __init__(self, a, b, c):
        self._a = a
        self._b = b
        self._c = c
    @staticmethod
    def is_valid(a, b, c):
        return a + b > c and b + c > a and a + c > b
    def perimeter(self):
        return self._a + self._b + self._c
    def area(self):
        half = self.perimeter() / 2
        return sqrt(half * (half - self._a) *
                    (half - self._b) * (half - 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(Triangle.perimeter(t))
        print(t.area())
        # print(Triangle.area(t))
    else:
        print('无法构成三角形.')
if __name__ == '__main__':
    main()

继承

class A(object):
def __init__(self,a1):
self.a = 1000
self.a1 = a1
def A1(self):
print('A1')
class B(A):
def __init__(self,a1):
A.__init__(self,a1)
pass
def B1(self):
print(self.a1)
if __name__ =="__main__":
b = B('Joker')
b.B1()

多态
子类在继承了父类的方法后，可以对父类已有的方法给出新的实现版本，这个动作称之为方法重写（override）。通过方法重写我们可以让父类的同一个行为在子类中拥有不同的实现版本，当我们调用这个经过子类重写的方法时，不同的子类对象会表现出不同的行为，这个就是多态。

from abc import ABCMeta, abstractmethod
class Pet(object, metaclass=ABCMeta):
    def __init__(self, nickname):
        self._nickname = nickname
    @abstractmethod
    def make_voice(self):
        """发出声音"""
        pass
class Dog(Pet):
    """狗"""
    def make_voice(self):
        print('%s: 汪汪汪...' % self._nickname)
class Cat(Pet):
    """猫"""
    def make_voice(self):
        print('%s: 喵...喵...' % self._nickname)
def main():
    pets = [Dog('旺财'), Cat('凯蒂'), Dog('大黄')]
    for pet in pets:
        pet.make_voice()
if __name__ == '__main__':
    main()