【Python零基础】类的概念

最新推荐文章于 2024-09-02 23:14:47 发布
最新推荐文章于 2024-09-02 23:14:47 发布
阅读量1.7k 收藏 46
点赞数 43
分类专栏： python 文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40141628/article/details/141439896
版权

文章目录

前言

面向对象编程是现在使用最多的软件编写方法之一。面向对象中最核心的就是类(class)，类用来描述现实世界的事物和情景，我们基于这些类来创建实例对象。类就是这些对象共有的属性和行为的抽象。举个例子——鸟类，鸟类共有的属性如一对翅膀，双爪。共有的行为如飞翔，进食。这样当我们创建一个鸟类的实例对象时，就自动拥有这些属性和行为。

在Python中，类是一种用户定义的数据类型，使用class关键字定义。类定义了一组相关的属性（数据成员）和方法（成员函数），用于描述一类对象的共同特征和行为。通过实例化类，可以创建具有相同特性和行为的具体对象。类支持封装、继承和多态等面向对象编程的核心概念，有助于提高代码的复用性和可维护性。

新手读者朋友暂且先不必关注什么是封装、继承、多态。后面慢慢的结合代码会理解。

一、创建并使用类

创建Student类

我们先来创建一个Student类，文件名为 student.py

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

    def student_info(self):
        return f"Student(name={self.name}, age={self.age})"

1.类的定义

class Student:

根据这个可以总结出类的定义模板为：

class ClassName

2.构造函数

   def __init__(self, name, age):
       self.name = name
       self.age = age

这个 init()方法是构造函数方法，是Python中类的最基本的默认方法，只能是这个名字，不能自行修改，前后有两个下划线是为了和普通方法做区分。我们自己定义的方法当然也可以使用下划线，但是实在是没有必要，还会引起混淆，分不清Python默认方法还是自定义方法。每个类在实列化时都会自动调用的方法，进行一些初始化的操作，如属性赋值等。构造函数中为当前的实例对象设置两个属性name和age

  • self是一个指向实例本身的引用，它是每个实例方法的第一个参数。在这个例子中，self代表创建的Student对象。
  • name和age是传递给构造函数的参数，用于初始化Student对象的属性。
  • self.name = name 和 self.age = age 分别将传入的name和age值存储为对象的属性。

3.自定义方法

   def student_info(self):
       return f"Student(name={self.name}, age={self.age})"

这个是我们自定义的方法，返回学生信息，比较简单。

重点解释下这个 self 参数，每个方法默认第一个参数就是self，这个是必不可少的参数（除非你不想使用任何参数，那就不必传），并且必须位于其他形参的前面。Python调用_init_()方法时，会自动传入self参数。每个与实列对象相关联的方法，都会自动传递实参self，该实参是一个指向实例本身的引用，让实列能够访问实列中的属性和方法

这个self可以替换成其他的，比如this，但是我们写代码时不要去替换。使用self来表示当前实例的引用是默认的规则，更改反而不利于他人的阅读理解，属于画蛇添足

根据Student类创建一个实例

我们再创建一个test.py文件，在其中引入Student类

from student import Student

my_student = Student(name='John', age=30)

print(f"My name is {my_student.name}")

print(f"My age is {my_student.age}")

代码 **my_student = Student(‘John’, ‘Doe’)**就是Student类实例化的方式，我们传入了两个实参，分别对应方法 _init_(self, name, age)中的后两个参数，第一个self默认自动传入。 _init_()方法会自动返回一个实例，不需要显示的return

在这里插入图片描述

1.访问属性

如 my_student.name，my_student.age

实例名.属性名

2.调用方法

from student import Student

my_student = Student(name='John', age=30)

student_info = my_student.student_info()

print(student_info)

如 my_student.student_info()，调用了student_info()方法

实例名.方法名

3.创建多个实例

from student import Student

my_student1 = Student(name='John', age=30)

my_student2 = Student(name='Luke', age=25)

student_info1 = my_student1.student_info()

student_info2 = my_student2.student_info()

print(student_info1)

print(student_info2)

代码中创建了两个实例对象，分别调用了各自的实例方法 student_info

在这里插入图片描述

二、使用类和实例

创建Car类

class Car:
    """一次模拟汽车的简单尝试"""

    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year

    def get_descriptive_name(self):
        """返回整洁的描述性信息"""
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name.title()


