Tensorflow安装及使用总结

其他 2018-06-13 05:17:41 阅读次数: 2

1、安装Python

地址：https://www.python.org/downloads/release/python-352/

要安装3.5.x的，安装包如下：


我的系统是win7-x64-intel

下面开始安装：

（1）以管理员身份运行；

（2）勾选将路径写入path，并选择自定义安装


（3）自定义附加的功能组件


（4）自定义路径


然后点击install即可。

2、安装Tensorflow

（1）注意，不要进入python

（2）先更新pip版本

python -m pip install --upgrade pip

（2）以管理员身份打开cmd，直接在cmd键入(pip我们在安装python是一个组件可以勾选一起安装)：

本机没有N显卡，因此安装cpu版本，如果有的话就安装gpu版本。gpu版本安装完之后还要安装CUDA和cuDNN。我们用cpu版本，gpu相关的问题就先不管了。

cpu版本：

pip3 install --upgrade tensorflow

gpu版本：

pip3 install --upgrade tensorflow-gpu

3、测试Tensorflow是否安装成功


输入第三行指令的时候报警告，意思是说Tensorflow没有按照你的电脑的cpu的指令集进行特别优化，因此执行不能达到最佳性能。此问题可以不解决，也可以这样解决：在自己的电脑上重新编译Tensorflow。

4、如果测试运行失败可以卸载了换版本试试

卸载：

pip uninstall tensorflow

指定版本安装(已安装的版本会自动卸载)：

pip3 install tensorflow==1.7.0

5、第一例子

import tensorflow as tf
import numpy as np

# create data

# x_data,生成100个随机数，数值都在0-1之间
# 生成的x_data是一个一维数组
#例如[0.03370675 0.4111335]

x_data = np.random.rand(100).astype(np.float32)

# y_data是对x_data这个一维数组进行操作，所以他的结果也是一个一维数组
#例如[0.30337068 0.34111136]
y_data = x_data*0.1+0.3

# 创建了这两个数组，这两个数组有每个对应的位置，比如0对0，1对1的位置，他们存在着：
# y = x*0.1+0.3这样的关系，但是我只给这两个数组，没有给任何变量或者什么
# 要让程序能够预测(总结)出0.1和0.3这两个数
# 这个权重就是0.1，这个偏置就是0.3
# 我们要他运算完成，权重可以接近0.1，偏置接近0.3，我们的这个运算就算成功

### create tensorflow structure start ###

#权重
# 初始值给一个随机，在-1到1之间的一个随机
Weights = tf.Variable(tf.random_uniform([1],-1.0,1.0))

#偏置
# 初始偏置给他定义为0
biases = tf.Variable(tf.zeros([1]))

# 其实这里就是给出了y_data与x_data的关系
# 但是没告诉他weights和biases的值
# 要他根据y_data和x_data的值推算出weight和biases

# 其实这个什么权重、偏置，先不用管那么多，可以理解为：
# y = ax+b 给定了x和y 求a和b
# 有多组的x和y的话，其实a和b都是确定可求的
# 但是此种方法是用深度学习去过滤他，统计他，得出答案


# 预测y
y = Weights*x_data+biases

# 损失函数，预测的y和实际的y的差别
# 这里是预测的y-实际的y
loss = tf.reduce_mean(tf.square(y-y_data))

# 优化器，参数是学习效率，一般是小于1的数
# 这个优化器叫做梯度下降法，是最基本的优化器
optimizer = tf.train.GradientDescentOptimizer(0.5)

# 优化器训练要尽量减少loss
train = optimizer.minimize(loss)

init = tf.initialize_all_variables()

### create tensorflow structure end ###

sess = tf.Session()

sess.run(init)

# 训练201次
for step  in range(201):
	sess.run(train)
	if step%20 == 0:
		print(step,sess.run(Weights),sess.run(biases))
sess.close()

运行结果：


6、Session的两种使用方法

import tensorflow as tf

