日期: 2021 年 4 月 27 日

操作步骤：

xshell 下载  https://xshell.en.softonic.com/

点击下载后，会有邮箱验证，点击验证通过就会自动下载，然后安装就行。

打开工具，点击新建会话

然后

浏览文件后直接点击确认，出来这样就登录成功了

记录下命令，

看动态日志的 ： tail -f /data/logs/work-telecom-chongqing-web/work-telecom-chongqing-web.2020-03-27.0.log

cd /data/logs   这是日志的目录，所有项目都有

sudo sh /root/twork_telecom_chongqing.web.sh

选择排序详解

前言： *近换工作，面试稍微大一点的厂都会被问到算法和数据结构这块知识，得空自己总结一下吧，总结不到位希望大佬指正哈。

情景记忆： 选择排序其实蛮好记的，看排序的名称就很容易联想，“选择”是这个排序的核心思想，那选择的时候是怎么选择的呢，其实要记住这个排序你就联想择优或者淘汰机制就很容易记住：择优是从一堆参差不齐的同种物品中选择*好的，比如有一对苹果，有大有小，我们择大而食；淘汰就是从一堆参差不齐的物品中淘汰*烂的，比如还是有一堆苹果，这次是腐烂程度不同的苹果或者快要腐烂，我们要从中选择腐烂程度*大的苹果丢弃。

逻辑实现： 以上的记忆方法是不是很贴近生活，这样就很容易记住了。逻辑其实也十分简单，一次选择一个*好的或*坏的出来，那么有N个数进行排序，那我们就可以看成是N趟排序，而一趟排序要对数值对比N次。

代码实现：
正向排序：

def select_sort(my_list):
llen = len(my_list)
for i in range(llen):
print(“第%s趟：” % (i + 1), my_list)
for j in range(i, llen):
if my_list[j] < my_list[i]:
my_list[j], my_list[i] = my_list[i], my_list[j]

if __name__ == ‘__main__’:
my_list = [7, 2, 0, 1, 5, 6, 8, 3, 9, 4]
select_sort(my_list)

