最近动态

未分类

iterm2 profile配置快捷登录服务器与记住密码

使用iTerm2 Profiles快捷登录ssh(推荐)

找一个目录创建一个普通文件,例:vim 12.20_prod_aide

我放在了nextcloud网盘的code/linux目录下

编辑一下内容,把自己的信息填写上去。

1
2
3
4
5
6
7
8
9
10
11
12
13
#!/usr/bin/expect

set PORT 22
set HOST ***.**.12.20
set USER root
set PASSWORD ************

spawn ssh -p $PORT $USER@$HOST
expect {
"yes/no" {send "yes\r";exp_continue;}
"*password:*" { send "$PASSWORD\r" }
}
interact

打开iterm2 -> preferences -> Profiles
点击下面“+”号,新建一个profile。
选择Command 在输入框中输入
expect+刚才建的文件路径

1472307-20181108095857368-514837377

按option点击profile 可以以新窗口而不是新tab页的方式打开

使用ssh公钥登录(免输入密码)

SSH还提供了公钥登录,可以省去输入密码的步骤。

使用公钥登录,首先你要有公钥。看下这个目录(~/.ssh/)下是否存在id_rsa.pub和id_rsa这两个文件。
没有的话,运行此命令:

1
$ ssh-keygen

会在 ~/.ssh 目录下生成两个文件 d_rsa.pub和id_rsa ,前者是公钥,后者是你的私钥。
公钥生成后,运行:

1
ssh-copy-id -i ~/.ssh/id_rsa.pub -p port user@host

好了,从此你再登录此远程主机,就不需要输入密码了。
如果还是不行,就打开远程主机的/etc/ssh/sshd_config这个文件,检查下面几行前面”#”注释是否取掉。

1
2
3
RSAAuthentication yes   
PubkeyAuthentication yes
AuthorizedKeysFile .ssh/authorized\_keys

然后,重启远程主机的ssh服务。
原理:
公钥登录是为了解决每次登录服务器都要输入密码的问题,流行使用RSA加密方案,主要流程包含:

    1、客户端生成RSA公钥和私钥

    2、客户端将自己的公钥存放到服务器

    3、客户端请求连接服务器,服务器将一个随机字符串发送给客户端

    4、客户端根据自己的私钥加密这个随机字符串之后再发送给服务器

    5、服务器接受到加密后的字符串之后用公钥解密,如果正确就让客户端登录,否则拒绝。这样就不用使用密码了。     

对公钥和私钥的说明可参考:https://www.cnblogs.com/scofi/p/6617394.html

阅读剩下更多

默认配图
未分类

numpy(一)numpy基本概念

引入numpy 函数库

​ numpy是python开发环境的一个独立模块,如果在之前的python3安装环境章节安装了anaconda,那么numpy已经在anaconda中自带了。如果只安装了python,可以在命令行终端中输入pip install -y numpy来安装numpy。

​ 如果确认numpy已经安装,在python代码中引入numpy函数库

1
import numpy as np

​ 当然也可以像介绍python那节提到的使用from numpy import * 将numpy库中的所有模块引入当前的命名空间,两者之间只有使用习惯上的差别。本节的剩余部分会按照import numpy as np的方式介绍剩余的代码。

numpy的数据结构

​ numpy有两种的数据类型,分别为矩阵matrix与N维数据array,这两种数据类型是numpy数据计算的基础,两者都可以用于处理行列表示的数据元素。其中矩阵matrix更贴近于Matlab中的matrices。并且matrix更贴近数学中矩阵的概念,只有两维,而创建数组的维度是不限的。

​ 新建一个array:

1
2
3
4
np.array([[1,2],[3,4]])
# 输出:
# array([[1, 2],
# [3, 4]])

​ 新建一个matrix:

1
2
3
4
np.mat([[1,2],[3,4]])
# 输出:
# matrix([[1, 2],
# [3, 4]])

​ array转换为matrix

1
2
3
4
5
a = np.array([[1,2],[3,4]])
np.mat(a)
# 输出:
# matrix([[1, 2],
# [3, 4]])

