【python】Notebook_notebook怎么对某一列求平均数

1. 小Tips

三元运算符

类似C语言的条件运算符？：
语法：
c = a if a>b else b //如果a>b返回a，否则返回b

平均数 np.mean()

>>> a = np.array([[1, 2], [3, 4]])
>>> np.mean(a) # 将上面二维矩阵的每个元素相加除以元素个数（求平均数）
2.5
>>> np.mean(a, axis=0) # axis=0，计算每一列的均值
array([ 2.,  3.])
>>> np.mean(a, axis=1) # 计算每一行的均值
array([ 1.5,  3.5])
1
2
3
4
5
6
7

range() 与 np.arange()

• range()返回的是range object，而np.arange()返回的是numpy.ndarray（type(np.arange(10)) == np.ndarray）

  • 两者都是均匀地（evenly）等分区间；
  • range尽可用于迭代，而np.arange作用远不止于此，它是一个序列，可被当做向量使用。

• range()不支持步长为小数，np.arange()支持步长为小数

• 两者都可用于迭代

• 两者都有三个参数，以第一个参数为起点，第三个参数为步长，截止到第二个参数之前的不包括第二个参数的数据序列
  某种意义上，和STL中由迭代器组成的区间是一样的，即左闭右开的区间。[first, last)或者不加严谨地写作[first:step:last)

>>>range(1,5)
range(1,5)
>>>tuple(range(1, 5))
(1, 2, 3, 4)
>>>list(range(1, 5))
[1, 2, 3, 4]


>>>r = range(1, 5)
>>>type(r)
<class 'range'>

>>>for  i in range(1, 5):
...    print(i)
1
2
3
4

>>> np.arange(1, 5)
array([1, 2, 3, 4])

