以下函数的用法基于Tensorflow1.4版本。
1、tf.constant
tf.constant方法用来定义一个常量，所谓常量，就是“不变化的量”。我们先看下官方Api是如何对constant函数来定义的：
tf.constant(
value,
dtype=None,
shape=None,
name='Const',
verify_shape=False
)
其中包括5个输入值：
value（必填）：常量值，可以是一个数，也可以是一个向量或矩阵。
dtype（非必填）：用来指定数据类型，例如tf.float32类型或tf.float64。
shape（非必填）：用来指定数据的维度。
name（非必填）：为常量定义名称，默认为Const。
verify_shape（非必填）：默认值为False，如果值为True时，在定义常量时会自动检测value和shape维度是否相同，不同则报错，例如value定义为1，而shape定义为一行两列的矩阵（1,2），那么肯定会报错。
了解了参数的具体含义，我们用代码来验证一下吧！
指定value的值：
#定义一个整数
a = tf.constant(1)
#定义一个向量
b = tf.constant([1,2])
#定义一个2行3列的矩阵
c = tf.constant([[1,2,3],[4,5,6]])
print(a)
print(b)
print(c)
输出结果：
Tensor("Const:0", shape=(), dtype=int32)
Tensor("Const_1:0", shape=(2,), dtype=int32)
Tensor("Const_2:0", shape=(2, 3), dtype=int32)
变量a的shape为空，0个纬度，也就是一个数值；
变量b的shape是（2,），只有一个维度，是一个长度为2向量；
变量c的shape是（2,3），有两个维度，是一个2X3的矩阵。
当指定dtype参数时：
#定义一个整数
a = tf.constant(1,dtype=tf.float32)
#定义一个向量
b = tf.constant([1,2],dtype=tf.float32)
#定义一个2行3列的矩阵
c = tf.constant([[1,2,3],[4,5,6]],dtype=tf.float32)
print(a)
print(b)
print(c)
输出结果：
Tensor("Const:0", shape=(), dtype=float32)
Tensor("Const_1:0", shape=(2,), dtype=float32)
Tensor("Const_2:0", shape=(2, 3), dtype=float32)
可见数值的类型都变为float32类型。
当指定shape参数时：
#定义一个整数
a = tf.constant(2.,shape=())
b = tf.constant(2.,shape=(3,))
c = tf.constant(2.,shape=(3,4))
with tf.Session() as sess:
print(a.eval())
print(b.eval())
print(c.eval())
输出结果：
2.0
[2. 2. 2.]
[[2. 2. 2. 2.]
[2. 2. 2. 2.]
[2. 2. 2. 2.]]
此时constant会根据shape指定的维度使用value值来进行填充，例如参数a指定维度为0，也就是一个整数；参数b指定维度为1长度为3，也就是一个向量；参数b指定维度为2长度为3X4，也就是定义一个3X4的矩阵，全部都使用value值2.0来进行填充。
当指定name参数时：
#不指定name
a = tf.constant(2.)
#指定name
b = tf.constant(2.,name="b")
print(a)
print(b)
输出结果：
Tensor("Const:0", shape=(), dtype=float32)
Tensor("b:0", shape=(), dtype=float32)
常量的默认名称为Const，建议大家创建常量时最好定义一下name，只要是字符串就没有问题。
当指定verify_shape=True时：
a = tf.constant(2.,shape=(2,3),verify_shape=True)
输出结果报错：
TypeError: Expected Tensor's shape: (2,3), got ().
错误原因是value的值和指定的shape维度不同，value是一个数值，而我们指定的shape为2X3的矩阵，所以报错！当我们去掉verify_shape参数时错误即消失。那么问题来了，此时这个常量到底是整数还是一个矩阵呢？当然是矩阵啦（一个被value值填充的2X3矩阵）！
2、tf.Variable
tf.Variable方法用来定义一个变量，所谓变量，就是“变化的量”。我们看一下函数的定义：
tf.Variable(
initial_value=None,
trainable=True,
collections=None,
validate_shape=True,
caching_device=None,
name=None,
variable_def=None,
dtype=None,
expected_shape=None,
import_scope=None,
constraint=None
)
是不是参数多到令人发指！目前感觉最常用的也就是initial_value、name、dtype，用法和tf.constant类似，这里不用代码做过多演示。
3、tf.zeros
tf.zeros用来定义一个全部元素都为0的张量，例如一个全为0的矩阵或向量，看一下函数的定义：
tf.zeros(
shape,
dtype=tf.float32,
name=None
)
shape：数据的维度。
dtype：数据得类型。
name：命名。
#长度为1的1维向量
a = tf.zeros([1])
#长度为2的1维向量
b = tf.zeros([2])
#2维矩阵，矩阵大小3X4
c = tf.zeros([3,4])
with tf.Session() as sess:
print(sess.run(a))
print(sess.run(b))
print(sess.run(c))
输出结果：
[0.]
[0. 0.]
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
4、tf.ones
和tf.zeros功能相似，tf.ones用来定义一个全部元素都为1的张量，例如一个全为1的矩阵或向量，看一下函数的定义：
tf.ones(
shape,
dtype=tf.float32,
name=None
)
测试代码：
#长度为1的1维向量
a = tf.ones([1],name="n1",dtype=tf.float32)
#长度为2的1维向量
b = tf.ones([2])
#2维矩阵，矩阵大小3X4
c = tf.ones([3,4])
with tf.Session() as sess:
print(sess.run(a))
print(sess.run(b))
print(sess.run(c))
输出结果：
[1.]
[1. 1.]
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
5、tf.random_uniform
tf.random_uniform可用来生成一个被随机数填充的张量，可以是向量或矩阵，函数定义为：
tf.random_uniform(
shape,
minval=0,
maxval=None,
dtype=tf.float32,
seed=None,
name=None
)
参数说明：
shape：定义形状
minval：随机数最小值，默认是0
maxval：随机数最大值，默认是1
dtype：数据得类型，默认是float32类型
seed：随机数种子
name：定义返回值名称
#定义一个由最小值为0，最大值为0.5填充的向量
a = tf.random_uniform([3],0,0.5,name="a")
#定义一个由最小值为-1，最大值为1填充的4X3的矩阵
b = tf.random_uniform([4,3],-1,1,name="b")
#定义一个最小值为10，最大值为100的随机数
c = tf.random_uniform([],10,100,name="c")
#定义seed为1
d = tf.random_uniform([],10,100,seed=1)
e = tf.random_uniform([],10,100,seed=1)
#定义seed为2
f = tf.random_uniform([],10,100,seed=2)with tf.Session() as sess:
print(sess.run(a))
print(sess.run(b))
print(sess.run(c))
print(sess.run(d))
print(sess.run(e))
print(sess.run(f))
输出结果：
[0.37117624 0.28079355 0.12813371]
[[ 0.50496936 0.2632537 -0.30630517]
[ 0.16871548 0.7529404 -0.6158774 ]
[-0.9147036 0.35593843 -0.50358105]
[-0.4618771 -0.26037788 0.7437594 ]]
40.39641
31.513365
31.513365
71.08719
从结果中我们会发现，值d和e在设置相同seed的情况下，随机数值的相同的，这就意味着，如果最小值、最大值以及种子定义完全相同的话，随机数值也是相同的。如果想在相同范围内得到不同的随机数值，请修改seed
6、tf.add
tf.add方法计算两个张量之和，先看函数格式：
tf.add(
x,
y,
name=None
)
x：张量1
y：张量2
name：计算结果命名
注：输入的x，y两个张量的类型必须一致
#数值加法
a = tf.constant(3)
b = tf.constant(4)
c = tf.add(a,b)#向量加法
a1 = tf.constant([1,2])
b1 = tf.constant([3,4])
c1 = tf.add(a1,b1)#矩阵加法
a2 = tf.constant([[1,1],[2,2]])
b2 = tf.constant([[3,3],[4,4]])
c2 = tf.add(a2,b2)with tf.Session() as sess:
print("数值加法")
print(sess.run(c))
print("向量加法")
print(sess.run(c1))
print("矩阵加法")
print(sess.run(c2))
输出结果：
数值加法
7
向量加法
[4 6]
矩阵加法
[[4 4]
[6 6]]
7、tf.subtract
tf.subtract方法计算两个张量之差，与tf.add结构相同。同样需要注意的是，传入的两个张量的类型必须保持一致。
tf.subtract(
x,
y,
name=None
)
8、tf.matmul和tf.multiply
之所以把matmul和multipy放在一起讨论，因为好多人会把这两个函数搞混。
tf.matmul是矩阵乘法，tf.multiply是元素乘法。
#定义一个被数值2填充的2X3矩阵
a = tf.constant(2,shape=(2,3),name="a")
#定义一个被数值3填充的2X3矩阵
b = tf.constant(3,shape=(2,3),name="b")
#定义一个被数
c = tf.constant(5,name="c")
#multiply
d = tf.multiply(a,b)
#multiply
e = tf.multiply(a,c)
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
print('a的值')
print(sess.run(a))
print('b的值')
print(sess.run(b))
print('c的值')
print(sess.run(c))
print('matmul(a,b)')
print(sess.run(d))
print('matmul(a,c)')
print(sess.run(e))
输出结果：
a的值
[[2 2 2]
[2 2 2]]
b的值
[[3 3 3]
[3 3 3]]
c的值
5
matmul(a,b)
[[6 6 6]
[6 6 6]]
matmul(a,c)
[[10 10 10]
[10 10 10]]
a、b是两个矩阵，ca和b类型一致，可以multiply，结果依然是一个2X3的矩阵；
a是一个矩阵，c是一个数值，虽类型不同，但依然可以multiply，结果和a的类型保持一致。
所以multiply的两个输入的张量类型可以不一致。
#定义一个被数值2填充的2X3矩阵
a = tf.constant(2,shape=(2,3),name="a")
#定义一个被数值3填充的2X3矩阵
b = tf.constant(3,shape=(3,3),name="b")
#multiply
c = tf.matmul(a,b)
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
print('a的值')
print(sess.run(a))
print('b的值')
print(sess.run(b))
print('matmul后')
print(sess.run(c))
输出结果：
a的值
[[2 2 2]
[2 2 2]]
b的值
[[3 3 3]
[3 3 3]
[3 3 3]]
matmul后
[[18 18 18]
[18 18 18]]
a、b两个矩阵被函数matmul处理后，依然是一个2X3的矩阵，matmul要求两个输入的张量类型必须完全的一致。
9、tf.divide
浮点数除法，两个输入的张量类型可以不一致。
tf.divide(
x,
y,
name=None
)
10、tf.mod
两个张量相除并取余。
tf.mod(
x,
y,
name=None
)
11、tf.placeholder
之前我们了解了如何用tf.constant定义常量，用tf.Variable定义变量，那加入我想在运算过程中动态的修改传入的值呢？我们可以考虑使用placeholder，也就是占位符。我们先看一下它的结构：
tf.placeholder(
dtype,
shape=None,
name=None
)
结构很简单，那我们为什么要用占位符呢？这其实就设计到了Tensorflow的设计理念，作为入门教程的第二篇，我们先不讲其设计理念和计算流图，我们只要记住，在未创建Tensorflow的session会话之前，定义的所有变量、常量其实都还没有进行计算，我们使用placeholder可以先为一个变量预留出一份内存，等Tensorflow启动session会话以后，就可以将数据喂到这个预留的内存中去，实现Tensorflow运算过程中的动态赋值，文字不好理解，直接上代码：
import tensorflow as tf
import numpy as np
#定义一个数值
a = tf.constant(2.,name="a")
#定义一个数值类型的placeholder
b = tf.placeholder(tf.float32,[],name="b")
#定义一个矩阵类型的placeholder
c = tf.placeholder(tf.float32,[2,3],name="c")
#d为a*b
d = tf.multiply(a,b)
#e为a*c
e = tf.multiply(a,c)
#一个随机数组
rand_value = np.random.rand(2,3)
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)#初始化变量
print("从0循环到9，分别乘2")
for i in range(10):
print(sess.run(d,feed_dict={b:i}))
print("传入随机生成的一个数组")
print(sess.run(e,feed_dict={c:rand_value}))
输出结果：
从0循环到9，分别乘2
0.0
2.0
4.0
6.0
8.0
10.0
12.0
14.0
16.0
18.0
传入随机生成的一个数组
[[0.7041698 1.0414026 1.973911 ]
[1.952334 0.46541974 1.1905501 ]]
d的值等于a乘b，a的值为2.0，b为一个占位符，在运算过程中，通过feed_dict动态的修改了b的值，得到了不同的计算结果。
e的值等于a乘c，a的值为2.0，c为一个2X3的矩阵占位符，运算过程中，使用feed_dict动态的把随机矩阵rand_value喂到了运算中，计算得到了不同的结果。
