Python基础知识

一、数据类型

（一）简单类型

整数（int）：表示整数值，例如 5 和 -10。
浮点数（float）：表示带有小数部分的数字，例如 3.14 和 -2.7。
复数（complex）：也就是数据运算中的复数 a+bi，a 是实部，b是虚部。
字符串（str）：表示文本数据，一般用 【 ‘一对单引号’】或【”一对双引号”】或【’’’一对3个单引号’’’】或【”””一对3个双引号”””】括起来，例如 “Hello World” 、 ‘Python’、’’’每天都要开开心心’’’。
布尔值（bool）：表示真或假的值，只有两个取值：True 和 False。
空值（None）：空值None是python中的一个特殊的值，表示空（没有），也是类型 NoneType的唯一值。

（二）容器类型

数据结构	定义符号	元素是否可变	元素是否可重复	元素是否有序
列表（list）	[]	可变	可重复	有序
元组（tuple）	()	不可变	可重复	有序
字典（dict）	{key : value}	可变	key不可重复 value可重复	无序
集合（set）	{}	可变	不可重复	无序

以上4种容器类型都由一个基类类型——序列衍生出来。

1.序列

序列是具有先后关系的一组元素。

序列是一维元素向量，元素类型可以不同
类似数学元素序列：S0 , S1 ,…, S~~n-1~~
元素间由序号引导，通过下标访问序列的特定元素
序列是一个基类类型，一般使用其衍生出来的字符串类型、元组类型、列表类型

通用操作符

操作符及应用	描述
x in s	如果x是序列s的元素，返回True，否则返回False
x not in s	如果x是序列s的元素，返回False，否则返回True
s + t	连接两个序列 s 和 t
s * n 或 n * s	将序列 s 复制 n 次
s[i]	索引，返回 s 中的第 i 个元素，i 是序列的序号
s[i: j] 或 s[i: j: k]	切片，返回序列 s 中第 i 到 j 以 k 为步长的元素子序列

函数和方法

函数和方法	描述
len(s)	返回序列s的长度
min(s)	返回序列s的最小元素，s中元素需要可比较
max(s)	返回序列s的最大元素，s中元素需要可比较
s.index(x) 或 s.index(x, i, j)	返回序列s从 i 开始到 j 位置中第一次出现元素x的位置
s.count(x)	返回序列s中出现x的总次数

2.列表

列表是序列类型的一种扩展，十分常用。

列表是一种序列类型，创建后可以随意被修改
使用方括号 [] 或 list() 创建，元素间用逗号 , 分隔
列表中各元素类型可以不同，无长度限制

列表类型常用函数和方法

函数或方法	描述
s[i] = x	替换列表 s 第 i 元素为 x
s[i: j: k] = t	用列表 t 替换 s 切片后所对应元素子列表
del s[i]	删除列表 s 中第 i 元素
del s[i: j: k]	删除列表 s 中第 i 到第 j 以 k 为步长的元素
s += t	更新列表 s，将列表 t 元素增加到列表 ls 中
s *= n	更新列表 s，其元素重复n次
s.append(x)	在列表 s 最后增加一个元素 x
s.clear()	删除列表 s 中所有元素
s.copy()	生成一个新列表，赋值 s 中所有元素
s.insert(i,x)	在列表 s 的第 i 位置增加元素x
s.pop(i)	将列表 s 中第 i 位置元素取出并删除该元素
s.remove(x)	将列表 s 中出现的第一个元素 x 删除
s.reverse()	将列表 s 中的元素反转
s.extend(t)	更新列表 s，将列表 t 元素增加到列表 s 中

代码演示

# 创建一个空列表
my_list = []

# 创建一个包含多个元素的列表
my_list = [1, 2, 3]

# 访问列表中的元素
print(my_list[0])  # 输出：1
print(my_list[1])  # 输出：2
print(my_list[2])  # 输出：3

# 修改列表中的元素
my_list[0] = 4
print(my_list)  # 输出：[4, 2, 3]

# 在列表末尾添加元素
my_list.append(5)
print(my_list)  # 输出：[4, 2, 3, 5]

# 在指定位置插入元素
my_list.insert(1, 6)
print(my_list)  # 输出：[4, 6, 2, 3, 5]

# 删除列表中的元素
my_list.remove(2)
print(my_list)  # 输出：[4, 6, 3, 5]

