一jieba 中文分词库的用法

jieba 是 Python 中经典的中文分词工具，能将连续的中文文本按语义或词典规则切分为词语，广泛用于文本分析自然语言处理等场景。

安装方式

在命令行中通过 pip 安装：

pip install jieba

核心用法

1. 精确模式分词

将文本精确切分成词语，适合常规文本分析。

import jieba

text = "我喜欢用Python做数据分析"
result = jieba.lcut(text)  # 返回列表形式的分词结果
print(result)
# 输出：['我' '喜欢' '用' 'Python' '做' '数据' '分析']

2. 全模式分词

将文本中所有可能的词语都切分出来，会有冗余但能覆盖更多可能性。

import jieba

text = "我喜欢用Python做数据分析"
result = jieba.lcut(text cut_all=True)
print(result)
# 输出：['我' '喜欢' '用' 'Python' '做' '数据' '分析' '析']

3. 搜索引擎模式

在精确模式基础上，对长词再次切分，适合搜索引擎构建索引。

import jieba

text = "我喜欢用Python做数据分析"
result = jieba.lcut_for_search(text)
print(result)
# 输出：['我' '喜欢' '用' 'Python' '做' '数据' '分析']

4. 自定义词典

若默认词典未覆盖专业词汇，可添加自定义词典。

import jieba

# 自定义词典文件（如dict.txt，每行格式：词语 词频 词性）
jieba.load_userdict("dict.txt")  
text = "机器学习是人工智能的核心技术"
print(jieba.lcut(text))

二pow 函数的用法

pow() 是 Python 内置的幂运算函数，用于计算&ldquo；底数的指数次幂&rdquo；，支持三种使用场景，比运算符 ** 更灵活。

基础用法：pow(base exp)

计算 base 的 exp 次幂，等价于 base ** exp。

# 整数幂
print(pow(2 3))   # 2^3 = 8
# 浮点数幂
print(pow(4 0.5)) # 4的平方根 = 2.0
# 负指数幂
print(pow(2 -1))  # 2的-1次方 = 0.5
# 负数底数幂
print(pow(-3 2))  # (-3)^2 = 9

带模运算：pow(base exp mod)

计算 (base ** exp) % mod，内部做了优化，大数值计算时比先幂运算再取余更高效。

print(pow(2 3 5))   # (2^3) % 5 = 8 % 5 = 3
print(pow(10 2 7))  # (10^2) % 7 = 100 % 7 = 2
print(pow(5 0 10))  # (5^0) % 10 = 1 % 10 = 1（任何数的0次幂为1）

特殊场景注意

• 当 exp = 0 时，任何非零 base 的 0 次幂都为 1（如 pow(5 0) == 1）。
• 当 base = 0 且 exp >； 0 时，结果为 0（如 pow(0 3) == 0）。
• 当 base = 0 且 exp <； 0 时，会触发 ZeroDivisionError（数学上 0 不能做除数）。

三Python 中 format() 方法的全面用法解析

format() 是 Python 中用于字符串格式化的核心方法，通过占位符 {} 与格式说明符组合，可灵活处理字符串数字日期等多种数据的显示格式。以下是其主要用法分类详解：

一基础用法：参数传递与引用

format() 支持通过位置参数或关键字参数向占位符传递数据，适用于简单的变量替换场景。

1. 位置参数（按顺序引用）

占位符可通过索引（从0开始）指定引用的参数位置，或省略索引按顺序匹配。

# 省略索引：按参数顺序匹配
print("姓名：{}，年龄：{}".format("张三" 20))  
# 输出：姓名：张三，年龄：20

# 指定索引：可重复或打乱顺序引用
print("第2个参数：{1}，第1个参数：{0}，重复第1个：{0}".format("A" "B"))  
# 输出：第2个参数：B，第1个参数：A，重复第1个：A

2. 关键字参数（按名称引用）

占位符中使用 key 名称，format() 中通过 key=value 传递参数，更直观易读。

print("书名：{book}，作者：{author}，价格：{price}元".format(
    book="Python编程" 
    author="张三" 
    price=59.9
))  
# 输出：书名：Python编程，作者：张三，价格：59.9元

