python知识点汇总

2020-04-01 本文已影响0人裁尘的人儿

按行名和列名取出行列

data.loc['rowname',:]
data.loc[:,'colname']

按行索引和列索引取出行列：

data.iloc[3,:]
data.iloc[:,3]

同时取出array的某几行某几列数据

#取出1，2行数据
C_A = c[[0,2]]  #必须先取出想要的行数据，再取出想要的列数据
#取出3、4列数据
C_A = C_A[:,[2,3]]
#注意：不能同时取

计算列表里各元素出现的次数：

y=[1,2,3,4,22,1,1,1,3,4]
 pd.Series(y).value_counts()

或者：计算列表中从0开始每个数的出现的次数
np.bincount(y)

4.给dataframe命名列名（只赋第三列）

a.columns=[None,None,"type",None]


#非常重要：只修改某个特定列名！！！！
df.rename(columns={'a':'A'})

#修改全部列名
df.columns = ['A','B']

4.1 调整列的顺序

#调整列的顺序
#方式一：
columns_order = ['date', 'time', 'open', 'high', 'low', 'close', 'volumefrom', 'volumeto']
df = df[columns_order]或df=pd.DataFrame(df, columns=columns_order )
#方式二：
#意思是，先把需要调整的列的数据拿出来，之后，再将这个列删掉，最后，再用插入的方式把这个列调整到对应的位置上。
df_id = df.id
df = df.drop('id',axis=1)
df.insert(0,'id',df_id)

关于路径操作：

