pandas and numpy

最新推荐文章于 2024-10-17 08:00:29 发布

qq_41852655

最新推荐文章于 2024-10-17 08:00:29 发布

阅读量490

点赞数

文章标签： python

本文链接：https://blog.csdn.net/qq_41852655/article/details/124311714

版权

1 numpy
2 pandas

# 数据类型：
# tuple元组，
# list列表，
# dataframe数据框，
# array数组，
# set无序不重复数组，
# dataframegroup 分组数据框，

numpy

创建array

# 数组的属性有
import numpy as np
a.ndim   #维度，
a.shape  #大小，
a.size   #元素数量，
a.dtype  #元素类型

a = np.array([[1,2,3],[2,3,4]],dtype = np.int)
a = np.zeros((3,4),dtype = np.int) #np.empty(),np.ones()
a = np.arange(开始值,终止值,数量).reshape((3,4),dtype=np.int)  # 有序数组
a = np.arange(数量).reshape()   #自然数从0开始
a = np.arange(开始,终止)     #间隔为1
a = np.linspaces(开始，终止，数量).reshape((行数,列数),dtype=np.int)  # 生成线段

a = np.random.randn((行数，列数),dtype=np.int)    # 给定大小的服从标准正态分布的随机数 等价于
a = np.random.standard_normal()   #功能同上但是参数只能有一个，就是数量
a = np.random.random(n)# 生成指定大小的服从0-1的均匀分布
a = np.random.rand(n)   #给定大小的均匀分布的随机数
a = np.random.random_sample()   #均匀分布，参数是数量
a = np.random.choice(list,n)   #随机从list中选择N个
# array,zeros,ones,reshape有dtype属性

import numpy as np
a=np.array([1,2,3])
print(a)

[1 2 3]

array 基础运算

# 加减乘除都是对应元素的运算，次方用**2，而不是^2
b=np.sin(a)   #np.cos(),np.tan()
b=np.arange(4)
b<3  #返回同样大小的布尔类型数组 同样还有>和==
c = a*b   #是对应元素相乘
c_dot = np.dot(a,b) = a.dot(b) = a@b    #是矩阵乘法


# 特殊运算，  有axis属性：0按行操作，1按列操作
a = np.arange(2,14).reshape((3,4))  #
np.mean(a,axis=0)     #返回整个数组的均值,等价于a.mean(),等价于np.average(a),没有a.average(),axis=0是按行列，1表示按行计算
np.sum(a,axis = 0)   #  按照行或者列进行计算,0为行，1为列
np.min()
np.max()
np.median(a,axis=0)   #中位数
np.diff(a,axis=0)     #每一行后一项减前一项，3行4列变为3行3列或者2行4列
np.argmin(a,axis=0)   # 返回每列最小值的位置，没有axis返回整个数组的最小值的位置
np.argmax(a)     #返回整个数组的最大值的位置,没有axis返回整个数组的最大值的位置

# 没有axis属性
np.cumsum(a)   # 累加，没有axis属性
np.sort(a)     # 逐行排序，没有axis属性
np.transpose(a)   #转置，等价于 a.T，3行4列变为4行3列，没有axis属性
np.clip(a,5,9)    #数组中小于5的数变为5，大于9的数变为9，没有axis属性

array索引

# 按照位置进行索引
a[1:3,0:2]  # 提取array的2-4行1-3列的位置元素，等价于a[1][1]
a[1]   #提取第2行的数据,等价于a[1,:]
for x in a:
    print(x)   # 循环a的每一行
for x in a.T:
    print(x)    #循环a的每一列
a.flat   #  flat()是一个迭代器 返回<numpy.flatiter at 0x20812afce30>
a.flatten()   # 迭代出a的每一个值，返回转换成一行的a
for x in a.flat:
    print(x)   #迭代出a的每一个元素，等价于print(a.flatten())

array合并

#横向合并
np.hstack((a,b))  #横向合并，左右合并
np.concatenate((a,b),axis=1)  # 列变，行不变，左右合并
# 纵向合并
np.vstack((a,b,b))   # 列向合并  vertical stack
np.concatenate((a,a,b),axis=0)   # 0纵向合并,1横向合并

