Day17-面向对象初识

最新推荐文章于 2024-10-08 23:14:39 发布

林钟一

最新推荐文章于 2024-10-08 23:14:39 发布

阅读量143

点赞数

本文链接：https://blog.csdn.net/LinZhongYii/article/details/117046462

版权

qf学习专栏收录该内容

28 篇文章 1 订阅

订阅专栏

Day17-面向对象初识

类和对象
1. 定义类(创造类)
  - 定义类用代码描述清楚这个类的相同功能、相同属性
    - 功能 - 对应的是函数
    - 属性 - 保存数据的变量(在类中叫做属性)
  - 语法:
    class 类名:
    类的说明文档
    类的内容
  - 说明
    - class - 关键字, 固定写法
    - 类型 - 程序员自己命名
      要求: 是标识符, 不是关键字
      规范: 见名知义, 驼峰式命名(单词之间采用首字母大写)
      首字母大写; 不使用系统函数名、类名和模块名
    - : - 固定写法
    - 类的说明文档 - 本质就是多行注释
    - 类的内容 - 包括属性和方法
      属性分为: 类属性(类的字段)和对象属性
      方法分为: 对象方法、类方法和静态方法
2. 定义对象(创造对象)
  - 语法: 类()
```
stu1 = Student()
stu2 = Student()
print(stu1, stu2)
```
对象方法
1. 方法
  - 定义在类中的函数就是方法
2. 对象方法
  - 怎么定义: 直接定义在类中的函数(定义函数前不用加装饰器)
  - 怎么调用: 用对象来调用 - 对象.函数名()
  - 特点: 自带参数self, 在调用的时候self不用传参, 系统自动将当前对象传给self(谁调用, self指向谁)
  - ```
  lass Person:
      """
      人类
      """
      def sleep(self):
          print(f'self:{self}')
          print('睡觉')
  
  
  p1 = Person()   # 创建对象
  p2 = Person()
  print(f'p1:{p1}, p2:{p2}')
  p2.sleep()
```

构造方法和初始化方法

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

初始化方法: init

定义类的时候可以根据需求在类中添加对象方法: init, 添加的时候要保证函数名是__init__, 第一个参数是self,除此以外,我们可以随意添加参数和函数体
使用类创建对象的时候, 系统会自动调用这个类中的__init__方法
调用构造方法创建对象的时候是否需要参数, 以及需要几个参数取决于这个类的__init__方法除了self以外有无额外参数
魔法方法: 类中方法名由__开头并且以__结尾的方法就是魔法方法, 所有的魔法方法都是自动调用

class Dog:
    def __init__(self):
        print('__init__被调用')


# 下面的这个函数的定义有系统自动完成
'''
def Dog():
    创建对象并且申请内存保存对象
    新建好的对象.__init__()
    return 新建好的对象
'''

dog1 = Dog()
dog2 = Dog()


class Cat:
    def __init__(self, name, age):
        print('猫:__init__被调用')
        print(f'name:{name}, age:{age}')


cat1 = Cat('小小', 12)
cat2 = Cat(name='巧克力', age=4)
cat3 = Cat('zz', 8)


# 补充
def __init__(x, y):
    print('自己的__init__被调用')
    print(f'x:{x}, y:{y}')

def Cat(*args, **kwargs):
    __init__(*args, **kwargs)


c1 = Cat(10,20)
c2 = Cat(x=100, y=200)


def func2(a, b, c):
    print(f'a:{a}, b:{b}, c:{c}')


# func2(100, 200, 300)

alist = (100, 200, 300)
func2(*alist)

dict1 = {'a':10, 'b':20, 'c':30}
# **dict1 ->    a=10, b=20, c=30
# func2(**dict1)  #a:10, b:20, c:30

属性

属性
- 属性是用来描述类的数据特征. 属性的本质是保存数据的变量
对象属性和类属性
1. 类属性
  - 怎么定义: 直接定义在类中的变量就是类属性
  - 怎么使用: 通过类来使用类.类属性
  - 什么时候用: 属性的值不会因为对象的变化而变化，这种属性就定义成雷属性
2. 对象属性
  - 怎么定义: 以’self.属性名=值’的形式定义在__init__方法中
  - 怎么使用: 通过对象来使用, 对象.对象属性
  - 什么时候用: 属性的值会因为对象不同二不一样, 这种类型就定义成对象属性
