NLP基础知识——文本处理、张量表示、文本数据分析

文本分词

jieba分词
繁体、简体都可以

#精确模式分词
import jieba
content='我来工作爱生活爱拉芳爱学习喜欢跳舞'
jieba.lcut(content,cut_all=False)
#全模式分词
jieba.lcut(content,cut_all=True)
#搜索引擎模式
jieba.lcut_for_search(content)
#自定义字典dict
jieba.load_userdict("./dict.txt")
jieba.lcut(content)

hanlp分词
基于tensorflow2.0

import hanlp
#zhongwen
tokenizer=hanlp.load('CTB6_CONVSEG')
tokenizer('我来工作爱生活,爱拉芳爱学习喜欢跳舞')
#英文
tokenizer=hanlp.utils.rules.tokenize_english
tokenizer('i love work and dog and wo')
#命名实体NER 也就是专有名词的划分
#中文
recognizer=hanlp.load(hanlp.pretrained.ner.MSRA_NER_BERT_BASE_ZH)
list('我来工作爱生活,爱拉芳爱学习喜欢跳舞')
recognizer(list('我来工作爱生活,爱拉芳爱学习喜欢跳舞'))
#英文
recognizer=hanlp.load(hanlp.pretrained.ner.COLL03_NER_BERT_BASE_UNCASED_EN)

词性标注

#中文的
#词性标注 动词、名词划分
import jieba.posseg as pseg
pseg.lcut("我爱工作爱生活爱学校")
#英文
tagger=hanlp.load(hanlp.pretrained.pos.PTB_POS_RNN_FASTTEXT_EN)

文本的张量表示

其实就是把文字变成数字,计算机才认识!!
one-hot编码
优缺点:操作简单,便于理解但是割裂了词与词的联系,占用内存大
假如4个词 ’我和小王‘
就可以表示为
我(1,0,0,0)
和(0,1,0,0)
以此类推的4*4的0-1矩阵

from sklearn.externals import joblib
#导入词汇映射器
from keras.preprocessing.text import Tokenizer
#初始化词汇表
vacal={"鹿晗","张翰","林更新"}
t=Tokenizer(num_words=None,char_level=False)
t.fit_on_text(vacal)
for token in vocal:zero_list=[0]*len(vocal)token_index=t.texts_to_sequences([token])[0][0]-1zero_list[token_index]=1
tokenizer_path='./e' #保存的位置
jolib.dump(t,tokenizer_path)

word2vec
无监督训练方法,将网络参数作为词汇的向量表示包括了cbow和skipgram。
CBOW步骤就是:如果i love nice day like ,假设窗口大小为3,则是i love nice 三个词,然后 i 和nice 作为输入,采用one-hot编码,(1,0,0,0,0)和(0,1,0,0,0)然后预测 love,以此内推,love nice day用love和day预测nice
skipgram的步骤和CBOW类似,输入和输出交换

 #lr表示学习率# 训练模型
import fasttest
model=fasttext.train_unsupervised(data,'cbow',dim=300,epoch=1,lr=0.05)
#训练完后检验,找到nice相关的词汇
model.get_nearest_neighbors('nice')
#保存模型
model.save_model('fil9.bin')
#用的时候直接调用
modelnew=fasttext.load_model('fil9.bin')

word embedding 词嵌入

# 导入torch和tensorboard导入进来
import torch
import json
import fileinput
from torch.utils.tensorboard import SummaryWriter# 实例化一个写入对象
writer = SummaryWriter()# 随机初始化一个100*50的矩阵, 将其视作已经得到的词嵌入矩阵
embedded = torch.randn(100, 50)# 导入事先准备好的100个中文词汇文件, 形成meta列表原始词汇
meta = list(map(lambda x: x.strip(), fileinput.FileInput("./vocab100.csv")))
writer.add_embedding(embedded, metadata=meta)
writer.close()

文本数据分析

也就是帮忙理解语调,标签正常不、特征丰富不、标签分类
下面以酒店评语的数据来进行文本分析

标签数量分布
酒店的评论有两列,第一列包括各种评论,第二列是评论的好坏 好的为1,不好的0