# 增加一个维度
a=np.array([1,1,1])  # a.shape 返回(3,)，而不是（1，3）
b=np.array([[1,1,1]])# b.shape 返回(1，3)
a[:,np.newaxis]    #a.shape 返回（3，1），列向增加一个维度
a[np.newaxis,:]   #a.shape 返回（1，3），行向怎加一个维度

array分割和复制

# 横向分割
np.split(a,2,axis=1)  # 1表示列变，行不变，横向分割，按列将a等量分成2块，列数必须为2的倍数，否则报错
np.hsplit(a,2)     # 横向分割
np.array_split(a,3,axis=1) # 按列分成3块，可以进行不等量分割
# 纵向分割
np.split(a,2,axis=0)    # 0表示行变，列不变，纵向分割
np.vsplit(a,3)  #纵向分割 等价于np.split(a,2,axis=0)
np.array_split(a,3,axis=0)


# 复制
b=a   #将一个a的值赋给b，当改变a的值时，b的值发生改变；b改变，a也改变。指针的道理。
b=a.copy()  #深度复制，a和b将没有关系

pandas

pandas基础

numpy和pandas两者关系相当于数组和字典的关系。
pandas的dataframe有三部分：分别是index表示行名，columns表示列名，values表示值。
numpy的array只有一部分：values。
一般两个一起用，dataframe的values用np来处理。

import pandas as pd
import numpy as np

# 创建序列和数据框
s = pd.Series([1,3,6,np.nan,44,1])   #不指定index会自动从0开始排序
dates = pd.date_range('2016-01-01',periods=6)
df = pd.DataFrame(np.random.randn(6,4),index=dates,columns = ['a','b','c','d'])
df2=pd.DataFrame(np.arange(12).reshape(3,4))  # 不指定index和columns直接从0开始自动设定
#也可以用字典创建，键是columns，值是对应列的values，长度不同会按照最长的对齐


# 数据框属性
df.dtypes  #返回每一列的数据类型  是属性，所以不是df.dtypes()
df.index  #返回所有行名
df.columns   #返回所有列名
df.values
df.describe()  #返回数值型数据的均值，方差等
df.T   #转置，列名变行名

# 排序
df.sort_index(axis=0,ascending=False)  #按照行名进行倒序排序
df.sort_values(by='e')    #按照e这一列的值进行排序

数据选择

# 创建一个dataframe
date = pd.date_range('2021-07-01',periods = 6)
df = pd.DataFrame(np.arange(24).reshape((6,4)),index = date,columns = ['a','b','c','d'])

# 选择行列
df.a
df['a']
df[0:3]


# 高级
#按照标签选择 label:loc
df.loc['20210701':,['a','b']]
# 按照位置选择position:iloc
df.iloc[3:5,1:2]
df.iloc[[1,3,5],1:3]
#混合选择：ix
df.ix[:3,['a','c']]  # 新版的pandas不能用
#按照条件筛选
df[df.a>8]   #返回满足条件的所有行和列 


# 选定位置重新赋值
df.iloc[2,2] = 3333
df.loc['2021-07-01','a'] = 3333
df[df.a>4] = 0
df.b[df.a>4] = 0
# 创建新列,直接定义列名 
df.f = np.nan   #现在这个方法不可行
df['e'] = pd.Series([1,2,3,4,5,6],index = pd.data_range('20190701',periods = 6))
# 创建新行用loc
df.loc['index'] = np.arange(5)  

# 删除行或者列
df.drop('行名'，axis = 0)   #删除行
df.drop('列名'，axis = 1)   #删除列
del df.c                    #删除列

#重命名
df['a'].columns=['aa']

import pandas as pd
import numpy as np
date = pd.date_range('2021-07-01',periods = 6)
df = pd.DataFrame(np.arange(24).reshape((6,4)),index = date,columns = ['a','b','c','d'])
print(df)

             a   b   c   d
