bash 脚本的优点

Bash 脚本是一种强大且灵活的工具，可以用于自动化系统管理任务、管理系统资源以及在 Unix/Linux 系统中执行其他例行任务。Shell 脚本的一些优点包括：

• 自动化：Shell 脚本允许你自动化重复性任务和过程，节省时间并减少手动执行时可能出现的错误。
• 可移植性：Shell 脚本可以在各种平台和操作系统上运行，包括 Unix、Linux、macOS，甚至通过使用模拟器或虚拟机在 Windows 上运行。
• 灵活性：Shell 脚本高度可定制，可以轻松修改以满足特定需求。它们还可以与其他编程语言或实用程序结合，创建更强大的脚本。
• 易访问性：Shell 脚本易于编写，不需要任何特殊工具或软件。它们可以使用任何文本编辑器进行编辑，并且大多数操作系统都有内置的 shell 解释器。
• 集成：Shell 脚本可以与其他工具和应用程序集成，如数据库、Web 服务器和云服务，从而实现更复杂的自动化和系统管理任务。
• 调试：Shell 脚本易于调试，大多数 shell 都内置调试和错误报告工具，可以帮助快速识别和修复问题。

运行 shell 脚本的方法有两种：

1， 作为可执行程序运行

2，作为解释器参数运行

1
2

#！/bin/bash
echo "hello World"

当作为可执行程序运行时

1
2
3
4

chmod +x test.sh
#赋予可执行权限
./test.sh 
#执行程序

当作为解释器运行时

1
2
3
4

/bin/sh test.sh 
#执行命令
/bin/php test.php
#执行命令

创建 bash 脚本

使用 vi 命令创建一个名为 run_all.sh 的文件

1

vi run_all.sh

在文件中添加以下命令并保存

1
2
3
4
5
6
7
8

#!/bin/bash
echo "今天是 " `date`

echo -e "\n请输入目录路径"
read the_path

echo -e "\n 你的路径包含以下文件和文件夹："
ls $the_path

打印用户提供的目录内容的脚本