# 导入必备的工具包
import seaborn as sns
import pandas as pd
import matplotlib.pyplot as plt
import jieba
# 设置显示风格
plt.style.use('fivethirtyeight')
# 利用pandas读取训练数据和验证数据
train_data = pd.read_csv("./cn_data/train.tsv", sep="\t")
valid_data = pd.read_csv("./cn_data/dev.tsv", sep="\t")
# 获得训练数据标签的数量分布
sns.countplot("label", data=train_data)
plt.title("train_data")
plt.show()
# 获得验证数据标签的数量分布
sns.countplot("label", data=valid_data)
plt.title("valid_data")
plt.show()

## 获得训练集和验证集长度分布

# 在训练数据中添加新的句子长度列, 每个元素的值都是对应句子的长度
train_data["sentence_length"] = list(map(lambda x: len(x), train_data["sentence"]))# 绘制句子长度列的数量分布
# sns.countplot("sentence_length", data=train_data)
# plt.xticks([])
# plt.show()# 绘制dist长度分布图
# sns.distplot(train_data["sentence_length"])
# plt.yticks([])
# plt.show()
#---------------------------------=-----------------------
# 在验证数据中添加新的句子长度列, 每个元素的值对应句子的长度
valid_data["sentence_length"] = list(map(lambda x: len(x), valid_data["sentence"]))
# 绘制句子长度列的数量分布图
# sns.countplot("sentence_length", data=valid_data)
# plt.xticks([])
# plt.show()
# 绘制dist长度分布图
# sns.distplot(valid_data["sentence_length"])
# plt.yticks([])
# plt.show()
# 绘制训练数据语句长度的散点图
# sns.stripplot(y="sentence_length", x="label", data=train_data)
# plt.show()# 绘制验证数据语句长度的散点图
# sns.stripplot(y="sentence_length", x="label", data=valid_data)
# plt.show()

统计不同词汇的数量

# 进行训练集的句子进行分词, 并统计出不同词汇的总数
# train_vocab = set(chain(*map(lambda x: jieba.lcut(x), train_data["sentence"])))
# print("训练集共包含不同词汇总数为:", len(train_vocab))# 进行验证集的句子进行分词, 并统计出不同词汇的总数
# valid_vocab = set(chain(*map(lambda x: jieba.lcut(x), valid_data["sentence"])))
# print("验证集共包含不同词汇总数为:", len(valid_vocab))

训练集词云

# 导入jieba 中的词性标注工具包
import jieba.posseg as pseg# 定义获取形容词的列表函数
def get_a_list(text):# 使用jieba的词性标注方法来切分文本, 获得两个属性word,flag# 利用flag属性去判断一个词汇是否是形容词r = []for g in pseg.lcut(text):if g.flag == 'a':r.append(g.word)return r
# 导入绘制词云的工具包
from wordcloud import WordCloud# 定义获取词云的函数并绘图
def get_word_cloud(keywords_list):# 首先实例化词云类对象, 里面三个参数# font_path: 字体路径,为了能够更好的显示中文# max_words: 指定词云图像最多可以显示的词汇数量# backgroud_color: 代表图片的北京颜色wordcloud = WordCloud(max_words=100, background_color='white')# 将传入的列表参数转化为字符串形式, 因为词云对象的参数要求是字符串类型keywords_string = " ".join(keywords_list)# 生成词云wordcloud.generate(keywords_string)# 绘图plt.figure()plt.imshow(wordcloud, interpolation="bilinear")plt.axis("off")plt.show()# 获取训练集上的正样本
p_train_data = train_data[train_data["label"]==1]["sentence"]# 对正样本的每个句子提取形容词
train_p_a_vocab = chain(*map(lambda x: get_a_list(x), p_train_data))# 获取训练集上的负样本
n_train_data = train_data[train_data["label"]==0]["sentence"]# 对负样本的每个句子提取形容词
train_n_a_vocab = chain(*map(lambda x: get_a_list(x), n_train_data))# 调用获取词云的函数
get_word_cloud(train_p_a_vocab)
get_word_cloud(train_n_a_vocab)
#-------------------------------------------------------------
# 获取验证集的数据正样本
p_valid_data = valid_data[valid_data["label"]==1]["sentence"]# 获取正样本的每个句子的形容词
valid_p_a_vocab = chain(*map(lambda x: get_a_list(x), p_valid_data))# 获取验证集的数据负样本
n_valid_data = valid_data[valid_data["label"]==0]["sentence"]# 获取负样本的每个句子的形容词
valid_n_a_vocab = chain(*map(lambda x: get_a_list(x), n_valid_data))# 调用获取词云的函数
get_word_cloud(valid_p_a_vocab)
get_word_cloud(valid_n_a_vocab)

