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]
4. t1 = [[1, 2, 3], [4, 5, 6]]  
5. t2 = [[7, 8, 9], [10, 11, 12]]  
6. tf.concat(1, [t1, t2]) ==> [[1, 2, 3, 7, 8, 9], [4, 5, 6, 10, 11, 12
7. t1=tf.constant([1,2,3])  
8. t2=tf.constant([4,5,6])  
9. #concated = tf.concat(1, [t1,t2])这样会报错  
10. t1=tf.expand_dims(tf.constant([1,2,3]),1)  
11. t2=tf.expand_dims(tf.constant([4,5,6]),1)  
12. 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)  
4. 这个意思是产生10个3*4的二维矩阵的意思，并且，最后将他们10个都罗列到一个最外层的数组中
5. >>> a = np.array([1, 2, 3])  
6. >>> b = np.array([2, 3, 4])  
7. >>> np.stack((a, b))  
8. array([[1, 2, 3],  
9.        [2, 3, 4]])  
10.   
11. >>>  
12.   
13. >>> np.stack((a, b), axis=-1)  
14. array([[1, 2],  
15.        [2, 3],  
16.        [3, 4]])  
17.  

       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.]]])]  
33.  

19：

isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。

isinstance() 与 type() 区别：

• type() 不会认为子类是一种父类类型，不考虑继承关系。

• isinstance() 会认为子类是一种父类类型，考虑继承关系。

例子：

>>>a = 2

>>> isinstance (a,int)

True

>>> isinstance (a,str)

False

>>> isinstance (a,(str,int,list)) # 是元组中的一个返回 TrueTrue

20:np._c[]和np._r[]的用法

import numpy as np

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

b = np.array([4, 5, 6])

c = np.c_[a,b]

print(np.r_[a,b])

print(c)

print(np.c_[c,a])

 

np.r_是按列连接两个矩阵，就是把两矩阵上下相加，要求列数相等，类似于pandas中的concat()。

np.c_是按行连接两个矩阵，就是把两矩阵左右相加，要求行数相等，类似于pandas中的merge()。

21:os.path.join()的用法

它的作用是合并目录：os.path.join(file1,file2);将file1和file2的目录进行合并；

 

>>> import os

>>> os.path.join('/hello/','good/boy/','doiido')

'/hello/good/boy/doiido'

 

22：eval函数的作用

eval(str)函数很强大，官方解释为：将字符串str当成有效的表达式来求值并返回计算结果。所以，结合math当成一个计算器很好用。后面是str。

例子：

23：Matplotlib中hist的用法

matplotlib.pyplot.hist(

x, bins=10, range=None, normed=False,

weights=None, cumulative=False, bottom=None,

histtype=u'bar', align=u'mid', orientation=u'vertical',

rwidth=None, log=False, color=None, label=None, stacked=False,

hold=None, **kwargs)，

hist中的参数相对较多，x就是输入的数据，bins就是要画多少个直方图，normed指定的是密度，color指定的是颜色。

24：python中的分位数（就是数据从百分之多少划分为前后两部分）

import numpy as np

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

np.median(a)#中位数

np.percentile(a,95)#95%分位数，按百分之95的点划分为两部分，前部分占所有数据的95%，后面占5%，计算方法就是1+（4-1）*0.95=3.85，所以3.85这个点就是95%的划分点。

df = pd.DataFrame(np.array([[1, 1], [2, 10], [3, 100], [4, 100]]),columns=['a', 'b'])

print(df.quantile(.1))

输出结果：a 1.3 b 3.7 Name: 0.1, dtype: float64

计算方法与上面的一致。

25：python中的date_range的用法

pandas.date_range(start=None, end=None, periods=None, freq=’D’, tz=None, normalize=False, name=None, closed=None, **kwargs)

参数

• start：string或datetime-like，默认值是None，表示日期的起点。

• end：string或datetime-like，默认值是None，表示日期的终点。