• 第 1 行：Shebang (<font style="color:rgb(10, 10, 35);">#!/bin/bash</font>) 指向 bash shell 路径。
• 第 2 行：<font style="color:rgb(10, 10, 35);">echo</font> 命令在终端显示当前日期和时间。注意 <font style="color:rgb(10, 10, 35);">date</font> 在反引号中。
• 第 4 行：我们希望用户输入一个有效的路径。
• 第 5 行：<font style="color:rgb(10, 10, 35);">read</font> 命令读取输入并将其存储在变量 <font style="color:rgb(10, 10, 35);">the_path</font> 中。
• 第 8 行：<font style="color:rgb(10, 10, 35);">ls</font> 命令使用存储路径的变量并显示当前的文件和文件夹。

执行 bash 脚本

1

chmod u+x run_all.sh

• <font style="color:rgb(10, 10, 35);">chmod</font> 修改文件的所有权以供当前用户使用：<font style="color:rgb(10, 10, 35);">u</font>。
• <font style="color:rgb(10, 10, 35);">+x</font> 将执行权限添加到当前用户。这意味着作为所有者的用户现在可以运行该脚本。
• <font style="color:rgb(10, 10, 35);">run_all.sh</font> 是我们希望运行的文件。

1
2
3

sh run_all.sh
bash run_all.sh
./run_all.sh

变量命令规范

在 Bash 脚本中，以下是变量命名规范：

1. 变量名称应以字母或下划线 (<font style="color:rgb(10, 10, 35);">_</font>) 开头。
2. 变量名称可以包含字母、数字和下划线 (<font style="color:rgb(10, 10, 35);">_</font>)。
3. 变量名称区分大小写。
4. 变量名称不应包含空格或特殊字符。
5. 使用能反映变量用途的描述性名称。
6. 避免使用保留关键字（如 <font style="color:rgb(10, 10, 35);">if</font>, <font style="color:rgb(10, 10, 35);">then</font>, <font style="color:rgb(10, 10, 35);">else</font>, <font style="color:rgb(10, 10, 35);">fi</font> 等）作为变量名称

收集输入

1，读取用户输入并将其存储在变量中，可以使用 read 命令读取用户输入

1
2
3
4
5
6
7

#!/bin/bash 

echo "What's your name?" 

read entered_name 

echo -e "\nWelcome to bash tutorial" $entered_name

2，从文件读取

此代码从名为 <font style="color:rgb(10, 10, 35);">input.txt</font> 的文件中读取每一行并将其打印到终端。我们将在本文稍后学习 while 循环。

1
2
3
4

while read line
do
  echo $line
done < input.txt

3，命令行参数

在 bash 脚本或函数中，<font style="color:rgb(10, 10, 35);">$1</font> 表示传递的初始参数，<font style="color:rgb(10, 10, 35);">$2</font> 表示传递的第二个参数，以此类推。

此脚本将名字作为命令行参数并打印个性化问候语。

1

echo "Hello, $1!"

我们将 <font style="color:rgb(10, 10, 35);">Zaira</font> 作为参数提供给脚本。

1
2

#!/bin/bash
echo "Hello, $1!"

脚本代码：greeting.sh

输出

显示输出

1
2
3
4
5
6
7
8

#打印到终端
echo "Hello, World!"
#写入文件
echo "This is some text." > output.txt
#追加到文件
echo "More text." >> output.txt
#重定向输出
ls > files.txt

基本 bash 命令

1. <font style="color:rgb(10, 10, 35);">cd</font>: 切换到不同目录。
2. <font style="color:rgb(10, 10, 35);">ls</font>: 列出当前目录的内容。
3. <font style="color:rgb(10, 10, 35);">mkdir</font>: 创建新目录。
4. <font style="color:rgb(10, 10, 35);">touch</font>: 创建新文件。
5. <font style="color:rgb(10, 10, 35);">rm</font>: 删除文件或目录。
6. <font style="color:rgb(10, 10, 35);">cp</font>: 复制文件或目录。
7. <font style="color:rgb(10, 10, 35);">mv</font>: 移动或重命名文件或目录。
8. <font style="color:rgb(10, 10, 35);">echo</font>: 将文本打印到终端。
9. <font style="color:rgb(10, 10, 35);">cat</font>: 连接并打印文件内容。
10. <font style="color:rgb(10, 10, 35);">grep</font>: 在文件中搜索模式。
11. <font style="color:rgb(10, 10, 35);">chmod</font>: 更改文件或目录的权限。
12. <font style="color:rgb(10, 10, 35);">sudo</font>: 以管理权限运行命令。
13. <font style="color:rgb(10, 10, 35);">df</font>: 显示可用磁盘空间。
14. <font style="color:rgb(10, 10, 35);">history</font>: 显示先前执行的命令列表。
15. <font style="color:rgb(10, 10, 35);">ps</font>: 显示有关正在运行的进程的信息。

脚本安全和 set

set 命令：可以用来定制 shell 环境

h：hashall，打开选项后，Shell 会将命令所在的路径hash下来，避免每

次都要查询。通过set +h将h选项关闭

i：interactive-comments，包含这个选项说明当前的 shell 是一个交互式的 shell。所谓的交互式shell, 在脚本中，i选项是关闭的

m：monitor，打开监控模式，就可以通过Job control来控制进程的停

止、继续，后台或者前台执行等

B：braceexpand，大括号扩展

H：history，H选项打开，可以展开历史列表中的命令，可以通过!感叹号来完成，例如“!!”返回上最近的一个历史命令，“!n”返回第 n 个历史命令

set 命令实现脚本安全

-u 在扩展一个没有设置的变量时，显示错误信息， 等同set -o

nounset

-e 如果一个命令返回一个非0退出状态值(失败)就退出， 等同set -o

errexit

-o option 显示，打开或者关闭选项

显示选项：set -o

打开选项：set -o 选项 关闭选项：set +o 选项

-x 当执行命令时，打印命令及其参数,类似 bash -x

bc 命令

bash 计算器实际上是一种编程语言，允许在命令行中输入浮点数表达式，然后解释并计算该 表达式，最后返回结果。bash 计算器能够识别以下内容。

数字（整数和浮点数）

变量（简单变量和数组）

注释（以#或 C 语言中的/* */开始的行）

表达式

编程语句（比如 if-then 语句）

函数

1
2
3
4
5
6
7
8
9
10

-h --help
print this usage and exit
-i --interactive force interactive mode
-l --mathlib use the predefined math routines
-q --quiet
don't print initial banner
-s --standard non-standard bc constructs are errors
-w --warn
warn about non-standard bc constructs
-v --version print version information and exit

浮点数运算是由内建变量 scale 控制的。必须将该变量的值设置为希望在计算结果中保留的小数位数，否则将无法得到期望的结果

scale 变量的默认值是 0。在 scale 值被设置前，bash 计算器的计算结果不包含小数位。 在将其设置成 4 后，bash 计算器显示的结果包含4 位小数。-q 选项可以不显示 bash 计算器冗长 的欢迎信息。

read 命令接受输入

尽管命令行选项和参数是从脚本用户处获取输入的一种重要方式，但有时候脚本还需要更多的交互性。你可能想要在脚本运行时询问用户并等待用户回答。为此，bash shell 提供了read 命令。

使用 read 能把输入值分配给一个或多个 shell 变量，read 从标准输入中读取值，给每个单词分配一个变量，所有剩余单词都被分配给最后一个变量，如果变量名没有指定，默认标准输入的值赋值给系统内置变量REPLY

1
2
3
4
5

-p 指定要显示的提示
-s 静默输入，一般用于密码
-n N 指定输入的字符长度N
-d '字符' 输入结束符
-t N TIMEOUT为N秒

read 命令从标准输入（键盘）或另一个文件描述符中接受输入。获取输入后，read 命令会将数据存入变量。

变量的声明和赋值

用于将一个变量绑定到一个对象上。格式：变量=表达式

最简单的表达式就是字面量，比如：a = 123.运行过程中，解释器先运行右边的表达式，生成一个代表表达式运算结果的对象；然后将这个对象地址赋值给左边的变量

删除变量和垃圾回收机制

1，可以通过 del 语句删除不再使用的变量

2，如果对象没有变量引用，就会被垃圾回收器回收，清空内存空间

常量

Python 不支持常量，即没有语法规则改变一个常量的值，我们只能约定常量的命名规则以及在程序的逻辑上不对常量的值作出修改

链式赋值

用于同一个对象赋值给多个变量

x = y = 123

系列解包赋值

给对应相同个数的变量（个数必须保持一致）

a,b,c = 3,4,5 相当于：a=3;b=4,c=5

最基本内置数据类型

1，整型：int

整数，2345，10，30

2，浮点型：float

小数，3.14 或者科学计数法 314e-2

3，布尔型：bool

表示真假，仅包含：True，False

4，字符串型：str

由字符组成的序列“abc”“sxt”，“尚学堂”（用单引号或者双引号都可以）

数字和基本运算符

python 支持整数（如：50，520）和浮点数（如：3.14，10.0，1.23e2），我们可以对数字做如下运算

三种进制

python 中除了十进制，还有其他三种进制：

0b 或 0B，二进制 0 1

使用 int（）实现类型转换

1，浮点数直接舍去小数部分。如：int（9.9）结果是 9

2，布尔值 True 转为 1，False 转为 0.如：int（True）结果是 1

3，字符串符合整数格式（浮点数格式不行）则直接转成对应整数，否则报错

浮点数

1，浮点数用科学计数法表示。比如：3.14，表示成：314E-2 或者 314e-2

2，这些数字在内存中也是按照科学计数法存储

类型转换和四舍五入

1，类似于 int（），我们也可以使用 float（）将其他类型转化成浮点数

2，整数和浮点数混合运算时，表达式结果自动转型成浮点数。比如：2+8.0 的结果是 10.0

3，round（value）可以返回四舍五入的值。但不会改变原有值，而是产生新的值

增强型赋值运算符

运算符+、-、*、/、//、**和%和赋值符=结合可以构成“增强型赋值运算符”

注意！：“+=”中间不能加空格

复合赋值可以让程序更加精炼，提高效率

定义为 False 的对象：None 和 False

值为 0 的数字类型：0，0.0，0j，Decimal（0），Fraction（0，1）

空的序列和集合：“，（），{}，[]，set（），range（0）

+运算符操作

并不是真正的尾部添加元素，而是创建新的列表对象；将原列表的元素和新列表的元素依次复制到新的列表对象中，这样，会涉及大量的复制操作，对于操作大量元素不建议使用

extend（）方法

将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象

insert（）插入元素

使用 insert（）方法可以将指定的元素插入到列表对象的任意指定制定位置，这样会让插入位置后面所有的元素进行移动，会影响处理速度，涉及大量元素时，尽量避免使用。类似发生这种移动的函数还有：remove（），pop（），del（）。它们在删除非尾部元素时也会发生操作位置后面元素的移动

通过索引直接访问元素

索引的区间在【0，列表长度-1】这个范围，超过这个范围则会报错

index（）获得指定元素在列表中首次出现的索引

语法是：index(value,[start.[end]])

其中 start 和 end 指定了搜索的范围

count（）获得指定元素在列表中出现的次数

字符串

字符串的创建

可以使用引号（单引号’，双引号’‘或三引号’‘’）来创建字符串

可以使用 str 类的构造函数 str（）

python 的三引号

python 的三引号（三个单引号或三个双引号均可）用于字符串跨多行，字符串中可以包含换行符，制表符以及其他特殊字符

字符串中值的访问（切片：SLICE）

python 不支持字符类型，即使是单个字符，python 也将其视为一个字符串来使用，访问子串，实际上就是用方括号来截取字符串，有的文献称之为“切片运算”

tuple

将一个可迭代对象转换成元组

返回最小值和最大值

列表，元组和字符串的共同点

1，都可以通过索引获取每一个元素

2，第一个元素的索引值都是 0

3，都可以通过切片的方法获取一个范围

4，都有很多共同的运算符

列表是可变序列。

元组和字符串是不可变序列

+ *

序列的加法表示两个序列进行拼接

乘法表示将序列进行重复（即拷贝）

sorted（）函数

返回的是一个全新的列表，而原来的列表并不会受影响

案例

当我们单独传入这个 t 列表的时候，它对比的是列表中的每一个元素，这里的每一个元素又是字符串，所以它对比的是字符串的每一个字符的编码值

key 函数指定的是一个干预排序算法的函数

all（）&any（）

all（）是判断可迭代对象中是否所有元素的值都为真

any（）是判断可迭代对象中是否存在某个元素的值为真

enumerate（）

enumerate（）函数用于返回一个枚举对象，它的功能就是将可迭代对象中的每个元素及从 0 开始的序号共同构成一个二元组的列表

zip（）

zip （）函数用于创建一个聚会多个可迭代对象的迭代器。

它会将作为参数传入的每个可迭代对象的每个元素依次组合成元组，即第 i 个元组包含每个参数的第 i 个元素

map（）

map（）函数会根据提供的函数对指定的可迭代对象的每个元素进行运算，并将返回运算结果的迭代器

filter（）

filter（）函数会根据提供的函数对指定的可迭代对象的每个元素进行运算，并将运算结果为真的元素，以迭代器的形式返回

一个迭代器肯定是一个可迭代对象

可迭代对象可以重复使用而迭代器则是一次性的

iter（）把 x （可迭代对象）传过去，得到的结果给到 y，y 就是一个迭代器，通过 type（）函数观察到这个区别

next（）逐个将迭代器中的元素提取出来

元组 tuple

列表属于可变序列，可任意修改列表中的元素

元组属于不可变序列，不能修改元组中的元素

因此，元组没有增加元素，修改元素，删除元素相关的方法

只需掌握元组的创建和删除，元素的访问和计数即可

1，索引访问

2，切片操作

3，连接操作

4，成员关系操作

5，比较运算操作

6，计数：元组长度 len（），最大值 max（），最小值 min（），求和 sun（）等

元组的创建

通过（）创建元组，小括号可省略

如果元组只有一个元素，则必须后面加逗号，这是因为解释器会把（1）解释为整数 1，（1，）解释为元组

通过 tuple（）创建元组

总结

tuple（）可以接收列表，字符串，其他序列类型，迭代器等生成元组

list（）可以接收元组，字符串，其他序列类型，迭代器等生成列表

元组的元素访问和计数

1， 元组的元素不能修改

2， 元组的元素访问，index（），count（），切片等操作，和列表一样

3， 列表关于排序的方法 list.sorted()是修改原列表对象，元组没有该方法，如果要对元组排序，只能使用内置函数 sorted（tupleObj），并生成新的列表对象

zip

zip（列表 1，列表 2,…）将多个列表对应位置的元素组合成为元组，并返回这个 zip 对象

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同

生成器推导式创建元组

1 ，从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号

2，列表推导式直接生成列表对象，生成器推导式生成的不是列表也不是元组，而是一个生成器对象

3，我们可以通过生成器对象，转化成列表或元组，也可以使用生成器对象的 next()方法进行遍历，或者直接作为迭代器对象来使用，不管什么方式使用，元素访问结束后，如果需要重新访问其中的元素，必须重新创建该生成器对象

元组总结

1，元组的核心特点是：不可变序列

2，元组的访问和处理速度比列表快

3，与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用

字典是“键值对”的无序可变序列，字典中的每个元素都是一个”键值对“，包含”键对象“和”值对象“，可以通过”键对象“实现快速获取，删除，更新对应的”值对象“

字典是 Python 中唯一实现映射关系的内置类型

列表中通过”下标数字”找到对应的对象，字典中通过”键对象“找到对应的”值对象“

1，”键“的任意的不可变数据，比如:整数，浮点数，字符串，元组

2，但是：列表，字典，集合这些可变对象，不能作为“键”

3，并且“键”不可重复

4，“值”可以是任意的数据，并且可以重复

字典的创建

1， 通过{},dict()来创建字典对象

2，通过 zip（）创建字典对象

3，通过 fromkeys 创建值为空的字典

集合创建和删除

1.使用{}创建集合对象，并使用 add（）方法添加元素

2，使用 set（），将列表，元组等可迭代对象转成集合。如果原来数据存在重复数据，则只保留一个

集合是 python 的基本数据类型，把不同的元素组合在一起便形成了集合，组成一个集合的成员称作该集合的元素（element）

集合分为两类：可变集合（set），不可变集合（frozenset）

可变集合可添加和删除元素，是非可哈希的，不能用作字典的键，也不能做其他集合的元素。

不可变集合与之相反

可变集合的创建

在一个集合中不能有相同的元素。相同的元素被自动删除

不可变集合创建

创建不可变集合应使用 frozenset（）函数，不能使用大括号

不可变集合不能被修改

集合的遍历

因集合是无序的，不能使用索引来访问集合中的元素。可使用 for 循环可以遍历一个集合

元素访问的顺序依赖于它们在内部是如何存储的，输出中元素的顺序与创建集合时的顺序是不同的

无序使得可以实现高效的集合操作

增加和删除集合元素

如果要增加的元素没包含在集合中，它会被增加到集合中并且集合的大小加 1；

如果要增加的元素包含在集合中，则添加操作不会有效果，集合没有被修改。

如果元素存在，discard 方法会删除它，但是如果元素不是集合成员时，则不会有效果。

clear 方法删除集合中的所有元素，留下一个空集合

集合和列表都可以存储多个元素，两者不同：

• 集合不能存储重复的元素
• 集合中的元素是无序的，不能通过下标运算符来访问元素
• 集合还支持如何判断集合关系以及四种集合运算
• 列表的存储方式为顺序存储，而集合采用的存储方式更加负责。这使得在执行查找元素和删除元素的操作时，使用集合比使用列表的效率高

• list 用来存储任意大小的数据集合
• 一个列表中可以包含任意个数据，每个数据称为元素
• 列表是 Python 中使用最频繁的数据类型，它是放在方括号（[ ]）内，用逗号分隔的一系列元素
• 列表中元素的类型可以不同，它支持数字，字符串甚至可以包含列表。换言之，列表允许嵌套

列表的创建

1，变量名 = [ value1,value2,…]

2，通过 python 内置的 list 类的构造函数来创建列表

使用 list（）可以将任何可迭代的数据转换成列表

列表元素的访问

通过下标运算符来访问元素。下标从 0 开始

python 可以使用负数下标访问列表元素。负数下标提供了按相反顺序访问元素的方法

一般地，负数下标的有效范围介于-1 和-len（列表变量）之间

列表的切片（list slicing）

列表的切片操作使用 list[start: end] 来返回列表 list 的一个片段，这个片段是原列表从下标 start 到 end-1 的元素所构成的一个新列表

起始下标和结束下标可以省略

如果省略起始下标，则起始下标默认为 0；

如果省略结束下标，则结束下标默认为列表长度，即截取到列表的最好一个元素

list[start: end: step]

step：正负数均可，其绝对值大小决定了切取数据时的“步长”，而正负号决定了“切取方向”，正表示“从左往右”取值，负表示“从右往左”取值。当 step 省略时，默认为 1，即从左往右以增量 1 取值

列表的内置函数与其他方法

增

append（）添加元素

在列表的末尾来添加一个指定的元素

缺点：每次只能添加一个元素

extend（）允许直接添加一个可迭代对象

insert（）在列表的任意位置来添加数据

有两个参数：1，指定待插入的位置

2，指定待插入的元素

删

remove（）将指定的元素删除

• 如果列表中存在多个匹配的元素，那么它只会删除第一个
• 如果指定的元素不存在，那么程序就会报错

pop（）删除某个位置上的元素

参数是元素的下标索引值

sort（）直接实现排序

reverse（）从大到小排序，原地反转列表中的元素

s.sort(key=None,reverse=False)---->对列表中的元素进行原地排序（key参数用于指定一个用于比较的函数；reverse参数用于指定排序结果是否反转

查

count（）查找某个元素出现的次数

index（） 查找某个元素的索引值

index（x，start，end）指定查找的开始和结束位置

copy（）拷贝一个列表

条件测试命令

按照文件类型判断

在选项后加文件名，可以判断文件（若存在）类型是否符合条件，若文件不存在直接返回假，符合条件返回真，具体文件类型判断符与 ls 命令结果中文件属性第一位相似

1
2

[选项 文件名]
echo #?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

-a FILE
如果文件存在，则为 True。
-b FILE
如果文件是特殊块，则为 True。
-c FILE
如果文件是特殊字符，则为 True。
-d FILE
如果文件是目录，则为 True。
-e FILE
如果文件存在，则为 True。
-f FILE
如果文件存在且是普通文件，则为 True。
-g FILE
如果文件是 set-group-id 则为 True。
-h FILE
如果文件是符号链接，则为 True。
-L FILE
如果文件是符号链接，则为 True。
-k FILE
如果文件的 "粘性 "位已设置，则为 True。
-p FILE
如果文件是已命名的管道，则为 True。
-r FILE
如果您可以读取文件，则为 True。
-s FILE
如果文件存在且不为空，则为 True。
-S FILE
如果文件是套接字，则为 True。
-t FD
如果 FD 在终端上打开，则为 True。
-u FILE
如果文件是 set-user-id 则为 True。
-w FILE
如果文件可由您写入，则为 True。
-x FILE
如果文件有执行权限，则为 "true"。
-O FILE
如果文件所属者是你，则为 True。
-G FILE
如果文件所属组是你，则为 True。
-N FILE
如果文件自上次读取后已被修改，则为 True。
FILE1 -nt FILE2 如果文件 1 比文件 2 新（根据修改日期），则为True。
FILE1 -ot FILE2 如果文件 1 比文件 2 早，则为 True。
FILE1 -ef FILE2 如果文件 1 是文件 2 的硬链接，则为 True。

1
2
3
4
5
6
7
8

-z STRING
#如果字符串为空，则为 True。
-n STRING
#如果字符串不为空，则为 True。
STRING1 = STRING2 如果字符串相等，则为 True。
STRING1 != STRING2 如果字符串不相等，则为 True。
STRING1 < STRING2 如果 STRING1 按顺序排列在 STRING2 之前，则为 True。
STRING1 > STRING2 如果 STRING1 按顺序排列在 STRING2 之后，则为 True。

1
2
3
4
5
6
7
8
9
10

-o OPTION 
#如果 shell 选项 OPTION 已启用，则为 True。
-v VAR
#如果 shell 变量 VAR 已设置，则为 True。
-R VAR
#如果 shell 变量 VAR 已设置且是名称引用，则为True。
! EXPR
#如果 expr 为假，则为 True。
EXPR1 -a EXPR2 如果 expr1 和 expr2 均为真，则为真。
EXPR1 -o EXPR2 如果 expr1 或 expr2 为真，则为 True。

1
2
3
4
5
6

-eq 是否等于
-ne 是否不等于
-gt 是否大于
-ge 是否大于等于
-lt 是否小于
-le 是否小于等于

字符串测试

1
2
3
4
5
6
7

test和 [ ]用法
-z STRING 字符串是否为空，没定义或空为真，不空为假，
-n STRING 字符串是否不空，不空为真，空为假
STRING1 = STRING2 是否等于，注意 = 前后有空格
STRING1 != STRING2 是否不等于
> ascii码是否大于ascii码
< 是否小于

1
2
3
4
5

[[ expression ]] 用法
== 左侧字符串是否和右侧的PATTERN相同
注意:此表达式用于[[ ]]中，PATTERN为通配符
=~ 左侧字符串是否能够被右侧的正则表达式的PATTERN所匹配
注意: 此表达式用于[[ ]]中；扩展的正则表达式

建议：当使用正则表达式或通配符使用[[ ]]，其它情况一般使用 [ ]

文件测试

1
2
3
4
5
6
7
8

-a FILE：同 -e
-e FILE: 文件存在性测试，存在为真，否则为假
-b FILE：是否存在且为块设备文件
-c FILE：是否存在且为字符设备文件
-d FILE：是否存在且为目录文件
-f FILE：是否存在且为普通文件
-h FILE 或 -L FILE：存在且为符号链接文件
-p FILE：是否存在且为命名管道文件-S FILE：是否存在且为套接字文件

1
2
3
4
5
6

-r FILE：是否存在且可读
-w FILE: 是否存在且可写
-x FILE: 是否存在且可执行
-u FILE：是否存在且拥有suid权限
-g FILE：是否存在且拥有sgid权限
-k FILE：是否存在且拥有sticky权限

1
2
3
4
5
6
7

-s FILE #是否存在且非空
-t fd #fd 文件描述符是否在某终端已经打开
-N FILE #文件自从上一次被读取之后是否被修改过
-O FILE #当前有效用户是否为文件属主-G FILE #当前有效用户是否为文件属组
FILE1 -ef FILE2 #FILE1是否是FILE2的硬链接
FILE1 -nt FILE2 #FILE1是否新于FILE2（mtime）
FILE1 -ot FILE2 #FILE1是否旧于FILE2

按照文件权限判断

同样要在选项后加文件名，有权限为真，无权限或文件不存在为假。（判断的是当前用户对这个文件的权限）

比较两个文件的信息

格式：文件 1 [ 选项 ] 文件 2

其中，Inode 号是标识文件的序号，两个不同的文件可以名称相同，但 inode 号不能相同，若两个文件为硬链接（保存为副本，同步更新）关系，则两个文件的 inode 号才会相同，其余不同

两个硬链接的文件，除了 inode 号相同外没有任何标志，可以使用这个判断方式判断硬链接

比较两个整数

若为两个变量，不需要声明为整型格式，语法：整数 1 [ 选项 ] 整数 2

判断字符串相关

语法包含在选项中，注意：两个字符串比较相关的判断符两边都要加空格，否则无论如何，返回值均为真

当字符串是变量时，如果变量没有定义，则同样视作空字符串

两个判断条件的逻辑关系

同时使用两个判断条件时，要注意它们之间的逻辑关系，两个判断关系的格式：条件 1【选项】条件 2

条件判断语句基础

条件判断语句是编程语言中的基本构造之一，它允许程序在满足特定条件时执行不同的代码块。在 Linux shell 脚本中，常见的条件判断语句包括 <font style="color:rgb(51, 51, 51);background-color:rgb(246, 246, 246);">if</font>、<font style="color:rgb(51, 51, 51);background-color:rgb(246, 246, 246);">then</font>、<font style="color:rgb(51, 51, 51);background-color:rgb(246, 246, 246);">else if</font>、<font style="color:rgb(51, 51, 51);background-color:rgb(246, 246, 246);">else</font> 以及 <font style="color:rgb(51, 51, 51);background-color:rgb(246, 246, 246);">fi</font>（<font style="color:rgb(51, 51, 51);background-color:rgb(246, 246, 246);">if</font> 的倒置）。这些语句能够根据表达式的真假来决定执行哪些命令。

if 语句

1
2
3

if [ 条件 ]; then
  # 条件为真时执行的命令
fi

使用 else

当你需要根据条件的真假来选择两个不同的动作时，可以使用 else 语句：

1
2
3
4
5

if [ 条件 ]; then
  # 条件为真时执行的命令
else
  # 条件为假时执行的命令
fi

使用 elif

如果你有多个条件需要判断，可以使用 elif（else if 的简写）来扩展 if 语句：

1
2
3
4
5
6
7

if [ 条件1 ]; then
  # 条件1为真时执行的命令
elif [ 条件2 ]; then
  # 条件1为假且条件2为真时执行的命令
else
  # 上述条件都不为真时执行的命令
fi

检查文件属性

检查文件是否存在，是否为空，是否可读等属性是常见的操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 检查文件是否存在
if [ -f "/path/to/file" ]; then
  echo "文件存在"
else
  echo "文件不存在"
fi

# 检查文件是否为空
if [ ! -s "/path/to/file" ]; then
  echo "文件为空"
else
  echo "文件不为空"
fi

# 检查文件是否可读
if [ -r "/path/to/file" ]; then
  echo "文件可读"
else
  echo "文件不可读"
fi

比较字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 比较两个字符串是否相等
str1="Hello"
str2="World"
if [ "$str1" == "$str2" ]; then
  echo "字符串相等"
else
  echo "字符串不相等"
fi

# 检查字符串是否为空
str3=""
if [ -z "$str3" ]; then
  echo "字符串为空"
else
  echo "字符串不为空"
fi

比较数值

1
2
3
4
5
6
7
8
9
10

# 比较两个数值大小
num1=10
num2=20
if [ $num1 -eq $num2 ]; then
  echo "数值相等"
elif [ $num1 -lt $num2 ]; then
  echo "num1 小于 num2"
else
  echo "num1 大于 num2"
fi

处理用户输入

编写一个脚本时，需要根据用户的输入来决定执行哪些操作

1
2
3
4
5
6
7
8
9
10
11
12
13

#!/bin/bash

# 获取用户输入的参数
user_input=$1

# 使用条件判断来处理不同的输入
if [ "$user_input" == "hello" ]; then
  echo "Hello, world!"
elif [ "$user_input" == "bye" ]; then
  echo "Goodbye!"
else
  echo "Unknown command"
fi

自动化任务中的条件判断

在自动化任务中，条件判断语句可以用来检查任务是否按照预期执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#!/bin/bash

backup_dir="/path/to/backup"

# 检查备份目录是否存在
if [ ! -d "$backup_dir" ]; then
  echo "备份目录不存在，正在创建..."
  mkdir -p "$backup_dir"
else
  echo "备份目录已存在."
fi

# 执行备份操作
# ...

监控系统资源

条件判断语句也常用于监控系统资源，如 CPU 使用率，磁盘空间等

1
2
3
4
5
6
7
8
9
10
11
12

#!/bin/bash

# 获取CPU使用率
cpu_usage=$(top -bn1 | grep "Cpu(s)" | sed "s/.*, *\([0-9.]*\)%* id.*/\1/" | awk '{print 100 - $1}')

# 判断CPU使用率是否超过预设阈值
threshold=80
if (( $(echo "$cpu_usage > $threshold" | bc -l) )); then
  echo "警告: CPU使用率超过${threshold}%!"
else
  echo "CPU使用率正常."
fi

网络连接测试

1
2
3
4
5
6
7
8
9
10
11

#!/bin/bash

# 定义要检查的网络地址
network_address="google.com"

# 使用ping命令测试网络连接
if ping -c 4 "$network_address" &> /dev/null; then
  echo "网络连接正常，$network_address 可达。"
else
  echo "网络连接异常，$network_address 不可达。"
fi

服务状态检查

1
2
3
4
5
6
7
8
9
10
11
12

#!/bin/bash

# 定义要检查的服务名称
service_name="sshd"

# 检查服务是否正在运行
if systemctl is-active --quiet "$service_name"; then
  echo "$service_name 服务正在运行。"
else
  echo "$service_name 服务未运行，正在尝试重启..."
  systemctl restart "$service_name"
fi

文件内容处理

1
2
3
4
5
6
7
8
9
10
11
12
13

#!/bin/bash

# 定义日志文件路径
log_file="/var/log/syslog"

# 检查日志文件中是否包含特定错误信息
error_message="Error: Out of Memory"
if grep -q "$error_message" "$log_file"; then
  echo "检测到错误信息，发送通知。"
  # 在这里添加发送通知的代码
else
  echo "日志文件中没有检测到错误信息。"
fi

系统更新检查

1
2
3
4
5
6
7
8
9

#!/bin/bash

# 检查是否有可用的系统更新
if apt-get update && apt-get upgrade -s | grep -q "upgradable"; then
  echo "有可用的系统更新，正在应用更新..."
  apt-get upgrade -y
else
  echo "当前没有可用的系统更新。"
fi

tkinter (Tk interface)是python 的标准 GUI 库，支持跨平台的GUI 程序开发

Tkinter适合小型的GUI程序编写，也特别适合初学者学习GUI 编程。本书以 Tkinter为核心进行讲解。

2.wxpython

wxpython是比较流行的GUI 库，适合大型应用程序开发，功能强于 Tkinter

整体设计框架类似于MFC(Microsoft Foundation Classes 微软基础类库

3,PyQT是QT的工具包，QT是开源的GUI

基于 tkinter 模块创建 GUI 程序包含如下 4 个核心步骤：

1，创建应用程序主窗口对象（也称：根窗口）

（1）通过类 Tk 的无参构造函数

1
2
3
4

from tkinter import*


root = Tk()

2,在主窗口中，添加各种可视化组件，比如：按钮（Button），文本框（Label）等

1
2
3

btn01 = Button(root)

btn01["text"] ="点我就送花"

3,通过几何布局管理器，管理组件的大小和位置

1

btn01.pack()

4**，事件处理**

（1）通过绑定事件处理程序，响应用户操作所触发的事件（比如：单击，双击等）

1
2
3
4
5
6

def songhua(e):

    messagebox.showinfo("Message","送你一朵玫瑰花")
    print("送你99朵玫瑰花")

btn01.bind("<Button-1>",songhua)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

from tkinter import *
from tkinter import messagebox
root = Tk()

btn01 = Button(root)
btn01["text"] = "点我就送花"

btn01.pack()


def songhua(e):    # e就是事件对象
    messagebox.showinfo("Message", "送你一朵玫瑰花")
    print("送你99朵玫瑰花")


btn01.bind("<Button-1>", songhua)

root.mainloop()    #调用组件的mainloop()方法，进入事件循环

可变参数

指的是”可变数量的参数“，分两种情况

1，*param（一个星号），将多个参数收集到一个”元组“对象中

2，**param（两个星号），将多个参数收集到一个”字典“对象中

特殊方法和运算符重载

python 的 运算符实际上是通过调用对象的特殊方法实现的，比如：

1
2
3
4
5
6

a = 20
b = 30
c = a+b
d = a.__add__(b)
print("c=",c)
print("d=",d)

Entry 单行文本框

Entry 用来接收一行字符串的控件。如果用户输入的文字长度长于 Entry 控件的宽度时，文字会自动向后滚动。如果想输入多行文本，需要使用 Text 控件

Text 多行文本框

主要用于显示多行文本，还可以显示网页链接，图片，HTML 页面，甚至 CSS 样式表，添加组件等。因此，也常 被当做简单的文本处理器，文本编辑器或者网页浏览器来使用。比如 IDLE 就是 Text 组件构成的.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

from tkinter import *
import webbrowser

class Application(Frame):

    def __init__(self, master=None):
        super().__init__(master)    #super()代表的是父类的定义，而不是父类对象
        self.master = master
        self.pack()
        self.createWidget()


    def createWidget(self):
        self.w1 = Text(root, width=40, height=12, bg="gray")
        self.w1.pack()

        self.w1.insert(1.0, "0123456789\nabcdefg")
        self.w1.insert(2.3, "锄禾日当午，汗滴禾下土。谁知盘中餐，粒粒皆辛苦\n")

        Button(self, text="重复插入文本",command=self.insertText).pack(side="left")
        Button(self, text="返回文本", command=self.returnText).pack(side="left")
        Button(self, text="添加组件", command=self.addWidget).pack(side="left")
        Button(self, text="通过tag精确控制文本", command=self.testTag).pack(side="left")

    def insertText(self):
        self.w1.insert(INSERT, 'Gaoqi')
        self.w1.insert(END, '[sxt]')

    def returnText(self):
        print(self.w1.get(1.2, 1.6))
        self.w1.insert(1.8, "gaoqi")
        print("所有文本内容: \n"+self.w1.get(1.0, END))

    def addWidget(self):
        b1 = Button(self.w1, text='爱尚学堂')
        self.w1.window_create(INSERT, window=b1)

    def testTag(self):
        self.w1.delete(1.0,END)
        self.w1.insert(INSERT,"good good study,day day up!\n北京尚学堂\n百战程序员\n百度，搜一下就知道了")
        self.w1.tag_add("good",1.0, 1.9)
        self.w1.tag_config("good", background="yellow", foreground="red")

        self.w1.tag_add("baidu", 4.0, 4.2)
        self.w1.tag_config("baidu", underline=True)
        self.w1.tag_bind("baidu", "<Button-1>", self.webshow)

    def webshow(self,event):
        webbrowser.open("http://www.baidu.com")

if __name__ == '__main__':
    root = Tk()
    root.geometry("450x300+200+300")
    app = Application(master=root)
    root.mainloop()

以上代码存在问题：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

from tkinter import *
import webbrowser

class Application(Frame):

    def __init__(self, master=None):
        super().__init__(master)    # super()代表的是父类的定义，而不是父类对象
        self.master = master
        self.pack()
        self.createWidget()

    def createWidget(self):
        # 修改这里：将父容器从 root 改为 self
        self.w1 = Text(self, width=40, height=12, bg="gray")  # 改为 self
        self.w1.pack()

        self.w1.insert(1.0, "0123456789\nabcdefg")
        self.w1.insert(2.3, "锄禾日当午，汗滴禾下土。谁知盘中餐，粒粒皆辛苦\n")

        Button(self, text="重复插入文本", command=self.insertText).pack(side="left")
        Button(self, text="返回文本", command=self.returnText).pack(side="left")
        Button(self, text="添加组件", command=self.addWidget).pack(side="left")
        Button(self, text="通过tag精确控制文本", command=self.testTag).pack(side="left")

    def insertText(self):
        self.w1.insert(INSERT, 'Gaoqi')
        self.w1.insert(END, '[sxt]')

    def returnText(self):
        print(self.w1.get(1.2, 1.6))
        self.w1.insert(1.8, "gaoqi")
        print("所有文本内容: \n"+self.w1.get(1.0, END))

    def addWidget(self):
        b1 = Button(self.w1, text='爱尚学堂')
        self.w1.window_create(INSERT, window=b1)

    def testTag(self):
        self.w1.delete(1.0, END)
        self.w1.insert(INSERT, "good good study,day day up!\n北京尚学堂\n百战程序员\n百度，搜一下就知道了")
        
        # 添加 good tag
        self.w1.tag_add("good", 1.0, 1.9)
        self.w1.tag_config("good", background="yellow", foreground="red")
        
        # 添加 baidu tag - 这里索引要正确
        self.w1.tag_add("baidu", 4.0, 4.2)  # "百度"两个字
        self.w1.tag_config("baidu", underline=True, foreground="blue")
        self.w1.tag_bind("baidu", "<Button-1>", self.webshow)

    def webshow(self, event):
        webbrowser.open("http://www.baidu.com")

if __name__ == '__main__':
    root = Tk()
    root.geometry("450x300+200+300")
    app = Application(master=root)
    root.mainloop()

Radiobutton 单选按钮

Radiobutton 控件用于选择同一组单选按钮中的一个。

Radiobutton 可以显示文本，也可以显示图像

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

"""测试Radiobutton组件的基本用法，使用面向对象的方式"""

from tkinter import *
from tkinter import messagebox

class Application(Frame):
    
    def __init__(self, master=None):
        super().__init__(master)

        self.master = master
        self.pack()
        self.creareWidget()

    def createWidget(self):
        self.v = StringVar();
        self.v.set("F")

        self.r1 = Radiobutton(root, text="男性", value="M", variable=self.v)
        self.r2 = Radiobutton(root, text="女性", value="F", variable=self.v)

        self.r1.pack(side="left");self.r2.pack(side="left")

        Button(root,text="确定", command=self.confirm).pack(side="left")

    def confirm(self):
        messagebox.showinfo("测试", "选择的性别:"+self.v.get())

if __name__ == '__main__':
    root = Tk()
    root.geometry("400x50+200+300")
    app = Application(master=root)
    root.mainloop()

以上代码也存在一点问题，不能执行

父容器选择：

使用 self 作为父容器

因为 Application 是继承自 Frame 的，所有在类内部创建的组件应该放在这个 Frame 内部，而不是直接放在根窗口 root 上。

代码结构说明：

• 使用 <font style="color:rgb(15, 17, 21);background-color:rgb(235, 238, 242);">self</font> 作为父容器可以让所有组件都在 <font style="color:rgb(15, 17, 21);background-color:rgb(235, 238, 242);">Application</font> 的 Frame 内部，这样布局更清晰，也更符合面向对象的设计。
• <font style="color:rgb(15, 17, 21);background-color:rgb(235, 238, 242);">self.v = StringVar()</font> 创建了一个 StringVar 变量，用于绑定到 RadioButton 组件。当选择不同的 RadioButton 时，<font style="color:rgb(15, 17, 21);background-color:rgb(235, 238, 242);">self.v</font> 的值会自动更新。
• <font style="color:rgb(15, 17, 21);background-color:rgb(235, 238, 242);">self.v.set("F")</font> 设置了默认选中"女性"选项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

"""测试Radiobutton组件的基本用法，使用面向对象的方式"""

from tkinter import *
from tkinter import messagebox

class Application(Frame):

    def __init__(self, master=None):
        super().__init__(master)
        self.master = master
        self.pack()
        self.createWidget()  # 这里拼写错误：creareWidget -> createWidget

    def createWidget(self):
        self.v = StringVar()
        self.v.set("F")

        # 修改这里：将父容器从 root 改为 self
        self.r1 = Radiobutton(self, text="男性", value="M", variable=self.v)
        self.r2 = Radiobutton(self, text="女性", value="F", variable=self.v)

        self.r1.pack(side="left")
        self.r2.pack(side="left")

        Button(self, text="确定", command=self.confirm).pack(side="left")

    def confirm(self):
        messagebox.showinfo("测试", "选择的性别:" + self.v.get())

if __name__ == '__main__':
    root = Tk()
    root.geometry("400x50+200+300")
    app = Application(master=root)
    root.mainloop()

Checkbutton 复选按钮

Checkbutton 控件用于选择多个按钮的情况，Checkbutton 可以显示文本，也可以显示图像

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

"""测试Radiobutton组件的基本用法，使用面向对象的方式"""

from tkinter import *
from tkinter import messagebox

class Application(Frame):

    def __init__(self, master=None):
        super().__init__(master)
        self.master = master
        self.pack()
        self.createWidget()

    def createWidget(self):
        self.codeHobby = IntVar();
        self.videHobby = IntVar()

        print(self.codeHobby.get())
        self.c1 = Checkbutton(self, text="敲代码",
                              variable=self.codeHobby, onvalue=1, offvalue=0)
        self.c2 = Checkbutton(self, text="看视频",
                              variable=self.videHobby, onvalue=1, offvalue=0)

        self.c1.pack(side="left")
        self.c2.pack(side="left")

        Button(self, text="确定", command=self.confirm).pack(side="left")

    def confirm(self):
        if self.videHobby.get() == 1:
            messagebox.showinfo("测试", "看视频，都是正常人有的爱好！你喜欢看什么类型？" )
        if self.codeHobby.get() == 1:
            messagebox.showinfo("测试", "抓获野生程序猿一只，赶紧送给他尚学堂的视频充饥" )

if __name__ == '__main__':
    root = Tk()
    root.geometry("400x50+200+300")
    app = Application(master=root)
    root.mainloop()
    

canvas 画布

canvas 是一个矩形区域，可以放置图形，图像，组件等

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

"""测试canvas组件的基本用法，使用面向对象的方式"""

from tkinter import *
import random


class Application(Frame):

    def __init__(self, master=None):
        super().__init__(master)
        self.master = master
        self.pack()
        self.createWidget()

    def createWidget(self):
        # 创建画布
        self.canvas = Canvas(self, width=300, height=200, bg="lightgreen")
        self.canvas.pack()
        
        # 画线
        line = self.canvas.create_line(10, 10, 30, 20, 40, 50)
        
        # 画矩形
        rect = self.canvas.create_rectangle(50, 50, 100, 100, fill="red")
        
        # 画椭圆
        oval = self.canvas.create_oval(150, 50, 200, 100, fill="blue")

        # 尝试加载图片（如果存在）
        try:
            self.photo = PhotoImage(file="imgs/logo.gif")
            self.canvas.create_image(150, 170, image=self.photo)
        except Exception as e:
            print(f"无法加载图片: {e}")
            # 如果没有图片，画一个替代图形
            self.canvas.create_rectangle(130, 150, 170, 190, fill="yellow")
            self.canvas.create_text(150, 170, text="图片")

        # 按钮
        Button(self, text="画10个矩形", command=self.draw50Recg).pack(side="left")

    def draw50Recg(self):
        colors = ["red", "blue", "green", "yellow", "orange", "purple", "pink"]
        for i in range(0, 10):
            x1 = random.randrange(int(self.canvas["width"]))
            y1 = random.randrange(int(self.canvas["height"]))
            x2 = x1 + random.randrange(20, 50)
            y2 = y1 + random.randrange(20, 50)
            color = random.choice(colors)
            self.canvas.create_rectangle(x1, y1, x2, y2, 
                                         fill=color, 
                                         outline="black", 
                                         width=2)


if __name__ == '__main__':
    root = Tk()
    root.title("Canvas测试")
    root.geometry("400x300+200+300")  # 修正窗口大小
    app = Application(master=root)
    root.mainloop()

布局管理器

一个 GUI 应用程序必然有大量的组件，需要使用 tkinter 提供的布局管理器帮助我们组织，管理在父组件中子组件的布局方式，tkinter 提供了三种管理器：pack，grid，place

grid 布局 管理器

grid 表格布局，采用表格结构组织组件，子组件的位置由行和列的单元格来确定，并且可以跨行和跨列，从而实现复杂的布局

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

"""计算器软件界面的设计"""

from tkinter import *
import random


class Application(Frame):

    def __init__(self, master=None):
        super().__init__(master)
        self.master = master
        self.pack()
        self.createWidget()

    def createWidget(self):
        """通过grid布局实现计算器的界面"""
        btnText = (("MC", "M+", "M-", "MR"),
                   ("C", "±", "/", "×"),
                   (7,8,9,"-"),
                   (4,5,6,"+"),
                   (1,2,3,"="),
                   (0,"."))

        Entry(self).grid(row=0, column=0, columnspan=4,pady=10)

        for rindex,r in enumerate(btnText):
            for cindex,c in enumerate(r):
                Button(self, text=c,width=2).grid(row=rindex+1,column=cindex,sticky=NSEW)

if __name__ == '__main__':
    root = Tk()
    root.geometry("200x200+200+300")
    app = Application(master=root)
    root.mainloop()

pack 布局管理器

pack 按照组件的创建顺序将子组件添加到父组件中，按照垂直或者水平的方向自然排布，如果不指定任何选项，默认在父组件中自顶向下垂直添加组件

pack 是代码量最少，最简单的一种，可以用于快速生成界面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#coding=utf-8
#测试pack布局管理

from tkinter import *

root = Tk()
root.geometry("700x200")

f1 = Frame(root)
f1.pack()
f2 = Frame(root);f2.pack()

btnText = ("流行风", "中国风","日本风","重金属","轻音乐")

for txt in btnText:
    Button(f1,text=txt).pack(side="left",padx="10")

for i in range(1,20):
    Label(f2,width=5,height=10,borderwidth=1,relief="solid",
          bg="black" if i%2==0 else "white").pack(side="left",padx=2)

root.mainloop()

place 布局管理器

place 布局管理器可以通过坐标精确控制组件的位置，适用于一些布局更加灵活的场景

1
2
3
4
5
6
7
8
9
10
11
12
13

# coding=utf-8
from tkinter import *

root = Tk()
root.geometry("500x300")

f1 = Frame(root,width=200,height=200,bg="green")
f1.place(x=30,y=30)

Button(root,text="尚学堂").place(relx=0.2, x=100,y=20,relheight=0.5,relwidth=0.2)
Button(f1,text="百战程序员").place(relx=0.6,rely=0.7)
Button(f1,text="高琦老师").place(relx=0.5,rely=0.2)
root.mainloop()

lambda 表达式–事件传参应用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# coding=utf-8
# 测试command属性绑定事件，测试lambda表达式帮助传参
from tkinter import *

root = Tk()
root.geometry("270x50")


def mouseTest1():
    print("command方式，简单情况：不涉及获取event对象，可以使用")


def mouseTest2(a, b):
    print("a={0},b={1}".format(a, b))


Button(root, text="测试command1",
       command=mouseTest1).pack(side="left")

Button(root, text="测试command2",
       command=lambda:mouseTest2("gaoqi", "xixi")).pack(side="left")

root.mainloop()

在free命令中显示的buffer和cache，它们都是占用内存：

buffer : 作为buffer cache的内存，是块设备的读写缓冲区，更靠近存储设备，或者直接就是disk的缓冲区。

cache: 作为page cache的内存, 文件系统的cache，是memory的缓冲区。

如果cache 的值很大，说明cache住的文件数很多。如果频繁访问到的文件都能被cache住，那么磁盘的读IO 必会非常小。

page cache（页面缓存）

Page cache 也叫页缓冲或文件缓冲，是由好几个磁盘块构成，大小通常为4k，在64位系统上为8k，构成的几个磁盘块在物理磁盘上不一定连续，文件的组织单位为一页， 也就是一个page cache大小，文件读取是由外存上不连续的几个磁盘块，到buffer cache，然后组成page cache，然后供给应用程序。

Page cache在linux读写文件时，它用于缓存文件的逻辑内容，从而加快对磁盘上映像和数据的访问。具体说是加速对文件内容的访问，buffer cache缓存文件的具体内容——物理磁盘上的磁盘块，这是加速对磁盘的访问

Buffer cache（块缓存）

Buffer cache 也叫块缓冲，是内存对物理磁盘上的一个磁盘块进行的缓冲，其大小为通常为1k，磁盘块也是磁盘的组织单位。设立buffer cache的目的是为在程序多次访问同一磁盘块时，减少访问时间。系统将磁盘块首先读入buffer cache，如果cache空间不够时，会通过一定的策略将一些过时或多次未被访问的buffer cache清空。程序在下一次访问磁盘时首先查看是否在buffer cache找到所需块，命中可减少访问磁盘时间。不命中时需重新读入buffer cache。对buffer cache的写分为两种，一是直接写，这是程序在写buffer cache后也写磁盘，要读时从buffer cache上读，二是后台写，程序在写完buffer cache后并不立即写磁盘，因为有可能程序在很短时间内又需要写文件，如果直接写，就需多次写磁盘了。这样效率很低，而是过一段时间后由后台写，减少了多次访磁盘的时间。

Buffer cache是由物理内存分配，Linux系统为提高内存使用率，会将空闲内存全分给buffer cache ，当其他程序需要更多内存时，系统会减少cache大小。

Swap space（交换空间）

Swap space交换空间，是虚拟内存的表现形式。系统为了应付一些需要大量内存的应用，而将磁盘上的空间做内存使用，当物理内存不够用时，将其中一些暂时不需的数据交换到交换空间，也叫交换文件或页面文件中。做虚拟内存的好处是让进程以为好像可以访问整个系统物理内存。因为在一个进程访问数据时，其他进程的数据会被交换到交换空间中。

Swap cache（交换缓存）

swap cache，它表示交换缓存的大小。Page cache是磁盘数据在内存中的缓存，而swap cache则是交换分区在内存中的临时缓存。

Page cache和Buffer cache的区别

磁盘的操作有逻辑级（文件系统）和物理级（磁盘块），这两种Cache就是分别缓存逻辑和物理级数据的。

假设通过文件系统操作文件，那么文件将被缓存到Page Cache，如果需要刷新文件的时候，Page Cache将交给Buffer Cache去完成，因为Buffer Cache就是缓存磁盘块的。

也就是说，直接去操作文件，那就是Page Cache区缓存，用dd等命令直接操作磁盘块，就是Buffer Cache缓存的东西。

Page cache实际上是针对文件系统的，是文件的缓存，在文件层面上的数据会缓存到page cache。文件的逻辑层需要映射到实际的物理磁盘，这种映射关系由文件系统来完成。当page cache的数据需要刷新时，page cache中的数据交给buffer cache，但是这种处理在2.6版本的内核之后就变的很简单了，没有真正意义上的cache操作。

Buffer cache是针对磁盘块的缓存，也就是在没有文件系统的情况下，直接对磁盘进行操作的数据会缓存到buffer cache中，例如，文件系统的元数据都会缓存到buffer cache中。简单说来，page cache用来缓存文件数据，buffer cache用来缓存磁盘数据。在有文件系统的情况下，对文件操作，那么数据会缓存到page cache，如果直接采用dd等工具对磁盘进行读写，那么数据会缓存到buffer cache。

Buffer(Buffer Cache)以块形式缓冲了块设备的操作，定时或手动的同步到硬盘，它是为了缓冲写操作然后一次性将很多改动写入硬盘，避免频繁写硬盘，提高写入效率。

Cache(Page Cache)以页面形式缓存了文件系统的文件，给需要使用的程序读取，它是为了给读操作提供缓冲，避免频繁读硬盘，提高读取效率。

综合监控工具 glances

实时监控 CPU，内存，磁盘，网络等指标

支持彩色显示和动态刷新

可通过 Web 界面远程访问

低资源占用，适合长期运行

支持插件扩展功能

1
2

sudo apt update
sudo apt install glances

1
2

sudo yum install epel-release
sudo yum install glances

1

pip install glances

-b: 以Byte为单位显示网卡数据速率

-d: 关闭磁盘I/O模块

-f /path/to/somefile: 设定输入文件位置

-o {HTML|CSV}：输出格式

-m: 禁用mount模块

-n: 禁用网络模块

-t #: 延迟时间间隔

-1：每个CPU的相关数据单独显示

1
2
3
4
5
6
7
8
9

glances -t 2          # 设置刷新间隔为2秒（默认1秒）
glances --disable-plugins fs,ip  # 禁用文件系统和IP插件
glances --percpu      # 显示每个CPU核心的使用情况
glances --csv         # CSV格式输出
glances --json        # JSON格式输出
glances --export influxdb  # 输出到InfluxDB数据库
glances -s            # 启动glances服务器模式
glances -c @192.168.1.100  # 连接到远程glances服务器
glances -w            # 启用Web服务器模式（默认端口61208）

实例：

1
2
3
4
5
6
7
8
9

#监控特定进程
glances --process-name nginx  # 只监控nginx相关进程
#生成系统快照
glances --export csv --export-csv-file /tmp/system_stats.csv
#设置告警阈值
glances --alert cpu:80,mem:90  # CPU超过80%或内存超过90%时告警
#远程Web监控
glances -w &                   # 启动Web服务
firefox http://localhost:61208 # 在浏览器中查看

glances 配置文件

glances 的配置文件通常位于 <font style="color:rgb(51, 51, 51);background-color:rgb(250, 252, 253);">~/.config/glances/glances.conf</font>，你可以通过编辑这个文件来永久修改默认设置。

信号发送 kill

内部命令，可用来向进程发送控制信号，以实现对进程管理，如果不指定信号，默认会发送 TERM 信号（15），即终止。 若仍无法终止该程序，可使用 SIGKILL(9) 信息尝试强制删除程序。每个信号对应一个数字，信号名称以 SIG 开头

用于终止正在运行的进程，

kill -l /trap -l：显示当前系统可用信号

1
2
3

kill                #结束指定PID的进程
killall                #根据进程名杀死进程
pkill                #同样是根据进程名杀死进程

常用信号

1) SIGHUP 无须关闭进程而让其重读配置文件

2) SIGINT 中止正在运行的进程；相当于Ctrl+c