文本特征处理
包括语料、长度的处理
‘我 喜欢 工作’假设是【2,43,56】
1.n-gram特征:就是特征中假如到相邻的特征 而我和喜欢相邻假设是89 加到里面 喜欢和工作相邻假设是5 加入其中【2,43,56,89,5】

#n-gram
def creat_ngram_set(input_list):return set(zip(*[input_list[i:] for i in range(ngram_range)]))
input_list=[4,2,89,56,7]
#长度规范 能够覆盖90%以上的语料长度
假设是20,不足加0,长度大于20保留后面20个舍去前面的
cutlen=20
def padding(x_train):return sequence.pad_sequences(x_train,cutlen)

文本增强
回译数据增强,基于google翻译接口,将原始的中文句子翻译成另外一种语言如英语,然后又翻译回来
优势劣势:获得预料质量高,但是对于短文本可能重复率高,那么也可以中文变成英语,英语变韩文然后再变回中文

word1='我爱狗狗'
word2='她和他的家的东西'
from gooletrain import Translator
translator=Translator()
#ko是韩语
translations=translator.translate([word1,word2],dest='ko')
ko_result=list(map(lambda x:x.text,translations))
#翻译回来
translations=translator.translate(ko_result,dest='zh-cn')
cn_result=list(map(lambda x:x.text,translations))

新闻主题分类

看这一段新闻是哪一类的体育?财经?
首先导入我们需要的数据

# 导入相关的工具包
import torch
import torchtext
# 导入数据集中的文本分类任务
from torchtext.datasets import text_classification
import os# 定义数据下载路径, 当前文件夹下的data文件夹
load_data_path = "./data"
if not os.path.isdir(load_data_path):os.mkdir(load_data_path)# 选取torchtext包中的文本分类数据集'AG_NEWS', 即新闻主题分类数据
# 顺便将数据加载到内存中
train_dataset, test_dataset = text_classification.DATASETS['AG_NEWS'](root=load_data_path)

构建带有embedding的文本分类模型
对数据batch处理
构建训练和验证函数
训练模型和验证
查看嵌入的词向量
注意troch.nn里面有很多神经网络的