获得当前工作目录：os.getcwd()
新建目录：os.mkdir()
切换工作路径：os.chdir()
路径粘贴：os.path.join(）可以有n多个参数

字符串分割，截取，拼接，部分替换，字符串与int直接转换

#字符串拼接：
 "{0}.png".format("kghf")     #结果为："kghf.png"
 "aaa" + "bbb"

# 字符串截取：
"kghfdfgsf.tiff"[:-6]   #截去/删除后六个字符

#字符串分割：
"kghfdfgsf.tiff".split(".")

#字符串部分替换：
#如果只需要将一个字符串里的某一部分替换掉，可以用a.replace(要替换掉的部分字符串，要替换进来的字符串）：
label_path =  os.path.join(label_dir, img.replace('fullstack', 'cellmask'))

6.1 将列表中的字符串转为数字

#字符转整数：
int("2")
#整数转字符：
str(2)


numbers = [ int(x) for x in numbers ]

#Python2,可以使用map函数  
numbers = map(int, numbers)

#如果是3.x,map返回的是map对象，当然也可以转换为List:
numbers = list(map(int, numbers)

6.1 关于format:

'数字{1}{2}和{0}'.format("123",456,'789')
#'数字456789和123'

7.画图：

#方式一：
#注意：plt.cm.gray和cmap='gray'等同
fig,[(ax0, ax1, ax2),(ax3, ax4, ax5)]= plt.subplots(2, 3, figsize=(4*3, 4*2))

ax0.imshow(label[:,:,0], plt.cm.gray, interpolation='nearest')
ax0.axis('off')

ax1.imshow(label[:,:,1], plt.cm.gray, interpolation='nearest')
ax1.axis('off')

ax2.imshow(label[:,:,2], plt.cm.gray, interpolation='nearest')
ax2.axis('off')

ax3.imshow(label[:,:,3], plt.cm.gray, interpolation='nearest')
ax3.axis('off')

ax4.imshow(label[:,:,4], plt.cm.gray, interpolation='nearest')
ax4.axis('off')

ax5.imshow(label[:,:,5], plt.cm.gray, interpolation='nearest')
##cmap='gray'或plt.cm.gray
ax5.axis('off')
fig.tight_layout()

#方式二：
import matplotlib.pyplot as plt
plt.imshow(label[:,:,5], cmap='gray', interpolation='nearest')

#方式三：在一张图片上又继续画图
fig, ax = plt.subplots()
ax.imshow(image, cmap=plt.cm.gray)

for props in regions:
    y0, x0 = props.centroid
    orientation = props.orientation
    x1 = x0 + math.cos(orientation) * 0.5 * props.minor_axis_length
    y1 = y0 - math.sin(orientation) * 0.5 * props.minor_axis_length
    x2 = x0 - math.sin(orientation) * 0.5 * props.major_axis_length
    y2 = y0 - math.cos(orientation) * 0.5 * props.major_axis_length

    ax.plot((x0, x1), (y0, y1), '-r', linewidth=2.5)
    ax.plot((x0, x2), (y0, y2), '-r', linewidth=2.5)
    ax.plot(x0, y0, '.g', markersize=15)

    minr, minc, maxr, maxc = props.bbox
    bx = (minc, maxc, maxc, minc, minc)
    by = (minr, minr, maxr, maxr, minr)
    ax.plot(bx, by, '-b', linewidth=2.5)

ax.axis((0, 600, 600, 0))
plt.show()

#方式四：循环画图
import matplotlib.pyplot as plt
%matplotlib inline
nrows = 3
ncols = 3
figsize = (8, 8)
_, figs = plt.subplots(nrows, ncols, figsize=figsize)
for i in range(nrows):
    for j in range(ncols):
        figs[i][j].imshow(im_aug(im))
        figs[i][j].axes.get_xaxis().set_visible(False)
        figs[i][j].axes.get_yaxis().set_visible(False)
plt.show()

8.去重/排序：

去重：np.unique()
排序：np.sort()

9.根据矩阵里不同的标记/数字，给矩阵图片显示不同的颜色

from skimage import measure,color
dst=color.label2rgb(labels2cluster)  #根据不同的标记显示不同的颜色

#开图fig,开轴ax
fig,ax= plt.subplots(1, 1, figsize=(4*1, 4*1))
ax.imshow(dst,interpolation='nearest')
ax.axis('off')
fig.tight_layout()

矩阵逻辑操作：可以赋值，但是不能赋值给其他变量，因为逻辑操作后得到的不是矩阵，而是从中取出满足条件的一个数组

a[a>10]=1
a[a<=10]=0

注意：b=a[a>10]结果是一个数组，取出矩阵a中大于10的所有数

mask提取ROI:

imasked = cv2.add(raw_img, np.zeros(np.shape(raw_img), dtype=np.float32), mask=imask.astype(np.uint8))
#注意：
#1. mask必须是np.uint8
#2. 前两个参数必须数据类型一致

连通区域标记：使用label和mask均可

调整图片尺寸，不改变图片内容的方法： skimage.transform里的resize函数

a=tiff.imread("test/crop_self_testunet34_mask/crop_MB0002_1_345_cellmask.tiff").astype(np.uint8)
img_size_target=512
from skimage.transform import resize
a0=resize(a, (22,img_size_target, img_size_target), mode='constant', preserve_range=True)

来自：https://blog.csdn.net/Fredric_2014/article/details/83240107

给mask里每个不同数字的object加颜色：

import numpy as np
import scipy.ndimage as ndi
from skimage import measure,color
import matplotlib.pyplot as plt

img=tiff.imread("....celltype.tiff").astype(np.uint8)
dst = color.label2rgb(img）
plt.imshow(dst,cmap='gray',interpolation='nearest')
plt.show()

#也或者给mask里每个object加不同颜色：
labels, num = measure.label(img, return_num=True)
dst = color.label2rgb(img）
plt.imshow(dst,cmap='gray',interpolation='nearest')
plt.show()

添加一对一对文件（train和label）：

 img_list = []
 for img in os.listdir(os.path.join(image_dir)):
     img_path = os.path.join(image_dir, img)
     label_path =  os.path.join(label_dir, img.replace('fullstack', 'cellmask')) #img:MB0000_1_527_fullstack.tiff    label: MB0000_1_527_cellmask.tiff
     img_list.append([img_path, label_path])

图像上采样：将图片扩充(padding)成固定尺寸，eg. 512*512

#图片padding在图像学上称为上采样
def pad_image(array, label):
    _, width, height = array.shape
    pad_w = 0
    pad_h = 0
    if width<513:
        pad_w = 513-width
    if height<513:
       pad_h = 513-height

    array_pad = np.pad(array,((0, 0),
                              (pad_w//2, pad_w-pad_w//2),#向上填充1个维度，向下填充两个维度
                              (pad_h//2, pad_h-pad_h//2))#向左填充2个维度，向右填充一个维度
                              ,mode="constant",#填充模式
                              constant_values=(0,0))#第一个维度（就是向上和向左）填充6，第二个维度（向下和向右）填充5
    label_pad = np.pad(label,(
                              (pad_w//2, pad_w-pad_w//2),#向上填充1个维度，向下填充两个维度
                              (pad_h//2, pad_h-pad_h//2))#向左填充2个维度，向右填充一个维度
                              ,mode="constant",#填充模式
                              constant_values=(0,0))#
    return array_pad, label_pad

图片下采样，即图片随机裁剪成固定尺寸：

def randomcrop(crop_size, image, label):
    z, x, y = image.shape
    size_z, size_x, size_y = crop_size

    if x < size_x or y < size_y or z < size_z:
        raise ValueError

    #z1 = np.random.randint(0, z - size_z)
    x1 = np.random.randint(0, x - size_x)
    y1 = np.random.randint(0, y - size_y)

    image = image[0: 50,           x1: x1 + size_x, y1: y1 + size_y]
    label = label[                 x1: x1 + size_x, y1: y1 + size_y]

    return image, label

椭圆拟合

cv2.fitEllipse(points)

# points类型要求是numpy.array（[[x,y],[x1,y1]...]） 
#注意：并不是把所有点都包括在椭圆里面，而是拟合出一个椭圆尽量使得点都在圆上

cv2.ellipse(img, center, axes, angle, startAngle, endAngle, color[, thickness[, lineType[, shift]]]) 

# 其中每个参数的意义如下：

# img 图像

# center 中心坐标

# axes 椭圆的尺寸（长短轴）

# angle 旋转角度

# startAngle 起始角度

# endAngle 终止角度

# 后面参数都是跟线条有关的
#注意：
# . 平时我们用cv2.ellipse来画椭圆的时候，给定的长短轴都是半轴的长度;
# . 用cv2.fitEllipse拟合出来的是半轴的双倍长度。在用cv2.ellipse绘制的时候注意;
# . 如果直接用cv2.fitEllipse拟合出来的参数绘制，可以直接将拟合参数作为cv2.ellipse的参数，而不必将长短轴除以2，如下图所示。（这儿_ellipse假设是cv2.fitEllipse拟合出来的）

#先拟合，后画圆

统计每个元素的数量

from collections import Counter
a = [1, 2, 3, 1, 1, 2]
result = Counter(a)
print result

#统计个数并排序
from collections import Counter
# 根据数列中字母出现的次数和ASCII的大小，进行排序。
l1 = ['d', 'f', 'g', 'f', 'e', 'z', 'f', 'a', 'a'] 
d2 = Counter(l1)
sorted_x = sorted(d2.items(), key=lambda x: x[1], reverse=True)

列表追加元素：

#1. +加号添加
[0,5]+list(range(7,12))
#[0, 5, 7, 8, 9, 10, 11]

22.列表元素排序：

#逆序
sorted(list(np.unique(raw_img)),reverse=True)

删除某些行：

#法一：删除ImageNumber列为78的行
ind= al["ImageNumber"]==78
single_data = al.loc[-ind,]#-表示删除

#法二：删除指定行
meta0=meta.drop([27,42,46,48],axis = 0)#[27,42,46,48]都是行名
#删除指定列
meta0=meta.drop(['a','b'],axis = 1)

将dataframe里的某一列从float转为int
meta0.loc[:,['FullStack']]=meta0.loc[:,['FullStack']].astype(int)
删除列表里的nan:

import math
list_c=pd.Series(list_c)[[(not math.isnan(x)) for x in list_c]]

25.对数据框按照某一列排序
a.sort_values(by="mean_pro",ascending=False)#是否升序：否

将数据框的某一列加一：
panel.loc[:,['FullStack']]=panel.loc[:,['FullStack']]-1
逐行往数据框里写入数据

for i,fn in enumerate(os.listdir(folder_uncertainty)):
    print(i,fn, np.mean(tiff.imread(os.path.join(folder_uncertainty,fn))))
    if i ==0:
        a=pd.DataFrame([i,fn, np.mean(tiff.imread(os.path.join(folder_uncertainty,fn)))]).T
    else:
        a=pd.concat([a,pd.DataFrame([i,fn, np.mean(tiff.imread(os.path.join(folder_uncertainty,fn)))]).T],axis=0)


a.columns=["index","fn","mean_pro"]
a.index=range(a.shape[0])
a

python 一行语句实现if else:
x if x > y else y

#value_when_true if condition_is_ture else value_when_condition_is_false
max_value =       x if x > y else y
#这一行命令的逻辑：若x > y，则max_value = x，否则：max_value = y。

python 直接替换列表中的元素三种方法：

#法一：
aaa=['黑色','红色','白色','黑色']
bbb=['黄色' if i =='黑色' else i for i in aaa]
bbb
#结果：
#['黄色', '红色', '白色', '黄色']

#法二：（替换批量的元素）
aaa=['黑色','红色','白色','黑色']
ccc=['黑色','红色']
bbb=['黄色' if i in ccc  else i for i in aaa]
bbb
#结果：
#['黄色', '黄色', '白色', '黄色']

#法三：（替换多个元素）
aaa=['黑色','红色','白色','黑色']
ccc={'黑色':'黄色','红色':'白色'}
bbb=[ccc[i] if i in ccc else i for i in aaa]
bbb
#结果：
#['黄色', '白色', '白色', '黄色']

输出多个字符串+数字

print("dice:%f, dice_nuclei:%f, dice_cell:%f" % (dice,dice_nuclei, dice_cell))
#注意：%d整数型；%f浮点型

画直方图

plt.hist(data, bins=[0, 5, 10, 15, 20, 25])#表示统计这批数据在0-5区间、5-10、10-15、15-20、20-25区间内数据的频次
#[ 7549, 16011, 25071, 23348, 19649]

plt.hist(data, bins=[0, 5, 10, 15, 20, 25,30,35])#表示统计这批数据在0-5区间、5-10、10-15、15-20、20-25、25-30、30-35区间内数据的频次
#[ 7549, 16011, 25071, 23348, 16904, 12511, 12640]


import matplotlib.pyplot as plt
fig,(ax0, ax1,ax2)= plt.subplots(1, 3, figsize=(8*3, 8*1))

ax0.hist(a["dice"])
#显示子图的坐标轴
ax0.axis('on')
#设置子图的标题
ax0.set_title("dice on all test images")
#设置子图的x轴名称
ax0.set_xlabel("dice")
#设置子图的y轴名称
# ax0.set_ylabel("frequency")


# b[b>0]=255
ax1.hist(a["dice_nuclei"])
ax1.axis('on')
ax1.set_title("dice for nuclei mask on all test images")
ax1.set_xlabel("dice")
# ax1.set_ylabel("frequency")

# c=tiff.imread("/mnt/md0/qy/project/unet/train/test/mask_nuclei/MB0530_1_348_ilastik_s2_Probabilities_nuc_mask.tiff")
# c[c>0]=255
ax2.hist(a["dice_cell"])
ax2.axis('on')
ax2.set_title("dice for cell mask  on all test images")
ax2.set_xlabel("dice")
# ax2.set_ylabel("frequency")

#设置总图标题
# fig.suptitle('Dice')

fig.tight_layout()

pandas多条件组合筛选数据：

props[(props['minor_axis_length']>0) & (props['area']>2)]
#DataFrame某一列按照条件筛选，另一列赋值，一定加loc
df.loc[((df.vol_avg_daily < 95) | (df.vol_avg_daily > 110)) & (df.wiring_mode == '2'), 'vol_if_exception'] = 1

32.1 同时取出数组的某几行某几列数据

#取出1，2行数据
C_A = c[[0,2]]  #必须先取出想要的行数据，再取出想要的列数据
#取出3、4列数据
C_A = C_A[:,[2,3]]
#注意：不能同时取

与操作：

if (img.shape[0] >= 250) & (img.shape[1] >= 250): .......#注意：一定要加括号

从列表里删除所有的某值

#方法一：耗时长
c=[1,2,4,1,1,2]#len=6

for i in range(len(c)-1,-1,-1):#注意这里一定要是递减的，这样减到最后c[i]才不会因为c里元素的删减而超出索引。[5, -1],step=-1 >>>> [5,4,3,2,1,0]

     if c[i]==1:

          c.remove(1)

print(c)

#方法二：
arr=[1,1,3]

print(list(filter(lambda x:x!=1,arr)))

把一个矩阵行优先展成一个向量

# 有两种方式：
# numpy.ravel()   VS   numpy.flatten()
# 首先声明两者所要实现的功能是一致的（将多维数组降位一维），两者的区别在于: 返回拷贝（copy）还是返回视图（view）

# 1. numpy.flatten()返回一份拷贝，对拷贝所做的修改不会影响原始矩阵
x = np.array([[1, 2], [3, 4]])
print(x.flatten()[1] = 100)
#array([[1, 2],
#       [3, 4]])            # flatten：返回的是拷贝，不会对数据进行修改


# 2.而numpy.ravel()返回的是视图，会影响原始矩阵。
print(x.ravel()[1] = 100)  #ravel()则回对数据进行就该
#array([[  1, 100],
#       [  3,   4]])

将array展开成一维向量、统计array里每个元素的数量，排序

#将array展开成一维向量
labels.flatten()

#统计array里每个元素的数量，按数量排序
from collections import Counter

d2=Counter(labels.flatten())
sorted(d2.items(), key=lambda x: x[1], reverse=True)

#统计数值数量，并按数值的大小排序
Counter(sorted(im.flatten(),reverse=True))

37.获取当前系统时间

#获取时间
datetime.datetime.now()
# datetime.datetime(2020, 7, 24, 10, 34, 36, 503188)

#分别获取年月日
datetime.datetime.now().year
datetime.datetime.now().month
datetime.datetime.now().day
datetime.datetime.now().hour
datetime.datetime.now().minute
datetime.datetime.now().second

#获取到的时间转换成字符串
datetime.datetime.now().strftime("%Y-%m-%d-%H-%M")
datetime.datetime.now().strftime("%Y-%m-%d %H:%M")

查看某数据类型的范围

np.iinfo(a.dtype)

np.iinfo(a.dtype).max

np.histogram

imhist,bins = np.histogram(im,256)
#把im里的数据从[im.min, im.max]之间划分成256个区间
#计算每个区间段内的频数，
#所以imhist是有256个值的list，每个值代表im内有多少个值出现在该区间
#bins是列出了257个数，代码256个区间的257个临界点

imhist,bins = np.histogram(im,256,normed=True)


a = np.random.rand(100)      #表示在（0,1）之间随机产生100个数
#1. 自定义区间数量和区间范围
 np.histogram(a,bins=5,range=(0,1))#表示0-1内划分成5个区间
#(array([10, 24, 17, 19, 30]), array([0. , 0.2, 0.4, 0.6, 0.8, 1. ]))   #表示在[0,0.2)之间有10个数，以此类推

#2. 自定义分区间
np.histogram(a,bins=[0,0.2,0.5,0.8,1])#自定义统计区间
#(array([10, 33, 27, 30]), array([0. , 0.2, 0.5, 0.8, 1. ]))

读h5文件：

data = h5py.File('MB0002_1_345_ilastik_x383_y71_w500_h500.h5', "r")
data
#<HDF5 file "MB0002_1_345_ilastik_x383_y71_w500_h500.h5" (mode r)>
list(train_dataset)
#['stacked_channels']
data['stacked_channels'][:]

#写h5文件
f = h5py.File('example.h5','w') 
f['stacked_channels'] = data               #将数据写入文件的主键data下面
f.close()

找分位数

dat.quantile(0.9)#对于数据框，默认找到每一列的分位数
dat['HH3'].dat.quantile(0.9)#找到一组数据的分位数

array数组二值化

(array>0.5).astype(np.uint8)

(0.6*np.ones([3,3])>0.5).astype(np.uint8)
array([[0, 0, 0],
       [0, 0, 0],
       [0, 0, 0]], dtype=uint8)

python中[-1]、[:-1]、[::-1]、[2::-1]的使用方法

import numpy as np
a=[1,2,3.4,5]
print(a)
[ 1 2 3 4 5 ]
 
print(a[-1]) ###取最后一个元素
[5]
 
print(a[:-1])  ### 除了最后一个取全部
[ 1 2 3 4 ]
 
print(a[::-1]) ### 取从后向前（相反）的元素
[ 5 4 3 2 1 ]
 
print(a[2::-1]) ### 先将列表翻转，再读取从索引2开始的元素。
[ 3 2 1 ]

np.clip逐个元素将超出指定范围内的数强制变为边界值

强制变为边界值

numpy.clip(a, a_min, a_max, out=None)

x=np.array([[1,2,3,5,6,7,8,9],[1,2,3,5,6,7,8,9]])
np.clip(x,3,8)
#array([[3, 3, 3, 5, 6, 7, 8, 8],
       [3, 3, 3, 5, 6, 7, 8, 8]])

系统命令：

1. 复制文件到另一个文件夹
import shutil
shutil.copy(file, file_dir)

2. 文件重命名
os.rename(old_file,new_file)

3. 0 查看路径下所有文件的全路径：
import glob
import natsort
read_folder = glob.glob("test_folder/*")
3.1 并排序
x_sort = natsort.natsorted(read_folder) 
总结：查看路径下所有文件的全路径并排序：
natsort.natsorted(glob.glob(test_folder))

判断文件夹是否存在，不存在则创建

if not os.path.exists(path):
    os.mkdir(path)

追加文件命令：

1. 往csv文件里追加pandas数据框
pandas_d.to_csv('./static.csv',mode='a',encoding='utf-8’,header=False,index=False)#行名和列名不写进去

pandas_d.to_csv('./static.csv',mode='a',encoding='utf-8’,header=True,index=True)

2. 往txt文件里追加字符串（注意这种方法只能追加字符串文本进去，pandas数据框是无法追加的）
with open(os.path.join(output_path," self_measured_SingleCell_data.csv"), 'a')as f:
    f.write(“这是新增的一行”)#注意：f.write()的参数只接收字符串

Python保留指定位数的小数（能够进行四舍五入）

1.针对单个数字

#1. ‘%.2f’ %f 方法
f = 1.123456

print("%.5f" % f)
print("%.4f" % f)
print("%.3f" % f )
#结果：
#1.12346
#1.1235
#1.123
#这个方法会进行四舍五入

#2. format函数

print(format(1.123456, '.3f'))
print(format(1.123456, '.4f'))
print(format(1.123456, '.5f'))
结果：
1.123
1.1235
1.12346
这个方法会进行四舍五入

2.针对数组

numpy数组四舍五入
numpy.around(nlist, number)
传入一个np的数组和需要保留的位数作为参数

x=[0.         0.01298701 0.02597403 0.03896104 0.05194805 0.06493506
 0.07792208 0.09090909 0.1038961  0.11688312]

np.around(x, 3)   #保存为3位小数
#array([0. , 0.013, 0.026, 0.039, 0.052, 0.065, 0.078, 0.091, 0.104, 0.117])

多线程：

from multiprocessing import Pool
def fun(i):
  ...

res=fun(0)
with Pool(80) as p:
    result = p.map(fun, [i for i in range(1,len(images))])

pd.DataFrame

1.通过字典来构造
pd.DataFrame( {列名1:[行数据列表1],
列名2:[行数据列表2],
列名3:[行数据列表3]})

seaborn画图

画多张seaborn图：你可以用subplot的形式来表达。如下程序段：

f=plt.figure(figsize=(8*3,8*1)
f.add_subplot(2,1,1)
sns.distplot (#你需要显示的图1)
f.add_subplot(2,1,2)
sns.distplot (#你需要显示的图2)
图1和图2 可以以列的形式显示出来。

seaborn画直方图

import seaborn as sns
#sns.distplot参数说明：
#(1) hist=True表示显示直方图，即是否显示柱子

#(2) kde是否显示密度函数线条：
#kde默认True
#不显示kde密度图的话，柱子的高度是频数

#(3) fit：指定一个分布，可以用来和kde核密度函数比较
#fit=stats.gamma,表示拟合伽马分布，可以和核密度函数比较。
1. 统计频次
sns.distplot(props["area"],bins=50,kde=False)
2. 统计频率（kde是和概率密度函数，其实就是对频率的拟合曲线）
# sns.distplot(props["area"],hist=False/True, kde=True)


#再同一张子图画多条曲线并备注（label属性并plt.legend())）
f=plt.figure(figsize=(8*3,8*1))

f.add_subplot(1,3,1)
sns.distplot(pred_props["area"],bins=100,color="purple",hist=False)

f.add_subplot(1,3,2)
sns.distplot(ground_props["area"],bins=100,color="red",hist=False)

f.add_subplot(1,3,3)
sns.distplot(ground_props["area"],bins=100,color="red",hist=False,label="ground truth")
sns.distplot(pred_props["area"],bins=100,color="purple",hist=False,label="prediction")

#画图注（就是每张图里发label属性里写的）
f.legend()

f.show()

Python_matplotlib画图时图例说明(legend)放到图像外侧

用python的matplotlib画图时，往往需要加图例说明。如果不设置任何参数，默认是加到图像的内侧的最佳位置。

import matplotlib.pyplot as plt
import numpy as np
 
x = np.arange(10)
 
fig = plt.figure()
ax = plt.subplot(111)
 
for i in xrange(5):
    ax.plot(x, i * x, label='$y = %ix$' % i)
 
plt.legend()
 
plt.show()

如果需要将该legend移到图像外侧，有多种方法，这里介绍一种。

在plt.legend()函数中加入若干参数：plt.legend(bbox_to_anchor=(num1, num2), loc=num3, borderaxespad=num4)
参数解释在这里：
bbox_to_anchor(num1,num2)表示legend的位置和图像的位置关系，num1表示水平位置，num2表示垂直位置。
（num1=0表示legend位于图像的左侧垂直线）
（这里的其它参数设置：num2=0,num3=3,num4=0）

python脚本里获取位置。

在目录example里运行code/main.py，那么:
（1）./：表示当前脚本被运行的位置即example/（而不是脚本的位置即example/code/）
os.getcwd()等同于./，输出当前脚本的运行环境目录
（2）sys.path[0]会输出脚本的绝对位置即example/code/