# 矩阵，可以理解为图片上的点
# matrix1是一个一行两列的矩阵
# [3,3] [x1,y1]
matrix1 = tf.constant([[3,3]])
# matrix2是一个两行一列的矩阵
# T 2 T  T x2 T
# L 2 J  L y2 J
matrix2 = tf.constant([[2],
			    		[2]])
# 矩阵1和2相乘的算法是：x1y1+x2y2 = 3*2+3*2 = 12

# 这里是用tf的矩阵乘法，如果是在np中是这样的：np.dot(m1,m2)
product = tf.matmul(matrix1,matrix2)

# method 1
# sess = tf.Session()
# result = sess.run(product)
# print(result)# 执行结果:[[12]]
# sess.close()

# method 2
with tf.Session() as sess:# 这种方式不需要显式close
	result2 = sess.run(product)
print(result2)

7、变量

import tensorflow as tf

# 定义一个tensorflow的变量
# 可以定义初始值，还有名称
state = tf.Variable(1,name = 'counter') # 变量，初始值为1

# print(state.name)# 输出（counter:0）0表示这是tf的第一个变量

# 定义一个常量值为1
one = tf.constant(1) # 常量，初始值为1

# add可以理解为加号
new_value = tf.add(state,one) # 执行两数相加 1+1=2
# 这个update可以理解为一个函数，是一个运算的名称
# 这个动作可以理解为：state = state+one;
# 第一次：1+1=2,
# 第二次：2+1=3，
# 第三次：3+1=4
# assign可以理解为等号
update = tf.assign(state,new_value)# new_value加载到state上，这里update=2

init = tf.initialize_all_variables()# 初始化所有变量，当然，要等到sess出现才真正激活，如果有定义变量一定要有这一句

with tf.Session() as sess:
	sess.run(init)
	for _ in range(3):
		sess.run(update)
		print(sess.run(state))

8、占位符

import tensorflow as tf

# 占位符的意思就是这两个数，将来是要用用户输入的值来代替的（当然现在也没有赋值，可以认为是变量）
input1 = tf.placeholder(tf.float32)
input2 = tf.placeholder(tf.float32)

# 乘法运算
output = tf.multiply(input1,input2)

with tf.Session() as sess:
	print(sess.run(output,feed_dict={input1:[7.],input2:[2.]}))# [14.]

9、添加 层

import tensorflow as tf

# 没有激励就是线性
def add_layer(inputs,in_size,out_size,activation_function=None):
	Weights = tf.Variable(tf.random_normal([in_size,out_size]))# 随机生成一个矩阵，有in_size行数和out_size列数
	biases = tf.Variable(tf.zeros([1,out_size])+0.1)# 这个是个一维数组，行数只有1，列数为out_size，这里+0.1表示他每个值都是0.1
	Wx_plus_b = tf.matmul(inputs,Weights)+biases# 矩阵相乘再加biases
if activation_function  is None:
	outputs = Wx_plus_b# 如果没有激励，则直接就是这个线性函数
else:
	outputs = activation_function(Wx_plus_b)# 如果有激励，则把线性函数传进激励函数（进行过滤或缩放等操作）
return outputs

10、建造神经网络

import tensorflow as tf
import numpy as np

# 没有激励就是线性
def add_layer(inputs,in_size,out_size,activation_function=None):
	Weights = tf.Variable(tf.random_normal([in_size,out_size]))# 随机生成一个矩阵，有in_size行数和out_size列数
	biases = tf.Variable(tf.zeros([1,out_size])+0.1)# 这个是个一维数组，行数只有1，列数为out_size，这里+0.1表示他每个值都是0.1
	Wx_plus_b = tf.matmul(inputs,Weights)+biases# 矩阵相乘再加biases
	if activation_function  is None:
		outputs = Wx_plus_b# 如果没有激励，则直接就是这个线性函数
	else:
		outputs = activation_function(Wx_plus_b)# 如果有激励，则把线性函数传进激励函数（进行过滤或缩放等操作）
	return outputs

