备案控制台
探索云世界
开发者社区 大数据 文章 正文

Python pandas数据分析中常用方法

2018-02-02 12666
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

读取写入文件

官方IO 
读取 写入 
read_csv 　　　　　　to_csv 
read_excel 　　　　　to_excel 
read_hdf 　　　　　　to_hdf 
read_sql 　　　　　　to_sql 
read_json　　　　　　to_json 
read_msgpack (experimental) 　　to_msgpack (experimental) 
read_html 　　　　　　to_html 
read_gbq (experimental) 　　　　to_gbq (experimental) 
read_stata 　　　　　 to_stata 
read_sas 
read_clipboard 　　　to_clipboard 
read_pickle 　　　　　to_pickle／／速度比csv快 
读取CSV文件：

pd.read_csv('foo.csv')   //读取CSV
# header参数指定从第几行开始生成，且将header行的数据作为列的name（键），header行以前的数据将不会处理。取值为None表示csv中行不做为列的name（键），取值为0表示将csv的第0行作为列的name。| 如果没有传递参数names那么header默认为0；如果传递参数names，那么header默认为None。
  • 1
  • 2

存储为csv文件：

submission = pd.DataFrame({ 'PassengerId': test_df['PassengerId'],'Survived': predictions })
submission.to_csv("submission.csv", index=False)
# index参数是否写入行names键
  • 1
  • 2
  • 3

选择数据

官方选择教程 
官方多index选择教程

[]:

df['A']  通过列name（键）选择列
df[['A', 'B']]  通过list选择列
df[0:3]  通过隐含的序列（index所在行值）选择行
df['20130102':'20130104']   通过行index（键）选择行
dataset[(dataset['Sex'] == i) & (dataset['Pclass'] == j+1)]['Age']        #布尔运算选择数据，以其他列为条件筛选数据，注意做布尔运算时最好将每个运算用括号括起来，像以下这种就会容易出问题：dataset[dataset['TARGET'].notnull() & dataset['need_pre']!=1 ]
  • 1
  • 2
  • 3
  • 4
  • 5

loc:

dataset.loc[ dataset.Age.isnull(),'BB']  //age不是null的数据中选择BB列
train_df.loc[:, ['Age*Class', 'Age', 'Pclass']].head(10)
dataset.loc[ EID,'Age']  //根据index（注意这个是index的取值，而不是index所在行）选取列Age单元数据
  • 1
  • 2
  • 3

iloc: 
iloc是选择DataFrame第几行第几列（类似于数组，数值下标从0开始）

df.iloc[3:5,0:2]
df.iloc[1:3,:]
df.iat[1,1]
  • 1
  • 2
  • 3

循环行数据：

for i, row in colTypes.iterrows():
# i为dataFrame的index，row为一行数据
  • 1
  • 2

计算数据

重复数值个数统计：

Series.value_counts() //统计重复重现的数据的个数。返回以数据作为key，以重复个数为value的对象。
X[c].value_counts().index[0] //最多的那个数
  • 1
  • 2

中值计算：

Series.median() //计算某个轴的中值
  • 1

计算均值和偏差：

age_mean = guess_df.mean()
# 计算均值
age_std = guess_df.std()
# 计算标准差
  • 1
  • 2
  • 3
  • 4

计算众值：

# freq_port = train_df.Embarked.dropna().mode()[0]
# mode返回出现最多的数据，可能出现多个，因此返回数组
  • 1
  • 2

其他： 
方法　　 　　　　　　　　　说明 
count　　　　　　　　　 非NA值得数量 
describe　　 　　　　　针对series或各dataframe列计算汇总统计 
min max 　　　　　　　计算最小值和最大值 
argmin，argmax 　　　计算能够获取到最小值和最大值的索引位置（整数） 
idxmin , idxmax 　　　　计算获取到最小值和最大值索引值

df.idxmax()   //按列
df.idxmax(axis=1)  //按行
  • 1
  • 2

quantile 　　　　　　　计算样本的分位数（0到1） 
sum 　　　　　　　　　　值得总和

df.sum()   //按列求和
df.sum(axis=1)  //按行求和
  • 1
  • 2

