【python编程从入门到实践】第九章总结-类

最新推荐文章于 2023-03-16 00:33:34 发布
最新推荐文章于 2023-03-16 00:33:34 发布
阅读量355 收藏 1
点赞数 1
分类专栏： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_40024275/article/details/103406532
版权

python编程 从入门到实践 第九章

创建和使用类

创建Dog类
class Dog():
	"""一次模拟小狗的简单尝试"""
	def __init__(self, name, age):
		"""初始化属性name和age"""
		self.name = name
		self.age = age
	
	def sit(self):
		"""模拟小狗被命令时蹲下"""
		print
		(self.name.title() + ' is now sitting')
	
	def roll_over(self):
		"""模拟小狗被命令时打滚"""
		print(self.name.title() + ' rolled over.')
方法__init__()
  • 类中的函数成为方法。
    -__init__()方法是一个特殊的方法，每当根据Dog类创建新实例的时候，python都会自动运行它。
  • 在这个方法名称中，开头和末尾各有两个下划线，这是一种约定，避免python默认方法与普通方法发生名称冲突。
  • 将方法__init__()定义成了包含三个形参：self、name、age。在这个方法的定义中，形参self必不可少，还必须位于其他形参的前面。
  • self形参：python在调用这个__init__()方法来创建Dog实例时，将自动传入实参self。
  • 每个与类相关量的方法调用都自动传递实参self，它是一个指向实例本身的引用，让实例可以访问类中的属性和方法。
  • 每次根据Dog实例创建对象的时候，都只需给最后两个形参提供值。
  • __init__()函数体内的两个变量都有前缀self.。以self.为前缀的变量都可以共类中的所有方法使用，我们还可以通过类的任何实例来访问这些变量。
  • self.name = name：获取存储在形参name中的值，并将其存储到变量name中，然后该变量被关联到当前创建的实例。
  • 可以通过实例来访问的变量称之为“属性”。
其他方法
  • Dog类中还定义了其他两个方法。这些方法不需要额外的信息，因此它们只有一个形参self。
根据类创建实例
my_dog = Dog('Willie', 6)
print("My dog's name is " + my_dog.name.title() + '.')
print("My dog is ", my_dog.age + 'years old')
my_dog.sit()
my_dog.roll_over()
  • 这里使用的是前一个例子中编写的Dog类。
  • 在第一行，我们让python创建一条名字为Willie，年龄为6的小狗狗。遇到这一行代码时，python使用实参Willie和6调用Dog类中的方法__init__()。方法__init__()创建一个表示特定小狗的实例，并使用我们提供的值来设置属性name和age。方法__init__()并未显式地包含return语句，但是python会自动返回一个表示这条小狗的实例。我们将这个实例存储在变量my_dog中。
  • 通常约定，首字母大写的名称指的是类名，而小写的名称通常是指根据类创建的实例。
  • 要访问实例的属性，可以用句点表示法，如：my_dog.name。python会先找到实例my_dog，再查找跟这个实例相关联的属性name。在Dog类中引用这个属性时，使用的是self.name
  • 要调用实例的方法，可以使用句点表示法。先指定实例的名称以及要调用的方法，并用句点分隔他们。代码运行到该行时，python会在Dog类助攻查找对应的方法并且运行其代码。
  • 可以按照需求根据类创建任意数量的实例。

Part One 练习

# 9.1 餐馆
print('---------- 9.1 ----------')
class Restaurant():
    def __init__(self, restaurant_name, cuisine_type):
        self.restaurant_name = restaurant_name
        self.cuisine_type = cuisine_type

    def describe_restaurant(self):
        print('restaurant_name: ' + self.restaurant_name)
        print('cuisine_type: ' + self.cuisine_type)

    def open_restaurant(self):
        print('This restaurant ' + self.restaurant_name + ' is open now.')

