Python的函数大全
Python的函数
eye()
numpy.eye(N, M=None, k=0, dtype=
, order=‘C’)
取回一个单位矩阵
参数：
N int 返回数组行数
可选参数：
M：列数，无则默认为N
k：对角线的索引
dtype：返回数组的数值类型
order可选参数{‘C’,‘F’}：是否在内存中以C或fortran(行或列)顺序存储多维数据
import numpy as np
A=np.eye(3,6,dtype=int,k=1)
print(A)
输出：
array([[0, 1, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0],
[0, 0, 0, 1, 0, 0]])
read_cav()
panda.read_cav(path,sep/demlimiter,header,names,index_col,usecols,encoding)
读取csv,txt文档生成 DataFrame
参数：
path：路径
header：将指定行的数据作为读取数据各列的列名，默认参数为0
names：对列名进行命名
可选参数：
sep/demlimiter：分隔符/定界符
k：对角线的索引
index_col：利用读取数据中的内容建立行的索引
usecols：选定我们需要的对应列的数据
import pandas as pd
path = 'D:\Desktop\py_test\ex1data1.txt'
data = pd.read_csv(path,header=None,names=['Population','Profit'])
head()
DataFrame.head(n)
返回数据前n行
参数：
N int 默认为5
import pandas as pd
path = '/home/mw/ex1data1.txt'
data = pd.read_csv(path,header=None,names=['Population','Profit'])
print(data.head(3))
输出：
Population Profit
0 6.1101 17.5920
1 5.5277 9.1302
2 8.5186 13.6620
plot()
matplotlib.pyplot.plot(x,y,kind,label,figsize(x,y))
画二维平面图，结合matplotlib.pyplot.show()使用
需要matplotlib的子库pyplot库
参数：
x=‘x轴名称’
y=‘y轴名称’
可选参数：
kind：‘line’, ‘bar’, ‘barh’, 密度图’kde’, 散布图’scatter’
label：标记图内容的标签文本
figsize(x,y)：指定width和height的inch
ls：折线图的线条风格 ls=“-”
lw：折线图的线条宽度 lw=2
color：线条颜色
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
path = 'D:\Desktop\py_test\ex1data1.txt'
data = pd.read_csv(path,header=None,names=['Population','Profit'])
data.plot(kind='scatter', x='Population', y='Profit', figsize=(10,6), label='data')
plt.show()
输出：
power()
numpy.power(x,y,z)
求幂
参数：
x,y：数字，列表
import numpy as np
# 2的3次方
print(np.power(2, 3))
# [ 8 27 64]，分别求 2， 3， 4 的 3 次方
print(np.power([2,3,4], 3))
# [ 4 8 16]，分别求 2的 2， 3， 4 次方
print(np.power(2, [2,3,4]))
# [ 8 81]，分别求 2 的 3 次方和 3 的 4 次方
print(np.power([2,3], [3,4]))
insert()
list.insert(index,object)
DataFrame.insert(index,‘str’,value)
insert(arr, obj, values, axis=None)
在列表指定位置插入指定对象
参数：
index：插入的索引位置
object：要插入的列表对象
arr：需要插入的数组
obj：向数组中插入值的位置
values：往数组中插入的值
axis：可选，默认为None按行插入，axis=1时按列插入
原文链接：https://blog.csdn.net/qq_44444503/article/details/124181479
aList = [123, 'xyz', 'zara', 'abc']
# 索引从0开始
aList.insert( 3, 2009)
# 插入DataFrame，则插入一列名为str的value值
data.insert(0, 'Ones', 1)
print(data.head())
输出：
Ones Population Profit
0 1 6.1101 17.5920
1 1 5.5277 9.1302
2 1 8.5186 13.6620
3 1 7.0032 11.8540
4 1 5.8598 6.8233
shape()
DataFrame.shape(n或array)
输出 行 / 列数
参数：
n：0输出行数，1输出列数
array：输出矩阵的行、列数
import numpy as np
x = np.array([[1,2,5],[2,3,5],[3,4,5],[2,3,6]])
# 输出(4,3)
print(x.shape)
# 输出4
print(x.shape[0])
# 输出3
print(x.shape[1])
iloc()
pandas.DataFrame.iloc[row selection, column selection]
pandas.DataFrame.iloc[a:b, c:d]
列表切片
参数：
row：前行后列
import numpy as np
import pandas as pd
path = 'D:\Desktop\py_test\ex1data1.txt'
data = pd.read_csv(path,header=None,names=['Population','Profit'])
# 选择第2列
y = data.iloc[:,1]
# 选择第2列
y = data.iloc[:,1:2]
# 选择第2列
y = data.iloc[:,1]
# 选择从开头到第2行
y = data.iloc[:2,]
# 选择从开头到第2行，第2列到最后
y = data.iloc[:2,1:]
# 选择从第1行到第3行、第3列到第4列的数据
y = data.iloc[0:3,2:4]
# 选择从第1行到第4行、第3列到第5列的数据
y = data.iloc[[0:3],[2:4]]
matrix()
numpy.matrix(array_like_value)
创建二维矩阵
matrix是array的分支，array的优势就是不仅仅表示二维，还能表示3、4、5…维
matrix的优势就是相对简单的运算符号，如矩阵相乘用符号*，但是array相乘得用方法.dot()
返回值：
一个矩阵
参数：
N int 返回数组行数
-
class numpy.matrix(data,dtype,copy):返回一个矩阵，其中data为ndarray对象或者字符形式；dtype:为data的type；copy:为bool类型。
-
矩阵的换行必须是用分号(;)隔开，内部数据必须为字符串形式(‘ ’)，矩阵的元素之间必须以空格隔开。
-
矩阵中的data可以为数组对象。
原文链接：https://blog.csdn.net/pipisorry/article/details/48791403
import numpy as np
# 创建二阶矩阵
a = np.matrix('1 2; 3 4')
# 根据DataFrame数据创建矩阵
X = data.iloc[:,:-1]
X = np.matrix(X.values)
sum()
numpy.sum(array)
numpy.sum(array,array_axis)
矩阵内数据求和，或是矩阵内某一轴的数据求和
参数：
-
array：使用array/matrix生成矩阵作为参数代入
-
(array,array_axis)：当多维矩阵时，可用于矩阵降维(合并高维)。
3维：2轴列，1轴行，0轴页
可合并列，保留其他两轴
原文链接：https://blog.csdn.net/qq_46212154/article/details/120707761
import numpy as np
a = np.array([[[1,2,3,4,5],[5,4,3,2,1],[1,1,1,1,1]],[[5,4,3,2,1],[1,2,3,4,5],[1,1,1,1,1]]])
# 三维矩阵输出格式为(2,3,5)
print(a.shape)
# 输出每个数之和：70
print(np.sum(a))
# 输出三维矩阵合并列之后的二维矩阵
print(np.sum(a,axis = 2))
输出：
[[15 15 5]
[15 15 5]]
len()
len(list / dict / touple / str / matrix)
python中求长度的库函数
参数：
参数为矩阵matrix时，返回行数
类似于data.shape[0] ?
原文链接：https://blog.csdn.net/zfhsfdhdfajhsr/article/details/109815525
import numpy as np
X = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[9, 10, 11, 12],
[9, 10, 11, 12]])
length = len(X) # 返回对象的长度 不是元素的个数
print("length of X:", length)
输出：
length of X: 5
zeros()
numpy.zeros(n, dtype=float, order=‘C’)
numpy.zeros((a,b), dtype=[(‘x’, ‘int’), (‘y’, ‘float’)])
创建指定长度/形状、类型的全零矩阵
参数：
-
n：创建全0的一维数组
-
(a,b)：指定矩阵的shape
-
dtype:可选参数,返回的数组内数据的数据类型,默认是float
-
order:可选参数,与C语言类似,C代表行优先,F代表列优先
原文链接：https://blog.csdn.net/weixin_44884379/article/details/112170531
import numpy as np
np.zeros(3)
# array([0., 0., 0.])
# 注意zeros(n)生成数组时，输出的array.shape为(n,)，表示n列的行矩阵
np.zeros((3,3))
# array([[0., 0., 0.],
# [0., 0., 0.],
# [0., 0., 0.]])
np.zeros((3,1))
# array([[0.],
# [0.],
# [0.]])
np.zeros((3,1),dtype=[('x', 'int'), ('y', 'float')])
#可分别指定x和y的数据类型,结果返回的数据类型为numpy的数据类型
# array([[(0, 0.)],
# [(0, 0.)],
# [(0, 0.)]], dtype=[('x', '
range()
range(n)
range(start, stop[, step])
创建指定长度/形状、类型的全零矩阵
返回值：
Python3 range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表
参数：
-
n：从0开始的类似列表
-
start：计数从 start 开始。默认是从 0 开始。
-
stop：计数到 stop 结束，但不包括 stop
-
step：步长，默认为1
原文链接：https://www.runoob.com/python3/python3-func-range.html
print(list(range(10)))
r = 'rbasjfdiafdfiasjd'
for i in range(len(r)):
print(r[i])
linspace()
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
生成均匀分布的数值序列
参数：
- start：开始数值
- stop：结束数值
- num：默认是50个样本点（数据），为正整数
- endpoint：默认为True，如果改为Fasle取不到右端点
- restep：步长，如第一个数据和第第二个数据之间的距离
- dtype：可以设置数值类型
原文链接：https://blog.csdn.net/qq_39432161/article/details/84673127
import numpy as geek
x = np.linspace(1,20,20)
print(x)
# 输出[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20.]
min / max()
DataFrame.min()
返回所求axis的最小值
原文链接：https://blog.csdn.net/qq_39432161/article/details/84673127
import pandas as pd
path = 'D:\Desktop\py_test\ex1data1.txt'
data = pd.read_csv(path,header=None,names=['Population','Profit'])
print(data.Population.min())
# 输出Population的最小值
subplots()
matplotlib.pyplot.subplots(nrows ncols)
既创建了一个包含子图区域的画布，又创建了一个 figure 图形对象
返回值：
fig , ax
fig： 图形对象
ax：返回axes.Axes对象或Axes对象数组，包含等于nrows * ncols的轴对象的元组，每个轴对象都可通过索引访问
参数：
nrows, ncols：这些参数是子图网格的行数/列数
sharex, sharey：控制x(共享x)或y(共享)轴之间的属性共享，默认为False，用来指定各子图之间是否共用xy轴属性
原文链接1：https://blog.csdn.net/ccc369639963/article/details/123003382
原文链接2：https://vimsky.com/examples/usage/matplotlib-pyplot-subplots-in-python.html
x = np.linspace(data.Population.min(), data.Population.max(), 100)
f = g[0, 0] + (g[0, 1] * x)
fig, ax = plt.subplots(figsize=(12,8))
ax.plot(x, f, 'r', label='Prediction')
ax.scatter(data.Population, data.Profit, label='Traning Data')
ax.legend(loc=2)
ax.set_xlabel('Population')
ax.set_ylabel('Profit')
ax.set_title('Predicted Profit vs. Population Size')
plt.show()
legend()
matplotlib.pyplot.ax.legend(loc=1/2/3/4)
图上标明图例，文字显示意义
参数：
loc：如legend(loc=2)，说明在第二象限
原文链接：https://wenku.baidu.com/view/6c1bfe84b3717fd5360cba1aa8114431b80d8e5a.html
mean()
DataFrame.mean()
mean()
求行/列平均值
参数：
DataFrame.mean()：
无参数/DataFrame.mean(0)：根据每列输出平均值
DataFrame.mean(1)：根据每列输出平均值
mean(matrix,axis=0) 其中 matrix为⼀个矩阵，axis为参数：
不设置axis：对矩阵每个数求均值，返回一个实数
axis=0：对每一列求均值，返回一个行矩阵
axis=1：对每一行求均值，返回一个列矩阵
原文链接1：https://blog.csdn.net/Ricardo_ChenM/article/details/110927533
原文链接2：https://wenku.baidu.com/view/8ddd8082f624ccbff121dd36a32d7375a417c6bb.html
import pandas as pd
path = 'D:\Desktop\py_test\ex1data1.txt'
data = pd.read_csv(path,header=None,names=['Size', 'Bedrooms', 'Price'])
# 按列输出平均值
print(data.mean(0))
# 按行输出平均值
print(data.mean(1))
std()
**DataFrame.std(axis=None, skipna=None, level=None, ddof=1, numeric_only=None, kwargs)
返回请求轴上的样品标准偏差
返回值：
Series或DataFrame
原文链接：https://vimsky.com/examples/usage/python-pandas-dataframe-std.html
inv() / pinv()
numpy.linalg.inv(Matrix)
numpy.linalg.pinv(Matrix)
求矩阵的 逆 / 伪逆
返回值：
对应的逆矩阵的数组
参数：
Matrix：要计算逆的矩阵数组
原文链接1：https://blog.csdn.net/weixin_43977640/article/details/109908976
原文链接2：https://blog.csdn.net/caomin1hao/article/details/81131382
原文链接3：https://iowiki.com/numpy/numpy_inv.html
import numpy as np
x = np.array([[1,2],[3,4]])
y = np.linalg.inv(x)
print np.dot(x,y)
dot()
numpy.dot(value / array / list / matrix)
求数组 / 矩阵的乘积
参数：
value标量：返回乘法结果
array一维数组 / 列表：返回内积
matrix二维数组 / 矩阵：返回矩阵乘法的结果矩阵
原文链接1：https://blog.csdn.net/qq_42842335/article/details/83781528
原文链接2：https://wenku.baidu.com/view/9174a938c6da50e2524de518964bcf84b9d52d18.html
import numpy as np
a.dot(b)
# 等于 np.dot(a,b)
A@X
# A 和 B 都是二维 array，那么 dot 就是它们的矩阵乘积
isin()
pandas.DataFrame.isin(self, values)
返回具有指定条件的DataFrame
参数：
values：iterable, Series, DataFrame或dict
values是Series，那就是索引
values是一个dict，则键必须是必须匹配的列名
values是DataFrame，则索引标签和列标签都必须匹配
原文链接1：https://blog.csdn.net/weixin_39626690/article/details/110758929
原文链接2：https://blog.csdn.net/W_weiying/article/details/84618685
import pandas as pd
# IN [1]: data
# Out[1]:
A B C D
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
target_data1 = data[data['A'].isin([4,8])]
# 返回值满足，{A列含有数值[4,8]}
# Out[2]:
A B C D
1 4 5 6 7
2 8 9 10 11
target_data2 = data[~data['A'].isin([4,8])]
# #逆函数 剔除{A列含有数值[4,8]}的dataframe
# Out[3]:
A B C D
0 0 1 2 3
scatter()
matplotlib.pyplot.scatter(x, y, s, c, marker, …, label)
画散点图
参数：
x,y：输入数据
s：点的大小
c：颜色
marker：点的样式
label：标签
原文链接1：https://www.jb51.net/article/127806.htm
import matplotlib.pyplot as plt
positive = data[data['Admitted'].isin([1])]
negative = data[data['Admitted'].isin([0])]
fig, ax = plt.subplots(figsize=(12,8))
ax.scatter(positive['Exam1'], positive['Exam2'], s=50, c='b', marker='o', label='Admitted')
ax.scatter(negative['Exam1'], negative['Exam2'], s=50, c='r', marker='x', label='Not Admitted')
log()
numpy.log(类似array)
计算对数 / 自然对数ln()
原文链接1：https://wenku.baidu.com/view/252dc19266ce0508763231126edb6f1aff00712b.html
原文链接2：https://blog.csdn.net/u011699626/article/details/118885071
exp()
numpy.exp(x / matrix)
返回输入数组中所有自然底数 e 的幂
参数：
x：返回标量
matrix：返回一个同型矩阵，其中每个数都取对应的自然底数的幂
原文链接：https://vimsky.com/examples/usage/numpy-exp-python.html
import numpy as np
in_array = [1, 3, 5]
out_array = np.exp(in_array)
print ("Output array : ", out_array)
# 输出
Output array : [ 2.71828183 20.08553692 148.4131591 ]
fminunc()
fminunc()
工程最优化，求最值
参数：
- fminunc(‘程序名’, x0)：需要预先把函数存入一个程序中，x0=n个变量
- fminunc(‘程序名’, x1, xn)：求函数在区间[x1,xn]的最小值
- fminunc(‘程序名’, x0, A, b)：有约束条件的最优化问题
A为系数矩阵
b为常数项列向量
x0为初试向量
fmin_tnc()
scipy.optimize.fminunc(func, x0, fprime=None, args=())
python中对fminunc函数的替代，工程最优化，求最值
参数：
- func：优化的目标函数
- x0：初值
- fprime：提供优化函数func的梯度函数
- args：元组，是传递给优化函数的参数
返回值：
返回：(array([-5.48743618, 6.23719559, 5.56645627]), 71, 4)
x ：数组，返回的优化问题目标值
nfeval ：整数，function evaluations的数目
在进行优化的时候，每当目标优化函数被调用一次，就算一个function evaluation。在一次迭代过程中会有多次function evaluation。这个参数不等同于迭代次数，而往往大于迭代次数。
原文链接1：https://blog.csdn.net/weixin_39861920/article/details/110542452
原文链接2：https://www.cnblogs.com/tongtong123/p/10634716.html
map()
map(function, iterable)
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表迭代器。
参数：
- function：函数
- iterable：一个或多个序列
返回值：
Python 2.x 返回列表。
Python 3.x 返回迭代器。
原文链接：https://www.runoob.com/python/python-func-map.html
def square(x) : # 计算平方数
return x ** 2
print(map(square, [1,2,3,4,5])) # 计算列表各个元素的平方
# 输出
print(list(map(square, [1,2,3,4,5]))) # 使用 list() 转换为列表
# 输出[1, 4, 9, 16, 25]
print(list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))) # 使用 lambda 匿名函数
# 输出[1, 4, 9, 16, 25]
drop()
pandas.DataFrame.drop(labels=None, axis=0, index=None, columns=None,inplace=False)
删除表中指定行 / 列
参数：
- labels：要删除的标签名，可直接写：‘target_label’
- axis：axis=0表示行，axis=1表示列
- columns：列名，效果类似于labels
- index：表示dataframe的index, 如index=1, index=a
- inplace：True表示删除某行后原dataframe变化，False不改变原始dataframe
原文链接：https://blog.csdn.net/W_weiying/article/details/84626260
import pandas as pd
path = 'D:\Desktop\py_test\ex2data2.txt'
data = pd.read_csv(path,header=None,names=['Test 1', 'Test 2', 'Accepted'])
data.drop('Test 1', axis=1, inplace=True)
zip()
zip(iterable, …)
python 2.x版本的zip()函数会直接返回列表，python3.x版本会返回zip对象，但是不论哪个版本所包含的元素是一样的都是元组类型
参数：
- iterable,… 表示多个列表、元组、字典、集合、字符串
- zip(*iterable, …)：反过来将zip解压为元组
原文链接1：https://blog.csdn.net/weixin_47906106/article/details/121702241
原文链接2：https://www.jb51.net/article/234749.htm
x = [1,2,3]
y = [4,5,6]
for i in zip(x,y):
print(i)
# 输出(1, 4) (2, 5) (3, 6)
x_cord, y_cord = zip(*(x,y))
print(x_cord, y_cord)
# 输出(1, 2, 3) (4, 5, 6)
loadmat()
scipy.io.loadmat(path / file_name)
加载 MATLAB 文件
参数：
- path：相对地址 / 绝对地址
- file_name：mat 文件的名称
返回值：
以变量名作为键的字典
原文链接1：https://vimsky.com/examples/usage/python-scipy.io.loadmat.html
原文链接2：https://blog.csdn.net/qq_43524683/article/details/105674621
from scipy.io import loadmat
data = loadmat('D:\Desktop\py_test\ex3data1.mat')
# 输出：
{'__header__': b'MATLAB 5.0 MAT-file, Platform: GLNXA64, Created on: Sun Oct 16 13:09:09 2011', '__version__': '1.0', '__globals__': [],
'X': array([[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., 0., 0., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 0., 0.]]),
'y': array([[10],
[10],
[10],
...,
[ 9],
[ 9],
[ 9]], dtype=uint8)}
arange()
numpy.arange(begin, end, step)
生成带起点和终点的特定步长的排列
参数：
- 只有一个参数，则这个参数为终点。起点默认为0,步长默认为1
- 有两个参数，第一个参数为起点，第二个参数为终点，步长默认为1。默认取值左闭右开
- 有三个参数，第一个参数为起点，第二个参数为终点，第三个参数为步长。步长支持小数。
返回值：
原文链接：https://blog.csdn.net/qq_39072607/article/details/89320992
import numpy as np
# 输出[0 1 2 3 4]
print(np.arange(5))
# 输出[2 3 4]
print(np.arange(2,5))
choice()
numpy.random.choice(a, size=None, replace=True, p=None)
从给定的1维数组中生成随机样本
参数：
- a：一维数组或int整数，采样的样本
- size：int（例如1,2,3）或int型的元组（例如：(1,2,3) ），采样的大小，如果不填默认返回一个随机样本
- replace：采样是否有放回，即是否有重复样本
- p：采样概率，None表示均匀采样
返回值：
原文链接1：https://blog.csdn.net/weixin_41377182/article/details/124851878
原文链接2：https://blog.csdn.net/Ahead_J/article/details/85302137
import numpy as np
a = [1, 1, 2, 3, 4, 5]
data = np.random.choice(a, 3, replace=False)
print(data)
# 输出：
# [5 4 3]
# [1 2 4]
matshow()
**matplotlib.pyplot.matshow(A, fignum=None, kwargs)
用于在新图形窗口中将数组表示为矩阵
参数：
- A：这是一个类似于对象的数组，代表矩阵。它是必需的参数
- fignum：它接受三个值，即“ None”，“ False”或整数值。如果将该值设置为“无”，则将使用自动编号创建图形的新窗口。如果该值是非零整数，则将其绘制到与给定数字对应的图形中，或者如果不存在则创建它。如果将“ 0”设置为该参数的值，则它将使用当前轴，或者如果不存在则创建一个轴。
- cmap：代表一种颜色映射方式
返回值：
返回一个Axesimage类的图像
原文链接1：http://www.manongjc.com/detail/30-dstbzbvmghemarp.html
原文链接2：https://blog.csdn.net/weixin_42474537/article/details/114410309
原文链接3：http://www.wjhsh.net/shanger-p-13021491.html
import matplotlib.pyplot as plot
import numpy as np
reshape()
array.reshape(value1,value2)
是数组对象中的方法，用于改变数组的形状
返回值：
原文链接1：https://www.py.cn/jishu/jichu/22193.html
原文链接2：https://blog.csdn.net/sweat_mango/article/details/88664365
import numpy as np
# 或reshape((2,8))
arr = np.arange(16).reshape(2,8)
print(arr)
# 输出 value1 × value2 的数组
[[ 0 1 2 3 4 5 6 7]
[ 8 9 10 11 12 13 14 15]]
yticks()
**matplotlib.pyplot.yticks(ticks=None, labels=None, kwargs)
xticks()类似
获取或设置当前x轴刻度位置和标签。
参数：
- ticks：可选参数，数组，x轴刻度位置的列表。传入空列表移除所有x轴刻度
- labels：可选参数，数组，放在指定刻度位置的标签文本。只有当ticks参数有输入值，该参数才能传入参数
- **kwargs：其他关键字参数：文本属性用来控制标签文本的展示：例如字体大小、字体样式等
原文链接：https://blog.csdn.net/chongbaikaishi/article/details/109105934
multiply()
numpy.multiply(arr1, arr2)
两个数组的乘法 / 让两个矩阵同样位置的元素相乘
参数：
- arr1：数组或标量
返回值：
arr1和arr2的乘积
原文链接1：https://blog.csdn.net/fukangwei_lite/article/details/122522957
原文链接2：https://vimsky.com/examples/usage/numpy-multiply-in-python.html
import numpy as geek
in_arr1 = geek.array([[2, -7, 5], [-6, 2, 0]])
in_arr2 = geek.array([[0, -7, 8], [5, -2, 9]])
out_arr = geek.multiply(in_arr1, in_arr2)
print ("Resultant output array:", out_arr)
# 输出：
Resultant output array: [[ 0 49 40]
[-30 -4 0]]
minimize()
scipy.optimize.minimize(fun, x0, args=(), method=None, jac=None, hess=None,hessp=None, bounds=None, constraints=(), tol=None,
callback=None, options=None)
求解约束函数最小值
参数：
- fun：该参数就是costFunction你要去最小化的损失函数，将costFunction的名字传给fun
- x0：初始化的theta,其shape必须为shape(n,)即一维数组
- method：该参数代表采用的方式，默认是BFGS, L-BFGS-B, SLSQP中的一种，可选TNC
- args：其他参数，具体指X，Y，lambda等
- jac：该参数就是计算梯度的函数，和fun参数类似，jac指代的gradient函数的第一个参数必须为theta且其shape必须为(n,)即一维数组,最后返回的梯度也必须为一个一维数组
- options：用来控制最大的迭代次数，以字典的形式来进行设置，例如：options={‘maxiter’:400}
返回值：
res：OptimizeResult
优化结果表示为 OptimizeResult 对象
x ：解决方案数组
success： 指示优化器是否成功退出的布尔标志
message：说明终止原因
原文链接1：https://blog.csdn.net/qq_38048756/article/details/103208834
原文链接2：https://vimsky.com/examples/usage/python-scipy.optimize.minimize.html
unique()
numpy.unique(ar, return_index, return_inverse, return_counts, axis)
找出数组中独一无二的元素值
参数：
- ar：输入数组，除非有axis的设定，否则自动扁平化为一个一维数组
- return_index：可选参数，bool，若为True则结果会同时返回被提取元素在原始数组中的索引值
- return_inverse：可选参数，bool，若为True则结果会同时返回元素位于原始数组中的索引值
- return_counts：可选参数，bool，若为True则结果会同时返回每个元素在原始数组中出现的次数
- axis：有返回值，返回一个排好序列的独一无二的数组
返回值：
原文链接：https://wenku.baidu.com/view/9ee9175e158884868762caaedd3383c4ba4cb449.html
argmax()
numpy.argmax(a, axis)
返回axis轴方向最大值的索引
参数：
- a ：为所需处理的矩阵
- axis ：为处理的轴向，axis=0表示按列操作，对比当前列返回最大值的索引；axis=1表示按行操作，对比当前行返回最大值的索引
原文链接1：https://blog.csdn.net/qq_43636375/article/details/105744725
原文链接2：https://wenku.baidu.com/view/9c9d566a862458fb770bf78a6529647d2728343f.html
import numpy as np
a=np.array([1,2,3,4,5])
print(np.argmax(a))
# 输出4
b=np.array([[1,0,6,4],[9,8,2,3],[3,1,2,7]])
print(np.argmax(b,axis=0))
# 输出：
[[1 0 6 4]
[9 8 2 3]
[3 1 2 7]]
classification_report()
sklearn.metrics.classification_report(y_true, y_pred, labels=None, target_names=None, sample_weight=None, digits=2, output_dict=False)
在深度学习中，分类任务评价指标是很重要的，在sklearn中有自动生成这些指标的的工具，就是 sklearn.metrics.classification_report模块
参数：
- y_true: 类别的真实标签值，类标签的列表
- y_pred: 预测值的标签，类标签的列表
- labels: 报告中要包含的标签索引的可选列表；这个参数一般不需要设置（如果要设置，比如200个类别，那么就应该如此设置：lable= range(200); 然后在sklearn.metrics.classification_report中将labels=label），可是有的时候不设置就会出错，之所以会出错是因为：比如你总共的类别为200个类，但是，你的测试集中真实标签包含的类别只有199个，有一个类别缺失数据，如果不设置这个参数就会报错
- target_name: 与标签匹配的名称，就是一个字符串列表，在报告中显示；也即是显示与labels对应的名称
- sample_weight：设置权重的参数，一般不用
- digits：这个参数是用来设置你要输出的格式位数
- output_dict：如果为True，则将输出作为dict返回
Notice：现在不再有micro avg了,因为这个指标指的是全体样本的准确率，所以简化成了一个指标accuracy
返回值：
accuracy：表示准确率，也即正确预测样本量与总样本量的比值
macro avg：表示宏平均，表示所有类别对应指标的平均值
weighted avg：表示带权重平均，表示类别样本占总样本的比重与对应指标的乘积的累加和
precision：精确度，正确预测为正的，占全部预测为正的比例
recall：召回率，正确预测为正的，占全部实际为正的比例
f1-score：精确率和召回率的调和平均数，2 * precision*recall / (precision+recall)
原文链接1：https://blog.csdn.net/comway_Li/article/details/102758972
原文链接2：https://www.jianshu.com/p/757dfef76e13
原文链接3：http://t.zoukankan.com/cgmcoding-p-13518979.html
# 输出报告
precision recall f1-score support
1 0.95 0.99 0.97 500
2 0.95 0.92 0.93 500
3 0.95 0.91 0.93 500
4 0.95 0.95 0.95 500
5 0.92 0.92 0.92 500
6 0.97 0.98 0.97 500
7 0.95 0.95 0.95 500
8 0.93 0.92 0.92 500
9 0.92 0.92 0.92 500
10 0.97 0.99 0.98 500
accuracy 0.94 5000
macro avg 0.94 0.94 0.94 5000
weighted avg 0.94 0.94 0.94 5000
OneHotEncoder()
sklearn.preprocessing.OneHotEncoder(categories=‘auto’, sparse=‘True’, dtype=‘float’)
将分类特征编码为one-hot数字数组
此处用于将y从50001转换为500010的数组
这个转换器的输入应该是一个类似数组的整数或字符串，表示分类（离散）特征所采用的值。使用 one-hot（又名“one-of-K”或“dummy”）编码方案对特征进行编码。这将为每个类别创建一个二进制列并返回一个稀疏矩阵或密集数组（取决于sparse 参数）。
默认情况下，编码器根据每个特征中的唯一值派生类别。或者，您也可以categories 手动指定。
参数：
- categories ：默认’auto’，根据根据训练数据自动确认类别；默认数组的列表，categories[i]保存第 i 列中预期的类别。传递的类别不应在单个特征中混合字符串和数值，并且应在数值的情况下进行排序
- sparse ：默认为True，如果设置为 True 将返回稀疏矩阵，否则将返回一个数组
- dtype：默认为float，所需的输出数据类型
函数方法：
- get_feature_names() ：查看拟合后的特征名称
- fit(X) ：使X拟合OneHotEncoder
- fit_transform(X)：数据预处理，使X拟合OneHotEncoder，并且转换X
原文链接：https://blog.csdn.net/weixin_44225602/article/details/122726150
import pandas as pd
data = {'degree':['master','master','PHD'],'grade':['A', 'B', 'C']}
df = pd.DataFrame(data)
from sklearn.preprocessing import OneHotEncoder
enc = OneHotEncoder()
enc.fit(df)
random()
numpy.random.random(size=n)
返回随机值为(0.0 , 1.0)的n维数组
参数：
- size：数组的大小
返回值：
原文链接：https://blog.csdn.net/weixin_42782150/article/details/122311468
import numpy as np
data = np.random.random(size=2)
print(data)
# 输出：
[0.58530303 0.58317698]
concatenate()
numpy.concatenate((a1, a2, …), axis=0)
一次完成多个数组的拼接
numpy.append()和numpy.concatenate()两个函数的运行时间进行比较的话，numpy.concatenate()效率更高，适合大规模的数组拼接
参数：
a1,a2……为要拼接的数组
axis：在哪个维度上进行拼接，默认为0
原文链接1：https://blog.csdn.net/summer2day/article/details/79935058
原文链接2：https://blog.csdn.net/qq_35037684/article/details/107882261
apply()
**pandas.DataFrame.apply(func, axis=0, raw=False, result_type=None, agrs=(), kwargs)
将函数应用到由列或行形成的一维数组上
参数：
func：函数，要应用于每一列或每一行的函数
axis：默认为0，0对应行索引，将func函数应用于每一列；1对应列，将函数应用于每一行
raw：布尔值，默认为False,确定行或列是否作为Series或ndarray对象传递
False：将每一行或每一列作为一个Series对象传递给函数
True：函数将接收ndarray对象
result_type：可选值有expand，reduce，broadcast，None，默认为None
args：元组，除了数组和Series之外，要传递给func的位置参数
返回值：
func函数沿Dataframe的给定轴应用的结果
原文链接：https://blog.csdn.net/qq_38727995/article/details/124459704
norm()
numpy.linalg.norm(x, ord=None, axis=None, keepdims=False)
linalg：线性代数
norm：范数，是对向量（或者矩阵）的度量，是一个标量
计算范数
0 范数，表示向量中非零元素的个数。
1 范数，表示向量中各个元素绝对值之和。
2 范数，表示向量中各个元素平方和 的 1/2 次方，L2 范数又称 Euclidean 范数或者 Frobenius 范数。
p 范数，表示向量中各个元素绝对值 p 次方和 的 1/p 次方。
参数：
x：表示矩阵（也可以是一维）
ord：范数类型，默认2范数
返回值：
矩阵的范数
原文链接1：https://blog.csdn.net/lens___/article/details/85697175
原文链接2：https://blog.csdn.net/m0_51816252/article/details/126199555
append()
List.append(element)
向列表末尾添加元素
import numpy as np
featuer1 = [-0.13, -0.0012, -0.1906, 0.02803, 0.075]
featuer2 = [-0.2302, -0.001, -0.2006, 0.01803, 0.095458]
sample_feature_list = [["Jack",featuer1], ["Jacob",featuer2]]
current =[]
for i in sample_feature_list:
current.append(i[1])
原文链接：https://www.jb51.net/article/250221.htm