# 这个x_data是这样的：产生300个[x],其值从-1开始到1不等距分布
# [-0.001234234]
# [-0.002453244]
# .
# .
# .
# [0.932423425]
# [0.993242424]
x_data = np.linspace(-1,1,300)[:,np.newaxis]

# 噪点，结构与x_data类似有负有正
# 以0为中点，方差为0.05波动
# 这个数与0之间的差值的平方值，最大为0.05，即这个数的平方不能大于0.05

noise = np.random.normal(0,0.05,x_data.shape)

# 令y_data等于x_data的二次方，再减去0.5,然后加上一个随机噪声，这样x跟y就不是完全线性相关的

y_data = np.square(x_data) - 0.5 + noise

xs = tf.placeholder(tf.float32,[None,1])
ys = tf.placeholder(tf.float32,[None,1])

# 定义隐藏层。输入神经元1个，隐藏层神经元10个，激励函数：非线性函数
#（inputs,in_size,out_size,activation_function=None）
#(输入数据，输入参数个数，输出参数根数，激励函数)
l1 = add_layer(xs,1,10,activation_function = tf.nn.relu)

# 定义输出层。l1，神经元10个，输出1
# 输出层，就是预测值
predition = add_layer(l1,10,1,activation_function = None)

# tf.square(ys - predition) （对每个例子）实际值减预测值的平方
# 对刚才的平方，所有例子求和
# 对刚才求的和求一个平均值

loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - predition),
	reduction_indices = [1]))
# 梯度下降法优化器
# 参数是学习效率
# 优化器的目标是最小化误差
train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

init = tf.initialize_all_variables()

sess = tf.Session()
sess.run(init)

for i in range(1000):
	sess.run(train_step,feed_dict = {xs:x_data,ys:y_data})
	if i% 50:
		print(sess.run(loss,feed_dict = {xs:x_data,ys:y_data}))
# 如果打印的loss越来越小，说明是收敛的，训练有效
# 检验发现，10000次训练不会比1000此训练loss更小，说明不收敛(不是无限收敛)

11、用动态图显示训练效果

import tensorflow as tf
import numpy as np
# 引入图表
import matplotlib.pyplot as plt

# 没有激励就是线性
def add_layer(inputs,in_size,out_size,activation_function=None):
	Weights = tf.Variable(tf.random_normal([in_size,out_size]))# 随机生成一个矩阵，有in_size行数和out_size列数
	biases = tf.Variable(tf.zeros([1,out_size])+0.1)# 这个是个一维数组，行数只有1，列数为out_size，这里+0.1表示他每个值都是0.1
	Wx_plus_b = tf.matmul(inputs,Weights)+biases# 矩阵相乘再加biases
	if activation_function  is None:
		outputs = Wx_plus_b# 如果没有激励，则直接就是这个线性函数
	else:
		outputs = activation_function(Wx_plus_b)# 如果有激励，则把线性函数传进激励函数（进行过滤或缩放等操作）
	return outputs

# 这个x_data是这样的：产生300个[x],其值从-1开始到1不等距分布
# [-0.001234234]
# [-0.002453244]
# .
# .
# .
# [0.932423425]
# [0.993242424]
x_data = np.linspace(-1,1,300)[:,np.newaxis]

# 噪点，结构与x_data类似有负有正
# 以0为中点，方差为0.05波动
# 这个数与0之间的差值的平方值，最大为0.05，即这个数的平方不能大于0.05

noise = np.random.normal(0,0.05,x_data.shape)

# 令y_data等于x_data的二次方，再减去0.5,然后加上一个随机噪声，这样x跟y就不是完全线性相关的

y_data = np.square(x_data) - 0.5 + noise

xs = tf.placeholder(tf.float32,[None,1])
ys = tf.placeholder(tf.float32,[None,1])

# 定义隐藏层。输入神经元1个，隐藏层神经元10个，激励函数：非线性函数
#（inputs,in_size,out_size,activation_function=None）
#(输入数据，输入参数个数，输出参数根数，激励函数)
l1 = add_layer(xs,1,10,activation_function = tf.nn.relu)

