1 TCP协议的拥塞控制就是防止过多的数据注入到网络中，这样可以使网络中的路由器或链路不致过载。常用的方法有:
正确答案 : BC 您的答案 : BC
A 慢启动、窗口滑动
B 慢开始、拥塞控制
C 快重传、快恢复
D 快开始、快恢复

2 Shell 脚本（shell script），是一种为 shell 编写的脚本程序。现有一个test.sh文件，且有可执行权限，文件中内容为：
#!/bin/bash
aa=’Hello World !’
请问下面选项中哪个能正常显示Hello World !
正确答案 : D 您的答案 : D
A sh test.sh >/dev/null 1 && echo $aa
B ./test.sh >/dev/null 1 && echo $aa
C bash test.sh >/dev/null 1 && echo $aa
D source test.sh >/dev/null 1 && echo $aa

3 bash脚本文件一般第一行开头是
正确答案 : C 您的答案 : C
A //
B ##
C #!
D #/

4 在bash编程中,算术比较大于、大于等于的运算符是（ ）
正确答案 : CD 您的答案 : CD
A >
B >=
C ge
D gt

5 系统管理员编写扫描临时文件的shell程序tmpsc.sh, 测试该程序时提示拒绝执行，解决的方法有（ ）
正确答案 : BCD 您的答案 : BC
A chmod 644 tmpsc.sh
B chmod 755 tmpsc.sh
C chmod a+x tmpsc.sh
D chmod u+x tmpsc.sh
解析：
目录/文件的满权限的形式：
drwxrwxrwx
-rwxrwxrwx 其中：(r:读取，w:写，x:执行)
数字对应：(r:4，w:2，x:1)， 命令行中的三个数字对应的授权角色为owner, group, others

1. 通过数字修改权限
   chmod 777 [-R]
2. 符号类型修改
   u: owner
   g: group
   o: others
   a : all
   chmod a+x [-R] 所有人都拥有执行权限

6

1
2
3
4
5
6
7
8
9

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class Main {
 public static void main(String[] args) {
 ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 15, TimeUnit.SECONDS,
 new ArrayBlockingQueue<Runnable>(5), new ThreadPoolExecutor.CallerRunsPolicy());
 }
}

线程池executor在空闲状态下的线程个数是？
正确答案 : B 您的答案 : B
A 0
B 5
C 10
D 不确定

7 Object类不含有以下哪种方法？
正确答案 : A 您的答案 : A
A equal
B wait
C notify
D clone

8

1
2
3
4
5
6
7
8
9
10

import java.util.ArrayList;
import java.util.List;
public class Main {
 public static void main(String[] args) {
 List<String> list = new ArrayList<>();
 for(int i=0;i<100;i++){
 list.add("a");
 }
 }
}

JDK1.8中，执行以上程序后，该list进行了几次扩容？
正确答案 : C 您的答案 : D
A 4
B 5
C 6
D 7
解析：初始容量被设置为10,那么容量变化的规则是((旧容量 * 3) / 2) + 1，也就是1.5倍增长

9

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class Main {
 public static void main(String[] args) {
 System.out.print(fun1());
 }
 public static String fun1() {
 try {
 System.out.print("A");
 return fun2();
 } finally {
 System.out.print("B");
 }
 }
 public static String fun2() {
 System.out.print("C");
 return "D";
 }
}

执行以上程序后，输出结果正确的是？
正确答案 : C 您的答案 : C
A ABCD
B ACDB
C ACBD
D 不确定

10 根据类加载器加载类的初始化原理，推断以下代码的输入结果为？

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

public class Test {
 public static void main(String[] args) throws Exception{
 ClassLoader classLoader=ClassLoader.getSystemClassLoader();
 Class clazz=classLoader.loadClass("A");
 System.out.print("Test");
 clazz.forName("A");
 }
}
class A{
 static {
 System.out.print("A");
 }
}