2021-07-01   0   1   2   3
2021-07-02   4   5   6   7
2021-07-03   8   9  10  11
2021-07-04  12  13  14  15
2021-07-05  16  17  18  19
2021-07-06  20  21  22  23

缺失值处理

# 缺失值处理 
df.dropna(axis=0,how=any)  #how={any,all} 删除掉任何有缺失值的行
df.fillna(value=0)   #缺失值填充为0
df.isnull()   # 返回和数据一样大小的布尔表，
np.any(df.isnull()==True)   #只要表中有一个缺失值就返回True

# 读取数据    存储数据
read_csv       to_csv
read_excel     to_excel
read_html      to_html
read_pickle    to_pickel

data = pd.read_csv('路径和名称')
data.to_csv('路径和名称')

数据合并concatenating和append

df1 = pd.DataFrame(np.ones((3,4))*0,columns = ['a','b','c','d'])
df2 = pd.DataFrame(np.onse((3,4))*1,columns = ['e','b','c','d'])
df3 = pd.DataFrame(np.onse((3,4))*3,columns = ['a','b','c','d'])
#axis =0是竖向合并，1是横向合并，索引是原来的索引，可能会重复,
# ignore_index = True忽略原来索引，构建新索引
# join={inner,outer},默认outer外连接，inner会合并一些相同的数据
# join_axes = [df1.index],横向合并时只按照df1的index来
res = pd.concat([df1,df2,df3],axis = 0，ignore_index = True，join = 'inner') 

# append 竖向合并，可以append dataframe,也可以append series
res2 = df1.append([df2,df3],ignore_index=True)
s1 = pd.Series([1,2,3,4],index = ['a','b','c','d'])
res2 = df1.append(s1,ignore_index = True)

df1 = pd.DataFrame(np.ones((3,4))*0,columns = ['a','b','c','d'])
df2 = pd.DataFrame(np.ones((3,4))*1,columns = ['a','b','c','d'])
df3 = pd.DataFrame(np.ones((3,4))*3,columns = ['a','b','c','d'])
print(df1)
res = pd.concat([df1,df2,df3],axis = 0,ignore_index = True,join = 'inner')
print(res)

     a    b    c    d
0  0.0  0.0  0.0  0.0
1  0.0  0.0  0.0  0.0
2  0.0  0.0  0.0  0.0
     a    b    c    d
0  0.0  0.0  0.0  0.0
1  0.0  0.0  0.0  0.0
2  0.0  0.0  0.0  0.0
3  1.0  1.0  1.0  1.0
4  1.0  1.0  1.0  1.0
5  1.0  1.0  1.0  1.0
6  3.0  3.0  3.0  3.0
7  3.0  3.0  3.0  3.0
8  3.0  3.0  3.0  3.0

merge 功能更加全，join函数和其相似

# res = pd.merge(data1,data2, on=, how=, indecater=, left_index=,right=,suffixes=)
# on='',按照某一列进行内连接
# how={inner,outer,left,right},默认inner
# indicater=True,默认False,形成新的一列，表示合并的时候，哪个有数，还是都有数，也可以指定新列的名称
# indicator='indicator_name',给新的列命名
# left_index=True,right_index = True,默认是False,相当于how参数换到了Index方向
# suffixes=['_a','_b'],相同的列名后加了_a和_b，两个表合并时，有相同的列名，创建新的列名进行区分

# merge by keys.(may be used in database)
left = pd.DataFrame({'key':['k0','k1','k2','k3'],
                     'a':['a0','a1','a2','a3'],
                     'b':['b0','b1','b2','b3']})
right = pd.DataFrame({'key':['k0','k1','k2','k3'],
                      'c':['c0','c1','c2','c3'],
                      'd':['d0','d1','d2','d3']})
res = pd.merge(left,right,on='key',)

# consider two key
left = pd.DataFrame({'key1':['k0','k0','k1','k2'],
                     'key2':['k0','k1','k0','k1'],
                     'a':['a0','a1','a2','a3'],
                     'b':['b0','b1','b2','b3']})