# 使用切片操作获取子列表
sub_list = my_list[1:3]
print(sub_list)  # 输出：[6, 3]

# 列表长度
length = len(my_list)
print(length)  # 输出：4

# 列表排序
my_list.sort()
print(my_list)  # 输出：[3, 4, 5, 6]

# 列表反转
my_list.reverse()
print(my_list)  # 输出：[6, 5, 4, 3]

# 遍历列表
for item in my_list:
    print(item)

3.元组

元组是序列类型的一种扩展。

元组是一种序列类型，一旦创建就不能被修改
使用小括号 () 或 tuple() 创建，元素间用逗号，分割
元组与列表类似，不同之处在于元素的元素不能修改

代码演示

# 创建一个空元组
my_tuple = ()

# 创建一个包含多个元素的元组
my_tuple = (1, 2, 3)

# 访问元组中的元素
print(my_tuple[0])  # 输出：1
print(my_tuple[1])  # 输出：2
print(my_tuple[2])  # 输出：3

# 尝试修改元组中的元素（会报错）
# my_tuple[0] = 4  # 会引发 TypeError: 'tuple' object does not support item assignment

# 拆包元组中的元素
a, b, c = my_tuple
print(a)  # 输出：1
print(b)  # 输出：2
print(c)  # 输出：3

# 元组与列表结合
my_list = [4, 5, 6]
combined_tuple = (*my_tuple, *my_list)
print(combined_tuple)  # 输出：(1, 2, 3, 4, 5, 6)

# 使用内置函数返回元组
my_string = "Hello"
string_tuple = tuple(my_string)
print(string_tuple)  # 输出：('H', 'e', 'l', 'l', 'o')

# 元组解压缩
my_tuple = ('Apple', 'Banana', 'Orange')
fruit1, fruit2, fruit3 = my_tuple
print(fruit1)  # 输出：'Apple'
print(fruit2)  # 输出：'Banana'
print(fruit3)  # 输出：'Orange'

4.字典

理解“映射”。

映射是一种键（索引）和值（数据）的对应

字典类型是“映射”的体现。

键值对：键是数据索引的扩展
字典是键值对的集合，键值对之间无序
采用大括号 { } 和 dict() 创建，键值对用冒号 : 表示
<字典变量> = {<键1>:<值1>, … , <键n>:<值n>}
空大括号—— { } 默认生成字典类型

字典类型常用函数或方法

函数或方法	描述
del d[k]	删除字典d中键k对应的数据值
k in d	判断键k是否在字典d中，如果在返回True，否则False
d.keys()	返回字典d中所有的键信息
d.values()	返回字典d中所有的值信息
d.items()	返回字典d中所有的键值对信息
d.get(k, default)	键k存在，则返回相应值，不在则返回 default 值
d.pop(k, default)	键k存在，则取出相应值，不在则返回 default 值
d.popitem()	随机从字典d中取出一个键值对，以元组形式返回
d.clear()	删除所有的键值对
len(d)	返回字典d中元素的个数

代码演示

# 创建一个空字典
my_dict = {}

# 添加键值对
my_dict['name'] = 'Alice'
my_dict['age'] = 25
my_dict['city'] = 'New York'

# 打印整个字典
print(my_dict)

# 访问字典中的值
print(f"Name: {my_dict['name']}")
print(f"Age: {my_dict['age']}")
print(f"City: {my_dict['city']}")

# 修改字典中的值
my_dict['age'] = 26
print(f"Updated age: {my_dict['age']}")

# 删除键值对
del my_dict['city']
print(my_dict)

# 检查键是否存在
if 'name' in my_dict:
    print("Name key exists")

# 遍历字典
for key, value in my_dict.items():
    print(f"{key}: {value}")

5.集合

集合的特点

不可哈希类型不能作为集合的元素
集合里的元素顺序是无序，且不能重复的
如果对元素顺序无要求的话，可以用集合进行去重

代码演示

# 创建一个空集合
empty_set = set()
print(empty_set)  # 输出: set()

# 创建一个包含元素的集合
fruits = {'apple', 'banana', 'orange'}
print(fruits)  # 输出: {'orange', 'banana', 'apple'}

# 添加元素到集合
fruits.add('grape')
print(fruits)  # 输出: {'banana', 'grape', 'apple', 'orange'}

