python数据分析相关笔记

  2019-3-27 

迄今为止在python数据分析相关库上遇到的坑，超长预警

  1. source .bashrc
  2. source activate base先激活base环境
    再jupyter notebook启动jupyter notebook！先前anaconda安装的包都是在base环境下的！
    在jupyter中sys.path就可以看出环境对没对！如果不是指定anaconda3中（我安装的）环境，那就没对！
    查看anconda3有哪些环境conda info --envs
  3. .ipynb文件转.py文件
    jupyter nbconvert --to script demo.ipynb
  4. for i in (a,b) for i in range(a,b) 别搞混了！
    且range左闭右开

  5. black10w.drop(black10w[black10w['Filename']==filename].index,axis=0,inplace=True)
    去掉dataframe中文件名为filename的那一行

  6. virtualenv --python=/usr/bin/python3.5 --no-site-packages envNAME
    用此命令建立新的python环境，并使用系统的python3.5
    http://www.cnblogs.com/freely/p/8022923.html

  7. +见20181123的周记

  8. drop函数是个返回值！ pandas里好多函数都是返回值形式！一定勿忘赋值回去！不然不会改变
    df = df.drop(list) drop掉list中索引的内容，默认drop行（axis=0）
    如df=df.drop([0])就是把第0行去掉
    如果设置axis=1就是去掉列 索引可以不一定是序号 列用str索引那么列表里的元素就是list即可！
    drop掉指定行之后，不会自己重新索引！ 要手动重新索引!
    df = df.reset_index(drop = True)
    也可以直接修改列索引
    df = pd.DataFrame(df,columns = ['One','Two','Three'])
    （如果不需要用索引刻意不重建）

  9. pandas中的append()函数也是个返回值！
    df=df.append(x)
    在append两个dataframe之后，索引可能就乱了！要在append里加参数ignore_index=True即可自动重建索引
    df=df.append(x,ignore_index=True)

    但是，非pandas库中的不一定是！比如对于list，不在pandas中，则必须直接list.append()

  10. iloc函数是按行数（编号）的！而不是index索引，即使drop后 index没有被重新排列，iloc也是从1开始数来定位

    drop函数是drop的对应index，而不是编号！
比如
      a b c
  0    1 6 4
  1    2 7 4
  2    3 8 5

drop掉1后就变成
      a b c
  0    1 6 4
  2    3 8 5
而这时候iloc[2]就out of bonud了，因为编号2已经不在了，在的是index2

    但是 loc是按索引取号！

    即使这行删了，他也不会out of bonud 因为想要的索引那行并没有被删！

    所以在循环删除满足条件的行的时候，要用loc来删除！因为删除行后每行的索引是不变的！但行号是会变的！iloc是按行号来算的，所以就会出错！

    drop(x) 这里x是索引而不是行号

  11. item = ‘t2_asd’
    item[0:3]
    输出：t2_
    截取和range一样，也是左闭右开

  12. feaMatrix[:,'a']等效于feaMatrix.a

  13. DataFrame.values

    values是DataFrame的一个特殊属性，得到一个array包含每一行的值(一个list)

columns和rows也是DF的特殊属性，分布得到Index类型的列索引和行索引

如果feaMatrix.columns.values则得到array类型的列索引列表和行索引列表


>>feaMatrix.columns.values
array(['a', 'b'], dtype=object)

  14. 切片和range都是左闭右开！！！！！

  15. 切片的时候 行用：而列不能用：

  16. 矩阵合并
    可以用merge和append，都属于pandas库

    pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