my_new_car = Car('audi', 'a4', 2016)

print(my_new_car.get_descriptive_name())

下面是对这段代码的详细解释

类定义

  • 类名：Car
  • 文档字符串：“一次模拟汽车的简单尝试”，用于描述类的功能。

初始化方法 init

  • 参数：
    • self：代表类的实例，是每个方法的第一个参数。
    • make：汽车制造商的名字。
    • model：汽车型号。
    • year：汽车生产年份。
  • 功能：
    • 初始化汽车的三个属性：制造商、型号和生产年份。
    • 这些属性通过 self.make、self.model 和 self.year 存储在实例中。

方法 get_descriptive_name

  • 功能：
    • 返回一个格式化的字符串，包含汽车的所有信息。
    • 字符串格式为：“YearMakeModel”，其中 Year 是四位数字的年份，Make 和 Model 分别是制造商和型号。
    • 使用 title() 方法将字符串中的单词首字母大写。

创建实例并调用方法

  • 实例化：
    • 创建了一个 Car 类的实例 my_new_car，传入了 “audi”、“a4” 和 2016 作为参数。
  • 调用方法：
    • 通过 my_new_car.get_descriptive_name() 调用了 get_descriptive_name 方法。
    • 输出结果：“2016AudiA4”，其中每个单词的首字母都被大写了。

在这里插入图片描述

给属性指定默认值

类中的每个属性都必须有初始值，哪怕这个值是0或空字符串。在有些情况下，如设置默认值时，在方法_init_()内指定这种初始值是可行的；如果你对某个属性这样做了，就无需包含为它提供初始值的形参。

class Car:
    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        # 设置初始值里程数 = 0
        self.odometer_reading = 0

    def get_descriptive_name(self):
        return str(self.year) + ' ' + self.make + ' ' + self.model
    def read_odometer(self):
        """打印一条指出汽车里程的消息"""
        print("This car has " + str(self.odometer_reading) + " miles on it.")


my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name())
#读取里程数
my_new_car.read_odometer()

在这里插入图片描述
汽车里程odometer_reading的属性被我们指定成0

修改属性的值

可以以三种不同的方式修改属性的值：

  1. 直接通过实例进行修改
  2. 通过方法进行设置
  3. 通过方法进行递增（增加特定的值）​

1.直接通过实例进行修改

#设置里程数
my_new_car.odometer_reading = 30
#读取里程数
my_new_car.read_odometer()

调用读取里程数之前，先通过实例修改了属性值

在这里插入图片描述

2.通过方法修改属性的值

我们在car.py的Car类下面增加一个方法 update_odometer，用于修改里程值。
update_odometer()在修改属性前检查指定的读数是否合理。如果新指定的里程(mileage)大于或等于原来的里程(self.odometer_reading)，就将里程表读数改为新指定的里程；否则就发出警告，指出不能将里程表往回拨。

    def update_odometer(self, mileage):
        """将里程表读数设置为指定的值"""
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("you can't roll back an odometer!")

接着调用方法，设置属性

#设置里程数
my_new_car.update_odometer(46)
#读取里程数
my_new_car.read_odometer()

控制台打印结果如下

This car has 46 miles on it.

3.通过方法让属性值递增
有时，我们需要对属性值进行递增操作，而不是完全替换，再提供一个递增方法

    def increment_odometer(self, miles):
        """将里程表读数增加指定的量"""
        self.odometer_reading += miles

递增调用的代码如下

#增加里程数
my_new_car.increment_odometer(10)
#读取里程数
my_new_car.read_odometer()

#增加里程数
my_new_car.increment_odometer(20)
#读取里程数
my_new_car.read_odometer()

打印结果如下

在这里插入图片描述
上述方法实际开发中，我们需要做好权限和风险控制，防止出现意外结果

三、继承

继承这个概念比较容易理解，并不是Python语言独有的，是面向对象编程思想的核心概念之一。从字面上来看，就是类属性和方法的复用，创建一个类继承另外一个类，那么这个类便拥有了继承那个类的属性和方法。创建的这个类叫子类，继承的类叫父类。子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。

子类中的__init__()方法