mean 　　　　　　　　　值得平均数

df.mean(axis=1) //按行求和，注意，如果存在Nan值会忽略，如果整个都为nan，则取nan
df.mean(axis=1, skipna = False) //禁止忽略nan值
  • 1
  • 2

median 　　　　　　　　值的算数中位数 
mad 　　　　　　　　　　根据平均值计算平均绝对离差 
var 　　　　　　　　　　　样本值得方差 
std 　　　　　　　　　　　样本值得标准差 
skew 　　　　　　　　　样本值得偏度（三阶矩） 
kurt 　　　　　　　　　　样本值的峰度（四阶矩） 
cumsum 　　　　　　　　样本值的累计和，累计累积，也就是说从开始位置到当前位置的总和

df.cumsum()   //按列求累积和，如果当前位置为nan，直接返回nan，如果不是，而前面某个位置是，则忽略前面位置的nan
df.cumsum(axis=1)  //按行求累积和
  • 1
  • 2

cummin,cummax 　　　样本值的累计最大值和累计最小值 
cumprod 　　　　　　　　　样本值的累计积 
diff 　　　　　　　　　　计算一阶差分（对时间序列很有用） 
pct_change 　　　　　　　　计算百分数变化 
isin 　　　　　　　　　　判断series，dataframe数据是否在另一个变量其中

缺失值处理

方法　　　　　　 说明 
count 　　　　　非NA值得数量 
dropna 　　　　　根据各标签的值中是否存在缺失数据对轴标签进行过滤，可通过阈值调节对缺失值得容忍度 
fillna 　　　　　用指定值或插值方法（如ffill或bfill）填充确实数据 
isnull 　　　　　返回一个含有布尔值的对象，这些布尔值表示哪些值是缺失值/NA，该对象的类型与源类型一样 
notnull 　　　　　isnull的否定式

存在三种方法来完善连续数字特征： 
1、简单方式：在中值和标准偏差间产生一个随机数 
2、准确方式：通过相关特征猜测缺失值 
3、联合1、2基于特征组合，在中值和偏差间产生一个随机数 
缺失值填充：

dataset['E'] = dataset['E'].fillna(f)

# 对缺失值处进行填充0，参数value可为 scalar, dict, Series, 或者DataFrame，但不能是list；Series应用于每个index，DataFrame应用于每个列。如果不在dict/Series/DataFrame中，将不会被填充

清除空值：.dropna()

dataset.loc[ (dataset.Age.isnull()) & (dataset.Sex == i) & (dataset.Pclass == j+1),'Age'] = guess_ages[i,j]
# 多条件填充
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

方法1：

for dataset in full_data:
    age_avg        = dataset['Age'].mean()
    age_std        = dataset['Age'].std()
    age_null_count = dataset['Age'].isnull().sum()

    age_null_random_list = np.random.randint(age_avg - age_std, age_avg + age_std, size=age_null_count)
    dataset['Age'][np.isnan(dataset['Age'])] = age_null_random_list
    dataset['Age'] = dataset['Age'].astype(int)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

方法3：

# 生成一个空数组来存储Age的猜测值：
        # guess_ages = np.zeros((2,3))
        # guess_ages
# 遍历Sex和Pclass来猜测Age猜测值：
        # for dataset in combine:
        #     for i in range(0, 2):
        #         for j in range(0, 3):
        #             guess_df = dataset[(dataset['Sex'] == i) & (dataset['Pclass'] == j+1)]['Age'].dropna()
        # 根据相关特征值Pclass，Sex选取数据并除空值
                #     age_mean = guess_df.mean()
                # 计算均值
                #     age_std = guess_df.std()
                # 计算标准差
                #     age_guess = rnd.uniform(age_mean - age_std, age_mean + age_std)
                # 产生随机值
                #     age_guess = guess_df.median()
                # 或计算中值
                #     Convert random age float to nearest .5 age
                #     guess_ages[i,j] = int( age_guess/0.5 + 0.5 ) * 0.5   