```
class Person:
    # num就是类属性
    num = 61

    # name、age、gender就是对象属性
    def __init__(self):
        self.name = '小明'
        self.age = 18
        self.gender = '男'


print(Person.num)
Person.num = 60
print(Person.num)

p1 = Person()
print(p1.name, p1.age, p1.gender)
p1.name = '明小'
print(p1.name)


class Circle:
    pi = 3.1415926
```

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

方式一: 赋一个固定的值
方式二: 使用没有默认值的参数赋值
方式三: 使用有默认值的参数赋值

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.breed, self.gender, self.color, self.age}'
        # return str(self.__dict__)
        return f'<{str(self.__dict__)[1:-1]}>'


dog1 = Dog('潇潇', '五颜六色')
print(f'dog1:{dog1}')

# 练习: 定义一个商品类, 拥有属性: 价格、名称、产地、类型、生产日期、保质期
# 要求: 创建爱你对象的时候价格、名称、生产日期必须赋值、产地默认温州、保质期默认一年、类型默认食品
# 打印对象的时候打印商品基本信息
import time
from datetime import datetime

class Item:
    def __init__(self, price, name):
        self.price = price
        self.name = name
        self.origin = '温州'
        self.type = 'food'
        self.product_time = time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))
        self.date_use = '2022.5.19'

    def __repr__(self):
        return f'<{str(self.__dict__)[1:-1]}>'


mouse = item(89,'鼠标')
print(mouse)

方法
1. 对象方法
  - 怎么定义: 直接在类中定义函数(函数前不加装饰器)
  - 怎么调用: 对象.对象方法()
  - 特点: 自带参数self, self不用传参, 谁调用self就指向谁
  - 什么时候用: 如果实现函数功能需要用到对象属性, 一定是对象方法
2. 类方法
  - 怎么定义: 在定义函数前加装饰器@classmethod
  - 怎么调用: 类.类方法()
  - 特点: 自带参数cls, cls不用传参, 系统将当前类传给cls(谁调用就指向谁)
  - 什么时候用: 实现函数的功能, 在不需要对象属性的时候需要类就使用类方法
3. 静态方法
  - 怎么定义: 在定义函数前加装饰器@staticmethod
  - 怎么调用: 类.静态方法()
  - 特点: 没有默认参数
  - 什么时候用: 实现函数的功能既不需要当前类的对象也不需要当前类, 就是用静态方法
```
class Test:
    def func1(self):
        print('对象方法')

    @classmethod
    def func2(cls):
        # cls = Test
        print(f'cls:{cls}')
        print('类方法')

    @staticmethod
    def func3():
        print('静态方法')


t1 = Test()

# 用对象调用对象方法
t1.func1()

# 用类调用类方法
Test.func2()
print(f'Test:{Test}')

Test.func3()


class Circle:
    pi = 3.1415926


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


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


    @classmethod
    def set_pi(cls, value):
        cls.pi = value
```

作业

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

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

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

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

    def bark(self):
        print(f'{self.name}:汪汪汪')


dog1 = Dog('小明', '公', '土狗')
dog1.bark()


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}')


p1 = Person('花花', '18', '小明')
p1.walk_dog()

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

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

    def get_rec_circumference(self):
        circumference = self.width * 2+self.length * 2
        print('该矩形的周长是:', circumference)

    def get_rec_area(self):
        area = self.length*self.width
        print('该矩形的面积是:', area)


rec1 = Rectangles(10, 5)
rec1.get_rec_area()
rec1.get_rec_circumference()

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

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def get_distance(self, another_point):
        return ((another_point.x-self.x)**2 + (another_point.y-self.y)**2)**0.5


p1 = Point(1,1)
p2 = Point(5,5)

print(f'p1和p2的距离为:', p1.get_distance(p2) )

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

class Circle:
    pi = 3.1415926

    def __init__(self, radius, coc:Point):
        self.radius = radius
        self.coc = coc

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

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


    def is_externally_tangent_circle(self, c1):
        distance = self.coc.get_distance(c1.coc)
        if self.radius + c1.radius == distance:
            return '两圆相切,距离是:', distance
        else:
            return '两圆没有外切'


circle1 = Circle(1,Point(1,0))
circle2 = Circle(1,Point(5,0))
print(circle1.is_externally_tangent_circle(circle2))

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

class Lines:
    def __init__(self, x:Point, y:Point):
        self.x = x
        self.y = y

    def get_lines_distance(self):
        return '线段长度:',self.x.get_distance(self.y)