Python3完全新手小白的学习手册 9 类

最新推荐文章于 2025-11-05 13:11:51 发布
原创 最新推荐文章于 2025-11-05 13:11:51 发布 · 494 阅读 · 7 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#学习 #python #开发语言
Python3.8

Python3.8

Conda
Python

Python 是一种高级、解释型、通用的编程语言，以其简洁易读的语法而闻名，适用于广泛的应用，包括Web开发、数据分析、人工智能和自动化脚本

文章目录

面向对象编程（object-oriented programming，oop）是最有效的软件编写方法之一。
你编写表示现实世界中的事物和情景的类（class），并基于这些类来创建对象（object）。
编写类时，你定义一大类对象都有的通用行为。
根据类来创建对象称为实例化，这让你能够使用类的实例。

创建和使用类

编写一个表示小哥的简单类Dog，它表示的是任何小狗。

创建Dog类

Dog类表示的是任何小狗，因此它没有特定的小狗，而只是对小狗的抽象。

Dog类，每个实例都将储存名字和年龄，而且我们会赋予每条小狗坐下（sit()）和打滚（rollover()）的能力。

# 首先定义一个名为Dog的类，首字母大写名称是类
class Dog(object):
    """一次模拟小狗的简单尝试"""

    # 类中的函数称为方法，__init__是一个特殊的方法，每当根据Dog类创建实例时，python都会自动运行它。
    # 方法定义包含三个形参：self、name、age。
    # 形参self必不可少，而且必须位于形参的前面。
    def __init__(self, name, age):
        """初始化属性name和age"""
        self.name = name
        self.age = age

    def sit(self):
        """模拟小狗收到命令时坐下"""
        print(f"{self.name} is now sitting")

    def roll_over(self):
        """模拟小狗收到命令时打滚"""
        print(f"{self.name} rolled over")

类中的函数称为方法，__init__是一个特殊的方法，每当根据Dog类创建实例时，python都会自动运行它。

方法定义包含三个形参：self、name、age。

形参self必不可少，而且必须位于形参的前面。

_init_() 是一个特殊方法，每当你根据 Dog 类创建新实例时，Python 都会自动运行它。
开头和末尾各有两个下划线，这是一种约定，旨在避免 Python 默认方法与普通方法发生名称冲突。

Python 调用这个方法来创建 Dog 实例时，将自动传入实参 self。每个与实例相关联的方法调用都会自动传递实参 self，该实参是一个指向实例本身的引用，让实例能够访问类中的属性和方法。

根据类创建实例

# 我们让 Python 创建一条名字为 'Willie'、年龄为 6 的小狗
my_dog = Dog("Wille", 6)
# 使用提供的值设置属性 name 和 age。接下来，Python 返回一个表示这条小狗的实例，而我们将这个实例赋给变量 my_dog。

print(f"my_dog.name: {my_dog.name}")
print(f"my_dog.age: {my_dog.age}")

1.访问属性

要访问实例的属性，可使用句点表示法。
句点表示法是一种获取对象属性的方式。

# 访问实例的属性
print(f"my_dog.name: {my_dog.name}")
print(f"my_dog.age: {my_dog.age}")

2.调用方法
根据类创建实例后，就可以使用句点表示法来调用 Dog 类中定义的任何方法。

# 调用实例的方法
my_dog.sit()
my_dog.roll_over()

3.创建多个实例
可以根据一个类创建多个实例，就像可以根据 Dog 类创建任意数量的小狗。

# 根据类创建多个实例
your_dog = Dog("Lucy", 3)
print(f"your_dog.name: {your_dog.name}")
print(f"your_dog.age: {your_dog.age}")
your_dog.sit()
your_dog.roll_over()

使用类和实例

class Car:
    """一次模拟汽车的简单尝试"""
    # 建新的 Car 实例时，需要指定其制造商、型号和生产年份。
    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year

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


my_new_car = Car("audi", "a4", 2019)
print(my_new_car.get_descriptive_name())