​ 但有一些场景array与matrix的运算会得到不同的结果,例如,array的运算操作大都是逐元素的,而matrix更类似矩阵预算,例如乘法来说

1
2
3
4
5
6
7
8
9
10
11
12
13
# 数组乘法
a = np.array([[1,2],[3,4]])
a*a
# 输出:
# array([[ 1, 4],
# [ 9, 16]])

#矩阵乘法
m = np.mat([[1,2],[3,4]])
m*m
# 输出:
# matrix([[ 7, 10],
# [15, 22]])

​ 当然,这是基础运算符的默认结果,如果希望明确的使用某种运算,也可以直接使用内置函数完成。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
a = np.array([[1,2],[3,4]])
m = np.mat([[1,2],[3,4]])

# 逐个元素相乘
np.multiply(m,m)
# 输出:
# matrix([[ 1, 4],
# [ 9, 16]])

# 矩阵乘法
np.dot(a,a)
# 输出:
# array([[ 7, 10],
# [15, 22]])

​ 没有特殊情况需要使用matrix的话,更推荐大家使用array数组,因为很多内置的numpy函数即使传入的参数是matrix,返回值也都是array数组。而array的特性也能覆盖平时代码的大部分场景,本章的其他部分也会着重介绍array。

numpy基础-类型、初始化、属性

​ numpy有多种初始化方式,例如上面代码中将python中的列表转换为numpy数组就是一种,此外numpy还提供了一些其他方法用于创建数组。

​ 比较基础的创建数组并且设置站位符的方法有ones、zeros。

​ ones、zeros同样是传入一个列表,接收的参数是作为一个维度来生成数组,并设置占位数为0或1,例如

1
2
3
4
5
6
7
8
9
10
np.zeros([3,3])
# 输出:
# array([[0., 0., 0.],
# [0., 0., 0.],
# [0., 0., 0.]])

np.ones([2,2])
# 输出:
# array([[ 1., 1.],
# [1., 1.]])

​ 需要注意的是有ones_like、zeros_like两个函数,传入的参数也是列表吗,名称也相似,但包含like的两个函数的作用是将返回一个与列表相同维度的数组并用占位符填充,例如:

1
2
3
np.zeros_like([3,3])
# 输出:
# array([0, 0])

​ 以上就是一些最常用的初始化方式,numpy中还有的一些其他初始化方式将在之后文章使用到的时候简单讲解。

​ 可能在使用np.zeros(3,3)初始化的时候,我们会发现返回值多了一个点,这说明了生成的数组并不是一个整型,而是一个浮点型,numpy的数组可以由多种类型构成,例如之前用到的整型、浮点型等数值类型、还有python自带的字符串等类型,除此之外,numpy内部也定义了许多类型可供使用,可以使用dtype属性来查看当前数组的类型,例如:

1
2
3
4
a = np.array([[1,2],[3,4]])
a.dtype
# 输出:
# dtype('int64')

​ 而修改dtype,也就是转型时,要注意不能直接修改dtype,会造成转换的问题,从而输出错误数据,如果需要转换类型可以使用astype函数:

1
2
3
4
5
a = np.array([[1,2],[3,4]])
a = a.astype('float64')
a.dtype
# 输出:
# dtype('float64')

Numpy数据类型的表格(来源于官网):

dtype 类型与描述
bool_ 布尔类型,以byte方式存储
int_ 默认的int类型,类比于C语言中的long,根据操作系统平台的不同,保存为64位或32为
intc 与C语言中的int相同,32位或64位
intp 常用于索引,等同于C语言中的ssize_t,32位或64位
int8 8位整型 (-128 to 127)
int16 16位的整型 (-32768 to 32767)
int32 32位的整型(-2147483648 to 2147483647)
int64 64位的整型 (-9223372036854775808 to 9223372036854775807)
uint8 无符号8位整型(0 to 255)
uint16 无符号16位整型 (0 to 65535)
uint32 无符号32位整型 (0 to 4294967295)
uint64 无符号64位整型 (0 to 18446744073709551615)
float_ 浮点型,等同于float64,简写
float16 16位的浮点型
float32 32位的浮点型
float64 64位的浮点型
complex_ 复数,等同于complex128,是它的简写
complex64 64位的复数,相当于两个32位的浮点组合(分别是实部与虚部)
Complex128 128位的复数

