常用

数据预处理

axis=1是列

# 统计某一列当中的种类数量
data_namecount=data_new2['小区名字'].value_counts()

分组之后命名列

# 统计某一列当中的种类，并计算某一列平均值
data=data_new2.groupby('小区名字')['单价'].mean().astype(int).reset_index(name='平均单价')

原数据：

处理后的数据：

# 按key1进行分组，求每个分组的平均值
dfk=df.groupby('key1').mean()
dfk

# 为统计后的数据添加列名
# 将series转化为dataframe
data_namecount=data_namecount.reset_index()
data_namecount.columns = ["区域",'数量']

原数据：

改变后数据：

统计某一列数据当中有哪些值/统计某一列当中唯一的数值

value_counts = data_new2['户型'].value_counts()

绘图

绘制热力图

# 数据列中数据有重复的，使用pviot_table绘制，没有使用pviot绘制
flights = data_new2.pivot_table(index='楼层',columns='朝向',values='单价')
sns.heatmap(flights)
plt.yticks(rotation=0)

x坐标垂直，避免重叠

plt.xticks(rotation=90)

数据处理

NumPy

# 对角线为1的数组建立
np.eyes([3,3])

# 建立间隔为5的数组，返回的数组不是列表
np.arange(1，20，5)

#给出区间，最后一个为个数，dtype为数值类型
np.linspace(1,20,5)

# 数组维度的个数，输出结果2，表示二维数组
data.ndim

# 数组的维度，输出结果（3，4），表示3行4列
data.shape

# 数组元素的个数，输出结果12，表示总共有12个元素
data.size

data = np.arange(12).reshape(3, 4)  # 创建一个3行4列的数组

# 创建一个三行四列的全0数组ones\empty
np.zeros((3,4))

# 数据类型转换为float64
data=data.astype(np.float64)

#获取前两行，前两列的元素
arr2d[0:2,0:2] 

# 获取索引为(1,1)和(3,2)的元素,前面一组是行，后面一组是列
demo_arr[[1,3],[1,2]]  

# 返回哪些值是nan
isnan

# 将‘出生年份（年）’中数据里的‘年’字去除，并把数据的数据类型转换为整型
data['出生年份（年）'] = data['出生年份（年）'].str.replace('年', '').astype(int)
data

数组变换

#表示变成两行，列你帮我计算
arr.reshape(2,-1)

#将数组变成一维数组
arr.ravel()

# 数组合并
arr3=np.hstack(())# 横向
vstack#纵向
concatenate

#数组分割
np.hsplit(arr,2)#横向，切成两份
vsplit#纵向

#数组转置
arr.tanspose((1,0))

#可以从数组当中选出数拼接
np.where()
np.where()

#数组判断
np.all()  #数组都满足括号里的条件，就返回true
np.any()  #数组有一个满足括号里的条件，就返回true

#使用tile函数实现数据重复。
arr = np.array([[1,2,3],[4,5,6]])
```
结果：array([[1, 1, 2, 2, 3, 3],
       [4, 4, 5, 5, 6, 6]])
```

#利用np.where()函数输出结果array([1,6,7])，arr_x =[1, 5, 7]，arr_y = [2, 6, 8]
np.where([True, False, True],arr_x,arr_y)

Pandas