class Car:
    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        # 设置初始值里程数 = 0
        self.odometer_reading = 0

    def get_descriptive_name(self):
        return str(self.year) + ' ' + self.make + ' ' + self.model
    def read_odometer(self):
        """打印一条指出汽车里程的消息"""
        print("This car has " + str(self.odometer_reading) + " miles on it.")

    def update_odometer(self, mileage):
        """将里程表读数设置为指定的值"""
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("you can't roll back an odometer!")

    def increment_odometer(self, miles):
        """将里程表读数增加指定的量"""
        self.odometer_reading += miles


"""
继承
"""
class ElectricCar(Car):
    """电动汽车的独特之处"""
    def __init__(self, make, model, year):
        """初始化父类的属性"""
        super().__init__(make, model, year)


my_electric_car = ElectricCar('tesla', 'model s', 2016)
print(my_electric_car.get_descriptive_name())

class ElectricCar(Car)这种写法就是ElectricCar类继承自Car类，创建子类时，必须引入父类的代码。笔者这里是把父类和子类写在一个模块文件里了，如果父类是在一个单独的模块中，比如car.py，则需要引入，具体如下

在这里插入图片描述
子类继承父类的所有属性和方法，代码运行结果如下

在这里插入图片描述

重写父类中的方法

对于父类的方法，只要它不符合子类模拟的实物的行为，都可对其进行重写。为此，可在子类中定义一个这样的方法，即它与要重写的父类方法同名。这样，Python将不会考虑这个父类方法，而只关注你在子类中定义的相应方法。

父类代码如下

class Car:
    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        # 设置初始值里程数 = 0
        self.odometer_reading = 0

    def fill_gas_tank(self):
        return "跑的里程数为:"+str(self.odometer_reading)

在子类所在模块中定义一个同名的方法，要求参数个数、类型、顺序都要和父类保持一致。可选参数必须放在最后，子类可以省略可选参数。

把实例用作属性

在 Python 中，可以将一个类的实例作为另一个类的属性。这种做法允许你将不同类的对象组合在一起，形成更复杂的数据结构。

假设我们有两个类：Address 和 Person。我们将创建一个 Address 实例，并将其作为 Person 类的一个属性。

定义 Address 类

class Address:
    def __init__(self, street, city, state, zip_code):
        self.street = street
        self.city = city
        self.state = state
        self.zip_code = zip_code

    def display_address(self):
        return f"{self.street}, {self.city}, {self.state} {self.zip_code}"

定义 Person 类

class Person:
    def __init__(self, name, age, address):
        self.name = name
        self.age = age
        self.address = address  # 将 Address 类的实例作为属性

    def display_person_info(self):
        return f"Name: {self.name}, Age: {self.age}, Address: {self.address.display_address()}"

调用代码示例如下

# 创建 Address 实例
address = Address("123 Main St", "Anytown", "CA", "12345")

# 创建 Person 实例，并传入 Address 实例作为属性
person = Person("Alice", 30, address)

# 显示 Person 的信息
print(person.display_person_info())

以上示例中创建了一个Address类的实例，并作为属性传递给Person类

运行结果如下

在这里插入图片描述
笔者把这些代码都放在了一个模块中

在这里插入图片描述

四、导入类

实际开发场景是复杂的，我们不可能把所有逻辑都写在一个模块中，更不能写在一个类中。我们要考虑可维护性、可复用性。这就要求我们要合理的划分模块，建立类。不过这种只有经过大量的实战项目，代码练习才能具备相当的经验。目前我们只需要掌握以下内容即可。

导入单个类

首先新建一个address.py文件，其中代码如下

class Address:
    def __init__(self, street, city, state, zip_code):
        self.street = street
        self.city = city
        self.state = state
        self.zip_code = zip_code

    def display_address(self):
        return f"{self.street}, {self.city}, {self.state} {self.zip_code}"

再新建一个my_address.py文件，在这个文件中引入address.py中的Address类，实例化是一个对象my_address ，打印地址信息

from address import Address

my_address = Address("123 Main St", "Any town", "CA", "12345")

address_info = my_address.display_address()

print(address_info)

在一个模块中存储多个类

先建立一个player_characters.py文件，在其中新建几个不同游戏玩家角色的类Warrior、Mage、Archer

class Warrior:
    def __init__(self, name, strength=80, health=100):
        self.name = name
        self.strength = strength
        self.health = health

    def attack(self):
        return f"{self.name} attacks with a strength of {self.strength}!"

    def get_health(self):
        return f"{self.name}'s health is {self.health}."