​ 上面说的dtype算作numpy数组的一个属性,除此之外,还有一些其他重要的属性。一个数组,有维度(用shape获得),有维度的个数(即矩阵的秩,ndim),有数组长度(size)。这些也都可以用python获取属性的方式获得:

1
2
3
4
5
6
7
a = np.array([[1,2],[3,4]])
a.size
# 输出: 4
a.ndim
# 输出: 2
a.shape
# 输出: (2,2)

numpy索引、切片

​ numpy数组与python的其他序列结构一样,也有着索引和切片的概念:

1
2
3
4
a = np.array([[1,2,5,6],[3,4,7,8]])
# 通过索引获得下标为1,1的元素
a[1,1]
# 输出: 4

​ 也可以通过切片切割数组

1
2
3
4
5
6
a = np.array([[1,2,5,6],[3,4,7,8],[9,10,11,12]])
# 通过缩影截取掉第一个维度的所有值,和第二个维度的第一个值
a[1:,1:]
# 输出:
# array([[ 4, 7, 8],
# [10, 11, 12]])

​ 可能这个切片的结果会让人有点难以理解,那么把它想象成一个表格会好理解一些:

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

​ a[1:,1:]这样的操作就是将第一行全部截掉,再将第一列全部截掉,更多维度的操作也以此类推。

阅读剩下更多

默认配图
未分类

算法题的输入大总结

next和nextline不混用(只用next,不用nextline)

1
2
3
4
5
6
7
8
Sample Input
1 2
12 24
400 500
Sample Output
3
36
900
1
2
3
4
5
6
7
8
9
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNext()) {
System.out.println(sc.nextInt()+sc.nextInt());
}
}
}
第一行是数据的组数N,从第二行开始是N组由两个整数(A和B)构成的数据,A和B之间用空格隔开,每组输入单独占一行
1
2
3
4
5
6
7
Sample Input
2
1 2
10 20
Sample Output
3
30
1
2
3
4
5
6
7
8
9
10
11
//2
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n=sc.nextInt();
while(n-->0) {
System.out.println(sc.nextInt()+sc.nextInt());
}
}
}
多组数据:每组由两个整数(A和B)构成,A和B之间用空格隔开,每组输入单独占一行。当输入为”0 0”时,输入结束。”0 0”这组数据不处理。
1
2
3
4
5
6
7
8
9
Sample Input
1 2
3 4
10 20
0 0
Sample Output
3
7
30
1
2
3
4
5
6
7
8
9
10
11
12
13
//3
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(true) {
int a=sc.nextInt();
int b=sc.nextInt();
if(a==0 && b==0)break;
System.out.println(a+b);
}
}
}
输入包含多个测试用例。每个测试用例包含一个正整数N,随后是N个整数跟在同一行上。当某个测试用例以0开始,终止输入,且该用例不处理。
1
2
3
4
5
6
7
8
9
Sample Input
3 1 2 4
1 23
5 1 3 5 7 9
0
Sample Output
7
23
25
1
2
3
4
5
6
7
8
9
10
11
12
13
14
//4
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(true) {
int a=sc.nextInt();
if(a==0)break;
int ac=0;
while(a-->0)ac+=sc.nextInt();
System.out.println(ac);
}
}
}
第一行为N,下面紧跟N行数据。每行数据:开头为M,后面紧跟M个数。
1
2
3
4
5
6
7
Sample Input
2
1 1
2 3 4
Sample Output
1
7
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//5
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n=sc.nextInt();
while(n-->0) {
int a=sc.nextInt();
if(a==0)break;
int ac=0;
while(a-->0)ac+=sc.nextInt();
System.out.println(ac);
}
}
}

阅读剩下更多

默认配图
返回顶部