二填充与对齐：控制字符串排版

通过格式说明符 [填充字符][对齐方式][宽度] 控制字符串的对齐方式和填充效果，常用于生成规整的文本（如表格标题）。

1. 对齐方式

• ^：居中对齐
• <；：左对齐
• >；：右对齐

2. 填充字符

可指定任意字符（如 *=+ 等）作为填充符，默认用空格填充。

示例

# 居中对齐，总宽度10，用*填充
print("{:*^10}".format("居中"))  # 输出：****居中****

# 左对齐，总宽度10，用-填充
print("{:-<；10}".format("左对齐"))  # 输出：左对齐------

# 右对齐，总宽度10，用#填充
print("{:#>；10}".format("右对齐"))  # 输出：######右对齐

三数据类型格式化：针对性处理不同数据

format() 支持通过格式类型符对整数浮点数字符串等进行专项格式化，满足不同场景的显示需求。

1. 字符串格式化

• s：默认类型，显式指定字符串格式（可省略）。
• 配合 [.精度] 可截断字符串（保留前N个字符）。

# 显式指定字符串类型
print("字符串：{:s}".format("Hello"))  # 输出：字符串：Hello

# 截断字符串（保留前3个字符）
print("截断后：{:.3s}".format("Python"))  # 输出：截断后：Pyt

2. 整数格式化

支持十进制（默认）二进制八进制十六进制等多种进制转换，以及符号控制。

3. 浮点数格式化

可控制小数位数科学计数法百分比等显示形式。

示例

num = 123.4567

# 保留2位小数
print("保留2位：{:.2f}".format(num))  # 输出：保留2位：123.46

# 科学计数法
print("科学计数：{:.1e}".format(num))  # 输出：科学计数：1.2e+02

# 百分比
print("百分比：{:.0%}".format(num/100))  # 输出：百分比：123%

四高级用法：千位分隔符与嵌套格式化

1. 千位分隔符（处理大数字）

使用 作为格式符，可自动为整数或浮点数添加千位分隔符，增强可读性。

# 整数千位分隔
print("人口：{:}人".format(1400000000))  # 输出：人口：1400000000人

# 浮点数千位分隔（保留2位小数）
print("金额：{:.2f}元".format(123456.789))  # 输出：金额：123456.79元

2. 嵌套格式化（组合多种规则）

在一个占位符中同时使用多种格式说明符（如先填充对齐，再控制数据类型）。

# 居中对齐（宽度15，用=填充）+ 保留2位小数
print("{:=^15.2f}".format(3.14159))  
# 输出：======3.14=======

# 右对齐（宽度10，用$填充）+ 十六进制大写
print("${:>；$10X}".format(255))  
# 输出：$$$$$$$$FF

3. 格式化对象属性与表达式

format() 可直接引用对象的属性或执行简单表达式，无需提前定义变量。

class Person:
    def __init__(self name age):
        self.name = name
        self.age = age

p = Person("李四" 25)

# 格式化对象属性
print("姓名：{0.name}，年龄：{0.age}".format(p))  # 输出：姓名：李四，年龄：25

# 格式化表达式结果
print("1+2={}".format(1+2))  # 输出：1+2=3

四lambda 用法

在Python中，lambda 是用于创建匿名函数的关键字，其核心特点是&ldquo；简洁&rdquo；&mdash；&mdash；通常用于定义简单的单行的函数逻辑，无需显式命名。以下是 lambda 的全面用法总结，包含具体场景和示例：

一基本语法

lambda 函数的语法格式：

lambda 参数列表: 表达式

• 参数列表：可以是0个或多个参数（如 aab*args**kwargs 等）。
• 表达式：只能有一个表达式（不能包含循环多行逻辑等），函数返回该表达式的计算结果。

二核心用法场景

1. 定义简单的匿名函数（直接使用）

用于替代逻辑简单的命名函数（用 def 定义的函数），减少代码冗余。

示例：

# 用lambda定义一个加法函数
add = lambda a b: a + b
print(add(2 3))  # 输出：5

# 无参数的lambda（返回固定值）
hello = lambda: "Hello lambda!"
print(hello())  # 输出：Hello lambda!