class Mage:
    def __init__(self, name, intelligence=70, mana=120):
        self.name = name
        self.intelligence = intelligence
        self.mana = mana

    def cast_spell(self):
        return f"{self.name} casts a spell with an intelligence of {self.intelligence}!"

    def get_mana(self):
        return f"{self.name}'s mana is {self.mana}."


class Archer:
    def __init__(self, name, agility=90, arrows=50):
        self.name = name
        self.agility = agility
        self.arrows = arrows

    def shoot_arrow(self):
        if self.arrows > 0:
            self.arrows -= 1
            return f"{self.name} shoots an arrow! Arrows left: {self.arrows}"
        else:
            return f"{self.name} has no more arrows!"

    def get_arrows(self):
        return f"{self.name}'s arrows: {self.arrows}."

从一个模块中导入多个类

再新建一个game.py文件，导入上述player_characters.py文件中的三个类，分别实例化并调用其中的方法

from player_characters import Warrior, Mage, Archer

# 创建角色实例
warrior = Warrior("Thorin")

mage = Mage("Gandalf")

archer = Archer("Pergolas")

# 执行角色的动作
print(warrior.attack())
print(mage.cast_spell())
print(archer.shoot_arrow())
print(archer.shoot_arrow())

# 查看角色的状态
print(warrior.get_health())
print(mage.get_mana())
print(archer.get_arrows())

在这里插入图片描述

导入整个模块

笔者这里使用了别名module，不使用也可以，直接使用模块的名称player_characters调用其中的类进行实例化

import player_characters as module

# 创建角色实例
warrior = module.Warrior("Thorin")

mage = module.Mage("Gandalf")

archer = module.Archer("Pergolas")

# 执行角色的动作
print(warrior.attack())
print(mage.cast_spell())
print(archer.shoot_arrow())
print(archer.shoot_arrow())

# 查看角色的状态
print(warrior.get_health())
print(mage.get_mana())
print(archer.get_arrows())

**导入模块中的所有类 **

导入模块中的所有内容的语法如下，本质上没有区别

from player_characters import *

不推荐使用这种导入方式，原因有以下两点

  • 首先，如果只要看一下文件开头的import语句，就能清楚地知道程序使用了哪些类，将大有裨益；但这种导入方式没有明确地指出你使用了模块中的哪些类。这种导入方式还可能引发名称方面的困惑。如果你不小心导入了一个与程序文件中其他东西同名的类，将引发难以诊断的错误。这里之所以介绍这种导入方式，是因为虽然不推荐使用这种方式，但你可能会在别人编写的代码中见到它。
  • 需要从一个模块中导入很多类时，最好导入整个模块，并使用module_name.class_name语法来访问类。这样做时，虽然文件开头并没有列出用到的所有类，但你清楚地知道在程序的哪些地方使用了导入的模块；你还避免了导入模块中的每个类可能引发的名称冲突。

导入模块中少量类使用如下语法

from player_characters import Warrior, Mage, Archer

导入模块中大量类使用如下语法

import player_characters

五、Python标准库

Python标准库是一组模块，安装的Python都包含它。就是官方提供的工具类库，基础库，帮我们封装和实现好了许多复杂又常用的数据结构。

新建一个birthday_calculator.py的文件，这是一个提供计算距离下一个生日天数的工具类，其中使用了datetime、random两个标准库的函数

import datetime
import random


def days_until_birthday(birth_date):
    """
    计算距离下一个生日还有多少天。
    
    参数:
    birth_date (str): 生日日期，格式为 'YYYY-MM-DD'。
    
    返回:
    int: 距离下一个生日的天数。
    """
    today = datetime.date.today()
    next_birthday = datetime.datetime.strptime(birth_date, '%Y-%m-%d').date().replace(year=today.year)
    if next_birthday < today:
        next_birthday = next_birthday.replace(year=today.year + 1)
    return (next_birthday - today).days


def get_random_wish():
    """
    随机选择一条祝福语句。
    
    返回:
    str: 祝福语句。
    """
    wishes = [
        "祝你生日快乐，愿你拥有美好的一年！",
        "希望你的每一个愿望都能实现！",
        "愿你的每一天都充满阳光和笑容！",
        "愿你新的一岁更加精彩！",
        "生日快乐，愿你健康平安！"
    ]
    return random.choice(wishes)

再新建一个main.py文件，代码如下