# 从集合中删除元素
fruits.remove('banana')
print(fruits)  # 输出: {'grape', 'apple', 'orange'}

# 检查集合中是否包含元素
print('apple' in fruits)  # 输出: True
print('pear' in fruits)  # 输出: False

# 集合的长度
print(len(fruits))  # 输出: 3

# 使用for循环遍历集合
for fruit in fruits:
    print(fruit)

# 集合的数学运算和集合操作
set1 = {1, 2, 3}
set2 = {2, 3, 4}

union_set = set1.union(set2)
print(union_set)  # 输出: {1, 2, 3, 4}

intersection_set = set1.intersection(set2)
print(intersection_set)  # 输出: {2, 3}

difference_set = set1.difference(set2)
print(difference_set)  # 输出: {1}

symmetric_difference_set = set1.symmetric_difference(set2)
print(symmetric_difference_set)  # 输出: {1, 4}

# 清空集合
fruits.clear()
print(fruits)  # 输出: set()

（三）类类型

1.创建Cat类

class Cat:
    def __init__(self, name):  # 这里设置类的属性
        self.name = name
        print('%s appeared.' % self.name)

    def __del__(self):
        print('%s disappeared.' % self.name)

    def __str__(self):
        return 'He is a cat named %s.' % self.name

    def eat(self):
        print("%s is eating." % self.name)

    def drink(self):
        print('%s is drinking.' % self.name)


def main():
    tom = Cat('Tom')
    print(tom)
    tom.eat()
    tom.drink()


main()

类自带的成员方法：

1
2
3

def __init__(self, name)  # 构造函数 在这里设置类的属性
def __del__(self)  # 析构函数
def __str__(self)  # 类似于Java类中的toString()函数

2.创建家具类 HouseItem 和房屋类 House

class HouseItem:
    def __init__(self, name, area):
        self.name = name
        self.area = area

    def __str__(self):
        return '[%s] 占地 %.2f' % (self.name, self.area)


class House:
    def __init__(self, house_type, area):
        self.house_type = house_type
        self.area = area
        self.free_area = area
        self.item_list = []

    def __str__(self):
        return '户型: %s\n总面积: %.2f\n剩余:%.2f\n家具: %s' \
            % (self.house_type, self.area, self.free_area, self.item_list)

    def add_item(self, item):
        print('要添加 %s' % item)
        if item.area > self.free_area:
            print('%s 的面积太大了,无法添加' % item.name)
            return
        self.item_list.append(item.name)
        self.free_area -= item.area


def main():
    bed = HouseItem('席梦思', 4)
    chest = HouseItem('衣柜', 2)
    table = HouseItem('餐桌', 1.5)

    my_house = House('三室两厅', 100)
    print(my_house)
    my_house.add_item(bed)
    my_house.add_item(chest)
    my_house.add_item(table)
    print(my_house)


main()

3.属性可以是另外一个类创建的对象

class Gun:
    def __init__(self, model):
        self.model = model
        self.bullet_count = 0

    def add_bullet(self, count):
        self.bullet_count += count

    def shoot(self):
        if self.bullet_count <= 0:
            print('[%s] 没有子弹了...' % self.model)
            return
        self.bullet_count -= 1
        print('[%s] 突突突... [剩余子弹 %d]' % (self.model, self.bullet_count))


class Soldier:
    def __init__(self, name):
        self.name = name
        # 新兵没有枪
        self.gun = None

    '''
    is 和 == 的区别:
    is 用于判断 两个变量 引用对象是否为同一个
    == 用于判断 引用变量的值 是否相等
    '''

    def fire(self):
        if self.gun is None:
            print('[%s] 还没有枪...' % self.name)
            return
        if self.gun.bullet_count <= 0:
            self.gun.add_bullet(50)
            print('%s 装弹完毕,即将开火!' % self.name)
        self.gun.shoot()

    def __str__(self):
        return 'I am a soldier named %s.' % self.name


def main():
    ak47 = Gun('AK47')
    jack = Soldier('Jack')
    print(jack)
    jack.gun = ak47
    jack.fire()
    jack.fire()
    jack.fire()


if __name__ == '__main__':
    main()

4.私有属性和私有方法

在定义属性或方法时，在属性名或者方法名前增加两个下划线，定义的就是私有属性或方法