正确答案 : A 您的答案 : A
A TestA
B ATestA
C ATest
D Test

11 继承是JAVA语言的一个特性，针对类的继承，虚拟机会如何进行父类和子类的初始化加载呢？请阅读代码选择出该段代码
的输入结果。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class Test {
 public static void main(String[] args) {
 System.out.print(B.c);
 }
}
class A {
 public static String c = "C";
 static {
 System.out.print("A");
 }
}
class B extends A{
 static {
 System.out.print("B");
 }
}

正确答案 : A 您的答案 : A
A AC
B ABC
C C
D BC

12 继承是JAVA语言的一个特性，针对类的继承，虚拟机会如何进行父类和子类的初始化加载呢？请阅读代码选择出该段代码
的输入结果。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class Test {
 public static void main(String[] args) {
 System.out.print(B.c);
 }
}
class A {
 static {
 System.out.print("A");
 }
}
class B extends A{
 static {
 System.out.print("B");
 }
 public final static String c = "C";
}

正确答案 : C 您的答案 : C
A AB
B ABC
C C
D BC

13 JAVA的类加载期负责整个生命周期内的class的初始化和加载工作，就虚拟机的规范来说，以下代码会输出什么结果？

1
2
3
4
5
6
7
8
9
10
11

public class Test {
 public static void main(String[] args) {
 System.out.println(Test2.a);
 }
}
class Test2{
 static {
 System.out.print("OK");
 }
 public static final String a=new String("JD");
}

正确答案 : D 您的答案 : D
A 只有JD
B 只有OK
C 输出 JDOK
D 输出 OKJD

14 JAVA的类加载期负责整个生命周期内的class的初始化和加载工作，就虚拟机的规范来说，以下代码会输出什么结果？

1
2
3
4
5
6
7
8
9
10
11

public class Test {
 public static void main(String[] args) {
 System.out.println(Test2.a);
 }
}
class Test2{
 public static final String a=new String("JD");
 static {
 System.out.print("OK");
 }
}

正确答案 : D 您的答案 : D
A 只有JD
B 只有OK
C 输出 JDOK
D 输出 OKJD

15 JAVA的类加载期负责整个生命周期内的class的初始化和加载工作，就虚拟机的规范来说，以下代码会输出什么结果？

1
2
3
4
5
6
7
8
9
10
11

public class Test {
 public static void main(String[] args) {
 System.out.println(Test2.a);
 }
}
class Test2{
 public static final String a="JD";
 static {
 System.out.print("OK");
 }
}

正确答案 : A 您的答案 : A
A 只有JD
B 只有OK
C 输出 JDOK
D 输出 OKJD

16

1
2
3
4
5
6
7
8
9

public class Main {
 public static void main(String[] args) {
 String s1 = "abc";
 String s2 = "abc";
 System.out.println(s1 == s2);
 String s3 = new String("abc");
 System.out.println(s1 == s3);
 }
}

执行以上程序后，输出结果正确的是？
正确答案 : B 您的答案 : B
A true true
B true false
C false fasle
D false true

17

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

public class Main {
 private static int x = 10;
 private static Integer y = 10;
 public static void updateX(int value) {
 value = 3 * value;
 }
 public static void updateY(Integer value) {
 value = 3 * value;
 }
 public static void main(String[] args) {
 updateX(x);
 updateY(y);
 }
}

执行以上程序后，x和y的值分别是多少？
正确答案 : A 您的答案 : A
A 10,10
B 10,30
C 30,10
D 30,30

18

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class Main {
 public static void main(String[] args) {
 System.out.println("A");
 new Main();
 new Main();
 }
 public Main() {
 System.out.println("B");
 }
 {
 System.out.println("C");
 }
 static {
 System.out.println("D");
 }
}

以上程序输出的结果，正确的是？
正确答案 : C 您的答案 : C
A DCABB
B DABCBC
C DACBCB
D DACBB

