python小知识

np.where()

带一个星号（*）参数的函数传人的参数存储为一个元组（tuple）；

而带两个星号（*）参数的函数传人的参数则存储为一个字典（dict）

np.where()[0] 表示行的索引，
np.where()[1] 则表示列的索引

shape函数是numpy.core.fromnumeric中的函数，它的功能是读取矩阵的长度，比如shape[0]就是读取矩阵第一维度的长度

python中的字符数字之间的转换函数

int(x [,base ])         将x转换为一个整数    
long(x [,base ])        将x转换为一个长整数    
float(x )               将x转换到一个浮点数

complex(real [,imag ]) 创建一个复数
str(x ) 将对象 x 转换为字符串
repr(x ) 将对象 x 转换为表达式字符串
eval(str ) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s ) 将序列 s 转换为一个元组
list(s ) 将序列 s 转换为一个列表
chr(x ) 将一个整数转换为一个字符
unichr(x ) 将一个整数转换为Unicode字符
ord(x ) 将一个字符转换为它的整数值
hex(x ) 将一个整数转换为一个十六进制字符串
oct(x ) 将一个整数转换为一个八进制字符串

chr(65)=’A’
ord(‘A’)=65

int(‘2’)=2;
str(2)=’2’

获取绝对路径，相对路径

　　>os.path.abspath(“文件名”)：

显示的是一个文件的绝对路径

os.path.dirname(“文件名”):

显示的是一个文件的相对路径
os.getcwd()——获得当前工作的目录
os模块常用命令

文件和目录访问

函数中×和××的区别

函数接收参数为元组

例如

def myfun(*args): #相当于 def myfun(1,2,3) ==> args 就相当于（1,2,3）

　　for a in args:

　　　　print(a)

** 表示函数接收参数为一个字典

def myfun(**args) :#相当于 def myfun({a:1,b:2,c:3}) ==>args 就相当于{a:1,b:2,c:3}

　　for k,v in args:

　　　　print(k,”:”,v)

查看帮助

python中每个modul，每个class，每个def都是留有写doc的地方的，写没写是另一回事，可以用“对象名称.doc”查看。这是一个字符串，所以内容只能是字符串允许的内容。如果字符不足以满足说明需求，可能会加上web链接，或者专门的说明函数。

你要查看的应该是
import scipy
print scipy.quiver.doc

或者
import scipy
print help(scipy.quiver)

zip

import numpy as np
a=[1,2,3]
b=[4,5,6,7]
c=[8,9,10,11,12]
zz=zip(a,b,c)
print(zz)

x,y,z=zip(*zz)
print(x)
print(y)
print(z)

输出：
[(1, 4, 8), (2, 5, 9), (3, 6, 10)]
(1, 2, 3)
(4, 5, 6)
(8, 9, 10)

unzip后的列表b和c的值都少了。
https://blog.csdn.net/csdn15698845876/article/details/73411541

pd.cut

https://blog.csdn.net/cbbing/article/details/50721468

Python3pandas库transform

import pandas as pd
import numpy as np
A=np.array([[1,2,3,4,5],[2,1,1,2,2],[1,2,3,4,5],[2,1,1,2,2],[1,2,3,4,5]])
data=pd.DataFrame(A,index=[‘li’,’chen’,’wang’,’zhao’,’qian’],columns=[‘a’,’b’,’c’,’d’,’e’])
print(data)

a  b  c  d  e

li 1 2 3 4 5
chen 2 1 1 2 2
wang 1 2 3 4 5
zhao 2 1 1 2 2
qian 1 2 3 4 5

key=[‘ss’,’kk’,’kk’,’ss’,’ss’] #给定index分组标记
print(data.groupby(key).mean()) #mean是按key做分组的列均值

a         b         c         d    e

kk 1.500000 1.500000 2.000000 3.000000 3.5
ss 1.333333 1.666667 2.333333 3.333333 4.0

data里每个元素位置的取值由transform函数的参数函数计算

print(data.groupby(key).transform(np.mean))

#data里每个位置元素取对应分组列的均值

a         b         c         d    e

li 1.333333 1.666667 2.333333 3.333333 4.0
chen 1.500000 1.500000 2.000000 3.000000 3.5
wang 1.500000 1.500000 2.000000 3.000000 3.5
zhao 1.333333 1.666667 2.333333 3.333333 4.0
qian 1.333333 1.666667 2.333333 3.333333 4.0

