PYTHON

记录

每日dedede。菜鸟一枚 默默记录再学习过程中遇到的问题和学到的方法 希望没有人看的到。

PYTHON

语法记录

• 取交集 list0 = list(set(list1).intersection(set(list2)))
• 取并集 list0 = list(set(list1).union(set(list2)))
• 论文中的log 通常指以2为底 math.log(x,2)
• 写txt文件：
  f= open(’…/test.txt’, ‘a+’, encoding=‘utf-8’)
  f.write(str(test).‘test’)
• 写dict文件：
  test_dict = {}
  test_dict[i]=j
  with open(‘data/test_dict.json’, ‘w’) as f: #不转换成ascii json字符串首缩进
  f.write(json.dumps(test_dict, ensure_ascii=False, indent=2))
• 读dict文件：
  import json
  with open(“data/test_dict.json”, ‘r’) as f:
  test_dict = json.load(f)
• 遍历dict文件的key
  for i in test_dict:
  print(“key:”，i)
• 读xlsx文件：
  from openpyxl import load_workbook
  workbook = load_workbook(‘data/test.xlsx’) # 找到需要xlsx文件的位置
  booksheet = workbook.active # 获取当前活跃的sheet,默认是第一个sheet
  rows = booksheet.rows
  i = 0
  for _ in rows:
  i = i+1
  cell_data_1 = booksheet.cell(row=i, column=1).value # 获取第i行1 列的数据

yield函数教程

带yield的函数是一个生成器，而不是一个函数了，这个生成器有一个函数就是next函数，next就相当于“下一步”生成哪个数，这一次的next开始的地方是接着上一次的next停止的地方执行的，所以调用next的时候，生成器并不会从foo函数的开始执行，只是接着上一步停止的地方开始，然后遇到yield后，return出要生成的数，此步就结束。
例子：

def foo():
    print("starting...")
    while True:
        res = yield 4
        print("res:",res)
g = foo()
print(next(g))
print("*"*20)
print(next(g))

结果：

starting...
4
********************
res: None
4

1.程序开始执行以后，因为foo函数中有yield关键字，所以foo函数并不会真的执行，而是先得到一个生成器g(相当于一个对象)

2.直到调用next方法，foo函数正式开始执行，先执行foo函数中的print方法，然后进入while循环

3.程序遇到yield关键字，然后把yield想想成return,return了一个4之后，程序停止，并没有执行赋值给res操作，此时next(g)语句执行完成，所以输出的前两行（第一个是while上面的print的结果,第二个是return出的结果）是执行print(next(g))的结果，

4.程序执行print("*"20)，输出20个

5.又开始执行下面的print(next(g)),这个时候和上面那个差不多，不过不同的是，这个时候是从刚才那个next程序停止的地方开始执行的，也就是要执行res的赋值操作，这时候要注意，这个时候赋值操作的右边是没有值的（因为刚才那个是return出去了，并没有给赋值操作的左边传参数），所以这个时候res赋值是None,所以接着下面的输出就是res:None,

6.程序会继续在while里执行，又一次碰到yield,这个时候同样return 出4，然后程序停止，print函数输出的4就是这次return出的4.

enumerate() 函数

用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(seasons)))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

print(list(enumerate(seasons, start=1)))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

Pytorch

torch.cat Tensor 拼接

