pyhon中平时碰到的小知识总结

1：sep的用法

gy_contest_link_traveltime_training_data = pd.read_table('training_data.txt',sep=';')

他的作用就是让training_data.txt中的数据输出时中间加上sep后面的内容分号；输出的每一列都用；分开输出，比如输出123，而用了sep后输出的是1；2；3

2：loc和iloc的用法总结

loc主要用在panda数据结构中的dataframe中，主要是用来定位位置用的，dataframe是一个框架的形式，如果第几行第几列没有数字，那就默认为NAN

A   B    C    D

0   4    5      6

1   8    7     9 

4   4           5 

6   7    3     6

①data=df.loc(:,['A','C'])   （输出所有行和第A和C两列的值）

②data=df.iloc(:,[0,2])       （0,2就是A和C的位置坐标，当用iloc时是定位的坐标而不是具体的行列数）

③data=df.loc([0:2],['A','C'])（这里是制取前两行的和AC两列的值）

④data=df.iloc([0:2],[0,2])

通过上面的四个形式，就能很好的理解他们的用法了

3：pd.to_datetime的用法总结

df=pd.read_table('文件的绝对路径.txt',sep=",")  #读取文件

df.columns=["a","b","c"] #列的命名

df['c']=pd.to_datetime(df['c'],format='%Y-%m-%d%H;%M;%s')#读取的日期转化为datatime的格式

x=[i.year for i in df["c"]]

print x

4：pandas get_dummies

import pandas as pd

s=pd.Series(list('abcd'))

print pd.get_dummies(s)

输出结果为  

     a    b     c  

0   1   0      0

1   0  1      0

2   0   0     1

3   1   0     0

5:pd.groupby的用法

pandas提供的groupby的功能很灵活，对数据集进行切片、切块、摘要等操作。根据一个或者多个键拆分pandas对象。计算分组摘要统计，如计数、平均数、标准差，

import pandas as pd