19 兼容接口不同的类在一起工作，采用以下哪种设计模式最好？
正确答案 : B 您的答案 : C
A 建造者模式
B 适配器模式
C 桥接模式
D 代理模式

20 下图的UML类结构图表示的是哪种设计模式：

正确答案 : A 您的答案 : A
A 抽象工厂模式
B 享元模式
C 装饰模式
D 责任链模式

21 以下哪条SQL语句可以返回table1中的全部的key：
正确答案 : D 您的答案 : D
A select tabel1.key from table1 join tabel2 on table1.key=table2.key
B select tabel1.key from table1 right outer join tabel2 on table1.key=table2.key
C select tabel1.key from table1 left semi join tabel2 on table1.key=table2.key
D select tabel1.key from table1 left outer join tabel2 on table1.key=table2.key

22 下列有关软连接描述正确的是
正确答案 : C 您的答案 : C
A 与普通文件没什么不同，inode 都指向同一个文件在硬盘中的区块
B 不能对目录创建软链接
C 保存了其代表的文件的绝对路径，是另外一种文件，在硬盘上有独立的区块，访问时替换自身路径
D 不可以对不存在的文件创建软链接

23 以下哪种设备工作在数据链路层？
正确答案 : B 您的答案 : B
A 中继器
B 集线器
C 交换机
D 路由器

24 一颗二叉树的叶子节点有5个，出度为1的结点有3个，该二叉树的结点总个数是？
正确答案 : B 您的答案 : B
A 11
B 12
C 13
D 14

25 若串S=”UP！UP！JD”，则其子串的数目
正确答案 : B 您的答案 : B
A 33
B 37
C 39
D 35
解析：(n*(n+1)/2)+1

26 已知小顶堆：{51,32,73,23,42,62,99,14,24,3943,58,65,80,120}，请问62对应节点的左子节点是
正确答案 : B 您的答案 : B
A 99
B 73
C 3943
D 120

27 关于递归法的说法不正确的是（ ）
正确答案 : D 您的答案 : D
A 程序结构更简洁
B 占用CPU的处理时间更多
C 要消耗大量的内存空间，程序执行慢，甚至无法执行
D 递归法比递推法的执行效率更高

28 以下为求0到1000以内所有奇数和的算法，从中选出描述正确的算法（ ）
正确答案 : A 您的答案 : A
A ①s=0；②i=1；③s=s+i；④i=i+2；⑤如果i≤1000，则返回③；⑥结束
B ①s=0；②i=1；③i=i+2；④s=s+i；⑤如果i≤1000，则返回③；⑥结束
C ①s=1；②i=1；③s=s+i；④i=i+2；⑤如果i≤1000，则返回③；⑥结束
D ①s=1；②i=1；③i=i+2；④s=s+i；⑤如果i≤1000，则返回③；⑥结束

29 如何在多线程中避免发生死锁？
正确答案 : ABCD 您的答案 : ABCD
A 允许进程同时访问某些资源。
B 允许进程强行从占有者那里夺取某些资源。
C 进程在运行前一次性地向系统申请它所需要的全部资源。
D 把资源事先分类编号，按号分配，使进程在申请，占用资源时不会形成环路。

30 下面有关值类型和引用类型描述正确的是（）？
正确答案 : ABC 您的答案 : ABC
值类型的变量赋值只是进行数据复制，创建一个同值的新对象，而引用类型变量赋值，仅仅是把对象的引用
的指针赋值给变量，使它们共用一个内存地址。
A
值类型数据是在栈上分配内存空间，它的变量直接包含变量的实例，使用效率相对较高。而引用类型数据是
分配在堆上，引用类型的变量通常包含一个指向实例的指针，变量通过指针来引用实例。
B
C 引用类型一般都具有继承性，但是值类型一般都是封装的，因此值类型不能作为其他任何类型的基类。
D 值类型变量的作用域主要是在栈上分配内存空间内，而引用类型变量作用域主要在分配的堆上。