3) SIGQUIT 相当于ctrl+\

9) SIGKILL 强制杀死正在运行的进程,可能会导致数据丢失,慎用!

15) SIGTERM 终止正在运行的进程，默认信号

18) SIGCONT 继续运行

19) SIGSTOP 后台休眠

也可以在终端中使用组合键发送信号。例如，Ctrl+C 发送 SIGINT信号，Ctrl+S 发送 SIGSTOP 信号，Ctrl+Q 发送 SIGCONT 信号。

可以使用trap命令处理Bash中的信号。例如，在脚本中添加trap date SIGINT，脚本会打印收到 SIGINT 的日期。

SIGINT

SIGINT 是按下 Ctrl+C 时发出的信号。默认操作是终止进程。

SIGTERM 和 SIGQUIT

SIGTERM 和 SIGQUIT 信号旨在终止进程。在这种情况下，特别要求结束进程。当使用 kill 命令时，SIGTERM 是默认信号。

当发送 SIGTERM 时，进程有时会在退出前执行一个清理例程。还可以处理 SIGTERM，在退出前请求确认。编写一个名为handle_sigterm.sh 的脚本，只有当用户发送两次信号时才终止：

SIGKILL

当进程收到 SIGKILL 信号时，它就会被终止。这是一个特殊的信号，因为它不能被忽略，也不能改变它的行为。

