面向对象

最新推荐文章于 2023-06-25 09:35:46 发布

叫我星娃子

最新推荐文章于 2023-06-25 09:35:46 发布

阅读量55

点赞数

本文链接：https://blog.csdn.net/qq_42273268/article/details/117049200

版权

总结

类和对象

定义类（创建类）

"""
定义类用代码描述清楚你这个类是拥有哪些相同功能和哪些相同属性的对象的集合。
功能  -  对应的是函数
属性  -  保存数据的变量（在类中叫属性）

语法:
class 类名:
    类的说明文档
    类的内容
    
    
说明：
class  -  关键字，固定写法
类名   -   程序员自己命名
        要求：是标识符，不是关键字
        规范：见名知义；驼峰式命名，并且首字母大写，不使用系统函数名、类名和模块名
:     -   固定写法
类的说明文档  -   本质就是多行注释
类的内容  -   包括属性和方法
             属性分为：类属性（类的字段）  和  对象属性
             方法分为：对象方法、类方法 和 静态方法


注：方法就是定义在类中的函数
"""

class Student:
    """
    学生类
    """
    pass

定义对象（创建对象）

"""
语法： 类()
"""
stu1 = Student()
stu2 = Student()
print(stu1, stu2)

对象方法

方法 - 定义在类中的函数

对象方法

"""
怎么定义：直接定义在类中的函数（定义函数前不用加装饰器）
怎么调用：用对象来调用   对象.函数名()
特点：自带参数self,在调用的时候self不用传参，系统会自动将当前对象传给self（谁调用，self就指向谁）
"""
class Person:
    """
    人类
    """
    def sleep(self):
        print(f'self{self}')  # self<__main__.Person object at 0x000001CC12B74520>
        print('睡觉')

    def eat(self, food, drink):
        print(f'吃{food}，喝{drink}')
        
p1 = Person()  # 创建对象
p1.sleep()   # 对象.函数名()  调用
p1.eat(food='薯片', drink='可乐')
print(f'p1{p1}')  # p1<__main__.Person object at 0x000001CC12B74520>

构造方法和初始化方法

函数名和类名相同，并且是用来创建对象的方法，就是构造方法

python的构造函数在创建类的时候由系统自动创建，程序员只需要在创建对象的时候自动调用

初始化方法：_init_

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

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

魔法方法：类中，方法名由__开头，并且以__结尾的方法就是魔法方法。所有的魔法方法都是自动调用。
"""
class Dog:
    def __init__(self, name, age):
        print('__init__被调用')
        print(f'name:{name}, age:{age}')
        
# 下面的这个函数的定义由系统自动完成
"""
def Dog():
    新建好的对象 = 创建对象并且申请内存保存对象
    新建好的对象.__init__()
    return 新建好的对象
