python学习笔记2

最新推荐文章于 2022-11-21 18:37:21 发布

小理想啊

最新推荐文章于 2022-11-21 18:37:21 发布

阅读量188

点赞数

分类专栏： python

本文链接：https://blog.csdn.net/baidu_36536257/article/details/85013567

版权

python 专栏收录该内容

30 篇文章 1 订阅

订阅专栏

1.axis

当数据只有一维时，我们看成一条长的横向量，axis=0；

数据有2维时，看成横&纵，横axis=0，纵axis=1

数据有3维时，看成横&纵&列，横axis=0，纵axis=1，高axis=2

以此类推每增加一位数据其对应的axis+1

但是在计算的时候可以逆序看成高axis=0，行axis=1，列axis=2并且想象成一个串，将所有的数串起来

a=np.array([[[1,2],[3,4]],[[5,6],[7,8]],[[9,10],[11,12]]])

a.shape
Out[16]: (3, 2, 2)
322分别对应高纵横和访问数组元素时的顺序一样a[2,0,0]  和  a[2][0][0]访问的结果都是9
#补充，切片访问也可，[  )
a.ndim
Out[17]: 3

np.sum(a,axis=0)
Out[18]: 
array([[15, 18],
       [21, 24]])

np.sum(a,axis=1)
Out[19]: 
array([[ 4,  6],
       [12, 14],
       [20, 22]])

np.sum(a,axis=2)
Out[20]: 
array([[ 3,  7],
       [11, 15],
       [19, 23]])

b=np.array([[1,2],[3,4]])

np.sum(b,axis=0)
Out[22]: array([4, 6])

#np.cumsum()累加
np.cumsum(c,axis=1)
Out[26]: array([[ 1,  3,  6, 10, 15]], dtype=int32)

2.KNN

#数据集是鸢尾花数据集
import numpy as np
import pandas as pd
import csv
from collections import Counter
# 读入数据
fr=open(r'C:\Users\Lenovo\Desktop\鸢尾花.csv','r')
lines=csv.reader(fr)
data_file=np.array(list(lines))
data=data_file[:,0:-1].astype(float)
label=data_file[:,-1]
fr.close()

def knn(train,la,test,k):
    d1=train-test
    d2=d1**2
    d3=d2.sum(axis=1)
    d4=np.sqrt(d3)
    index=d4.argsort()
    t=Counter(la[index[:k]])
    return t.most_common()[0][0]
    # ('Iris-virginica', 4)这是t.most_common()[0]的结果
    #[('Iris-virginica', 4), ('Iris-versicolor', 1)]这是t.most_common()的结果
   
#手动设置训练集和测试集，共150条数据前148条为训练集，最后两条只是测试了最后一条 
aaa=data[:-2,:]
bbb=data[-2:,:]
l=knn(aaa,label[:-2],bbb[1],5)

3.sklearn --- SVM

