day17-面向对象作业和总结

总结

一.属性

1. 属性

   1. 定义类就是用代码描述清楚这个类是拥有哪些相同功能和哪些相同属性的对象的集合，方法(函数)用来描述相同功能

   2. 属性(变量)用来描述相同属性。

   3. 属性分为两种：类属性(字段)、对象属性

      1. 类属性
         1. 怎么定义：直接定义在类中的变量就是类属性
         2. 怎么使用：通过 ‘类.’ 的方式去使用
         3. 什么时候用：如果属性值不会因为对象不同而不一样的时候
      2. 对象属性
         1. 怎么定义：以 ‘self.属性名 = 值’ 的方式定义在__init__方法中
         2. 怎么使用：通过 ‘对象.’ 的方式去使用
         3. 什么时候用：如果属性值会因为对象不同而不一样的时候

      class Student:
          # a是类属性
          a = 10
      
          # name和age是对象属性
          def __init__(self):
              self.name = '小明'
              self.age = 18
      
      
      print(Student.a)
      Student.a = 200
      print(Student.a)
      
      stu = Student()
      print(stu.name, stu.age)
      
      
      # 联系：定义一个圆类，用有两个属性分别是半径和圆周率
      class Circle:
          pi = 3.1415926
      
          def __init__(self):
              self.radius = 0
      
          def get_area(self):
              return Circle.pi * self.radius ** 2
      

2. 对象属性默认值

   1. 赋一个固定的值：每次创建对象的时候不能重新赋值，只能在创建好对象以后修改属性的值

   2. 使用没有默认值的参数赋值

   3. 使用有默认值的参数赋值

      class Person:
          def __init__(self, name, age=18, gender='男'):
              self.name = name
              self.age = age
              self.gender = gender
              self.height = 170
      
          def __repr__(self):
              # return f'<name:{self.name}, age:{self.age}, gender:{self.gender}>'
              return str(self.__dict__)
      
      
      p1 = Person('小明')
      p2 = Person('张三', 20)
      p3 = Person('小花', 22, '女')
      print(p1)
      print(p2)
      print(p3)
      

3. self的使用

   1. self是谁调用就指向谁，所以在对象中可以直接将self当成对象来使用。（这个类的对象能做的事情self都可以做）
   2. 练习：定义一个矩形类，有长和宽两个属性，有求面积和求周长两个方法

   class Rect:
       def __init__(self, w, l):
           self.width = w
           self.length = l
           # self.area = w * l
   
       def get_area(self):
           # self = r1; self = r2
           return self.width * self.length         # return r1.width * r1*length; r2.with * r2.length
   
       def get_perimeter(self):
           return (self.width + self.length) * 2
   
   
   r1 = Rect(10, 20)
   r2 = Rect(10, 5)
   print(r1.get_area())
   print(r2.get_area())
   
   r3 = Rect(10, 10)
   # print(r3.area)
   print(r3.get_area())
   
   r3.width = 3
   # print(r3.area)
   print(r3.get_area())
   

   4. 方法的选择

      1. 对象方法：如果实现函数的功能需要对象(需要对象属性)就使用对象方法
      2. 类方法：实现函数的功能不需要对象(或者对象属性)的前提下，需要类就使用类方法
      3. 静态方法：既不需要类，也不需要对象

      class Math:
          @staticmethod
          def sum(a, b):
              return a+b
      
      
      class Chemistry:
          @staticmethod
          def sum():
              print('化学剂混合')
      

二.继承