使用该信号强制终止进程。需要小心，因为进程将无法执行任何清理例程。

使用 SIGKILL 的一种常见方法是先发送 SIGTERM。会给进程一些时间来终止，也可能会发送几次 SIGTERM。如果进程没有自行结束，就需要发送SIGKILL 终止它

重写前面的示例，尝试处理 SIGKILL 并请求确认：

SIGINT 与 SIGTERM、SIGQUIT 和 SIGKILL 的关系

SIGINT、SIGTERM、SIGQUIT 和 SIGKILL 的默认操作是终止进程。不过，SIGTERM、SIGQUIT 和 SIGKILL 被定义为终止进程的信号，而SIGINT 则被定义为用户请求的中断。

特别是，如果发送 SIGINT（或按 Ctrl+C），根据进程和情况的不同，它的行为也会不同。因此，不应该完全依赖 SIGINT 来完成进程。由于 SIGINT 是用户发送的信号，进程之间通常使用其他信号进行通信。

例如，父进程通常会向其子进程发送 SIGTERM 以终止它们，即使 SIGINT也有同样的效果。 在 SIGQUIT 的情况下，它会生成核心转储，这对调试非常有用。

在 SIGKILL 之外，应该选择 SIGTERM 来终止进程。SIGTERM 是首选方式，因为进程有机会优雅地终止。