KFC = Restaurant('KFC', 'Western-style food')
print(KFC.restaurant_name+' '+ KFC.cuisine_type)
KFC.describe_restaurant()
KFC.open_restaurant()

# 9.2 三家餐馆
print('---------- 9.2 ----------')
KFC = Restaurant('KFC', 'Western-style food')
KFC.describe_restaurant()
KFC.open_restaurant()
QuanJuDe = Restaurant('QuanJuDe', 'Chinese food')
QuanJuDe.describe_restaurant()
QuanJuDe.open_restaurant()
Dong = Restaurant('Dong Laishun', 'Chinese food')
Dong.describe_restaurant()
Dong.open_restaurant()

# 9.3 用户
print('---------- 9.3 ----------')
class User():
    def __init__(self, first, last, **user_info):
        self.first_name = first
        self.last_name = last
        self.user_info = {}
        for k,v in user_info.items():
            self.user_info[k] = v

    def describe_user(self):
        print('first name: ' + self.first_name +
              '; last name: ' + self.last_name)
        for k,v in self.user_info.items():
            print(k, ':', v)

    def greet_user(self):
        print('Hello! ', self.first_name, self.last_name)

user1 = User('Vera', 'Zhang')
user1.describe_user()
user1.greet_user()
user2 = User('Sunny', 'Sun', city='HeKou', age=23)
user2.describe_user()
user2.greet_user()

使用类和实例

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())
给属性指定默认值
  • 类中的每一个属性都必须有初始值，哪怕这个值是0或者空字符串。
  • 在有些情况下，如设置默认值时，在方法__init__()内指定这种初始值是可行的。
  • 如果已经对某个属性在方法__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 = str(self.year) + ' ' + self.make + ' ' + self.model
		return long_name.title()
	
	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()
修改属性的值
  1. 直接修改属性的值
my_new_car.odometer_reading = 23
my_new_car.read_odometer()
  1. 通过方法进行设置
# 在类中添加一个方法
def update_odometer(self, mileage):
	if mileage >= self.odometer_reading:
		self.odometer_reading = mileage
	else:
		print('You cannot roll back an aodometer!')

# 类外进行的操作
my_new_car.update_odometer(23)
my_new_car.read_odometer()
  1. 通过方法进行递增
# 在类中添加一个方法
def increment_odometer(self, miles):
	if miles >= 0:
		self.odometer_reading += mileage
	else:
		print('You cannot roll back an aodometer!')
# 类外进行的操作
my_new_car.increment_odometer(10)
my_new_car.read_odometer()

Part Two 练习

# 9.4 就餐人数
print('---------- 9.4 ----------')
class Restaurant():
    def __init__(self, restaurant_name, cuisine_type):
        self.restaurant_name = restaurant_name
        self.cuisine_type = cuisine_type
        self.number_served = 0

    def describe_restaurant(self):
        print('restaurant_name: ' + self.restaurant_name)
        print('cuisine_type: ' + self.cuisine_type)

    def open_restaurant(self):
        print('This restaurant ' + self.restaurant_name + ' is open now.')

    def set_number_served(self, num):
        if num >= self.number_served:
            self.number_served = num
        else:
            print('Number of people served must increase at every time.')

    def increment_number_served(self, num):
        if num >= 0:
            self.number_served += num
        else:
            print('Number of people served must increase at every time.')

my_restaurant = Restaurant('My Res', 'Chinese food')
print('Number of people served:', my_restaurant.number_served)
my_restaurant.set_number_served(10)
print('Number of people served:', my_restaurant.number_served)
my_restaurant.increment_number_served(5)
print('Number of people served:', my_restaurant.number_served)

# 9.5 尝试登录次数
print('---------- 9.5 ----------')
class User():
    def __init__(self, first, last, **user_info):
        self.first_name = first
        self.last_name = last
        self.user_info = {}
        for k,v in user_info.items():
            self.user_info[k] = v
        self.loggin_attempts = 0

    def describe_user(self):
        print('first name: ' + self.first_name +
              '; last name: ' + self.last_name)
        for k,v in self.user_info.items():
            print(k, ':', v)

    def greet_user(self):
        print('Hello! ', self.first_name, self.last_name)

    def increment_loggin_attempts(self):
        self.loggin_attempts += 1

    def reset_loggin_attempts(self):
        self.loggin_attempts = 0

