Python 知识点及Tensorflow基础知识记录

本文主要记录自己在学习过程中遇到的一些python知识点以及Tensorflow基础知识，并不是全部知识点，仅供参考

1、 array与list、matrix的区别

list可以明显和array、matrix区分，list通过[ ]申明，支持append extend等方法，没有shape方法。
list变成array： np.array(list)
list变为matrxi：np.mat(list)
array和matrix相互转换: np.asmatrix np.asarray
array变换为list： data.toList()
两个都有shape属性，但是他俩的区别是什么？
matrix是array的子集，matrix只能是2维的，array可以是n维的。

import numpy as np
x = np.array ([1,1,1,1,-1,-1,-1])
print(x==1)

结果为[ True True True True False False False]
可以利用numpy 的where函数进行类似的操作。

x1 = np.where(x==1,True,False),但是x一定要为array，不能为list

2、读取文件错误

(1)在字符串前加上r或R，即：imread(r’C:\Users\harchi\Desktop\图像处理\skeleton.bmp’) ，其中r或R在python中表示一个不转义的字符串。
(2)在“\”前加上""实现转义。即：imread(‘C:\Users\harchi\Desktop\图像处理\skeleton.bmp’)
(3)将“\”换为“/”，即：imread(‘C:/Users\harchi/Desktop/图像处理/skeleton.bmp’)
最后：补充一下python字符串前缀的知识：
一、在字符串前加上r或R表示该字符串是非转义的原始字符串。
二、在字符串前加上u或U表示该字符串是unicode字符串。

3、单双下划线区别

Python 用下划线作为变量前缀和后缀指定特殊变量
_xxx ：保护变量，意思是只有类对象和子类对象能够访问到这些变量(尽量避免在类外部直接修改)
xxx ：系统定义名字
__xxx ：类中的私有变量名，意思是只有类对象自己能访问，连子类对象也不能访问到这个数据。
核心风格：避免用下划线作为变量名的开始。

4、iloc 和loc区别

loc——通过行标签索引行数据
iloc——通过行号索引行数据
ix——通过行标签或者行号索引行数据（基于loc和iloc 的混合）
示例：loc

import pandas as pd
data=[[1,2,3],[4,5,6]]
index=['a','b']#行号
columns=['c','d','e']#列号
df=pd.DataFrame(data,index=index,columns=columns)#生成一个数据框
#print df.loc['a']

c    1
d    2
e    3

print df.loc[0]
#这个就会出现错误：TypeError: cannot do label indexing on <class ‘pandas.indexes.base.Index’> with these indexers [1] of <type ‘int’>

示例：iloc

import pandas as pd
data=[[1,2,3],[4,5,6]]
index=['a','b']#行号
columns=['c','d','e']#列号
df=pd.DataFrame(data,index=index,columns=columns)#生成一个数据框

print df.iloc[0]

c    1
d    2
e    3

print df.iloc[‘a’]
#TypeError: cannot do positional indexing on <class ‘pandas.indexes.base.Index’> with these indexers [a] of <type ‘str’>

示例：ix

import pandas as pd
data=[[1,2,3],[4,5,6]]
index=['a','b']#行号
columns=['c','d','e']#列号
df=pd.DataFrame(data,index=index,columns=columns)#生成一个数据框

print df.ix[0]

c    1
d    2
e    3

print df.ix['a']

c    1
d    2
e    3

5、numpy的zeros、ones、empty函数

zeros函数可以创建任意维度和元素个数的数组，其元素值均为0；
ones函数可以创建任意维度和元素个数的数组，其元素值均为1；
empty一样，只是它所常见的数组内所有元素均为空，没有实际意义，所以它也是创建数组最快的方法。

Import numpy as np
a= np.zeros(5)
print(a)
输出：array([0., 0., 0., 0., 0.])

b = np.ones(1)
print(b)
输出：array([1., 1., 1., 1., 1.])

6、arange()、reshape()、shape()、contourf()函数

range(start, end, step)，返回一个list对象，起始值为start，终止值为end，但不含终止值，步长为step。只能创建int型list。
arange(start, end, step)，与range()类似，但是返回一个array对象。需要引入import numpy as np，并且arange可以使用float型数据。
reshape()函数功能：给予数组一个新的形状，而不改变它的数据
示例：