首先我们创建一个Car类，它表示汽车。
这个类有三个属性：make、model和year。
这个类还有一个方法：get_descriptive_name()。
这个方法返回一个整洁的描述性信息。

my_new_car = Car("audi", "a4", 2019)
print(my_new_car.get_descriptive_name())

我们创建了一个Car实例，并将其赋给变量my_new_car。
我们调用my_new_car的get_descriptive_name()方法，并将返回的值赋给变量long_name。
我们打印long_name的值。

给属性指定默认值

有些属性无须通过形参来定义，可以在 init() 方法中为其指定默认值。
这样在创建实例时就无需为这些属性指定值了。

class Car:
    """一次模拟汽车的简单尝试"""
    # 为属性指定默认值
    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    def get_descriptive_name(self):
        """返回整洁的描述性信息"""
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()    
    def read_odometer(self):
        """打印一条指出汽车里程的消息"""
        print(f"This car has {self.odometer_reading} miles on it.")

我们在 init() 方法中为属性odometer_reading指定了默认值0。
这样，在创建Car实例时，这个属性就会自动设置为0。

my_new_car = Car("audi", "a4", 2019)    
print(my_new_car.get_descriptive_name())    
my_new_car.read_odometer()

我们创建了一个Car实例，并将其赋给变量my_new_car。
我们调用my_new_car的get_descriptive_name()方法，并将返回的值赋给变量long_name。
我们打印long_name的值。
我们调用my_new_car的read_odometer()方法，并打印出汽车的里程。

This car has 0 miles on it.

我们将odometer_reading的值设置为23，并再次调用read_odometer()方法。

my_new_car.odometer_reading = 23
my_new_car.read_odometer()

我们将odometer_reading的值设置为23，并再次调用read_odometer()方法。

This car has 23 miles on it.

修改属性的值

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

  1. 直接修改属性的值
  2. 通过方法修改属性的值
  3. 通过方法对属性的值进行递增

1.直接修改属性的值

my_new_car = Car("audi", "a4", 2019)
print(my_new_car.get_descriptive_name())    
my_new_car.odometer_reading = 23
my_new_car.read_odometer()

我们创建了一个Car实例，并将其赋给变量my_new_car。
我们调用my_new_car的get_descriptive_name()方法，并将返回的值赋给变量long_name。
我们打印long_name的值。
我们将odometer_reading的值设置为23，并再次调用read_odometer()方法。

This car has 23 miles on it.

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

class Car:
    """一次模拟汽车的简单尝试"""
    # 为属性指定默认值
    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    def get_descriptive_name(self):
        """返回整洁的描述性信息"""
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()    
    def read_odometer(self):
        """打印一条指出汽车里程的消息"""
        print(f"This car has {self.odometer_reading} miles on it.") 
    def update_odometer(self, mileage):
        """将里程表读数设置为指定的值"""
        self.odometer_reading = mileage

我们在Car类中添加了一个方法update_odometer()，它接受一个参数mileage，并将odometer_reading的值设置为mileage。

my_new_car = Car("audi", "a4", 2019)    
print(my_new_car.get_descriptive_name())    
my_new_car.update_odometer(23)
my_new_car.read_odometer()

我们创建了一个Car实例，并将其赋给变量my_new_car。
我们调用my_new_car的get_descriptive_name()方法，并将返回的值赋给变量long_name。
我们打印long_name的值。
我们调用my_new_car的update_odometer()方法，并将23作为参数传递给它。
我们调用my_new_car的read_odometer()方法，并打印出汽车的里程。

This car has 23 miles on it.

3.通过方法对属性的值进行递增

class Car:
    """一次模拟汽车的简单尝试"""
    # 为属性指定默认值

    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    def get_descriptive_name(self):
        """返回整洁的描述性信息"""
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()    
    def read_odometer(self):
        """打印一条指出汽车里程的消息"""
        print(f"This car has {self.odometer_reading} miles on it.") 
    def update_odometer(self, mileage):
        """将里程表读数设置为指定的值"""
        self.odometer_reading = mileage
    def increment_odometer(self, miles):
        """将里程表读数增加指定的量"""
        self.odometer_reading += miles