right = pd.DataFrame({'key1':['k0','k1','k1','k2'],
                      'key2':['k0','k0','k0','k0'],
                      'c':['c0','c1','c2','c3'],
                      'd':['d0','d1','d2','d3']})
res = pd.merge(left,right,on=['key1','key2']) # 通过两个特征进行链接，默认内连接inner,how={inner,outer left,right}

# merge by index 这里没有on参数
left=pd.DataFrame({'a':['a0','a1','a2'],
                   'b':['b0','b1','b2']},
                 index=['k0','k1','k2'])
right=pd.DataFrame({'c':['c0','c1','c2'],
                   'd':['d0','d1','d2']},
                 index=['k0','k2','k3'])
res = pd.merge(left,right,left_index=True, right_index=True,how='outer')

# suffixes参数
boys = pd.DataFrame({'k':['k0','k1','k2'],'age':[1,2,3]})
girls = pd.DataFrame({'k':['k0','k0','k3'],'age':[4,5,6]})

res = pd.merge(boys,girls,on='k',suffixes=['_boys','_girls'],how = 'outer',indicator=True)

# dataframe遍历
import pandas as pd 
inp = [{'c1':10, 'c2':100}, {'c1':11, 'c2':110}, {'c1':12, 'c2':123}]
df = pd.DataFrame(inp)
print(df)

# iterrows():将dataframe迭代为（index,series)对
for date, row in df.iterrows():
    print(date)    
for date, row in df.iterrows():
    print(row)
for date, row in df.iterrows():
    print(row['c1'], row['c2'])

0
1
2
c1     10
c2    100
Name: 0, dtype: int64
c1     11
c2    110
Name: 1, dtype: int64
c1     12
c2    123
Name: 2, dtype: int64
10 100
11 110
12 123

# iteritems():将dataframe迭代为（columns,series)对
for date, row in df.iteritems():
    print(date)    
for date, row in df.iteritems():
    print(row)
for date, row in df.iteritems():
    print(row[0], row[1],row[2])

c1
c2
0    10
1    11
2    12
Name: c1, dtype: int64
0    100
1    110
2    123
Name: c2, dtype: int64
10 11 12
100 110 123

# itertuples将数据转化为元组
for row in df.itertuples():
    print(row)
for row in df.itertuples():
    print(getattr(row,'c1'),getattr(row,'c2'))

Pandas(Index=0, c1=10, c2=100)
Pandas(Index=1, c1=11, c2=110)
Pandas(Index=2, c1=12, c2=123)
10 100
11 110
12 123

可视化

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Series
data = pd.Series(np.random.randn(1000),index = np.arange(1000))
data=data.cumsum()
data.plot()  #等价于 plt.plot(x=,y=,)
plt.show()


#DateFrame
data2=pd.DataFrame(np.random.randn(1000,4),
                  index=np.arange(1000),
                  columns=list('ABCD'))
data2=data2.cumsum()
data2.plot()
plt.show()
#其他画法  plot methods:bar,hist,box,kde,area,scatter,plot,hexbin,pie
ax=data2.plot.scatter(x='A',y='B',color='DarkBlue',label='class1')  #等价于plt.scatter(x=,y=)
data2.plot.scatter(x='A',y='C',color='DarkGreen',label='class2',ax=ax)# ax=ax表示两个图画在同一幅上面
plt.show()

在这里插入图片描述

# set(iterable)函数将可迭代对象(包括列表，字符串，字典)转化为无序数组。可以用来去重
# 将列表，字符串转化为去重无序元组
# dataframa只提取columns
# 字典只提取key
for i in set(df):
    print(i)

c1
c2

# 创建字典：
m={'a':1,'b':2}  #常用
m=dict(a=1,b=2)   #常用
m2=dict([('c',3),('d',4)])

# 字典拼接：四种,注意星号
data1=dict(m,**m2)
data2=dict(**m,**m2)
data4=dict(m.items(),**m2)    #第一项是可以迭代的对象
m.update(m2)
data1