a=array([[1,2,3],[4,5,6]])  
reshape(a, 6)
输出：array([1,2,3,4,5,6)

shape函数是numpy.core.fromnumeric中的函数，它的功能是查看矩阵或者数组的维数。

contour和contourf都是画三维等高线图的，不同点在于contourf会对等高线间的区域进行填充，区别如下

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
x=np.array([1,2])
y=np.array([1,2])
z=np.array([[1,2],[2,3]])
plt.xlim(1,2)
plt.ylim(1,2)
colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')
cmap = ListedColormap(colors[:len(np.unique(z))])
plt.contourf(x,y,z,cmap=cmap)   ###
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
x=np.array([1,2])
y=np.array([1,2])
z=np.array([[1,2],[2,3]])
plt.xlim(1,2)
plt.ylim(1,2)
colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')
cmap = ListedColormap(colors[:len(np.unique(z))])
plt.contour(x,y,z,cmap=cmap)   ###
plt.show()

7、numpy.ravel() vs numpy.flatten()

声明两者所要实现的功能是一致的（将多维数组降位一维），两者的区别在于返回拷贝（copy）还是返回视图（view），numpy.flatten()返回一份拷贝，对拷贝所做的修改不会影响（reflects）原始矩阵，而numpy.ravel()返回的是视图（view，也颇有几分C/C++引用reference的意味），会影响（reflects）原始矩阵。

x = np.array([[1, 2], [3, 4]])

输出：array([[1, 2],
       [3, 4]])
       
x.flatten()
输出：array([1, 2, 3, 4])

x.ravel()
输出：array([1, 2, 3, 4])

两者默认均是行序优先
x.flatten('F')
输出：array([1, 3, 2, 4])

 x.ravel('F')
输出：array([1, 3, 2, 4])


区别：
x = np.array([[1, 2], [3, 4]])
x.flatten()[1] = 100
 x
输出：array([[1, 2],
       [3, 4]])   # flatten：返回的是拷贝
       
x.ravel()[1] = 100
x
输出：array([[ 1, 100],
       [ 3,  4]])

8、zip()函数

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表

a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
zipped = zip(a,b)     # 打包为元组的列表
输出：[(1, 4), (2, 5), (3, 6)]

zip(a,c)              # 元素个数与最短的列表一致
输出：[(1, 4), (2, 5), (3, 6)]

zip(*zipped)          # 与 zip 相反，可理解为解压，返回二维矩阵式
输出：[(1, 2, 3), (4, 5, 6)]

9、numpy中的dot()函数

dot()返回的是两个数组的点积(dot product)

(1)如果处理的是一维数组，则得到的是两数组的內积

In : d = np.arange(0,9)
Out: array([0, 1, 2, 3, 4, 5, 6, 7, 8])
In : e = d[::-1]
Out: array([8, 7, 6, 5, 4, 3, 2, 1, 0])

In : np.dot(d,e) 
Out: 84

(2)如果是二维数组（矩阵）之间的运算，则得到的是矩阵积（matrix product）。

In : a = np.arange(1,5).reshape(2,2)
Out:
array([[1, 2],[3, 4]])
In : b = np.arange(5,9).reshape(2,2)

Out:
array([[5, 6],[7, 8]])

In : np.dot(a,b)
Out:
array([[19, 22],[43, 50]])

10、Python class和class(Object)的区别

# -.- coding:utf-8 -.-
# __author__ = 'zhengtong'

class Person:
    """
    不带object
    """
    name = "zhengtong"

class Animal(object):
    """
    带有object
    """
    name = "chonghong"

if __name__ == "__main__":
    x = Person()
    print "Person", dir(x)

    y = Animal()
    print "Animal", dir(y)

运行结果

Person ['__doc__', '__module__', 'name']

Animal ['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', 
'__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', 
'__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name']

Person类很明显能够看出区别，不继承object对象，只拥有了doc , module 和 自己定义的name变量, 也就是说这个类的命名空间只有三个对象可以操作.
Animal类继承了object对象，拥有了好多可操作对象，这些都是类中的高级特性。

对于不太了解python类的同学来说，这些高级特性基本上没用处，但是对于那些要着手写框架或者写大型项目的高手来说，这些特性就比较有用了，比如说tornado里面的异常捕获时就有用到class来定位类的名称，还有高度灵活传参数的时候用到dict来完成.

最后需要说清楚的一点， 本文是基于python 2.7.10版本，实际上在python 3.0中已经默认就帮你加载了object了（即便你没有写上object）。

11、subplot()函数

调用格式：subplot(numRows, numCols, plotNum)
参数一，子图总行数
参数二，子图总列数
参数三，子图位置

subplot将整个绘图区域等分为numRows行* numCols列个子区域，然后按照从左到右，从上到下的顺序对每个子区域进行编号，左上的子区域的编号为1。如果numRows，numCols和plotNum这三个数都小于10的话，可以把它们缩写为一个整数，例如subplot(323)和subplot(3,2,3)是相同的。subplot在plotNum指定的区域中创建一个轴对象。如果新创建的轴和之前创建的轴重叠的话，之前的轴将被删除。

12、numpy中shuffle与permutation的区别

函数shuffle与permutation都是对原来的数组进行重新洗牌（即随机打乱原来的元素顺序）；区别在于shuffle直接在原来的数组上进行操作，改变原来数组的顺序，无返回值。而permutation不直接在原来的数组上进行操作，而是返回一个新的打乱顺序的数组，并不改变原来的数组。

a = np.arange(12)
print a
np.random.shuffle(a)
print a
a = np.arange(12)
print a
b = np.random.permutation(a)
print b
print a

输出：

[ 0  1  2  3  4  5  6  7  8  9 10 11]
[11  6  4 10  3  0  7  1  9  2  5  8]

[ 0  1  2  3  4  5  6  7  8  9 10 11]
[10  4  8 11  1  7  6  2  0  9  5  3]
[ 0  1  2  3  4  5  6  7  8  9 10 11]

Tensorflow基础知识

1、batchsize、iteration和epoch 的理解

(1)batchsize：批大小。在深度学习中，一般采用SGD训练，即每次训练在训练集中取batchsize个样本训练；
(2)iteration：1个iteration等于使用batchsize个样本训练一次；
(3)epoch：1个epoch等于使用训练集中的全部样本训练一次；

举个例子，训练集有1000个样本，batchsize=10，那么：
训练完整个样本集需要：
100次iteration，1次epoch。

2、Tensorflow 中几个常用函数的解析

(1)Reduce_mean()

import tensorflow as tf;
import numpy as np;
 
A = np.array([[1,2], [3,4]])
 
with tf.Session() as sess:
	print sess.run(tf.reduce_mean(A))
	print sess.run(tf.reduce_mean(A, axis=0))
	print sess.run(tf.reduce_mean(A, axis=1))

输出：

2 #整体的平均值
[2 3] #按列求得平均
[1 3] #按照行求得平均

(2)Placeholder()

tensorflow中又一保存数据的利器，placeholder（type,strucuct…)它的第一个参数是你要保存的数据的数据类型，大多数是tensorflow中的float32数据类型，后面的参数就是要保存数据的结构，比如要保存一个1×2的矩阵，则struct=[1 2]。它在使用的时候和前面的variable不同的是在session运行阶段，需要给placeholder提供数据，利用feed_dict的字典结构给placeholdr变量“喂数据”，具体使用如下:

import tensorflow as tf
a=tf.placeholder(tf.float32)
b=tf.placeholder(tf.float32)
c=tf.add(a,b)

with tf.Session() as sess:
	print(sess.run(c,feed_dict={a:10,b:30}))  #把10赋给a，30赋给b

结果为40

(3) Constant()

def constant(value, dtype=None, shape=None, name=“Const”, verify_shape=False)
value: 符合tf中定义的数据类型的常数值或者常数列表;
dtype：数据类型，可选;
shape：常量的形状，可选;
name：常量的名字，可选;
verify_shape：常量的形状是否可以被更改，默认不可更改;

constant()函数提供在tensorflow中定义常量(不可更改的张量)的方法。

例如：

tensor_constant1 = tf.constant([1,2,3,4])

得到常数张量[1,2,3,4]。

(4) Variable()

tensorflow中的可以改变的量包括训练过程中的输入数据，输出数据以及控制从输入到输出的学习机制(具体体现为网络参数)，输入输出数据在tf中是用placeholder占位符定义的，tf的学习机制使用变量来表示。

TensorFlow中的变量特指深度学习机制中，控制输入到输出映射的可以变化的数据，这些变化数据随着训练迭代的进行，不断地改变数值，不断优化，使输出的结果越来越接近于正确的结果。