user = User('Sunny', 'Sun', city='HeKou', age=23)
print('loggin attempts:', user.loggin_attempts)
user.increment_loggin_attempts()
print('loggin attempts:', user.loggin_attempts)
user.increment_loggin_attempts()
print('loggin attempts:', user.loggin_attempts)
user.increment_loggin_attempts()
print('loggin attempts:', user.loggin_attempts)
user.reset_loggin_attempts()
print('loggin attempts:', user.loggin_attempts)

继承

一个类继承另一个类时，它将自动获得另一个类的所有属性和方法。原来的类称为父类，新类称为子类。子类会继承父类的所有属性和方法，同时还可以定义自己的属性和方法。

子类的方法__init__()
# 这里写入前面的Car类
class Car():
	# 类的主体
class ElectricCar(Car):
	def __init__(self, make, model, year):
		super().__init__(make, model, year)
my_tesla = ElectricCar('tesla', ',odel s', 2016)
print(my_tesla.get_descriptive_name())
  • 在创建子类时，父类必须包含在当前文件中，并且位于子类的前面。
  • 定义子类时，必须在括号内指定父类的名称。
  • super()是一个特殊的函数，帮助python把子类和父类关联起来。这一行代码让python调用ElectricCar的父类Car的方法__init__()，让ElectricCar实例包含父类的所有属性。
给子类定义属性和方法

让一个类继承另外一个类后，可以添加区分子类和父类所需的新属性和方法。

# 这里写入前面的Car类
class Car():
	# 类的主体
class ElectricCar(Car):
	def __init__(self, make, model, year):
		super().__init__(make, model, year)
		self.battery_size = 70
		
	def describe_battery(self):
		print("This car has a  " + str(self.battery_size) + "-kWh battery.")