A=torch.ones(2,3)    #2x3的张量（矩阵）                                     
# tensor([[ 1.,  1.,  1.],
#         [ 1.,  1.,  1.]])
B=2*torch.ones(2,3)  #2x3的张量（矩阵）                                    
# tensor([[ 2.,  2.,  2.],
#         [ 2.,  2.,  2.]])
#按维数 0（行）拼接 A 和 B
C=torch.cat((A,B),0） 
# tensor([[ 1.,  1.,  1.],
#          [ 1.,  1.,  1.],
#          [ 2.,  2.,  2.],
#          [ 2.,  2.,  2.]])
#按维数1（列）拼接 A 和 B
C=torch.cat((A,B),1)
tensor([[ 1.,  1.,  1.,  2.,  2.,  2.],
         [ 1.,  1.,  1.,  2.,  2.,  2.]])

t.shape，t.size()

返回Tensor t 的维度

torch.unsqueeze(x,1); torch.squeeze(x,0)

torch.squeeze() 这个函数主要对数据的维度进行压缩,，去掉维数为1的的维度
torch.unsqueeze()这个函数主要是对数据维度进行扩充。给指定位置加上维数为一的维度

.todense() .toarray()

toarray返回一个ndarray; todense返回一个矩阵

一、Numpy

创建数组

运算的所用的数据结构叫做叫做数组,与list相比没有‘,’作为分割符号

import numpy as np
data = np.array([1,2,3,4,5])
print(data)
#二维数组
data_2 = np.array([
		[1,2,3],
		[4,5,6]
	])
print(data_2 )
#全零数组
data_2dim = np.zeros((2,3))
#全一数组
data_3dim = np.ones((1,2,3))
print(data_2dim )
print(data_3dim )
#连续赋值[0 1 2 3 4 5 6 7 8 9]
data_a = np.arange(10)
print(data_a)

读取数据

1.索引：
1维数组：在数组名的后面用中括号[]括号中填写所查询数组的编码。比如：data[1]
n维数组：

• 用列表表示所查询数的坐标值，如data_2dim[1,0]
• 第二种：把多维数组看成一位数组套娃，依次取值，如data_2dim[1][0]

2.切片：

• 对于1维数组：在数组名后加上中括号[]，在括号中填写切片的范围，m:n用冒号作为分隔符，表示的意义是m≤index＜n，如：data[2:4]；
• 对于n维数组：把多维数组看成一位数组套娃，依次取值，要注意的是，多维数组的切片往往还是多维数组，如果需要得到具体某一个元素，则在切片之后还要进行索引操作。

import numpy as np
data = np.array([0,1,2,3,4,5])
print(data[1]) #1
print(data[2:4]) #[2 3]

data_2dim = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
print(data_2dim[1,0]) #4
print(data_2dim[1][0]) #4
print(data_2dim[1:4]) #[[4 5 6] [7 8 9 ] [10 11 12]]
print(data_2dim[1:4][1:3][1][2]) #12

ndarray数组的参数

我们在描述一个多维数组的时候，经常会用到两个参数：维度（dimension）和形状（shape）

print(data.ndim)# 维度 2
print(data.shape)# 形状 （3，4）   3*4

axis关键词表示对于numpy数组（矩阵）中的跨行/跨列计算

• axis取0的时候，是跨行计算，相当于是压扁矩阵（这里可以想象成把一个圆圆的气球压扁了）
• axis取1的时候，是跨列计算

np_dat = np.arange(12).reshape(3,4)
print(np_dat)
print(np_dat.sum(axis=0))
print(np_dat.sum(axis=1))

[[ 0  1  2  3]
[ 4  5  6  7]
[ 8  9 10 11]]

[12 15 18 21]
[ 6 22 38]

数组的操作

转置（transposition）和改造（reshape）

• 转置是把原来的行列互换
• 改造是把矩阵的长宽变成另外一对数值

import numpy as np
data = np.arange(10)
t_data = data.T #转置
rs_data = data.reshape((2,5))
trs_data = rs_data.T
print(data)
print(t_data)

print(rs_data)
print(trs_data)

[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4 5 6 7 8 9]

[[0 1 2 3 4]
 [5 6 7 8 9]]
[[0 5]
 [1 6]
 [2 7]
 [3 8]
 [4 9]]

数组的运算

1.一元运算
对一列元素进行运算：sqrt_data = np.sqrt(data_list)

2.二元运算
对一列元素和另外一列元素进行二元运算：sum_data = np.add(data1,data2)

3.统计学运算（聚合函数）
对一个数组进行运算：mean_data = np.mean(data)

数据的读取

把数据存放在txt中存储，在python中可以通过np.genfromtxt()方法读取数据然后进行后续的处理

data = np.genfromtxt('sars_data.txt',delimiter='/n')

二、sklearn

带有一些规范化的数据库
内置一些函数可以进行基本的数据分析

数据处理

##数据切分
from sklearn.model_selection import train_test_split
train_X, test_X, train_y, test_y = train_test_split(X, y, test_size=0.3) 

特征工程

1.特征选择

方差选择法

#计算各个特征的方差，然后根据阈值，选择方差大于threshold阈值的特征。
from sklearn.feature_selection import VarianceThreshold
VarianceThreshold(threshold=3).fit_transform(iris.data)

卡方检验

#检验特征对标签的相关性，选择其中K个与标签最相关的特征。
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2
SelectKBest(chi2, k=2).fit_transform(iris.data, iris.target)

2.特征提取
文本特征提取：

Sklearn.feature_extraction.text.CountVectorizer(stop_words[])
#stop_words:停用词指的是指定的词不在做为文本特征提取的处理对象

3.特征预处理

归一化

from sklearn.preprocessing import Normalizer
Normalizer().fit_transform(iris.data)

标准化

#将正态分布特征值转化为标准正态分布(需要用到协方差分析进行降维)
from sklearn.preprocessing import StandardScaler
StandardScaler().fit_transform(iris.data)

#(X-X_mean)/X_std 
from sklearn import preprocessing
X_scale = preprocessing.scale(X)

区间缩放

#返回值为缩放到[0, 1]区间的数据)(不涉及距离度量、协方差计算、不符合正太分布的时候)
from sklearn.preprocessing import MinMaxScaler
MinMaxScaler().fit_transform(iris.data)

机器学习算法

1.实例化一个estimator类
2.estimator调用fit()方法，对送入的x_train,y_train值进行训练
3.模型评估：y_predict=estimator.(x_test)
　　　　　 y_predict==y_test
KNN

import numpy as np
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier() # 引入模型
knn.fit(train_X, train_y) # fit 训练
pred = knn.predict(test_X) # pred 预测步骤
#打印
print(np.array(test_y))
print(np.array(pred))

SVM

from sklearn.svm import SVC
clf = SVC()
clf.fit(train_X, train_y)
print(clf.score(test_X, test_y)) 

决策树

classi=DecisionTreeClassifier()
classi.fit(train_x,train_y)
classi.score(test_x,test_y)

线性回归

from sklearn.linear_model import LogisticRegression
clf = LinearRegression(fit_intercept=True)
clf.fit(train_X, train_y)
print(clf.score(test_X, test_y)) 

逻辑回归

from sklearn.linear_model import LogisticRegression
clf = LogisticRegression(solver="liblinear",penalty="l2"C=1.0)
clf.fit(train_X, train_y)
print(clf.score(test_X, test_y)) 

K-means

from sklearn.cluster import KMeans
kmean  = KMeans(n_clusters=2, random_state=0)
kmean..fit(X)

评分函数

交叉验证(cross_validation)
指将原数据集切分成n等分，每一份做一次得分，求得平均值作为当前模型的准确度或者误差。

from sklearn.model_selection import cross_val_score
scores = cross_val_score(knn, X, y, cv=5, scoring="accuracy")
print(scores.mean()) 

降维

主成分分析法（PCA）

from sklearn.decomposition import PCA
#n_components为主成分数目
PCA(n_components=2).fit_transform(iris.data)

线性判别分析法（LDA）

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
#n_components为降维后的维数
LDA(n_components=2).fit_transform(iris.data, iris.target)

参数调优

为KNN选k（1-31）

k_score = []
k = range(1,31)
for n in k:
    knn = KNeighborsClassifier(n_neighbors=n)#引入模型
    scores = cross_val_score(knn, X, y, cv=5, scoring="accuracy") # 交叉验证（分类）
    # loss = -cross_val_score(knn, X, y, cv=5, scoring="mean_squared_error") # 回归
    k_score.append(scores.mean())
plt.plot(k, k_score)
plt.xlabel("Value for KNN")
plt.ylabel("Cross-validation accuracy")
plt.show() 

模型保存

import pickle
with open('save/clf.pickle', 'wb') as f:
    pickle.dump(knn, f)
with open('save/clf.pickle', 'wb') as f:
	knn = pickle.load(f)