left_index=False, right_index=False, sort=True,
suffixes=('_x', '_y'), copy=True, indicator=False)

    left︰ 对象
    right︰ 另一个对象
    on︰ 要加入的列 （名称）。必须在左、 右综合对象中找到。如果不能通过 left_index 和 right_index 是假，将推断 DataFrames 中的列的交叉点为连接键
    left_on︰ 从左边的综合使用作为键列。可以是列名或数组的长度等于长度综合
    right_on︰ 从正确的综合，以用作键列。可以是列名或数组的长度等于长度综合
    left_index︰ 如果为 True，则使用索引 （行标签） 从左综合作为其联接键。在与多重 （层次） 的综合，级别数必须匹配联接键从右综合的数目
    right_index︰ 相同用法作为正确综合 left_index
    how︰ 之一 ‘左’，’右’，’外在’、 ‘内部’。默认为内部。每个方法的更详细说明请参阅︰
    sort︰ 综合通过联接键按字典顺序对结果进行排序。默认值为 True，设置为 False将提高性能极大地在许多情况下
    suffixes︰ 字符串后缀并不适用于重叠列的元组。默认值为 (‘_x’，’_y’)。
    copy︰ 即使重新索引是不必要总是从传递的综合对象，复制的数据 （默认值True）。在许多情况下不能避免，但可能会提高性能 / 内存使用情况。可以避免复制上述案件有些病理但尽管如此提供此选项。
    indicator︰ 将列添加到输出综合呼吁 _merge 与信息源的每一行。_merge 是绝对类型，并对观测其合并键只出现在 ‘左’ 的综合，观测其合并键只会出现在 ‘正确’ 的综合，和两个如果观察合并关键发现在两个 right_only left_only 的值。
    eg：result = pd.merge(left, right, how='outer', on=['key1', 'key2'])

    遇见大坑:
    合并中发生排列组合问题！
    当两个要合并的dataframe里合并关键字有重名项的时候，将会发生排列组合！

    a  b
1  0
1  2
    
a  c  d
1  1  5
1  2  6
    
按a合并，结果是
a	b	c	d
1	0	1	5
1	0	2	6
1	2	1	5
1	2	2	6

  17. 矩阵检索

    #对于两个矩阵，找同一项的另一项，直接找速度非常慢。可以采用矩阵合并之后，再搜索
df.loc[df.Filename==filename, 'label'] = 1
tencent[tencent.Filename == '5F94E5453CF23ACBF0256575D629A442']
#以上两种都可以找
  18. dataframe删除行或列
    用法：DataFrame.drop(labels=None,axis=0, index=None, columns=None, inplace=False)

在这里默认：axis=0，指删除index，因此删除columns时要指定axis=1；

inplace=False，默认该删除操作不改变原数据，而是返回一个执行删除操作后的新dataframe；

inplace=True，则会直接在原数据上进行删除操作，删除后就回不来了。

eg:
tencent = tencent.drop([tencent[tencent.Filename == '6A6709AA7F9DF362CF90D2DE063D1FFF'].index.values[0]],inplace=True)

#这里tencent[tencent.Filename == '6A6709AA7F9DF362CF90D2DE063D1FFF'] 找到了该行，.index.values[0]]取出了索引号，然后由drop函数去drop，inplace=True重建索引，然后赋值回给tencent

##################################

>>>df = pd.DataFrame(np.arange(12).reshape(3,4), columns=['A', 'B', 'C', 'D'])
>>>df

   A   B   C   D
0  0   1   2   3
1  4   5   6   7
2  8   9  10  11
#Drop columns,下面两种方法等价
>>>df = df.drop(['B', 'C'], axis=1)
   A   D
0  0   3
1  4   7
2  8  11
>>>df = df.drop(columns=['B', 'C'])
   A   D
0  0   3
1  4   7
2  8  11
#Drop rows by index
>>>df = df.drop([0, 1])
   A  B   C   D
2  8  9  10  11

  19. 对于index类型，可以用index.values转化为array类型

  20. .values是什么属性

  21. JSON和字典
    [JSON]和[字典]的标准格式是用{}包起来的内容！必须要有外面的{}
    dict = eval(str)可以将字符串转化为字典

  22. inplace

    inplace参数的理解：
修改一个对象时：
inplace=True：不创建新的对象，直接对原始对象进行修改；
inplace=False：对数据进行修改，创建并返回新的对象承载其修改结果。

  23. python中list转字符串
    命令：’’.join(list)
    其中，引号中是字符之间的分割符，如“,”，“;”，“\t”等等
    如：
    list = [1, 2, 3, 4, 5]
    ‘’.join(list) 结果即为：12345
    ‘,’.join(list) 结果即为：1,2,3,4,5

  24. json函数库

    import json