class Women:
    def __init__(self, name):
        self.name = name
        self.__age = 18  # 私有属性

    def secret(self):
        print('%s 的年龄是 %d' % (self.name, self.__age))


def main():
    mary = Women('Mary')
    mary.secret()


if __name__ == '__main__':
    main()

如果想在外部访问类的私有属性，在属性名前面加上 __类名即可，Python并没有真正意义上的私有

5.继承

单继承

class Person(object):
    def __init__(self):
        self.__name = 'person'

    def __del__(self):
        pass

    def speak(self):
        print('hello')

    def move(self):
        print('run')

    def __siyou(self):
        print('父类的私有方法')

    def gongyou(self):
        print('在父类中调用私有属性和方法')
        print(self.__name)
        self.__siyou()


class Student(Person):
    def speak(self):
        super().speak()  # 调用父类方法
        print('I am a student.')

    def task(self):
        print('do homework')

    def test(self):
        print('在子类中调用父类的公有方法,进一步间接调用父类的私有方法')
        super().gongyou()


def main():
    jack = Student()
    jack.speak()
    jack.move()
    jack.task()
    jack.test()


if __name__ == '__main__':
    main()

多继承

class A(object):
    def testA(self):
        print('test A')


class B(object):
    def testB(self):
        print('test B')


class C(A, B):
    pass


def main():
    oc = C()
    oc.testA()
    oc.testB()


if __name__ == '__main__':
    main()

如果父类之间存在同名的属性或方法，应该尽量避免使用多继承

多态

class Dog(object):
    def __init__(self, name):
        self.name = name

    def game(self):
        print('%s 蹦蹦跳跳地玩耍...' % self.name)


class XiaoTianDog(Dog):
    def game(self):
        print('%s 飞到天上去玩耍' % self.name)


class Person(object):
    def __init__(self, name):
        self.name = name

    def game_with_dog(self, dog):
        print('%s 和 %s 快乐地玩耍...' % (self.name, dog.name))
        dog.game()


def main():
    dog = Dog('旺财')
    xiaotian = XiaoTianDog('旺财')

    p = Person('小明')
    p.game_with_dog(dog)
    p.game_with_dog(xiaotian)


if __name__ == '__main__':
    main()

类属性和类方法

class Tool(object):
    count = 0  # 类属性

    def __init__(self, name):
        self.name = name
        Tool.count += 1


def main():
    too11 = Tool('斧头')
    too12 = Tool('锤子')
    too13 = Tool('水桶')
    print(Tool.count)


if __name__ == '__main__':
    main()

类方法

class Tool(object):
    count = 0  # 类属性

    # 类方法
    @classmethod
    def show_tool_count(cls):
        print(Tool.count)

    def __init__(self, name):
        self.name = name
        Tool.count += 1


def main():
    too11 = Tool('斧头')
    too12 = Tool('锤子')
    too13 = Tool('水桶')
    Tool.show_tool_count()


if __name__ == '__main__':
    main()

静态方法

如果某个方法既不访问类属性，也不访问实例属性，可以将其设为静态方法

class Dog(object):
    @staticmethod  # 静态方法
    def run():
        print('小狗要跑')


def main():
    Dog.run()


if __name__ == '__main__':
    main()

或者：

class Game(object):
    top_score = 0

    def __init__(self, player_name):
        self.player_name = player_name

    @staticmethod
    def show_help():
        print('帮助信息:让僵尸进入大门')

    @classmethod
    def show_top_score(cls):
        print('历史记录: %d' % Game.top_score)

    def start_game(self):
        print('%s 开始游戏...' % self.player_name)


def main():
    Game.show_help()
    Game.show_top_score()
    game = Game('小明')
    game.start_game()


if __name__ == '__main__':
    main()

重写 new 方法

class MusicPlayer(object):
    def __init__(self):
        print('播放器初始化')

    # 重写new方法
    def __new__(cls, *args, **kwargs):
        # 1.创建对象时,new方法会被自动调用
        print('创建对象 分配空间')
        # 2.为对象分配空间
        instance = super().__new__(cls)
        # 3.返回对象的引用
        return instance


def main():
    player = MusicPlayer()
    print(player)


if __name__ == '__main__':
    main()

6.单例设计模式设计一个单例类