from birthday_calculator import days_until_birthday, get_random_wish


def main():
    print("欢迎使用生日计算器！")
    birth_date = input("请输入你的生日（格式：YYYY-MM-DD）: ")
    days_until = days_until_birthday(birth_date)
    print(f"距离你的下一个生日还有 {days_until} 天！")
    wish = get_random_wish()
    print(wish)


if __name__ == "__main__":
    main()

在这里插入图片描述

六、类的编码风格

在Python中，类的编码风格通常遵循PEP 8规范，这是Python官方推荐的编码风格指南。以下是关于类定义的一些关键编码风格要点：

1. 类名命名：

  • 类名应该使用CapWords（首字母大写）的命名方式，例如 MyClass。

2. 方法名命名：

  • 方法名应该使用小写字母加上下划线 _ 的方式，例如 my_method。

3. 空行：

  • 在类定义之间以及类的外部方法之间使用两个空行。
  • 在类的方法之间使用一个空行。

4. 文档字符串：

  • 类和方法都应该有文档字符串，用三引号括起来，放在类或方法的第一行。
  • 文档字符串应简洁地描述类或方法的目的和功能。

5. 私有成员：

  • 如果一个方法或属性不打算被外部使用，可以使用单下划线 _ 开头来标记为“私有”。
  • 如果是绝对不希望外部访问的，可以使用双下划线 __ 开头，但这不是强制性的。

6. 继承：

  • 继承时，在括号内指定父类名，例如 class Child(Parent):。

7. 初始化方法：

  • 类通常会有一个初始化方法 init，用于设置实例变量。

8. 方法参数：

  • 第一个参数通常是 self，代表实例本身。
  • 其他参数按照逻辑顺序排列。

9. 代码缩进：

  • 使用4个空格进行缩进，而不是制表符。

简单示例代码如下，我们实际开发中需要遵循这些规则，不要擅自自创规则，使得代码可读性很差。

class MyClass:
    """这是一个简单的类示例。"""

    def __init__(self, name):
        """初始化方法。

        参数:
            name (str): 实例的名字。
        """
        self.name = name

    def say_hello(self):
        """打印问候消息。"""
        print(f"Hello, {self.name}!")

总结

本文详细介绍了Python中有关类的创建和使用相关代码示例，介绍了标准库和代码风格的一些公共规则。通过练习，我们应该对类这个面向对象编程的核心概念有所领悟。