tensorflow2.0入门系列（二）

导入相关包

1
2
3
4
5

import tensorflow as tf
from tensorflow import keras

import numpy as np
import matplotlib.pyplot as plt

Fashion MNIST数据集，包含10个类别中的70,000个灰度图像。 图像显示了（28 x 28）的单个服装物品.
60,000张图像来训练网络和10,000张图像来评估网络学习图像分类的准确程度
图像为28x28 NumPy数组，像素值范围为0到255.标签是一个整数数组，范围从0到9.这些对应于图像所代表的服装类别：

导入时装MNIST数据集，作为MNIST手写时装数据集的扩展

1
2
3

fashion_mnist = keras.datasets.fashion_mnist

(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

每个图像都映射到一个标签。 由于类名不包含在数据集中，因此将它们存储在此处以便在后面绘制图像时使用

1
2

#新建列表用于存儲每個标签所对应的类型
class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat','Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

数据扩展

（ps下方展示的代码仅可用于了解一些基本的数据操作扩展方法，并非核心代码）

1
2
3
4
5
6
7

#获取数据集的Shape
print(train_images)
#输出(60000, 28, 28)

#获取数据集的数量
print(len(train_images))
#输出60000

数据预处理

在训练网络之前必须对数据进行预处理。
一是方便我们的神经网络能够快速的识别里面的特征。
二是能够有效的帮助我们训练出一个成功的模型。
我们可以借助matplotlib这个绘图工具包帮助我们直观的感受数据集，以及训练过程。当然TensorFlow也提供了tensorboard用于可视化，暂时我们先不做讲解
我们可以先试着借助matplotlib画出我们数据集中的某张图片：

1
2
3
4
5
6
7
8
9
10
11

plt.figure()
#显示图像
plt.imshow(train_images[0])
#颜色比例彩条
plt.colorbar()
#不显示网格线
plt.grid(False)
#保存图像
plt.savefig('some_one.png')
#显示图像
plt.show()

在将它们送到神经网络模型之前，我们为了将这些值缩放到0到1的范围，我们将值除以255.训练集和测试集以相同的方式进行预处理

1
2
3

train_images = train_images / 255.0

test_images = test_images / 255.0

为了验证数据格式是否正确以及我们是否已准备好构建和训练网络，让我们显示训练集中的前25个图像并在每个图像下方显示类名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#创建图
plt.figure(figsize=(10,10))
for i in range(25):
    #创建子图，5行5列，第i+1个
    plt.subplot(5,5,i+1)
    #X轴坐标刻度设置
    plt.xticks([])
    #Y轴坐标刻度设置
    plt.yticks([])
    plt.grid(False)
    #cmap: 颜色图谱（colormap), 默认绘制为RGB(A)颜色空间，这里使用的是二值图
    plt.imshow(train_images[i])
    plt.colorbar()
    #设置X轴标签
    plt.xlabel(class_names[train_labels[i]])
plt.show()

可以通过右边的彩色比例条可以明显看出图像值已经缩放到0-1的范围

构建模型

设置神经网络层

这里还是采用Keras提供的层叠模型

1
2
3
4
5
6
7
8

model = keras.Sequential([
    # 输入层
    keras.layers.Flatten(input_shape=(28, 28)),
    # 隐藏层一，全连接
    keras.layers.Dense(128, activation='relu'),
    # 输出层，全连接
    keras.layers.Dense(10, activation='softmax')
])

配置模型

1
2
3
4

#采用Adam优化器，loss计算方法为sparse_categorical_crossentropy，评价函数
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

训练模型

1
2

#训练总轮数为5轮
model.fit(train_images, train_labels, epochs=10)

评估模型

看准确度

1
2
3

test_loss, test_acc = model.evaluate(test_images, test_labels)

print('\nTest accuracy:', test_acc)

进行预测

1

predictions = model.predict(test_images)

现在我们去其中第一个结果看看预测情况：

1

print(predictions[0])

输出：[2.4625590e-08 6.4621108e-10 6.6212579e-08 1.8379983e-11 4.6871547e-09
4.0910607e-05 3.9370971e-07 9.7850722e-04 2.8181713e-09 9.9898010e-01]
预测是10个数字的数组。 它们代表模型的“信心”，即图像对应于10种不同服装中的每一种。 我们可以看到哪个标签具有最高的置信度值
我们可以使用np.argmax()来直接计算出置信度最高的所对应的标签

1
2

print(np.argmax(predictions[0]))
#输出 9

我们再对比一下真正的标签

1
2

print(test_labels[0])
# 输出 9

我们同样可以借助matplotlib直观的表现出来
首先我们可以构建画小图的函数和画预测值直方图的函数：

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
28
29
30

def plot_image(i, predictions_array, true_label, img):
  predictions_array, true_label, img = predictions_array[i], true_label[i], img[i]
  plt.grid(False)
  plt.xticks([])
  plt.yticks([])

  plt.imshow(img, cmap=plt.cm.binary)

  predicted_label = np.argmax(predictions_array)
  if predicted_label == true_label:
    color = 'blue'
  else:
    color = 'red'

  plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
                                100*np.max(predictions_array),
                                class_names[true_label]),
                                color=color)