由于进程可以覆盖 SIGINT、SIGTERM 和 SIGQUIT 的默认操作，因此可能出现这三个信号都无法结束进程的情况。此外，如果进程被挂起，它可能不会响应任何这些信号。在这种情况下，只能通过 SIGKILL 来终止进程。

读取最大线数

内核参数 threads-max 控制着线程的最大数量

该参数在 /proc/sys/kernel/threads-max 文件中定义。

sysctl 命令也可以获取线程最大值

kernel.pid_max 和 vm.max_map_count 还指定了另外两个限制，它们也会在峰值负载时阻止新线程的创建。

pid_max 参数指定了 PID 的最大值：

上面的 kernel.pid_max 值 4194304 意味着内核最多可同时执行 4194304 个进程。

max_map_count 参数指定一个进程可拥有的虚拟内存区域（VMA）的最大数量：

如果一个函数要有多个返回值，该如何书写代码？

1
2
3
4
5

def test_return():
 return 1,2
x,y = test_return()
print(x)  #结果1
print(y)  #结果2

按照返回值的顺序写对应顺序的多个变量接收即可

变量之间用逗号隔开

支持不同类型的数据return

1
2
3
4
5
6
7
8
9
10
11

"""
演示函数的多返回值示例
"""
#演示使用多个变量，接收多个返回值
def test_return():
    return 1,2,3