for i in range(0, 2):
      for j in range(0, 3):
            dataset.loc[ (dataset.Age.isnull()) & (dataset.Sex == i) & (dataset.Pclass == j+1),'Age'] = guess_ages[i,j]
            # 赋值
            dataset['Age'] = dataset['Age'].astype(int)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

填充众值：

# freq_port = train_df.Embarked.dropna().mode()[0]
# mode返回出现最多的数据，可能出现多个，因此返回数组
# 填充：
# for dataset in combine:
#     dataset['E'] = dataset['E'].fillna(freq_port)
  • 1
  • 2
  • 3
  • 4
  • 5

查看数据

查看键和值：

train_data = pd.read_csv('train.csv')
# 查看数据的行键index（index.values）、列键columns(columns.values)、值values
print(train_data.index)
print(train_data.index.values)
  • 1
  • 2
  • 3
  • 4

查看数据统计：

train_data.info()
# 主要统计有各列键非空数据数量（便于后面填充空值）、各列数据类型、及数据类型统计（一般object表示字符串对象数量）。

print(train_data.describe())
# 默认统计数值型数据每列数据平均值，标准差，最大值，最小值，25%，50%，75%比例。
print(train_data.describe(include=['O']))
# 统计字符串型数据的总数，取不同值数量，频率最高的取值。其中include参数是结果数据类型白名单，O代表object类型，可用info中输出类型筛选。

print("Before", train_data.shape)
# 数据行数和列数
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

查看部分数据内容：

# 查看前五条和后五条数据，大致了解数据内容
print(train_data.head())
print(train_data.tail())
# 选取三条数据
data_train.sample(3)
  • 1
  • 2
  • 3
  • 4
  • 5

排序：

features.sort_values(by='EID', ascending=True)
features.sort_index(axis=1, ascending=True)
  • 1
  • 2
python原生排序list和dict
sorted([wifi for wifi in line[5]], key=lambda x:int(x[1]), reverse=True)[:5]  // 默认从小到大
sorted(dict.items(),key=lambda x:x[1],reverse=True)[0][0]
sorted(L, cmp=lambda x,y:cmp(x[1],y[1])) //x，y代表前后两个元素
  • 1
  • 2
  • 3
  • 4

输出格式控制：

pandas dataframe数据全部输出，数据太多也不用省略号表示。
pd.set_option('display.max_columns',None)
或者
with option_context('display.max_rows', 10, 'display.max_columns', 5):
  • 1
  • 2
  • 3
  • 4

分析数据相关性

groupby数据：

train_data[['Pclass','Survived']].groupby(['Pclass'], as_index=False).mean().sort_values(by='Survived',ascending=False)
# 选取数据中两列，以Pclass分组，计算每个分组内平均值，最后根据Survived平均值降序排列。其中as_index=False不以Pclass做结果行键。
  • 1
  • 2

分组后，可以通过size()分组内数据数量,sum()分组内数据和,count()分组内：

df = DataFrame({'key1':['a','a','b','b','a'],'key2':['one','two','one','two','one'],'data1':np.random.randn(5),'data2':np.random.randn(5)})  
df  
#[Out]#       data1     data2 key1 key2  
#[Out]# 0  0.439801  1.582861    a  one  
#[Out]# 1 -1.388267 -0.603653    a  two  
#[Out]# 2 -0.514400 -0.826736    b  one  
#[Out]# 3 -1.487224 -0.192404    b  two  
#[Out]# 4  2.169966  0.074715    a  one
group2 = df.groupby(['key1','key2'])
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
group2.size()   
#[Out]# key1  key2  
#[Out]# a     one     2     //注意size返回的对象2，1，1，1没有列键
#[Out]#       two     1  
#[Out]# b     one     1  
#[Out]#       two     1  
#[Out]# dtype: int64  
group2.count()  
#[Out]#            data1  data2    
#[Out]# key1 key2                
#[Out]# a    one       2      2    //注意count返回的对象2，1，1，1有列键data1，data2
#[Out]#      two       1      1  
#[Out]# b    one       1      1  
#[Out]#      two       1      1
group2.sum()
                        data1   data2
key1    key2        
a       one           0.222249  1.188488
        two           0.627373  0.406101