• periods：integer或None，默认值是None，表示你要从这个函数产生多少个日期索引值；如果是None的话，那么start和end必须不能为None。

• freq：string或DateOffset，默认值是’D’，表示以自然日为单位，这个参数用来指定计时单位，比如’5H’表示每隔5个小时计算一次。

• tz：string或None，表示时区，例如：’Asia/Hong_Kong’。

• normalize：bool，默认值为False，如果为True的话，那么在产生时间索引值之前会先把start和end都转化为当日的午夜0点。

• name：str，默认值为None，给返回的时间索引指定一个名字。

• closed：string或者None，默认值为None，表示start和end这个区间端点是否包含在区间内，可以有三个值，’left’表示左闭右开区间，’right’表示左开右闭区间，None表示两边都是闭区间。

举例：pd.date_range(start='20180101',end='20180301')

输出的是从20180101到20180301的每一天日期形式。

26：dropna的用法

27 ：6*[0]=[0,0,0,0,0,0]

28: python中yield的用法：

#yield函数的作用类似于return功能，不同于return的是每次yield之后，函数并未退出，而是每次每次碰到yield都会返回相应的结果， #并保留函数当前的运行状态，等待下一次的调用，如果函数需要多次循环执行一个动作，并且每次执行的结果都是需要的，这是用yield，类似 一个生成器，生成器同时也是一个迭代器，支持通过next方法 获取下一个值

def func():
    for i in range(0,3):
        yield i
f=func()
print(f.next())
print(f.next())

29：pickle再次记忆一次。

#pickle模块是常见的函数，pickle.dump(obj,file,[protocol])函数的作用：将obj对象序列化存入已经打开的file中。
#pickle.load(file)函数功能：将file中的对象序列化读出。
#pickle.dumps(obj,[protocol])函数的功能：将obj对象序列化为string形式，而不是存入文件中
#pickle.loads(string)从string中读出序列化前的obj对象。

30：如何从序列化的的pkl文件中读取数据，因为.pkl文件是打不开或者打开全是乱码的。

#正确读取pkl文件的方式，因为pkl是一堆序列化的东西
import  cPickle as pickle
f = open("/home/yang/PycharmProjects/cnn_lstm_for_text_classify-master/cnn_my/corpus_test.pkl")
info=pickle.load(f)
print(info)

31：with open()用法总

r 只能读
r+ 可读可写 不会创建不存在的文件 从顶部开始写 会覆盖之前此位置的内容
w+ 可读可写 如果文件存在 则覆盖整个文件，不存在则创建
w 只能写 覆盖整个文件 ，不存在则创建
a 只能写 从文件底部添加内容， 不存在则创建
a+ 可读可写 从文件顶部读取内容 从文件底部添加内容， 不存在则创建

r+可读可写，不会创建不存在的文件。如果直接写文件，则从顶部开始写，覆盖之前此位置的内容，如果先读后写，则会在文件最后追加内容。

32：字典items()方法和iteritems()方法，是python字典的内建函数，分别会返回Python列表和迭代器，下面一起来看下字典items()和iteritems()的具体操作方法。
作用
python字典的items方法作用：是可以将字典中的所有项，以列表方式返回。如果对字典项的概念不理解，可以查看Python映射类型字典基础知识一文。因为字典是无序的，所以用items方法返回字典的所有项，也是没有顺序的。
python字典的iteritems方法作用：与items方法相比作用大致相同，只是它的返回值不是列表，而是一个迭代器。
调用格式
字典items()与iteritems()都是函数，调用标准格式和其它函数格式是一样的：变量.方法()
操作方法

33:python中argsort()的用法

# coding=utf-8
import numpy as np
x=np.array([1,4,3,-1,6,9])
print(x.argsort())

输出：[3 0 2 1 4 5]

输出的结果是其下标对应的最小值到最大值排序所对应的索引。

34：