@步行者@
关注
  • 43
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python零基础入门资料 python基础
01-08
作为零基础的你，想要入门Python，首先要理解它的基本概念和语法结构。 1. **变量与数据类型**：在Python中，声明变量非常简单，无需指定数据类型。Python有多种内置的数据类型，如整型（int）、浮点型（float）、...
零基础学python.pdf
04-28
零基础学Python Python是一种高级语言编程，最近几年来越来越流行，成为...本教程旨在帮助零基础的学习者快速入门Python，掌握基础语法和数据结构，了解控制流语句、函数、模块等基本概念，并应用于实际工作中。
python零基础入门学习
03-10
本教程主要针对零基础的学员，旨在帮助他们快速掌握Python的基本概念和操作。以下是基于标题、描述和部分内容的详细知识点解析： ### 1. Python环境配置 在Windows 10（64位）系统下配置Python环境主要包括以下...
Python零基础教程
02-13
本资源摘要信息主要介绍Python零基础教程的相关知识点，涵盖Python的基本概念、特点、应用场景等。 Python的定义和特点 Python是一种高效、功能强大的编程语言，擅长于解决问题，而非拘泥于语法与结构。它具有高...
零基础学Python全彩版课后习题答案
09-16
"零基础学Python全彩版"是一本面向初学者的教材，旨在帮助读者从零开始掌握Python编程的基本概念和技巧。课后习题和课堂练习是学习过程中不可或缺的部分，它们能够检验和巩固所学知识，促进理论与实践的结合。 课后...
【python】关于判断空值None、判断len()=0，和 if not 的区别
Meggie35的博客
08-28 7157
python的“空”与“无”之辩，关于None，和空数值。在程序中，判断里面没有值和判断东西是不是为空，也是不一样的东西，我们可以往下看看具体的区别。
爬取长篇小说：选择何种IP策略最佳？
KookeeyLena5的博客
08-29 435
在爬取长篇小说时，选择合适的IP策略至关重要。根据目标网站的反爬虫机制、请求频率限制以及爬取需求的不同，可以选择静态IP、动态IP、住宅IP或数据中心IP等不同类型的IP地址。同时，使用代理服务器或VPN等工具可以进一步提高爬取的稳定性和效率。在爬取过程中，应遵循最佳实践，确保爬取行为的合法性和稳定性。
CUDA编程08 - 并行编程思维
最新发布
GPU全栈博主-程序哥
09-02 1020
到目前为止，我们集中于学习并行编程的实用知识，包括CUDA编程接口特性、GPU架构、性能优化技术、并行模式和应用案例研究。在本章中，我们将讨论更为抽象的概念。我们将并行编程概括为一种思维过程，即设计或选择并行算法，并将一个实际问题分解基本的工作单元，这些工作单元可以由所选的算法高效地执行。具备强大思维技能的程序员不仅会分析问题，还会转变实际问题的结构：哪些部分本质上是串行的，哪些部分适合并行执行，以及将前者的部分转移到后者所涉及的一些权衡。
【Python报错已解决】`TypeError: ‘numpy.ndarray‘ object is not callable`
鸽芷咕的博客
09-01 269
在编程中，你是否遇到过尝试调用一个Numpy数组对象时出现了`TypeError: 'numpy.ndarray' object is not callable`的报错？这个问题通常是由于误将Numpy数组当成了一个函数来调用。接下来，我们将分析这个问题并提供解决方案。
np.ndarray和np.array区别；MXNet的 mx.array 类型是什么；NDArray优化了什么：并行计算优化
ZJQ的博客
09-01 168
如果使用传统的密集格式（如NumPy的ndarray）来存储这些梯度，将会占用大量的内存，并导致计算效率低下。MXNet是一个开源的深度学习框架，它提供了多种数据结构和操作来支持高效的数值计算和深度学习模型的训练。总之，MXNet的NDArray通过异步计算、内存优化、高效的数学和线性代数运算、稀疏数据支持以及自动化求导等优化措施，为深度学习模型的训练和数值计算提供了强大的支持。在表面上看似不同，但实际上它们之间有着紧密的联系，并且在大多数情况下可以互换使用，但它们的本质和用途略有不同。
BeautifulSoup：Python网页解析库详解
零度°C的博客
08-30 763
是一个Python库，用于从HTML或XML文件中提取数据。它能够通过简单的方法处理复杂的HTML文档，并且很容易就能找到你需要的标签和数据。
python json jsonl 的用法
大多_C的博客
08-28 1583
JSONL格式是一种非常实用的数据存储格式，特别适合处理大型、结构化的数据集。逐行读取：有效处理大文件，节省内存。简便性：每一行都是独立的JSON对象，便于解析和处理。灵活性：可以很容易地将数据追加到已有文件中。通过上述方法，您可以轻松地在Python中读取、写入和处理JSONL格式的数据。
java 基于Swing的随机点名
tonysong111073的专栏
09-02 140
使用java的swing开发的随机点名
python方法介绍
weixin_67832625的博客
08-28 1125
前言导读：Python的创始⼈人为吉多·范罗苏姆（Guido van Rossum）。1989年年的圣诞节期间，吉多·范罗苏姆为了了在阿姆斯特丹打发时间，决⼼开发一个新的脚本解释程序，作为ABC语言的一种继承。其诞生于1990年；
Python开源项目周排行 2024年第14周
cbbxn的博客
08-29 1398
注:当前文章会不定期进行更新。标签： 音频 AIGC。
喜羊羊做Python真题
dhdjjfhdghh的博客
08-31 483
今日，喜羊羊分享Python二级真题过程，为大家分享一些易错点，感谢大家的关注和点赞。
编译Android9报错，原来是python版本问题
ldswfun的专栏
08-29 199
编译代码的时候，代码没有变动，都正常编译，今天编译突然报错，以为是代码仓库切的分支不对，后面才记起来，为了编译第三方库，将python从2.7换成了3.6，结果就出现这个问题，原来android9必须要求python2
13. EnumSet是什么？为什么它的性能优于常规的Set实现？
zhzjn的博客
08-28 396
EnumSet。
python-FastApi框架
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
08-29 976
FastAPI 是一个用于构建 API 的现代、快速（高性能）的 web 框架，使用 Python 并基于标准的 Python 类型提示。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值