dict = json.loads(string)
#即可将string转换为json，其中里面的一切格式问题都不用管，json.loads全部解决
  25. python分割
    除了用split方法以外，还可以用正则表达式实现多规则分割
    import re
a = "Hello world!How are you?My friend.Tom"
re.split(" !|\?|\.", a)
['Hello', 'world', 'How', 'are', 'you', 'My', 'friend', 'Tom']
'''
但要注意，对? ( ) . 等字符分割的时候要转义，即要写 \. \( \) \?
'''

  26. append的时候勿忘ignore_index = True 否则索引就凉了！

  27. python广播
    numpy广播使得不同数组间可以进行运算
    如一个向量+一个常数的时候，常数会被自动扩展成一个向量
    见松鼠书P435

  28. numpy向量化计算
    尽量少使用显式循环
    用向量化（并行运算） 即将元素作为向量进行计算
    numpy.dot(x,y)
    numpy.exp(v)
    等等 numpy有很多向量化函数
    即为点乘
    平时计算的时候也可以直接用向量化计算，速度快很多

  29. numpy中常用reshape来确保数组的形式

  30. a.T转置

  31. numpy.random.randn(5)随机生成矩阵 15 注意生成的只有一个[]
    numpy.random.randn(1,5)随机生成矩阵 注意生成的是[[]] ==用这个
    （numpy array格式）
    *不要用上面那种写法，容易出错！不直观，它既不是行向量也不是列向量

  32. 不要吝惜使用reshape

  33. assert(表达式)语句用于检查表达式是否正确，如果不正确程序在这里引发错误
    方便检查

  34. list.append()
    不需要a = a.append()

  35. 改变DATAFRAME的顺序

    order = ['date', 'time', 'open', 'high', 'low', 'close', 'volumefrom', 'volumeto']
df = df[order]

  36. Dataframe遍历
    不能用for Line in DataFrame来遍历！
    要么用iloc index方法

    for i in range(0, len(df)):
    print df.iloc[i]['c1'], df.iloc[i]['c2']

    要么用iterrows（https://blog.csdn.net/ls13552912394/article/details/79349809）

  37. 排序不成功问题
    问题：遇到排序问题，使用下面的语句对pandas的某列进行排序时,发现根本没排序成功。
    bada_air.sort_value(by=’time’,ascending=False)
    解决方案：这里牵扯到很重要的参数inplace,默认的inplace设置是False,并没有对本体进行覆盖，所以解决方法有两个：
    1.设置本体覆盖，令inplace=True
    bada_air.sort_value(by=’time’,ascending=False,inplace=True)
    2.设置传值覆盖
    bada_air=bada_air.sort_value(by=’time’,ascending=False)

  38. pd.read_csv出现Unnamed:0这一列
    解决办法：pd.read_csv(path,index_col=0)

  39. 记清楚
    loc[行限制，列限制]
    比如行限制就可以A=A.loc[A.Filename = ‘aaa’,:]
    或者其他选法等等

  40. 合并 merge join 等的用法
    https://www.jianshu.com/p/5ecea164cec6

  41. 错点！ series别忘了转成list 再用in！ a in list O a in Series X

  42. df1=df2 传递的不是指针，而是内容复制了一份

  43. 关于drop

    • drop是drop的索引
    • 注意drop属于panda 要用df = df.drop(x)
    • inplace=True参数设置重建索引，df = df.drop(x,inplace=True)

  44. 重建索引
    df = df.reset_index(drop = True)

  45. 修改DF某元素（最终选择方法二）
    一。
    一个大坑
    在修改df元素的时候，iloc和loc有重大区别！
    loc和iloc都可以进行切片，但是用iloc不可以修改切片中的元素！
    loc可以修改切片中的元素！

    test =  pd.DataFrame({'a':[3,4,5,6],'b':[6,7,8,9]})
test['c']=0
test.iloc[2].c+=2  #用iloc
test

>>
	a	b	c
0	3	6	0
1	4	7	0
2	5	8	0
3	6	9	0

test =  pd.DataFrame({'a':[3,4,5,6],'b':[6,7,8,9]})
test['c']=0
test.loc[2].c+=2  #用loc
test