x,y,z = test_return()
print(x)
print(y)
print(z)

其中 1，2，3 的类型不受限，需要注意顺序问题，第一个数值对应第一个类型，依次类推

1
2
3
4
5
6
7
8
9
10
11

"""
演示函数的多返回值示例
"""
#演示使用多个变量，接收多个返回值
def test_return():
    return 1,"hello",True

x,y,z = test_return()
print(x)
print(y)
print(z)

位置参数

调用函数时根据函数定义的参数位置来传递参数

1
2
3
4
5

def user_info(name,age,gender):
 print(f'您的名字时{name},年龄是{age},性别是{gender}')


     user_info('TOM',20,'男')

注意：

传递的参数和定义的参数的顺序及个数必须一致

关键字参数

函数调用时通过”键=值“形式传递参数

可让函数更加清晰，容易使用，同时也清除了参数的顺序需求

1
2
3
4
5
6
7
8

def user_info(name,age,gender):
    print(f"您的名字是：{name}，年龄是：{age}，性别是：{gender}")
#关键字传参
user_info(name="小明",age=20,gender="男")
#可以不按照固定顺序
user_info(age=20,gender="男",name="小明")
#可以和位置参数混用，位置参数必须在前，且匹配参数顺序
user_info("小明",age=20,gender="男")    