b       one          -2.527461  0.267850
        two          -0.594238  -0.137129
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
自定义组内统计函数：
BRA_CLOSE_DECADE = branch2[['EID', 'B_ENDYEAR']].groupby('EID').agg(lambda df:df[df['B_ENDYEAR']>2007].count())
  • 1
  • 2

crosstab数据： 
这里写图片描述

pd.crosstab(train_data['Title'], train_data['Sex'])
# 分别以Title（Mrs，Mr等）为行，Sex（female，male）为例，计算出现频数。观察二者的对应关系。
  • 1
  • 2

Pivot数据：

impute_grps = data.pivot_table(values=["LoanAmount"], index=["Gender","Married","Self_Employed"], aggfunc=np.mean)
  • 1

这里写图片描述 
COV()，CORR()计算 
协方差cov()：表示线性相关的方向，取值正无穷到负无穷。协方差为正值，说明一个变量变大另一个变量也变大；协方差取负值，说明一个变量变大另一个变量变小，取0说明两个变量咩有相关关系。 
相关系数corr()：不仅表示线性相关的方向，还表示线性相关的程度，取值[-1,1]。也就是说，相关系数为正值，说明一个变量变大另一个变量也变大；取负值说明一个变量变大另一个变量变小，取0说明两个变量没有相关关系。同时，相关系数的绝对值越接近1，线性关系越显著。 
corrwith()：计算DataFrame的列（axis=0，默认）或行（axis=1)跟另外一个Series或DataFrame之间的相关系数。 
这里写图片描述 
这里写图片描述

删除数据 

print(df.drop(0,axis=0)) #删除行，注意原数据不变，返回一个新数据
print(df.drop(['col1'],axis=1,inplace=True)) #删除列，inplace=True表示直接在原数据修改而不新建对象
  • 1
  • 2

合并数据

concat: 
相同字段的表首尾相接

result = pd.concat([df1, df2, df3], keys=['x', 'y', 'z']) //keys给合并的表来源加一个辨识号
  • 1

注意多张表concat后可能会出现index重复情况，这是最好使用reset_index重新组织下index。

result.reset_index(drop=True)
  • 1

append方式：

# append方式
result = df1.append([df2, df3])  //将df2，df3追加到df1后返回
# [官方合并教程](http://pandas.pydata.org/pandas-docs/stable/merging.html#)
  • 1
  • 2
  • 3

merge方式： 
merge(left, right, how=’inner’, on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=True, suffixes=(‘_x’, ‘_y’), copy=True, indicator=False) 
merge方式用于通过一个或多个键将两个数据集的行连接起来，类似于 SQL 中的 JOIN 
on=None 用于显示指定列名（键名），如果该列在两个对象上的列名不同，则可以通过 left_on=None, right_on=None 来分别指定。或者想直接使用行索引作为连接键的话，就将left_index=False, right_index=False 设为 True。如果没有指定且其他参数也未指定则以两个DataFrame的列名交集做为连接键. 
how=’inner’ 参数指的是当左右两个对象中存在不重合的键时，取结果的方式：inner 代表交集；outer 代表并集；left 和 right 分别为取一边。 
suffixes=(‘_x’,’_y’) 指的是当左右对象中存在除连接键外的同名列时，结果集中的区分方式，可以各加一个小尾巴。 
对于多对多连接，结果采用的是行的笛卡尔积。

# merge方式
# 其中how取值 : {‘left’, ‘right’, ‘outer’, ‘inner’}, default ‘inner’类似于SQL中 left outer join，right outer join， full outer join，inner join
>>> A              >>> B
    lkey value         rkey value
0   foo  1         0   foo  5
1   bar  2         1   bar  6
2   baz  3         2   qux  7
3   foo  4         3   bar  8
>>> A.merge(B, left_on='lkey', right_on='rkey', how='outer')
   lkey  value_x  rkey  value_y
0  foo   1        foo   5
1  foo   4        foo   5
2  bar   2        bar   6
3  bar   2        bar   8
4  baz   3        NaN   NaN
5  NaN   NaN      qux   7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