{'a': 1, 'b': 2, 'c': 3, 'd': 4}

# map()函数介绍：
import pandas as pd

# 用法1：主要用法：map(function,iterable,...)
# pandas.series.map(func)可以对元素操作，也可以对行或者列进行操作
# 注意事项：map函数是一个惰性函数，返回一个map属性的迭代对象，需要用list将结果展现出来。
a=[1,2,3,4]
b=list(map(str,a))
print(b)


# 用法2：dataframe.map(dict),将字典中的键值对输入到数据框中
m = pd.DataFrame([['a',1,3],['a',2,3],['b',2,3]],columns=['性别','班级','年龄'])
dict={'a':'wa','b':'sai'}
m['new'] = m['性别'].map(dict)
print(m)

['1', '2', '3', '4']
  性别  班级  年龄  new
0  a   1   3   wa
1  a   2   3   wa
2  b   2   3  sai

# apply()函数介绍：
# DataFrame.apply(func, axis=0, raw=False, result_type=None, args=(), **kwargs)
# 是DF属性，对行或者列进行func操作,操作基本单位是：series
df = pd.DataFrame([[4, 9]] * 3, columns=['A', 'B'])
df.apply(lambda x:[1,2],axis=1,result_type='expand')

	0	1
0	1	2
1	1	2
2	1	2

# applymap()函数介绍：
# applymap(func),是DF的属性，对所有的元素应用func操作
df = pd.DataFrame([[4, 9]] * 3, columns=['A', 'B'])
df.applymap(np.sqrt)

	A	B
0	2.0	3.0
1	2.0	3.0
2	2.0	3.0

# groupby()函数介绍：
# groupby()函数出来的是一个字典，
train = pd.read_csv('C:/Users/Administrator/Desktop/黄玉光课程任务/比赛/data/极客_模型题数据集/极客_模型题数据集/data/train.csv')
train1=train[0:1000]
# 用法1：df.groupby().apply()
# 操作基本单位是分组后的dataframe，区别于单独的apply()函数，其操作基本单位是series
# 灵活但是运行效率比agg和transform慢
import time
df1 = train1.groupby('User_Id',as_index=False)['Timestamp'].apply(lambda x:time.localtime(x))


# 用法2：df.groupby().agg(),可以不同的特征进行不同的统计
df2=train1.groupby('User_Id',as_index = False).agg({'Timestamp':'max','Item_Id':'median'})

# 用法3：df.groupby().transform(),和agg的区别，agg每个组返回一个值，transform返回的数据长度和原始数据长度一样，同组的值一样。
# 另外transform的另一个功能是命名新的特征
train1['mean']=train1.groupby('User_Id',as_index=False)['Item_Id'].transform('mean')


# 分组数据提取：可以使用循环提取
for key,values in df1:
    print(key,values)
    print(type(key))   #可以看出来key的种类是分组的值的种类
    print(type(values))    #values的种类是dataframe
    
# 可以使用函数提取每组第几个位置的值：
data=train1.groupby('User_Id')['Item_Id'].apply(lambda x:x.iloc[-1] if len(x)>1 else np.nan)

# sorted()函数和.sort()

# sorted()
# 可以对数值和字符串进行排序，
# reverse参数确定升序或者降序，True降序，False升序
# 原始数据不会改变
# key参数可以灵活的更改排序规则，但是函数必须只能有一个输入
# 无论输入的是什么类型的数据，默认的输出是列表类型
# 不能比较的数据类型不能用这个函数
name=['harry','suzy','al','mark']
name_s=sorted(name)   #按照字符进行排序，有大小写的区别
name_s2=sorted(name,key=len,reverse=True)  # len函数输入参数只有一个，add函数输入参数有两个，所以这儿不能用。
#按照字符串长度降序，key=str.lower字符串都小写

# .sort()
# 是list类的内置方法，只能和list一起用，
# 原始数据回发生不可逆的改变
# reverse同上
# key同上，可以设置函数改变排序规则，比如：key=lambda x:x.split()[2][1]
list=[5,2,6,4]
list.sort()