pandas
创建数据框
# 列表和字典均可传入DataFrame，我这里用的是字典传入：
data=pd.DataFrame({
"id":np.arange(101,111), # np.arange会自动输出范围内的数据，这里会输出101~110的id号。
"date":pd.date_range(start="20200310",periods=10), # 输出日期数据，设置周期为10，注意这里的周期数应该与数据条数相等。
"money":[5,4,65,-10,15,20,35,16,6,20], # 设置一个-10的坑，下面会填（好惨，自己给自己挖坑，幸亏不准备跳~）
"product":['苏打水','可乐','牛肉干','老干妈','菠萝','冰激凌','洗面奶','洋葱','牙膏','薯片'],
"department":['饮料','饮料','零食','调味品','水果',np.nan,'日用品','蔬菜','日用品','零食'], # 再设置一个空值的坑
"origin":['China',' China','America','China','Thailand','China','america','China','China','Japan'] # 再再设置一个america的坑
})
data
数据写入和读取
data.to_csv("shopping.csv",index=False) # index=False表示不加索引，否则会多一行索引
data=pd.read_csv("shopping.csv")
数据查看
data.shape # 行数列数
data.dtypes # 所有列的数据类型
data['id'].dtype # 某一列的数据类型
data.ndim # 数据维度
data.index # 行索引
data.columns # 列索引
data.values # 对象值
数据集整体情况查询
data.head() # 显示头部几行（默认5行）
data.tail() # 显示末尾几行（默认5行）
data.info() # 数据集相关信息概览：索引情况、列数据类型、非空值、内存使用情况
data.describe() # 快速综合统计结果
数据清洗
空值处理,填补
pandas.DataFrame.fillna（value = None，method = None，inplace = False）
- value：用于填充的值，可以是具体值、字典和数组，不能是列表；
- method：填充方法，有 ffill 和 bfill 等；（ffill填充上一个值，bfill填充下一个值）.
- inplace默认无False，如果为True，则将修改此对象上的所有其他视图。
大小写转换
data['origin'].str.title() # 将首字母大写
data['origin'].str.capitalize() # 将首字母大写
data['origin'].str.upper() # 全部大写
data['origin'].str.lower() # 全部小写
数据替换
data['origin'].replace("america","America",inplace=True) # 将第一个值替换为第二个值，inplace默认为False
data['origin']
data['money'].replace(-10,np.nan,inplace=True) # 将负值替换为空值
data['money'].replace(np.nan,data['money'].mean(),inplace=True) # 将空值替换为均值
data['money']
数据删除(方法1)
data1 = data[data.origin != 'American'] #去掉origin为American的行
data1
data2=data[(data != 'Japan').all(1)] #去掉所有包含Japan的行 不等于Japan的行为真，则返回
data2
数据删除（方法2）
data['origin'].drop_duplicates() # 默认删除后面出现的重复值，即保留第一次出现的重复值
data['origin'].drop_duplicates(keep='last') # 删除前面出现的重复值，即保留最后一次出现的重复值
数据格式转换
data['id'].astype('str') # 将id列的类型转换为字符串类型。
常见数据类型
python模块pandas和numpy的所有基础函数
更改列名称
data.rename(columns={'id':'ID', 'origin':'产地'})# 将id列改为ID，将origin改为产地。
将列名做成列表
df.columns.tolist()
排序替换
df.sort_values("str",inplace=True,ascending=False)：将str一列按照降序排列，且得到的数据替换原数据。inplace表示是否用排序后的数据替代原数据，默认为False，也就是不替换。ascending表示排序的顺序，默认为True，也就是按照升序排列。
分组求平均
df.pivot_table(index="a",values="b",aggfunc=np.mean)：这是一个很重要的函数，将b求平均值，按照a的类别进行分类，第三个参数默认为求平均值。
apply的用法
df.apply()：这是在pandas中的自定义函数的使用方法，括号中传入函数名。
python的pandas读取矩阵后，
df['max_idx'] = df.idxmax(axis=1) #求一行的最大值对应的索引（每行最大值的列名）
df['max_val']= df.max(axis=1) #取出该最大值 （每行的最大值）
a = df.drop(columns=['max_idx','max_val']) 去掉数据框的特定列
a['min_idx'] = a.idxmin(axis=1) 最小值的索引
a['min_val'] = a.min(axis=1) 最小值
python常用的高阶函数
map
map(function,iterable,...)
第一个参数，是函数
第二个参数，是可迭代对象（列表、字符串等）
map返回的是对可迭代对象里的每个元素进行函数运算的结果
def fun(x):
return x*3
l=[0,1,2,3,4,5]
l_m=map(fun,l)
print(list(l_m))
这里需要注意的是 ，map()直接返回的是一个<map at 0x205ef31fb00>的对象
我们需要利用list函数将它里边的元素释放出来。
也可以直接使用lambda
print(list(map(lambda x:x*3,l)))
zip函数
zip()将多个可迭代对象的元素组合成为为一个元组序列
l = ['a', 'b', 'c']
n = [1, 2, 3]
print(list(zip(l,n)))
[('a', 1), ('b', 2), ('c', 3)]
filter函数
filter（function，sequence）
第一个参数是函数，第二个参数是可迭代对象
最后返回的是，可迭代对象里满足函数要求的元素。
因此也称之为过滤。
long = [1,2,3,4,5]
list(filter(lambda x:x%2==0,long)) # 找出偶数。
# filter函数返回的是迭代器，所以需要用list转换,进行释放元素。
# 输出：
[2, 4]
apply函数
DataFrame.apply(func, axis=0, broadcast=False, raw=False, reduce=None, args=(), kwds)
apply函数是pandas.DataFrame里的方法
例如
kk是pd.DataFrame的类型的数据
0
0 0a
1 1b
2 2c
3 3d
4 4e
kk["new"]=kk[0].apply(lambda x:x[-1] )
kk
0 new
0 0a a
1 1b b
2 2c c
3 3d d
4 4e e
sort_values
DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')
参数说明
axis:{0 or ‘index’, 1 or ‘columns’}
#default 0，默认按照索引排序，即纵向排序，如果为1，则是横向排序
by:str or list of str
#如果axis=0，那么by="列名"；如果axis=1，那么by="行名"；
ascending: #布尔型，True则升序，可以是[True,False]，即第一字段升序，第二个降序
inplace: #布尔型，是否用排序后的数据框替换现有的数据框
kind:排序方法， #{‘quicksort’, ‘mergesort’, ‘heapsort’}, default ‘quicksort’。
na_position : #{‘first’, ‘last’}, default ‘last’，默认缺失值排在最后面
import pandas as pd
import numpy as np
a = np.random.randint(low=0,high=100,size=(11,2))
data = pd.DataFrame(a)
data.apply(lambda x:x*10)
[*data.columns]=["z1",'z2']
sort函数
sort(key,reverse)
这个是列表的方法
key：是排序的条件
reverse：表示是否逆序，默认是从小到大，默认为False
x = ['mmm', 'mm', 'mm', 'm' ]
x.sort(key = len)
print (x)
# out： ['m', 'mm', 'mm', 'mmm']
y = [3, 2, 8 ,0 , 1]
y.sort(reverse = True)
print (y)
#[8, 3, 2, 1, 0]
#True为逆序排列，False为正序排列
Enumerate函数
enumerate 是一个会返回元组迭代器的内置函数，这些元组包含列表的索引和值。当你需要在循环中获取可迭代对象的每个元素及其索引时，将经常用到该函数。
letters = ['a', 'b', 'c', 'd', 'e']
for i, letter in enumerate(letters):
print(i, letter)
0 a
1 b
2 c
3 d
4 e
numpy常用函数
矩阵的合并
矩阵的合并可以通过numpy中的hstack方法和vstack方法实现
import numpy as np
a1 = np.array([[1,2],[3,4]])
a2 = np.array([[5,6],[7,8]])
#!注意 参数传入时要以列表list或元组tuple的形式传入
print(np.hstack([a1,a2]))
#横向合并，返回结果如下
[[1 2 5 6]
[3 4 7 8]]
print(np.vstack((a1,a2)))
#纵向合并，返回结果如下
[[1 2]
[3 4]
[5 6]
[7 8]]
矩阵的合并也可以通过concatenatef方法。
np.concatenate( (a1,a2), axis=0 ) 等价于 np.vstack( (a1,a2) )
np.concatenate( (a1,a2), axis=1 ) 等价于 np.hstack( (a1,a2) )
通过函数创建矩阵
numpy模块中自带了一些创建ndarray对象的函数，可以很方便的创建常用的或有规律的矩阵。
import numpy as np
a = np.arange(10) # 默认从0开始到10（不包括10），步长为1
print(a) # 返回 [0 1 2 3 4 5 6 7 8 9]
a1 = np.arange(5,10) # 从5开始到10（不包括10），步长为1
print(a1) # 返回 [5 6 7 8 9]
a2 = np.arange(5,20,2) # 从5开始到20（不包括20），步长为2
print(a2) # 返回 [ 5 7 9 11 13 15 17 19]
linspace函数
linspace()和matlab的linspace很类似，用于创建指定数量等间隔的序列，实际生成一个等差数列。
import numpy as np
a = np.linspace(0,10,7) # 生成首位是0，末位是10，含7个数的等差数列
print(a)
# 结果
[ 0. 1.66666667 3.33333333 5. 6.66666667 8.33333333 10. ]
logspace
linspace用于生成等差数列，而logspace用于生成等比数列。
下面的例子用于生成首位是100，末位是102，含5个数的等比数列。
import numpy as np
a = np.logspace(0,2,5)
print(a)
# 结果
[ 1. 3.16227766 10. 31.6227766 100. ]
ones、zeros、eye、empty
- ones创建全1矩阵
- zeros创建全0矩阵
- eye创建单位矩阵
- empty创建空矩阵（实际有值）
import numpy as np
a_ones = np.ones((3,4)) # 创建3*4的全1矩阵
print(a_ones)
# 结果
[[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]]
a_zeros = np.zeros((3,4)) # 创建3*4的全0矩阵
print(a_zeros)
# 结果
[[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]]
a_eye = np.eye(3) # 创建3阶单位矩阵
print(a_eye)
# 结果
[ 1. 0. 0.]
[ 0. 1. 0.]
[ 0. 0. 1.]]
a_empty = np.empty((3,4)) # 创建3*4的空矩阵
print(a_empty)
# 结果
[[ 1.78006111e-306 -3.13259416e-294 4.71524461e-309 1.94927842e+289]
[ 2.10230387e-309 5.42870216e+294 6.73606381e-310 3.82265219e-297]
[ 6.24242356e-309 1.07034394e-296 2.12687797e+183 6.88703165e-315]]
fromstring
fromstring()方法可以将字符串转化成ndarray对象，需要将字符串数字化时这个方法比较有用，可以获得字符串的ascii码序列。
a = "abcdef"
b = np.fromstring(a,dtype=np.int8) # 因为一个字符为8为，所以指定dtype为np.int8
print(b) # 返回 [ 97 98 99 100 101 102]
常用矩阵函数
矩阵的转置
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.transpose())
# 结果
[[1 4]
[2 5]
[3 6]]
矩阵的转置还有更简单的方法，就是a.T
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.T)
# 结果
[[1 4]
[2 5]
[3 6]]
矩阵的最大值，最小值
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.max()) #获取整个矩阵的最大值 结果： 6
print(a.min()) #结果：1
# 可以指定关键字参数axis来获得行最大（小）值或列最大（小）值
# axis=0 行方向最大（小）值，即获得每列的最大（小）值
# axis=1 列方向最大（小）值，即获得每行的最大（小）值
# 例如
print(a.max(axis=0))
# 结果为 [4 5 6]
print(a.max(axis=1))
# 结果为 [3 6]
# 要想获得最大最小值元素所在的位置，可以通过argmax函数来获得
print(a.argmax(axis=1))
# 结果为 [2 2]
平均值
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.mean()) #结果为： 3.5
# 同样地，可以通过关键字axis参数指定沿哪个方向获取平均值
print(a.mean(axis=0)) # 结果 [ 2.5 3.5 4.5]
print(a.mean(axis=1)) # 结果 [ 2. 5.]
方差
方差的函数为var(),方差函数var()相当于函数mean(abs(x - x.mean())**2),其中x为矩阵。
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.var()) # 结果 2.91666666667
print(a.var(axis=0)) # 结果 [ 2.25 2.25 2.25]
print(a.var(axis=1)) # 结果 [ 0.66666667 0.66666667]
标准差
标准差的函数为std()。
std()相当于sqrt(mean(abs(x - x.mean())**2))，或相当于sqrt(x.var())。
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.std()) # 结果 1.70782512766
print(a.std(axis=0)) # 结果 [ 1.5 1.5 1.5]
print(a.std(axis=1)) # 结果 [ 0.81649658 0.81649658]
中值
import numpy as np
x = np.array([[1,2,3],[4,5,6]])
print(np.median(x)) # 对所有数取中值
# 结果
3.5
print(np.median(x,axis=0)) # 沿第一维方向取中值
# 结果
[ 2.5 3.5 4.5]
print(np.median(x,axis=1)) # 沿第二维方向取中值
# 结果
[ 2. 5.]
累积和
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.cumsum()) # 对整个矩阵求累积和
# 结果 [ 1 3 6 10 15 21]
print(a.cumsum(axis=0)) # 对行方向求累积和
# 结果
[[1 2 3]
[5 7 9]]
print(a.cumsum(axis=1)) # 对列方向求累积和
# 结果
[[ 1 3 6]
[ 4 9 15]]
数组的类型变换
数据类型的转换 ：a.astype(new_type) : eg, a.astype (np.float)
数组向列表的转换： a.tolist()
数组的索引和切片
数组的运算
np.abs(a) np.fabs(a) : 取各元素的绝对值
np.sqrt(a) : 计算各元素的平方根
np.square(a): 计算各元素的平方
np.log(a) np.log10(a) np.log2(a) : 计算各元素的自然对数、10、2为底的对数
np.ceil(a) np.floor(a) : 计算各元素的ceiling 值， floor值（ceiling向上取整，floor向下取整）
np.rint(a) : 各元素 四舍五入
np.modf(a) : 将数组各元素的小数和整数部分以两个独立数组形式返回
np.exp(a) : 计算各元素的指数值
np.sign(a) : 计算各元素的符号值 1（+），0，-1（-）
np.maximum(a, b) np.fmax() : 比较（或者计算）元素级的最大值
np.minimum(a, b) np.fmin() : 取最小值
np.mod(a, b) : 元素级的模运算
np.copysign(a, b) : 将b中各元素的符号赋值给数组a的对应元素
分位值
import numpy as np
a1 = np.array([[10,0,9],[8,9,9],[9,10,9]]) #建立二维数组
np.percentile(a1,50,axis=0)
增加和删除行（列）
函数delete(arr, obj, axis=None)，arr为数组对象，obj为下标切片、下标标量、下标列表、下标整数数组，axis=None默认值，删除后的新数组为一维数组，在axis=1的情况下，保留元素按照行方向形成新数组；在axis=0的情况下，保留元素按照列方向形成新数组。
d = np.arange(9).reshape((3,3))
np.delete(d,np.s_[:2],axis=1) #在行方法上，删除d数组的1,2列
d = np.arange(9).reshape((3,3))
np.delete(d,np.s_[:2],axis=0) #在列方向上，删除d数组的1,2行
5011
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
