Day17_面向对象

Day17_面向对象

笔记:

类和对象

1. 定义 类

"""
定义类就是用代码描述清楚你这个类是拥有哪些相同功能哪些相同属性的对象的集合
功能 - 对应的就是函数
属性 - 保存数据的变量(在类中叫属性)
语法:
class 类名:
    类的说明文档
    类的内容  
说明:
class - 关键字,固定写法
类名   - 程序员自己命名
        要求:是标识符,不是关键字
        规范:见名知义;驼峰式命名(单词之间首字母大写);首字母大写,不能使用类名,模块名,函数名
类的说明文档 - 本质就是多行注释
类的内容  - 包括属性和方法
           属性分为:类属性(类的字段) 和 对象属性
           方法对象:对象方法,类方法和静态方法
注:方法就是定义在类中的函数
"""

2. 定义对象(创建对象)

语法:类()
"""
stu1 = Students()
print(stu1)

对象方法

1. 方法

• 定义在类中的函数就是方法

2. 对象方法

• 怎么定义:直接定义在类中的函数(定义函数前不用加装饰器)
  怎么调用:用对象来调用 - 对象.函数名()
  特点:自带参数self,在调用的时候不用self传参,系统会自动将当前对象传个self

构造方法和初始化一样

1. 构造函数/构造方法

• 函数名和类名相同,并且是用来创建对象的方法就是构造方法
• Python的构造函数在创建类的时候系统自动创建,程序员只需要在创建对象的时候自动调用

2. 初始化方法:init

"""
定义类的时候可以根据需求在类中添加对象方法:__init__,添加的时候要保证函数名是__init__,第一个参数是self,
除此以外我们可以随意添加参数和函数体

每次使用类创建对象的时候,系统会自动调用类中的__init__方法.
调用构造方法创建对象的时候需不需要参数,需要几个参数看这个类的__init__方法除了self以外有没有额外的参数.

魔法方法:类中,方法名由__开头并且__结束的方法就是魔法方法.所有的魔法方法都是自动调用的.
"""

3. 补充

def Rabbit(*args, **kwargs):
    __init__(*args, **kwargs)
# * 和**具有打包/解包的功能

属性

• 属性是用来描述类的数据特征,属性的本质是保存数据的变量

• 对象属性和类属性:

  • 类属性:

    怎么定义:直接定义在类中的变量就是类属性
    怎么使用:通过类来使用,类.类属性
    什么时候用:属性的值不会因为对象的不同而不一样,这样的属性就定义成类属性

  • 对象属性:

    怎么定义:以’self.属性名 = 值’的形式定义在__init__方法中
    怎么使用:通过对象来使用,对象.对象属性
    什么时候用:属性的值会因为对象的不同而不一样,这种属性就定义成对象属性

• 对象属性赋初值的三种方式

"""
方式1:赋一个固定的值,
方式2:使用没有默认值的参数赋值
方式3:使用有默认值的参数赋值

"""
class Dog:
    def __init__(self, name, color, breed='土狗', gender='公'):
        self.breed = breed
        self.name = name
        self.gender = gender
        self.color = color
        self.age = 1  # 赋固定固定值
    # __repr__方法在当前类的对象被打印的时候会被自动调用,这个方法返回值(必须是字符串)的就是什么?
    def __repr__(self):
        # 打印谁,self就是谁
        # return f'{self.name,self.color,self.age,self.breed,self.gender},'
        return f'<{str(self.__dict__)[1:-1]}>'
dog1 = Dog('阿黄', '黄色')
print(f'dog1:{dog1}')

方法

1. 对象方法

• 怎么定义:直接定义在类中的函数(函数前不加装饰器)
  怎么调用:对象.对象方法()
  特点:自带参数self,self不用传参,谁调用self就指向谁
  什么时候用: 如果实现函数的功能需要用到对象属性,一定是对象方法

2. 类方法

• 怎么定义:在类中定义函数前加装饰器@classmethod
  怎么调用:类.类方法
  特点:自带参数cls,cls不用传参,系统将当前类传个cls(谁调用就指向谁)
  什么时候用:实现函数的功能,在不需要对象属性的时候需要类就使用类方法

3. 静态方法

• 怎么定义:在类中定义函数前加装饰器@staticmethod
  怎么调用:类.静态方法
  特点:没有默认参数
  什么时候用:实现函数的功能既不需要当前类的对象也不需要当前类,就使用静态方法

作业:

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

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

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

class Dog:
    def __init__(self, name, gender, breed):
        self.name = name
        self.gender = gender
        self.breed = breed

    @classmethod
    def bark(cls):
        print(f'{cls}会叫唤')


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

    def walk_dog(self):
        print(f'{self.name}会遛{self.dog}')

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

class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def perimeter(self):
        return 2 * self.width + 2 * self.length

    def area(self):
        return self.width * self.length

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

class Two_dimension_points:
    def __init__(self, coord_x, coord_y):
        self.coord_x = coord_x
        self.coord_y = coord_y

    def length_points(self, x, y):
        return ((self.coord_x - x) ** 2 + (self.coord_y - y) ** 2) ** 0.5

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

class Circle:
    pi = 3.1415926

    def __init__(self, radius, cir_center=(0, 0)):
        self.circle_center = cir_center
        self.radius = radius

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

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

    def is_excircle(self, radius, c_center=(0, 0)):
        if ((self.circle_center[0] - c_center[0]) ** 2 + (
                self.circle_center[1] - c_center[1]) ** 2) ** 0.5 == self.radius + radius:
            return True
        return False

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

class Line:
    def __init__(self, start_point=(0, 0), end_point=(0, 0)):
        self.start_point = start_point
        self.end_point = end_point

    def length(self):
        return ((self.end_point[0] - self.start_point[0]) ** 2 + (self.end_point[1] - self.start_point[1]) ** 2) ** 0.5