1. 继承

   1. 继承就是让子类直接拥有父类所有的属性和方法。

   2. 子类 - 继承者

   3. 父类(超类) - 被继承者

   4. 语法

      语法：
      class 类名(父类列表):
          类的说明文档
          类的内容
          
      注意：如果定义类的时候没有写父类，那么这个类默认继承Python的基类-object
      

      class Person:
          count = 61
      
          def __init__(self):
              self.name = '小明'
              self.age = 18
              self.gender = '男'
      
          def eat(self):
              print('吃饭')
      
          def sleep(self):
              print('睡觉')
      
      
      class Student(Person):
          pass
      
      
      print(Student.count)
      
      stu = Student()
      print(stu.name, stu.age, stu.gender)
      
      stu.eat()
      stu.sleep()
      
      
      
      class A:
          x = 10
      
          def __init__(self):
              self.y = 100
      
          def func1(self):
              print('func1')
      
          @classmethod
          def func2(cls):
              print('func2')
      
          @staticmethod
          def func3():
              print('func3')
      
      
      class B(A):
          pass
      
      
      print(B.x)
      b = B()
      print(b.y)
      b.func1()
      B.func2()
      B.func3()
      

2. 在子类中添加内容

   1. 添加类属性和方法 - 直接在子类中定义新的类属性和新的方法

   2. 添加对象属性

      class C:
          a = 10
      
          def func1(self):
              print('对象方法func1')
      
          def __init__(self):
              print('c的init')
              self.m = 100
              self.n = 200
      
      
      class D(C):
          # 新增类属性(字段)
          x = 20
          y = 30
      
          # 新增方法
          def func2(self):
              print('对象方法2')
      
          @classmethod
          def func3(cls):
              print('类方法')
      
          def __init__(self):
              # 在这儿调用父类的__init__方法就可以继承父类的对象属性
              super().__init__()     # 调用当前类的父类的__init__()
              self.t = 500
      
      
      print(D.a)
      print(D.x, D.y)
      d = D()
      d.func1()
      d.func2()
      D.func3()
      
      print(d.m, d.n)
      print(d.t)
      
      
      class Animal:
          def __init__(self, age, gender='雌'):
              self.age = age
              self.gender = gender
      
      
      class Dog(Animal):
          def __init__(self, name, breed='土狗', age=3, gender='雄'):
              super().__init__(age, gender)
              self.name = name
              self.breed = breed
      
          def __repr__(self):
              return str(self.__dict__)
      
      
      dog1 = Dog('大黄', breed='金毛')
      dog2 = Dog('小白', '萨姆', 2)
      print(dog1)
      print(dog2)
      

3. 多继承可以继承所有父类的所有的方法和类属性，只能继承第一个父类的对象属性 (了解)

   class E:
       a1 = 100
   
       def __init__(self):
           self.x1 = 100
           self.x2 = 200
   
   
       def func1(self):
           print('E的func1')
   
   
   class F:
       b1 = 200
   
       def __init__(self):
           self.y1 = 'hello'
   
       def func2(self):
           print('F的func2')
   
   
   class Test(E, F):
       pass
   
   
   print(Test.a1, Test.b1)
   
   t1 = Test()
   
   t1.func1()
   t1.func2()
   
   print(t1.x1, t1.x2)
   # print(t1.y1)      # AttributeError: 'Test' object has no attribute 'y1'
   

三.json数据

1. json数据 - json是一种通用的数据格式，主要用于不同语言之间进行有效的数据沟通。

2. json数据格式

   1. 要求
      1. 一个json有且只有一个数据
      2. 唯一的这个数据必须是json支持的类型的数据
   2. json支持的数据类型
      1. 数字 - 数字直接写，并且支持科学计数法，例如: 67、1.23、-23、23.8、3e5
      2. 字符串 - 只能使用双引号，支持转义字符，例如: “abc”、“abc\n123”、"\u4e00"
      3. 布尔值 - 只有 true 和 false 两个值
      4. 空值 - null
      5. 数组 - 相当于python的列表, [元素1, 元素2, …]
      6. 字典 - 相当于python的字典, 但是键只能是字符串