class MusicPlayer(object):
    # 记录第一个被创建对象的引用
    instance = None

    # 记录是否执行过初始化动作
    init_flag = False

    # 重写new方法
    def __new__(cls, *args, **kwargs):
        # 1.判断类属性是否是空对象
        if cls.instance is None:
            # 2.调用父类的方法为第一个对象分配空间
            cls.instance = super().__new__(cls)
        # 3.返回类属性保存的第一个对象的引用
        return cls.instance

    def __init__(self):
        if MusicPlayer.init_flag:
            return
        print('初始化播放器')
        MusicPlayer.init_flag = True


def main():
    player1 = MusicPlayer()
    print(player1)
    player2 = MusicPlayer()
    print(player2)


if __name__ == '__main__':
    main()

二、Python的33个保留字

and	elif	import	raise	global
as	else	in	return	nonlocal
assert	except	is	try	True
break	finally	lambda	while	False
class	for	not	with	None
continue	from	or	yield
def	if	pass	del

三、Python语句结构

（一）选择结构

n = int(input())
if n < 0:
    print('-')
elif n == 0:
    print(0)
else:
    print('+')

（二）for循环结构

n = 10
s = 'abcdefghijk'
for i in range(0, n):
    print(i, end='')
print()
for c in s:
    print(c, end='')
print()

（三）while循环结构

n = 10
while n >= 0:
    print(n)
    n -= 1

（四）continue和break

for c in 'python':
    if c == 't':
        continue
    print(c, end='')
print()
for c in 'python':
    if c == 't':
        break
    print(c, end='')
print()

（五）循环的扩展

当循环没有被break语句退出时，执行else语句块
else语句块作为“正常”完成循环的奖励

这里else的用法与异常处理中的else用法相似

for c in 'python':
    if c == 'z':
        break
    print(c)
else:
    print('正常退出')

（六）异常处理

for example:

try:
    num = eval(input('请输入一个整数:'))
    print(num**2)
except NameError:
    print('输入不是整数')

another example:

try:
    num = eval(input('input an integer:'))
except NameError:
    print('is not integer')
else:
    print('is integer')
finally:
    print('whatever')

异常捕获的完整语法结构

try:
    # 尝试执行的代码
    pass
except 错误类型1:
    # 针对错误类型1,对应的处理代码
    pass
except 错误类型2:
    # 针对错误类型2,对应的处理代码
    pass
except (错误类型3, 错误类型4):
    # 针对错误类型3和错误类型4,对应的处理代码
    pass
except Exception as result:
    # 打印错误信息
    print(result)
else:
    # 没有异常才会执行的代码
    pass
finally:
    #无论是否有异常,都会执行的代码
    pass

主动抛出异常

def input_password():
    pwd = input('请输入密码:')
    if len(pwd) >= 8:
        return pwd
    print('主动抛出异常')
    ex = Exception('密码长度不够')
    raise ex


def main():
    try:
        print(input_password())
    except Exception as result:
        print(result)


if __name__ == '__main__':
    main()

（七）Python程序打包

通过pyinstaller库可以将py文件打包成可独立执行的exe程序

四、Python引入库的三种方法

（一）使用函数时加库名

1 2	import turtle turtle.goto(100, 100)

（二）使用函数时不用加库名

1 2	from turtle import * goto(100, 100)

（三）给库起别名

1 2	import turtle as t t.goto(100, 100)

五、文件

（一）文件的打开模式

文件的打开模式	描述
‘r’	只读模式，默认值，如果文件不存在，返回FileNotFound
‘w’	覆盖写模式，文件不存在则创建，存在则完全覆盖
‘x’	创建写模式，文件不存在则创建，存在则返回FileExistsError
‘a’	追加写模式，文件不存在则创建，存在则在文件最后追加内容
‘b’	二进制文件模式
‘t’	文本文件模式，默认值
‘+’	与 r / w / x / a 一同使用，在原功能基础上增加同时读写功能

（二）文件内容的读取

操作方法	描述
f.read(size = -1)	读入全部内容，如果给出参数，读入前size长度 >>>s = f.read(2) 中国
f.readline(size = -1)	读入一行内容，如果给出参数，读入该行前size长度 >>>s = f.readline() 中国是一个伟大的国家！
f.readlines(hint = -1)	读入文件所有行，以每行为元素形成列表如果给出参数，读入前 hint 行 [‘中国是一个伟大的国家！’]