# 带默认参数的lambda
power = lambda x n=2: x **n  # 计算x的n次方，默认n=2
print(power(3))   # 输出：9（3²）
print(power(2 3))# 输出：8（2³）

2. 作为高阶函数的参数（最常用场景）

lambda 常作为参数传递给高阶函数（如 sorted()map()filter() 等），用于简化临时函数的定义。

（1）与 sorted() 配合：指定排序规则

sorted(iterable key=...) 中，key 参数接受一个函数，用于提取排序的&ldquo；关键字&rdquo；，lambda 可快速定义该函数。

示例：

# 对列表中的元组按第二个元素排序
data = [(1 3) (4 1) (2 5)]
sorted_data = sorted(data key=lambda x: x[1])  # key=lambda x: x[1] 表示按元组第二个元素排序
print(sorted_data)  # 输出：[(4 1) (1 3) (2 5)]

# 对字典按值排序（返回键值对列表）
d = {"b": 2 "a": 1 "c": 3}
sorted_items = sorted(d.items() key=lambda x: x[1])  # 按值（x[1]）排序
print(sorted_items)  # 输出：[('a' 1) ('b' 2) ('c' 3)]


lis = {'微信': 3, '更好': 4, '我们': 7, '产品': 3, '开发': 4, '建立': 5, '系统': 3, '定制': 6, '平台': 4, '通过': 5}

it = list(lis.items())

it.sort(key=lambda x:x[1], reverse=True)
print(it) # 输出 [('我们', 7), ('定制', 6), ('建立', 5), ('通过', 5), ('更好', 4), ('开发', 4), ('平台', 4), ('微信', 3), ('产品', 3), ('系统', 3)]

（2）与 map() 配合：批量处理可迭代对象

map(func iterable) 用于对可迭代对象的每个元素应用 func 函数，lambda 可定义简单的处理逻辑。

示例：

# 对列表中每个元素求平方
nums = [1 2 3 4]
squared = map(lambda x: x** 2 nums)
print(list(squared))  # 输出：[1 4 9 16]

# 对两个列表对应元素求和
a = [1 2 3]
b = [4 5 6]
sum_ab = map(lambda x y: x + y a b)
print(list(sum_ab))  # 输出：[5 7 9]

（3）与 filter() 配合：过滤可迭代对象

filter(func iterable) 用于保留 func 返回 True 的元素，lambda 可定义过滤条件。

示例：

# 过滤出列表中的偶数
nums = [1 2 3 4 5 6]
evens = filter(lambda x: x % 2 == 0 nums)
print(list(evens))  # 输出：[2 4 6]

# 过滤出长度大于3的字符串
words = ["apple" "cat" "banana" "dog"]
long_words = filter(lambda s: len(s) >； 3 words)
print(list(long_words))  # 输出：['apple' 'banana']

（4）与 functools.reduce() 配合：累积计算

reduce(func iterable) 用于对可迭代对象进行累积计算（需导入 functools），lambda 可定义累积逻辑。

示例：

from functools import reduce

# 计算列表中所有元素的乘积
nums = [1 2 3 4]
product = reduce(lambda x y: x * y nums)  # 等价于 1*2*3*4
print(product)  # 输出：24

# 拼接字符串列表
words = ["I" "love" "Python"]
sentence = reduce(lambda x y: x + " " + y words)
print(sentence)  # 输出：I love Python

3. 作为函数的返回值（动态生成函数）

函数可以返回 lambda 函数，实现&ldquo；动态生成不同逻辑的函数&rdquo；的效果。

示例：

def make_operation(op):
    """根据操作符返回对应的lambda函数"""
    if op == "+":
        return lambda a b: a + b
    elif op == "-":
        return lambda a b: a - b
    elif op == "*":
        return lambda a b: a * b
    else:
        return lambda a b: a / b

# 动态生成加法函数
add = make_operation("+")
print(add(2 3))  # 输出：5

# 动态生成除法函数
divide = make_operation("/")
print(divide(6 2))  # 输出：3.0

4. 在数据结构中存储简单逻辑

可将 lambda 作为字典列表等数据结构的值，实现&ldquo；逻辑映射&rdquo；（根据键快速调用对应的处理逻辑）。