join方式： 
其中参数的意义与merge方法基本相同,只是join方法默认为左外连接how=left。默认按索引合并，可以合并相同或相似的索引。主要用于索引上的合并

join(self, other, on=None, how='left', lsuffix='', rsuffix='',sort=False):
  • 1

修改数据

从数据中提取数据：

dataset['Title'] = dataset.Name.str.extract(' ([A-Za-z]+)\.', expand=False)
# 左边dataset['Title']为DataFrame添加一列，右边dataset.Name取出DataFrame的name列，然后对于该Series里的string匹配正则，返回匹配到的正则子集。[官方api](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.str.extract.html)
  • 1
  • 2
data['sum_Times']=data['Times'].groupby(['userID']).cumsum()     //统计单个userid组内到当前行之前的所有time和
  • 1

替换数据：

dataset['Title'] = dataset['Title'].replace('Ms', 'Miss')
dataset['Title'].replace('Ms', 'Miss')
#将一列中数据Ms替换Miss，[详解](https://jingyan.baidu.com/article/454316ab4d0e64f7a6c03a41.html)
  • 1
  • 2
  • 3

将分类数据数值化：

title_mapping = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5}
for dataset in combine:
     dataset['Title'] = dataset['Title'].map(title_mapping)
# dataset['Sex'] = dataset['Sex'].map( {'female': 1, 'male': 0} ).astype(int)
  • 1
  • 2
  • 3
  • 4

转成矩阵：

big_X_imputed[0:train_df.shape[0]].as_matrix()  //将DataFrame对象转成numpy矩阵
  • 1

将连续值分成几部分：

# 自动
pd.cut(np.array([.2, 1.4, 2.5, 6.2, 9.7, 2.1]), 3,
           labels=["good","medium","bad"])
[good, good, good, medium, bad, good]
  • 1
  • 2
  • 3
  • 4
# 手动，一般手动前先自动分析一波。
# train_df['AgeBand'] = pd.cut(train_df['Age'], 5)
# train_df[['AgeBand', 'Survived']].groupby(['AgeBand'], as_index=False).mean().sort_values(by='AgeBand', ascending=True)
# 手动区分
# for dataset in combine:    
#     dataset.loc[ dataset['Age'] <= 16, 'Age'] = 0
#     dataset.loc[(dataset['Age'] > 16) & (dataset['Age'] <= 32), 'Age'] = 1
#     dataset.loc[ dataset['Age'] > 64, 'Age'] = 4
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

对每一行或每一列应用函数：

def num_missing(x):
  return sum(x.isnull())
#应用列:
print data.apply(num_missing, axis=0)
#应用行:
print data.apply(num_missing, axis=1).head()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
def get_title(name):
    title_search = re.search(' ([A-Za-z]+)\.', name)
    # If the title exists, extract and return it.
    if title_search:
        return title_search.group(1)
    return ""

for dataset in full_data:
    dataset['Title'] = dataset['Name'].apply(get_title)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
df.Cabin = df.Cabin.apply(lambda x: x[0])
  • 1

将字符型数据转成数值型数值：

from sklearn import preprocessing
def encode_features(df_train, df_test):
    features = ['Fare', 'Cabin', 'Age', 'Sex', 'Lname', 'NamePrefix']
    df_combined = pd.concat([df_train[features], df_test[features]])

    for feature in features:
        le = preprocessing.LabelEncoder()
        le = le.fit(df_combined[feature])
        df_train[feature] = le.transform(df_train[feature])
        df_test[feature] = le.transform(df_test[feature])
    return df_train, df_test

data_train, data_test = encode_features(data_train, data_test)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

除去离群点： 
通过画图如果发现数据中出现一些离群点，应将其除去，使用pandas布尔运算即可：

train = train[abs(train['length'])<10]
  • 1

categorial无序特征哑编码one-hot： 
星期为无序特征，如果该特征有三种取值：星期一、星期二、星期三，那么可用三维向量分别表示（1，0，0）（0，1，0）（0，0，1）。使用pd.get_dummies()，如果特征取值过多就应根据数据分布规律将不重要的几个取值归为一类。 
这里写图片描述
去重相同行：

