python期末复习（基于python程序设计基础与实战》）

python期末复习（基于python程序设计基础与实战》）

大家好，这是一篇来自一个谆谆好学的少年花了大心思写的blog，希望大家能够支持，同时预祝大家看了本篇报告，期末考试都能过，最后希望大家能给予我一点点支持。在这里我也吸取了前辈的经验，同时也增加了自己的理解。

大家可以查看下面的书籍书籍课件查询获得具体的书本内容

在这里我也推荐一些视频教程学习链接

这里也提供一些下载的视频下载链接

同时在这我也提供一些下载和学习anaconda的教程下载链接,在这里我也提供学习链接

我们以一段代码来开始我们的讲解吧,相信大家在看完我的blog后一定会有自己的收获。加油

class Book:
    def __init__(self, title, author, isbn):
        self.title = title
        self.author = author
        self.isbn = isbn

    def __str__(self):
        return f"'{self.title}' by {self.author}, ISBN: {self.isbn}"


class Library:
    def __init__(self):
        self.books = []

    def add_book(self, book):
        self.books.append(book)
        print(f"Book added: {book}")

    def remove_book(self, isbn):
        for book in self.books:
            if book.isbn == isbn:
                self.books.remove(book)
                print(f"Book removed: {book}")
                return
        print("Book not found.")

    def search_book(self, title):
        found_books = [book for book in self.books if title.lower() in book.title.lower()]
        if found_books:
            print("Found books:")
            for book in found_books:
                print(book)
        else:
            print("No books found with that title.")

    def list_books(self):
        if self.books:
            print("Library books:")
            for book in self.books:
                print(book)
        else:
            print("The library is empty.")


def main():
    my_library = Library()
    while True:
        print("\nLibrary Management System")
        print("1. Add a book")
        print("2. Remove a book")
        print("3. Search for a book")
        print("4. List all books")
        print("5. Exit")
        choice = input("Enter your choice: ")

        if choice == '1':
            title = input("Enter the book title: ")
            author = input("Enter the book author: ")
            isbn = input("Enter the book ISBN: ")
            my_library.add_book(Book(title, author, isbn))
        elif choice == '2':
            isbn = input("Enter the book ISBN to remove: ")
            my_library.remove_book(isbn)
        elif choice == '3':
            title = input("Enter the book title to search for: ")
            my_library.search_book(title)
        elif choice == '4':
            my_library.list_books()
        elif choice == '5':
            print("Exiting the Library Management System.")
            break
        else:
            print("Invalid choice. Please choose a valid option.")


if __name__ == "__main__":
    main()

第一章

认识python

python环境配置

集成开发环境

第二章

python的代码编写规范

变量

基本的输入与输出

模块

第三章

数字类型

数字类型的操作

字符串类型及操作

常用的字符串方法

第四章

程序表示方法

条件语句

循环语句

异常处理

第五章

通用序列操作

列表

元祖

第六章

字典的创建和使用

字典的常用操作

jieba库的使用

集合的创建的运算

第七章

函数的基本运用

函数的参数传递

可变对象作为参数

变量的作用域

函数的递归调用

算法（快速排序）

第八章

类的对象概述

类的基本使用

属性

方法

导入模块的类

第九章

面对对象概述

封装

继承

多态

自定义异常类

寄语

亲爱的读者们，

在这个充满挑战与机遇的季节里，我，一个怀揣着求知渴望的少年，带着满腔热忱，向大家呈现这篇心血结晶的博客。我诚挚地希望，我的这份努力能够得到你们的支持与鼓励。

随着期末考试的脚步日益临近，我预祝每一位阅读这篇文章的朋友都能取得优异的成绩，顺利通过考试。在这个过程中，我不仅汲取了前辈们宝贵的经验，还融入了自己的深刻理解，希望能够为你们的学习之路增添一份力量。

在此，我也希望得到你们的一点点支持，哪怕是一个小小的点赞，一句鼓励的话语，都是对我莫大的鼓励。让我们在这个知识的海洋中，携手同行，共同成长。

愿我们都能以最饱满的热情迎接挑战，用最坚定的信念追求卓越。感谢大家的陪伴与支持，让我们共同期待一个充满希望的未来。

祝福你们，愿知识的光芒照亮每个人的道路。**

程序设计基本方法

• 计算机与程序设计

• 计算机是根据指令操作数据的设备

• 计算机发展参照摩尔定律，表现为指数形式

  计算机执行源程序两种方式：编译和解释

• 编译：将源代码一次性转换成目标代码的过程。执行编译过程的程序叫编译器(compiler)。

• 解释：将原代码逐条转换成目标代码同时逐条运行的过程。执行解释过程的程序叫解释器(interpreter)。