my_tesla = ElectricCar('tesla', ',odel s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()

在上面的代码中，为子类添加了新的属性battery_size并设置其初始值为0，同时也为子类加入了方法describe_battery().则所有根据类ElectricCar创建的所有实例都包含这个属性，都可以调用这个方法，但是Car的实例都不包含它们。

重写父类的方法

可以在子类中定义一个与父类的方法重名的方法，即对父类中的方法进行重写。这样python就只会关注于子类中定义的相应的方法。

将实例用作属性

可以在类的属性中添加另一个类的实例。

# 这里写入前面的Car类
class Car():
 # 类的主体
class Battery():
	def __init__(self, battery_size=70):
		self.battery_size = battery_size
	
	def describe_battery(self):
		print("This car has a " + str(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', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery(

在上述代码中，定义了一个名为Battery的新类，它没有继承任何类。在它的初始化函数中，定义了一个默认形参battery_size。
在ElectricCar类中，定义了一个名为battery的属性，它是Battery类的一个实例。

Part Three 练习

# 9.6 冰淇淋小店
print('---------- 9.6 ----------')
class Restaurant():
    def __init__(self, restaurant_name, cuisine_type):
        self.restaurant_name = restaurant_name
        self.cuisine_type = cuisine_type
        self.number_served = 0

    def describe_restaurant(self):
        print('restaurant_name: ' + self.restaurant_name)
        print('cuisine_type: ' + self.cuisine_type)
       
    def open_restaurant(self):
        print('This restaurant ' + self.restaurant_name + ' is open now.')

    def set_number_served(self, num):
        if num >= self.number_served:
            self.number_served = num
        else:
            print('Number of people served must increase at every time.')
    def increment_number_served(self, num):
        if num >= 0:
            self.number_served += num
        else:
            print('Number of people served must increase at every time.')

class IceCreamStand(Restaurant):
    def __init__(self, restaurant_name, cuisine_type, *flavors):
        super().__init__(restaurant_name, cuisine_type)
        self.flavors = flavors
    
    def display_flavors(self):
        print("Here are some icecreams:")
        for flavor in self.flavors:
            print('\t' + str(flavor))
    
ice_cream_stand = IceCreamStand('ice cream', 'cold food',
                                'ice cream 1', 'ice cream 2','ice cream 3',)
ice_cream_stand.display_flavors()

# 9.7 管理员
print('---------- 9.6 ----------')
class User():
    def __init__(self, first, last, **user_info):
        self.first_name = first
        self.last_name = last
        self.user_info = {}
        for k,v in user_info.items():
            self.user_info[k] = v
        self.loggin_attempts = 0
        
    def describe_user(self):
        print('first name: ' + self.first_name +
              '; last name: ' + self.last_name)
        for k,v in self.user_info.items():
            print(k, ':', v)
            
    def greet_user(self):
        print('Hello! ', self.first_name, self.last_name)
        
    def increment_loggin_attempts(self):
        self.loggin_attempts += 1

    def reset_loggin_attempts(self):
        self.loggin_attempts = 0
        
class Admin(User):
    def __init__(self, privileges, first, last, **user_info):
        super().__init__(first, last, **user_info)
        self.privileges = privileges
        # privileges : 'can add post', 'can delete post', 'can be user'
        
    def show_privileges(self):
        print(str(self.privileges))
        
admin = Admin('can add post', 'Sunny', 'Sun', city='HeKou', age=23)
admin.show_privileges()

# 9.8 权限
print('---------- 9.6 ----------')
class Privileges():
    def __init__(self, privileges):
        self.privileges = privileges

    def show_privileges(self):
        print(str(self.privileges))

class Admin(User):
    def __init__(self, privileges, first, last, **user_info):
        super().__init__(first, last, **user_info)
        self.privileges = Privileges(privileges)

admin = Admin('can add post', 'Sunny', 'Sun', city='HeKou', age=23)
admin.privileges.show_privileges()

# 9.9 电瓶升级
print('---------- 9.6 ----------')
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 = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name.title()

    def read_odometer(self):
        print('This car has ' + str(self.odometer_reading) + ' miles on it.')

class Battery():
    def __init__(self, battery_size=70):
        self.battery_size = battery_size

    def describe_battery(self):
        print("This car has a " + str(self.battery_size) + " -kWh battery.")

    def get_range(self):
        range = 0
        if self.battery_size == 70:
            range = 240
        elif self.battery_size == 85:
            range = 270
        message = "This car can go approximately " + str(range) + " miles on a full charge"
        print(message)

    def update_battery(self):
        if self.battery_size != 85:
            self.battery_size = 85

class ElectricCar(Car):
    def __init__(self, make, model, year):
        super().__init__(make, model, year)
        self.battery = Battery()

electric_car = ElectricCar('tesla', 'model s', 2016)
electric_car.battery.describe_battery()
electric_car.battery.get_range()
electric_car.battery.update_battery()
electric_car.battery.get_range()

导入类

导入单个类

将Car类的定义放在car.py文件里面。
在my_car.py文件中导入Car类并创建实例：from car import Car

在一个模块中存储多个类

将Battery和ElectricCar类都放在模块car.py中，因为这些类中都是存在某种相关性的。
在my_electric_car.py的文件中导入ElectricCar类，并创建一辆电动汽车：from car import ElectricCar

从一个模块中导入多个类

my_car.py文件中导入Car和ElectricCar两个类：from car import Car, ElectricCar

导入整个模块

my_cars.py中import car

导入模块中的所有类

from module_name import *

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

有时候需要将类分散到多个模块中，避免模块太大，或者在同一个模块中存储不相关的类。将类存储在多个模块时，发现一个模块中的类依赖于另一个模块中的类。在这种情况下，可以在前一个模块中导入必要的类。
from car import Car

Python编程从入门到实践，第9章练习：9-1~9-15
weixin_56698264的博客
09-07 4421
1.创建和使用类，2.使用类和实例， 3.继承， 4.导入类， 5.Python标准库
类
清菡的博客
01-22 403
文章总览图面向对象编程是最有效的软件编写方法之一。在面向对象编程中，编写表示现实世界中的事物和情景的类，并基于这些类来创建对象。编写类时，定义一大类对象都有的通用行为。基于类创建对象时，...
《Python编程：从入门到实践》学习笔记——第9章 类
槐序的小山洞
03-19 833
文章目录前言1 创建和使用类1.1 创建 Dog 类1.1.1 方法__init__()1.1.2 在Python 2.7中创建类1.2 根据类创建实例1.2.1 访问属性1.2.2 调用方法1.2.3 创建多个实例2 使用类和实例2.2 给属性指定默认值2.3 修改属性的值2.3.1 直接修改属性的值2.3.2 通过方法修改属性的值2.3.3 通过方法对属性的值进行递增3 继承3.1 子类的方法__init__()3.2 Python 2.7 中的继承3.3 给子类定义属性和方法3.4 重写父类的方法3.
Python编程从入门到实践第九章：类
SweetWind1996的博客
04-23 1102
类创建和使用类使用类和实例修改属性的值直接通过实例进行修改通过方法进行设置通过方法进行递增（增加特定的值继承如果你要编写的类是另一个类的特殊版本，可使用继承。一个类继承另一个类时，它将自动获得另一个类的所有属性和方法。原有的类称为父类，而新类称为子类。子类继承其父类的所有属性和方法，同时还可以定义自己的属性和方法。创建子类时，父类必须包含在当前文件中，且在子类前面。重写父类的方法当子类中含有与父类...
Python编程从入门到实践-----第9章 类
一个人的学习和碎碎念
04-28 525
目录1、创建和使用类 1、创建和使用类   以下图创建Dog类：
Python编程从入门到实践第9章源码_Python编程从入门到实践第9章源码_
10-02
在《Python编程从入门到实践》这本书的第九章中，读者会接触到实际的编程项目，以深化对Python语言的理解和应用。本章的源码包括了两个文件：`car.py` 和 `my_electric_car.py`，它们是针对一个具体的案例——模拟...
Python编程三剑客第3版：Python编程从入门到实践第3版快速上手第.pptx
最新发布
10-13
Python编程三剑客第3版：Python编程从入门到实践第3版快速上手第 《Python编程三剑客第3版：Python编程从入门到实践第3版快速上手第》是一本介绍Python编程语言及其应用领域的书籍，适合对Python编程感兴趣的读者...
《Python编程从入门到实践（第2版）》第1章到第11章练习题答案，简洁，简单
06-24
《Python编程从入门到实践（第2版）》是一本广受欢迎的Python学习书籍，它为初学者提供了全面且深入的Python编程基础。书中的每一章都包含一系列的练习题，旨在帮助读者巩固所学知识并提升编程技能。这份压缩包文件...
《Python编程：从入门到实践》源代码文件
01-23
《Python编程：从入门到实践》是一本广受欢迎的Python编程教材，旨在帮助初学者掌握Python语言的基础知识，并通过实际项目提升编程技能。该书涵盖了从基础语法到高级特性的全面教程，同时还提供了丰富的实践项目，使...
python 小游戏飞机大战 根据《python编程从入门到实践》实现
02-10
本项目"Python小游戏：飞机大战"是基于《Python编程从入门到实践》一书中的"外星人入侵"项目进行的实践，旨在帮助学习者掌握Python游戏编程的基础知识，特别是使用Pygame库。 Pygame是Python的一个模块，专门为创建...
Python编程 从入门到实践——第9章 类
weixin_42589774的博客
03-16 830
Python编程学习笔记
《Python编程：从入门到实践》第九章：类
田蒲君
11-13 3134
第九章 类 面向对象编程；你定义一大类对象都有的通用行为。基于类创建对象时，每个对象都自动具备这种通用行为，然后可根据需要赋予每个对象独特的个性。 根据类来创建对象被称为实例化。你将指定可在实例中存储什么信息，定义可对这些实例执行哪些操作。你还将编写一些类来扩展既有类的功能，让相似的类能够高效地共享代码。 9.1 创建和使用类 创建简单的Dog类（表示任何小狗），创建表示小狗的对象，将创建表示特...
小菜鸟的python学习之路（8）
weixin_41953800的博客
11-02 357
学习阶梯 《Python编程：从入门到实践》 第一部分：基础知识 第9章 类 面向对象编程是最有效的软件编写方法之一。 在面向对象编程中，编写表示现实世界中的事物和情景的类，并基于这些类来创建对象。 编写类时，你定义一大类对象都有的通用行为。 基于类创建对象时，每个对象都自动具备这种通用行为，然后可根据需要赋予每个对象独特的个性。 根据类来创建对象被称为实例化，这让你能够使用类的实例。 可以指定能在实例中存储什么信息，定义可对这些实例执行哪些操作。还可以通过编写一些类来扩展既有类的功能，让相似的类能
《Python编程：从入门到实践》课后习题-第9章
Million Reasons的博客
09-05 1887
9-1 餐馆
《Python编程：从入门到实践》第九章笔记
不学无术的小镇做题家
06-05 248
9.1 创建和使用类 9.1.1 创建Dog类 class Dog(): def __init__(self,name,age): #3 """初始化属性name和age""" self.name = name self.age = age def sit(self): print(self.name.title() + "is now sitting") def roll_over(self):
《Python编程：从入门到实践》第9章学习小结
weixin_45928286的博客
08-04 245
学习笔记： 方法、属性 方法__init__()是一个特殊的方法，每当你根据Dog类创建新实例时，Python都会自动运行它。在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生名称冲突。 我们将方法__init__()定义成了包含三个形参：self、name和age。在这个方法的定义中，形参self必不可少，还必须位于其他形参的前面。Python调用这个__init__()方法来创建Dog实例时，将自动传入实参self。每个与类相关联的方法调用都自动传递
《Python编程：从入门到实践》2-9章 笔记
weixin_30387339的博客
09-04 315
2 变量和简单数据类型 2.2 变量 2.2.1 变量的命名和使用 牢记有关变量的规则 变量名只能包含字母、数字和下划线，变量名可以以字母或下划线开头，但不能以数字开头。错误示例：1_message。 变量名不能包含空格，但可使用下划线来分隔其中单词。错误示例：greeting message 。正确示例：greeting_message。 不要将Python关键字和函数名用作...
python编程从入门到实践 第九章 知识点总结
weixin_42435071的博客
04-10 207
第九章 类 1、方法定义中必须包含形参self 2、使用句点表示法调用类中定义的任何方法 3、类中的每个属性都必须有初始值，哪怕这个值是0或空字符 4、修改属性的值：(1)直接修改属性的值。(2)通过方法修改属性的值。(3)通过方法对属性的值进行递增 5、一个类继承另一个类时，它将自动获得另一个类的所有属性和方法 6、super()是一个特殊函数，帮助Python将父类和子类关联起来 7、在子类中...
《Python编程：从入门到实践》简要笔记
尉澄华的博客
06-14 359
来自《Python编程：从入门到实践》（作者 美国的Eric·Matthes）的学习笔记。主要针对Python 3。 Python根据缩进来判断代码行与前一个代码行的关系。在前面的示例中，向各位魔术师显示消息的代码行是for循环的一部分，因为它们缩进了。 magicians = ['alice', 'david', 'carolina'] for magician in magicians: print(magician.title() + ", that was a great trick!")
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值