# 定义输出层。l1，神经元10个，输出1
# 输出层，就是预测值
predition = add_layer(l1,10,1,activation_function = None)

# tf.square(ys - predition) （对每个例子）实际值减预测值的平方
# 对刚才的平方，所有例子求和
# 对刚才求的和求一个平均值

loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - predition),
	reduction_indices = [1]))
# 梯度下降法优化器
# 参数是学习效率
# 优化器的目标是最小化误差
train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

init = tf.initialize_all_variables()

sess = tf.Session()
sess.run(init)

# 在此显示图形
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.scatter(x_data,y_data)# x和对应的y
plt.ion()#有这个语句就不阻塞会继续往下走
plt.show()

for i in range(1000):
	sess.run(train_step,feed_dict = {xs:x_data,ys:y_data})
	if i% 50:
		#print(sess.run(loss,feed_dict = {xs:x_data,ys:y_data}))
		try:
			ax.lines.remove(lines[0])
		except Exception:
			pass
		prediction_value = sess.run(predition,feed_dict={xs:x_data})
		lines  = ax.plot(x_data,prediction_value,'r-',lw=5)#红线是预测的线
		plt.pause(0.1)#暂停0.1秒
# 如果打印的loss越来越小，说明是收敛的，训练有效
# 检验发现，10000次训练不会比1000此训练loss更小，说明不收敛(不是无限收敛)

12、使用tensorboard展示程序流程图

import tensorflow as tf
import numpy as np
# 引入图表
import matplotlib.pyplot as plt

# 没有激励就是线性
def add_layer(inputs,in_size,out_size,activation_function=None):
	with tf.name_scope('layer'):
		with tf.name_scope('weights'):
			Weights = tf.Variable(tf.random_normal([in_size,out_size]),name = 'W')# 随机生成一个矩阵，有in_size行数和out_size列数
		with tf.name_scope('biases'):
			biases = tf.Variable(tf.zeros([1,out_size])+0.1,name = 'b')# 这个是个一维数组，行数只有1，列数为out_size，这里+0.1表示他每个值都是0.1
		with tf.name_scope('Wx_plus_b'):
			Wx_plus_b = tf.matmul(inputs,Weights)+biases# 矩阵相乘再加biases
		if activation_function  is None:
			outputs = Wx_plus_b# 如果没有激励，则直接就是这个线性函数
		else:
			outputs = activation_function(Wx_plus_b)# 如果有激励，则把线性函数传进激励函数（进行过滤或缩放等操作）
		return outputs

# 这个x_data是这样的：产生300个[x],其值从-1开始到1不等距分布
# [-0.001234234]
# [-0.002453244]
# .
# .
# .
# [0.932423425]
# [0.993242424]
x_data = np.linspace(-1,1,300)[:,np.newaxis]

# 噪点，结构与x_data类似有负有正
# 以0为中点，方差为0.05波动
# 这个数与0之间的差值的平方值，最大为0.05，即这个数的平方不能大于0.05

noise = np.random.normal(0,0.05,x_data.shape)

# 令y_data等于x_data的二次方，再减去0.5,然后加上一个随机噪声，这样x跟y就不是完全线性相关的

y_data = np.square(x_data) - 0.5 + noise

with tf.name_scope('inputs'):
	xs = tf.placeholder(tf.float32,[None,1],name = 'x_input')
	ys = tf.placeholder(tf.float32,[None,1],name = 'y_input')

# 定义隐藏层。输入神经元1个，隐藏层神经元10个，激励函数：非线性函数
#（inputs,in_size,out_size,activation_function=None）
#(输入数据，输入参数个数，输出参数根数，激励函数)
l1 = add_layer(xs,1,10,activation_function = tf.nn.relu)

# 定义输出层。l1，神经元10个，输出1
# 输出层，就是预测值
predition = add_layer(l1,10,1,activation_function = None)

# tf.square(ys - predition) （对每个例子）实际值减预测值的平方
# 对刚才的平方，所有例子求和
# 对刚才求的和求一个平均值
with tf.name_scope('loss'):
	loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - predition),
		reduction_indices = [1]))