（三）文件的写入

操作方法	描述
f.write(s)	向文件写入一个字符串或字节流 >>>f.write(“中国是一个伟大的国家！”)
f.writelines(lines)	将一个元素全为字符串的列表写入文件 >>>ls = [“中国”, “法国”, “美国”] >>>f.writelines(ls) 中国法国美国
f.seek(offset)	改变当前文件操作指针的位置， offset 含义如下： 0 - 文件开头；1 - 当前位置；2 - 文件结尾 >>>f.seek(0) # 回到文件开头

六、Python常用库

（一）jieba库

jieba库主要用于分词，其常用函数包括：

函数	描述
jieba.lcut(s)	精确模式，返回一个列表类型的分词结果 >>>jieba.lcut(‘中国是一个伟大的国家’) [‘中国’, ‘是’, ‘一个’, ‘伟大’, ‘的’, ‘国家’]
jieba.lcut(s,cut_all=True)	全模式，返回一个列表类型的分词结果，存在冗余 >>>jieba.lcut(‘中国是一个伟大的国家’,cut_all=True) [‘中国’, ‘国是’, ‘一个’, ‘伟大’, ‘的’, ‘国家’]
jieba.lcut_for_search(s)	搜索引擎模式，返回一个列表类型的分词结果，存在冗余 >>>jieba.lcut_for_search(‘中华人民共和国是伟大的’) [‘中华’, ‘华人’, ‘人民’, ‘共和’, ‘共和国’, ‘中华人民共和国’, ‘是’, ‘伟大’, ‘的’]
jieba.add_word(w)	向分词词典增加新词 >>>jieba.add_word(‘蟒蛇语言’)

（二）wordcloud库

w = wordcloud.WordCloud()

方法	描述
w.generate(txt)	向WordCloud对象 w 中加载文本txt >>>w.generate(“Python and WordCloud”)
w.to_file(filename)	将词云输出为图像文件，.png或 .jpg格式 >>>w.to_file(“outfile.png”)

配置对象参数：

参数	描述
min_font_size	指定词云中字体的最小字号，默认4号 >>>w = wordcloud.WordCloud(min_font_size = 10)
max_font_size	指定词云中字体的最大字号，根据高度自动调节 >>>w = wordcloud.WordCloud(max_font_size = 20)
font_step	指定词云中字体字号的步进间隔，默认为1 >>>w = wordcloud.WordCloud(font_step = 2)
font_path	指定字体文件的路径，默认None >>>w = wordcloud.WordCloud(font_path = “myyh.ttc”)
max_words	指定词云显示的最大单次数量，默认200 >>>w = wordcloud.WordCloud(max_words = 20)
stop_words	指定词云的排除词列表，即不显示的单词列表 >>>w = wordcloud.WordCloud(stop_words = {“Python”})
mask	指定词云形状，默认为长方形，需要引用 imread() 函数 >>>from scipy.misc import imread >>>mk = imread(“pic.png”) >>>w = wordcloud.WordCloud(mask = mk)
background_color	指定词云图片的背景颜色，默认为黑色 >>>w = wordcloud.WordCloud(background_color = “white”)

（三）机器学习相关的库

Scikit-learn 库、TensorFlow库

import tensorflow as tf
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
res = sess.run(result)
print('result:', res)

MXNet：基于神经网络的深度学习计算框架

提供可扩展的神经网络及深度学习计算功能
可用于自动驾驶、机器翻译、语音识别等众多领域

（四）网络爬虫相关的库

可以使用 request 库、Scrapy 库、pyspider 库

import requests
r = requests.get('https://api.github.com/user',auth = ('user','pass'))
r.status_code
r.headers['content-type']
r.encoding
r.text

（五）Web信息提取

Beautiful Soup 库、Re 库（标准库）、goose3 库

from goose3 import Goose
from goose3.text import StopWordsChinese
# 初始化，设置中文分词
g = Goose({'stopwords_class': StopWordsChinese})
# 文章地址
url = 'https://sniperstar.github.io/2021/11/13/%E7%88%B1%E6%83%85/#more'
# 获取文章内容
article = g.extract(url=url)
# 标题
print('标题:', article.title)
# 显示正文
print(article.cleaned_text)