字符串的格式化

使用format进行格式化

1
2
3
4
5
6
7
8
9
10
# 索引插入
"{1}：计算机{0}的CPU占用率{2}%".format("2020年1月1日", "PYTHON", "10")
"{}：计算机{}的CPU占用率{}%，今天是{2}号".format("2020年1月1日", "PYTHON", "10") # 字符串复用

# 关键词插入
text = "My name is {name}, I am {age} years old".format(name="Tom", age=18) # 同样支持复用

# 字典
context = {'name': "Alice",'age': 28}
text = "My name is {name}, I am {age} years old".format(** context) # 同样支持复用
python

格式控制

1
2
3
4
5
6
7
8
9
10
11
context = "{:-^20}".format("Train") # ^表示居中，-表示填充字符
context = "{:-^20,}".format(123123123) # 逗号表示千位分隔符
context = "{:-^20,.2f}".format(123123123) # 逗号表示千位分隔符，.2f表示小数点后保留两位
context = "{:-^20,.2}".format(3.1415159) # 输出3.1
context = "{:-^20,.2f}".format(3.1415159) # 输出3.14
context = "{:-^20,.2e}".format(3.1415159) # 输出3.14e+00
context = "{:-^20,.2E}".format(3.1415159) # 输出3.14E+00
context = "{:-^20,.2%}".format(3.1415159) # 输出314.15%
context = "{:-^50c}, hello world, {:+<20c}".format(97, 100) # 输出------------------------a-------------------------, hello world, d+++++++++++++++++++
print("{1:-^50c}, hello world, {0:+<20c}".format(97, 100)) # 输出+++++++++++++++++++, hello world, d------------------------a-------------------------
print("{:10}".format("hello")) # 输出hello       ，默认右对齐,空格填充

还有两个不写了 # 文本进度条 tqdm库 # 正则表达式 特殊字符： “.”，代表一个任意字符 “”，代表任意多个字符（包括0个）（表示前面的字符可以出现任意多次）”+“，代表至少一个字符（表示前面的字符可以出现任意多次）（与的区别就是有没有0次）”{a}“，代表a个字符（表示{}前面的字符可以出现a次）”?“，代表0个或1个字符 # 取消贪婪模式”，代表数字，即0-9 “”，代表非数字 “”，代表空白，即空格、tab键 “”，代表非空白 “”，代表单词字符，即a-z、A-Z、0-9、_共47个字符 “”，代表非单词字符 “[abc]”，代表a、b、c三个字符中的任意一个 # []中可以放多个字符，表示其中任意一个字符（[]中的特殊字符相当于加了转义） “^”，代表字符串开头 “$”，代表字符串结尾 分组：()，将括号中的内容作为一个分组，可以单独取出来

数据结构

if

1.字符串可以比较大小，比较的是ASCII码 print(‘apple’ > ‘banana’) # False 2.列表可以比较大小，比较的是第一个元素的大小，如果第一个元素相等，则比较第二个元素的大小，以此类推 print([1,2,3] > [1,2,4]) # False 3.元组可以比较大小，比较的是第一个元素的大小，如果第一个元素相等，则比较第二个元素的大小，以此类推 print((1,2,3) > (1,2,4)) # False 4.字典可以比较大小，比较的是第一个键值对的大小，如果第一个键值对相等，则比较第二个键值对的大小，以此类推 print({‘a’:1,‘b’:2} > {‘a’:1,‘b’:3}) # False 5.print(10 == ‘10’) # False 6.print(10 == 10.0) # True 7.print(10 < ‘10’) # 结果报错 8.if x == true,可以简写为if x if 可以写链式表达 判空用 is None 与或非的顺序：先执行非（!），再执行与（and），最后执行或(or) 9.海象运算符 if (n := len(a)) > 10: print(n) # 等价于 n = len(a) if n > 10: print(n) 10.三元运算符 x = 1 if condition else 2 11.断言 assert condition, ‘message’ 如果condition为False，则抛出AssertionError，并输出message 12.三元运算符和断言的结合 x = 1 if condition else assert False, ‘message’

for

1
2
3
4
5
6
7
8
9
for i in range(10):
    print(i)    
    if i == 5:
        # 循环里面修改了循环变量里面的值，不会影响循环
        i = 8

a = [7, 4, 5, 6, 2, 3, 1]
for index, number in enumerate(a):
    print(index, number)

enumerate:可以同时输出索引和值

字典遍历： 

1
2
3
4
5
6
7
dict = {'a':1,'b':2,'c':3}
# 只会输出key
for key, value in dict.items():
    print(key, value)
# 会输出key和value
for i in dict.items():
    print(i)

zip: 

1
2
3
4
5
6
7
year = [2020,2021,2022,2023,2024,2025]
score = [600,601,602,603,604,605]
for i in zip(year, score):
    print(i)
sentiment = ['kaixin', 'shangxin', 'kaixin', 'shangxin']
for i in zip(year, score, sentiment):
    print(i)