# 梯度下降法优化器
# 参数是学习效率
# 优化器的目标是最小化误差
with tf.name_scope('train'):
	train_step = tf.train.AdamOptimizer(0.1).minimize(loss)

init = tf.initialize_all_variables()

sess = tf.Session()

# 写入框架图
writer = tf.summary.FileWriter("logs/",sess.graph)

sess.run(init)

# 在此显示图形
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.scatter(x_data,y_data)# x和对应的y
plt.ion()#有这个语句就不阻塞会继续往下走
plt.show()

for i in range(1000):
	sess.run(train_step,feed_dict = {xs:x_data,ys:y_data})
	if i% 50:
		#print(sess.run(loss,feed_dict = {xs:x_data,ys:y_data}))
		try:
			ax.lines.remove(lines[0])
		except Exception:
			pass
		prediction_value = sess.run(predition,feed_dict={xs:x_data})
		lines  = ax.plot(x_data,prediction_value,'r-',lw=5)#红线是预测的线
		plt.pause(0.1)#暂停0.1秒
# 如果打印的loss越来越小，说明是收敛的，训练有效
# 检验发现，10000次训练不会比1000此训练loss更小，说明不收敛(不是无限收敛)

运行之后，在当前脚本目录下的log文件夹里会产生一个文件；

在当前目录下输入如下命令：


它提示可以通过地址192.168.1.111:6006访问此流程图。访问期间调用googleapi，需要翻墙。

13、分类

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

# 如果数据不存在会去网上下载
# 这个mnist分为train数据和test数据
# 这两个数据设为不同的，原因很简单，如果相同怕是不能检验学习效果

mnist = input_data.read_data_sets('MNIST_data',one_hot = True)

# 以上自动下载的方法，因为联网失败，改为先自己去下载数据然后导入
# 数据下载地址：http://yann.lecun.com/exdb/mnist/
# 下载之后，在脚本的同个目录下，创建一个文件夹MINIST_data，然后把这些压缩文件（4个）直接放进去
# 其实他自动下载的话，也是会自动创建这样一个名称的文件夹，在此路径下，但是我去看了，没下下来


def add_layer(inputs,in_size,out_size,activation_function=None):
	Weights = tf.Variable(tf.random_normal([in_size,out_size]))# 随机生成一个矩阵，有in_size行数和out_size列数
	biases = tf.Variable(tf.zeros([1,out_size])+0.1)# 这个是个一维数组，行数只有1，列数为out_size，这里+0.1表示他每个值都是0.1
	Wx_plus_b = tf.matmul(inputs,Weights)+biases# 矩阵相乘再加biases
	if activation_function  is None:
		outputs = Wx_plus_b# 如果没有激励，则直接就是这个线性函数
	else:
		outputs = activation_function(Wx_plus_b)# 如果有激励，则把线性函数传进激励函数（进行过滤或缩放等操作）
	return outputs

# 传入，输入和输出值
def compute_accuracy(v_xs,v_ys):
	global prediction
	# 输入xs然后生成预测值
	y_pre = sess.run(prediction,feed_dict={xs:v_xs})
	# 对比预测的y和真实正确的y，返回是否正确。就是对比他们最大值的位置。
	# 比如，一个一列10行的矩阵，最大值1发生在3的位置，他的值代表3
	correct_prediction = tf.equal(tf.argmax(y_pre,1),tf.argmax(v_ys,1))
	# 统计正确的个数
	accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
	# 输出result是一个百分比，百分比越高就越准确
	result = sess.run(accuracy,feed_dict = {xs:v_xs,ys:v_ys})
	return result

#### define placeholder for inputs to network  ####

# 28*28 不规定他有多少个sample，但是规定他每个sample的大小，
# 他是一个点阵图，28*28，代表一个数字
xs = tf.placeholder(tf.float32,[None,784])
# 输出是一个一列10行的矩阵，用其中一个为1，其他为0，代表他是0-9的某个数字
ys = tf.placeholder(tf.float32,[None,10])