我们在Car类中添加了一个方法increment_odometer()，它接受一个参数miles，并将odometer_reading的值增加miles。

my_new_car = Car("audi", "a4", 2019)
print(my_new_car.get_descriptive_name())
my_new_car.update_odometer(23)  
my_new_car.read_odometer()  
my_new_car.increment_odometer(100)  
my_new_car.read_odometer()

我们创建了一个Car实例，并将其赋给变量my_new_car。
我们调用my_new_car的get_descriptive_name()方法，并将返回的值赋给变量long_name。
我们打印long_name的值。
我们调用my_new_car的update_odometer()方法，并将23作为参数传递给它。
我们调用my_new_car的read_odometer()方法，并打印出汽车的里程。
我们调用my_new_car的increment_odometer()方法，并将100作为参数传递给它。
我们调用my_new_car的read_odometer()方法，并打印出汽车的里程。

This car has 23 miles on it.
This car has 123 miles on it.

继承

继承是面向对象编程的一个重要概念，它允许你根据已有的类创建新类。
新类继承了已有类的属性和方法，同时可以添加新的属性和方法。
继承使得代码更加模块化，易于维护和扩展。

1.子类的方法__init__()

创建子类时，父类必须包含在当前文件中，且位于子类前面。
定义子类时，必须在括号内指定父类的名称。
方法__init__()接受创建 Car 实例所需的信息。
下面以创建电动汽车为例，我们将创建一个名为ElectricCar的子类，它继承了Car类。