alter.duplicated()   //返回每行是否重复的bool值，frame.duplicated(['state'])可选择指定列进行查重。
alter.duplicated().value_counts()
alter2 = alter.drop_duplicates()  //除去相同行，注意返回新数据，而不是在旧有的上面修改
  • 1
  • 2
  • 3

修改index名，列键名：

df.columns = ['a', 'b', 'c', 'd', 'e']
df.columns = df.columns.str.strip('$')
df.columns = df.columns.map(lambda x:x[1:])
  • 1
  • 2
  • 3
df.rename(columns=('$a': 'a', '$b': 'b', '$c': 'c', '$d': 'd', '$e': 'e'}, inplace=True) 
df.rename(columns=lambda x:x.replace('$',''), inplace=True)
  • 1
  • 2
investFeature.index.rename('EID', inplace=True)
  • 1

列转index、index转列：

 df.set_index('date', inplace=True)
  • 1
df['index'] = df.index
df.reset_index(level=0, inplace=True)
df.reset_index(level=['tick', 'obs'])
df['si_name'] = df.index.get_level_values('si_name') # where si_name is the name of the subindex.


转载。原文：http://blog.csdn.net/qq_16234613/article/details/64217337
文章标签：
Python
索引
数据挖掘
BI
SQL
API
存储
关键词：
Python方法
Python Pandas
Pandas python
数据分析python
Python数据分析
Chin2018
目录
相关文章
众所周知
|
3天前
|
数据处理 Python
如何使用Python的Pandas库进行数据排序和排名
【4月更文挑战第22天】Pandas Python库提供数据排序和排名功能。使用`sort_values()`按列进行升序或降序排序，如`df.sort_values(by=&#39;A&#39;, ascending=False)`。`rank()`函数用于计算排名，如`df[&#39;A&#39;].rank(ascending=False)`。多列操作可传入列名列表，如`df.sort_values(by=[&#39;A&#39;, &#39;B&#39;], ascending=[True, False])`和分别对&#39;A&#39;、&#39;B&#39;列排名。
众所周知
14 2
龙大吉
|
4天前
|
索引 Python
如何在Python中使用Pandas库进行季节性调整？
在Python中使用Pandas和Statsmodels进行季节性调整的步骤包括：导入pandas和seasonal_decompose模块，准备时间序列DataFrame，调用`seasonal_decompose()`函数分解数据为趋势、季节性和残差，可选地绘制图表分析，以及根据需求去除季节性影响（如将原始数据减去季节性成分）。这是对时间序列数据进行季节性分析的基础流程。
龙大吉
19 2
同学小张
|
2天前
|
人工智能 Python
【Python实用技能】建议收藏：自动化实现网页内容转PDF并保存的方法探索（含代码，亲测可用）
【Python实用技能】建议收藏：自动化实现网页内容转PDF并保存的方法探索（含代码，亲测可用）
同学小张
20 0
HannYang
|
2天前
|
数据挖掘 数据处理 索引
python常用pandas函数nlargest / nsmallest及其手动实现
python常用pandas函数nlargest / nsmallest及其手动实现
HannYang
15 0
东方睿赢
|
2天前
|
数据挖掘 数据处理 索引
如何使用Python的Pandas库进行数据筛选和过滤？
Pandas是Python数据分析的核心库，提供DataFrame数据结构。基本步骤包括导入库、创建DataFrame及进行数据筛选。示例代码展示了如何通过布尔索引、`query()`和`loc[]`方法筛选`Age`大于19的记录。
东方睿赢
10 0
东方睿赢
|
4天前
|
Python
如何使用Python的Pandas库进行数据缺失值处理？
Pandas在Python中提供多种处理缺失值的方法：1) 使用`isnull()`检查；2) `dropna()`删除含缺失值的行或列；3) `fillna()`用常数、前后值填充；4) `interpolate()`进行插值填充。根据需求选择合适的方法处理数据缺失。
东方睿赢
38 9
龙大吉
|
6天前
|
索引 Python
如何使用Python的Pandas库进行数据透视表（pivot table）操作？
使用Pandas在Python中创建数据透视表的步骤包括：安装Pandas库，导入它，创建或读取数据（如DataFrame），使用`pd.pivot_table()`指定数据框、行索引、列索引和值，计算聚合函数（如平均分），并可打印或保存结果到文件。这允许对数据进行高效汇总和分析。
龙大吉
10 2
小Lee
|
6天前
|
机器学习/深度学习 数据挖掘 计算机视觉
python数据分析工具SciPy
【4月更文挑战第15天】SciPy是Python的开源库，用于数学、科学和工程计算，基于NumPy扩展了优化、线性代数、积分、插值、特殊函数、信号处理、图像处理和常微分方程求解等功能。它包含优化、线性代数、积分、信号和图像处理等多个模块。通过SciPy，可以方便地执行各种科学计算任务。例如，计算高斯分布的PDF，需要结合NumPy使用。要安装SciPy，可以使用`pip install scipy`命令。这个库极大地丰富了Python在科学计算领域的应用。
小Lee
12 1
阿文没烦恼
|
7天前
|
存储 关系型数据库 MySQL
Python搭建代理IP池实现存储IP的方法
Python搭建代理IP池实现存储IP的方法
阿文没烦恼
28 2
阿文没烦恼
|
7天前
|
Python
Python动态IP代理防止被封的方法
Python动态IP代理防止被封的方法
阿文没烦恼
26 3