"""
dog1 = Dog(name='仙人板板', age=2)
dog2 = Dog('花', 2)

属性

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

对象属性和类属性

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

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

class Person:
    # num是类属性
    num = 18

    # name，age，sex 是对象属性
    def __init__(self):
        self.name = '小明'
        self.age = 28
        self.sex = '男'


print(Person.num)  # 18
person1 = Person()
print(person1.name, person1.age, person1.sex)  # 小明 28 男
person1.name = '小李'
print(person1.name)  # 小李

# 3.对象属性赋初始值的三种方式
"""
方式1：赋一个固定的值
方式2：使用没有默认值的参数赋值
方式3：使用有默认值的参数赋值
"""
class Dog:
    def __init__(self, name, color, breed='边牧', sex='母狗'):
        self.breed = breed  # 有默认值的参数
        self.sex = sex
        self.color = color  # 没有默认值的参数
        self.name = name
        self.age = 1   # 赋固定值

    # 在打印当前类的对象的时候就会被自动调用，这个方法的返回值（必须是字符串）是什么就打印什么
    def __repr__(self):
        # 打印谁，self就是谁
        # return f'{self.name, self.age, self.breed, self.color}'
        return f'<{str(self.__dict__)[1:-1]}>'


dog1 = Dog('财财', '黑白色')
print(f'dog1:{dog1}')  # dog1:<'breed': '边牧', 'sex': '母狗', 'color': '黑白色', 'name': '财财', 'age': 1>

class Goods:
    def __init__(self, name, price, datetimes, types='食品', quality='1天', place='温州'):
        self.name = name
        self.price = price
        self.datetimes = datetimes
        self.types = types
        self.quality = quality
        self.place = place

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


types1 = Goods('包子', '两块', '2021.5.19')
print(f'types1:{types1}')
# types1:<'name': '包子', 'price': '两块', 'datetimes': '2021.5.19', 'types': '食品', 'quality': '1天', 'place': '温州'>

方法

对象方法、类方法、静态方法

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

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

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

class Test:
    def func1(self):
        print('对象方法')

    @classmethod
    def func2(cls):
        print('类方法')

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


test = Test()
test.func1()  # 对象方法 调用
Test.func2()  # 类方法  调用
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


c1 = Circle(1)
c2 = Circle(10)

print(c1.area())
print(c2.area())

作业

# 1定义一个狗类和一个人类：
# 狗拥有属性：姓名、性别和品种   拥有方法：叫唤
# 人类拥有属性：姓名、年龄、狗   拥有方法：遛狗
class Dog:
    def __init__(self, name, sex, kind):
        self.name = name
        self.sex = sex
        self.kind = kind

    def call(self):
        print(f'{self.name}在叫:汪~~~')


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.name}的狗')


dog1 = Dog('土豆', '母', '边牧')
pe1 = Person('小李', '28', dog1)
pe1.walk_dog()

# 2定义一个矩形类，拥有属性：长、宽  拥有方法：求周长、求面积
class Square:
    def __init__(self, long, wide):
        self.long = long
        self.wide = wide

    def Perimeter(self):
        return (self.long + self.wide) * 2

    def area(self):
        return self.long * self.wide


squ1 = Square(10, 15)
print(f'周长：{squ1.Perimeter()}，面积{squ1.area()}')

# 3.定义一个二维点类，拥有属性：x坐标、y坐标    拥有方法：求当前点到另外一个点的距离
# 4.定义一个圆类，拥有属性：半径、圆心   拥有方法：求圆的周长和面积、判断当前圆和另一个圆是否外切
# 5.定义一个线段类，拥有属性：起点和终点， 拥有方法：获取线段的长度
import math


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

    # 点到点的距离
    def distance1(self, other):
        return math.sqrt((other.x - self.x) ** 2 + (other.y - self.y) ** 2)

    # def distance(self, x1, y1):
    #     return math.sqrt((x1 - self.x) ** 2 + (y1 - self.y) ** 2)


p1 = Point(0, 0)
p2 = Point(3, 4)
print(f'两点距离：{p1.distance1(p2)}')


# Circle类
class Circle:
    def __init__(self, r):
        self.r = r
        self.center_point = None

    # 周长
    def perimeter(self):
        return 2 * math.pi * self.r

    # 面积
    def area(self):
        return math.pi * self.r ** 2

    # 是否是外切
    def circumcision(self, other):
        d = (self.center_point.x - other.center_point.x) ** 2 + (self.center_point.y - other.center_point.y) ** 2
        if math.sqrt(d) == other.r + self.r:
            print('是外切')
        else:
            print('不是外切')


c1 = Circle(10)
c1_point = Point(0, 0)
c1.center_point = c1_point
print(f'周长是：{c1.perimeter()}')
print(f'面积是：{c1.area()}')

c2 = Circle(5)
c2_point = Point(15, 0)
c2.center_point = c2_point
print(f'周长是：{c2.perimeter()}')
print(f'面积是：{c2.area()}')

c1.circumcision(c2)


# Line类
class Segment:
    def __init__(self, x1, x2):
        self.x1 = x1
        self.x2 = x2

    def length(self):
        return math.sqrt((self.x1 - self.x2)**2)


q1 = Segment(10, 5)
result = q1.length()
print(f'线段长度：{result}')

叫我星娃子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象

总结类和对象定义类（创建类）"""定义类用代码描述清楚你这个类是拥有哪些相同功能和哪些相同属性的对象的集合。功能 - 对应的是函数属性 - 保存数据的变量（在类中叫属性）语法:class 类名: 类的说明文档类的内容说明：class - 关键字，固定写法类名 - 程序员自己命名要求：是标识符，不是关键字规范：见名知义；驼峰式命名，并且首字母大写，不使用系统函数名、类名和模块名:
复制链接

扫一扫