df=pd.DataFrame({'key1':{'a','b','c','a'],'key2':['one','two',one','two','one'],'data1':np.random.randn(5),'data2':np.random.randn(5)))

grouped =df['data'].groupby(df['key1'])

grouped.mean()

其效果和下面的语法的效果是一样的

means =df['data1'].groupby([df['key1'], df['key2']]).mean()

6:python中eval（）函数的用法

可以把list,tuple,dict和string相互转化。
#################################################
字符串转换成列表
>>>a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
>>>type(a)
<type 'str'>
>>> b = eval(a)
>>> print b
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]
>>> type(b)
<type 'list'>
#################################################
字符串转换成字典
>>> a = "{1: 'a', 2: 'b'}"
>>> type(a)
<type 'str'>
>>> b = eval(a)
>>> print b
{1: 'a', 2: 'b'}
>>> type(b)
<type 'dict'>
#################################################
字符串转换成元组
>>> a = "([1,2], [3,4], [5,6], [7,8], (9,0))"
>>> type(a)
<type 'str'>
>>> b = eval(a)
>>> print b
([1, 2], [3, 4], [5, 6], [7, 8], (9, 0))
>>> type(b)
<type 'tuple'>

7：Python中的future模块的作用

python提供的__future__模块，是把下一个新版本的特性导入到当前版本，这样就可以在当前版本中测试一些新版本的特性，主要就是版本2.7中下载一部分代码中测试一些3.0的特性，乳沟没问题再将3.0的代码移植到2.7中。

由于Python是由社区推动的开源并且免费的开发语言，不受商业公司控制，因此，Python的改进往往比较激进，不兼容的情况时有发生。Python为了确保你能顺利过渡到新版本，特别提供了__future__模块，让你在旧的版本中试验新版本的一些特性

8：Python中的collection模块的作用

python有一些内置的数据类型，比如str,int,list,tuple,dict等，collectiongs模块在这些内置数据类型的基础上，提供了几个额外的数据类型：

①：namedtuple():生成可以使用名字访问元素内容的tuple子类

②：双端队列，可以快速的从另一端追加推出对象

③：Counter:计数器，主要用来计数

④：orderDict：有序字典

⑤：defaultdict：带有默认的字典

9：Python中列别和元组的区别

①：列表是可以改变的，但是元组是不能更改的

②：列别可以利用append()方法进行添加，而元组不能更改

③：Python采用元组的方法使含义更加明确(namedtuple)

10：Python中zip（）函数的用法

  x=[[1,2],[2,3]]

y=[[6,7],[8,9]]

     z=zip(x,y),

z=[[1,6],[2,7],[2,8],[3,9]]

z=zip(*x,y)的作用就是一个类似解压包的过程

11:tf.cast()函数的用法

a = tf.Variable([1,0,0,1,1]) b = tf.cast(a,dtype=tf.bool，name=None)

tf.cast就是将a的原来的数据格式转化为目标类型dtype=bool类型，命名name为：

12：import pickle: pickle模块的作用是将数据对象保存到文件中

      pickle模块实现基本数据的序列化和反序列化。pickle模块的序列化操作是将程序中运行的对象信息保存到文件中永久保存；反序列化操作是我们从文件中创建上一次程序保存的对象。

       pickle.dump(obj, file ,[,protocol])，将对象obj保存到文件file中去，protocol为序列化的协议版本。

       pickle.load(file)；从file中读取一个字符串，并将它重构为原来的python对象。file为文件对象，有read()和readline()接口。

13:python中join()的用法

      >>> a="aaaddd"
     >>> ",".join(a)
'    a,a,a,d,d,d'

   >>> b="ccccbbbb"
   >>> "|".join(a+b)
   'a|a|a|d|d|d|c|c|c|c|b|b|b|b'

14：np.random.seed()

seed()的用法，如果为np.random.seed(5)那意思是产生5个相同的随机数字，如果没有指定seed()后面具体是多少，那每次循环时产生的随机数都是不同的

15:numpy库中tlie函数的用法、

a=array(1,3)

tile(a,1)

输出：array([1,2])

tile(a,2)

输出：array([1,2,1,2])

tile(a,3)

输出：array([1,2,1,2,1,2])

tile(a,(1,1))

输出：array([[1,2]]

tile(a,(1,2))

输出：array([[1,2,1,2]])

tile(a,(2,1))

array([[1,2],

           [1,2]])

总结：tile(a,(1,2))里面参数1是控制a的行数，2是控制a的重复次数

15：tf.concat()的用法

tf.concat(concat_dim, values, name='concat')

第一个参数concat_dim：必须是一个数，表明在哪一维上连接\

如果concat_dim是0，那么在某一个shape的第一个维度上连，对应到实际，就是叠放到列上

如果concat_dim是1，那么在某一个shape的第二个维度上连

第二个参数values：就是两个或者一组待连接的tensor了


1. t1 = [[1, 2, 3], [4, 5, 6]]  
2. t2 = [[7, 8, 9], [10, 11, 12]]  
3. tf.concat(0, [t1, t2]) == > [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]

1. t1 = [[1, 2, 3], [4, 5, 6]]  
2. t2 = [[7, 8, 9], [10, 11, 12]]  
3. tf.concat(1, [t1, t2]) ==> [[1, 2, 3, 7, 8, 9], [4, 5, 6, 10, 11, 12

1. t1=tf.constant([1,2,3])  
2. t2=tf.constant([4,5,6])  
3. #concated = tf.concat(1, [t1,t2])这样会报错  
4. t1=tf.expand_dims(tf.constant([1,2,3]),1)  
5. t2=tf.expand_dims(tf.constant([4,5,6]),1)  
6. concated = tf.concat(1, [t1,t2])#这样就是正确的

16：fromkeys的用法

seq=('name','sex','age')dict=dict.fromkeys(seq)print(str(dict))dict=dict.fromkeys(seq,2)print(str(dict))

{'name': None, 'sex': None, 'age': None}
{'name': 2, 'sex': 2, 'age': 2}

17：npy和npz的区别

文件存取的格式：二进制和文本。二进制格式的文件又分为NumPy专用的格式化二进制类型和无格式类型。

np.save("a.npy",a)

c=np.load("a.npy")

文件保存为npy否则会出错，保存numpy专用二进制格式化后，就可以用notepad++打开乱码看了

18：np.stack()，np.hstack(), np.dstack(),np.vstack(),np.vsplit()等的用法：

     1:np,stack(arrays,axis=0)

1. >>> arrays = [np.random.randn(3, 4) for _ in range(10)]  
2. >>> np.stack(arrays, axis=0).shape  
3. (10, 3, 4)  

        

1. >>> a = np.array([1, 2, 3])  
2. >>> b = np.array([2, 3, 4])  
3. >>> np.stack((a, b))  
4. array([[1, 2, 3],  
5.        [2, 3, 4]])  
6.   
7. >>>  
8.   
9. >>> np.stack((a, b), axis=-1)  
10. array([[1, 2],  
11.        [2, 3],  
12.        [3, 4]])  

       2:np.hstack()

     

1. >>> a = np.array((1,2,3))  
2. >>> b = np.array((2,3,4))  
3. >>> np.hstack((a,b))  
4. array([1, 2, 3, 2, 3, 4])  
5. >>> a = np.array([[1],[2],[3]])  
6. >>> b = np.array([[2],[3],[4]])  
7. >>> np.hstack((a,b))  
8. array([[1, 2],  
9.        [2, 3],  
10.        [3, 4]])  

     3:np.vstack()

        

1. >>> a = np.array([1, 2, 3])  
2. >>> b = np.array([2, 3, 4])  
3. >>> np.vstack((a,b))  
4. array([[1, 2, 3],  
5.        [2, 3, 4]])  
6.   
7. >>>  
8.   
9. >>> a = np.array([[1], [2], [3]])  
10. >>> b = np.array([[2], [3], [4]])  
11. >>> np.vstack((a,b))  
12. array([[1],  
13.        [2],  
14.        [3],  
15.        [2],  
16.        [3],  
17.        [4]]) 

    4:np.dstack()

     

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

  5:np.vsplit()

     

1. >>> x = np.arange(16.0).reshape(4, 4)  
2. >>> x  
3. array([[  0.,   1.,   2.,   3.],  
4.        [  4.,   5.,   6.,   7.],  
5.        [  8.,   9.,  10.,  11.],  
6.        [ 12.,  13.,  14.,  15.]])  
7. >>> np.vsplit(x, 2)  
8. [array([[ 0.,  1.,  2.,  3.],  
9.        [ 4.,  5.,  6.,  7.]]),  
10.  array([[  8.,   9.,  10.,  11.],  
11.        [ 12.,  13.,  14.,  15.]])]  
12. >>> np.vsplit(x, np.array([3, 6]))  
13. [array([[  0.,   1.,   2.,   3.],  
14.        [  4.,   5.,   6.,   7.],  
15.        [  8.,   9.,  10.,  11.]]),  
16.  array([[ 12.,  13.,  14.,  15.]]),  
17.  array([], dtype=float64)]  
18.   
19. With a higher dimensional array the split is still along the first axis.  
20. >>>  
21.   
22. >>> x = np.arange(8.0).reshape(2, 2, 2)  
23. >>> x  
24. array([[[ 0.,  1.],  
25.         [ 2.,  3.]],  
26.        [[ 4.,  5.],  
27.         [ 6.,  7.]]])  
28. >>> np.vsplit(x, 2)  
29. [array([[[ 0.,  1.],  
30.         [ 2.,  3.]]]),  
31.  array([[[ 4.,  5.],  
32.         [ 6.,  7.]]])]