示例：

# 用字典存储不同的计算逻辑
operations = {
    "square": lambda x: x **2
    "cube": lambda x: x** 3
    "sqrt": lambda x: x **0.5
}

# 根据键调用对应的lambda函数
num = 4
print(operations["square"](num))  # 输出：16（平方）
print(operations["sqrt"](num))    # 输出：2.0（平方根）

5. 与类结合：简化简单方法

在类中，lambda 可用于定义简单的方法（但通常不推荐，可读性较差）。

示例：

class Calculator:
    def __init__(self):
        # 用lambda定义简单的方法
        self.add = lambda a b: a + b
        self.sub = lambda a b: a - b

calc = Calculator()
print(calc.add(5 3))  # 输出：8
print(calc.sub(5 3))  # 输出：2

三lambda 的局限性

1. 只能有一个表达式：无法包含循环条件语句（除非是单行三目运算符）return 等复杂逻辑。

   # 错误：lambda中不能有循环
   wrong = lambda x: for i in x: print(i)  # SyntaxError
   
   # 正确：可用单行三目运算符
   max_num = lambda a b: a if a >； b else b  # 等价于返回a和b中的最大值
   

2. 可读性限制：逻辑复杂时，lambda 会降低代码可读性，此时应使用 def 定义命名函数。

3. 无法包含文档字符串：lambda 函数没有文档字符串（__doc__），不利于代码注释和维护。

五二叉树遍历

      A
     / \
    B   C
   / \   \
  D   E   F
     / \ / \
    G  H I  J

六系统结构图的扇入、扇出、深度、宽度

七基础语法

1.string.printable

 ；

import string

char1 = 'a'
char2 = '%'
char3 = '\t' # 制表符

print(f"'{char1}' is in string.printable: {char1 in string.printable}")
print(f"'{char2}' is in string.printable: {char2 in string.printable}")
print(f"'{char3}' is in string.printable: {char3 in string.printable}")

**输出：**

#### 检查整个字符串 (重要陷阱)
当使用 `in` 运算符检查一个多字符的字符串时，它判断的是该字符串是否作为 **子字符串** 完整地连续地出现在 `string.printable` 中。`string.printable` 本身是一个无序的字符集合字符串，所以一个普通的单词（如 'hello'）几乎不可能在其中连续出现。

**示例代码：**
```python
import string

word = 'hello'

# 这会检查 'hello' 是否是 string.printable 的一个连续子串
print(f"'{word}' in string.printable: {word in string.printable}")

# 正确的检查方法是遍历字符串中的每一个字符
is_all_printable = all(char in string.printable for char in word)
print(f"All characters in '{word}' are in string.printable: {is_all_printable}")

'hello' in string.printable: False
All characters in 'hello' are in string.printable: True```

### 4. 与 `str.isprintable()` 方法的区别

Python 的字符串对象自身有一个 `.isprintable()` 方法，它与 `string.printable` 的用途相似但行为不同。

*   **`str.isprintable()`**: 这个方法检查字符串中 **所有** 字符是否都是可打印的。 如果字符串为空，它也返回 `True`。 像换行符 `\n` 和制表符 `\t` 这类在 `string.printable` 中存在的字符，在 `.isprintable()` 方法看来是 **不可打印** 的。
*   **`string.printable`**: 它是一个固定的字符串常量。 使用 `in` 来检查时，如上所述，它包含 `\n` `\t` 等空白字符。

**示例代码：**
```python
import string

my_string1 = "Hello World"
my_string2 = "Hello\tWorld"

# 使用 str.isprintable()
print(f"'{my_string1}'.isprintable(): {my_string1.isprintable()}")
print(f"'{my_string2}'.isprintable(): {my_string2.isprintable()}")

# 使用 string.printable
print(f"All chars in '{my_string2}' in string.printable: {all(c in string.printable for c in my_string2)}")

'Hello World'.isprintable(): True
'Hello\tWorld'.isprintable(): False
All chars in 'HelloWorld' in string.printable: True

import string

y1 = 'a'
y2 = 'asdf'
print(y1 in string.printable, y2 in string.printable)