• 静态语言：使用编译执行的编程语言(C/C++,java)

• 脚本语言：使用解释执行的编程语言(Python,JavaScript，PHP)

  

  input输入:文件输入、控制台输入、交互输入、内部参数输入等。
  process处理(主要逻辑)：算法（灵魂）
  output输出：控制台、文件、网络、操作系统内部变量等输出。

  计算机编程能够训练思维：编程体现一种抽象交互、自动化执行的思维方式
  计算思维：区分逻辑思维和实证思维的第三种思维模式。
  

import keyword
print(keyword.kwlist)

数据类型

字符串：由0个或多个字符组成的"有序"字符序列。# 有序–>可以索引、切片
整数：数学中的整数
浮点数：数学中的实数，带有小数点部分
列表：由0个或多个数据组成的"有序"序列
语句与函数

赋值语句
分支语句
函数
Python程序的输入输出

input（）控制台输入
print（）控制台输出，格式化

第二章 Python基本图形绘制

模块：turtle库的调用

大家可以尝试自己打印自己的图案哟

pen.forward(distance)：向前移动指定的距离。
pen.backward(distance)：向后移动指定的距离。
pen.right(angle)：向右旋转指定的角度（单位为度）。
pen.left(angle)：向左旋转指定的角度。
pen.up()：提起画笔，移动时不绘制线条。
pen.down()：放下画笔，移动时绘制线条。
pen.goto(x, y)：将画笔移动到指定的坐标位置。
pen.setheading(angle)：设置画笔的朝向。
注：4个参数后两个可选，不选则默认在窗口的正中间，setup（）不是必须的 turtle空间坐标体系绝对坐标：和数学中的坐标系（象限）知识相同
turtle.goto(x,y)

第三章 基本数据类型

• int
• char
• bool
• float
• complex

整数类型：与数学中概念一致，+|-均可，无范围限制
--pow(x,y)函数

4种进制表示形式：
十进制，二进制(0b,0B开头)，八进制(0o,0O开头)，十六进制(0x,0X)浮点数类型：浮点数范围和小数精度都存在限制，但常规计算可以忽
浮点数间运算存在不确定尾数，发生在10E-16左右，不是bug

浮点数采用科学计数法表示
e

字符串类型的表示:

• 单引号，双引号；三引号
• 索引 [M]
• 切片 [M,N,K]
• 转义字符：\b回退，\n换行，\r回车（光标移到本行行首）

字符串操作符:
+ 字符串拼接
* 复制n次字符串
in

字符串处理函数
len(x)  
str(x) 任意类型所对应的字符串形式
hex(x)或oct(x) 整数x的十六进制或八进制小写形式字符串
chr(u) u为Unicode编码，返回其对应的字符
ord(x) x为字符，返回其对应的Unicode编码

字符串处理方法:
S.lower()或S.upper() 返回字符串副本，全部字符小写/大写
S.split(sep=None) 返回一个列表，由str根据sep被分隔部分组成
S.count(sub) 返回子字符串sub在str中出现的次数
S.replace(old,new)
S.center(width[,fillchar])
S.strip(chars)从str中去掉在其左侧和右侧chars中列出的字符。
S.join(iter) 在iter变量除最后元素外每个元素增加一个S。例如：','.join("12345")  #主要用于字符串分割

字符串类型的格式化:
"{<参数序号>:<格式控制标记>}"<填充><对齐><宽度><,><.精度><类型>

time库的基本介绍

时间获取：time() ctime() gmtime()
时间格式化： strftime() strptime()
程序计时：sleep(),perf_counter()

时间获取:
.time() #获取当前时间戳，即计算计算机内部时间值，浮点数。

.ctime() #获取当前时间并以易读方式表示，返回字符串

.gmtime() #获取当前时间，表示为计算机可处理的时间格式

 时间格式化:
.strftime(tpl,ts) : tpl # 是格式化模板字符串，用来定义输出效果，ts是计算机内部时间类型变量
t = time.gmtime()
time.strftime("%Y-%m-%d %H:%M:%S", t)
t = time.gmtime()
time.strftime("%Y-%m-%d %H:%M:%S", t)
timeStr = "2018-01-26 12:55:20"
time.strptime(timeStr,"%Y-%m-%d %H:%M:%S")

程序计时应用:
start = time.perf_counter()
end = time.perf_counter()
end - start
sleep(s) # s拟休眠时间，单位是秒，可以是浮点数

