Python 面向对象 class类的基础

蜗牛其实也很努力

已于 2024-03-18 13:45:00 修改

阅读量965

点赞数 19

分类专栏： Python 文章标签： python

于 2024-01-18 15:34:45 首次发布

本文链接：https://blog.csdn.net/eighters/article/details/135665397

版权

Python 专栏收录该内容

32 篇文章 0 订阅

订阅专栏

面向对象理念

面向对象编程（Object-Oriented Programming，简称OOP）是一种常用的编程范式，它将程序中的数据和操作数据的方法组织在一起，形成对象，通过对象之间的交互来实现程序的功能。

    类：描述具有相同属性和方法的集合，简单来说就是一个模板，通它来创建对象。

    对象：类的实例。

    方法：类中定义的函数。

    类变量：定义在类中且在函数之外的变量，在所有实例化对象中公用。

    局部变量：方法中定义的变量，只作用于当前实例。

面向对象三大特性

    封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式，提高复用性和安全性。

    继承：一个类继承一个基类便可拥有基类的属性和方法，可提高代码的复用性。

    多态：父类定义的引用变量可以指向子类的实例对象，提高了程序的拓展性。

设计一个类的三要素：

类名，这类事物的名字，大驼峰命名法，例如CapWords，单词之间不使用下划线

属性，这类事物具有什么样的特征

方法，这类事物具有什么样的行为

__方法名__格式的方法是python提供的内置方法/属性

定义类

面向对象是更大的封装，在一个类中包含多个方法（函数）

格式

class 类名:
    
    pass

创建对象（实例化一个对象）

class Person:
    pass


tom = Person()
print(tom)

定义一个类 Person

创建了一个对象 tom

创建方法

实例方法(self): 类和实例的属性和方法都可以访问调用
类方法(cls): 只能使用类属性和方法，不能使用实例属性和方法
静态方法(static): 类属性方法和实例属性方法都不能使用，只是依附于该类，相当于独立函数

实例方法

实例方法中的第一个参数是 self，表示实例本身。def定义方法后，会在括号内自动补全 self

class Person:
    def eat(self):
        print("吃了冰淇淋")

    def run(self):
        print("跑了5公里")


tom = Person()
tom.eat()
tom.run()

一个 Person 类，包含了两个方法：eat 和 run

对象 tom 调用了 eat 和 run 的方法

类方法

类方法中的第一个参数是 cls，表示类本身，类方法可以通过类对象和实例对象进行调用。

定义方法后，在括号内会自动补全 cls

使用 @classmethod 装饰器

class Car:
    @classmethod
    def describe(cls, color, brand, city):
        print("这是一个类方法", f"这是一辆{city}产的{color}的{brand}轿车")

Car.describe("黑色", "大众", "德国")

静态方法

默认没有第一个参数，什么也不接收。静态方法是定义在类中的方法，它不需要访问类的实例或实例的属性。它可以通过类名直接调用，而无需创建类的实例。静态方法通常用于执行与类相关但独立于实例的操作。

使用 @staticmethod 装饰器

class MathUtils:
    @staticmethod
    def multiply(x, y):
        return x * y

result = MathUtils.multiply(2, 3)
print(result)

self含义

self指的是调用该类的对象（是一个实例），是一个python自动会给传值的参数

哪个对象执行方法，self就是谁。

例如
obj1.fetch('haha')         self就是obj1

obj2.fetch('hehe')         self就是obj2

对象属性

添加获取对象属性

对象名.属性名

观察下方示例：

class Washer:
    def wash(self):
        print("洗衣服")

haier = Washer()
haier.wash()
haier.width = 400
haier.height = 600
print(f"洗衣机的长宽是{haier.width}, {haier.height}")

haier.width = 400 和 haier.height = 600 就是定义了一个对象的属性

类里面获取对象属性

观察下方示例：

class Washer:
    def info(self):
        print(F"洗衣机的宽度是{self.width}， 高度是{self.height}")


haier = Washer()
haier.width = 400
haier.height = 600
haier.info()

self.width 和 self.height 就相当于haier.width 和 haier.height。
即self就是该类的对象

特殊方法

init()

当使用类名（）创建对象时，会自动执行以下操作

__init__()是对象的的内置方法，是专门用来定义一个类具有哪些属性的方法

class Person:
    def __init__(self):
        print("这是一个初始化方法")
 
result = Person()

这是一个初始化方法

str()

str()是Python中的特殊方法，也称为魔法方法之一。它用于定义对象的字符串表示形式。当尝试将一个对象转换为字符串时（如使用str(obj)或在print语句中使用），Python将尝试调用该对象的__str__()方法来获取字符串表示。