运行结果：
第1趟： [7, 2, 0, 1, 5, 6, 8, 3, 9, 4]
第2趟： [0, 7, 2, 1, 5, 6, 8, 3, 9, 4]
第3趟： [0, 1, 7, 2, 5, 6, 8, 3, 9, 4]
第4趟： [0, 1, 2, 7, 5, 6, 8, 3, 9, 4]
第5趟： [0, 1, 2, 3, 7, 6, 8, 5, 9, 4]
第6趟： [0, 1, 2, 3, 4, 7, 8, 6, 9, 5]
第7趟： [0, 1, 2, 3, 4, 5, 8, 7, 9, 6]
第8趟： [0, 1, 2, 3, 4, 5, 6, 8, 9, 7]
第9趟： [0, 1, 2, 3, 4, 5, 6, 7, 9, 8]
第10趟： [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

逆向排序：

def select_sort(my_list):
llen = len(my_list)
for i in range(llen):
print(“第%s趟：” % (i + 1), my_list)
for j in range(i, llen):
if my_list[j] > my_list[i]:
my_list[j], my_list[i] = my_list[i], my_list[j]

if __name__ == ‘__main__’:
my_list = [7, 2, 0, 1, 5, 6, 8, 3, 9, 4]
select_sort(my_list)

运行结果：
第1趟： [7, 2, 0, 1, 5, 6, 8, 3, 9, 4]
第2趟： [9, 2, 0, 1, 5, 6, 7, 3, 8, 4]
第3趟： [9, 8, 0, 1, 2, 5, 6, 3, 7, 4]
第4趟： [9, 8, 7, 0, 1, 2, 5, 3, 6, 4]
第5趟： [9, 8, 7, 6, 0, 1, 2, 3, 5, 4]
第6趟： [9, 8, 7, 6, 5, 0, 1, 2, 3, 4]
第7趟： [9, 8, 7, 6, 5, 4, 0, 1, 2, 3]
第8趟： [9, 8, 7, 6, 5, 4, 3, 0, 1, 2]
第9趟： [9, 8, 7, 6, 5, 4, 3, 2, 0, 1]
第10趟： [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

选择排序总结：
没有*好的算法只有*合适的算法，一个算法的好坏，与运用的场景通常是于算法的时间复杂度、空间复杂度和稳定性相关的。

时间复杂度：时间复杂度的衡量标准是每次比较和交换位置所花的时间综合，也就是完成排序所花的时间总和称为时间复杂度；计算标准是一次循环（不论循环几次）我们记为n，如果能够差分为二叉树结构的我们记为log n，那么选择排序的时间复杂度我们可用看出是O(n^2)

空间复杂度：空间复杂度的衡量标准是在完成排序的整个过程中是否有申请新的存储空间来完成排序，如果有，且申请的空间越多那么我们则认为该算法的空间复杂度约复杂，那么冒泡排序在过程中没有申请存储空间，所有我们认为选择排序的空间复杂度小（除了自己本身）

稳定性：即在原序列中，list[i]=list[j]，且list[i]在list[j]之前，而在排序后的序列中，list[i]仍在list[j]之前，则称这种排序算法是稳定的,否则称为不稳定的,那么我们认为冒泡排序是稳定的，稳定性比较：堆排序、快速排序、希尔排序、选择排序是不稳定的排序算法，而冒泡排序、插入排序、归并排序是稳定的排序算法。

基于基础c语言的水仙花数编程方法

首先，什么是水仙花数？
水仙花数（Narcissistic number）也被称为超完全数字不变数（pluperfect digital invariant, PPDI）、自恋数、自幂数、阿姆斯壮数或阿姆斯特朗数（Armstrong number），水仙花数是指一个 3 位数，它的每个位上的数字的 3次幂之和等于它本身（例如：1^3 + 5^3+ 3^3 = 153）。

那么，如何用基础的c语言语句来编写一个能够实现3~7位的水仙花数的输出呢？

这边，我们需要用到几个简单的循环语句。

下面进行水仙花数基于c语言简单循环语句的编写。

思路
将程序大致分为两个模块，一个模块确定数的范围，一个模块用来遍历寻找水仙花数。

方法
1.确定程序输出的水仙花数的数值范围，比如我需要实现一个3位数水仙花数的输出，那么，我们的数值范围就是100~999

for (i = 1; i < n; i++) {
first *= 10;
}
printf(“%d\n”, first);

2.水仙花数是怎么定义的呢，简单点就比如153=1^3 + 5^3+ 3^3，由于我们使用的是简单的循环语句，暂时不用到函数，所以我们需要对一个数进行循环相乘。比如1的三次方我需要循环相乘3次来得到。而在数循环相乘之前，我们需要对这个数进行拆分。比如：153拆分成1 5 3三个独立的数值。

do {
int d = t;
d %= 10;
t /= 10;

} while (t > 0);

一位一位进行取余处理，这样循环多次即可分离出各个独立的数值。

3.分离出来的独立的数值还需进行自乘，1的三次方=1*1*1，我们可以用循环语句来实现。

int j;
int p = d;
for (j = 1; j < n; j++) {
p *= d；
}

4. *后，便是判断，定义一个sum，如果sum=i，我们即可输出这个sum为水仙花数

sum += p；

if (sum == i) {
printf(“%d\n”, sum);

}

*后，输出即可。总代码如下：

#include<stdio.h>

int main() {
int n;
scanf_s(“%d”, &n);
int first = 1;
int i = 1;

for (i = 1; i < n; i++) {            //确定范围
first *= 10;
}
printf(“%d\n”, first);
i = first;

while (i < first * 10) {            //遍历寻找水仙花数
int t = i;
int sum = 0;
do {                                 //对数进行拆分处理
int d = t;
d %= 10;
t /= 10;
int j;
int p = d;
for (j = 1; j < n; j++) {
p *= d;

}
sum += p;
} while (t > 0);

if (sum == i) {                 //判断是否为水仙花数
printf(“%d\n”, sum);
}
i++;
}
return 0;
}

记录自己学习c语言的路程，加油。

自然语言处理——中英文分词

目录
英文分词

中文分词

机械分词法

正向*大匹配法

逆向*大匹配法

双向*大匹配法

统计分词法

语料统计法

序列标注法

英文分词
英文原文： it is a good day!
分词结果： it , is , a , good , day , !
通过上面的英文分词例子，可以发现英文文本词与词之间有空格或者标点符号，如果想要对这种普通的英文文本进行分词的话是不需要什么算法支撑，直接通过空格或者标点来将文本进行分开就可以完成英文分词。

如果要对多个英文文本分词，要求同时以 , ， . ， ? ， ! ， 五个符号分词。为了方便调用，我们将代码写成一个函数。首先对原文本以其中一个规则切分后，再对分好后的文本进行下一个规则的切分，再对分好的文本进行切分，直到按 5 个规则切分完成，*后将切分好的词添加进 tokenized_text 并返回。这里还是把 .split() 方法当作拆分的核心：

def tokenize_english_text(text):
# 首先，我们按照标点来分句
# 先建立一个空集用来，用来将分好的词添加到里面作为函数的返回值
tokenized_text = []
# 一个 text 中可能不止一个内容，我们对每个文本单独处理并存放在各自的分词结果中。
for data in text:
# 建立一个空集来存储每一个文本自己的分词结果，每对 data 一次操作我们都归零这个集合
tokenized_data = []
# 以 ‘.’分割整个句子，对分割后的每一小快 s：
for s in data.split(‘.’):
# 将’s’以 ‘？’分割，分割后的每一小快 s2：
for s1 in s.split(‘?’):
# 同样的道理分割 s2，
for s2 in s1.split(‘!’):
# 同理
for s3 in s2.split(‘,’):
# 将 s3 以空格分割，然后将结果添加到 tokenized_data 当中
tokenized_data.extend(
s4 for s4 in s3.split(‘ ‘) if s4 != ”)
# 括号内的部分拆开理解
# for s4 in s3.split(‘ ‘):
# if s4!=”: 这一步是去除空字符”。注意与’ ‘ 的区别。
# 将每个 tokenized_data 分别添加到 tokenized_text 当中
tokenized_text.append(tokenized_data)

return tokenized_text
写好函数后，我们来调用函数对英文文本分词。为了直观展示，我们自定义多个文本，模拟英文应用中的多个文本：

a = [‘i am a boy?i am a boy ! i am a boy,i’, ‘god is a girl’, ‘i love you!’]
result = tokenize_english_text(a)
result

# 输出结果如下
# [[‘i’, ‘am’, ‘a’, ‘boy’, ‘i’, ‘am’, ‘a’, ‘boy’, ‘i’, ‘am’, ‘a’, ‘boy’, ‘i’],
# [‘god’, ‘is’, ‘a’, ‘girl’],
# [‘i’, ‘love’, ‘you’]]
中文分词
中文原文： 今天是个好日子。
分词结果： 今天 | 是 | 个 | 好 | 日子 。
在中文中，文本是由连续的字序列构成，词和词之间没有天然的分隔符。不同分词方法的结果会影响到词性，句法等问题。分词作为一个方法，如果运用场景不同，要求不同，*终对任务达到的效果也不同。可以说中文分词相对英文分词有很大的困难。

机械分词法
机械分词方法又叫做基于规则的分词方法：这种分词方法按照一定的规则将待处理的字符串与一个词表词典中的词进行逐一匹配，若在词典中找到某个字符串，则切分，否则不切分。机械分词方法按照匹配规则的方式，又可以分为：正向*大匹配法，逆向*大匹配法和双向匹配法三种。

正向*大匹配法
正向*大匹配法（Maximum Match Method，MM 法）是指从左向右按*大原则与词典里面的词进行匹配。假设词典中*长词是 ?m 个字，那么从待切分文本的*左边取 ?m 个字符与词典进行匹配，如果匹配成功，则分词。如果匹配不成功，那么取 ?−1m−1 个字符与词典匹配，一直取直到成功匹配为止。

首先我们先给定文本和字典：

# 文本
text = ‘我们是共产主义的接班人’

# 词典
dic = (‘我们’, ‘是’, ‘共产主义’, ‘的’, ‘接班’, ‘人’, ‘你’, ‘我’, ‘社会’, ‘主义’)
然后我们需要遍历词典来求出*长词的长度：

# 初始*长词长度为 0
max_len_word0 = 0
for key in dic:
# 若当前词长度大于 max_len_word，则将 len(key)值赋值给 max_len_word
if len(key) > max_len_word0:
max_len_word0 = len(key)
下面是通过循环来完成 MM 法：

sent = text
words = [] # 建立一个空数组来存放分词结果：
max_len_word = max_len_word0
# 判断 text 的长度是否大于 0，如果大于 0 则进行下面的循环
while len(sent) > 0:
# 初始化想要取的字符串长度
# 按照*长词长度初始化
word_len = max_len_word
# 对每个字符串可能会有(max_len_word)次循环
for i in range(0, max_len_word):
# 令 word 等于 text 的前 word_len 个字符
word = sent[0:word_len]
# 为了便于观察过程，我们打印一下当前分割结果
print(‘用 【’, word, ‘】 进行匹配’)
# 判断 word 是否在词典 dic 当中
# 如果不在词典当中
if word not in dic:
# 则以 word_len – 1
word_len -= 1
# 清空 word
word = []
# 如果 word 在词典当中
else:
# 更新 text 串起始位置
sent = sent[word_len:]
# 为了方便观察过程，我们打印一下当前结果
print(‘【{}】 匹配成功，添加进 words 当中’.format(word))
print(‘-‘*50)
# 把匹配成功的word添加进上面创建好的words当中
words.append(word)
# 清空word
word = []

# 输出结果如下
# [‘我们’, ‘是’, ‘共产主义’, ‘的’, ‘接班’, ‘人’]
逆向*大匹配法
逆向*大匹配法（ Reverse Maximum Match Method, RMM 法）的原理与正向法基本相同，唯一不同的就是切分的方向与 MM 法相反。逆向法从文本末端开始匹配，每次用末端的*长词长度个字符进行匹配。

双向*大匹配法
双向*大匹配法（Bi-direction Matching Method ，BMM）则是将正向匹配法得到的分词结果与逆向匹配法得到的分词结果进行比较，然后按照*大匹配原则，选取次数切分*少的作为结果。

统计分词法
上面主要讲述了基于字典的分词方法，可以发现基于的字典的方法实现比较简单，而且性能也还不错。但是其有一个缺点，那就是不能切分未登录词（即没有被收录在分词词表中但必须切分出来的词，包括各类专有名词（人名、地名、企业名等）、缩写词、新增词汇等等），也就是不能切分字典里面没有的词。为解决这一问题，于是有学者提出了基于统计的分词方法，包括语料统计法和序列标注法。

语料统计法
对于语料统计方法可以这样理解：我们已经有一个由很多个文本组成的的语料库 D ，假设现在对一个句子【我有一个苹果】进行分词。其中两个相连的字 【苹】【果】在不同的文本中连续出现的次数越多，就说明这两个相连字很可能构成一个词【苹果】。与此同时 【个】【苹】 这两个相连的词在别的文本中连续出现的次数很少，就说明这两个相连的字不太可能构成一个词【个苹】。所以，我们就可以利用这个统计规则来反应字与字成词的可信度。当字连续组合的概率高过一个临界值时，就认为该组合构成了一个词语。

序列标注法
序列标注方法则将中文分词看做是一个序列标注问题。首先，规定每个字在一个词语当中有着 4 个不同的位置，词首 B，词中 M，词尾 E，单字成词 S。我们通过给一句话中的每个字标记上述的属性，在训练时，输入中文句子和对应的标注序列，训练完成得到一个模型。在测试时，输入中文句子，通过模型运算得到一个标注序列。然后通过标注序列来进行切分句子。目前在实际应用中，jieba 分词是使用率很高的一款工具。

在使用 jieba 进行分词时，有三种模式可选：

1、全模式

import jieba
string = ‘我来到中国科学院大学上大学’
seg_list = jieba.cut(string, cut_all=True)
‘| ‘.join(seg_list)

# 输出结果如下
# ‘我| 来到| 中国| 中国科学院| 科学| 科学院| 学院| 大学| 学上| 大学’
2、精确模式

import jieba
string = ‘我来到中国科学院大学上大学’
seg_list = jieba.cut(string, cut_all=False)
‘| ‘.join(seg_list)

# 输出结果如下
# ‘我| 来到| 中国科学院| 大学| 上| 大学’
3、搜索引擎模式

import jieba
string = ‘我来到中国科学院大学上大学’
seg_list = jieba.cut_for_search(string)
‘| ‘.join(seg_list)

# 输出结果如下
# ‘我| 来到| 中国| 科学| 学院| 科学院| 中国科学院| 大学| 上| 大学’
jieba 在某些特定的情况下分词，可能表现不是很好。比如一篇非常专业的计算机技术论文，含有一些特定领域的专有名词。不过，为了解决此类问题， jieba 允许用户自己添加该领域的自定义词典，我们可以提前把这些词加进自定义词典当中，来增加分词的效果。调用的方法是：jieba.load_userdic()。

除了使用 jieba.load_userdic() 函数在分词开始前加载自定义词典之外，还有两种方法在可以在程序中动态修改词典：

使用 add_word(word, freq=None, tag=None) 和 del_word(word) 可在程序中动态修改词典。

使用 suggest_freq(segment, tune=True) 可调节单个词语的词频，使其能（或不能）被分出来

0-1背包问题 Python 动态规划

文章目录
基于动态规划算法的 0 − 1 0-1 0−1 背包问题设计过程与实现
1. 算法设计
1.1 构造*优值矩阵
1.2 计算*优解
2. 算法实现-完整代码
3. 程序测试
输入值
输出值
测试结果
基于动态规划算法的 0 − 1 0-1 0−1 背包问题设计过程与实现
1. 算法设计
获取对应信息（商品数量，背包容积，各商品的体积和价值）
构造*优值矩阵
初始化*优值矩阵（上方和左侧留有一列空白矩阵用作后续运算，但不做结果使用）
根据商品之间的*优值公式计算得出相应的结果
通过逆向推导矩阵得到某件商品装了或是没有装
输出结果
1.1 构造*优值矩阵
# 计算*优值矩阵
dp = [[0 for i in range(v+1)] for j in range(n+1)] # 初始化*优值矩阵
for i in range(1, n+1):
for j in range(1, v+1):
dp[i][j] = dp[i-1][j] # 默认不装，即和上一项*优值相等
if j >= goods[i-1][0]:
# 如果背包剩余空间充足
dp[i][j] = max(dp[i][j], dp[i – 1][j-goods[i-1][0]] +
goods[i-1][1]) # 对比装与不装的价值并选择较大值

1.2 计算*优解
# 计算*优解
x = [0 for i in range(n+1)] # 初始化物品状态，0：不装，1：装
for i in range(n, 0, -1):
if dp[i][v] == dp[i-1][v]: # 判断*优值是否发生变化，如果没有变化，则说明没有装
x[i] = 0 # 不装
else: # 如果有变化，则说明装了，并减去对应重量
x[i] = 1 # 装
v -= goods[i-1][0] # 减去对应重量
x[n] = 1 if dp[n][v] != 0 else 0 # 判断*后一个物品装不装

2. 算法实现-完整代码
print(‘请输入待装物品数量和背包体积(空格隔开):’)
n, v = map(int, input().split()) # 获取物品数量和背包体积
goods = [] # 初始化商品列表
for i in range(n):
print(f’请输入第{i + 1}个物品的重量和价值(空格隔开):’)
goods.append(list(map(int, input().split()))) # 获取商品信息

# 计算*优值矩阵
dp = [[0 for i in range(v + 1)] for j in range(n + 1)] # 初始化*优值矩阵
for i in range(1, n + 1):
for j in range(1, v + 1):
dp[i][j] = dp[i – 1][j] # 默认不装，即和上一项*优值相等
if j >= goods[i – 1][0]:
# 如果背包剩余空间充足
dp[i][j] = max(dp[i][j], dp[i – 1][j – goods[i – 1][0]] +
goods[i – 1][1]) # 对比装与不装的价值并选择较大值

“””
# 输出*优值矩阵
for i in dp:
print(i)
“””

# 计算*优解
x = [0 for i in range(n + 1)] # 初始化物品状态，0：不装，1：装
for i in range(n, 0, -1):
if dp[i][v] == dp[i – 1][v]: # 判断*优值是否发生变化，如果没有变化，则说明没有装
x[i] = 0 # 不装
else: # 如果有变化，则说明装了，并减去对应重量
x[i] = 1 # 装
v -= goods[i – 1][0] # 减去对应重量
x[n] = 1 if dp[n][v] != 0 else 0 # 判断*后一个物品装不装

# 输出*优解
print(‘背包应装物品为：’)
for i in range(1, n + 1):
print(f’编号：{str(i)}\t重量：{goods[i – 1][0]}\t价值：{goods[i – 1][1]}\n’ if x[i] == 1 else ”, end=”)
# 输出*优值
print(‘*大物品价值:’, dp[-1][-1])

3. 程序测试
输入值
请输入待装物品数量和背包体积(空格隔开):
5 10
请输入第1个物品的重量和价值(空格隔开):
2 6
请输入第2个物品的重量和价值(空格隔开):
2 3
请输入第3个物品的重量和价值(空格隔开):
6 5
请输入第4个物品的重量和价值(空格隔开):
5 4
请输入第5个物品的重量和价值(空格隔开):
4 6

输出值
背包应装物品为：
编号：1 重量：2 价值：6
编号：2 重量：2 价值：3
编号：5 重量：4 价值：6
*大物品价值: 15

测试结果
程序运行正确且运行结果符合预期。

Linux系统中的文件传输

文章目录
一、scp命令
二、rsync命令
rsync用法
三、文件的归档压缩
1、文件归档
2、 文件的压缩
3、 归档+压缩
实验环境
需要两台主机并且保证这两台主机是可以通信的

systemctl disable firewalld
systemctl stop firewalld
1
2
关闭防火墙

一、scp命令
scp 本地文件 远程主机用户@远程主机ip：远程主机目录的*对路径
scp 远程主机用户@远程主机ip：远程主机文件的*对路径 本地文件
1
2
实验步骤：
1、在westosa中建立实验素材

touch westos
mkdir westosdir

2、测试
a) 把本地文件复制到远程主机 （上传）

scp westos root@172.25.254.218:/root/Desktop
scp -r westosdir root@172.25.254.218:/root/Desktop #-r 表示复制目录
scp -q westos root@172.25.254.218:/root/Desktop #-q 表示传输文件时不显示进度

b)把远程文件复制到本地 （下载）