# 导入相关工具包
import torch
import torch.nn as nn
import torch.nn.functional as F# 指定BATCH_SIZE的大小
BATCH_SIZE = 1import torchtext
# 导入数据集中的文本分类任务
from torchtext.datasets import text_classification
import os# 定义数据下载路径, 当前文件夹下的data文件夹
load_data_path = "./data"
if not os.path.isdir(load_data_path):os.mkdir(load_data_path)# 选取torchtext包中的文本分类数据集'AG_NEWS', 即新闻主题分类数据
# 顺便将数据加载到内存中
train_dataset, test_dataset = text_classification.DATASETS['AG_NEWS'](root=load_data_path)# 进行设备检测, 如果有GPU的话有限使用GPU进行模型训练, 否则在CPU上进行训练
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")# 构建文本分类的类
class TextSentiment(nn.Module):def __init__(self, vocab_size, embed_dim, num_class):# vocab_size: 代表整个语料包含的单词总数# embed_dim: 代表词嵌入的维度# num_class: 代表是文本分类的类别数 这里是4super().__init__()# 实例化EMbedding层的对象, 传入3个参数, 分别代表单词总数, 词嵌入的维度, spqrse进行梯度求解时只更新部分权重self.embedding = nn.Embedding(vocab_size, embed_dim, sparse=True)# 实例化全连接线性层的对象, 两个参数分别代表输入的维度和输出的维度self.fc = nn.Linear(embed_dim, num_class)# 对定义的所有层权重进行初始化self.init_weights()def init_weights(self):# 首先给定初始化权重的值域范围initrange = 0.5# 各层的权重使用均匀分布进行初始化self.embedding.weight.data.uniform_(-initrange, initrange)self.fc.weight.data.uniform_(-initrange, initrange)self.fc.bias.data.zero_()def forward(self, text):# text: 代表文本进过数字化映射后的张量# 对文本进行词嵌入的操作embedded = self.embedding(text)c = embedded.size(0) // BATCH_SIZEembedded = embedded[:BATCH_SIZE * c]# 明确一点, 平均池化的张量需要传入三维张量, 而且在行上进行操作embedded = embedded.transpose(1, 0).unsqueeze(0)# 进行平均池化的操作embedded = F.avg_pool1d(embedded, kernel_size=c)# 首先将三维张量恢复成二维张量, 再将行列进行转置return self.fc(embedded[0].transpose(1, 0))# 获取整个语料中词汇的总数
VOCAB_SIZE = len(train_dataset.get_vocab())# 指定词嵌入的维度
EMBED_DIM = 32# 获取真个文本分类的总数
NUM_CLASS = len(train_dataset.get_labels())# 实例化模型对象
model = TextSentiment(VOCAB_SIZE, EMBED_DIM, NUM_CLASS).to(device)
#----------------------------------------------------------------------------------------------------------
# 构建产生批次数据的函数
def generate_batch(batch):# batch: 由样本张量和标签的元组所组成的batch_size大小的列表# 首先提取标签的列表label = torch.tensor([entry[1] for entry in batch])# 然后提取样本张量text = [entry[0] for entry in batch]text = torch.cat(text)return text, labelbatch = [(torch.tensor([3,23,2,8]), 1), (torch.tensor([3,45,21,6]), 0)]
res = generate_batch(batch)
print(res)
#---------------
# 导入数据加载器的工具包,处理数据的
from torch.utils.data import DataLoader#--------------------------------------------------------------
# 编写训练函数的代码
def train(train_data):# train_data: 代表传入的训练数据# 初始化训练损失值和准确率train_loss = 0train_acc = 0# 使用数据加载器构建批次数据,shuffle随机打乱,返回的是text和lable的张量data = DataLoader(train_data, batch_size=BATCH_SIZE, shuffle=True, collate_fn=generate_batch)# 对data进行循环遍历, 使用每个batch数据先进行训练for i, (text, cls) in enumerate(data):# 训练模型的第一步: 将优化器的梯度清零optimizer.zero_grad()# 将一个批次的数据输入模型中, 进行预测output = model(text)# 计算预测值和真实标签之间的损失loss = criterion(output, cls)# 将该批次的损失值累加到总损失中train_loss += loss.item()# 进行反向传播的计算loss.backward()# 参数更新optimizer.step()# 计算该批次的准确率并加到总准确率上, 注意一点这里加的是准确的数字train_acc += (output.argmax(1) == cls).sum().item()# 进行整个轮次的优化器学习率的调整scheduler.step()# 返回本轮次训练的平均损失值和平均准确率return train_loss / len(train_data), train_acc / len(train_data)# 编写验证函数的代码
def valid(valid_data):# valid_data: 代表验证集的数据# 初始化验证的损失值和准确率valid_loss = 0valid_acc = 0# 利用数据加载器构造每一个批次的验证数据data = DataLoader(valid_data, batch_size=BATCH_SIZE, collate_fn=generate_batch)# 循环遍历验证数据for text, cls in data:# 注意: 在验证阶段, 一定要保证模型的参数不发生改变, 也就是不求梯度,直接用训练的参数with torch.no_grad():# 将验证数据输入模型进行预测output = model(text)# 计算损失值loss = criterion(output, cls)# 将该批次的损失值累加到总损失值中valid_loss += loss.item()# 将该批次的准确数据累加到总准确数字中valid_acc += (output.argmax(1) == cls).sum().item()# 返回本轮次验证的平均损失值和平均准确率return valid_loss / len(valid_data), valid_acc / len(valid_data)
#---------------------------------------
# 导入时间工具包
import time
# 导入数据的随机划分方法工具包
from torch.utils.data.dataset import random_split# 指定训练的轮次
N_EPOCHS = 10# 定义初始的验证损失值
min_valid_loss = float('inf')# 定义损失函数, 定义交叉熵损失函数
criterion = torch.nn.CrossEntropyLoss().to(device)# 定义优化器, 定义随机梯度下降优化器
optimizer = torch.optim.SGD(model.parameters(), lr=4.0)# 定义优化器步长的一个优化器, 专门用于学习率的衰减
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 1, gamma=0.9)# 选择全部训练数据的95%作为训练集数据, 剩下的5%作为验证数据
train_len = int(len(train_dataset) * 0.95)sub_train_, sub_valid_ = random_split(train_dataset, [train_len, len(train_dataset) - train_len])# 开始每一次的训练模型
for epoch in range(N_EPOCHS):# 记录训练开始的时间start_time = time.time()# 将训练数据和验证数据分别传入训练函数和验证函数中, 得到训练损失和准确率, 以及验证损失和准确率train_loss, train_acc = train(sub_train_)valid_loss, valid_acc = valid(sub_valid_)# 计算当前轮次的总时间secs = int(time.time() - start_time)# 将耗时的秒数转换成分钟+秒mins = secs / 60secs = secs % 60# 打印训练和验证的耗时, 损失值, 准确率值print('Epoch: %d' % (epoch + 1), " | time in %d minites, %d seconds" % (mins, secs))print(f'\tLoss: {train_loss:.4f}(train)\t|\tAcc: {train_acc * 100:.1f}%(train)')print(f'\tLoss: {valid_loss:.4f}(valid)\t|\tAcc: {valid_acc * 100:.1f}%(valid)')print('********************')
print(model.state_dict()['embedding.weight'])
#-------------看emdedding的词向量
print(model.state_dict()['embedding.weight'])

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/pingmian/32523.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Java中的编译时与运行时注解

