Python的函数大全

小博Robert

已于 2022-11-23 17:09:09 修改

阅读量802

点赞数

文章标签： python 开发语言 numpy pandas matplotlib

于 2022-06-01 11:32:40 首次发布

本文链接：https://blog.csdn.net/Renobo/article/details/125080173

版权

Python的函数

eye()

numpy.eye(N, M=None, k=0, dtype=<class ‘float’>, 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', '<i4'), ('y', '<f8')])

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]))    # 计算列表各个元素的平方
# 输出<map object at 0x100d3d550>   返回迭代器
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。默认取值左闭右开
有三个参数，第一个参数为起点，第二个参数为终点，第三个参数为步长。步长支持小数。

返回值：
<class ‘numpy.ndarray’>：一个特殊的numpy数据类型,他是一个多维数组

原文链接：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表示均匀采样

返回值：
<class ‘numpy.ndarray’>：默认为一维的int或者数组

原文链接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)
是数组对象中的方法，用于改变数组的形状

返回值：
<class ‘numpy.ndarray’>

原文链接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：有返回值，返回一个排好序列的独一无二的数组

返回值：
<class ‘numpy.ndarray’>包含目标数的数组

原文链接：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：数组的大小

返回值：
<class ‘numpy.ndarray’>

原文链接：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])