可以整合多种类型; 可以整合2个以及多个列表; 当最短的列表遍历完时，就会停止

效率： map reduce:把同一个任务放到不同的节点上进行运算，最后汇总结果 map: 

1
2
3
4
5
 import time
start = time.perf_counter()
# squares = [x ** 2 for x in range(1000000)]
squares = map(lambda x: x**2, [x for x in range(1000000)])
print(time.perf_counter() - start)
map:map(function, iterable, …) function:函数
iterable：迭代对象，惰性求值 python内置函数，作用就是将一个函数应用于一个或多个迭代对象上，并返回一个迭代器 map可以处理多个list

filter: 

1
2
3
4
5
import time
start = time.perf_counter()
# squares = [x ** 2 for x in range(1000000)]
squares = filter(lambda x: x%2 == 0, [x for x in range(1000000)])
print(time.perf_counter() - start)
filter:filter(function, iterable) function：函数，接受一个参数，返回布尔值 iterable：可迭代对象，惰性求值 python内置函数，作用就是将一个函数应用于一个或多个迭代对象上，并返回一个迭代器

while

扩展： 

1
2
while:
else: # 当while循环正常结束时，会执行else
break break:跳出循环 continue continue:跳过本次循环，继续下一次循环

time库

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 time
print(time.time())  #  相对于1970年1月1日的秒数

# 程序计时
start = time.time()
# 执行代码
end = time.time()
print('程序执行时间：', end - start)

# 获取当前时间
print(time.ctime())

# 格式化输出时间
print(time.strftime("%Y-%m-%d %H:%M:%S"))

# 字符串转化时间
print(time.strptime('2025-04-08 20:10:18', "%Y-%m-%d %H:%M:%S"))
# time.struct_time(tm_year=2025, tm_mon=4, tm_mday=8, tm_hour=20, tm_min=10, tm_sec=18, tm_wday=1, tm_yday=98, tm_isdst=-1)

# 获取时间戳
time.pref_counter() # 系统内的cpu时间
# 程序计时
start = time.pref_counter()
# 执行代码
end = time.pref_counter()
print('程序执行时间：', end - start)

random库

1
2
3
4
5
6
7
8
9
10
import random
import random
random.seed(15)
print(random.random()) # 生成0-1之间的随机小数
print(random.randint(1, 10)) # 生成1-10之间的随机整数
print(random.randrange(1, 10)) # 生成1-9之间的随机整数
print(random.uniform(1, 10)) # 生成1-10之间的随机小数
print(random.choice([1, 2, 3, 4, 5])) # 从列表中随机选择一个元素
print(random.sample([1, 2, 3, 4, 5], 3)) # 从列表中随机选择3个元素
print(random.shuffle([1, 2, 3, 4, 5])) # 将列表中的元素随机排序

异常处理

1
2
3
4
5
6
7
8
9
# except 与 else是互斥的
try:
    # 可能会出错的代码
except Exception as e:
    # 出错时执行的代码
else:
    # 没出错时执行的代码
finally:
    # 无论是否出错，都会执行的代码

with

with语句用于简化资源管理，例如文件操作、网络连接等。在with语句中，资源会在进入语句时自动打开，在语句结束时自动关闭，无需手动调用close()方法。 

1
with open('file.txt', 'r') as f:

函数调用

可变位置传参：

1
def fact(n, *b):

n位必选参数，b为可变参数，（意思为b有多个参数，表示一个数量不固定的元组）

关键词可变参数：

1
def show_info(**kwargs):

意思是这个函数地传入的关键词有多少我也不知道，以字典的形式存储。

从函数定义的角度来看，$**kwargs $也必须放在参数列表的最后面

位置可变，关键词可变组合使用：

1
def dome(a,b,*args,c=0,**kwargs):

return返回值

1
2
def fe():
	return 1,2,3,"a","b",[4,5,6],[7,8,9],{'name':'zhangsan'}

return 可以返回多种类型，但是以元组的形式打包

函数的高阶返回

1
2
3
4
5
6
7
def create_add(x):
    def adder(y):
        return x+y
    return adder

add5 = create_add(5)
print(add5(3))

局部变量与全局变量

一：全局变量与局部变量不一致

1
2
3
4
5
6
7
n, s = 10,100
def fact(n):
    s = 1
    for i in range(1, n+1):
		s *= i					
    return s				# 此处的局部变量s = 3628800
print(fact(n), s)			# 此处的全局变量s = 100

使用全局变量声明：

1
2
3
4
5
6
7
n, s = 10,100
def fact(n):
    global s
    for i in range(1, n+1):
		s *= i					
    return s				# 此处的变量s指全局变量 = 3628800
print(fact(n), s)			# 此处的全局变量s = 3628800

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

1
2
3
4
5
6
7
8
ls = ['f', 'F']
def func(a):
    ls.append(a)
    return