Java中的编译时与运行时注解 大家好,我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编,也是冬天不穿秋裤,天冷也要风度的程序猿! 注解(Annotation)是Java语言的一项重要特性,广…

数学建模---包汤圆问题引发的思考

1.前言 (1)虽然我学习这个数学建模已经很长一段时间了,但是我认为自己始终是一个门外汉,只是学习了一下这个基本的建模软件使用方法,以及一些相关的知识,虽然参加了一次这个电工杯的比赛,但是这…

1.Triangle

一、你好,三角形 在OpenGL中,任何事物都在3D空间中,而屏幕和窗口却是2D像素数组,这导致OpenGL的大部分工作都是关于把3D坐标转变为适应你屏幕的2D像素。 3D坐标转为2D坐标的处理过程是由OpenGL的图形渲染管线(Graphi…

Linux 下判断一个字符串ip是否合法

Linux 下判断一个字符串ip是否合法 C regexQt C ip是否合法参考 C regex #include <iostream> #include <regex> #include <string>bool is_valid_ip(std::string ip_str) {// 定义IPv4地址正则表达式//std::regex ipv4_regex("^([01]?[0-9]?[0-9]|2…

SQL中的DISTINCT用法总结

SQL中的DISTINCT用法总结 大家好&#xff0c;我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编&#xff0c;也是冬天不穿秋裤&#xff0c;天冷也要风度的程序猿&#xff01; 1. DISTINCT的基本概念 在SQL中&#xff0c;DISTINCT是一种用于去除查询结果中重复行…

稳态与敏态业务阶段

稳态业务就是比如你登录学校的图书馆教务处这些业务系统 用户数量和数据基本上不会发生太大的变化 业务系统的更新也不是很频繁&#xff0c;比较方便资源的采购 敏态业务就是比如我开发一个应用上线了&#xff0c;我不知道有多少用户和数量&#xff0c;无法预估 这就没办法…

2小时极速入门 TypeScript-慕课网 笔记

TS文档&#xff1a;https://www.tslang.cn/docs/handbook/modules.html 一&#xff0c;什么是TS 注:Typescript无法在浏览器中运行 ,所以需要编译器,将TS转变为JS 问&#xff1a;TS运行这么麻烦&#xff0c;为什么还要有TS&#xff1f; 答&#xff1a;TS强类型 1&#xff0c;规…

腾讯云OpenCloudOS系统上安装MySQL

在腾讯云OpenCloudOS系统上安装MySQL&#xff0c;可以通过以下步骤进行&#xff1a; 更新软件包列表&#xff1a; sudo yum update -y 安装MySQL服务器&#xff1a; sudo yum install mysql-server -y 启动MySQL服务&#xff1a; sudo systemctl start mysqld 设置MySQL…

LDO VS buck的优缺点对比:LDO(效率低但稳压);DCDC(降压buck,效率高但噪声大)

LDO&#xff1a; Low Dropout Regulator&#xff0c;低压差稳压器 低压差&#xff1a;输入电压与输出电压的差值低&#xff1b; 稳压&#xff1a;当输入电压VIN在正常范围内时&#xff0c;输出电压VOUT都稳定在一个我们需要的固定电压值&#xff1b; 举个栗子&#xff0c;输…

Selenium WebDriverWait和expected_conditions来定位实时更新的元素

WebDriverWait 是 Selenium WebDriver 的一个等待机制&#xff0c;用于等待一个特定条件成立直到一个最大的时间阈值。这种等待方式是显式等待&#xff0c;与隐式等待相对。显式等待提供了一种更灵活的方式来等待页面上的元素或条件&#xff0c;因为它允许你指定等待条件和时间…

Opencv学习项目4——pyzbar

Pyzbar介绍 Pyzbar 是一个用于解码条形码和二维码的 Python 库。它是基于 ZBar 条形码扫描器库的 Python 绑定&#xff0c;支持多种条形码格式&#xff0c;包括 QR 码、EAN-13、UPC-A、Code 128 等。 Pyzbar 的主要功能 解码多种类型的条形码和二维码&#xff1a;支持包括 QR 码…

前端构建工具其配置过程

前端构建工具&#xff08;如Webpack、Rollup等&#xff09;其配置过程。 前端构建工具&#xff0c;如Webpack和Rollup&#xff0c;是用于管理和优化前端项目模块化结构的工具。它们的主要任务是打包代码&#xff0c;压缩资源&#xff0c;处理依赖&#xff0c;以及实现模块化的…

Python: HexBinDecOct

因为&#xff1a; f0b1001110# 十进制 int()a0*2**01*2**11*2**21*2**30*2**40*2**51*2**6print(a)# 八进制 oct()print(78/8,78%8)# 110 001 001 8 116print(1*2**00*2**10*2**2,1*2**00*2**10*2**2,0*2**01*2**11*2**2)#十六进制 hex()#0 100 1110 16 4Eprint(sixteenFoo(0*…

SpringCloud微服务框架的原理及应用详解(四)

本系列文章简介&#xff1a; 随着云计算、大数据和物联网等技术的飞速发展&#xff0c;企业应用系统的规模和复杂度不断增加&#xff0c;传统的单体架构已经难以满足快速迭代、高并发、高可用性等现代业务需求。在这样的背景下&#xff0c;微服务架构应运而生&#xff0c;成为了…

汉语拼音字母表 (声母表和韵母表)

汉语拼音字母表 [声母表和韵母表] 1. 汉语拼音声母表2. 汉语拼音韵母表References 1. 汉语拼音声母表 声母是韵母前的辅音&#xff0c;与韵母一起构成一个完整的音节。 辅音是发声时&#xff0c;气流在口腔中受到各种阻碍所产生的声音&#xff0c;发音的过程即是气流受阻和克…

Python中的交互式GUI开发:与MATLAB uicontrol的比较

Python中的交互式GUI开发 Python中的交互式GUI开发&#xff1a;与MATLAB uicontrol的比较**Python GUI开发库****Tkinter****PyQt/PySide** **与MATLAB的比较****总结** Python中的交互式GUI开发&#xff1a;与MATLAB uicontrol的比较 在MATLAB中&#xff0c;uicontrol 是一个…

ubuntu设置第三方库环境变量

首先打开~/.bashrc配置文件 sudo gedit ~/.bashrc打开后文末添加,/xxx改成你库文件的路径 export LD_LIBRARY_PATH/xxx:$LD_LIBRARY_PATH 记住最最最重要的事情source一下 source ~/.bashrc 具体了解.bashrc配置文件的&#xff0c;可以看看 .bashrc

【设计模式之访问者模式 -- C++】

访问者模式 – 操作对象&#xff0c;分离算法 访问者模式&#xff08;Visitor Pattern&#xff09;是一种将算法与对象结构分离的设计模式。这种模式主要用于操作一个由许多对象构成的复杂对象结构&#xff0c;它能够在不修改这些对象的类的前提下定义作用于这些对象的新操作。…

Linux信号量机制总结与实例解析

目录 第一章&#xff1a;Linux信号量基础 1.1 信号量概念 1.2 信号量类型 1.3 信号量操作 1.4 实战案例&#xff1a;信号量在多线程同步中的应用 1.5 实战案例&#xff1a;信号量在进程间同步中的应用 第二章&#xff1a;Linux信号量高级应用 2.1 信号量与实时操作系统 …

2024年6月大众点评成都餐饮店铺POI分析22万家

2024年6月大众点评成都餐饮店铺POI共有221002家 店铺POI点位示例&#xff1a; 店铺id CACuqlcUQApLA7Ki 店铺名称 峨眉山豆腐脑(百吉街店) 十分制服务评分 7.3 十分制环境评分 7.5 十分制划算评分 7.1 人均价格 18 评价数量 38 店铺地址 百吉街86号1层 大类 美食 中类…