3. python数据和json数据的相互转换 - json模块提供了python中所有和json操作相关的函数

   1. json转python

      """
      json        python
      数字         int、float
      字符串        str（双引号变单引号）
      布尔值        true -> True; false -> False
      空值         null -> None
      数组         list
      字典         dict
      
      json.loads(json格式字符串)    -   将json格式字符串对应的json数据转换成相应的python数据
      注：json格式字符串 - 指的是字符串内容是json的字符串
      """
      
      import json
      json.loads('"abc"')   # 'abc'
      json.loads('100')     # 100
      json.loads('[10, 20, 30]')  # [10, 20, 30]
      json.loads('{"a": 10, "10": 20}')       # {'a': 10, '10': 20}
      result = json.loads('[10, "abc", true, null]')
      print(result)       # [10, 'abc', True, None]
      
      
      result = json.loads(open('files/汽车新闻.json', encoding='utf-8').read())
      for x in result['newslist']:
          print(x['title'])
      

   2. python转json

      """
      python          json
      int、float       数字
      str              字符串，单引号会变成双引号
      bool             布尔， True -> true, False -> false
      列表、元组         数组
      dict             字典，键会变成双引号字符串
      None             null
      
      json.dumps(python数据)   -   将指定的Python数据转换成json格式字符串
      """
      
      import json
      json.dumps(100)    # '100'
      json.dumps(True)   # 'true'
      json.dumps(None)   # 'null'
      json.dumps({10: 20, 'name': '小明', 'b': True})       # '{"10": 20, "name": "小明", "b": true}'
      

作业

1. 定义一个狗类和一个人类：

   狗拥有属性：姓名、性别和品种 拥有方法：叫唤

   人类拥有属性：姓名、年龄、狗 拥有方法：遛狗

   class Person:
       def __init__(self, name, age ,dog):
           self.name = name
           self.age = age
           self.dog = dog
       def tdfw(self):
           print('我去遛狗了')
   
   class Dog():
       def __init__(self, name, gender, breed):
           self.name = name
           self.gender = gender
           self.breed = breed
   
       def yelp(self):
           print(f'{self.breed}{self.name}在叫唤')
   
   d1 = Dog('大黄', '雄', '中华田园犬')
   d1.yelp()
   

2. 定义一个矩形类，拥有属性：长、宽 拥有方法：求周长、求面积

   class Rec:
       def __init__(self, l, w):
           self.length = l
           self.width = w
   
       def area(self):
           return self.length * self.width
   
       def perimeter(self):
           return (self.length + self.width) * 2
   
   a = Rec(10, 20)
   b = Rec(20, 40)
   print(a.area())
   print(a.perimeter())
   print(b.area())
   print(b.perimeter())
   

3. 定义一个二维点类，拥有属性：x坐标、y坐标 拥有方法：求当前点到另外一个点的距离

   class TwoDimensional:
       def __init__(self, x, y):
           self.x = x
           self.y = y
   
       def get_distance(self, other):
           return ((self.x - other.x) ** 2 + (self.y - other.y) ** 2) ** 0.5
   
   a = TwoDimensional(10,20)
   b = TwoDimensional(20,10)
   print(a.get_distance(b))
   

4. 定义一个圆类，拥有属性：半径、圆心 拥有方法：求圆的周长和面积、判断当前圆和另一个圆是否外切

   import math
   class Circle:
       def __init__(self, radius, x, y):
           self.radius =radius
           self.x = x
           self.y = y
   
       def get_perimeter(self):
           return 2 * math.pi * self.radius
   
       def get_area(self):
           return math.pi * self.radius ** 2
   
       def excircle(self, other):
           a = ((self.x - other.x) ** 2 + (self.y - other.y) ** 2) ** (1 / 2)
           if self.radius + other.radius == a:
               return '是外切圆'
           else:
               return '不是外切圆'
   
   
   a = Circle(4, 0, 0)
   b = Circle(2, 0, 6)
   print(a.get_area())
   print(a.get_perimeter())
   print(a.excircle(b))
   

5. 定义一个线段类，拥有属性：起点和终点， 拥有方法：获取线段的长度

   class Line:
       def __init__(self, start, end):
           (self.x, self.y) = start
           (self.a, self.b) = end
   
       def line_length(self):
           return ((self.x - self.a) ** 2 + (self.y - self.b) ** 2) ** (1 / 2)
       
   a = Line((10,2),(10,6))
   print(a.line_length())