热门文章

最新文章

  • 1
    阿里云 MaxCompute MaxFrame 开启免费邀测，统一 Python 开发生态
  • 2
    使用Python实现DBSCAN聚类算法
  • 3
    在Python Web开发过程中：数据库与缓存，MySQL和NoSQL数据库的主要差异是什么？
  • 4
    流畅的 Python 第二版（GPT 重译）（一）(1)
  • 5
    Python 学习之路 01基础入门---【Python安装，Python程序基本组成】
  • 6
    流畅的 Python 第二版（GPT 重译）（十一）(1)
  • 7
    Python函数使用(四)
  • 8
    Python速成篇（基础语法）上
  • 9
    流畅的 Python 第二版（GPT 重译）（十二）(1)
  • 10
    13 Python 阶段性总结抽奖系统（文末附代码地址）
  • 1
    python常用pandas函数nlargest / nsmallest及其手动实现
    15
  • 2
    如何使用Python的Pandas库进行数据筛选和过滤？
    10
  • 3
    如何使用Pandas进行数据合并？
    10
  • 4
    如何在Pandas中对数据集进行多级分组并进行聚合计算？
    18
  • 5
    如何使用Python的Pandas库进行数据排序和排名
    14
  • 6
    如何使用Python的Pandas库进行数据缺失值处理？
    38
  • 7
    如何在Python中使用Pandas库进行季节性调整？
    19
  • 8
    《Pandas 简易速速上手小册》第7章：Pandas 文本和类别数据处理（2024 最新版）
    24
  • 9
    如何使用Python的Pandas库进行数据透视表（pivot table）操作？
    10
  • 10
    Pandas一键解析代理IP与代理IP池的维护
    24

    • 相关课程

    更多
  • Python 科学计算库 NumPy 快速入门
  • Python 数据可视化库 Matplotlib 快速入门
  • Python 数据分析库 Pandas 快速入门
  • Python语言基础 - 语法入门
  • 深入理解数据分析
  • 场景实践-通过阿里云数据分析工具实现共享单车骑行分析

    • 相关电子书

    更多
  • Python第四讲——使用IPython/Jupyter Notebook与日志服务玩转超大规模数据分析与可视化
  • 互联网下半场的角逐，玩转轻资产的大数据服务—图（关系网络）数据分析与阿里应用
  • 如何使用大数据计算服务 MaxCompute进行数据分析

    • 相关实验场景

    更多
  • 用Python画圣诞树
  • 使用Python完成RDS数据开发及分析
  • 倚天大数据电商数据分析快速实践
  • AnalyticDB MySQL游戏行业数据分析实践
  • Github实时数据分析与可视化
  • 云端Python及基本操作
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）