def plot_value_array(i, predictions_array, true_label):
  predictions_array, true_label = predictions_array[i], true_label[i]
  plt.grid(False)
  plt.xticks(range(10), class_names, rotation=90)
  plt.yticks([])
  thisplot = plt.bar(range(10), predictions_array, color="#777777")
  plt.ylim([0, 1])
  predicted_label = np.argmax(predictions_array)

  thisplot[predicted_label].set_color('red')
  thisplot[true_label].set_color('blue')

我们可以看看15张图片的表现情况

1
2
3
4
5
6
7
8
9
10
11

num_rows = 5
num_cols = 3
num_images = num_rows*num_cols
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_images):
  plt.subplot(num_rows, 2*num_cols, 2*i+1)
  plot_image(i, predictions, test_labels, test_images)
  plt.subplot(num_rows, 2*num_cols, 2*i+2)
  plot_value_array(i, predictions, test_labels)
plt.tight_layout()
plt.show()

在做深度学习的过程中，MNIST是我们初学者常用到的数据集
通常在很多示例代码中仅通过

1
2

mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()

这两句代码即可加载
但是在很多情况下由于网络被墙原因（PS：需要到https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz下载数据集）或者Python sll模块并不支持HTTPS
错误代码如下：

1
2
3
4
5
6
7
8

Traceback (most recent call last):
  File "D:/workplace/python/tf2_learn/tf2_1.py", line 20, in <module>
    (x_train, y_train), (x_test, y_test) = mnist.load_data()
  File "D:\Application\Anaconda3\envs\tf2\lib\site-packages\tensorflow\python\keras\datasets\mnist.py", line 49, in load_data
    file_hash='8a61469f7ea1b51cbae51d4f78837e45')
  File "D:\Application\Anaconda3\envs\tf2\lib\site-packages\tensorflow\python\keras\utils\data_utils.py", line 255, in get_file
    raise Exception(error_msg.format(origin, e.errno, e.reason))
Exception: URL fetch failure on https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz: None -- unknown url type: https

以上问题可通过本地导入的方式解决：
1.手动下载数据集
MNIST下载地址
2.放到你的python项目里面，路径随意
3.在代码中做如下配置：

1
2
3
4
5
6
7
8

#配置你MNIST所在路径
path = "MNIST_data/mnist.npz"

#加载mnist数据
f = np.load(path)
x_train, y_train = f['x_train'], f['y_train']
x_test, y_test = f['x_test'], f['y_test']
f.close()