>>
	a	b	c
0	3	6	0
1	4	7	0
2	5	8	2
3	6	9	0

    二。但是！！ 在很多情况下 这样还是无法修改！！！！
    所以用这个方法！！
    不用loc iloc 先选列索引 再选行索引！
    test['c'][2]+=2 统一使用此方法！

    test =  pd.DataFrame({'a':[3,4,5,6],'b':[6,7,8,9]})
test['c']=0
test['c'][2]+=2  #看这里！！！！！！！！！！！！！！！！
test

>>
	a	b	c
0	3	6	0
1	4	7	0
2	5	8	2
3	6	9	0

  46. 在处理大批量数据时,如果需要先向df对象插入空列,在后期再填充空列中对应位置的元素,应优先考虑使用loc而不是iloc,因为前者的访问速度比后者快几十倍

  47. dict排序
    https://www.cnblogs.com/dylan-wu/p/6041465.html

    dict = sorted(dict.items(),key=lambda item:item[1],reverse=True)
# items()将dict转化为迭代器，lambda正咋表达式，item[1]即为迭代器的第二项

  48. 判断nan

    math.isnan(x) #x得是float类型

type(x) != float      #用类型判断，因为nan属于float类型

  49. python取数据！ python搜索数据 重要总结！
    https://www.jianshu.com/p/805f20ac6e06

  50. python搜索数据的时候 这种情况要用isin

    allDatasetApiCorpus[allDatasetApiCorpus['Filename'].isin(list)]
  51. Series可以直接与int比大小，等于对每一项比大小！
    eg:
lis = [1,2,3,-1,-2,-3]
lis = pd.Series(lis)
lis[lis>0]

>>
0    1
1    2
2    3
dtype: int64

lis>0
>>
0     True
1     True
2     True
3    False
4    False
5    False
dtype: bool
  52. 枚举 enumerate的用法
    lis = [1,2,3,-1,-2,-3]
for index, var in enumerate(lis):
    print(index,' ',var)

>>
0   1
1   2
2   3
3   -1
4   -2
5   -3
  53. 元组可以这样用
    s = (2,1)
s[0]

>>2

  54. 转置
    narray.T, dataframe.T

  55. 去重 drop_duplicates()
    drop_duplicates()是去除重复行，要想去除重复列要先转置

    DataFrame = DataFrame.drop_duplicates(subset=None, keep='first', inplace=False)

'''
subset : column label or sequence of labels, optional
用来指定特定的列，默认所有列（指的是以哪些列为参考删除行，删的还是行）
keep : {‘first’, ‘last’, False}, default ‘first’
删除重复项并保留第一次出现的项
inplace : boolean, default False
是直接在原来数据上修改还是保留一个副本
'''
  56. 初始化列表 list
    # 一维列表

# 初始化递增的list，与L = [i for i in range(10)] 效果相同
L = range(10)  
# print(L)
# [0,1,2,3,4,5,6,7,8,9]

#初始化每项为0的一维列表
L = [0] * 5
# print(L)
#[0,0,0,0,0]

# 二维列表

L = [[0] * 5 for i in range(5)]
#print(L)
#[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]

#这里需要注意，虽然L = [[0] * 5] * 5，也输出同样的效果，但是万万不能这样做！

#因为[0] * 5是一个一维列表的对象，再* 5的话只是把对象的引用复制了3次。什么意思呢，就是如果我们将L[0][0] = 1，#再输出L如下：
L = [[0] * 5] * 5
L[0][0] = 1
#print(L)
#[[1, 0, 0, 0, 0], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0]]

#我们只是想改变L[0][0]，结果L[[n][0]全部改变了！这回知道为啥不能这么做了吧！

#所以对于一位列表初始化，也建议大家用L = [[0] for i in range(5)]来代替L = [[0] * 5]
  57. Numpy扁平化函数 ravel和flatten
       from numpy import *

   a = arange(12).reshape(3,4)
   print(a)
   # [[ 0  1  2  3]
   #  [ 4  5  6  7]
   #  [ 8  9 10 11]]
   print(a.ravel())
   # [ 0  1  2  3  4  5  6  7  8  9 10 11]
   print(a.flatten())
   # [ 0  1  2  3  4  5  6  7  8  9 10 11]