生成的tsf里，每个位置元素取值是data里“对应位置元素”按transform的“函数参数”运算（这里是’对应元素’减去’对应分组列的均值’）；x取值是data的每个位置元素，只不过x.mean中的mean方法作用范围由key决定

my_transform = lambda x : x-x.mean()
tsf=data.groupby(key).transform(my_transform)
print(tsf)

a         b         c         d    e

li -0.333333 0.333333 0.666667 0.666667 1.0
chen 0.500000 -0.500000 -1.000000 -1.000000 -1.5
wang -0.500000 0.500000 1.000000 1.000000 1.5
zhao 0.666667 -0.666667 -1.333333 -1.333333 -2.0
qian -0.333333 0.333333 0.666667 0.666667 1.0
https://blog.csdn.net/cymy001/article/details/78300775

groupby+agg

从0.20.1开始，pandas引入了agg函数，它提供基于列的聚合操作。而groupby可以看做是基于行，或者说index的聚合操作。

从实现上看，groupby返回的是一个DataFrameGroupBy结构，这个结构必须调用聚合函数（如sum）之后，才会得到结构为Series的数据结果。
而agg是DataFrame的直接方法，返回的也是一个DataFrame。当然，很多功能用sum、mean等等也可以实现。但是agg更加简洁, 而且传给它的函数可以是字符串，也可以自定义，参数是column对应的子DataFrame
https://segmentfault.com/a/1190000012394176

特征选择 (feature_selection)

特征是否发散：如果一个特征不发散，例如方差接近于0，也就是说样本在这个特征上基本上没有差异，这个特征对于样本的区分并没有什么用。
特征与目标的相关性：这点比较显见，与目标相关性高的特征，应当优选选择。除移除低方差法外，本文介绍的其他方法均从相关性考虑。

https://www.cnblogs.com/stevenlk/p/6543628.html

Bagging（Bootstrap aggregating）、随机森林（random forests）、AdaBoost

https://blog.csdn.net/xlinsist/article/details/51475345

列 ——> 索引

df.set_index(‘date’)
df.set_index(‘date’, inplace=True) # column 改为 index

索引 ——> 列

df[‘index’] = df.index
df.reset_index(level=0, inplace=True)
df.reset_index(level=[‘tick’, ‘obs’])

loc——通过行标签索引行数据

loc扩展——索引某列

print df.loc[:,[‘c’]]

iloc——通过行号获取行数据

df[]直接索引

直接索引索引的是列，方口号里面的内容一般是列索引名。也可以接受一个列名组成的list来接受多个列名
索引slice对象，索引的是行，df[0:1]

http://www.cnblogs.com/daozhongshu/archive/2018/04/30/8973439.html

函数注解

当使用Python编写复杂的函数时，我们常常为没有合适的提示而苦恼。函数注解可以帮助我们解决这个问题。

def add(a: int, b: int) -> int:
return a + b

jieba 分词及词性表

jieba.load_userdict(file_name) # file_name为自定义词典的路径（https://blog.csdn.net/li_31415/article/details/48660073）

词性表：https://blog.csdn.net/huludan/article/details/52727298

类型和运算