from sklearn import svm
from sklearn import datasets
data_=datasets.load_digits()
clf=svm.SVC(gamma=0.001,C=100.)
#训练
clf.fit(data_.data[:-1,:],data_.target[:-1]

#剩最后一组做test，原本的test应该1*64的但是这样取值之后却是（64， ）
#so要用resize()或者reshape()，看具体情况了，对（64， ）转置后还是（64， ）
#所以特别注意只取一行的情况
#q=data_.data[0] （64， ）
#q=data_.data[0：2]  （2，64）
#二维数组【】里面只填一个数字，取整行

#预测
pr=clf.predict(data_.data[-1:])


from sklearn.externals import joblib
#存训练器
joblib.dump(clf,路径)
#取
clf=joblib.load(路径)

4.闭包

作用域也称命名空间，在同一个作用域里面，同名变量始终是同一个值。

i=2
for i in range(10):
    i
print(i)
最后输出的i=9,不是2哦

5.字符、字符集、字符编码

存在各种各样的字符，选取其中一些组成一个字符集，比如ASCII字符集、Unicode字符集等，每种字符集都对应着一种字符编码，即用怎样的数字组合表示一个字符

ASCII：7比特二进制表示，会扩充一位成一个字节进行存储

Unicode：为了多国语言同屏显示，统一、通用的可同时编码绝大多数的编码，UTF-8是对Unicode的一种编码，可根据不同的符号自动选择编码长短，提高编码效率。

6.赋值、深拷贝、浅拷贝

1.浅拷贝：将原对象或原数组的引用直接赋给新对象，新数组，新对象／数组只是原对象的一个引用
2.深拷贝：创建一个新的对象和数组，将原对象的各项属性的“值”（数组的所有元素）拷贝过来，是“值”而不是“引用”
3.为什么要使用深拷贝：我们希望在改变新的数组（对象）的时候，不改变原数组（对象）
4.深拷贝的要求程度：我们在使用深拷贝的时候，一定要弄清楚我们对深拷贝的要求程度：是仅“深”拷贝第一层级的对象属性或数组元素，还是递归拷贝所有层级的对象属性和数组元素？
5.怎么检验深拷贝成功：改变任意一个新对象/数组中的属性/元素, 都不改变原对象/数组

http://www.cnblogs.com/xueli/p/4952063.html

7.Counter计数

from collections import Counter
s=' aabb aa aa bb aaa aa aa aa bncj cc bbb bb bb bb'
l=s.split()
cc=Counter(l)

cc.most_common()
Out[21]: 
[('aa', 5),
 ('bb', 4),
 ('aabb', 1),
 ('aaa', 1),
 ('bncj', 1),
 ('cc', 1),
 ('bbb', 1)]

cc.most_common(1)
Out[22]: [('aa', 5)]

#不用counter版本
cc={}
for i in s.split():
    if i in cc:
        cc[i]+=1
    else:
        cc[i]=1

Out[24]: {'aabb': 1, 'aa': 5, 'bb': 4, 'aaa': 1, 'bncj': 1, 'cc': 1, 'bbb': 1}

8.压缩

常见的压缩格式有：zip/bz2/gz/rar

rar:专为Windows提供的压缩格式，不建议使用，因为很处理工具没有针对rar的内建支持

tar.gz:Linux常见，tar不是压缩格式是打包格式，gz压缩

zip:同时打包和压缩

9.numpy

numpy是科学计算库，科学计算是指类似matlab那样矩阵运算能力，包括多维数组对象、线性代数计算、一个高性能的c/c++语言内部实现。线性代数一个最明显的优势就是用矩阵乘法代替循环极大地提高运算速度。

.T转置

.ndim 秩，数组的维度

.shape

.dytype数组中数据的类型

.size数组中元素的个数

.itemsize一个元素的数据类型占据的内存空间

np.arange(start，end,step) [ )

np.linspace( start, end ,个数）[ ]

.shape(a,b)

.reshape(a,b....)被赋值-1的维度可自动计算，原矩阵不改变，返回新的矩阵

.resize(a,b...)不能赋值-1，原矩阵改变

np.random.random((a,b))

np.ones((a,b))

np.zeros((a,b))

np.empty((a,b))自动创建一个由随机的小数组成的数组

np.linalg.iva(a)矩阵的逆

同形的矩阵+ - * / **都是对应元素相互运算

单个矩阵和数字之间的+ - * / **都是矩阵所有元素和此数相互运算

如果想线代里那种乘法：a.dot(b)

a.sum() a.min() a.max() 默认是对所有元素操作，若（）里加入axis= 就指定轴

a.cumsum() 累积和，若（）里加入axis= 就指定轴

np.empty((3,4))
Out[3]: 
array([[6.23042070e-307, 1.42417221e-306, 1.37961641e-306,
        9.34582628e-307],
       [6.23058028e-307, 8.45593934e-307, 7.56593017e-307,
        8.01097889e-307],
       [2.22523004e-306, 1.37961709e-306, 1.33512376e-306,
        1.69121096e-306]])

a=np.array([1,2,3])
[1, 2, 3]
查看size （3， ）所以说向量都是一列一列的，单他又不是（3，1）
如果想让他变成（3，1）a.resize(3,1)就好了结果是
[[1],
 [2],
 [3]]这是个二维数组
如果想让他变成（1,3）a.resize(3,1)就好了[[1, 2, 3]]这是个二维数组


a+b
Out[8]: array([5, 7, 9])

a*b
Out[9]: array([ 4, 10, 18])

b/a
Out[10]: array([4. , 2.5, 2. ])

a*b
Out[11]: array([ 4, 10, 18])

a.dot(b)
Out[12]: 32

a+2
Out[21]: array([3, 4, 5])

a**b
Out[22]: array([  1,  32, 729], dtype=int32)

2**a
Out[23]: array([2, 4, 8], dtype=int32)


np.eye(4)#对角阵
Out[37]: 
array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])


sort =a.argsort()返回排序后索引
np.argsort(a)
Out[40]: 
array([[0, 1],
       [0, 1]], dtype=int64)