可以看到这两个函数实现的功能一样,但我们在平时使用的时候flatten()更为合适.在使用过程中flatten()分配了新的内存,但ravel()返回的是一个数组的视图.视图是数组的引用(说引用不太恰当,因为原数组和ravel()返回后的数组的地址并不一样),在使用过程中应该注意避免在修改视图时影响原本的数组.
  1. [confusion_matrix - too many values to unpack]
    you can only assign multiple variables dynamically if the number of outputs is certain. If you 		assign the result of `confusion_matrix` to a single variable, you can then check its contents 		in a loop and assign the contents conditionally:
returned = confusion_matrix(y_true, y_predict).ravel()
   for var in returned:
   #... do stuff with each item in the returned collection
You could also just check its length and if it is 4, you can proceed as usual:
if len(returned) == 4:
       tn, fp, fn, tp = returned

  2. 遍历dataframe
    for col in df遍历的是列标签
    要遍历行有几种方案https://blog.csdn.net/ls13552912394/article/details/79349809
    遍历这种东西在df选取等操作中不是一个好的解决方案，可以通过df的搜索loc iloc等很多方式来实现，比遍历好得多方便的多

  3. python list去重
    运用set的特性
    opList = list(set(opList))

  4. 切片的时候若不存在
    msgTrojanDynamicDF.loc[:,[‘android.content.Intent_setAction’,’sss’] ]
    其中如果sss不存在，则sss列全为NaN
    但如果两列都不存在，就会报错

  5. Series.sum(axis-1)可以统计竖向的和

  6. 拼接dataframe

    df = pd.concat([A,B,C])
    numpy.transpose 用于翻转
    https://blog.csdn.net/u012762410/article/details/78912667

  7. torch.cat 拼接Tensor
    torch.cat((a,b),1)`

  8. 转置
    np.transpose()
    torch.transpose()

  9. 左闭右开
    注意python各个库的左闭右开原则 [:]切片的时候注意！ range,list,numpy,pandas,torch都这样

  10. 将数据结构转化为集合可以自动去重！（#去重）
    a = set(a)
    set(1,2,3) = set(1,1,1,1,1,1,2,3)

  11. tensor,numpy array的创建与扩展

    #创建
np.zeros([3,10]) #创建一个3x10的array
torch.zeros(3,10) #创建一个3x10的tensor
list([0])*10  #[10,10,10,10,10,10,10,10,10,10]
list([[0]*10]*3) #创建一个3x10的list

np.random.rand(3,10) #随机创建一个3x10的array
torch.rand(3,10) #随机创建一个3x10的tensor

 #合并/拓展
a.extend([4,5]) #[1,2,3,4,5]
#注意用法
extend后保存的值就为a，和append用法类似

removes = np.append(array1,array2,axis=0) #axis为合并的维度
tensor 使用torch.stack进行合并

  12. list 删除元素

    list.remove(x)
print(list)

    该方法没有返回值
    只会删掉匹配到的第一个
    还有2个方法懒得记了

    python remove里有个巨坑！
    如果用for循环来remove的话，for循环的时候，每删除一个元素，长度就会改变，索引就会变化！所以remove就会出问题！
    比如 要依次删除1，2位置的元素。
    第一次删除了1位置，那么列表索引就变了，2元素成为了1元素，3元素成为了2元素！2元素就这样被跳过了！
    解决办法见下

  13. for循环 动态修改列表的时候的注意事项
    如何解决：deepcopy一份，一个列表用于循环，一个列表用于移除值
    （from copy import deepcopy)

  14. 调换维度。
    使用numpyarrray.swapaxes(ax0,ax1)

  15. numpy.size()函数
    a = np.array(…)
    np.size(a) 计算数组和矩阵所有数据的个数
    np.size(a,1)计算该array第1维（第一个维度为0）的元素个数

  16. tensor/array值归一化
    tensor.div_()
    narray.div_()

  17. windows路径\\变成/即可

  18. 改变numpy array中的数据类型

    array = array.astype(obj_type)

    obj_type就可以为比如float

赏

且听风吟