func('c')
print(ls)
1
2
3
4
5
6
7
8
9
ls = ['f', 'F']
def func(a):
    ls = []
    ls.append(a)
    return


func('c')
print(ls)
image-20250503213454842

lambda函数：

1
2
3
4
5
	<函数名> = lambda <参数>: <表达式>	
<====>
	def <函数名>(<参数>):
		函数体
		return <返回值>
1
2
f = lanbda  x,y : x+y
f(10, 25)

函数递归：

1.链条

2.基例

1
2
3
4
5
6
# 阶乘
def fact(n):
    if n == 0:
        return 1
    else:
        return n * fact(n - 1)
1
2
3
4
5
6
# 字符串反转
def rev(str):
    if str == "":
        return str
    else:
        return rev(str[1:]) + str[0]
1
2
3
4
5
6
7
8
# 上台阶问题
def f(n):
    if n == 1:
        return 1
    elif n == 2:
        return 2
    else:
        return f(n - 1) + f(n - 2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 汉诺塔
count = 0
def hanno(n, src, mid, des):
    global count
    if n == 1:
        count += 1
        print("{} -> {}".format(src, des))
    else:
        hanno(n - 1, src, des, mid)
        hanno(1, src, mid, des)
        hanno(n - 1, mid, src, des)

hanno(4, "A", "B", "C")
print(count)

字典：

键值对

键不能重复,键是唯一的

1
2
test = {"name":"wangdacui", 'age':18, 'age':20}
print(test)

字典的使用；

1
2
3
4
5
6
7
8
test = {"name":"王大锤","age":18}
print(test.keys())
print(test.values())
print(test.items())
print(test.get('name'))
print(test.get('age'))
print(test.pop('age'))
print(len(test))	# 返回唯一的key的个数

jieba库的使用：

2018年之前，分词很重要

分词：

1.基于规则得到分词：（效果很差）

正向最大匹配(FMM) 逆向最大匹配(RMM) 双向最大匹配(取最好)

2.基于统计的分词

​ 基于N-Gram模型的分词（2-语言模型）（预测、文本纠错，评价）

3.基于深度学习的分词（序列标注–>BIO）

关键词提取

1.TF-IDF

2.TextRank

open函数

1
2
3
tf = open(“f.txt”, rt, encoding = "utf-8")
print(tf.readline())
tf.close()	# 如果不写，程序结束之后自动关闭

UTF-8编码，每个中文是3个字节

读文件： a.read()、 a.readline()、 a.readlines()

写文件：

​ a.write()、a.writeline()

a.seek(offest)

<变量名> = open(<文件名>，<打开模式>)

路径：

绝对路径

相对路径 ：{执行目录、目标文件} –> [“.”代表当前目录；“..”代表上一层目录；“/”代表下一层目录]

执行目录是指你执行py文件的目录，不一定与py文件处于同一目录。用相对路径对文件需要以执行目录为准！！

打开模式：

“r” 只读
“w” 覆盖写
“x” 创建写
“a” 追加写
“b” 二进制
“t” 文本
“+”

文件内容读取：

（相当于有一个光标，读到哪里光标移动到哪里，前面读过的不会再读了）

​ a.read()、全部读取；a.read(size=2)，读取前两个字符

​ a.readline()、读第一行；

​ a.readlines()、读所有行（以list表示）；

文件内容写入：

​ a.write()、 直接写

​ a.writeline()、 把一个迭代对象写进去，但是会拼接到一起

a.seek(offest) ：

调整光标的位置

a.seek(0) 移动到开头

a.seek(1) 当前位置

a.seek(2) 移动到结尾

数据维度:

一维：线性列表

数据有序：列表：a = [1,2,3]

数据无序：集合: a = {1,2,3}

存储：

​ 符号分隔：使用符号进行分割保留存储结构。（数据中不能有相对应的符号）

处理：

​ split()、join()

二维：表格形式

列表嵌套：a = [[a,b,c],[d,e,f]]

存储： csv文件，存储一个table

面向对象编程

类与对象

类和对象（实例）都有各自独立的存储空间

查找属性的时候先找对象再找类

方法分为：普通方法与内置方法

类中的方法中的self是什么意思？

—> 调用类方法的对象本身

私有属性：

类的外部不能访问，得用set,get方法

构造方法：

内置方法之一，方法名是__ init __，对象被创建优先调用

析构方法：

__ del __，对象被销毁的时候调用

(stu3 = stu2，指针传递)

1.局部变量作用域结束

2.使用del

3.程序结束

str方法：

输出的样式

比较内置方法

继承

如何通过继承的方式创建类：

class 子类名(父类名……. )

方法重写与鸭子类型

机器学习

监督，无监督，强化（RL）

监督–>传统监督，半监督

​ –>分类，回归

爬虫

http

网页的组成：html,css,javascript

ctrl + shift +c

<div> <span>

<h1> - <h6>

<p>

<a>

request访问网站

beautifulsoup4 解析网站