例如初始化一个含有100个值为0的一维常量的变量：

w_c1 = Variable(tf.zeros([100]))

(5)reduce_sum()

import tensorflow as tf;
import numpy as np;
 
A = np.array([[1,2], [3,4]])
 
with tf.Session() as sess:
	print sess.run(tf.reduce_sum(A))
	print sess.run(tf.reduce_sum(A, axis=0))
	print sess.run(tf.reduce_sum(A, axis=1))

输出

10 #整体的和
[4 6] #按列求和
[3 7] #按照行求和

(6)session()

#创建会话
session=tf.Session()
#运行定义好的运算
session.run()
#关闭会话
session.close()

例：

import tensorflow as tf

a=tf.constant([1.0,2.0],name="a")

sess=tf.Session()
sess.run(a+b)
array([ 6.,  8.], dtype=float32)
sess.close()

a+b 输出如下：

<tf.Tensor 'add_1:0' shape=(2,) dtype=float32>

(7)argmax()

tf.argmax(input, axis=None, name=None, dimension=None)

此函数是对矩阵按行或列计算最大值

参数
input：输入Tensor
axis：0表示按列，1表示按行
name：名称
dimension：和axis功能一样，默认axis取值优先。新加的字段

返回：Tensor 一般是行或列的最大值下标向量

import tensorflow as tf  
      
a=tf.get_variable(name='a', shape=[3,4],dtype=tf.float32,initializer=tf.random_uniform_initializer(minval=-1,maxval=1))  
b=tf.argmax(input=a,axis=0)  
c=tf.argmax(input=a,dimension=1)   #此处用dimesion或用axis是一样的  
sess = tf.InteractiveSession()  
sess.run(tf.initialize_all_variables())  

print(sess.run(a))  
    #[[ 0.04261756 -0.34297419 -0.87816691 -0.15430689]  
    # [ 0.18663144  0.86972666 -0.06103253  0.38307118]  
    # [ 0.84588599 -0.45432305 -0.39736366  0.38526249]]  
    
print(sess.run(b))  
    #[2 1 1 2]  
    
print(sess.run(c))  
#[0 1 0]  

(8)equal()

tf.equal(A, B)是对比这两个矩阵或者向量的相等的元素，如果是相等的那就返回True，否则返回False，返回的值的矩阵维度和A是一样的。

import tensorflow as tf
import numpy as np
 
A = [[1,3,4,5,6]]
B = [[1,3,4,3,2]]
 
with tf.Session() as sess:
print(sess.run(tf.equal(A, B)))

输出：

[[ True  True  True False False]]

(9）cast()

tf.cast(x, dtype, name=None)
此函数是类型转换函数

参数：
x：输入
dtype：转换目标类型
name：名称
返回：Tensor

tensor a is [1.8, 2.2], dtype=tf.float

tf.cast(a, tf.int32) ==> [1, 2] # dtype=tf.int32

(10)clip_by_value()

将制定的tensor 限制在指定范围内。

import tensorflow as tf

#默认会话
sess = tf.InteractiveSession()

#定义一个list，填入一些数据
a = [1.0,2.0,3.1,4.3,5.6,2.4,6.7,1e-6,1e-7,0]

使用tf.clip_by_value函数进行处理，并返回处理过的tensor
#clip_by_value(t, clip_value_min, clip_value_max,name=None)
#t：待处理的tensor，或是一个list等
#clip_value_min：需要过滤的最小值，若t中存在比该值还小的值，一律换成clip_value_min
#clip_value_max：需要过滤的最大值，若t中存在比该值还大的值，一律换成clip_value_max
#name：名称

a = tf.clip_by_value(a,1e-5,5.0)    
print(a.eval())

[  1.00000000e+00   2.00000000e+00   3.09999990e+00   4.30000019e+00
   5.00000000e+00   2.40000010e+00   5.00000000e+00   9.99999975e-06
   9.99999975e-06   9.99999975e-06]