注意：

函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def user_info(name,age,gender):
    print(f"您的名字是：{name}，年龄是：{age}，性别是：{gender}")
#位置参数 - 默认使用形式
user_info('小明',20,'男')
#关键字传参
user_info(name="小王",age=11,gender="女")
#可以不按照固定顺序
user_info(age=10,gender="女",name="小文")
#可以和位置参数混用，位置参数必须在前，且匹配参数顺序
user_info("敏婕",age=9,gender="女")

#缺省参数（默认值）

#不定长 - 位置不定长，*号

#不定长 - 关键字不定长，**号

缺省参数

缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）

当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值

1
2
3
4
5
6

def user_info(name,age,gender='男'):
    print(f'您的名字是：{name}，年龄是：{age}，性别是：{gender}')


user_info('TOM',20)
user_info('Rose',18,'女')

注意：

函数调用时，如果为缺省参数传值则修改默认参数值，否则使用这个默认值

不定长参数

也叫可变参数，用于不确定调用的时候会传递多少个参数（不传参也可以）的场景

当调用函数时不确定参数个数时，可以使用不定长参数

类型：

位置传递

1
2
3
4
5
6
7
8

def user_info(*args):
    print(args)


#('TOM',)
user_info('TOM')    
#('TOM',18)
user_info('TOM',18)

注意：

传进的所有参数都会被 args 变量收集，它会根据传进参数的位置合并为一个元组（tuple），args 是元组类型，这就是位置传递

位置不定长传递以*号标记一个形式参数，以元组的形式接受参数，形式参数一般命名为 args

1
2
3
4
5
6
7

#不定长 - 位置不定长，*号
#不定长定义的形式参数会作为元组存在，接收不定长数量的参数传入
def user_info(*args):
print(f"args参数的类型是：{type(args)},内容是:{args}")

    user_info(1,2,3,'小明','男孩')
    #不定长 - 关键字不定长，**号

关键字传递

1
2
3
4
5
6

def user_info(**kwargs):
    print(kwargs)


#('name': 'TOM', 'age': 18, 'id': 110)
user_info(name='TOM', age=18, id=110)

注意：

参数是”键=值“形式的形式的情况下，所有的”键=值“都会被 kwargs 接受，同时会根据”键=值“组成字典。

关键字不定长传递以**号标记一个形式参数，以字典的形式接受参数，形式参数一般命名为 kwargs

1
2
3
4
5

#不定长 - 关键字不定长，**号
def user_info(**kwargs):
    print(f"args参数的类型是：{type(kwargs)},内容是:{kwargs}")

user_info(name="小王", age=11, gender="女")

匿名函数

函数作为参数传递

如下代码：

1
2
3
4
5
6
7
8

def test_func(compute):
    result = compute(1,2)
    print(result)

def compute(x,y):
  return x + y

test_func(compute)     #结果：3

函数 compute 作为参数，传入了 test_func 函数中使用

• test_func 需要一个函数作为参数传入，这个函数需要接收 2 个数字进行计算，计算逻辑由这个被传入函数决定
• compute 函数接收 2 个数字对其进行计算，compute 函数作为参数，传递了 test_func 函数使用
• 最终，在 test_func 函数内部，由传入的 compute 函数，完成了对数字的计算操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14

"""
演示函数作为参数传递
"""

#定义一个函数，接收另一个函数作为传入参数
def test_func(compute):
    result = compute(1,2)  #确定compute是函数
    print(f"compute参数的类型是：{type(compute)}")
    print(f"计算结果：{result}")
#定义一个函数，准备作为参数传入另一个函数
def compute(x,y):
    return x + y
#调用，并传入函数
test_func(compute)

将函数传入的作用在于：传入计算逻辑，而非传入数据

lambda 匿名函数

函数的定义中

• def 关键字，可以定义带有名称的函数
• lambda 关键字，可以定义匿名函数（无名称）

有名称的函数可以基于名称重复使用

无名称的匿名函数只可临时使用一次

匿名函数定义语法

**lambda **传入参数：函数体（一行代码）

• lambda 是关键字，表示定义匿名函数
• 传入参数表示匿名函数的形式参数，如：x，y 表示接收 2 个形式参数
• 函数体，就是函数的执行逻辑，要注意：只能写一行，无法书写多行代码

1
2
3
4
5
6
7
8
9
10

"""
演示lambda匿名函数
"""

#定义一个函数，接受其他函数输入
def test_func(compute):
    result = compute(1,2)
    print(f"结果：{result}")
#通过lambda匿名函数的形式，将匿名函数作为参数传入
test_func(lambda x,y: x + y)

注意：

• 匿名函数用于临时构建一个函数，只能用一次的场景
• 匿名函数的定义中，函数体只能写一行代码，如果函数体要写多行代码，不可用 lambda 匿名函数，应使用 def 定义带名函数

map 函数

map（）函数是一个内置的高阶函数

参数 1：传入一个函数，这个函数可以是内置的，也可以是自己定义，也可以是匿名函数

参数 2：是可迭代对象，如列表，字符串等等

该函数返回一个 map 对象，是个迭代器

注意不是列表不能直接输出，可以通过 for 循环或 list（）来显示

map 函数将 iterable 中的每一个元素执行一遍 function，结果以 map 对象的形式返回

注意，iterable 后还有省略号，即可以传多个 iterable，如果有额外的 iterable 参数，并行的从这些参数中取元素，并调用 function

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

def square(x):
    return X*X
a = map(square,[1,2,3])
print(a)
print(list(a))
#map返回的实际上是一个map对象
#也可以通过for循环来取出内容
def square(x):
    return X*X
a = map(square,[1,2,3])
ls = []
for i in a:
    ls.append(i)
print(ls)
#也可以使用推导式
def square(x):
    return X*X
a = map(square,[1,2,3])
ls = [item for item in a] 
print(ls)

python 使用内置函数 open（）打开文件，创建 file 对象，在系统中，只有存在 file 对象后，用户才能对文件进行相应的操作

• 文件名（name）为必选参数,name:是要打开的目标文件名的字符串（可以包含文件所在的具体路径）
• 模式（mode）和缓冲（buffering）参数是可选的，mode：设置打开文件的模式（访问模式）：只读，写入，追加等
• 该函数返回一个文件对象
• encoding：编码格式（推荐使用 UTF-8）

模式参数组合及其描述

写模式打开一个指定的文件（C:\Users\test.txt)

f 是一个文件对象，它与指定的文件建立了关联，很多文献称 f 为文件描述符

读取的文件与程序在相同文件夹中，直接提供文件名即可

以读模式打开文件时，文件必须存在，否则会引发异常

以写模式打开一个文件时，如果输出文件已经存在，那么它在写入新数据之前会被清空；如果文件不存在，会创建一个空文件

close（）关闭文件对象

1
2
3
4

f = open("python.txt", "r")
f.close()
#最后通过close，关闭文件对象，也就是关闭对文件的占用
#如果不调用close，同时程序没有停止运行，那么这个文件将一直被python程序占用

with open 语法

1
2
3
4

with open("python.txt", "r") as f:
    f.readlines()
#通过在with open的语句块中对文件进行操作
#可以在操作完成后自动关闭close文件，避免遗忘掉close方法

案例演示

1
2
3
4
5
6

#1，打开文件
f = open('python.txt','w')
#2,文件写入
f.write('hello world')
#3,内容刷新
f.flush()

注意：

• 直接调用 write，内容并未真正写入文件，而是会积攒在程序的内存中，称之为缓冲区
• 当调用 flush 的时候，内容会真正写入文件

读和写

1，read（）方法，语法格式如下：

size——从文件中读取的字节数，如果未指定则读取文件的全部信息

返回值为从文件中读取的字符串

2，write（）方法，语法格式如下；

write（）方法将字符串写入一个打开的文件

write（）方法不会自动在字符串的末尾添加换行符（‘\n’)，需要人为在字符串末尾添加换行符，

返回值：写入的字符数或字节数

会读文件

1
2
3

f = open("./data.txt")
print(f.read()) #对文件的操作
f.close()   #关闭文件，释放资源

1
2

with open("./data.txt") as f:
print(f.read())  #对文件的操作

with 后面跟上 open 函数的调用

as 后面跟上文件对象的命名，冒号，缩进的代码块放上对该文件对象的操作，这样在缩进的内容执行完毕后，文件就会被自动关闭，写法二能让代码更加简洁，不用单独调用 close 方法了

readline 方法

用于读取文件中所有行，直到结束符 EOF，并返回列表，包括所有行的信息，该列表可以由 python 的“for…in…"结构进行处理

1
2
3
4
5
6
7
8
9

f = open("./data.txt", "r", encoding="utf-8")
line = f.readline() 
    #读第一行
while line != "":   
#判断当前行是否为空
    print(line)   
        #不为空则打印当前行
    line = f.readline()  
        #读取下一行

readlines 方法

1
2
3

f = open("./data.txt", "r",encoding="utf-8")
    #readlines会读全部文件内容，并把每行作为列表元素返回
    print(f.readlines())

读取行

• 调用 read（）会一次性读取文件的全部内容，如果文件有 10G，太耗内存，所以，保险起见，可反复调用 read（size）方法，每次最多读取 size 个字节的内容
• 调用 readline（）可以每次读取一行内容，调用 readlines（）一次读取所有内容并按行返回 list，因此，要根据需要决定怎么调用
• 如果文件很小，read（）一次性读取最方便；如果不能确定文件大小，反复调用 read（size）比较保险；如果是配置文件，调用 readlines（）最方便

unittest.TestCase 类的常见测试方法

操作汇总

创建目录

mkdir（）方法，语法格式如下：

newdir——新建的目录名称，必须要带目录的完整路径

注意：要使用目录操作相关的内置函数，必须先导入 os 模块，然后才可以调用相关的功能