>>>range(1, 5, .1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'float' object cannot be interpreted as an integer

>>>np.arange(1, 5, .5)
array([ 1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ,  4.5])

>>>range(1, 5, 2)
>>>for i in range(1, 5, 2):
...    print(i)
1
3

>>for i in np.arange(1, 5):
...    print(i)
1
2
3
4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

求最大/小值及索引值

1. 列表

list = [9, 12, 88, 14, 25]
max_list =  max(list) # 返回最大值
max_index = list.index(max(list))# 最大值的索引
1
2
3

2. numpy

• min/max是python内置的函数

• np.argmin/np.argmax是numpy库中的成员函数

（可适合处理numpy.ndarray对象，可选的参数是axis=0或者1）

import numpy as np
 
a = np.array([1, 2, 3, 4])
b = np.array((5, 6, 7, 8))
c = np.array([[11, 2, 8, 4], [4, 52, 6, 17], [2, 8, 9, 100]])
 
print(a)
print(b)
print(c)
 
print(np.argmin(c))
print(np.argmin(c, axis=0)) # 按每列求出最小值的索引
print(np.argmin(c, axis=1)) # 按每行求出最小值的索引
1
2
3
4
5
6
7
8
9
10
11
12
13

合并 list 为字符串

>>> seq = ('b','o','o','k')
>>> print('_'.join(seq))
>>> b_o_o_k # 输出结果
1
2
3

剪切板模块 pyperclip

pyperclip模块不是自带的需要安装

pyperclip.copy(text) 把text字符串中的字符复制到剪切板

text = pyperclip.paste() 把剪切板上的字符串复制到text

将秒数转化为小时分钟秒

seconds =35400
m, s = divmod(seconds, 60)
h, m = divmod(m, 60)
print("%d:%02d:%02d" % (h, m, s))
1
2
3
4

2. 数学

随机数

import random

print( random.randint(1,10) )        # 产生 1 到 10 的一个整数型随机数  
print( random.random() )             # 产生 0 到 1 之间的随机浮点数
print( random.uniform(1.1,5.4) )     # 产生  1.1 到 5.4 之间的随机浮点数，区间可以不是整数
print( random.choice('tomorrow') )   # 从序列中随机选取一个元素
print( random.randrange(1,100,2) )   # 生成从1到100的间隔为2的随机整数

a=[1,3,5,6,7]                # 将序列a中的元素顺序打乱
random.shuffle(a)
print(a)
1
2
3
4
5
6
7
8
9
10
11

3. 文件相关

按分隔文件路径名的字符串来分割

root.split(os.sep)
1

数据的保存和读取

1. .mat 格式，Matlab 也可以使用
   保存： scipy.io.savemat()
   读取： scipy.io.loadmat()

import scipy.io as scio
data = scio.loadmat('ex3data1.mat')
X = data['X']
Y = data['y']
scio.savemat("weights.mat", {'weights': self.weights})
1
2
3
4
5

2. .npy 格式，numpy
   保存： numpy.save()
   读取： numpy.load()

import numpy as np
a = np.mat('1,2,3;4,5,6')
np.save('a.npy',a)
data_a = np.load('a.npy')
1
2
3
4

检查文件夹是否存在，不存在则创建

if not os.path.exists(save_path):
	os.makedirs(save_path)
1
2

判断文件是否存在

if not os.path.isfile(Ground_Truth_file):
	get_Ground_Truth()
1
2

遍历文件夹中所有最里面的子文件夹中的文件

目录中所有 不包含子文件夹 的 文件夹 中的文件

for root, sub_dir, files in os.walk(root_path):
    # only want to read files
    if sub_dir != []:  # Go to the bottom of the directory without folder
        continue
    for file in files:
    	img = imread(os.path.join(root, file), as_gray=True)
1
2
3
4
5
6

遍历文件夹中的所有文件

pos_img_files = os.listdir(pos_img_path)
for file in pos_img_files:
    img = imread(pos_img_path+file)
1
2
3

获取当前文件名

Python获取当前文件名可以通过__file__或者sys.argv[0]，下面以test.py文件为例.

# -*- coding: utf-8 -*-
# test.py
import sys
import os

# 绝对路径
print(__file__)
print(sys.argv[0])

# 文件名
print(os.path.basename(__file__))
print(os.path.basename(sys.argv[0]))
1
2
3
4
5
6
7
8
9
10
11
12

输出：

E:/Code/python3/EffectivePython/test.py
E:/Code/python3/EffectivePython/test.py
test.py
test.py

__file__和sys.argv[0]都是当前文件的绝对路径，可以通过os.path.basename获得文件名。

4. matplotlib 画图

x轴标签旋转

plt.xticks(rotation=45)
1

设置坐标刻度值的大小以及刻度值的字体

plt.tick_params(labelsize=15)
labels = ax.get_xticklabels() + ax.get_yticklabels()
[label.set_fontname('Times New Roman') for label in labels]
1
2
3

设置横纵坐标的名称以及对应字体格式

font = {'family': 'Times New Roman',
         'weight': 'normal',
         'size': 15,}
plt.xlabel('Value of C for LinearSVC', font)
1
2
3
4

设置输出的图片大小

figure, ax = plt.subplots(figsize=(12, 5))
1

5. sklearn

保存模型及参数

1. pickle方法（python自带）

from sklearn import svm #引入支持向量机 
from sklearn import datasets    #引入数据集  
clf = svm.SVC() #使用SVC进行分类 
iris = datasets.load_iris() 
X,y = iris.data, iris.target clf.fit(X,y)  #第一种方法，用python自带的pickle库 
import pickle with open('save/clf.pickle','wb') as f: #以写的形式设置一个文件： 
clf.pickle  pickle.dump(clf,f)      #将clf这个训练好的模型 存储在变量f中，且保存


#导出模型并预测值： 
import pickle iris = datasets.load_iris() 
X,y = iris.data, iris.target  
with open('save/clf.pickle','rb') as f: 
                 #以读取的方式 读取模型存储的pickle文件，并放在变量f里  
clf_load = pickle.load(f)           #将模型存储在变量clf_load中  
print(clf_load.predict(X[0:5]))     #调用并预测0-5的结果
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2. joblib方法（sklearn自带）

from sklearn.externals import joblib
#保存
joblib.dump(best_lin_svm_clf, 'save/clf.pkl', compress=3)  # 保存训练好的clf模型 compress读取速度
#读取
che_clf = joblib.load('save/clf.pkl')  # 读取训练好的clf模型
1
2
3
4
5

k 折交叉验证

比如将数据集分为10折，做一次交叉验证，实际上它是计算了十次，将每一折都当做一次测试集，其余九折当做训练集，这样循环十次。通过传入的模型，训练十次，最后将十次结果求平均值。将每个数据集都算一次

交叉验证优点：

1：交叉验证用于评估模型的预测性能，尤其是训练好的模型在新数据上的表现，可以在一定程度上减小过拟合。
2：还可以从有限的数据中获取尽可能多的有效信息。

我们如何利用它来选择参数呢？

我们可以给它加上循环，通过循环不断的改变参数，再利用交叉验证来评估不同参数模型的能力。最终选择能力最优的模型。

下面通过一个简单的实例来说明：（iris鸢尾花）

from sklearn import datasets	#自带数据集
from sklearn.model_selection import train_test_split,cross_val_score	#划分数据 交叉验证
from sklearn.neighbors import KNeighborsClassifier  #一个简单的模型，只有K一个参数，类似K-means
import matplotlib.pyplot as plt
iris = datasets.load_iris()		#加载sklearn自带的数据集
X = iris.data 			#这是数据
y = iris.target 		#这是每个数据所对应的标签
train_X,test_X,train_y,test_y = train_test_split(X,y,test_size=1/3,random_state=3)	#这里划分数据以1/3的来划分 训练集训练结果 测试集测试结果
k_range = range(1,31)
cv_scores = []		#用来放每个模型的结果值
for n in k_range:
    knn = KNeighborsClassifier(n)   #knn模型，这里一个超参数可以做预测，当多个超参数时需要使用另一种方法GridSearchCV
    scores = cross_val_score(knn,train_X,train_y,cv=10,scoring='accuracy')  #cv：选择每次测试折数  accuracy：评价指标是准确度,可以省略使用默认值，具体使用参考下面。
    cv_scores.append(scores.mean())
plt.plot(k_range,cv_scores)
plt.xlabel('K')
plt.ylabel('Accuracy')		#通过图像选择最好的参数
plt.show()
best_knn = KNeighborsClassifier(n_neighbors=3)	# 选择最优的K=3传入模型
best_knn.fit(train_X,train_y)			#训练模型
print(best_knn.score(test_X,test_y))	#看看评分
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

6. opencv

1. cv2.putText 文字换行（’\n’）无法解析换行

cv2.putText 在向图像中添加文本信息时，如果在待添加的文本中含有换行转义符，一般它是无法正确处理的：

cv2.putText(img, "This is \n some text", (50,50), cv2.FONT_HERSHEY_SIMPLEX, .6, (0, 255, 0), 1, 2)
1

一种解决方案如下：

img = cv2.imread('boat.png')
text = "FPS: " + str(curr_fps) + "\nperson: " + str(person_num)
y0, dy = 15, 20
for i, txt in enumerate(text.split('\n')):
    y = y0 + i * dy
    # cv2.putText(img, txt, (50, y), cv2.FONT_HERSHEY_SIMPLEX, .6, (0, 255, 0), 1, 2)
    cv2.putText(img, text=txt, org=(3, y), fontFace=cv2.FONT_HERSHEY_SIMPLEX,
                fontScale=0.50, color=(255, 0, 0), thickness=2)

cv2.imshow('img', img)
cv2.waitKey(0)
1
2
3
4
5
6
7
8
9
10
11

7. list, numpy.ndarray, torch.Tensor 格式相互转化

1. list 转 numpy

ndarray = np.array(list)
1

2. numpy 转 list

list = ndarray.tolist()
1

3. list 转 torch.Tensor

tensor=torch.Tensor(list)
1

4. torch.Tensor 转 list（先转numpy，后转list）

list = tensor.numpy().tolist()
1

5. torch.Tensor 转 numpy

ndarray = tensor.numpy()
# *gpu上的tensor不能直接转为numpy
ndarray = tensor.cpu().numpy()
1
2
3

6. numpy 转 torch.Tensor

tensor = torch.from_numpy(ndarray) 
1