实例4：文本进度条
本质：用后打印的字符串覆盖之前的字符串。不能换行(end=)，要能回退\r
import time
scale = 50
print("执行开始")
start = time.perf_counter()
for i in range(scale + 1):
    a = "*" * i 
    b = "." * (scale - i)
    c = (i / scale) * 100
    dur = time.perf_counter() - start
    print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c, a, b, dur), end="")
    time.sleep(0.1)
print("\n" + "执行结束".center(scale // 2, "-"))

程序的控制结构

程序的控制结构：顺序结构、分支结构、循环结构

单分支结构:
if <条件>:
	<语句块>   

二分支结构选择结构：
if <条件> ：
	<表达式1> 
else <表达式2>：
	<表达式2>
...........

多分支结构:
语法：if <条件1>:
         <语句块1>
      elif <条件2>：
          <语句2>
          ...
        else:
         <语句块N>
.......

注： 注意多条件之间的包含关系，注意变量取值范围的覆盖

通俗点： 多分支结构中，如果一个分支判断条件通过后，会执行对应的语句块，之后结束分支程序。即使，后续的elif条件也满足，也不会执行对应的语句块.所以这里其实也有一个顺序关系。

条件判断及组合

算术运算符：
<,<=,>=,>,==,!=

逻辑运算符：
and,or,not

程序的异常处理:
try:
    <语句块1>
except [<异常类型>]：
    <语句块2>
---------------------------
try:
    <语句块1>
except:
    <语句块2>
else:           # 不发生异常的时候执行(奖励)
    <语句块3>
finally:        # 一定会执行
    <语句块4>

注：标注异常类型后，仅响应该异常，异常类型名字等同于变量。

程序的循环结构

遍历循环:
for <循环变量> in <遍历结构>:
    <语句块>

---------------------------------------  
解释：
<语句块>--从遍历结构中逐一提取元素，放在循环变量中。
--完整遍历所有元素后结束
--每次循环，所获得元素放入循环变量，并执行一次语句块

关于遍历应用我们列出一些重要的方法：计数循环、字符串遍历循环、列表遍历循环、文件遍历循环

---

关于循环时，当我们在循环条件时，如果令条件一直为真的话，即不能用条件的问题来限制循环的结束与否，我们将这个循环称之为死循环，下面我们来简单的列举一个例子

while 1:
    语句块
-----------
while True：
	语句块

循环控制保留字:
break 跳出并结束当前循环，执行循环后的语句
continue 结束当次循环，继续执行后续次数循环
break和continue可以与for和while循环搭配使用。

#关于else的细致讲解
# 当循环没有被break语句退出时，执行else语句块
else #语句块作为“正常”完成循环的奖励,这里else的用法与异常处理中else用法相似
-----------------------
当循环没有被break语句退出时，执行else语句块
else语句块作为“正常”完成循环的奖励
这里else的用法与异常处理中else用法相似

random 库

首先伪随机数采用梅森旋转算法生成的(伪)随机序列中元素，因此我们可以用random库主要用于生成随机数
4.4.2 基本随机函数
seed(a=None) --初始化给定的随机数种子，默认为当前系统时间
–random.seed(10) # 产生种子10对应的序列
–这个在实战中用的比较多，“确定”的伪随机数便于对程序进行复现。

random()
–生成一个[0.0，1.0)之间的随机小数
–random.random()
4.4.3 扩展随机数函数

randint(a,b) 生成[a,b]之间的整数

randrange(m,n[,k]) 生成一个[m,n)之间以k为步长的随机整数

uniform(a,b) 生成一个[a,b]之间的随机小数
                        
getrandbits(k) 生成一个k比特长的随机整数

choice(seq) 从序列seq中随机选择一个元素

shuffle(seq) 将序列seq中元素随机排列，返回打乱后的序列

下面我们来了解一下圆周率，这里的话我就直接给出代码

from random import random
from time import perf_counter
DARTS = 1000 * 1000
hits = 0.0
start = perf_counter()
for i in range(1, DARTS+1):
  x, y = random(), random()
  dist = pow(x ** 2 + y ** 2, 0.5)
  if dist <= 1.0:
   hits += 1
pi = 4 * (hits / DARTS)
print("圆周率是：{}".format(pi))
print("运行时间是：{:.5f}s".format(perf_counter() - start))

函数的定义与使用

函数的理解和定义:函数是一段具有特定功能,可重用的语句组,可以做到降低编程难度 和 代码复用，注意不调用不会被执行

函数代码示例：

def <函数名>(<参数(0个或多个)>)：
    <函数体>
    return <返回值>

• 函数的使用及调用过程
• 调用是运行函数代码的方式
• 调用时给出实际参数，替代定义中的形式参数
• 函数调用得到返回值

可变数量参数，既不确定参数总数量

传递参数两种方式：位置参数，名称传递

可变数量参数，既不确定参数总数量

传递参数两种方式：位置参数，名称传递5.1.4 函数的返回值
return 保留字用来传递返回值,可以传，可以不传，可以传递0个，也可以传多个

局部变量和全局变量

一般函数外部是全局变量，函数内部的变量是局部变量

规则一：局部变量和全局变量是不同变量

局部变量是函数内部的占位符，与全局变量可能重名但不同
函数运算结束后，局部变量被释放
可以用 global保留字在函数内部使用全局变量	(这里还分可变类型和不可变类型)


规则二：局部变量为组合数据类型且未创建，等同于全局变量

使用规则：
-基本数据类型，无论是否重名，局部变量与全局变量不同
-可以通过global保留字在函数内部声明全局变量
-组合数据类型，如果局部变量未真实创建，则是全局变量

lambda函数

无名，保留字，函数名是返回结果

<函数名> = lambda <参数>:<表达式>

主要作用:特定函数或方法的参数
固定使用方式，逐步积累掌握.一般情况，用def定义普通函数，慎用lambda

下面我为大家提供七段数码管绘制方法，在这我提供了示例代码，以供大家参考

import turtle

# 初始化turtle模块
screen = turtle.Screen()
screen.title("七段数码管绘制")
t = turtle.Turtle()
t.speed(0)  # 设置绘制速度

# 定义绘制单个段的函数
def draw_segment(is_on):
    if is_on:
        t.begin_fill()
    t.forward(40)
    t.left(90)
    t.forward(10)
    t.left(90)
    t.forward(40)
    t.left(90)
    t.forward(10)
    t.left(90)
    if is_on:
        t.end_fill()

# 定义绘制数字的函数
def draw_digit(digit):
    # 根据数字控制各个段是否亮起
    segments = {
        'A': (200, 50, False),  # (起始角度, 长度, 是否亮)
        'B': (160, 40, False),
        'C': (120, 40, False),
        'D': (80, 40, False),
        'E': (40, 40, False),
        'F': (0, 40, False),
        'G': (200, 40, False)  # 重复使用A段
    }
    
    # 定义每个数字对应的段状态
    digit_patterns = {
        '0': "1111110",
        '1': "0110000",
        '2': "1101101",
        '3': "1111001",
        '4': "0110011",
        '5': "1011011",
        '6': "1011111",
        '7': "1110000",
        '8': "1111111",
        '9': "1111011",
    }
    
    pattern = digit_patterns[digit]  # 获取数字对应的模式
    t.penup()
    t.goto(-100, 0)  # 移动到起始位置
    t.pendown()
    
    for segment in 'ABCDEFG':
        is_on = pattern[segment] == '1'  # 根据模式判断是否亮
        draw_segment(is_on)  # 绘制段
        t.penup()
        t.forward(20)  # 移动到下一个段的起始位置
        t.pendown()

# 绘制数字
draw_digit('8')

# 完成绘制
turtle.done()

5.3 代码复用与函数递归

代码递归:

def factorial(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n - 1)

# 计算并打印5的阶乘
print("5的阶乘是:", factorial(5))

def square(number):
    return number * number

# 使用square函数计算并打印两个数的平方
num1 = 3
num2 = 4
print(f"{num1}的平方是: {square(num1)}")
print(f"{num2}的平方是: {square(num2)}")

下面我来为大家介绍一下它们的相关简介

• 代码复用：把代码当成资源进行抽象

• 代码复用：|函数|和|对象|是代码复用的两种主要形式

• 函数：(将代码命名)：在代码层面建立了初步抽象

• 对象：(属性和方法):在函数基础上再次组织进行抽象

• 模块化设计：分而治之

• 模块化设计：紧耦合、松耦合

  ---

  两个关键特征：

  • 链条：计算过程存在递归链条

  • 基例：存在一个或多个不需要再次递归的基例

    字符串反转(用递归来实现):

    def reverse_string(s):
        return s[::-1]
    
    # 测试字符串
    test_string = "Hello, World!"
    print("原始字符串:", test_string)
    print("反转后的字符串:", reverse_string(test_string))
    

    斐波那契数列(用递归来实现):

    def fibonacci_recursive(n):
        if n <= 0:
            return "输入的数字应该是正整数"
        elif n == 1:
            return 0
        elif n == 2:
            return 1
        else:
            return fibonacci_recursive(n-1) + fibonacci_recursive(n-2)
    
    # 获取斐波那契数列的前n项
    def get_fibonacci_recursive(n):
        fibonacci_list = []
        for i in range(1, n + 1):
            fibonacci_list.append(fibonacci_recursive(i))
        return fibonacci_list
    
    # 打印斐波那契数列的前10项
    print(get_fibonacci_recursive(10))
    

    下面我为大家送上一个小福利

    import turtle
    
    screen = turtle.Screen()
    screen.setup(width=600, height=600)
    
    dragon = turtle.Turtle()
    dragon.speed(0) 
    dragon.left(90)  
    
    def dragon_curve(length, iterations, turn_angle):
        if iterations == 0:
            return
        dragon.forward(length)
        dragon.left(turn_angle)
        dragon_curve(length * 2, iterations - 1, turn_angle)
        dragon.backward(length)
        dragon.right(turn_angle)
        dragon_curve(length * 2, iterations - 1, turn_angle)
    
    dragon_curve(10, 100, 90)  
    
    dragon.hideturtle()
    
    screen.mainloop()
    

集合知识讲解

操作函数或操作方法：
S.add(x) 如果X不在集合S中，将X增加到S
S.discard(x) 移除S中的元素X，如果x不在S中，不报错
S.remove(x) 移除S中元素X，如果x不在S中，产生KeyError异常
S.clear() 移除S中所有元素
S.pop() 随机返回S的一个元素，更新S，若S为[空]产生KeyError异常
S.copy() 返回集合S的一个副本
len(S)
x in S
x not in S
set(x) 其他变量转变为集合类型

序列

字符串

元组

列表

通用操作符(6个):

in
not in
"+" ：拼接
"*" : 复制
s[i] : 索引
s[i:j:k] : 切片

函数和方法(5个):

len(s)
min(s)
max(s)
s.index(x[,i,j])
s.count(x)

元组类型及操作:

元组是序列类型的一种扩展
不可修改
()或tuple()创建，元素间逗号分隔
可以使用或不用()

6.2.4 列表类型及操作

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

函数和方法:

ls[i] = x 修改
ls[i:j:k] = lt lt替换ls切片后所对应元素子列表
del ls[i] 删除第i个元素
del ls[i:j:k]
ls += lt 更新列表ls，将lt元素增加到ls中。这里有个特殊点提一下：这里的操作不会重新开辟内存空间，本质上相当于ls.extend(lt)。
ls *= n 更新列表ls，重复n次
ls.insert(i,x) 索引i的位置插入元素x
ls.pop(i) 取出索引为i对应的元素并将它从列表中删除，默认i=-1
ls.remove(x) 列表中出现的第一个x元素删除
ls.reverse() 列表中元素反转
ls.append(x) 列表后面追加x
ls.clear() 删除所有元素
ls.copy() 生成一个新列表，赋值ls中所有元素

字典类型及操作

函数和方法:

del d[k] 删除键k对应的键值对
k in d[k] 判断键是否在字典中
d.keys() 返回字典中所有键的信息，类似集合形式
d.values() 返回字典中所有值的信息，类似集合形式
d.items() 返回字典中所有键值对的信息，类似集合形式，键值对是以元组形式
d.get(k,<default>) 键k存在，返回对应的值，否则返回<default>值
d.pop(k,<default>) 键k存在，取出对应的值，否则返回<default>值
d.popitem() 随机从字典中取出一个键值对，以元组形式返回
d.clear() 删除所有键值对
len(d) 返回字典中键值对的个数

---

jieba库的使用(ieba库是优秀的中文分词第三方库)

import jieba

# 待分词的文本
text = "我来到北京清华大学"

# 精确模式：默认模式，试图将句子最精确地切开，适合文本分析
seg_list_exact = jieba.cut(text, cut_all=False)
print("精确模式: " + "/ ".join(seg_list_exact))

# 全模式：扫描所有可能的词语，速度非常快，但是不能解决歧义问题
seg_list_full = jieba.cut(text, cut_all=True)
print("全模式: " + "/ ".join(seg_list_full))

# 搜索引擎模式：在精确模式的基础上，对长词再次切分，提高召回率，适合用于搜索引擎
seg_list_search = jieba.cut_for_search(text)
print("搜索引擎模式: " + "/ ".join(seg_list_search))

# 添加自定义词典
jieba.load_userdict("userdict.txt")  # 假设有一个自定义词典文件 userdict.txt

# 添加自定义词汇
jieba.add_word("月之暗面科技有限公司")

# 测试自定义词汇分词
text_custom = "月之暗面科技有限公司是一家高科技公司"
seg_list_custom = jieba.cut(text_custom)
print("自定义词汇分词: " + "/ ".join(seg_list_custom))

常用函数：

jieba.lcut(s) 精确模式
jieba.lcut(s,cut_all=True) 全模式
jieba.lcut_for_search(s) 搜索引擎模式，返回列表类型的分词结果，存冗余
jieba.add_word(w) 向分词添加新词

---

下面我为大家在文件的知识上做出自己的讲解，首先话不多说我在这里先附上自己的代码，以供大家参考

# 文件创建与写入
def create_and_write_file(filename, content):
    with open(filename, 'w', encoding='utf-8') as file:
        file.write(content)

# 读取文件
def read_file(filename):
    with open(filename, 'r', encoding='utf-8') as file:
        return file.read()

# 追加内容到文件
def append_to_file(filename, content):
    with open(filename, 'a', encoding='utf-8') as file:
        file.write(content)

# 删除文件
def delete_file(filename):
    import os
    os.remove(filename)

# 复制文件
def copy_file(src_filename, dst_filename):
    import shutil
    shutil.copy(src_filename, dst_filename)

# 移动文件
def move_file(src_filename, dst_filename):
    import shutil
    shutil.move(src_filename, dst_filename)

# 使用示例
if __name__ == "__main__":
    filename = 'example.txt'
    content = 'Hello, World!\n这是一行文本。'

    # 创建并写入文件
    create_and_write_file(filename, content)

    # 读取文件内容并打印
    print(read_file(filename))

    # 追加内容到文件
    append_to_file(filename, '\n这是追加的一行文本。')

    # 再次读取文件内容并打印
    print(read_file(filename))

    # 删除文件
    delete_file(filename)

    # 复制文件
    copy_file('source.txt', 'destination.txt')

    # 移动文件
    move_file('source.txt', 'new_location.txt')

• 文件是数据的抽象和集合

• 文件是存储在辅助存储器上的[数据序列]

• 文件是数据存储的一种形式

• 文件展现形态：文本文件和二进制文件

• 文本文件 VS 二进制文件

• 文本文件和二进制文件只是文件的展示方法

  二进制文件：直接由比特0、1组成，没有统一字符编码一般存在二进制0，1的组织结构，即文件格式

关于文件的操作思路

文件处理的步骤：打开——操作——关闭
文件的存储状态文件的占用状态a = opne( , )a.close()文件的存储状态文件的占用状态

• 读文件：3种方法 VS 写文件： 3种方法 -文件的打开： <变量名> = open(<文件名>，<打开模式>)

• 变量名：文件句柄

• 文件名：文件路径和名称(源文件同目录可省略)

• 打开模式：文本or二进制；读or写

文件打开模式

"r"	只读模式，默认值，若文件不存在，返回FileNotFoundError
"w"	覆盖写模式，文件不存在则创建，存在则完全覆盖
"x"	创建写模式，文件不存在则创建，存在则返回FileExistsError
"a"	追加写模式，文件不存在则创建，存在则在文件最后追加内容
"b"	二进制文件模式
"t"	文本文件模式，默认值
"+"	与r/w/x/a一同使用，在原功能基础上增加同时读写功能
文件关闭：变量名.close()

操作方法

<f>.read(size=-1)	读入全部内容，如果给出参数，读入前size长度
<f>.readline(size=-1)	读入一行内容，如果给出参数，读入该行前size长度，每读取一行指针移动到下一行的行首。
<f>.readlines(hint=-1)	读入文件所有行，以每行为元素形成列表。如果给出参数，读入前hint行。

下面我为大家来讲解一下关于txt文件的操作方式，这个在考试中不做强制要求，大家自己可以随意取用。

txt = fo.read(2)
fo.close()
文件的逐行操作
逐行遍历文件：方法一:一次读入，分行处理。缺点：对于大文件读取速度慢
fo = open(filename,"r")
for line in fo.readlines():
    print(line)
fo.close()
逐行遍历文件：方法二:分行读入，逐行处理。优点：大文件处理速度块
fo = open(filename,"r")
for line in fo: # 通过迭代器访问
    print(line)
fo.close()

7.1.4 数据的文件写入
操作方法

<f>.write(s)	向文件写入一个字符串或字节流
<f>.writelines(lines)	将一个元素全为字符串的列表写入文件
<f>.seek(offset)	改变当前文件操作指针的位置，offset含义如下：0 - 文件开头；1 - 当前位置；2 - 文件结尾

基本思路：

• 步骤1：定义数据文件格式(接口)：个性化
• 步骤2：编写程序，根据文件接口解析参数绘制图形
• 步骤3：编制数据文件

理解方法思维:

自动化思维：数据和功能分离，数据驱动的自动运行
接口化设计：格式化设计接口，清晰明了
二维数据应用：应用维度组织数据，二维数据最常用

应用问题扩展(在下面我附上了代码，大家可以参考)：

• 接口设计，增加更多控制接口

• 功能设计,增加弧形等更多功能(我们可以使用Python的matplotlib库来绘制这些形状)

• 一维数据的格式化和处理

接口设计

from abc import ABC, abstractmethod

# 定义接口
class ExtensionInterface(ABC):
    @abstractmethod
    def do_something(self):
        """
        这个抽象方法必须在子类中实现。
        """
        pass

    @abstractmethod
    def do_another_thing(self):
        """
        另一个抽象方法，也必须在子类中实现。
        """
        pass

# 实现接口的类A
class ImplementationA(ExtensionInterface):
    def do_something(self):
        print("ImplementationA did something")

    def do_another_thing(self):
        print("ImplementationA did another thing")

# 实现接口的类B
class ImplementationB(ExtensionInterface):
    def do_something(self):
        print("ImplementationB did something")

    def do_another_thing(self):
        print("ImplementationB did another thing")

# 使用接口的函数
def use_interface(interface_instance):
    interface_instance.do_something()
    interface_instance.do_another_thing()

# 创建实例并使用
interface_a = ImplementationA()
interface_b = ImplementationB()

use_interface(interface_a)  # 将打印ImplementationA的输出
use_interface(interface_b)  # 将打印ImplementationB的输出

功能设计

import matplotlib.pyplot as plt
import numpy as np

# 定义一个绘图类
class ShapeDrawer:
    def __init__(self, figure_size=(8, 6)):
        self.fig, self.ax = plt.subplots(figsize=figure_size)
    
    def draw_line(self, x1, y1, x2, y2, color='blue', label=None):
        """绘制直线"""
        self.ax.plot([x1, x2], [y1, y2], color=color, label=label)
    
    def draw_circle(self, center_x, center_y, radius, color='green', label=None):
        """绘制圆形"""
        circle = plt.Circle((center_x, center_y), radius, color=color, label=label)
        self.ax.add_artist(circle)
    
    def draw_arc(self, center_x, center_y, radius, start_angle, end_angle, color='red', label=None):
        """绘制弧形"""
        arc = plt.Arc((center_x, center_y), 2*radius, 2*radius, 
                      theta1=start_angle, theta2=end_angle, color=color, label=label)
        self.ax.add_artist(arc)
    
    def show(self):
        """显示图形"""
        self.ax.set_aspect('equal')  # 保持比例一致
        self.ax.legend()
        plt.show()

# 使用ShapeDrawer类
drawer = ShapeDrawer()

# 绘制直线
drawer.draw_line(0, 0, 1, 1, color='blue', label='Line')

# 绘制圆形
drawer.draw_circle(2, 2, 1, color='green', label='Circle')

# 绘制弧形
drawer.draw_arc(4, 2, 1, 0, 180, color='red', label='Arc')

# 显示图形
drawer.show()

一维数据的格式化和处理

import pandas as pd
import numpy as np

# 假设我们有以下的一维数据列表
data = [1, 2, 3, None, 5, 6, None, 8, 9, 10]

# 将数据转换为Pandas Series对象
data_series = pd.Series(data)

# 查看原始数据
print("原始数据:")
print(data_series)

# 清理数据，例如填充缺失值
# 这里我们用0来填充缺失值
data_series_filled = data_series.fillna(0)

# 查看填充后的数据
print("\n填充缺失值后的数据:")
print(data_series_filled)

# 数据类型转换，例如将数据转换为浮点型
data_series_float = data_series_filled.astype(float)

# 查看数据类型转换后的数据
print("\n数据类型转换为浮点型后的数据:")
print(data_series_float)

# 数据排序
data_series_sorted = data_series_float.sort_values()

# 查看排序后的数据
print("\n排序后的数据:")
print(data_series_sorted)

# 计算描述性统计数据
description = data_series.describe()

# 打印描述性统计数据
print("\n描述性统计数据:")
print(description)

下面我为大家从维度的角度来分析一下数据，大家可以参考一下，欢迎大家为我提供一些建议，我将不胜感激

• **一维数据：**由对等关系的有序或无序数据构成，采用线性方式组织对应列表、数组和集合等概念
• **二维数据：**由多个一维数据构成，是一维数据的组合形式表格是典型的二维数据，其中，表头是二维数据的一部分
• **多维数据:**由一维或二维数据在新维度上扩展形成比如，加入时间维度高维数据仅利用组基本的二元关系展示数据间的复杂结构比如，字典嵌套
• **数据的操作周期：**存储<->表示<->操作

---

• 存储方式一：空格分隔
  使用一个或多个空格分隔进行存储，不换行
  缺点：数据中不能存在空格

• 存储方式二：逗号分隔
  使用英文半角逗号分隔数据进行存储，不换行
  缺点：数据中不能有英文逗号

• 存储方式三：其他方式，特殊字符(不做强制要求)
  使用其他符号或符号组合分隔，建议采用特殊符号

---

二维数据的表示:

list类型：二维列表
使用两层for遍历
外层列表中每个元素可以对应一行，也可以对应一列

CSV格式与二维数据存储(CSV：Comma-Separated Values)

读入处理：

fo = open(filename)
ls = []
for line in fo:
  line = line.replace("\n", "")
  ls.append(line.split(","))
fo.close()

写入处理：

f = open(fname, "w")
for item in ls:
    f.write(",".join(item) + "\n")
f.close()

---

wordcloud库的使用

# 导入WordCloud类和matplotlib库
from wordcloud import WordCloud
import matplotlib.pyplot as plt

# 准备文本数据
text = """
Python是广泛使用的解释型、高级编程、通用型编程语言。它的设计哲学强调代码的可读性，
其语言构造及其对象导向的方法旨在帮助程序员编写清晰、逻辑性强的代码。
"""

# 创建WordCloud对象，可以设置各种参数
wordcloud = WordCloud(
    width = 800,  # 词云图的宽度
    height = 400,  # 词云图的高度
    background_color ='white',  # 背景颜色，默认是黑色
    stopwords = None,  # 需要排除的词，None表示不过滤任何词
    max_words = 200,  # 最多显示的词数
    max_font_size = 100  # 字体最大值
).generate(text)  # 生成词云

# 显示生成的词云图
plt.figure(figsize=(8, 4))
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis('off')  # 不显示坐标轴
plt.show()

• 7.6 实例12：政府工作报告词云

# 导入所需的库
import jieba
from wordcloud import WordCloud
import matplotlib.pyplot as plt

# 指定政府工作报告文本文件的路径
file_path = 'government_report.txt'

# 读取文件内容
with open(file_path, 'r', encoding='utf-8') as file:
    text = file.read()

# 使用jieba进行中文分词
text_cut = " ".join(jieba.cut(text))

# 创建词云对象，可以自定义背景颜色、最大词数等参数
wordcloud = WordCloud(
    font_path='simhei.ttf',  # 设置字体路径，确保字体支持中文
    background_color='white',  # 设置背景颜色
    max_words=200,  # 设置最大显示的词数
    width=800,  # 设置词云图的宽度
    height=600  # 设置词云图的高度
).generate(text_cut)  # 根据分词结果生成词云

# 使用matplotlib显示词云图
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis('off')  # 不显示坐标轴
plt.show()  # 显示图像

小拓展:

使用jieba进行中文分词

text_cut = " ".join(jieba.cut(text))

创建词云对象，可以自定义背景颜色、最大词数等参数

wordcloud = WordCloud(
font_path=‘simhei.ttf’, # 设置字体路径，确保字体支持中文
background_color=‘white’, # 设置背景颜色
max_words=200, # 设置最大显示的词数
width=800, # 设置词云图的宽度
height=600 # 设置词云图的高度
).generate(text_cut) # 根据分词结果生成词云

plt.imshow(wordcloud, interpolation='bilinear')
plt.axis('off')  # 不显示坐标轴
plt.show()  # 显示图像

结语

随着这篇博文的落幕，我们共同完成了又一次的思想之旅。感谢你们的陪伴，我们一起学习、反思，共同成长。每次的分享都是我们进步的印记，每次的对话都是智慧的火花。

在这个信息充斥的时代，拥有你们这样的读者是我的荣幸。你们的每一次互动、每一条反馈、每一次传播，都是我前进的动力。我期望我的文章能够启发你们，也希望我们的思想能在文字中相遇，激发新的灵感。

在未来，我将不懈努力，带来更多深刻、有见地的内容。如果你有任何想法或想要讨论的话题，欢迎在评论区留下足迹，或通过邮件与我交流。我期待与你们的每一次对话，因为我相信，正是这些对话让我们的世界更加多元。

最后，记得生活不只有屏幕前的阅读和写作，还有窗外的景色和身边的人。在追求知识的同时，也别忘了享受生活，珍惜与亲友的时光。

期待我们的下一次相聚，直到那时，愿阳光温暖你的每一天，愿知识丰富你的每一刻。

再见，亲爱的读者们。

---

在这里我为大家准备了小礼物，最后再再再一次祝大家学习进步，也恳请大家的指导

• 《流畅的python》书本链接
• 《python深度学习》书本链接
• 《python并发教程》书本链接
• 《python高级编程》书本链接
• 《python编程实战》blog链接