series对象

    # series对象
    方法一：
    ser_obj = pd.Series([1, 2, 3, 4, 5],index=['a','b','c','d''e'])
    方法二：
    year_data = {2001: 17.8, 2002: 20.1, 2003: 16.5}
    ser_obj2 = pd.Series(year_data）


    # 获取ser_obj的索引
    ser_obj.index
    # 获取ser_obj的数据
    ser_obj.values

索引操作

如果使用的是位置索引进行切片，则切片结 果是不包含结束位置；如果使用索引名称进 行切片，则切片结果是包含结束位置的

    ser_obj[2: 4] # 使用位置索引进行切片
    ser_obj['c': 'e'] # 使用索引名称进行切片


    # 通过不连续位置索引获取数据集
    ser_obj[[0, 2, 4]

    # 创建布尔型Series对象
    ser_bool = ser_obj > 2
    # 获取结果为True的数据
    ser_obj[ser_bool]
    

DataFrame

特点：有行列索引

    pandas.DataFrame（data = None，index = None，columns =None，dtype = None，copy = False ）
    index：表示行标签。若不设置该参数，则默认会自动创
    建一个从0~N的整数索引

    # 创建数组
    demo_arr = np.array([['a','b','c'],['d','e','f']])
    # 基于数组创建DataFrame对象
    df_obj = pd.DataFrame(demo_arr)


    #指定列索引
    df_obj = pd.DataFrame(demo_arr,
    columns=['No1','No2','No3'])

    #用字典创建
    data = {
    'name':['张三', '李四', '王五', '小明'],
    'sex':['female', 'female', 'male', 'male'],
    'year':[2001, 2001, 2003, 2002],
    'city':['北京', '上海', '广州', '北京']
    }
    df = pd.DataFrame(data)
    print(df)


    结果：（自动生成列索引0-3）
         name sex year city
    0 张三 female 2001 北京
    1 李四 female 2001 上海
    2 王五 male 2003 广州
    3 小明 male 2002 北京



    #为数据指定列名
    df2 = pd.DataFrame(data, columns = ['name','year','sex','city','address'])
    print(df2)

查看DataFrame属性

arr.index

索引

选取行、列

    # 获取行索引
    arr.index
    #列索引
    arr.columns

    # 获取行数据，必须采用切片形式
    方法一：
    arr[:2]
    arr[1:3]
    arr.loc[[1,2]] # 这里的1，2是指定行名称
    
    方法二：
    df5[df5['year']==2001]

    #获取列索引
    arr['列名']
    arr.iloc[['','']] # 括号里同样填名称

选取指定行列

• iloc：可以选择标签、范围、位置
• loc: 基于标签，选取列的时候必须是标签。

# 获取行列(以获取)
dataframe_obj.iloc[0:2:,[1,3]]          # iloc用于列，1，3是列的个数下标（从0开始）    
dataframe_obj.iloc[[0,1], 1::2]       # iloc用于列，前面是选取具体列标签，后面是选取行的范围
dataframe_obj.iloc[0:2:, 1::2]        #前后都为范围
dataframe_obj.iloc[[0,1], [1,3]]
dataframe_obj.iloc[[0,1], ['b','d']]  #报错
                   
dataframe_obj.loc[[0,1],['b','d']]     #loc用于行，q前面是行标签，后面是列标签
dataframe_obj.loc[0:1:,['b','d']]        # 前面是行范围，后面是标签

增加数据

# 增加列
df['score]=[85,78,96,80]
# 这样可以指定新增的列到第一列后面，名字叫NO
df.insert(1,'No',[001002,003,004)

#增加行
datal=fcity:兰州name':李红year':2005sex:'female
df.append(datal,ignore index = True)

删除数据

drop：删除指定索引

# 默认按行（axis=0）
#默认数据删除不修改原数据，需要在原数据删除行列需要设置参数inplace = True
#df.drop(df[df['city']=='广州'].index) 返回的是包含广州的数据列的索引
arr.drop（‘名字’，axis=0）

修改数据

#可以直接索引到具体位置直接赋值
arr.replace({原来的一个：新的一个})

修改列名

# 把no改成number了
df5.rename(columns={'no':'number'},inplace=True)
~~~python

### 算数运算
~~~python
# 执行加法运算，补充缺失值
obj_one.add(obj_two, fill_value = 0)

排序

按索引

sort_index（axis = 0，level = None，ascending = True，inplace = False，kind =' quicksort '，na_position ='last'，sort_remaining = True ）

• axis：轴索引，0表示index（按行），1表示columns（按列）。
• level：若不为None，则对指定索引级别的值进行排序。
• ascending：默认为True表示升序。

按值 sort_values(by,axis=0, ascending=True, inplace=False, kind='quicksort',na_position='last')

• by：表示排序的列（by=2，表示按照列索引为2的进行排序）
• na_position：若设为first，则会将NaN值放在开头；若设为False，则会将NaN值放在最后

数据汇总

    #按行汇总
    df.sum()
    #列
    df.sum(axis=1)

    # describe()
    输出和、最大最小等数据

数据清洗

空值

pandas.isnull/notnull(obj)  判断空值

删除

# 删除所有含有缺失值的行 
df1 = df.dropna() 

# 删除所有含有缺失值的列
df2 = df.dropna(axis=1) 

# 删除所有元素都是缺失值的行和列 
df3 = df.dropna(how='all') 

# 如果某行或列非缺失值数量小于等于1，则删除该行或列 
df4 = df.dropna(thresh=2)

# 删除特定的行 
df5 = df.dropna(subset=['A'])

# 删除某一列
df.drop('B', axis=1, inplace=True)

填充

s1 = s.fillna(0)
# 使用前一个非缺失值进行向前填充 ，就是上头一下补充下头一个（不是左边补右边，这里的上下是方向）
s2 = s.fillna(method='ffill')

# 使用字典填充缺失值 ，可以指定那一列用什么填充
df1 = df.fillna({'A': 0, 'B': 100})

## 填充某一列为均值
mean_value = df['column_name'].mean() df['column_name'].fillna(mean_value, inplace=True)

重复值

#判断是否有重复值（这里是指行，只有行完全相同才会被判断为相同）
df.duplicated()

#删除重复值
df.drop_duplicates()

数据合并

# 内连接就是取相同，外连接就是取两个全部
#axis=1就是合并列，行不变，就是横向堆叠数据
concat(join='inner'/'outer')
例：
pd.concat([df1,df2],join='outer',axis=1)

merge(df1,df2,how='inner'/'outer'/'left'/'right')
# 以主键'key','B'合并数据，方式内连接。
pd.merge(left,right,on=['key','B'],how='inner')

#合并重叠数据
# 用right的数据填充left缺失的部分
right.combine_first(right)

数据重塑

# 将行变成列，行列转换，指定行列
# pivot，index为行索引，columns列索引
df = pd.DataFrame({ 
'A': ['foo', 'foo', 'bar', 'bar', 'foo', 'foo', 'bar', 'bar'], 
'B': ['one', 'one', 'one', 'two', 'two', 'two', 'one', 'two'], 
'C': [1, 2, 3, 4, 5, 6, 7, 8], 'D': [10, 20, 30, 40, 50, 60, 70, 80] }) 
# 使用pivot()方法进行透视 ，
pivoted_df = df.pivot(index='A', columns='B', values='C') print(pivoted_df)

B one two 
A 
bar 7 4 
foo 1 5

数据转化

# 保留小数
round(data,0)
# 保留整数部分
astype(int)

数据标准化

离差标准化，将数据映射到01 库：from sklearn.preproscessing import MinMaxScaler

原理：
def MinMaxScale(data):
    # 编写离差标准化的函数
    data=(data-data.min())/(data.max()-data.min())
    return data

使用

# 导入MinMaxScaler类
from sklearn.preprocessing import MinMaxScaler

# 创建MinMaxScaler对象
scaler = MinMaxScaler()

# 准备数据，将 '身高(cm)' 列的数据提取并转换为NumPy数组，同时进行reshape以确保是一列的形状
data = np.array(df_basketball['身高(cm)']).reshape(-1,1)

# 拟合Scaler对象，计算并存储数据的最小值和最大值
scaler.fit(data)

# 对数据进行缩放，将缩放后的结果存储回DataFrame中的 '身高(cm)' 列
df_basketball['身高(cm)'] = scaler.transform(data)

标准差标准化

from sklearn.preprocessing import StandardScaler
原理：
def StandardScale(data): 
    data = (data-data.mean())/data.std() 
    return data

使用

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
data = np.array(df_basketball['体重(kg)']).reshape(-1,1)
scaler.fit(data)
df_basketball['体重(kg)'] = scaler.transform(data)
df_basketball

鲁棒性

数据离散化

pd.cut(数据，划分节点)

• right：包含右节点就定位true，默认是true
• include_lowest包含左节点
• labels['老人','小孩']给分出来的每一个组增加了一列，赋值了这个labels
• precision保留几位小数

例：分出四组（0，20]，（20，30]···
bins=[0,20,30,40,50]
df=pd.cut(df1,bins)

#离散后计算每个组的组内的个数
pd.value_counts(pd.cut(ages,[0,35,60,100]))

data['年龄段']=pd.cut(data['年龄（岁）'],bins=bins,labels=['高','中','低'])

哑变量处理

将不是数值的数据转换成数值的
#没有大小关系的数据，我们每次通过编码001，010，等每次只激活一个1，使之能够变成可分析数值
data_test = pd.get_dummies(data_new2, columns=['朝向'])
pd.get_dummies(df)

# 有大小关系，指定代数替换
data_ya['楼层'].replace({'低层':1,'中层':2,'高层':3},inplace=True)

数据聚合与分组

分组

df.gruopby(by='某一行')

按行索引分组

• 使用Series对象
• 这样原来的五行就会被分成三组
• 第一行和第四行一组，因为他们都是a
• 如果Series长度和原来的不匹配，那么结果只会让有Series的进行分组

ser_obj = pd.Series(['a','b','c','a','b'])
group_obj = df.groupby(by = ser_obj)
for i in group_obj:
    print(i)

按列分组

ser = {'a':'第一组','b':'第二组','c':'第一组','d':'第二组','e':'第二组'}
num=num_df.groupby(ser,axis=1)
for i in num:
    print(i)

按条件分组

def jue(x):
    if x<5:
        return '第一组'
    else:
        return '第二组'
    
df1=df.groupby(df.mean(axis=0).map(jue))
for i in df1:
    print(i)

使用cut，按范围分组

#right表示包不包含右边,ignore_index=True重置索引
bins=[0,20,30,40]
sort=pd.cut(data,bins,right=True,ignore_index=True)

输出某一组的信息，查看分组信息

datak.get_group("a")

聚合

#分组之后计算平均值
df.groupby('key1').mean()

agg(函数)：agg（[函数，函数，····]）可以定义计算后的列名

data_group.agg([("极差" , range_data_group), ("和" , sum)]

# 每列使用不同的函数聚合分组数据：‘a’列求和，‘b’列求均值，‘c’列求极差
print(datak.agg({'a':'sum','b':'mean','c':range_data_group}))

数组转型：transform

# 将df按照‘key’列进行分组，求每组数据每列的均值，并用transform方法将每行数据填充为所属分组每列的均值
df1=df.groupby('key')
df1.transform('mean')

apply

# 调用apply()方法聚合，求每个分组中的最大值
max_values = datak.apply(lambda x: x.max())