class Car:
    """一次模拟汽车的简单尝试"""
    # 为属性指定默认值
    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    def get_descriptive_name(self):
        """返回整洁的描述性信息"""
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()    
    def read_odometer(self):
        """打印一条指出汽车里程的消息"""
        print(f"This car has {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)

我们创建了一个名为ElectricCar的子类，它继承了Car类。
我们在ElectricCar类中添加了一个方法__init__()，它接受一个参数make、model和year。
我们在ElectricCar类中添加了一个方法__init__()，它接受一个参数make、model和year。

my_tesla = ElectricCar("tesla", "model s", 2019)    
print(my_tesla.get_descriptive_name())

我们创建了一个ElectricCar实例，并将其赋给变量my_tesla。
我们调用my_tesla的get_descriptive_name()方法，并将返回的值赋给变量long_name。
我们打印long_name的值。

2019 Tesla Model S

2.给子类定义属性和方法

class Car:
    """一次模拟汽车的简单尝试"""
    # 为属性指定默认值
    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    def get_descriptive_name(self):
        """返回整洁的描述性信息"""
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()
    def read_odometer(self):
        """打印一条指出汽车里程的消息"""
        print(f"This car has {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)
        self.battery_size = 75
    def describe_battery(self):
        """打印一条描述电瓶容量的消息"""
        print(f"This car has a {self.battery_size}-kWh battery.")

我们创建了一个名为ElectricCar的子类，它继承了Car类。
我们在ElectricCar类中添加了一个属性battery_size，并将其值设置为75。
我们在ElectricCar类中添加了一个方法describe_battery()，它打印一条描述电瓶容量的消息。

my_tesla = ElectricCar("tesla", "model s", 2019)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()

我们创建了一个ElectricCar实例，并将其赋给变量my_tesla。
我们调用my_tesla的get_descriptive_name()方法，并将返回的值赋给变量long_name。
我们打印long_name的值。
我们调用my_tesla的describe_battery()方法。

2019 Tesla Model S
This car has a 75-kWh battery.

重写父类中的方法

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

class Car:
    """一次模拟汽车的简单尝试"""
    # 为属性指定默认值
    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    def get_descriptive_name(self):
        """返回整洁的描述性信息"""
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()
    def read_odometer(self):
        """打印一条指出汽车里程的消息"""
        print(f"This car has {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
        
    def fill_gas_tank(self):
        """汽车的油箱"""
        print("This car needs a gas tank!")
class ElectricCar(Car):
    """电动汽车的独特之处"""
    def __init__(self, make, model, year):
        """初始化父类的属性"""
        super().__init__(make, model, year)
        self.battery_size = 75
    def describe_battery(self):
        """打印一条描述电瓶容量的消息"""
        print(f"This car has a {self.battery_size}-kWh battery.")
    def fill_gas_tank(self):
        """电动汽车没有油箱"""
        print("This car doesn't need a gas tank!")

我们创建了一个名为ElectricCar的子类，它继承了Car类。

我们在ElectricCar类中添加了一个方法fill_gas_tank()，它打印一条消息，指出电动汽车没有油箱。

my_tesla = ElectricCar("tesla", "model s", 2019)    
   
my_tesla.fill_gas_tank()

我们创建了一个ElectricCar实例，并将其赋给变量my_tesla。

我们调用my_tesla的fill_gas_tank()方法。

2019 Tesla Model S
This car doesn't need a gas tank!

将实例用作属性

使用代码模拟实物时，你可能会发现自己给类添加的细节越来越多：属性和方法清单以及文件都越来越长。
在这种情况下，可能需要将类的一部分作为一个独立的类提取出来。
你可以将大型类拆分成多个协同工作的小类。
这种方法称为组合（composition）

class Car:
    """一次模拟汽车的简单尝试"""
    # 为属性指定默认值
    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    def get_descriptive_name(self):
        """返回整洁的描述性信息"""
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()
    def read_odometer(self):
        """打印一条指出汽车里程的消息"""
        print(f"This car has {self.odometer_reading} miles on it.")
    def update_odometer(self, mileage):
        """将里程表读数设置为指定的值"""
        self.odometer_reading = mileage
    def increment_odometer(self, miles):
        """将里程表读数增加指定的量"""
        self.odometer_reading += miles

class Battery:
    """一次模拟电动汽车电瓶的简单尝试"""
    def __init__(self, battery_size=75):
        """初始化电瓶的属性"""
        self.battery_size = battery_size
    def describe_battery(self):
        """打印一条描述电瓶容量的消息"""
        print(f"This car has a {self.battery_size}-kWh battery.")



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

my_tesla = ElectricCar("tesla", "model s", 2019)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()

我们创建了一个名为Battery的类，它没有继承任何类。
我们在Battery类中添加了一个方法describe_battery()，它打印一条描述电瓶容量的消息。
我们在ElectricCar类中添加了一个属性battery，并将其值设置为Battery类的实例。
我们创建了一个ElectricCar实例，并将其赋给变量my_tesla。
我们调用my_tesla的get_descriptive_name()方法，并将返回的值赋给变量long_name。
我们打印long_name的值。
我们调用my_tesla的battery的describe_battery()方法。

2019 Tesla Model S
This car has a 75-kWh battery.

导入类

1.导入单个类

# car.py
class Car:
    """一次模拟汽车的简单尝试"""
    def __init__(self, make, model, year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    def get_descriptive_name(self):
        """返回整洁的描述性信息"""
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()

    def read_odometer(self):
        """打印一条指出汽车里程的消息"""
        print(f"This car has {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

我们创建了一个名为Car的类，它有一个方法get_descriptive_name()，它打印一条描述汽车的消息。
我们将这个类保存到一个名为car.py的文件中。

接下来创建另一个文件my_car.py，用于导入Car类并创建Car实例。

from car import Car
my_new_car = Car("audi", "a4", 2019)
print(my_new_car.get_descriptive_name())

my_new_car.odometer_reading = 23
my_new_car.read_odometer()

我们使用import语句导入Car类。

在一个模块中存储多个类


"""一组用于表示燃油汽车和电动汽车的类"""

class Car:
    --snip--

class Battery:
    """一次模拟电动汽车电瓶的简单尝试"""

    def __init__(self, battery_size=40):
        """初始化电池的属性"""
        self.battery_size = battery_size

    def describe_battery(self):
        """打印一条描述电池容量的消息"""
        print(f"This car has a {self.battery_size}-kWh battery.")

    def get_range(self):
        """打印一条描述电池续航里程的消息"""
        if self.battery_size == 40:
            range = 150
        elif self.battery_size == 65:
            range = 225

        print(f"This car can go about {range} miles on a full charge.")

class ElectricCar(Car):
    """模拟电动汽车的独特之处"""

    def __init__(self, make, model, year):
        """
        先初始化父类的属性，再初始化电动汽车特有的属性
        """
        super().__init__(make, model, year)
        self.battery = Battery()

现在新建一个名为my_electric_car.py的文件，用于导入Car类和ElectricCar类，并创建ElectricCar实例。

from car import ElectricCar
my_tesla = ElectricCar("tesla", "model s", 2019)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()

我们使用import语句导入ElectricCar类。

c从一个模块中导入多个类

from car import Car, ElectricCar
my_beetle = Car("volkswagen", "beetle", 2019)
print(my_beetle.get_descriptive_name())
my_tesla = ElectricCar("tesla", "roadster", 2019)
print(my_tesla.get_descriptive_name())

我们使用import语句导入Car类和ElectricCar类。

导入整个模块

import car
my_beetle = car.Car("volkswagen", "beetle", 2019)
print(my_beetle.get_descriptive_name())
my_tesla = car.ElectricCar("tesla", "roadster", 2019)   
print(my_tesla.get_descriptive_name())

我们使用import语句导入整个car模块。

导入模块中的所有类

form module_name import *

这种导入方式不推荐使用，因为它可能导致命名冲突。
如果两个模块都包含一个名为Car的类，那么导入*时，Python将不知道要导入哪个Car类。

在一个模块中导入另一个模块

有时候，需要将类分散到多个模块中，以免模块太大或者在同一个模块中存储不相关的类。

现在可分别从每个模块中导入类。

from car import Car
from electric_car import ElectricCar
my_beetle = Car("volkswagen", "beetle", 2019)   
print(my_beetle.get_descriptive_name()) 
my_tesla = ElectricCar("tesla", "roadster", 2019)   
print(my_tesla.get_descriptive_name())

我们使用import语句导入Car类和ElectricCar类。

使用别名

from car import Car as C
from electric_car import ElectricCar as EC

找到合适的工作流

一开始应让代码结构尽量简单。首先尝试在一个文件中完成所有的工作，确定一切都能正确运行后，再将类移到独立的模块中。

Python标准库

Python 标准库是一组模块，在安装 Python 时已经包含在内。
Python 标准库包含了很多有用的模块，例如：

  • os：用于操作文件和目录
  • sys：用于操作 Python 解释器
  • math：用于进行数学运算
  • random：用于生成随机数
  • datetime：用于处理日期和时间
  • re：用于进行正则表达式匹配
  • json：用于处理 JSON 数据
  • csv：用于处理 CSV 数据
  • pickle：用于序列化和反序列化 Python 对象
  • unittest：用于编写和运行单元测试
  • logging：用于记录日志
  • argparse：用于解析命令行参数
  • socket：用于进行网络编程
  • threading：用于进行多线程编程
  • multiprocessing：用于进行多进程编程

在这个模块中，一个有趣的函数是 randint()。
它接受两个参数：一个是下限，另一个是上限。
这个函数将返回一个位于指定范围内的随机整数。

import random
print(random.randint(1, 6))

我们导入了 random 模块，并使用 randint() 函数生成了一个 1 到 6 的随机整数。

3

在模块 random 中，另一个有趣的函数是 choice()。
它接受一个列表作为参数，并返回列表中的一个随机元素。

import random
players = ["charles", "martina", "michael", "florence", "eli"]
first_up = random.choice(players)
print(first_up)

我们导入了 random 模块，并使用 choice() 函数从 players 列表中选择了一个随机元素。

eli

类编码风格

类名

类名通常采用驼峰命名法，即每个单词的首字母大写，其余字母小写。
例如，类名可以是 Car、ElectricCar、Battery 等。

方法名

方法名通常采用小写字母和下划线的组合，例如 get_descriptive_name()、read_odometer()、update_odometer() 等。

属性名

属性名通常采用小写字母和下划线的组合，例如 make、model、year 等。

文档注释

对于每个类，都应在类定义后面紧跟一个文档字符串。这种文档字符串简要地描述类的功能。每个模块也都应包含一个文档字符串，对其中的类可用来做什么进行描述。

分隔

在类中，可以使用一个空行来分隔方法；而在模块中，可以使用两个空行来分隔类。

先编写导入标准库模块的 import 语句，再添加一个空行，然后编写导入你自己编写的模块的 import 语句。

往期

代码仓库

代码仓库

您可能感兴趣的与本文相关的镜像

Python3.8

Python3.8

Conda
Python

Python 是一种高级、解释型、通用的编程语言，以其简洁易读的语法而闻名，适用于广泛的应用，包括Web开发、数据分析、人工智能和自动化脚本

Python 3 | 菜鸟教程 （一）
热门推荐
wuds_158的博客
06-13 3万+
目录 一、Python3 简介 二、Python 发展历史 三、Python 特点 （一）易于学习 （二）易于阅读 （三）易于维护 （四）一个广泛的标准库 （五）互动模式 （六）可移植 （七）可扩展 （八）数据库 （九）GUI编程 （十）可嵌入 四、Python 应用 五、 Python3 环境搭建 六、Python3 下载 七、Python 安装 （一）下载地址 （二）Unix & Linux 平台安装 Python3: （三）Window 平台安装 Pyt
Python 3 入门，看这篇就够了
m0_59235945的博客
03-18 4619
Python 是一种高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。Python 由 Guido van Rossum 于 1989 年底在荷兰国家数学和计算机科学研究所发明，第一个公开发行版发行于 1991 年。特点易于学习：Python 有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。易于阅读：Python 代码定义的更清晰。易于维护：Python 的成功在于它的源代码是相当容易维护的。一个广泛的标准库。
Python3(超详细python3，三万字教程）
Python单行客的博客
10-16 9236
Python3(超详细python3，三万字教程）
Python笔记——Python 3 | 菜鸟教程 (一)_python3
a25847a的博客
01-02 1298
如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。（二）Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。
python3入门教程(非常详细),python3从入门到精通
chatgpt001的博客
01-31 1489
（一）Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。（二）Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。1、这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。2、这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。3、这意味着Python支持面向对象的风格或代码封装在对象的编程技术。4、
Python3完全新手小白的学习手册 9-1类的总结
qyydeep的博客
07-14 508
本文介绍了Python类的实际应用，通过汽车类案例展示面向对象编程。主要内容包括：1）创建Car基础类，包含制造商、型号、年份属性和里程表操作方法；2）扩展ElectricCar类继承Car类，并组合Battery类实现电动汽车特有功能；3）分别实例化汽油车和电动车，演示类的方法调用。代码采用模块化设计，将不同类放在单独文件中，通过导入实现功能复用，使代码结构更清晰。文章还提供了相关学习资源的链接，适合Python初学者理解类的继承、组合等核心概念。
Python3完全新手小白的学习手册 11学习中期目录
qyydeep的博客
07-08 800
本文总结了Python3新手教程的前10章基础知识，涵盖Python安装、变量、列表、字典、函数、类、文件操作等核心内容。作者强调编程学习需要持续练习，即使是非编程工作也应保持编程习惯。后续将通过3个实战项目（外星人入侵、数据可视化、Web应用）巩固基础，重点培养软件开发思路。建议读者认真学习基础知识，在项目实践中遇到问题时及时回顾前文内容。
Python3完全新手小白的学习手册 4 操作列表
qyydeep的博客
06-25 1154
本文介绍了Python中列表的基本操作和常用方法。主要内容包括：1）使用for循环遍历列表；2）数值列表的创建和操作，包括range()函数的使用、数值统计和列表推导式；3）列表切片的使用方法；4）元组的定义和操作特性。重点讲解了列表遍历、切片、数值列表生成等实用技巧，并对比了列表与元组的异同。通过学习，读者可以掌握Python中列表的基本操作方法和应用场景。
Python3完全新手小白的学习手册 1 Python 的安装
qyydeep的博客
06-23 688
本文介绍了Python和PyCharm的安装方法。对于Python安装，3.9及以上版本无需重装，可通过官网或阿里云镜像下载安装包，安装后使用python3 --version验证。建议使用PyCharm社区版作为开发工具，提供中文支持且免费。教程包含简单的HelloWorld程序示例，使用print函数输出内容。Linux用户通常无需单独安装Python。若遇安装问题可查看终端版本信息确认是否成功。
Python3学习
m0_46692607的博客
09-02 1466
python3 的入门级总结，简单易懂
一文入门Python语言：掌握Python使用规则
bjxiaxueliang的CODING小栈
12-15 8764
Python 是一种高级编程语言，以其简洁清晰的语法而闻名。它在数据科学、机器学习、Web 开发等多个领域都有着广泛的应用。Python 3 作为 Python 的最新版本，拥有更多的新特性和改进。对于初学者来说，理解并掌握 Python 3 的基础语法是迈向编程世界的坚实一步。
python3最全知识点，从入门到开车就是这么简单（建议收藏）
m0_59236602的博客
03-22 2271
此文是自己学习python过程中的笔记和总结.适合有语言基础的人快速了解python3和没基础的作为学习的大纲了解学习的方向、知识点；笔记是从多本书和视频上学习后的整合版。（一）初识python1、一般文件以.py为格式；用#作注释.2、一般对象不用特别声明，python会自动识别；一个对象也可以重新绑定到不同数据类型，因为python采用的是动态类型机制；但对已经声明过的对象则不能改变。
Python3基础库入门（个人学习用）
qq_40773212的博客
03-29 1006
事件循环（event loop）是 asyncio 的核心，可以理解为一个无限循环，我们可以把一些函数（通过 async 定义的函数，称为协程）注册到事件循环（event loop）上，Python 的 queue 库（标准库，无需安装）提供了线程安全的队列（FIFO、LIFO、优先级队列）实现，主要用于多线程编程中实现线程间的数据共享和通信。这个fun()是一个coroutine function（有点像是注册的意思），返回的是一个coroutine object，虽然调用了，但是它不会立马运行。
python string内置函数表格
weixin_42236288的博客
09-11 797
python string内置函数 方法 描述 string.capitalize() 把字符串的第一个字符大写 string.center(width) 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 string.count(str,...
python3(超详细-保姆级教程)
qq_34093387的博客
12-08 3118
Python 的 3.0 版本，常被称为 Python 3000，或简称 Py3k。相对于 Python 的早期版本，这是一个较大的升级。为了不带入过多的累赘，Python 3.0 在设计的时候没有考虑向下兼容。
Python入门：Python3日期和时间全面学习教程
最新发布
不踩坑，不知道坑有多深；不总结，踩过的坑白踩。
11-05 15万+
Python入门：Python3日期和时间全面学习教程，该教程围绕Python3中time和calendar模块，系统讲解日期时间处理知识。先介绍核心概念，时间戳以1970年1月1日为起点计秒，存在时间范围限制，时间元组（struct_time）含9个时间字段；接着详解time模块，包括获取当前时间（元组与可读格式）、日期格式化（strftime与strptime）、时间戳转换、程序延时及CPU时间计算等功能与属性；然后阐述calendar模块，涵盖打印月/年历、闰年判断、月份信息获取等操作……
python3基础入门篇
Documentlv的博客
03-15 1031
Python 3 是一种高级编程语言，可以运行在各种操作系统中。它是Guido van Rossum 在1989年底发布的，现在由 Python 软件基金会维护。Python 3 与其前身 Python 2 相比，有很多重要的改进和新特性。最明显的是 Python 3 在语法和标准库上有很多变化，这些变化使得 Python 3 更加现代化、易于学习和使用。
Python 3 学习笔记之基础篇（一）
兰君
02-07 905
从零基础开始，讲述Python3的每一个基础细节，看完你可以编写简单的Python小程序，包含：1.Python3 简介 2.Python3 环境搭建 3. Python3 基础语法 4. Python3 基本数据类型 5. Python3 运算符
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

qyydeep

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值