os.mkdir()方法应用如下所示：

显示当前工作目录

getcwd（）方法，语法格式如下：

改变目录

chdir（）方法，语法格式如下：

chdir——要改变的新的工作目录名称，需要带目录的完整路径

删除目录

rmdir（）方法，语法格式如下：

rmdir——要删除的目录名称，需要带目录的完整路径

OS 模块提供的与目录相关的函数

os.path 模块提供的与目录相关的函数

os.stat(path)获取基本信息

返回值是一个对象，通过这个对象的一些属性就可以获取这个文件的基本信息

基本语法

st_ctime 获取文件的创建日期(状态变化时间）

st_mtime 获取文件的修改日期

st_size 获取文件的大小

st_mode 获取文件的保护模式

st_ino 获取文件的索引号

st_atime 获取文件的最后一次访问时间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import os 
def formatTime(longtime):
    '''格式化时间的函数'''
    import time
    return time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(longtime))
def formatByte(number)
    '''格式化文件大小的函数'''
    for (scale,label) in [(1024*1024*1024,"GB"),(1024*1024,"MB"),(1024,"KB")]:
        if number>=scale: #大于等于1KB
            return "%.2f %s" %(number*1.0/scale,lable)
        elif number == 1:
            return "1 字节"
        else:  #小于1KB
            byte = "%.2f" %(number or 0)
        return (byte[:-3] if byte.endswith(".00") else byte) + "字节"
            
fileino = os.stat("mr.png") #获取文件的基本信息
print("文件完整路径：",os.path.abspat("mr.png"))  #获取文件的完整路径
#输出文件的基本信息：
print("索引号：",fileinfo.st_ino)
print("设备名：",fileinfo.st_dev)
print("文件大小：",fileinfo.st_size)
print("最后一次访问时间：",fileinfo.st_atime)
print("最后一次修改时间：",fileinfo.st_mtime)
print("最后一次状态变化的时间：",fileinfo.st_ctime)

使用递归算法遍历目录下所有文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import os
allfile = []

def getFiles(path,level):
    childFiles = os.listdir(path)
    for file in childFiles:
        filepath = os.path.join(path,file)
        if os.path.isdir(filepath):
            getFiles(filepath,level+1)
        allfile.append("\t"*level+filepath)

getFiles(os.getcwd(),0)

for f in reversed(allfile):
    print(f)

扣子的知识库功能支持上传和存储外部知识内容，并提供了多种检索能力，扣子的知识能力可以解决大模型幻觉，专业领域知识不足的问题，提升大模型回复的准确率

扣子的知识库功能包括两个能力

一是存储和管理外部数据的能力

二是增强检索的能力

• 数据管理与存储

扣子支持从多种数据源例如本地文档，在线数据，Notion，飞书文档等渠道上传文本和表格数据。上传后，扣子可将知识内容自动切分为一个个内容片段进行存储，同时支持用户自定义内容分片规则，例如通过分段标识符，字符长度等方式进行内容分割。

• 增强检索

扣子的知识功能还提供了多种检索方式来对存储的内容片段进行检索，例如使用全文检索通过关键词进行内容片段检索和召回。大模型会根据召回的内容片段生成最终的回复内容

知识库类型与限制

使用知识库功能的第一步就是上传知识内容，知识内容分为如下三种知识类型:

def 函数名（传入参数）:

函数体

return 返回值

使用步骤

先定义函数

后调用函数

注意事项

参数不需要，可以省略

返回值不需要，可省略

函数的定义

一个程序可以按不同功能实现拆分成不同模块，而函数就是能实现某一部分功能的代码块。

python 中定义一个函数要使用 def 语句，依次写出函数名，括号，括号内参数和冒号，然后在缩进块中编写函数体，函数的返回值用 return 语句返回

注意：python 是靠缩进块来标明函数的作用域范围的，缩进块内是函数体，这和其他高级编程语言是有区别的，比如：C/C++/java/R 语言大括号{ }内的是函数体

函数中传入参数

传入参数的功能是：在函数进行计算的时候，接受外部（调用时）提供的数据

使用方式

1
2
3

def add(x,y)
    result = x + y
    print("f{x} + {y}的结果是：{result}")

注意事项

函数定义中的参数称之为形式参数

函数调用中的参数称之为实际参数

函数的参数数量不限，使用逗号分隔开

传入参数的时候，要和形式参数一 一对应，逗号隔开

函数的返回值

如图代码，定义两数相加的函数功能，完成功能后，会将相加的结果返回给函数调用者，所以，变量 r 接收到了函数的执行结果

综上所述，返回值就是程序中函数完成事情后，最后给调用者的结果

返回值的语法

1
2
3
4

def 函数（参数）：
函数体
return返回值
变量=函数（参数）

变量就能接收到函数的返回值

语法就是：通过 return 关键字，就能向调用者返回数据

应用语法

使用关键字：return 来返回结果

注意：

函数体在遇到 return 后就结束了，所以写在 return 后的代码不会执行

None 类型

其类型是：<class ‘NoneType’>

无返回值的函数，实际上就是返回了：None 这个字面量

None 表示：空的，无实际意义的意思

函数返回的 None 就表示这个函数没有返回什么有意义的内容

也就是返回了空的意思

应用场景

1，用于函数无返回值上

2，用在 if 判断上

（1），在 if 判断上，None 等同于 False

（2），一般用于在函数中主动返回 None，配合 if 判断做相关处理

3，用于声明无内容的变量上

定义变量，但暂时不需要变量有具体值，可以用 None 来代替

1
2

#暂不赋予变量具体值
name = None

函数如何返回 None

1，不使用 return 语句即返回 None

2，主动 return None

说明文档

函数是纯代码语言，想要理解其含义，就需要一行行的去阅读理解代码，效率比较低

我们可以给函数添加说明文档，辅助理解函数的作用

1
2
3
4
5
6
7
8
9

def func(x,y):
"""
    函数说明
    ：param x：形参x的说明
    ：param y：形参y的说明
    ：return：返回值的说明
    """
    函数体
    return返回值

通过多行注释的形式，对函数进行说明解释

内容应写在函数体之前

：param 用于解释参数

：return 用于解释返回值

函数的嵌套

函数嵌套指的是一个函数里面又调用了另外一个函数

·

执行流程：

函数 A 中执行到调用函数 B 的语句，会将函数 B 全部执行完成后，继续执行函数 A 的剩余内容

变量

局部变量

变量作用域指的是变量的作用范围（变量在哪里可用，在哪里不可用）

主要分为两类：局部变量和全局变量

所谓局部变量是定义在函数体内部的变量，即只在函数体内部生效

变量 A 是定义在“testA”函数内部的 变量，在函数外部访问则立即报错

局部变量的作用：在函数内部，临时保存数据，即当函数调用完成后，则销毁局部变量

全局变量

指的是在函数体内，外都能生效的变量

使用 global 关键字将函数内定义的变量声明为全局变量

位置参数和关键字参数

位置参数调用参数时，传入参数值按照位置顺序依次赋给参数，这样的参数称为位置参数，如下所示代码 ：

关键字参数函数调用时，通过参数名指定需要赋值的参数。通常我们在调用一个函数的时候，如果参数有多个，我们常常会混洗一个参数的顺序，达不到我们希望的效果。在 python 中引入关键字参数就可解决这个潜在的问题，如下所示代码：

例题

主菜单效果

查询余额效果

存，取款效果

1.定义一个全局变量：money，用来记录银行卡余额（默认 5000000）

2，定义一个全局变量：name ，用来记录客户姓名（启动程序时输入）

3.定义如下的函数：

• 查询余额函数
• 存款函数
• 取款函数
• 主菜单函数

要求：

• 程序启动后要求输入客户姓名
• 查询余额，存款，取款后都会返回主菜单
• 存款，取款后，都应显示一下当前余额
• 客户选择退出或输入错误，程序会退出，否则程序会一直运行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

"""
演示函数综合案例开发
"""
#定义全局变量money name
money = 5000000
name = None

#要求客户输入姓名
name = input("请输入您的姓名：")
#定义查询函数
def query(show_header):
  if show_header:
      print("----------------查询余额-----------------------")
  print(f"{name},您好，您的余额剩余：{money}元")


#定义存款函数
def saving(num):
  global money   #money在函数内部定义为全局变量
  money += num
  print("----------------存款-----------------------")
  print(f"{name},您好，您存款{num}元成功")

  #调用query函数查询余额
  query(False)

#定义取款函数
def get_money(num):
  global money
  money -= num
  print("----------------取款-----------------------")
  print(f"{name},您好，您取款{num}元成功")

#调用query函数查询余额
query(False)
#定义主菜单函数
def main():
  print("----------------主菜单-----------------------")
  print(f"{name},您好，欢迎来到黑马银行AMT。请选择操作：")
  print("查询余额\t[输入1]")
  print("存款\t\t[输入2]")
  print("取款\t\t[输入3]")   #通过\t制表符对齐输出
  print("退出\t\t[输入4]")
  return input("请输入您的选择：")


#设置无限循环，确保程序不退出
while True:
  keyboard_input = main()
  if keyboard_input == "1":
    query(True)
    continue  #通过continue继续下一次循环，一进来就是回到了主菜单
  elif keyboard_input == "2":
    num = int(input("您想要存多少钱？请输入："))
    saving(num)
    continue
  elif keyboard_input == "3":
    num = int(input("您想要取多少钱？请输入："))
    get_money(num)
    continue
  else:
    print("程序退出啦")
    break    #通过break退出循环

递归函数

递归可以把一个大问题分解成更小的同类型问题，直到问题小到可以被直接解决，继而层层解决掉原本的大问题

递归函数需要一个终止条件，当满足某个终止条件时，函数就不再递归调用了

为什么无限调用会导致程序崩溃呢？

因为每次调用函数都会在内存新增一个栈帧，用来保存函数内部的状态，比如函数局部变量的值等等，因为函数各个都是相互独立的，但栈空间是有限的，如果我们只是一味调用函数而不返回，一旦栈被填满后，就会导致栈溢出。程序会直接中止运行

基本情况（Base case）：用来决定递归的终止条件

LEGB 规则

python 在查找“名称”时，是按照 LEGB 规则查找的：

Local 指的是函数或者类的方法内部

Enclosed 指的是嵌套函数（一个函数包裹另一个函数，闭包）

Global 指的是模块中的全局变量

Built in 指的是 python 为自己保留的特殊名称