解码：b’\xe4\xbd\xa0\xe5\xa5\xbd’.decode()
b’\xc4\xe3\xba\xc3’.decode(‘gb2312’)
b’\xff\xfe`O}Y’.decode(‘utf16’)
b’\x60\x4f\x7d\x59’.decode(‘utf16’)

链接：https://www.jianshu.com/p/f6d90d53027a

python里的那些坑

嵌套列表的创建

li = [[] for _ in range(3)]

这样我们就创建了三个不同的list对象

print([id(inner_list) for inner_list in li])

列表元素的引用

不要使用索引方法遍历list，例如：

        for i in range(len(tab)):
            print(tab[i])
比较好的方法是：

for elem in tab:
print(elem)

for语句会自动生成一个迭代器。如果你需要索引位置和元素，使用enumerate函数：

        for i, elem in enumerate(tab):
            print((i, elem))
[python 里的那些坑](https://segmentfault.com/a/1190000010784254)
## 解析ＸＭＬ
查文档比较靠谱，[DOM](https://docs.python.org/3/library/xml.dom.html)
,这样调用哪些函数比较清楚
### 类型判断

if ele.nodeType == xml.dom.minidom.Node.ELEMENT_NODE

1
2
3

### 获得标签属性
#coding: utf-8

import xml.dom.minidom
dom = xml.dom.minidom.parse(“del.xml”) #打开xml文档

root = dom.documentElement #得到xml文档对象
print “nodeName:”, root.nodeName #每一个结点都有它的nodeName，nodeValue，nodeType属性
print “nodeValue:”, root.nodeValue #nodeValue是结点的值，只对文本结点有效
print “nodeType:”, root.nodeType
print “ELEMENT_NODE:”, root.ELEMENT_NODE

1 2	### 获得标签对之间的数据

import xml.dom.minidom
dom = xml.dom.minidom.parse(“del.xml”)

root = dom.documentElement
itemlist = root.getElementsByTagName(‘caption’)

item = itemlist[0]
print item.firstChild.data

item2 = itemlist[1]
print item2.firstChild.data

1
2


### 总结

minidom.parse(filename)
加载读取XML文件

doc.documentElement
获取XML文档对象

node.getAttribute(AttributeName)
获取XML节点属性值

node.getElementsByTagName(TagName)
获取XML节点对象集合

node.childNodes #返回子节点列表。

node.childNodes[index].nodeValue
获取XML节点值

node.firstChild

#访问第一个节点。等价于pagexml.childNodes[0]

doc = minidom.parse(filename)
doc.toxml(‘UTF-8’)
返回Node节点的xml表示的文本

Node.attributes[“id”]
a.name #就是上面的 “id”
a.value #属性的值
访问元素属性


参考网址：http://www.cnblogs.com/kaituorensheng/p/4493306.html
https://blog.csdn.net/oopsangle/article/details/24589135（判断类型）
## log 日志
[官方网址](https://docs.python.org/3/library/logging.html#logging.Logger.getEffectiveLevel)
## Python 包内的导入问题（绝对导入和相对导入）
python中，每个py文件都称为模块，每个具有_int_.py文件的目录被称为包，如numpy、matplotlib等包
对于 Python 的包内导入，即包内模块导入包内模块，存在绝对导入和相对导入问题。
python模块导入时需要经过搜索路径的过程python搜索模块的路径为：1）、程序的主目录（当前目录）2）、pythonpath目录（后面会介绍添加该路径方法）3）、标准链接库目录（在python安装目录中的lib/site-package中）4）、任何的.pth文件的内容（如果存在的话）.新功能，允许用户把有效果的目录添加到模块搜索路径中去
import sys
sys.path.append(r'自己包的路径')
存在编码问题时：
path = 'c:\\xxx\\中文文件夹'
upath = unicode(path,'utf-8')
sklearn是package，一般导入是采用‘from sklearn import xxx'，module是采用import module，这是因为package是单个或多个module组合而成，所以如果直接采用import package，终端会混乱导致error
包内的文件相互导入分两种，用绝对路径和相对路径，用.或者..都是第二种，相对路径。
重点是，相对导入的路径依赖于当前模块的_name_，是根据它的值去找平级或者上级文件。
或者from . import XXXX
在模块A.B.C中的代码
from . import D     # 导入A.B.D
from .. import E    # 导入A.E
from ..F import G    # 导入A.F.G，.. 和 F是连着的，中间没有空格
.代表当前目录，..代表上一层目录，...代表上上层目录。
相对路径是指相对执行脚本的目录
## 调试
设置断点
F7 进入
F8 跳过
## 自动生成函数注释，包括参数和返回值。
使用方法，函数定义时，直接输入三个双引号后回车
1. 文件注释
pycharm提供了一个在新建文件自动生成文件头注释的功能，可以实现自动生成运行环境，作者、日期等必要信息，使用比较方便，配置十分简单
在seting--edit---file and code tempalate --python script
添加：

#-- encoding: utf-8 --
‘’’
@File : ${NAME}.py

@Contact :

@Modify Time @Author @Version @Desciption

${DATE} ${TIME} wxy 1.0 None

‘’’
```
其他函数注解，参考https://blog.csdn.net/littlehuang950620/article/details/82181234

str转字典

eval(dict)