scp root@172.25.254.218:/root/Desktop/westos_rhel8 /root/Desktop

c)

time scp

二、rsync命令
a) rsync和scp命令的对比
在westosa中

ssh-keygen #生成密钥
ssh-copy-id -i /root/.ssh/id_rsa.pub. root@172.25.254.218

b)创建测试脚本

vim check_scp.sh

编辑测试scp传输时间脚本

time scp -qr /boot root@172.25.254.218:/root/Desktop
time scp -qr /boot root@172.25.254.218:/root/Desktop
time scp -qr /boot root@172.25.254.218:/root/Desktop

编写测试rsync传输时间脚本

time rsync -raCq /boot root@172.25.254.218:/root/Desktop
time rsync -raCq /boot root@172.25.254.218:/root/Desktop
time rsync -raCq /boot root@172.25.254.218:/root/Desktop

c)执行脚本
【scp脚本】

sh check_scp.sh
real 0m1.334s
user 0m0.210s
sys 0m0.490s #*次系统执行时间

real 0m1.642s
user 0m0.412s
sys 0m0.383s #第二次系统执行时间

real 0m1.586s
user 0m0.309s
sys 0m0.497s #第三次系统执行时间

以上执行效果可以看出scp三次执行时间几乎一致

【rsync脚本】