使用__str__()必须使用return返回字符串

class InFo:
    def __init__(self, name, age, city):
        self.name = name
        self.age = age
        self.city = city
 
    def __str__(self):
        return f"{self.name}来自{self.city}, 今年{self.age}了"

student1 = InFo("张三", 18, "北京")
student2 = InFo("李四", 20, "上海")
student3 = InFo("王五", 22, "广州")
print(student1, student2, student3)
张三来自北京, 今年18了李四来自上海, 今年20了王五来自广州, 今年22了
————————————————

实例

创建目录

import os
 
class DirectoryCreate:
    def __init__(self, dir_name):
        self.dir_name = dir_name
 
    def create_directory(self):
        try:
            os.mkdir(self.dir_name)
            print(f"目录 '{self.dir_name}' 创建成功")
        except FileExistsError:
            print(f"目录 '{self.dir_name}' 已经存在，无法创建")
 
# 创建目录的实例
directory_creator = DirectoryCreate("python_package")
directory_creator.create_directory()

定义颜色

class Color:
    END = '\033[0m'  # normal
    BOLD = '\033[1m'  # bold
    RED = '\033[1;91m'  # red
    GREEN = '\033[1;92m'  # green
    ORANGE = '\033[1;93m'  # orange
    BLUE = '\033[1;94m'  # blue
    PURPLE = '\033[1;95m'  # purple
    UNDERLINE = '\033[4m'  # underline
    CYAN = '\033[1;96m'  # cyan
    GREY = '\033[1;97m'  # gray
    BR = '\033[1;97;41m'  # background red
    BG = '\033[1;97;42m'  # background green
    BY = '\033[1;97;43m'  # background yellow
 
    def print_info(self, info):
        colored_info = self.BLUE + info + self.END
        print(colored_info)
 
#  一个普通的变量
resp = "这是一个简单的示例"
content = Color.RED + resp + Color.END
print(content)
 
# 一个对象实例
result = Color()
result.print_info("这是一个封装的简单示例")

继承

单继承

子类拥有父类的所有属性和方法

代码示例

class Animal:
    def eat(self):
        return "吃食物---"
    def run(self):
        return "跑---"

class Dog(Animal):
    def bark(self):
        return "汪汪叫:wangwang~"

class Cat(Animal):
    def mioaomiao(self):
        return "喵喵叫"


animal = Animal()
print(f"动物的天性就是: {animal.eat()}, {animal.run()}")

dog = Dog()
print(f"狗的天性除了: {dog.eat()}, {dog.run()}，还会{dog.bark()}")

cat = Cat()
print(f"猫的天性除了: {cat.eat()}, {cat.run()}，还会{cat.mioaomiao()}")

定义了一个动物类：Animal，其包含两个方法：eat 和 run

定义了一个狗类：Dog，继承其父类 Animal，这样狗的这个类就拥有了其父类（Aniaml）的eat 和 run 方法

同理定义了一个猫类：Cat，继承其父类 Animal，这样狗的这个类就拥有了其父类（Aniaml）的eat 和 run 方法

多继承

和单继承同理，格式参考如下：

class 类名(父类1，父类2):
    pass

代码示例

class Man:
    def father(self):
        print("父亲叫张航")


class Women:
    def mother(self):
        print("母亲叫王丽")


class Son(Man, Women):
    def son(self):
        print("我叫张宇")


son_name = Son()
son_name.son()
son_name.father()
son_name.mother()

Son 这个类继承了父类 Man 和 Women之后，便拥有了他俩的方法

多态

" 多态 " 指的是 相同类型的不同对象 完成某个行为时 , 会得到不同的状态 ;

多态是面向对象编程中一个重要的概念，它允许不同类型的实例在调用相同方法时表现出不同的行为，提高了程序的灵活性和可扩展性

" 多态 " 是通过继承关系实现的

观察下方示例：

class Voice:
    def say(self):
        print('动物基本的发声频率:', end=' ')


class People(Voice):
    def say(self):
        super().say()
        return '嘤嘤嘤'


class Dog(Voice):
    def say(self):
        super().say()
        return '汪汪汪'


class Cat(Voice):
    def say(self):
        super().say()
        return '喵喵喵'

voice = Voice()
voice.say()
print()
people = People()
print(f"人的发声频率：{people.say()}")

dog = Dog()
print(f"狗的发生频率：{dog.say()}")

cat = Cat()
print(f"猫的发生频率：{cat.say()}")

创建了一个父类：Voice，并调用它的 say()方法

定义了三个子类：People、Dog、Cat类，指定父类 Voice

调用People、Dog、Cat类的 say()方法时，使用super().say()语法同时调用父类Voice类的say()方法

输出：