参考电子书：
anaconda安装相关库的命令：
anaconda search -t conda tensorflow#这个tensorflow是你想安装的东西的名字，这个命令会告诉你所需要装的库
anaconda show ---#用---选好你要安装的库之后，这个命令会告诉你安装的库的命令是什么
不知道一个命令怎么用的时候，可以使用print(help(name))来打印出来，建议开两个编译器，一个看help顺便做一些实验
目录
常用函数库
numpy
-
ndarray数据特征
可以把ndarray看做一个矩阵。ndarray.shape可以来看这个数据是几维的，里面有多少个数据，如果是一维的，就直接输出数据量加逗号。
ndarray.dtype可以看这个ndarray中的数据是什么类型的（因为ndarray里面的数据类型要求是一样的，并且他也会自动转化成一样的）
-
ndarray数据读取
这个genfromtxt是从txt文件中读取数据的，分隔符用delimiter来指定，读取数据类型str，后面可以强制转换其它的类型，
-
ndarray数据读取
ndarray也是按照索引来取值的，如果是二维的就要指定行和列了。
-
ndarray数据切片
取一列，用“:”冒号代替所有的列
如果是取两列的话用print(matrix[:, 0:2])这个是取第一列和第二列0,1;
取某些数据都能用切片来完成的
-
数据比较
vector = np.array([5,10,15,20])
vector == 10
array([False, True, False, False])这个会和每一个元素进行比较，然后输出所有结果。就不用写一个for循环然后每个对比这么麻烦啦。
布尔类型当索引，选出true之后，那个true就变成了索引。就能根据那一索引，来取那个索引相关的行，列的数了
-
“&”,“|”
这个“或”，只有单符号。和C的||不一样。
-
用astype转换类型
vector = vector.astype(float)#把ndarray中的数组数据转换成float类型的-
用min,max等求极值
vector.min()#可以用print (help(numpy.array))查看更多信息import numpy as np
matrix = np.array([
[5,10,15],
[20,25,30],
[35,40,45]
])
matrix.sum(axis=1)#axis=1的时候是按照行求和的
#输出
array([ 30, 75, 120])
matrix.sum(axis=0)#axis=0的时候是按照列求和的
#输出
array([60, 75, 90])-
将一维向量，变成矩阵形式
print(np.arange(15))
a = np.arange(15).reshape(3,5)#reshape是将一维改成3维5列的矩阵
#也可以使用，并且下面这个只要写出第一位，另一位列就自动确定了(另外一个列写负数就没问题，如果是正数不符合乘法就不行）
a.shape = (3,5)
a
#输出
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
a.shape
#输出
(3, 5)
a.ndim #ndim是查看维度的方法
#输出
2
a.size #查看元素个数
#输出15
a.dtype #输出dtype('int32')
a.dtype.name #输出'int32'-
将矩阵拉成一维向量
A = np.array([[1,1],
[0,1]] )
print(A.ravel())#将矩阵变成一维向量
#输出[1 1 0 1]-
初始化空矩阵，让矩阵所以值都是0或1
np.zeros(3,4)
#TypeError: data type not understood，这个会报错的，因为传进去的要是一个元组的形式即
np.zeros((3,4))
#输出，可以发现这个时候默认类型是浮点数类型，这个时候指定类型的话看下面
array([[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]])
np.ones((2,3,4), dtype=np.int32)
#输出
array([[[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]],
[[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]]])
#empty可以创建一个没有任何具体值的数组
np.empty((2, 3, 2))
#注意：认为np.empty会返回全0数组的想法是不安全的。很多情况下（如前所示），它返回的都是一些未初始化#的垃圾值-
创造一个数字序列
np.arange(10,30,5)
#输出array([10, 15, 20, 25])
np.arange(0,2,0.3)
#输出array([0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])
-
产生随机数
np.random.random((2,3))
#输出; 返回半开放区间内的随机浮点数[0.0,1.0]
array([[0.06038955, 0.36319797, 0.18147858],
[0.36807729, 0.40904528, 0.18005306]])
#产生的随机数，间隔是平均的
from numpy import pi
np.linspace(0, 2*pi, 10)
#输出
array([0. , 0.6981317 , 1.3962634 , 2.0943951 , 2.7925268 ,
3.4906585 , 4.1887902 , 4.88692191, 5.58505361, 6.28318531])
np.sin(np.linspace(0, 2*pi, 10))
#输出,sin的意思是我们可以对这个序列进行一系列的操作
array([ 0.00000000e+00, 6.42787610e-01, 9.84807753e-01, 8.66025404e-01,
3.42020143e-01, -3.42020143e-01, -8.66025404e-01, -9.84807753e-01,
-6.42787610e-01, -2.44929360e-16])
-
array数据操作
a = np.array([10,20,30,40])
b = np.arange(4)
a -b
#输出array([10, 19, 28, 37])
b-1
#输出array([-1, 0, 1, 2])
a<35
#输出array([ True, True, True, False])
-
矩阵的乘法
A = np.array([[1,1],
[0,1]] )
B = np.array(
[[2,0],
[3,4]])
print(A*B)#这个是把它们两对应位置相乘
#输出
[[2 0]
[0 4]]
print(A.dot(B))#和下面写法一样都是表示矩阵的相乘
#输出
[[5 4]
[3 4]]
print(np.dot(A, B))#
#输出
[[5 4]
[3 4]]对他算内积，还是对他算一个值
-
数学形式 || 矩阵的常用矩阵
B = np.arange(4)
print(np.exp(B))#e的多少次方
print(np.sqrt(B))#对B中每个元素进行开方
#输出
[ 1. 2.71828183 7.3890561 20.08553692]
[0. 1. 1.41421356 1.73205081]
a = np.floor(10*np.random.random((3,4)))#floor是向下取整
a.shape = (6,-1)
print(a)
print(a.T)#取a的转置矩阵
#输出
[[1. 6.]
[8. 4.]
[1. 0.]
[1. 4.]
[0. 8.]
[7. 9.]]
[[1. 8. 1. 1. 0. 7.]
[6. 4. 0. 4. 8. 9.]]
########hstack是横着连接，即把列合并，要求行数相同,vstack是按照行进行合并，要求列数相同
a = np.floor(10*np.random.random((2,2)))
b = np.floor(10*np.random.random((2,3)))
print(np.hstack((a,b)))
#输出
[[9. 8. 7. 7. 5.]
[2. 4. 4. 0. 6.]]
###按照列进行切分
a = np.floor(10*np.random.random((2,12)))
print(np.hsplit(a,3))
#输出，3是表示切成3份，则可以发现有三个array，每个都是2行4列，4列是12/3=4
[array([[0., 5., 9., 6.],
[8., 8., 8., 3.]]), array([[5., 2., 6., 0.],
[6., 9., 1., 7.]]), array([[5., 8., 0., 6.],
[9., 4., 7., 9.]])]
#也可以指定切的位置
a = np.floor(10*np.random.random((2,12)))
print(a)
print(np.hsplit(a,(3,4)))#可以发现在下标3位置前方切了一刀，下标4的位置前方切了一刀，下方按照行#同理
[[2. 3. 8. 0. 1. 9. 1. 1. 0. 6. 6. 2.]
[2. 3. 5. 3. 4. 2. 8. 1. 7. 5. 2. 1.]]
[array([[2., 3., 8.],
[2., 3., 5.]]), array([[0.],
[3.]]), array([[1., 9., 1., 1., 0., 6., 6., 2.],
[4., 2., 8., 1., 7., 5., 2., 1.]])]
#同理下面这个是按照行切分
a = np.floor(10*np.random.random((12,2)))
print(np.vsplit(a,3))
array([[9., 9.],
[8., 6.],
[4., 2.],
[0., 5.]]), array([[0., 8.],
[0., 7.],
[4., 7.],
[4., 1.]]), array([[7., 1.],
[9., 6.],
[8., 7.],
[7., 3.]])]-
ndarray的复制操作
a = np.arange(12)
b = a
print(b is a)
b.shape = 3,-1
print(a.shape)
#输出
True
(3,4)
print(id(a))
print(id(b))
#输出
1779962103888
1779962103888
#可以发现，这个赋值之后，a和b指的是同一个地址，且一个修改的时候，另外一个也跟着修改了。
#浅复制
c = a.view()
print(c is a)
c.shape = 2,6
print(a.shape)
c[0,4] = 1234
print(a)
print(id(a))
print(id(c))
#输出
False
(3, 4)
[[ 0 1 2 3]
[1234 5 6 7]
[ 8 9 10 11]]
80119008
80197712
#这个浅复制，两个变量指的地址是不一样，但是他们的值是公用的。修改一个，另外一个的值也改变了
#单纯复制，互不影响
d = a.copy()
print(d is a)
d[0,0] = 9999
print(d)
print(a)
#输出
False
[[9999 1 2 3]
[1234 5 6 7]
[ 8 9 10 11]]
[[ 0 1 2 3]
[1234 5 6 7]
[ 8 9 10 11]]
#这个复制就是互不影响的了-
排序和索引
import numpy as np
data = np.sin(np.arange(20)).reshape(5,4)
print(data)
ind = data.argmax(axis=0)
print(ind)
data_max = data[ind, range(data.shape[1])]
print(data_max)
print(data.shape[1])
#输出
[[ 0. 0.84147098 0.90929743 0.14112001]
[-0.7568025 -0.95892427 -0.2794155 0.6569866 ]
[ 0.98935825 0.41211849 -0.54402111 -0.99999021]
[-0.53657292 0.42016704 0.99060736 0.65028784]
[-0.28790332 -0.96139749 -0.75098725 0.14987721]]
[2 0 3 1]
[0.98935825 0.84147098 0.99060736 0.6569866 ]
4
#可以发现这里先是通过axis=0标记每一列，然后通过argmax()找出每一列的最大值的下标，然后复制给ind
#然后再把这些下标作为行，通过data.shape[1]（这个的意思是输出列的数量），也就是标记所有列，通过这个
#下标索引再找出最值的方法就是如此
#排序
a = np.array([[4,3,5],[1,2,1]])
print(a)
print('-----------')
b = np.sort(a, axis=1)
print(b)
a.sort(axis=1)
print('-----------')
print(a)
a = np.array([4,3,1,2])
j = np.argsort(a)
print('-----------')
print(j)
print('-----------')
print(a[j])
#输出，且提示这里并没有用b=a，而是用b去接受新产生的ndarray的，所以并没有复制的操作
[[4 3 5]
[1 2 1]]
-----------
[[3 4 5]
[1 1 2]]
-----------
[[3 4 5]
[1 1 2]]
-----------
[2 3 1 0]
-----------
[1 2 3 4]
#可以发现sort是升序排列的，argsort是找出这个ndarray中的从小到大的值的下标，然后可以通过这个下标#作为索引来查看值
-
原array多次复制扩展操作
a = np.arange(10,40,10)
print(a)
b = np.tile(a, (2,2))
print(b)
b = np.tile(a, (3,4))
print(b)
#输出
[10 20 30]
[[10 20 30 10 20 30]
[10 20 30 10 20 30]]
[[10 20 30 10 20 30 10 20 30 10 20 30]
[10 20 30 10 20 30 10 20 30 10 20 30]
[10 20 30 10 20 30 10 20 30 10 20 30]]
#可以发现，tile是把原来的行和列扩大相应的倍数，且是把原ndarray进行复制扩展唯一化以及其它的集合逻辑
In [206]: names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
In [207]: np.unique(names)
Out[207]:
array(['Bob', 'Joe', 'Will'],
dtype='<U4')
In [208]: ints = np.array([3, 3, 3, 2, 2, 1, 1, 4, 4])
In [209]: np.unique(ints)
Out[209]: array([1, 2, 3, 4])
#和纯Python比较
In [210]: sorted(set(names))
Out[210]: ['Bob', 'Joe', 'Will']
#另一个函数np.in1d用于测试一个数组中的值在另一个数组中的成员资格，返回一个布尔型数组：
In [211]: values = np.array([6, 0, 0, 3, 2, 5, 6])
In [212]: np.in1d(values, [2, 3, 6])
Out[212]: array([ True, False, False, True, True, False, True], dtype=bool)
pandas
数据结构
- Series
Series是一种类似于一维数组的对象，它由一组数据（各种NumPy数据类型）以及一组与之相关的数据标签（即索引）组成
创建的时候
import pandas as pd
from pandas import Series, DataFrame
import numpy as np
obj=pd.Series([4, 7, -5, 3])
obj.values #输出array([ 4, 7, -5, 3], dtype=int64)
obj.index #输出RangeIndex(start=0, stop=4, step=1)
obj2 = pd.Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c'])
obj2.index #输出Index(['d', 'b', 'a', 'c'], dtype='object')
obj2[['d','b','c']]
#输出
d 4
b 7
c 3
dtype: int64
obj2[obj2 > 0]
#输出
d 4
b 7
c 3
dtype: int64
np.exp(obj2)
#输出
d 54.598150
b 1096.633158
a 0.006738
c 20.085537
dtype: float64
sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
obj3 = pd.Series(sdata) #这里是直接用一个词典创建一个series
obj3
#输出
Ohio 35000
Oregon 16000
Texas 71000
Utah 5000
dtype: int64
#如果只传入一个字典，则结果Series中的索引就是原字典的键（有序排列）。会自动有序排列
#你可以传入排好序的字典的键以改变顺序：
states = ['California', 'Ohio', 'Oregon', 'Texas']
obj4 = pd.Series(sdata, index=states)
obj4
#输出，NaN表示not a number，即非数字，表示缺失或NA值
California NaN
Ohio 35000.0
Oregon 16000.0
Texas 71000.0
dtype: float64
#obj4作为新series，只会根据index来选择值，就我们可以选择我们想要的index，然后用pd.isnull(obj4)或者pd.notnull(obj4)再或者obj4.isnull()。等方法判断是否为空Series对象本身及其索引都有一个name属性，该属性跟pandas其他的关键功能关系非常密切：
obj4.name = 'population'
obj4.index.name = 'state'
obj4
#输出
state
California NaN
Ohio 35000.0
Oregon 16000.0
Texas 71000.0
Name: population, dtype: float64
#series的索引可以根据通过赋值的方式就地修改：
obj4.index = ['Cali', 'Ohi', 'Oregon', 'Texas']
#输出
state
Cali NaN
Ohi 35000.0
Oregon 16000.0
Texas 71000.0
Name: population, dtype: float64#后记思考
Series是由一系列的索引+值构成的，其能根据索引值去更改DataFrame中的一列。如果是由字典创造的话，字典的key就会转换成索引，字典的value就会转化为值
- DataFrame
DataFrame是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔值等）。DataFrame既有行索引也有列索引，它可以被看做由Series组成的字典（共用同一个索引）。DataFrame中的数据是以一个或多个二维块存放的（而不是列表、字典或别的一维数据结构）
建DataFrame的办法有很多，最常用的一种是直接传入一个由等长列表或NumPy数组组成的字典：
data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],
'year': [2000, 2001, 2002, 2001, 2002, 2003],
'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
frame = pd.DataFrame(data)
frame
#输出
state year pop
0 Ohio 2000 1.5
1 Ohio 2001 1.7
2 Ohio 2002 3.6
3 Nevada 2001 2.4
4 Nevada 2002 2.9
5 Nevada 2003 3.2
frame.head() #默认输出前五行，可以在括号里面指定数量
#如果指定了列序列，则DataFrame的列就会按照指定顺序进行排列：
pd.DataFrame(data, columns=['year', 'state', 'pop'])
#输出
year state pop
0 2000 Ohio 1.5
1 2001 Ohio 1.7
2 2002 Ohio 3.6
3 2001 Nevada 2.4
4 2002 Nevada 2.9
5 2003 Nevada 3.2
frame2 = pd.DataFrame(data, columns=['year', 'state', 'pop', 'debt'],
index=['one', 'two', 'three', 'four',
'five', 'six'])
#输出，如果传入的列在数据中找不到，就会在结果中产生缺失值
year state pop debt
one 2000 Ohio 1.5 NaN
two 2001 Ohio 1.7 NaN
three 2002 Ohio 3.6 NaN
four 2001 Nevada 2.4 NaN
five 2002 Nevada 2.9 NaN
six 2003 Nevada 3.2 NaN
frame2.columns
#输出Index(['year', 'state', 'pop', 'debt'], dtype='object')- 将DataFrame的列获取为一个Series
frame2['state']
#输出
one Ohio
two Ohio
three Ohio
four Nevada
five Nevada
six Nevada
Name: state, dtype: object
frame2.year
one 2000
two 2001
three 2002
four 2001
five 2002
six 2003
Name: year, dtype: int64笔记：IPython提供了类似属性的访问（即frame2.year）和tab补全。 frame2[column]适用于任何列的名，但是frame2.column只有在列名是一个合理的Python变量名时才适用。
import pandas as pd
#一开始的错误
In [8]: pd.read_csv("C:\Users\Administrator\Desktop\vote_result.csv",encoding="
...: utf-8")
File "<ipython-input-8-2def213ebeea>", line 1
pd.read_csv("C:\Users\Administrator\Desktop\vote_result.csv",encoding="utf-8
")
^
SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in positio
n 2-3: truncated \UXXXXXXXX escape原因：
window 读取文件可以用\，但是在字符串中\是被当作转义字符来使用，所以’d:\a.txt’会被转义成’d:\a.txt’这是正确路径，所以不会报错。而‘C:\Users\FrankYuan\Pictures\Camera Roll\WIN_20161010_08_51_57_Pro.jpg ’中经过转义之后可能就找不到路径的资源了，例如\t可能就转义成tab键了。
解决办法：
方式一:转义的方式
'd:\\a.txt'
方式二:显式声明字符串不用转义
'd:r\a.txt'
方式三:使用Linux的路径/
'd:/a.txt'使用第三种即可。看这个老哥的博客解决的：https://blog.csdn.net/u011242657/article/details/64437612
import pandas as pd
info=pd.read_csv("C:/Users/Administrator/Desktop/vote_result.csv",encoding="utf-8")
print(type(info))
print(info.dtypes)
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
