Python基础之模块详解

目录
  • 一、模块
    • 1、模块的四种形式
    • 2、为什么要用模块?
  • 二、如何用模块
    • 1、import 模块名
      • 导入重命名:smt变量指向span模块的名称空间
      • 导入多个模块
    • 2、from 模块名 import 具体的函数
      • rom … import * 语句:导入文件内所有的功能:
    • 3、循环导入
    • 4、dir() 函数
  • 三、模块搜索路径
    • 1、导入模块时查找模块的顺序
      • 1、先从内存中已经导入的模块中寻找
      • 2、内置的模块
      • 3、环境变量sys.path中找(强调:sys.path的第一个值是当前执行文件的所在的文件夹)
    • 2、搜索路径以执行文件为准
  • 四、Python文件的两种用途
  • 五、包
    • 1、两种方式导入:
    • 2、import 导入包内的模块
    • 3、from import方式:
      • 导入模块内具体的模块
      • 导入模块内具体的功能
    • 4、 绝对导入和相对导入
      • 绝对导入:
      • 相对导入:
    • 5、from...import *
  • 六、软件开发的目录规范
    • settings.py
    • common.py
    • src.py
    • run.py
  • 七、Python标准库

一、模块

模块可以看成是一堆函数的集合体。

一个py文件内部就可以放一堆函数,因此一个py文件就可以看成一个模块。

如果这个py文件的文件名为module.py,模块名则是module

1、模块的四种形式

在Python中,总共有以下四种形式的模块:

  • 自定义模块:如果你自己写一个py文件,在文件内写入一堆函数,则它被称为自定义模块,即使用python编写的.py文件
  • 第三方模块:已被编译为共享库或DLL的C或C++扩展 ,如requests
  • 内置模块:使用C编写并链接到python解释器的内置模块 ,如time
  • 包(文件夹):把一系列模块组织到一起的文件夹(注:文件夹下有一个__init__.py文件,该文件夹称之为包)

2、为什么要用模块?

  • 用第三方或者内置的模块是一种拿来主义,可以极大地提升开发效率。
  • 自定义模块,将我们自己程序中用到的公共功能,写入一个python文件,然后程序的各部分组件可以通过导入的方式来引用自定义模块的功能。

二、如何用模块

一般我们使用import和from...import...导入模块。

以下述spam.py内的文件代码为例。

# spam.py
print('from the spam.py')
money = 1000
def read1():
print('spam模块:', money)
def read2():
print('spam模块')
read1()
def change():
global money
money = 0

1、import 模块名

语法如下:

import module1[, module2[,... moduleN]

import导入的模块,访问需要加前缀。

import首次导入模块发生了3件事:

  • 以模块为准创造一个模块的名称空间
  • 执行模块对应的文件,将执行过程中产生的名字都丢到模块的名称空间
  • 在当前执行文件中拿到一个模块名

注意:模块的重复导入会直接引用之前创造好的结果,不会重复执行模块的文件。

# run.py
import spam # from the spam.py
import spam
money = 111111
spam.read1() # 'spam模块:1000'
spam.change()
print(spam.money) # 0
print(money) # 111111

导入重命名:smt变量指向span模块的名称空间

# run.py
import spam as sm
money = 111111
sm.money
sm.read1() # 'spam模块:1000'
sm.read2
sm.change()
print(money) # 1000

导入多个模块

import spam, time, os
# 推荐使用下述方式
import spam
import time
import os

2、from 模块名 import 具体的函数

语法如下:

from modname import name1[, name2[, ... nameN]]

这个声明不会把整个模块导入到当前的命名空间中,它只会将模块里的一个或多个函数引入进来。

from...import...导入的模块,访问不需要加前缀。

from...import...首次导入模块发生了3件事:

  • 以模块为准创造一个模块的名称空间
  • 执行模块对应的文件,将执行过程中产生的名字都丢到模块的名称空间
  • 在当前执行文件的名称空间中拿到一个名字,该名字直接指向模块中的某一个名字,意味着可以不用加任何前缀而直接使用
  • 优点:不用加前缀,代码更加精简
  • 缺点:容易与当前执行文件中名称空间中的名字冲突
# run.py
from spam import money
from spam import money,read1
money = 10
print(money) # 10

rom … import * 语句:导入文件内所有的功能:

# spam.py
__all__ = ['money', 'read1'] # 只允许导入'money'和'read1'

# run.py
from spam import * # 导入spam.py内的所有功能,但会受限制于__all__
money = 111111
read1() # 'spam模块:1000'
change()
read1() # 'spam模块:0'
print(money) # 111111

3、循环导入

以下情况会出现循环导入:

# m1.py
print('from m1.py')
from m2 import x
y = 'm1'
# m2.py
print('from m2.py')
from m1 import y
x = 'm2'

可以使用函数定义阶段只识别语法的特性解决循环导入的问题,或从本质上解决循环导入的问题,但是最好的解决方法是不要出现循环导入。

方案一:

# m1.py
print('from m1.py')
def func1():
from m2 import x
print(x)
y = 'm1'

# m2.py
print('from m2.py')
def func1():
from m1 import y
print(y)
x = 'm2'

方案二:

5、# m1.py
print('from m1.py')
y = 'm1'
from m2 import x

# m2.py
print('from m2.py')
x = 'm2'
from m1 import y

4、dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:

dir(sys)
['__displayhook__', '__doc__', '__excepthook__', '__loader__', '__name__',
'__package__', '__stderr__', '__stdin__', '__stdout__',
'_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe',
'_home', '_mercurial', '_xoptions', 'abiflags', 'api_version', 'argv',
'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder',
'call_tracing', 'callstats', 'copyright', 'displayhook',
'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix',
'executable', 'exit', 'flags', 'float_info', 'float_repr_style',
'getcheckinterval', 'getdefaultencoding', 'getdlopenflags',
'getfilesystemencoding', 'getobjects', 'getprofile', 'getrecursionlimit',
'getrefcount', 'getsizeof', 'getswitchinterval', 'gettotalrefcount',
'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',
'intern', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path',
'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1',
'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit',
'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout',
'thread_info', 'version', 'version_info', 'warnoptions']

如果没有给定参数,那么 dir() 函数会罗列出当前定义的所有名称:

a = [1, 2, 3, 4, 5]
import fibo
fib = fibo.fib
print(dir()) # 得到一个当前模块中定义的属性列表
# ['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']

b = 5 # 建立一个新的变量 'a'
print(dir())
# ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'b']
del b # 删除变量名a
print(dir())
# ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'a']

三、模块搜索路径

1、导入模块时查找模块的顺序

1、先从内存中已经导入的模块中寻找

如果我们在运行run.py文件的时候,快速删除mmm.py文件,我们会发现文件会继续运行,而不会报错,因为mmm已经被导入内存当中。如果我们再一次运行run.py时会报错,因为mmm.py已经被删除了。

# test.py
import m1 # 从m1.py文件中导入的,然后会生成m1模块的名称空间
import time
# 删除m1.py文件,m1模块的名称空间仍然存在

time.sleep(10)
import m1 # 不报错,一定不是从文件中获取了m1模块,而是从内存中获取的

2、内置的模块

验证先从内置中找,不会先找自定义的time.py文件。

# time.py
print('from time.py')
# run.py
import time
print(time) #

3、环境变量sys.path中找(强调:sys.path的第一个值是当前执行文件的所在的文件夹)

import sys
for n in sys.path:
print(n)
# C:\PycharmProjects\untitled\venv\Scripts\python.exe C:/PycharmProjects/untitled/hello.py
# C:\PycharmProjects\untitled
# C:\PycharmProjects\untitled
# C:\Python\Python38\python38.zip
# C:\Python\Python38\DLLs
# C:\Python\Python38\lib
# C:\Python\Python38
# C:\PycharmProjects\untitled\venv
# C:\PycharmProjects\untitled\venv\lib\site-packages

如果mmm.py在C:\PycharmProjects\untitled\day16路径下,而执行文件路径为C:\PycharmProjects\untitled,如果普通导入一定会报错,我们可以把C:\PycharmProjects\untitled\day16添加到环境变量sys.path中,防止报错。

# run.py
import sys
sys.path.append(r'C:\PycharmProjects\untitled\day16')
print(sys.path)
import mmm
mmm.f1()

2、搜索路径以执行文件为准

假设我们有如下目录结构的文件,文件内代码分别是:

而hello和spam.py不是同目录下的,因此run.py的环境变量无法直接找到m2,需要从文件夹导入

from aa import spam
print(spam.money)

四、Python文件的两种用途

一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。

python文件总共有两种用途,一种是执行文件;另一种是被当做模块导入。

每个模块都有一个__name__属性,当其值是'__main__'时,表明该模块自身在运行,否则是被引入。

1、当run.py运行的时候,aaa.py被当做引用模块,它的__name__ == 'aaa'(模块名),会执行aaa.py中的f1()。

# aaa.py
x = 1
def f1():
print('from f1')
f1()
# run.py
import aaa

2、aaa.py被当做可执行文件时,加上__name__ == '__main__',单独运行aaa.py才会执行aaa.py中的f1()。 run.py运行时可以防止执行f1()。

# aaa.py
x = 1
def f1():
print('from f1')

if __name__ == '__main__':
f1()

五、包

包是一种管理 Python 模块命名空间的形式,包的本质就是一个含有.py的文件的文件夹。

包采用"点模块名称"。比如一个模块的名称是 A.B, 那么他表示一个包 A中的子模块 B 。

目录只有包含一个叫做 __init__.py 的文件才会被认作是一个包。

在导入一个包的时候,Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。

导入包发生的三件事:

  • 创建一个包的名称空间
  • 由于包是一个文件夹,无法执行包,因此执行包下的.py文件,将执行过程中产生的名字存放于包名称空间中(即包名称空间中存放的名字都是来自于.py)
  • 在当前执行文件中拿到一个名字aaa,aaa是指向包的名称空间的

导入包就是在导入包下的.py,导入m1就是导入m1中的__init__。

1、两种方式导入:

  • import ... : 
    import item.subitem.subsubitem 这种导入形式,除了最后一项,都必须是包,而最后一项则可以是模块或者是包,但是不可以是类,函数或者变量的名字。
  • from ... import...: 
    当使用 from package import item 这种形式的时候,对应的 item 既可以是包里面的子模块(子包),或者包里面定义的其他名称,比如函数,类或者变量。

2、import 导入包内的模块

import 可以每次只导入一个包里面的特定模块,他必须使用全名去访问。

import aaa.bbb.m3
print(aaa.bbb.m3.func3())

import方式不能导入函数、变量:import aaa.bbb.m3.f3错误

3、from import方式:

导入模块内具体的模块

这种方式不需要那些冗长的前缀进行访问

from aaa.bbb import m3
print(m3.func3())

导入模块内具体的功能

这种方式不需要那些冗长的前缀进行访问

from aaa.bbb.m3 import func3
print(func3())

4、 绝对导入和相对导入

绝对导入:

# aaa/.py
from aaa.m1 import func1
from aaa.m2 import func2

相对导入:

  • .代表当前被导入文件所在的文件夹
  • ..代表当前被导入文件所在的文件夹的上一级
  • ...代表当前被导入文件所在的文件夹的上一级的上一级
from .m1 import func1
from .m2 import func2

5、from...import *

导入语句遵循如下规则:如果包定义文件 __init__.py 存在一个叫做 __all__ 的列表变量,那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入。

这里有一个例子,在:file:sounds/effects/__init__.py中包含如下代码:

__all__ = ["echo", "surround", "reverse"]

这表示当你使用from sound.effects import *这种用法时,你只会导入包里面这三个子模块。

六、软件开发的目录规范

为了提高程序的可读性与可维护性,我们应该为软件设计良好的目录结构,这与规范的编码风格同等重要,简而言之就是把软件代码分文件目录。假设你要写一个ATM软件,你可以按照下面的目录结构管理你的软件代码:

ATM/
|-- core/
| |-- src.py # 业务核心逻辑代码
|
|-- api/
| |-- api.py # 接口文件
|
|-- db/
| |-- db_handle.py # 操作数据文件
| |-- db.txt # 存储数据文件
|
|-- lib/
| |-- common.py # 共享功能
|
|-- conf/
| |-- settings.py # 配置相关
|
|-- bin/
| |-- run.py # 程序的启动文件,一般放在项目的根目录下,因为在运行时会默认将运行文件所在的文件夹作为sys.path的第一个路径,这样就省去了处理环境变量的步骤
|
|-- log/
| |-- log.log # 日志文件
|
|-- requirements.txt # 存放软件依赖的外部Python包列表,详见https://pip.readthedocs.io/en/1.1/requirements.html
|-- README # 项目说明文件

settings.py

# settings.py
import os
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
DB_PATH = os.path.join(BASE_DIR, 'db', 'db.txt')
LOG_PATH = os.path.join(BASE_DIR, 'log', 'user.log')
# print(DB_PATH)
# print(LOG_PATH)

common.py

# common.py
import time
from conf import settings
def logger(msg):
current_time = time.strftime('%Y-%m-%d %X')
with open(settings.LOG_PATH, mode='a', encoding='utf-8') as f:
f.write('%s %s' % (current_time, msg))

src.py

# src.py
from conf import settings
from lib import common
def login():
print('登陆')
def register():
print('注册')
name = input('username>>: ')
pwd = input('password>>: ')
with open(settings.DB_PATH, mode='a', encoding='utf-8') as f:
f.write('%s:%s\n' % (name, pwd))
# 记录日志。。。。。。
common.logger('%s注册成功' % name)
print('注册成功')
def shopping():
print('购物')
def pay():
print('支付')
def transfer():
print('转账')
func_dic = {
'1': login,
'2': register,
'3': shopping,
'4': pay,
'5': transfer,
}
def run():
while True:
print("""
1 登陆
2 注册
3 购物
4 支付
5 转账
6 退出
""")
choice = input('>>>: ').strip()
if choice == '6': break
if choice not in func_dic:
print('输入错误命令,傻叉')
continue
func_dic[choice]()

run.py

# run.py
import sys
import os
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)
from core import src
if __name__ == '__main__':
src.run()

