MCorazon

基础字符匹配

预定义字符类

边界匹配

重复匹配

贪婪模式（默认）：尽可能多匹配（a.*b 在 “axbxb” 中匹配整个字符串）。
非贪婪模式：加 ? 尽可能少匹配（a.*?b → “axb”）。

分组与捕获

注：在真实大数据场景中，非捕获分组通常更快更可靠。

选择与断言

转义与特殊字符

• 元字符需转义：\.、\*、\(、\)、\[、\\ 等。

• 特殊序列：

  • \t：制表符
  • \n：换行符
  • \r：回车符
  • \x21：十六进制字符（如 !）
  • \u4E00：Unicode 字符（如 “一”）

标志（Flags）

常用正则示例

邮箱验证：

1

^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

URL 提取：

1

https?://[^\s/$.?#]+\.[^\s]+

日期匹配（YYYY-MM-DD）：

1

\d{4}-\d{2}-\d{2}

中文汉字：

1

[\u4e00-\u9fa5]

工具与学习资源

• 在线测试工具：

  • Regex101
  • RegExr

• 学习资料：

  • 《精通正则表达式》（Jeffrey Friedl）
  • MDN 正则文档

掌握正则表达式可大幅提升文本处理效率！建议从实际案例入手练习，逐步熟悉复杂语法。

本文参考：

Python概述

pycharm常用快捷键：

标识符与关键字：

标识符

标识符就是一个名字，就好像每个人都有自己的名字；主要作用是作为程序中变量、函数、类、模块以及其他对象的调用名称。

Python中标识符的命名要遵守一定的命名规则：

• 标识符由字母、下划线和数字组成，但不能以数字开头。

• 标识符不能和 Python中关键字等相同。

• 标识符严格区分大小写，例：Corazon和corazon是不同标识符。

• 以下划线开头标识符往往有特殊含义。

关键字

关键字就是Pytnon内部已经定义好的具有特殊意义的标识符，开发人员不能重复定义。

Python3的关键字可以通过keyword模块的变量kwlist查看：

1
2
3
4
5
6
7
8

# 打印关键字列表
import keyword
print(keyword.kwlist)
# 关键字输出结果
['False', 'None', 'True', '__peg_parser__','and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

# 查看关键字帮助
print(help("if"))

定义变量

1

变量名 = 数据

等号表示赋值运算符，两端有空格是开发规范，可以没有。

定义变量示例：

1
2
3
4
5
6
7
8
9

name  =  "Corazon"
age = 35
is_man = True 

# 打印单个变量值，print()是一个输出函数，类似Linux里echo
print(name)
print(age)
# 打印多个变量值,多个变量用逗号隔开
print(name, age, is_man)

注释

注释是编写程序时，程序员对一个语句、程序段、函数等的解释或提示，可提高程序代码可读性；

合理的代码注释应该占源代码的1/4左右，注释内容不会被解释器执行。

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

# 单行注释信息：以#号开头，后面留一个空格
# 这里就是单行注释，以#开头,后面整行都不会被解释器执行
print("I am Corazon teacher.")  # 表示打印输出
-- 在程序尾部注释，“#”前至少有两个空格
# 多行注释信息：包含在3个双引号或者3个单引号内的语句
"""
这里就是多行注释
三个引号里面的任何内容不会被解释器执行
"""
或者
'''
这里就是多行注释
三个引号里面的任何内容不会被解释器执行
'''

python代码编写语法规范

代码语句分隔符号

Python使用分号，用于一条语句的结束标识，如果是一行结尾，可用换行来替代分号。

1
2
3
4
5
6
7
8

Python使用分号，用于一条语句的结束标识，如果是一行结尾，可用换行来替代分号。

# 使用分号作为语句分隔符
print("I am");print("Corazon")

# 使用换行作为语句分隔符
print("I am")
print("Corazon")

代码语句缩进要求

Java、C 语言采用大括号“{}”分隔代码块，而Python 采用冒号“:”和“代码缩进”和来区分代码块之间的层次;对于类、函数、流程控制语句、异常处理语句等，行尾的冒号和下一行的缩进，表示下一个代码块的开始;而缩进的结束则表示此代码块的结束。

Python 中可使用空格或者Tab键实现，但无论是手动敲空格，还是使用 Tab 键，通常情况下都是采用 4 个空格长度作为一个缩进量;

默认情况下，一个 Tab 键就是4 个空格。

1
2
3
4
5
6

i = int(input("请你输入一个数字: "))
if i > 5:
    print("你输入的数字是", i, "，大于5，",sep='')
else:
    print("你输入的数字是", i, "，小于5，",sep='')

代码语法规范补充

Python 采用 PEP 8 作为编码规范，其中 PEP 是 Python Enhancement Proposal（Python 增强建议书）的缩写;8 代表的是 Python 代码的样式指南。

• 下面仅给大家列出 PEP 8 中初学者应严格遵守的一些编写规则：

• 不要在行尾添加分号";"

• 不要用分号将两条命令放在同一行;

• 在运算符两侧、函数参数之间以及逗号两侧，都使用空格分隔;

• 使用必要的空行可以增加代码的可读性，通常在顶级定义（如函数或类的定义）之间空两行，而方法定义之间空一行;

• 另外在用于分隔某些功能的位置也可以空一行。

• python中有些特殊语句指令结尾，需要加入：

python数据类型介绍

在python开发过程中，可以将数据类型分为两个大类：

python基本数据类型：字符串 数值型(整型 布尔型) 浮点型

python复合数据类型：元组、列表、字典、集合

数据类型之数字类型介绍

整数类型

python中的整型，即int类型，Python中没有对整型数字大小限制；

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

# 整数类型示例
x = 10
print(x) #   输出x的值    
print(type(x))  #打印类型，type()函数用于输出变量的类型
# 将不同进制数转成十进制
print(0x11, 0b101, 0O12, 20)
#为实现进制数互相转换，Python中内置了用于转换的函数：
y = 0b10001
print(bin(y),oct(y),int(y),hex(y))

#运行结果
10
<class 'int'>
17 5 10 20
0b10001 0o21 17 0x11

浮点类型

在python中小数都属于浮点型(float）,有两种表现形式

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

# 小数点形式（常用），较小的小数表示
f =  3.14
num1 = 3.1415926 + 3.1415926
x = 1
y = "Corazon"
f1 =  -3.14E2  # 指数形式： aEn 或 aen，较大的小数表示
f2 =  3.14e-2  # 指数形式： aEn 或 aen，较大的小数表示
print("f:",type(f))
print(num1)
print(3.1415926+3.1415926)
print("x:",type(x), "y:",type(y))
print("f1:",type(f1),"f2:",type(f2))

# 执行结果
f: <class 'float'>
6.2831852
6.2831852
x: <class 'int'> y: <class 'str'>
f1: <class 'float'> f2: <class 'float'>

布尔类型

布尔型（Bool）是一种特殊数据类型，常用于判断，这种类型只有两种值，即"真"与"假"。

1
2
3
4
5
6
7
8

print(4 == 2,5 > 1)
# 也可以做字符判断   --判断大小 依据ascii编码
name = "zhangsan"
print(name == "lisi")

# 打印结果
False True
False

1
2
3
4

# 不光上面代码语句的结果是布尔值，单独一个数据没有进行计算也可以都有自己的布尔值，这就涉及到布尔的零值。
# 任意数据类型都有一个具体值的布尔值为False,我们称为零值。该类型的其他值的布尔值皆为True。
print(bool("Cozrzon"),bool(0)) # 字符串的零值True False
print(bool(24),bool(0))        # 整型的零值  True False

数据类型间相互转换方法

python内置了进行转换数据类型的函数，常见有int()、float()，示例如下：

1
2
3
4
5
6
7
8
9
10
11

# int() 转成整型
# float() 转成小数
x = 3
y = 3.14
#注意：浮点型转换为整数型时直接舍去小数部分（向下取整）
print(x, type(x), y, type(y))
print(float(x), type(float(x)), int(y), type(int(y)))

# 运行结果
3 <class 'int'> 3.14 <class 'float'>
3.0 <class 'float'> 3 <class 'int'>

数据类型值字符类型介绍

字符串格式

单行字符串：

1
2
3
4
5
6

# 用双引号，直接输出字符串
print("hi,Corazon")

# 以变量的形式输出字符串，采用单引号定义
s1 = 'hi,Corazon'
print(s1)

多行字符串也叫文本字符串，就是三个单引号或者三个双引号圈住的内容，实际上也是字符串；

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

s = """
s1 = "hi,boy\nhi,girl"
s2 = 'I\'m Corazon'
s3 = "D:\\中科人才\\python.exe"
s4 = "我是中科人才，\
我喜欢python"
长字符串中放置单引号或者双引号不会导致解析错误
"""
print(s)

# 打印结果
s1 = "hi,boy
hi,girl"
s2 = 'I'm Corazon'
s3 = "D:\中科人才\python.exe"
s4 = "我是中科人才，我喜欢python"
长字符串中放置单引号或者双引号不会导致解析错误

字符串信息转义设置

有些特殊字符信息前面加\ 转义字符会有特殊的含义作用：

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

# 01 索引取值
s = "hello，Corazon"
print(s[1])  # 索引从前到后，从0开始，1对应的字符为e
print(s[-3])  # 索引从后到前，从-1开始，-3为倒数第三个字符，对应的字符为k
# 02 切片取值：序列类型对象[start : end : step]
print(s[2:5])  # llo     ：取索引1到索引3（左闭右开） == [1:3)
print(s[:5])  # hello   ：start缺省，默认从0取
print(s[6:])  # Corazon ：end缺省，默认取到最后
# 03 判断存在：使用in关键字检查某元素是否为序列的成员。
s = "hello,Corazon"
print("Corazon" in s)  # True
print("Leonidas" in s)  # False
# 04 +/*运算：支持使用“+”运算符做相加操作，它会将两个序列进行连接，但不会去除重复的元素。
#            使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次的结果。
s = "hello" + "Corazon"
print(s)  # 输出helloCorazon
s = "hello" + ",Corazon!!!"
print(s * 2)
print("*" * 30)  # 输出30个*

# 打印结果
e
z
llo
hello
Corazon
True
False
helloCorazon
hello,Corazon!!!hello,Corazon!!!
******************************

字符串内置方法

在对字符串进行操作时，还会存在一些内置的方法函数，完成对字符串信息的特殊需求处理：

注意：index()和find()方法只能匹配首个指定字符的索引

复合数据类型

元组数据类型

元组数据类型定义：

元组的元素只能读，不能进行修改（下标不能改 元素不能改 长度不能增加 但整体可以改），通常情况下，元组用于保存无需修改的内容；元组使用小括号表示声明（定义）一个元素数据类型：

1

(element1, element2, element3, ..., elementn)

注意：当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号，否则python解释器会将它视为字符串

1
2
3
4
5
6

l = (1,2,3)
print(l,type(l)) # (1, 2, 3) <class 'tuple'>

pen = ("pear1", "pear2", "pear3")  # 小括号
# 打印元组所有元素
print(pen)

02 元组数据序列操作：

元组数据信息调取和列表操作基本一致，支持索引和切片操作。

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

l = ("element1", "element2", "element3", "element4", "element5", "element6")
print(l[2])  # 3

# 切片操作
print(l[2:4])  # (3, 4)  也是前闭后开 [2:4)
print(l[:4])  # (1, 2, 3, 4)
print("element2" in l)  # True

# 列表信息循环遍历：
pen = ("pear1", "pear2", "pear3")
for item in pen:
    print(item,end=" ")
print("\n--------分隔符-------")
#整体可以改
pen = ("pear1", "pear2", "pear3","pear4")
for item in pen:
    if item.find("4") >= 0:  # 字符串查找用法  find 返回字符串位置
        print(item + "这是第4个梨")  # 字符串相连用法
    else:
        print(item)
print("---------------")

# 运行结果
element3
('element3', 'element4')
('element1', 'element2', 'element3', 'element4')
True
pear1 pear2 pear3 
--------分隔符-------
pear1
pear2
pear3
pear4这是第4个梨
---------------

列表数据类型

列表会将所有元素都放在一对中括号[]里面，相邻元素之间用逗号分隔，具体表现形式：

1

[element1, element2, element3, ..., elementn]

注意：不同于C，java等语言中的数组，python的列表可以存放不同的任意数据类型对象。

1
2
3
4
5
6
7
8
9

l = [123,"zkrc",True]
print(l,type(l),len(l))
for item in l:
    print(item,type(item))
# 执行结果
[123, 'zkrc', True] <class 'list'> 3
123 <class 'int'>
zkrc <class 'str'>
True <class 'bool'>

1
2
3
4
5

# 列表方式赋值变量 --列表值与变量数量要一一对应
a,b = [1,2]
print(a,b)
a,b = [input("请输入第一个字符: "),input("请输入第二个字符: ")]
print(a,b)

列表数据信息调取

我们可以使用索引（index）访问列表中的某个元素，也可以使用切片操作访问列表中的一组元素值信息，从而得到的是一个新的子列表。

1
2
3
4
5
6
7
8
9

索引求值
l = [10,11,12,13,14]
print(l[2])  # 12
print(l[-1]) # 14
 
切片操作
l = [10,11,12,13,14]
print(l[2:5])       #[12, 13, 14]
print(l[-3:-1])     #[12, 13]

列表内置方法

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

# 01 列表元素增加操作：append insert extend
l1 = [1, 2, 3]

# append()：追加一个元素
l1.append(4)
print(l1)           # [1, 2, 3, 4]

# insert(): 插入，即在任意位置添加元素
l1.insert(1, 100)   # 在索引1的位置添加元素100
print(l1)           # [1, 100, 2, 3, 4]

# extend()：扩展一个列表
l2 = [20, 21, 22, 23]
# l1.append(l2)
l1.extend(l2)
print(l1)           #[1, 100, 2, 3, 4, 20, 21, 22, 23]


# 02 列表元素删除操作：pop，remove，clear
l4 = [10, 20, 30, 40, 50]

# 按索引删除:pop,返回删除的元素
ret = l4.pop(3)
print(ret)
print(l4)            # [10, 20, 30, 50]

# 按着元素值删除
l4.remove(30)
print(l4)            # [10, 20, 50]

# 清空列表
l4.clear()
print(l4)            # []


# 03 列表元素修改操作：
l5 = [10, 20, 30, 40, 50]

#  将索引为1的值改为200
l5[1] = 200
print(l5)             # [10, 200, 30, 40, 50]

# 将l5中的40改为400 , step1：查询40的索引 step2：将索引为i的值改为400
i = l5.index(40) #  3
l5[i] = 400
print(l5)             # [10, 20, 30, 400, 50]

# 04 列表元素查询操作：index，sort
l5.reverse()          # 只是翻转 [50, 400, 30, 200, 10]
print(l5) # []

# 查询某个元素的索引，比如30的索引
print(l5.index(30))   # 2

# 排序
l5.sort(reverse=True)
print(l5)             # [400, 200, 50, 30, 10]

字典数据类型

字典是python提供的唯一内键的映射（mapping type）数据类型，python使用{ }创建字典。

由于字典中每个元素都包含键（key）和值（value）两部分，因此在创建字典时，键和值之间使用英文冒号:分隔。相邻元素之间使用英文逗号,分隔，所有元素放在大括号 { } 中，字典的元素也叫成员，是一个键值对。

1

dictname = {'key1':'value1', 'key2':'value2', ...}

同一字典中的各个键必须唯一，不能重复。

字典的键值对原本是无序的，但是在python3.6版本之后，字典默认做成有序的了。

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

d = {"01": "zhangsan", "02": "lisi", "03": "wangwu"}
print(d, type(d))

# 01 查键值
print(d["01"],d["02"])

# 02 添加或修改键值对
# 注意：如果键存在，则是修改，否则是添加
d["01"] = "xiaoX"  # 修改键的值
d["04"] = "zhaoliu"  # 添加键值对
print(d)

# 03 删除键值对
print(d)
del d["01"]  # 删除字典指定成员信息 delete
print(d)
del d  # 删除字典

# 字典成员过滤筛选：
d = {"01": "zhangsan", "02": "lisi", "03": "wangwu"}
print("01" in d)

# 字典数据信息遍历：
d = {"01": "zhangsan", "02": "lisi", "03": "wangwu"}
for key in d:
    print(key, d[key],"||",end=" ")
# 执行结果
{'01': 'zhangsan', '02': 'lisi', '03': 'wangwu'} <class 'dict'>
zhangsan lisi
{'01': 'xiaoX', '02': 'lisi', '03': 'wangwu', '04': 'zhaoliu'}
{'01': 'xiaoX', '02': 'lisi', '03': 'wangwu', '04': 'zhaoliu'}
{'02': 'lisi', '03': 'wangwu', '04': 'zhaoliu'}
True
01 zhangsan || 02 lisi || 03 wangwu || 

字典内置的方法

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

dic = {"name": "zkrc", "age": 22, "sex": "male"}

# 01. 查字典的键的值
name = dic.get("name")
sex = dic.get("sex", "female")
print(name)
print(sex)
print(dic.keys())     # 返回值：['name', 'age', 'sex']
print(dic.values())   # 返回值：['zkrc', 22, 'male']
print(dic.items())    # [('name', 'zkrc'), ('age', 22), ('sex', 'male')]

# setdefault取某键的值，如果能取到，则返回该键的值，如果没有该键，则会设置键值对
print(dic.setdefault("name"))
print(dic.setdefault("height", "180cm"))  # get()不会添加键值对 ，setdefault会添加
print(dic)            # {'name': 'zkrc', 'age': 22, 'sex': 'male', 'height': '180cm'}

# 02. 删除键值对 pop popitem
sex = dic.pop("sex")  # male
print(sex)            # male
print(dic)            # {'name': 'zkrc', 'age': 22}

dic.popitem()  # 删除最后一个键值对
print(dic)            # {'name': 'zkrc'}

dic.clear()           # 清空键值对

# 03. 添加或修改 update
add_dic = {"height": "180cm", "weight": "60kg"}
dic.update(add_dic)
print(dic)            # {'name': 'zkrc', 'age': 22, 'sex': 'male', 'height': '180cm', 'weight': '60kg'}

update_dic = {"age": 33, "height": "180cm", "weight": "60kg"}
dic.update(update_dic)
print(dic)            # {'name': 'zkrc', 'age': 33, 'sex': 'male', 'height': '180cm', 'weight': '60kg'}

# 04. 字典的循环
dic = {"name": "zkrc", "age": 22, "sex": "male"}
# 遍历键值对方式1
for key in dic:       # 将每个键分别赋值给key
     print(key, dic.get(key))

# 遍历键值对儿方式2
for i in dic.items(): # [('name', 'zkrc'), ('age', 22), ('sex', 'male')]
     print(i[0],i[1])

集合数据类型

Python 中的集合，和数学中的集合概念一样，由不同可hash的不重复的元素组成的集合。

Python 集合会将所有元素放在一对大括号 {} 中，相邻元素之间用“,”分隔。

同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型，否则 Python 解释器会抛出 TypeError错误。

1

{element1,element2,...}

说明：由于集合中的元素是无序的，因此无法向列表那样使用下标访问元素，访问集合元素最常用的方法是使用循环结构；

集合内置方法

运算符号介绍

数运算符说明

Tips：事实上，a | b=(1 & b)+(a ^ b)

位运算符说明

比较运算符说明

逻辑运算符说明

成员运算符说明

in和not in用于测试给定数据是否存在于序列（如列表、字符串）中：

in作用是，如果指定字符在字符串中，则返回True，否则返回False。not in的作用刚好相反。

编写运算符应用示例代码：

1
2
3
4
5
6
7

x="zkrc"
y="b"
print(y in x)
print(y not in x)
# 运行结果
False
True

输入输出应用

输入输出函数说明

print()函数

print()函数用于打印内容或变量等输出，是python中最最用的函数。

函数语法格式：

1

print(value1, ..., sep=' ', end='\n', file=sys.stdout,flush=False)

函数参数信息：

print() 函数使用以%开头的转换说明符对各种类型的数据进行格式化输出，具体请看下表：

代码操作示例：

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

name = "Corazon"
sex = "Male"
age = 24
print(name, sex, sep=":", end=" ")
print(age)  # Corazon:Male 24  与上行合并为同一行
print("你的名字是:", name, "你的性别：", sex, "你的年龄", age)  # 你的名字是: Corazon 你的性别： Male 你的年龄 24
# 解决空格问题
print("你的名字是:", name, " 你的性别：", sex, " 你的年龄", age, sep='')  # 你的名字是:Corazon 你的性别：Male 你的年龄24
# 同时输出字符串和变量，用+拼接
info = "你的名字是:" + name
print(info)  # 你的名字是:Corazon

##Print格式化输出
# 方法1：{0}、{1}、{2}分别表示j,i,j+i，单引号里面是输出格式。
print("你的名字是{0},你的性别:{1},你的年龄:{2}".format(name, sex, age))  # 你的名字是Corazon,你的性别:Male,你的年龄:24
# 方法2：类似于C语言格式输出，使用%开头格式输出
print("你的名字是%s,你的性别:%s,你的年龄:%s" % (name, sex, age))  # 你的名字是Corazon,你的性别:Male,你的年龄:24

input()函数

input函数是用来接收用户输入的数据，会返回一个字符串类型的数据。如果想要得到其他类型的数据进行强制类型转化。代码操作示例：

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

# 允许用户在终端下输入自己的账号和密码
name = input("请输入您的姓名：")
year = int(input("请输入您的出生年："))
month = int(input("请输入您的出生月："))
day = int(input("请输入您的出生日："))
# 前面双引号内容是格式化字符串，%s就是占位符，占据一个位置，类似教室占座。
# 占位符%s最终会被后面的变量的值所替代。
# 中间的`%`是一个分隔符。
# 多个变量表达式必须使用小括号扩起来。
# %02d 以整数输出，如果不足2位整数的，左边加0补充进去
print("您好%s，您的出生日期为：%d-%02d-%02d" % (name,year, month, day))
# 执行结果
请输入您的姓名：Corazon
请输入您的出生年：2000
请输入您的出生月：6
请输入您的出生日：8
您好Corazon，您的出生日期为：2000-06-08

格式化输出

话不多说

% 格式化（传统方法）

1
2
3

name = "Alice"
age = 30
print("Name: %s, Age: %d" % (name, age))  # Name: Alice, Age: 30

高级控制：

1
2
3
4
5
6
7
8

# 宽度与对齐
print("[%10s]" % "left")    # 右对齐：[      left]
print("[%-10s]" % "right")  # 左对齐：[right     ]

# 浮点数精度
print("π: %.03f" % 3.14159)  # π: 3.142
print("a: %010.03f" % 1.23456)  # a: 000001.235
print("a: %.010f" % 1.23456)  # a: 1.2345600000

str.format() 方法

Python 2.6+版本支持str.format()` 方法：

1
2
3

print("Name: {0}, Age: {1}".format("Bob", 40))
print("Name: {name}, Age: {age}".format(name="Bob", age=40))
num=input("你还有{0}次机会，\n请输入一个1到20的整数：".format(5-count))

核心功能：

• 位置参数
  "{0} + {1} = {2}".format(1, 2, 3) → 1 + 2 = 3

• 关键字参数
  "User: {username}".format(username="admin")

• 混合使用
  "{0} {last}".format("John", last="Doe")

格式化规范（: 后定义格式）：

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

# 数字格式化
print("π: {:.3f}".format(3.14159))      # π: 3.142
print("Hex: {:x}".format(255))          # ff

# 文本对齐
print("[{:>10}]".format("right"))       # [     right]
print("[{:^10}]".format("center"))      # [  center  ]

# 符号显示
print("Balance: {:+d}".format(100))     # +100

# 千位分隔符
print("{:,}".format(1000000))           # 1,000,000

# 百分比
print("Ratio: {:.2%}".format(0.25))     # 25.00%

f-strings

Python 3.6+，推荐。在渗透测试Python脚本中经常使用f-strings方式构建PayLoad

1
2
3

name = "Corazon"
age = 35
print(f"Name: {name}, Age: {age}")  # Name: Corazon, Age: 35

高级特性：

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

# 表达式计算
print(f"Sum: {5 + 3}")                # Sum: 8

# 函数调用
print(f"Uppercase: {'hello'.upper()}")  # Uppercase: HELLO

# 格式控制
pi = 3.14159
print(f"π: {pi:.3f}")                 # π: 3.142 与%格式一样
print(f"Hex: {255:x}, int: {0b11111111:d}, Oct: {255:o}, Bin: {255:b}") # Hex: ff, int: 255, Oct: 377, Bin: 11111111

# 对齐与填充（字符串后接':'）
print(f"[{'left':<10}]")              # [left      ]
print(f"[{'right':>10}]")             # [     right]
print(f"[{'center':^10}]")            # [  center  ]
print(f"[{'pad':*>10}]")              # [*******pad]
# 构建cookie SQL注入字典，爆破某一用户密码（部分）：
cookies = {'TrackingId': f"{Tracking_id}' and ascii(substr((select password from {tablename} where username='{username}'),{password_index},1)) > {ascii_mid}--+;"}

# 日期格式化
from datetime import datetime
now = datetime.now()
print(now)                            # 2025-07-16 14:16:57.921635
print(f"Now: {now:%Y-%m-%d}")         # Now: 2025-07-16

# 原始字符串（避免转义）
name = "Corazon"
print(fr"Raw: \n {name}")             # Raw: \n Corazon
print(f"Raw: \\n {name}")             # Raw: \n Corazon

模板字符串（string.Template）

string.Template 是 Python 标准库中提供的一种安全、简单的字符串替换机制，特别适合处理用户提供的模板或需要防止注入攻击的场景。

基本用法：

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

from string import Template

#01 创建模板对象
t = Template("Hello, $name! Today is $day.")

# 使用 substitute() 方法进行安全替换：
result = t.substitute(name="Alice", day="Monday")
print(result)                   # 输出: Hello, Alice! Today is Monday.

# 使用 safe_substitute() 方法，当缺少变量时不会报错：
result = t.safe_substitute(name="Bob")
print(result)                   # 输出: Hello, Bob! Today is $day.


#02 变量表示形式
from string import Template

# 简单变量 ($var)
t = Template("Welcome, $user!")
print(t.substitute(user="Admin"))  # Welcome, Admin!

# 包裹变量 (${var})
# 当变量名后需要紧跟字母、数字或下划线时使用,避免歧义：
t = Template("Total: ${amount}USD")
print(t.substitute(amount=100))    # Total: 100USD


#03 使用字典进行替换
data = {"name": "Corazon", "item": "book", "price": 29.99}
t = Template("$name bought a $item for $$$price")
print(t.substitute(data))  # Corazon bought a book for $29.99


#04 特殊字符处理
# 转义 `$` 符号，使用两个 `$` 表示字面值的美元符号：
t = Template("Cost: $$ $amount")
print(t.substitute(amount=50))  # Cost: $ 50

# 处理包含 `$` 的值
t = Template("Value: $val")
print(t.substitute(val="$100"))  # Value: $100

高级用法

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

# 2.自定义分隔符（继承 Template）
class MyTemplate(Template):
    delimiter = '#'  # 将分隔符改为 #
    idpattern = r'[a-z]+'  # 只允许小写字母变量名
t = MyTemplate("Hello, #name! Your code is #code")  
print(t.substitute(name="Corazon", code="XYZ123"))  # Hello, Corazon! Your code is XYZ123

# 3.处理无效标识符
class SafeTemplate(Template):
    idpattern = r'[_a-z][_a-z0-9]*'  # 标准标识符规则
t = SafeTemplate("$user_name: $score")
print(t.substitute(user_name="Eve", score=95))  # Eve: 95

安全特性

string.Template 的主要安全优势：

1. 不执行表达式：不会像 f-strings 那样执行任意代码

2. 无格式化功能：不能访问对象属性或执行方法

3. 简单替换：只进行直接的字符串替换

1
2
3
4

# 安全示例 - 防止注入攻击
user_input = "${os.system('rm -rf /')}"  # 恶意输入
t = Template("User data: $data")
print(t.safe_substitute(data=user_input))  # 安全输出: User data: ${os.system('rm -rf /')}

实际应用场景

1. 邮件模板

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

email_template = Template("""
Dear $name,

Your order #$order_id has been shipped.
Tracking number: $tracking_num

Regards,
$company
""")

data = {
    "name": "Alice",
    "order_id": "12345",
    "tracking_num": "ZYX987",
    "company": "ACME Corp"
}

print(email_template.substitute(data))

2. 配置文件模板

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

config_template = Template("""
[DATABASE]
host = $db_host
port = $db_port
user = $db_user
password = $db_pass
""")

db_config = {
    "db_host": "localhost",
    "db_port": 5432,
    "db_user": "admin",
    "db_pass": "secure123"
}

print(config_template.substitute(db_config))

3. 多语言支持

1
2
3
4
5
6
7
8
9
10

templates = {
    "en": Template("Hello, $name!"),
    "es": Template("¡Hola, $name!"),
    "fr": Template("Bonjour, $name!")
}

def greet(name, lang="en"):
    return templates[lang].substitute(name=name)

print(greet("Pierre", "fr"))  # Bonjour, Pierre!

其他方法

(1) 字符串拼接

1

print("Name: " + name + ", Age: " + str(age))

(2) str.join() 处理列表

1
2

words = ["Python", "is", "powerful"]
print(" ".join(words))  # Python is powerful

总结对比

流程控制语句

python流程控制语句介绍

软件程序是由语句构成，而流程控制语句是用来控制程序中每条语句执行顺序的语句；可以通过控制语句实现更丰富的逻辑以及更强大的功能；几乎所有编程语言都有流程控制语句，功能也都基本相似，其流程控制方式有：

• 顺序结构

• 分支结构

• 循环结构

最简单最常用的就是顺序结构，即语句从上至下逐一执行：

1
2

print("I am zkrc.")
print("I like python.") # 从上到下依次执行

流程控制分支语句

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

# 单分支语句语法结构：
if 表达式:
    代码块 

# 双分支语句语法结构：
if 表达式:
    代码块1
else:
    代码块2

# if 表达式1:
    代码块1
elif 表达式2:
    代码块2
...更多elif语句
else：
    代码块 n

双分支语句中的pass用法：

• 空语句，不做任何事务处理，一般用作占位

• 保证格式完整

• 保证语义完整

一些高阶用法：

1
2
3

#01 打印num1和num2中较大的数
num1, num2 = 1, 2
print(num1 if num1 > num2 else num2)  # 2

流程控制循环语句

Python语言中的循环语句支持 while循环（条件循环）和for循环（遍历循环）

流程控制循环语句-while

循环语句语法格式：

1
2

while 表达式:
    循环体

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

# 无限循环
while True:
    print("ok")

# 无限循环打印,间隔0.5秒。
import time
while True:
    print("boss")
    time.sleep(0.5)
    
# 有限循环：从数字1打印输出到10
count = 1          
while count <= 10: 
    print(count)
    count+=1
print("end")

流程控制循环语句-for

循环语句语法格式：

1
2

for 迭代变量 in 字符串|列表|元组|字典|集合：
    代码块

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

for i in "zkrc":
    print(i)
    
for item in ["张三",'李四',"王五"]:
    print(item)
    
#  range函数： range(start,end,step)     
for i in range(5):  # range(5)结果为[0,1,2,3,4]
    print(i)

# 偶数
for i in range(2,11,2):
print(i)
结果:  前闭后开 不包含11
2
4
6
8
10

流程控制循环嵌套

1
2
3
4
5
6
7
8
9
10

#01 独立嵌套
for i in range(5):  #5次
    for j in range(5):  #5次
        print("  *",end="")
    print("")
#02 关联嵌套
for i in range(1,5):  #控制行数
    for j in range(i):  #控制每行个数
        print(" *",end="")
    print("") 

循环控制语句说明

如果在某一时刻（在不满足结束条件的情况下）想提前结束循环，可以使用break或continue关键字；

循环控制语句-break

当break关键字用于for循环时，会终止循环而执行整个循环语句后面的代码信息；break 退出的是循环 exit() 或者quit() 退出的是脚本

1
2
3
4
5

for i in range(1,6):
    if i == 3:
        break
    print(i)
print("end")

循环控制语句-continue

不同于break退出整个循环，continue指的退出当次循环，但会继续在循环结构中，完成后续的循环操作；

1
2
3
4
5

for i in range(1,6):
    if i == 3:
        continue
    print(i)
print("end")

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

import random
while True:
    rannum = random.randint(1,20)
    print("请出价猜水果价格：答案是1到20之间整数")
    count = 0
    while count <=5:
        num = input("你还有{0}次机会，\n请输入一个1到20的整数: ".format(5-count))
        if num.isdigit():
            num =int(num)
            if num == rannum:
                print("恭喜你，答对了!")
                break
            if num > rannum:
                print("猜的有点大")
            if num < rannum:
                print("猜的有点小")
            count = count +1
        else:
            print("请输入一个整数")
        if count == 5:
            print("给了你",count,"次机会都没答对，正确的答案是：",rannum,sep='')
            break
    print("怎么样，这游戏好玩吧？")
    print("按任意键结束游戏，按空格键继续游戏：")
    select = input("请输入你的选择：")
    if select != " ":
      break

编程函数

函数定义语法格式：

1
2

def 函数名(var1,var2...varn):
    操作指令信息

本文参考：

shell编程

这里说的Shell 脚本（shell script），是在Linux 环境下运行的脚本程序

Shell 编程跟 JavaScript、php 编程一样，只要有一个能编写代码的文本编辑器和一个能解释执行的脚本解释器就可以了。

Linux 的 Shell 种类众多，常见的有：

• Bourne Shell（/usr/bin/sh或/bin/sh）

• Bourne Again Shell（/bin/bash）

• C Shell（/usr/bin/csh）

• K Shell（/usr/bin/ksh）

• Shell for Root（/sbin/sh）

• ……

Bash是大多数Linux 系统默认的 Shell，本文也仅关注Bash Shell。

在一般情况下，并不区分 Bourne Shell 和 Bourne Again Shell，所以，像 #!/bin/sh，它同样也可以改为 #!/bin/bash。

#! 告诉系统其后路径所指定的程序即是解释此脚本文件的 Shell 程序。

雷神众测 需要技术 有基础再参加 不然号废了 钱少通过率可以
360众测 要先打靶场 钱多 通过率低 重复率高 不推荐漏洞盒子 需要积分补天
EDU众测 钱很少 不难火线众测 银行众测 快凉了

众测思路看手速 收录范围广

众测厂商等级银行证券：难政府、EDU、企业：中等私人项目：简单（捡钱，认识项目经理）

fofa、hunter到处资产 扫指纹 定位oa和框架 扫nday
arl边跑边测，怼着后台和功能

思路（不太常规，别人不太会用）利用icon收集信息查找网站的真是ip 挖网站的c端（比较容易歪） 不确定可以问问利用站点标题进行模糊搜索公众号小程序 关键词搜索谷歌/bing语法：很多玉米螟需要正确路径才能打开，不然40X

漏洞挖掘
nday 扫框架 组件漏洞未授权 弱口令逻辑漏洞短信轰炸（看能不能并发）

本文参考：

文件系统介绍

根目录结构及其功能

系统目录结构：

系统配置信息

日志信息

Linux系统拥有非常灵活和强大的日志功能，可以保存几乎所有的操作记录，并可以从中检索出我们 需要的信息。

1. 内核及系统日志由系统服务rsyslog统一进行管理，日志格式基本相似

2. 用户日志记录系统用户登录及退出系统的相关信息

3. 程序日志由相应的应用程序进行独立管理。如：web服务，ftp服务 常见日志文件

比较重要的几个日志：

登录失败记录：/var/log/btmp #lastb
最后一次登录：/var/log/lastlog #lastlog
登录成功记录: /var/log/wtmp #last
登录日志记录：/var/log/secure
目前登录用户信息：/var/run/utmp #w、who、users
历史命令记录：history
仅清理当前用户：history -c

网卡配置

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

vim  /etc/sysconfig/network-scripts/ifcfg-ens33
# 网络接口类型（通常为 Ethernet 或 Bridge）
TYPE=Ethernet
# 代理配置方式（none 表示不使用代理）
PROXY_METHOD=none
# 是否仅用于浏览器代理（no 表示不限制）
BROWSER_ONLY=no
# 获取IP地址的方式（static 表示静态IP，dhcp 表示动态获取）
BOOTPROTO=static
# 静态IP地址（需根据实际网络规划设置）
IPADDR=10.0.0.5
# 子网掩码（定义IP地址的网络部分）
NETMASK=255.255.255.0
# 默认网关（路由器的IP地址）
GATEWAY=10.0.0.254
# 主DNS服务器地址（注意：此处错误添加了域名，应仅保留IP）
DNS1=10.0.0.254
# 是否启用默认路由（yes 启用）
DEFROUTE=yes
# IPv4配置失败时是否视为严重错误（no 表示不终止网络服务）
IPV4_FAILURE_FATAL=no
# 是否初始化IPv6（yes 启用）
IPV6INIT=yes
# 是否自动配置IPv6地址（yes 启用）
IPV6_AUTOCONF=yes
# 是否启用IPv6默认路由（yes 启用）
IPV6_DEFROUTE=yes
# IPv6配置失败时是否视为严重错误（no 表示不终止网络服务）
IPV6_FAILURE_FATAL=no
# IPv6地址生成模式（增强隐私保护）
IPV6_ADDR_GEN_MODE=stable-privacy
# 网络连接名称（自定义标识）
NAME=ens33
# 设备唯一标识符（系统自动生成，通常无需修改）
UUID=27a73818-89f3-4991-9890-2da7924a73c4
# 物理设备名称（需与网卡实际名称一致）
DEVICE=ens33
# 是否在系统启动时激活此连接（yes 启用）
ONBOOT=yes

更改配置需要重启网卡systemctl restart network 或 service network restart

域名解析配置

1
2
3

vim /etc/resolv.conf    #域名解析配置文件
nameserver 10.0.0.254   #DNS服务器，不能写错 写错就访问不了了
cat /cat /etc/hosts     #访问内网的域名配置文件

系统管理

环境变量

和变量 环境变量 别名相关的配置文件信息：/etc/profile、/etc/bashrc、~/.bash_profile 、~/.bashrc、/etc/profile.d/

网安关注应急效应，异常占用资源、进程关闭后再次运行，有可能是 profile 被植入脚本运行命令。/etc/profile 、/etc/bashrc、两个文件写到任意一个都会受到影响（把某个恶意跑进程的脚本放进去）。局部变量优于全局变量

如果想让变量重启后仍然有效就修改这些文件。

其他

文件时间信息分类

inode与block

文件索引-inode 数据信息索引 每创建一个文件可用的索引次数就会减少

文件大小-block 数据信息容量 文件中的信息内容不断添加，数据块就会不断减少

查看相关信息：

df -i --inode 可用数为0 表示磁盘空间不足

df block 可用数 为0 表示磁盘空间不足

inode：默认大小为128或者256字节

block：默认大小1-4kb

由于磁盘分区都比较大，所以一个磁盘中会创建出大量的inode和block

本质上有数字编号和实际存储空间对应 便于检索数据信息 —指针 库管 会议 仓库提货过程

存储的数据文件中包含数据文件属性

描述数据的数据 – 元数据

系统进程

程序（Program）是经开发编译后形成的静态可执行代码集合，是数据与指令的有序封装（如磁盘中存储的wechat.exe或nginx二进制文件），其生命周期独立于运行状态，可长期保存在存储介质中。

当程序被加载到内存并开始执行时，便转化为进程（Process）—— 它是程序的动态运行实例。此时，操作系统会为其分配专属的系统资源（如内存空间、CPU 时间片、文件描述符等），并记录其运行状态（如就绪、运行、阻塞等）。同时，进程会关联明确的所属用户，受系统权限管控。

简言之，程序是 “静态的代码文件”，而进程是 “动态的执行过程”。例如，双击wechat.exe后，操作系统将其加载到内存并启动执行，此时任务管理器中显示的 “微信” 进程，便是该程序的运行实例。

进程与程序的本质区别

理解进程与程序的区别，是系统运维的基础：程序是 “待执行的蓝图”，而进程是 “正在施工的现场”—— 运维的核心工作，正是通过监控、管理这些 “现场”，确保系统按预期稳定运行。

根据进程生命周期，存在两种特殊进程情况：

• 僵尸进程：

异常进程 任务没处理完子进程崩溃了，就会出现僵尸进程（Z） 儿子死了父亲还在 关注 木马病毒 产生大量Z 会占用大量内存资源

• 孤儿进程：

异常进程 任务处理完毕告知父进程时，父进程异常了，产生孤儿进程，系统会自动回收孤儿进程 了解

查看当前静态进程情况

ps -ef|ps aux

1
2

ps aux   #USER, PID, %CPU, %MEM, VSZ, RSS, TTY, STAT, START, TIME, COMMAND
ps -ef   #UID, PID, PPID, C, STIME, TTY, TIME, CMD

以下是 ps aux 和 ps -ef 命令中所有列的英文缩写及含义对照表：

查看当前动态进程情况

top 输出分为 系统全局状态区 与 进程详情区，两者共同构成系统实时运行快照。

在 Linux 系统运维中，top 命令是实时监控进程资源与系统性能的核心工具。它通过动态刷新的界面，提供 CPU、内存、进程状态等关键指标，帮助管理员快速定位资源瓶颈与异常进程。

top与 ps 命令的核心差异：

系统全局状态区

系统全局状态区为输出的上半部分，以典型输出为例：

1
2
3
4
5

top - 09:27:45 up 5 days,  7:45,  4 users,  load average: 0.00, 0.01, 0.05  
Tasks: 123 total,   1 running, 121 sleeping,   1 stopped,   0 zombie  
%Cpu(s):  0.1 us,  0.0 sy,  0.0 ni, 99.9 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st  
KiB Mem :  1863032 total,  1121288 free,   256980 used,   484764 buff/cache  
KiB Swap:  1535996 total,  1535996 free,        0 used.  1408888 avail Mem  

1. 第一行（系统基础信息）

   • 09:27:45：当前系统时间。

   • up 5 days, 7:45：系统已连续运行 5 天 7 小时 45 分钟（未重启）。

   • 4 users：当前登录用户数（含本地终端与远程连接）。

   • load average: 0.00, 0.01, 0.05
     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
     
          ：系统平均负载，分别对应过去 1 分钟、5 分钟、15 分钟的活跃进程数。
     
          - **关键逻辑**：负载值代表处于 **可运行状态（`R`）** 或 **不可中断休眠状态（`D`）** 的进程数平均值。
          - **健康指标**：若 1 分钟负载值超过 CPU 核心数（如 4 核 CPU 负载 >4），表明系统短期过载；若 15 分钟负载持续偏高，需排查长期资源瓶颈。
     
     2. **第二行（进程总数统计）**
     
        - `123 total`：系统总进程数。
        - `1 running`：处于 `R` 状态的进程数（正在占用或等待 CPU）。
        - `121 sleeping`：处于 `S`（可中断休眠）或 `D`（不可中断休眠）状态的进程数。
        - `1 stopped`：处于 `T`（停止）状态的进程数（如被 `Ctrl+z` 暂停的 `ping` 进程）。
        - `0 zombie`：僵尸进程（`Z` 状态）数量，若大于 0 需检查父进程是否未回收资源。
     
     3. **第三行（CPU 资源占用）**
     
        - **`us`：用户态进程占用 CPU 的百分比（如应用程序）**。
        - `sy`：内核态进程占用 CPU 的百分比（如系统调用、进程调度）。
        - `ni`：调整过优先级（`nice` 值非 0）的用户态进程占用 CPU 的百分比。
        - `id`：CPU 空闲百分比（数值越高，系统越空闲）。
        - **`wa`：CPU 等待 I/O 操作（如磁盘读写）的百分比，若长期高于 5% 需排查存储性能。**
        - `hi`：硬中断（如硬件设备触发的中断）占用 CPU 的百分比。
        - `si`：软中断（如内核定时器、网络数据包处理）占用 CPU 的百分比。
        - `st`：虚拟化环境中，物理 CPU 被其他虚拟机占用的百分比（`st` 过高可能意味着宿主机资源竞争）。
     
     4. **第四、五行（内存与交换分区）**
     
        - `KiB Mem`（物理内存）：
          - `total`：总容量；`free`：完全空闲内存；`used`：进程直接占用内存；`buff/cache`：磁盘缓存（可释放供其他进程使用）。
        - `KiB Swap`（虚拟内存）：
          - `avail Mem`：新进程可使用的总内存（含 `free` 及可释放的 `buff/cache`）。
     
     
     ##### 进程详情区（下半部分）
     
     以典型输出为例：
     
     ```bash
     PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND  
     53720 root      20   0       0      0      0 S   0.3  0.0   0:18.08 kworker/1:1  
         1 root      20   0  202396   7300   4184 S   0.0  0.4   5:01.00 systemd  
         2 root      20   0       0      0      0 S   0.0  0.0   0:00.93 kthreadd  
     
     
     

字段说明：

核心功能与快捷键

top 命令以交互式界面实时展示系统状态，支持以下核心操作：

1. 基础交互

   • h 或 ?：调出帮助文档，查看所有快捷键与功能说明。
   • q：退出监控界面。
   • s 或 d：调整刷新间隔（单位：秒），默认 3 秒刷新一次。

2. 资源排序

   • P：按 CPU 使用率（%CPU）降序排序，快速定位高负载进程。
   • M：按内存使用率（%MEM）降序排序，排查内存占用异常。
   • T：按累计 CPU 时间（TIME+）排序，识别长期占用资源的进程。

3. 视图优化

   • 1：展开多核 CPU 视图，显示每个物理核心的负载详情（如 %Cpu0、%Cpu1）。
   • z：启用颜色高亮，区分不同数据区域（如红色标记高负载进程）。
   • b：高亮显示处于 R（运行）状态的进程，直观识别活跃任务。

4. 高级控制

   • k：终止进程（输入 PID 后可指定信号，如 9 强制终止）。
   • r：调整进程优先级（通过 nice 值，范围 -20~19，值越小优先级越高）。
   • c：切换显示进程完整命令行（含参数），避免因名称截断导致的误判。

关键指标与异常排查

1. 性能瓶颈定位

   • CPU 过载：若 %CPU 长期高于 80%，按 P 排序找出高负载进程，结合 ps -fp <PID> 分析代码逻辑或考虑扩容。
   • 内存泄漏：若 %MEM 持续增长且 avail Mem 下降，按 M 排序排查异常进程，使用 pmap 或 valgrind 分析内存分配。
   • 磁盘 I/O 瓶颈：若 wa 长期高于 10%，使用 iotop 定位高 I/O 进程，优化存储或升级硬件。

2. 进程状态异常

   • 僵尸进程（Z 状态）：终止父进程（kill <PPID>）或修复程序逻辑（确保调用 wait() 回收子进程资源）。
   • 不可中断进程（D 状态）：可能因磁盘 I/O 阻塞，使用 strace 跟踪系统调用或检查存储设备健康状态。

3. 虚拟化环境监控

   • 若 st 持续高于 10%，表明宿主机资源不足，需迁移虚拟机或增加物理 CPU 核心。

数据保存与高级用法

1. 批处理模式记录日志

   1	top -b -n 5 > /tmp/top_monitor.log # 记录 5 次刷新结果到文件

   • -b：以批处理模式运行，适合脚本调用或离线分析。

   • -n 5：指定刷新次数，避免无限输出。

2. 自定义显示字段

   • 按 f 进入字段选择界面，通过方向键添加 / 删除字段（如 CODE 代码内存、DATA 数据段内存）。
   • 按 o 调整字段顺序（如将 %CPU 列移至首位）。

3. 多进程监控

   1	top -p 1234,5678 # 同时监控多个进程（PID 1234 和 5678）

进程状态（STAT）信息

在 Linux 系统中，通过ps、top等命令查看进程时，状态标识（如R、S、Z等）直观反映了进程的当前行为。以下是各状态及相关符号的说明：

核心状态标识

进程状态由内核根据其资源占用、调度情况动态标记，核心状态标识（Process State Codes）如下：

1. R（Running / Runnable，运行状态）
   进程处于 “可被 CPU 调度” 的状态：要么正在占用 CPU 执行指令，要么已就绪（等待 CPU 分配时间片）。此时进程位于内核的 “就绪队列” 中，是系统中 “活跃” 的典型代表。

2. S（Interruptible Sleep，可中断休眠状态）
   进程因等待某事件（如 I/O 操作完成、信号触发、定时器超时等）而暂停执行，此时不占用 CPU 资源。该状态可被外部信号（如SIGINT）中断并唤醒（例如通过kill命令发送信号）。

   状态衍生符号（优先级相关）：

   • S<：表示进程处于高优先级可中断休眠状态（优先级高于默认值），内核会优先调度其唤醒。

   • SN：表示进程处于低优先级可中断休眠状态（优先级低于默认值），调度优先级较低。

3. T（Stopped / Traced，停止 / 跟踪状态）
   进程被主动暂停执行，通常由以下场景触发：

   • 收到暂停信号（如SIGSTOP），例如通过Ctrl+z暂停前台进程（如ping 223.5.5.5执行时，Ctrl+z会将其暂停为T状态）；
   • 被调试器（如gdb）跟踪，处于断点调试状态。

   该状态的进程可通过SIGCONT信号恢复运行（如fg命令将后台暂停进程调至前台），适用于暂不明确进程作用时 —— 先暂停而非直接kill，降低误操作风险。

   操作示例：

   • 暂停进程：ping 223.5.5.5执行中按Ctrl+z，进程进入T状态；

   • 查看暂停任务：jobs命令（仅显示当前终端会话创建的任务）；

   • 恢复进程：fg %1（将编号为 1 的暂停任务调至前台继续运行）；

   • 彻底终止：Ctrl+c直接终止前台进程，或kill命令发送终止信号。

4. D（Uninterruptible Sleep，不可中断休眠状态）
   进程因等待 “不可中断的系统资源”（如磁盘 I/O、硬件设备响应）而进入深度休眠，不响应任何外部信号（包括kill -9）。其设计目的是确保关键资源操作的原子性（如 MySQL 执行大量数据写入时，需等待磁盘同步完成，避免数据一致性问题）。

   注意：D状态进程虽不直接占用 CPU，但会锁定相关资源，若长期存在可能暗示硬件故障（如磁盘读写超时）。

5. Z（Zombie，僵尸状态）
   子进程已终止（退出），但父进程未调用wait()系列系统调用回收其资源（如进程 ID、退出状态等），导致其残留于进程表中。僵尸进程不占用 CPU、内存等实际资源，但会消耗进程表项（系统进程 ID 数量有限），积累过多可能导致新进程无法创建。

状态辅助符号

除核心状态外，ps命令还会显示以下符号，用于描述进程的附加属性：

• s：进程为会话首进程（Session Leader），通常是进程组的父进程，负责管理整个进程组的生命周期（如终端启动的命令进程多为会话首进程）。

• <：进程运行在高优先级（对应S<状态，优先级值低于默认，Linux 优先级范围为 - 20~19，值越小优先级越高）。

• N：进程运行在低优先级（对应SN状态，优先级值高于默认）。

• +：进程属于前台进程组，直接接收终端输入（如当前终端执行的ls命令进程）。

• l：进程包含多个线程（Lightweight Process），多线程进程可并行处理多个任务（如微信同时运行文字聊天、视频通话等功能，分别由不同线程执行），提升 CPU 利用率与响应速度。

结合ps、top等工具查看进程状态变化，通过状态标识可快速判断进程是否正常运行、是否存在资源竞争、是否需要干预（如终止僵尸进程、排查 D 状态进程的资源瓶颈）。

进程控制：kill 命令

kill 命令通过向进程发送 信号（signal） 实现进程控制（终止、暂停、重启等），核心语法为：

1

kill [参数] <进程标识符（PID）>

核心参数说明

• -l：列出所有可用信号（共 64 种，格式如 1) SIGHUP 9) SIGKILL）。

• -s <信号>：指定发送的信号（可用名称或编号，如 -s SIGKILL 或 -9）。

• -p：仅输出目标进程的 PID，不发送任何信号（用于验证进程存在性）。

常用信号及场景

注意事项

1. 权限要求：仅进程所有者或 root 可发送信号（普通用户无法终止其他用户的进程）。

2. 强制终止风险：SIGKILL（信号 9）可能导致数据丢失（如未保存的文件），尤其对存储服务（如数据库）需谨慎使用。

3. 信号重试：部分守护进程可能忽略 SIGTERM，可先尝试 SIGTERM，无效再用 SIGKILL。

系统平均负载

平均负载定义为 单位时间内，系统中处于「可运行状态（R）」和「不可中断状态（D）」的平均进程数（即活跃进程数），与 CPU 使用率无直接关联：

• 可运行状态（R）：正在占用 CPU，或等待 CPU 调度的进程（ps命令可见）。

• 不可中断状态（D）：等待硬件 I/O 响应的进程（如磁盘写入时的保护机制，中断会导致数据一致性问题，ps命令可见为D状态）。

系统平均负载的合理范围

系统平均负载的合理范围与 CPU 核心数强绑定。理想状态：平均负载 ≈ CPU 核心数（每个核心恰好运行 1 个进程）。不同核心数下，相同负载的意义截然不同：

时间维度的解读

平均负载包含 1 分钟、5 分钟、15 分钟 三个值，需结合判断趋势：

• 三者接近 → 负载平稳；

• 1 分钟值 ≫ 15 分钟 → 近期负载突增（需紧急排查）；

• 1 分钟值 ≪ 15 分钟 → 近期负载下降（关注历史瓶颈）。

告警建议：当平均负载超过 CPU 核心数的 70% 时，建议介入分析（需结合历史数据动态调整阈值）。

与 CPU 使用率的区别

平均负载涵盖 等待 CPU、等待 I/O、进程调度 的进程，而 CPU 使用率仅统计 CPU 繁忙程度，二者在不同场景下表现不同：

问题排查核心思路

1. 查看负载：通过 uptime/top 获取 1/5/15 分钟负载值，判断趋势。

2. 分析 CPU：用 mpstat 查看多核负载、iowait 等指标，定位瓶颈类型（CPU 计算 / IO 等待）。

3. 定位进程：通过 pidstat/top 追踪高负载进程（CPU/IO 占用异常的进程）。

4. 日志溯源：结合进程所属服务的日志，分析代码逻辑或资源配置问题。

压力测试与监控工具：

stress是Linux系统压力测试工具，可以用作异常进程模拟平均负载升高的场景。

mpstat:是多核CPU性能分析工具，用来实时查看每个CPU的性能指标，以及所有CPU的平均指标;

pidstat:是常用的进程性能分析工具，用来实时查看进程的CPU、内存、1/0以及上下文切换等性能指标;

1

yum install -y sysstat stress  # sysstat含mpstat/pidstat，stress用于压力测试

系统管理命令

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

# history 查看历史命令
history -c   #清除历史记录（慎用）

#关机命令 --关闭虚拟系统
shutdown -h now    #立即关机
shutdown -h 0      #立即关机
shutdown -h now    #立即关机
shutdown -h 5      #五分钟之后关机
init 0             #立即关机
half               #立即关机

#重启命令
shutdown -r 0/now  #立即重启
init 6             #立即重启
reboot             #立即重启

#修改主机名（修改之后要bash命令刷新）
hostname name   #临时修改
hostnamectl set-hostname name  #永久修改

#2> 错误重定向
command 2>/dev/null

#which 查找$PATH中设置命令及安装文件目录所在位置
which cat

#export 设置环境变量，使其在当前 shell 及子进程中生效
#临时设置
export NAME                # 导出已存在的变量为环境变量
export NAME=value          # 定义并导出变量 “=”两侧不能有空格
NAME=value; export NAME    # 等价写法
unset NAME                 # 删除变量
#永久设置
echo 'export JAVA_HOME="/opt/java"' >> /etc/profile   # 对所有用户生效
echo 'export PATH="$PATH:~/.local/bin"' >> ~/.bashrc  # 仅对当前用户生效

#env
env | grep NAME      # 检查环境变量

#alternatives 管理系统命令的多版本实现，避免文件冲突
alternatives --config <命令名>        # 手动选择版本
alternatives --remove <名称> <路径>   # 移除版本
alternatives --display <名称>        # 查看所有可用版本
alternatives --install <链接> <名称> <路径> <优先级>  # 添加新版本

#crontab 设置周期性执行的任务
crontab -e	        #编辑当前用户的 cron 表（首次使用会选择编辑器）。
crontab -l	        #列出当前用户的所有定时任务。
crontab -r	        #删除当前用户的所有定时任务（谨慎使用）。
crontab -u user -e	#以 root 身份编辑指定用户的 cron 表（需 root 权限）。
#时间格式：[分钟] [小时] [日期] [月份] [星期] command
#通配符与特殊符号："*"：匹配所有值 | ","：分隔多个值 | "-"：指定范围 | "/"：指定间隔
#相对时间：@daily | @weekly | @monthly | @reboot

# free  查看空间使用情况
free -h

# df 查看磁盘使用情况
df -h

#ps
a     # 显示现行终端机下的所有程序，包括其他用户的程序。
-A    # 显示所有程序。
c     # 列出程序时，显示每个程序真正的指令名称，而不包含路 径，参数或常驻服务的标示。
-e    # 此参数的效果和指定"A"参数相同。
e     # 列出程序时，显示每个程序所使用的环境变量。
f     # 用ASCII字符显示树状结构，表达程序间的相互关系。
-H    # 显示树状结构，表示程序间的相互关系。
-N    # 显示所有的程序，除了执行ps指令终端机下的程序之外。
s     # 采用程序信号的格式显示程序状况。
u     # 以用户为主的格式来显示程序状况。
x     # 显示所有程序，不以终端机来区分
ps aux   #USER, PID, %CPU, %MEM, VSZ, RSS, TTY, STAT, START, TIME, COMMAND
ps -ef   #UID, PID, PPID, C, STIME, TTY, TIME, CMD
# 若关注资源占用和用户名，用 ps aux；若需分析进程关系或用户 ID，用 ps -ef

#设置别名
alias eth0='cat /etc/sysconfig/network-scripts/ifcfg-ens33'
#取消别名
unalias eth0
#永久设置
alias eth0='cat /etc/sysconfig/network-scripts/ifcfg-eth0' >> /etc/profile

#timedatectl  --修改时区信息，以及显示系统时间   内容比较详细
#date    --快速简介显示时间信息
#"%Y" 年year| "%m" 月mouth | "%d" 日day | "%H" 时hour | "%M" 分min | "%S" 秒sec | "%F" 年-月-日 
touch `date +%F`.txt

#jobs bg fg
jobs   #用于查看后台运行启动
bg     #将进程信息放入后台运行
fg     #将进程信息放入前台运行

#uname [选项]
-a 或 --all	             #显示全部系统信息，涵盖系统名称、主机名、内核版本、处理器类型等内容。
-s 或 --kernel-name	     #显示内核名称，像 Linux、Darwin（macOS）等。
-n 或 --nodename	         #显示主机名，也就是计算机在网络中的标识名称。
-r 或 --kernel-release	 #显示内核版本号，例如 5.15.0-76-generic。

tail /var/log/messages    #查看系统报错日志