sh check_rsync.sh
real 0m1.603s
user 0m0.399s
sys 0m0.557s

real 0m0.329s
user 0m0.012s
sys 0m0.010s

real 0m0.348s
suer 0m0.014s
sys 0m0.022s

以上执行效果我们可以看出rsync三次执行时间后两次远远小于*次

rsync用法
rsync 文件 远程用户@远程主机ip：远程主机目录
rsync 远程用户@远程主机ip：远程主机目录 文件路径
1
2
rsync

– r #复制目录
– l #复制链接
– p #复制权限
– t #复制时间戳
– o #复制拥有者
– g #复制拥有组
– D #复制设备文件

实验环境
在westosa中建立一个桌面监视

watch -n 1 ls -lR /root/Desktop

在rhel7中

touch /root/Desktop/file{1..5}
chmod 777 /root/Desktop/*
useradd westos
chown westos /root/Desktop/*
ln -s /root/Desktop/file1 /root/Desktop/file

在westosb中
执行命令查看效果

rsync -r root@172.25.254.218:/root/Desktop /mnt/ #同步目录本身及目录中的文件
rsync -r root@172.25.254.218:/root/Desktop/ /mnt/ #只同步目录中的文件
rsync -rl root@172.25.254.218:/root/Desktop/ /mnt/ #同步链接
rsync -rlp root@172.25.254.218:/root/Desktop/ /mnt/ #同步权限
rsync -rlpog root@172.25.254.218:/root/Desktop/ /mnt/ #同步用户组
rsync -rlpogt root@172.25.254.218:/root/Desktop/ /mnt/ #同步时间
rsync -rD root@172.25.254.218:/root/Desktop/ /mnt/ #同步设备文件

三、文件的归档压缩
1、文件归档
tar
– c #创建
– f #指定文件名称
– x #解档
– v #显示过程
– t #查看
– r #向归档文件中添加文件
– -get #解档指定文件
– -delete #删除指定文件
– C #指定解档路径
– P #不移除“/”

实验步骤

tar cf etc.tar /etc
tar tf etc.tar
tar rf etc.tar westos_rhel8
tar xf etc.tar
tar f etc.tar –get westos_rhel8
tar f etc.tar –delete westos_rhel8
tar xf etc.tar -C /root/Desktop

2、 文件的压缩
zip

zip -r mnt.tar.zip mnt.tar #zip格式压缩
unzip mnt.tar.zip #zip格式解压缩

gzip

gzip mnt.tar #gzip格式压缩
gunzip mnt.tar.gz #gzip格式解压缩

bzip2

bzip2 mnt.tar #bzip2格式压缩
bunzip2 mnt.tar.bz2 #bzip2格式解压缩

xz

xz mnt.tar #xz格式压缩
unxz mnt.tar #xz格式解压缩

3、 归档+压缩
gzip

tar zcf etc.tar.gz /etc
tar zxf etc.tar.gz

bzip2

tar jcf etc.tar.bz2 /etc
tar jxf etc.tar.bz2

xz

tar Jcf etc.tar.xz /etc
tar Jxf etc.tar.xz

一文读懂python中的闭包

【干货满满】

昨日突然有小伙伴来问我python中的闭包到底是个神马东东，一想到我当初学习闭包时也是稀里糊涂的，所以特意写了一篇文章来讲解python中的闭包到底应该怎么用，希望能给大家带来帮助。

一、闭包的基本理解
在介绍闭包之前，先简单理解下两种函数概念。

外函数：嵌套函数中*外层的函数称之为外函数。

内函数：嵌套函数中*内层的函数称之为内函数。

闭包的特点：

①：闭包是一种特殊的函数，由外函数和内函数嵌套而成；

②：内函数引用了外函数的临时变量；

③：将使用临时变量的内函数作为外函数的返回值。

二、闭包写法介绍
闭包的基本格式如下：

def 外函数(参数a):
外函数临时变量b = 某值
def 内函数(参数c):
print(运算操作)
return 内函数

res = 外函数(参数a)
res(参数c)

其中：

①：外函数中可传入多个参数，也可不传入参数；

②：外函数中可定义一个或多个临时变量，用于内函数对其引用；

③：内函数可传入多个参数，也可不传入参数；

④：内函数中可对外函数中的参数、临时变量以及内函数中的参数进行相关运算操作；

⑤：然后用一个变量（这里命名为res）接收外函数的返回结果；

⑥：由于外函数的返回的结果为内函数，若直接输出res则会显示对应的内函数内存地址，因此需要写成res(参数c)的形式，才会显示内函数中运算操作的结果。

直接上案例：

def outer(a):
b = 12
def inner(c):
print(a + b + c)
return inner

res = outer(10)
res(5)

此时，*终输出的结果为27。

具体流程为外函数接收了参数a = 10，内函数接收了参数c = 5，同时外函数中的临时变量b被内函数引用，在内函数中打印出（a + b + c）的结果，并将内函数作为外函数的返回结果进行返回，*后直接调用外函数，将返回结果赋为res，再调用内函数，返回*终结果27。

三、 闭包中内函数修改外函数临时变量
下面介绍一种常用的修改外函数临时变量的方法：

利用nonlocal关键字声明临时变量

def outer(a):
b = 12
def inner(c):
nonlocal b
b = 22
print(a+b+c)
return inner
res = outer(10)
res(5)

由于我们在内函数中使用nonlocal关键字声明了临时变量b，并对其重新赋值，所以，此时的计算结果为37。

四、闭包注意事项
一般情况下，函数在运行结束后会将临时变量都释放给内存。但是闭包比较特殊，由于内函数中会用到外函数的临时变量，因此它会将外函数的临时变量与内函数捆绑在一起，在外函数运行结束后，使其临时变量会在后续中继续被内函数调用。

闭包主要用在装饰器中，接下来我将再出一篇python装饰器讲解文章，包含常用装饰器的使用方法和应用案例，欢迎大家评论关注哦。

特此说明
以上介绍仅是个人对于python闭包的理解，衷心希望能对各位小伙伴有所帮助，如有不妥之处欢迎大家批评指正！

Linux服务器的登录与使用
关于登录Linux服务器的方式有很多种，本文重点介绍了Linux和Windows下的登录和使用Linux服务器的方式。

Linux服务器
服务器可看为是一台功能配置强大的电脑，有独立的操作系统，其中核心系统以Linux系统为主的服务器，我们都称之为Linux服务器。

Windows系统下登录服务器
Windows系统中有很多工具可以连接并登录服务器。较常用的有SecureCRT、putty等。
SecureCRT

下载安装SecureCRT后，运行SecureCRT.exe（不是SecureFX.exe，运行SecureFX.exe只能查看目录并下载上传文件，不能使用命令行）。点击File->
Quick Connect，然后在Hostname栏中输入IP地址，点击connect即可弹出输入用户名和密码的窗口，输入用户名和密码即可登录服务器，就可以像使
用Linux系统一样操作服务器了。
上传和下载文件需先配置Securecrt上传和下载路径。点击Options，选择Global options->Generl中Default Session->Edit Default Settings->
Teminal->X/Y/Zmodem。设置upload和download路径。之后在服务器命令行中输入 rz 即可弹出文件选择框，选择文件即可上传至当前目录。输入
sz + 文件名 即可下载文件到download中。
Putty

putty只有500多k大小，下载后直接使用，不需安装。打开后在hostname中输入服务器IP地址，点击open在弹出的命令行输入用户名和密码即可登录
服务器。putty小，非常简单实用，但上传和下载文件不方便。
Linux系统下登录服务器
Linux系统下可直接使用SSH命令连接服务器，具体命令如下(假设IP地址为192.156.0.33，用户名为root)：

ssh 192.156.0.33@root
输入回车后提示输入密码，此时输入密码即可(密码不回显)。若密码无误即可登录服务器，就可以像使用自己的终端一样在服务器上输入命令。
在服务器中上传和下载文件的命令是scp，具体的使用方法同cp命令。

scp [options] source directory
options为可选参数，若文件为目录，需使用-r参数。source为文件源地址，directory为目的地址。

1. 成功登陆到远程服务器之后，输入指令：passwd

2.确认指令正确，按下回车键，即可弹出提示，让输入新的密码

3.如果输入的新密码过于简单，是不能通过Linux系统的，所以密码应该设置的复杂一些，这也是为了系统的安全性考虑，示例：输入密码123456不能通过

4.如果密码格式和长度符合要求，则会成功完成新密码的设置，Linux系统会给出一段成功更新的提示，再次登录的时候就需要使用新的密码了

要从Linux下通过SSH登录另一台Linux服务器非常容易–前提是在远程服务器上拥有一个用户账号。

主要操作是：打开Shell终端，执行ssh -l login_name hostname命令，应该把login_name替换成真实的用户账号，把hostname替换成服务器主机名（或者IP地址）。

或者ssh username@ip。

windows用户可以下载一个ssh客户端模拟连接。

下面这条命令以liu用户的身份登录到IP地址为10.71.84.145的Linux服务器上。

$ ssh -l liu 10.71.84.145 如果是初次登录，SSH可能会提示无法验证密钥的真实性，并询问是否继续建立连接，回答yes继续。用户口令验证通过后，SSH会反馈上次登录情况并以一句”Have a lot of fun…”作为问候。

The authenticity of host ‘10.71.84.145(10.71.84.145)’ can’t be established.  RSA key fingerprint is c9:58:fd:e4:dc:4b:4a:bb:03:d7:9b:87:a3:bc:6a:b0.  Are you sure you want to continue connecting (yes/no)? yes  Warning: Permanently added ‘10.71.84.145’(RSA) to the list of known hosts.  Password:   Last login: Sun Nov  9 10:38:30 2008 from console  Have a lot of fun…

:~> 注意Shell提示符前的用户和主机名改变了，表示当前已经登录到这台名为linux-dqw4（IP地址10.71.84.145）的服务器上。