tensorflow2入门教程（-）

导入TensorFlow2.0

1

import tensorflow as tf

MNIST数据集是一个手写数据集，其中有60,000张训练图片, 和10,000张训练图片，是深度学习常被用来入门的数据集

1
2
3
4
5
6

#加载mnist数据
mnist = tf.keras.datasets.mnist

#读取训练数据和测试数据，将样本从整数转换为浮点数
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

构建深度学习模型

首先，我们来看一下ReLU激活函数的形式，如下图:

relu，即Rectified Linear Unit，整流线性单元，激活部分神经元，增加稀疏性，当x小于0时，输出值为0，当x大于0时，输出值为x.

softmax用于多分类过程中，它将多个神经元的输出，映射到（0,1）区间内，可以看成概率来理解，从而来进行多分类！

1
2
3
4
5
6
7
8
9
10
11

#tf.keras.models.Sequential为Keras提供的层叠模型
model = tf.keras.models.Sequential([
  #输入层，输入的shape是28X28（图片大小是28X28）  ,tf.keras.layers.Flatten()将输入展平，将多维数据展层一维，降维打击
  tf.keras.layers.Flatten(input_shape=(28, 28)),
  #隐藏层一，输出shape是128，激励函数是relu,tf.keras.layers.Dense()全连接层
  tf.keras.layers.Dense(128, activation='relu'),
  #Dropout一些神经元，能够有效地处理在训练过程中产生的过拟合问题
  tf.keras.layers.Dropout(0.2),
  #输出层，shape为10分别对应着0-9这几个手写数字，激励函数为softmax，将特征值转换为在各个分类上的概率，,tf.keras.layers.Dense()全连接层
  tf.keras.layers.Dense(10, activation='softmax')
])

构建好模型后，通过调用 compile 方法配置该模型的学习流程

1
2
3
4

#采用adam优化器，损失函数为sparse_categorical_crossentropy，评价函数
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

训练并验证模型

1
2
3
4

#输入数据x_train,y_train;训练次数5次
model.fit(x_train, y_train, epochs=5)
#测试模型
model.evaluate(x_test, y_test)

一览图

conda环境使用基本命令：

1
2
3
4

conda create -n xxxx python=[python_version]   //创建python的xxxx虚拟环境
conda activate xxxx               //开启xxxx环境
conda deactivate                  //关闭环境
conda env list                    //显示所有的虚拟环境

更新，卸载安装包：

1
2
3

conda list         //查看已经安装的文件包
conda update xxx   //更新xxx文件包
conda uninstall xxx   //卸载xxx文件包

删除虚拟环境

1

conda remove -n xxxx --all //创建xxxx虚拟环境

清理（conda瘦身）

1
2
3

conda clean  //就可以轻松搞定！第一步：通过conda clean -p来删除一些没用的包，这个命令会检查哪些包没有在包缓存中被硬依赖到其他地方，并删除它们。第二步：通过conda clean -t可以将conda保存下来的tar包。
conda clean -p      //删除没有用的包
conda clean -t      //tar打包

sudo systemctl start apache2 将此命令用作sudo以启动Apache服务器。
sudo systemctl stop apache2 将此命令用作sudo，以便在Apache服务器处于启动模式时停止它。
sudo systemctl restart apache2 将此命令用作sudo以便停止然后再次启动Apache服务。
sudo systemctl reload apache2 将此命令用作sudo，以便在不重新启动连接的情况下应用配置更改。
sudo systemctl启用apache2 将此命令用作sudo，以便在每次启动系统时启用Apache。
sudo systemctl disable apache2 将Apache设置为每次启动系统时启动

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1

$ hexo new "My New Post"

More info: Writing

Run server

1

$ hexo server

More info: Server

Generate static files

1

$ hexo generate

More info: Generating

Deploy to remote sites

1

$ hexo deploy

More info: Deployment