#### add output layer ####

# 输入数据是xs，输入数据点有784，输出有10个
# softmax一般就是用来做分类的
prediction = add_layer(xs,784,10,activation_function = tf.nn.softmax)


#### error between prediction and real data ####
# loss 函数
cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys*tf.log(prediction),
								reduction_indices = [1]))#loss
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

sess = tf.Session()

sess.run(tf.initialize_all_variables())

for i in range(1000):
	# 提取一部分的xs和ys（提取100个）
	batch_xs,batch_ys = mnist.train.next_batch(100)
	sess.run(train_step,feed_dict={xs:batch_xs,ys:batch_ys})
	if i%50 == 0:
		print(compute_accuracy(
			mnist.test.images,mnist.test.labels))

可以看到识别率提升很快，最后能达到87%的准确率。

14、用扔掉函数解决过拟合问题

# 避免过拟合方法一：增加数据量
# 避免过拟合方法二：正规化
# 避免过拟合方法三：随机忽略(dropout扔掉)
# 本例子用dropout方法
import tensorflow as tf
from sklearn.datasets import load_digits
from sklearn.cross_validation import train_test_split
from sklearn.preprocessing import LabelBinarizer
#load data
# 加载0-9数字图片
digits = load_digits()
X = digits.data
# y的意思跟以前那个分类的一个意思，一列10行的一个矩阵，用其位置来标志其分类
y = digits.target
y = LabelBinarizer().fit_transform(y)
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size = .3)


def add_layer(inputs,in_size,out_size,layer_name,activation_function=None):
	Weights = tf.Variable(tf.random_normal([in_size,out_size]))# 随机生成一个矩阵，有in_size行数和out_size列数
	biases = tf.Variable(tf.zeros([1,out_size])+0.1)# 这个是个一维数组，行数只有1，列数为out_size，这里+0.1表示他每个值都是0.1
	Wx_plus_b = tf.matmul(inputs,Weights)+biases# 矩阵相乘再加biases
	if activation_function  is None:
		outputs = Wx_plus_b# 如果没有激励，则直接就是这个线性函数
	else:
		outputs = activation_function(Wx_plus_b)# 如果有激励，则把线性函数传进激励函数（进行过滤或缩放等操作）
	
	# 增加这条，在board上显示
	#tf.histogram_summary(layer_name+'/outputs',outputs)
	# 新的api改为：
	tf.summary.histogram(layer_name+'/outputs',outputs)

	return outputs

# define placeholder for inputs to network

xs = tf.placeholder(tf.float32,[None,64])#8*8
ys = tf.placeholder(tf.float32,[None,10])

# add output layer
l1 = add_layer(xs,64,100,'l1',activation_function = tf.nn.tanh)
prediction = add_layer(l1,100,10,'l2',activation_function = tf.nn.softmax)

# the loss between prediction and real data
cross_entropy = tf.reduce_mean(-tf.reduce_sum(ys*tf.log(prediction),
								reduction_indices = [1]))#loss

#tf.scalar_summary('loss',cross_entropy)
tf.summary.scalar('loss',cross_entropy)
train_step = tf.train.GradientDescentOptimizer(0.6).minimize(cross_entropy)

sess = tf.Session()
#merged = tf.merge_all_summaries()
merged = tf.summary.merge_all()

# summary writer goes in here
train_writer = tf.summary.FileWriter("logs/train",sess.graph)
test_writer = tf.summary.FileWriter("logs/test",sess.graph)

sess.run(tf.initialize_all_variables)

for i in range(500):
	sess.run(train_step,feed_dict = {xs:X_train,ys:y_train})
	if i%50 == 0:
		#record loss
		train_result = sess.run(merged,feed_dict = {xs:X_train,ys:y_train})
		test_result = sess.run(merged,feed_dict = {xs:X_test,ys:y_test})
		train_writer.add_summary(train_result,i)
		test_writer.add_summary(test_result,i)


猜你喜欢

转载自blog.csdn.net/wzj0808/article/details/80253257
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022