七、Python标准库

https://docs.python.org/zh-cn/3.8/library/index.html

到此这篇关于Python基础之模块的文章就介绍到这了。希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • Python中的pprint打印模块

    目录 1. 引言 2. 使用背景 3. pprint 大法好 4. 设定输出宽度 5. 设定输出缩进 6. 总结 1. 引言 ​​pprint​的英文全称​​Data pretty printer​​,顾名思义就是让显示结果更加直观漂亮. ​​print()​和​​pprint()​都是python的打印模块,功能基本一样,唯一的区别就是​​pprint()​模块打印出来的数据结构更加完整,每行为一个数据结构,更加方便阅读打印输出结果.特别是对于特别长的数据打印,​​print()​​输出结果都

  • Python并发编程之未来模块Futures

    目录 区分并发和并行 并发编程之Futures 到底什么是Futures? 为什么多线程每次只有一个线程执行? 总结 不论是哪一种语言,并发编程都是一项非常重要的技巧.比如我们上一章用的爬虫,就被广泛用在工业的各个领域.我们每天在各个网站.App上获取的新闻信息,很大一部分都是通过并发编程版本的爬虫获得的. 正确并合理的使用并发编程,无疑会给我们的程序带来极大性能上的提升.今天我们就一起学习Python中的并发编程——Futures. 区分并发和并行 我们在学习并发编程时,常常会听到两个词:并发

  • Python序列化模块之pickle与json详解

    目录 序列化模块 序列化和反序列化 使用场景 dumps & loads dump & load JSON序列化模块 使用场景 支持的数据类型 JSON和pickle的区别 序列化函数 json和pickle实际使用过程中的一些问题 pickle和json的区别总结 序列化模块 import pickle 序列化和反序列化 把不能直接存储的数据变得可存储,这个过程叫做序列化.把文件中的数据拿出来,回复称原来的数据类型,这个过程叫做反序列化. 在文件中存储的数据只能是字符串,或者是字节流,不

  • Python日志模块logging的使用方法总结

    目录 导语 关于开发日志 关于logging基础使用 关于logging进阶使用 记录器 处理器 格式器 配置记录 实战 生成记录器 请求处理装饰器 总结 导语 日常开发中,定位程序异常,追溯事件发生场景都需要通过日志记录的方式.可以说一个好的开发日志设计可以让开发人员在后续项目维护的过程中节省时间成本,提升解决问题的效率. 目前在网上已经有许多关于Python日志操作的文章,部分文章总结的非常到位,Python官方也有日志常用的手册.自己写这篇文章是主要围绕Python官方的logging模块

  • Python文件处理、os模块、glob模块

    目录 一.文件基本的操作 1.open() 打开文件 2.read() 读文件 3.write()写文件: 4.with open()方法 二.文件的打开模式 1.文件r打开模式 1.读文本 2.读字节 3.for逐行读取,相当于readline. 4.读方法: 2.文件W打开模式 1.文本模式 2.字节模式 3.写方法: 3.文件a打开模式 4.+可读.可写 三.文件指针操作 1.seek(offset, from_what) :改变当前文件操作指针的位置 2.tell():告诉文件当前位置.

  • Python文件系统模块pathlib库

    目录 一.pathlib库官方定义 二.pathlib秘籍 1. 基本用法 2. 基本属性 3. 改变路径 4. 拼接路径 5. 测试路径 6. 其他方法 三.os和pathlib.Path的区别 1. 获取当前文件路径 2. 获取上层/上层目录 3. 路径拼接 4. 其他封装 四.pathlib.PurePath的使用 1. PurePath.match 2. PurePath的子类:PurePosixPath(非Windows系统).PureWindowsPath 一.pathlib库官方定

  • 初识python的numpy模块

    目录 一.array类型 1.1array类型的基本使用 1.2对更高维度数据的处理 1.3Numpy创建特殊类型的array类型 1.3.1生成全为0或全为1的array 1.3.2np.arrange()和np.linspace() 1.4Numpy基础计算演示 二.线性代数相关 三.矩阵的高级函数-随机数矩阵 四.总结 Numpy是Numerical Python extensions的缩写,字面意思是Python数值计算扩展.Numpy是python中众多机器学习库的依赖,这些库通过Nu

  • 代码解析python标准库logging模块

    目录 问题1:如何获取caller的(文件名,行号,函数名)? findCaller内容如下: currentframe函数的定义: 问题2: Logger对象的层级,父子关系如何实现的? Manager的getLogger()定义如下: 问题1:如何获取caller的(文件名,行号,函数名)? 当新增一条log记录时,最终将调用Logger类的_log方法,这个方法首先会创建一个LogRecord对象.LogRecord对象需要(filename, lineno, funcname)参数信息.

  • Python基础之模块详解

    目录 一.模块 1.模块的四种形式 2.为什么要用模块? 二.如何用模块 1.import 模块名 导入重命名:smt变量指向span模块的名称空间 导入多个模块 2.from 模块名 import 具体的函数 rom … import * 语句:导入文件内所有的功能: 3.循环导入 4.dir() 函数 三.模块搜索路径 1.导入模块时查找模块的顺序 1.先从内存中已经导入的模块中寻找 2.内置的模块 3.环境变量sys.path中找(强调:sys.path的第一个值是当前执行文件的所在的文件

  • C++调用Python基础功能实例详解

    c++调用Python首先安装Python,以win7为例,Python路径为:c:\Python35\,通过mingw编译c++代码. 编写makefile文件,首先要添加包含路径: inc_path += c:/Python35/include 然后添加链接参数: ld_flag += c:/Python35/libs/libpython35.a 在源文件中添加头文件引用: #include "Python.h" Python解释器需要进行初始化,完成任务后需要终止: void s

  • Python基础之进程详解

    一.前言 进程,一个新鲜的字眼,可能有些人并不了解,它是系统某个运行程序的载体,这个程序可以有单个或者多个进程,一般来说,进程是通过系统CPU 内核数来分配并设置的,我们可以来看下系统中的进程: 可以看到,360浏览器是真的皮,这么多进程啊,当然可以这样来十分清楚的看进程线程使用情况: 通过任务管理器中的资源监视器,是不是很厉害了,哈哈哈.讲完了这些,再说说用法. 二.基本用法 进程能干什么,这是我们要深思熟虑的事情.我们都知道一个程序运行会创建进程,所以程序在创建这些进程的时候,为了让它们更能

  • Python基础之内置模块详解

    一.os import os # 1. 获取当前脚本绝对路径 """ abs_path = os.path.abspath(__file__) print(abs_path) """ # 2. 获取当前文件的上级目录 """ base_path = os.path.dirname( os.path.dirname(路径) ) print(base_path) """ # 3. 路径拼接

  • python中random模块详解

    Python中的random模块用于生成随机数,它提供了很多函数.常用函数总结如下: 1. random.random() 用于生成一个0到1的随机浮点数: 0 <= n < 1.0 2. random.seed(n) 用于设定种子值,其中的n可以是任意数字.random.random() 生成随机数时,每一次生成的数都是随机的.但是,使用 random.seed(n) 设定好种子之后,在先调用seed(n)时,使用 random() 生成的随机数将会是同一个. 3. random.unifo

  • python爬虫selenium模块详解

    selenium模块 selenium基本概念 selenium优势 便捷的获取网站中动态加载的数据 便捷实现模拟登陆 selenium使用流程: 1.环境安装:pip install selenium 2.下载一个浏览器的驱动程序(谷歌浏览器) 3.实例化一个浏览器对象 基本使用 代码 from selenium import webdriver from lxml import etree from time import sleep if __name__ == '__main__': b

  • Python基础之数据结构详解

    一.列表 创建一个列表,只要把逗号分隔的不同的数据项使用方括号括起来 示例: list01 = ['a','b','c'] 1.1 列表更新元素 一个列表是可以储存不同的类型的数据结构,并且修改的新元素也不一定需要和原来的元素类型一致,但是要注意的是,更新列表的索引必须是已存在的索引,不能对超出列表的索引更新元素 1.2 列表增加元素 增加元素的方法: 1.append方法:在列表的最后增加一个元素. list01 = ['a', 'b', 'c'] list01 .append('d') pr

  • Python基础 括号()[]{}的详解

    目录 1.python中的小括号() 2.python中的中括号[] 3.python大括号{}花括号 前言: Python主要有三种数据类型:字典.列表.元组.其分别由花括号,中括号,小括号表示. 如: 字典:dic={'a':12,'b':34} 列表:list=[1,2,3,4] 元组:tup=(1,2,3,4) python语言最常见的括号有三种,分别是∶小括号().中括号[]和大括号也叫做花括号{ }.其作用也各不相同,分别用来代表不同的python基本内置数据类型. 1.python

  • python基础字符串str详解

    目录 字符串str: 编码: ord(字符串)和chr(整数): 字符串字面值: 字符串通用操作 字符串str: 定义:是由一系列字符组成的不可变序列容器,储存的事字符的编码值 编码: 1.字节byte:计算机最小储存单位,等于8位bit 2. 字符:单个的数字,文字与字符 3. 字符集(码表):存储字符与二进制序列的对应关系 4. 编码:将字符转换为对应的二进制序列的过程 5. 解码:将二进制序列转换为对应的字符的过程 6. 编码方式: ASCLL编码:包含英文,数字等字符,每个字符1个字节

  • Python中BeautifulSoup模块详解

    目录 前言 安装库 导入库 解析文档示例 提取数据示例 CSS选择器 实例小项目 总结 前言 BeautifulSoup是主要以解析web网页的Python模块,它会提供一些强大的解释器,以解析网页,然后提供一些函数,从页面中提取所需要的数据,目前是Python爬虫中最常用的模块之一. 安装库 在使用前需要安装库,这里建议安装bs4,也就是第四版本,因为根据官方文档第三版的已经停止更新.同时安装lxml解释器 pip3 install bs4 pip3 install lxml 导入库 from

随机推荐