总结的pandas数据结构 和需要掌握的知识点

最新推荐文章于 2022-06-18 07:24:06 发布
最新推荐文章于 2022-06-18 07:24:06 发布
阅读量482 收藏 2
点赞数
文章标签： 数据结构 python 人工智能 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43737594/article/details/120004198
版权
本文深入介绍了Pandas的Series和DataFrame数据结构，包括它们的创建、属性、方法及其在数据分析中的应用。重点讲解了如何进行数据筛选、计算、导入导出等操作，并提供了丰富的代码示例，帮助读者掌握Pandas在实际问题中的运用。
摘要由CSDN通过智能技术生成

Pandas 数据结构

学习目标

  • 掌握Series的常用属性及方法

  • 掌握DataFrame的常用属性及方法

  • 掌握更改Series和DataFrame的方法

  • 掌握如何导入导出数据

创建Series和DataFrame

  • DataFrame和Series是Pandas最基本的两种数据结构

  • DataFrame和Series的区别联系：在Pandas中，Series是一维容器，Series表示DataFrame的每一列：

    • 可以把DataFrame看作由Series对象组成的字典，其中key是列名，值是Series

    • Series和Python中的列表非常相似，但是它的每个元素的数据类型必须相同

 创建Series

  • 创建 Series 的最简单方法是传入一个Python列表

    • 如果传入的数据类型是统一的数字，那么最终的dtype类型是int64

    • 如果传入的数据类型是统一的字符串，那么最终的dtype类型是object

    • 如果传入的数据类型是多种类型，那么最终的dtype类型也是object

    import pandas as pd
s = pd.Series(['banana', 42])
print(s)
s = pd.Series(['banana', 'apple'])
print(s)
s = pd.Series([50, 42])
print(s)
# 输出结果如下
0    banana
1        42
dtype: object
0    banana
1     apple
dtype: object
0    50
1    42
dtype: int64
# 上面的结果中，左边显示的0,1是Series的索引，默认为0,1,2,3...

  • 创建Series时，也可以通过index参数 来指定行索引

    s = pd.Series(['Wes McKinney','Male'],index = ['Name','Gender'])
print(s)
# 输出结果如下
Name      Wes McKinney
Gender            Male
dtype: object

 创建 DataFrame

  • 可以使用字典来创建DataFrame

    name_df = pd.DataFrame({
    'Name':['Tome','Bob'],
    'Occupation':['Teacher','IT Engineer'],
    'age':[28,36]
    })
print(name_df)
# 输出结果如下
   Name   Occupation  age
0  Tome      Teacher   28
1   Bob  IT Engineer   36

  • 创建DataFrame的时候可以使用colums参数指定列的顺序，也可以使用index来指定行索引

    name_df = pd.DataFrame(
    data={
        'Occupation': ['Teacher', 'IT Engineer'],
      'Age': [28,36]
    },
    columns=['Age', 'Occupation'],
    index=['Tome', 'Bob']
)
print(name_df)
# 输出结果如下
      Age   Occupation
Tome   28      Teacher
Bob    36  IT Engineer

 Series 常用操作

 Series常用属性

  • 使用 DataFrame的loc 属性获取数据集里的一行，就会得到一个Series对象

    data = pd.read_csv('data/nobel_prizes.csv',index_col='id')
data.head()
# 输出结果如下图

  • 使用行索引标签选择一条记录

    one_row = data.loc[941]
print(type(one_row))
print(one_row)
# 输出结果如下
<class 'pandas.core.series.Series'>
year                                                              2017
category                                                       physics
overallMotivation                                                  NaN
firstname                                                       Rainer
surname                                                          Weiss
motivation           "for decisive contributions to the LIGO detect...
share                                                                2
Name: 941, dtype: object

  • 可以通过 index 和 values属性获取行索引和值

    print(one_row.index)
print(one_row.values)
# 输出结果如下
Index(['year', 'category', 'overallMotivation', 'firstname', 'surname',
       'motivation', 'share'],
      dtype='object')
[2017 'physics' nan 'Rainer' 'Weiss'
 '"for decisive contributions to the LIGO detector and the observation of gravitational waves"'
 2]

  • Series的keys方法，作用与index属性一样

    data.keys()
# 输出结果如下
Index(['year', 'category', 'overallMotivation', 'firstname', 'surname',
       'motivation', 'share'],
      dtype='object')

  • Series的其他属性

    ​
    属性说明
    loc使用索引值取子集
    iloc使用索引位置取子集
    dtype或dtypesSeries内容的类型
    TSeries的转置矩阵
    shape数据的维数
    sizeSeries中元素的数量
    valuesSeries的值
    ​

    例如

    print(data.loc[941])
print(data.iloc[0])
print(data.shape, data.size)
# 输出结果如下
year                                                              2017
category                                                       physics
overallMotivation                                                  NaN
firstname                                                       Rainer
surname                                                          Weiss
motivation           "for decisive contributions to the LIGO detect...
share                                                                2
Name: 941, dtype: object
year                                                              2017
category                                                       physics
overallMotivation                                                  NaN
firstname                                                       Rainer
surname                                                          Weiss
motivation           "for decisive contributions to the LIGO detect...
share                                                                2
Name: 941, dtype: object
(923, 7) 6461

 Series常用方法

 常见计算

针对数值型的Series，可以进行常见计算

  • 平均值

#print(data.head())
share = data.share  # 从DataFrame中 获取Share列（几人获奖）返回Series
#print(share)
print(share.mean())    #计算几人获奖的平均值
# 输出结果如下
1.982665222101842

  • 最大值

share.max() # 计算最大值
# 输出结果如下
4

  • 最小值

share.min() # 计算最小值
# 输出结果如下
1

  • 标准差

share.std() # 计算标准差
# 输出结果如下
0.9324952202244597

2.2.2 value_counts函数

在获取某一列数据的Series对象后，通过value_counts()方法，可以返回以该列的值为分类依据，不同值的条目总数量；现在我们要对data/movie.csv数据集进行统计，分别统计相同点赞数的主演数量；实现如下：

  • 主演的facebook点赞数

movie = pd.read_csv('data/movie.csv')    # 加载电影数据
actor_1_fb_likes = movie['actor_1_facebook_likes'] # 从电影数据中取出主演的facebook点赞数
actor_1_fb_likes.head() #查看主演的facebook点赞数
# 输出结果如下
0     1000.0
1    40000.0
2    11000.0
3    27000.0
4      131.0
Name: actor_1_facebook_likes, dtype: float64

  • 分别统计相同点赞数的主演数量（有多少个主演的点赞数相同，且点赞数是多少）

actor_1_fb_likes.value_counts()
# 输出结果如下【左列为点赞数，右列为主演数量】
1000.0     436
11000.0    206
2000.0     189
3000.0     150
     ... 
216.0        1
859.0        1
225.0        1
334.0        1
Name: actor_1_facebook_likes, Length: 877, dtype: int64

再来看一个例子，现用vlaue_count函数统计不同导演指导的电影数量

  • 获取导演名字director_name列的Series对象

# movie = pd.read_csv('data/movie.csv')    # 加载电影数据
director = movie['director_name']   # 从电影数据中获取导演名字 返回Series
director.head()  #查看导演Series数据
# 输出结果如下
0        James Cameron
1       Gore Verbinski
2           Sam Mendes
3    Christopher Nolan
4          Doug Walker
Name: director_name, dtype: object

  • 统计不同导演指导的电影数量，本质就是以director_name列的值做分类，分别统计不同数据的数量

director.value_counts()      # 统计不同导演指导的电影数量
# 输出结果如下
Steven Spielberg    26
Woody Allen         22
Clint Eastwood      20
Martin Scorsese     20
               ..
Gavin Wiesen         1
Andrew Morahan       1
Luca Guadagnino      1
Richard Montoya      1
Name: director_name, Length: 2397, dtype: int64

 count函数

count函数可以统计Series对象中的非空值的总数（指定列中的数据没有空值，则计数+1）

  • 统计有导演的电影数量

director.count() 
# 输出结果如下
4814

  • 注意Series对象的count函数和value_counts函数的区别

    • Series对象的count函数：统计Series对象中的非空值的总数

    • Series对象的value_counts函数：统计以Series对象的值为分类依据，不同值的条目总数量

 describe函数

Series对象的describe函数可以输出统计描述

  • 查看facebook上对主演点赞数这一列数据的统计描述

actor_1_fb_likes.describe()
# 输出结果如下
count      4909.000000
mean       6494.488491
std       15106.986884
min           0.000000
25%         607.000000
50%         982.000000
75%       11000.000000
max      640000.000000
Name: actor_1_facebook_likes, dtype: float64

  • 查看导演名字这一列数据的统计描述

director.describe()
# 输出结果如下
count                 4814
unique                2397
top       Steven Spielberg
freq                    26
Name: director_name, dtype: object

  • 结果描述如下图所示

Series的其他方法列表

​

方法说明
append连接两个或多个Series
corr计算与另一个Series的相关系数
cov计算与另一个Series的协方差
describe计算常见统计量
drop_duplicates返回去重之后的Series
equals判断两个Series是否相同
get_values获取Series的值，作用与values属性相同
hist绘制直方图
isinSeries中是否包含某些值
min返回最小值
max返回最大值
mean返回算术平均值
median返回中位数
mode返回众数
quantile返回指定位置的分位数
replace用指定值代替Series中的值
sample返回Series的随机采样值
sort_values对值进行排序
to_frame把Series转换为DataFrame
unique去重返回数组

​

 布尔值列表获取Series对象中部分数据

从scientists.csv数据集中，列出大于Age列的平均值的具体值，具体步骤如下：

  • 加载并观察数据集

scientists = pd.read_csv('data/scientists.csv')
print(scientists)
#print(scientists.head())
# 输出结果如下
                   Name        Born        Died  Age          Occupation
0     Rosaline Franklin  1920-07-25  1958-04-16   37             Chemist
1        William Gosset  1876-06-13  1937-10-16   61        Statistician
2  Florence Nightingale  1820-05-12  1910-08-13   90               Nurse
3           Marie Curie  1867-11-07  1934-07-04   66             Chemist
4         Rachel Carson  1907-05-27  1964-04-14   56           Biologist
5             John Snow  1813-03-15  1858-06-16   45           Physician
6           Alan Turing  1912-06-23  1954-06-07   41  Computer Scientist
7          Johann Gauss  1777-04-30  1855-02-23   77       Mathematicia

  • 计算Age的平均值

ages = scientists['Age']
ages.mean()
# 输出结果如下
59.125

  • 输出大于Age列的平均值的具体值

print(ages[ages>ages.mean()])
# 输出结果如下
1    61
2    90
3    66
7    77
Name: Age, dtype: int64

在本例中，ages>ages.mean()，到底是什么？

为什么ages[ages>ages.mean()]就能返回我们想要的结果？

  • 利用表达式 ages > ages.mean() ，获取布尔值构成的series对象

new_ages_s = ages>ages.mean()
print(new_ages_s)
print(new_ages_s.values)
print(list(new_ages_s.values))
# 输出结果如下
0    False
1     True
2     True
3     True
4    False
5    False
6    False
7     True
Name: Age, dtype: bool
[False  True  True  True False False False  True]
[False, True, True, True, False, False, False, True]

  • 从Series中获取部分数据，可以通过标签，索引，也可以传入布尔值的列表

bool_values = (list(new_ages_s.values)) # 构造布尔值列表
ages[bool_values] # 通过布尔索引来控制，输出指定范围
# 输出结果如下
1    61
2    90
3    66
7    77
Name: Age, dtype: int64

 Series 的运算

 Series和数值型变量计算

Series和数值型变量计算时，变量会与Series中的每个元素逐一进行计算

  • 加法

ages+100
# 输出结果如下
0    137
1    161
2    190
3    166
4    156
5    145
6    141
7    177
Name: Age, dtype: int64

  • 乘法

ages*2
# 输出结果如下
0     74
1    122
2    180
3    132
4    112
5     90
6     82
7    154
Name: Age, dtype: int64

2.4.2 两个Series之间计算

  • 两个Series之间计算，如果Series元素个数相同，则将两个Series对应元素进行计算

print(ages+ages)
print('='*10)
print(ages*ages)
# 输出结果如下
0     74
1    122
2    180
3    132
4    112
5     90
6     82
7    154
Name: Age, dtype: int64
==========
0    1369
1    3721
2    8100
3    4356
4    3136
5    2025
6    1681
7    5929
Name: Age, dtype: int64

  • 元素个数不同的Series之间进行计算，会根据索引进行。索引不同的元素最终计算的结果会填充成缺失值，用NaN表示

print(ages)
print('='*10)
print(pd.Series([1,100]))
print('='*10)
print(ages + pd.Series([1,100]))
# 输出结果如下
0    37
1    61
2    90
3    66
4    56
5    45
6    41
7    77
Name: Age, dtype: int64
==========
0      1
1    100
dtype: int64
==========
0     38.0
1    161.0
2      NaN
3      NaN
4      NaN
5      NaN
6      NaN
7      NaN
dtype: float64:

  • 练习1：元素个数不同的Series之间的乘法计算

print(ages * pd.Series([1,100]))
# 合并多个Series为一个DataFrame
new_df = pd.concat([ages, pd.Series([1,100]), ages * pd.Series([1,100])], axis=1)
new_df
# 输出结果如下
0      37.0
1    6100.0
2       NaN
3       NaN
4       NaN
5       NaN
6       NaN
7       NaN
dtype: float64
Age	0	1
0	37	1.0	37.0
1	61	100.0	6100.0
2	90	NaN	NaN
3	66	NaN	NaN
4	56	NaN	NaN
5	45	NaN	NaN
6	41	NaN	NaN
7	77	NaN	NaN

  • 练习2：Series对象ages和倒序的ages做相乘计算

# sort_index() 对索引进行排序
rev_ages = ages.sort_index(ascending=False)
# 合并多个Series为一个DataFrame
pd.concat([ages, rev_ages, ages*ages, ages*rev_ages], axis=1)
# 输出结果如下
    Age	Age	Age	Age
0	37	37	1369	1369
1	61	61	3721	3721
2	90	90	8100	8100
3	66	66	4356	4356
4	56	56	3136	3136
5	45	45	2025	2025
6	41	41	1681	1681
7	77	77	5929	5929

  • 练习3：构造两个默认索引、且索引数量相同的Series，二者做相乘计算

# 构造两个默认索引、且数量相同的Series
print(pd.Series([1,2])) 
print(pd.Series([3,4]))
# 计算相乘
print(pd.Series([1,2])* pd.Series([3,4]))
# 输出结果如下
0    1
1    2
dtype: int64
0    3
1    4
dtype: int64
0    3
1    8
dtype: int64

  • 练习4：索引值不同的两个Series相乘

print(pd.Series([2,1])* pd.Series([3,4]))
print(pd.Series([2,1],index = [2,3])* pd.Series([3,4]))
# 输出结果如下
0    6
1    4
dtype: int64
0   NaN
1   NaN
2   NaN
3   NaN
dtype: float64

  • 练习5：索引值部分相同的两个Series相乘

print(pd.Series([2,1],index = [2,3]))
print(pd.Series([3,4],index = [1,2]))
print(pd.Series([3,4],index = [1,2])*pd.Series([2,1],index = [2,3]))
# 输出结果如下
2    2
3    1
dtype: int64
1    3
2    4
dtype: int64
1    NaN
2    8.0
3    NaN
dtype: float64

  • 通过上述练习，得出Series之间计算的结论：

    • Series之间进行计算时，数据会尽可能依据索引标签的值进行相互计算

    • 索引值相同的，对应计算得出新的Series

    • 索引值不同的元素最终计算的结果会填充成缺失值，用NaN表示

DataFrame常用操作

 DataFrame的常用属性和方法

DataFrame是Pandas中最常见的对象，Series数据结构的许多属性和方法在DataFrame中也一样适用

  • df.shape 行数和列数

movie = pd.read_csv('data/movie.csv')
# 打印行数和列数
print(movie.shape)
# 输出结果
(4916, 28)

  • df.size 数据的个数（列数*行数，NaN值也算）

# 打印数据的个数
movie.size
# 输出结果
137648

  • df.ndim 数据的维度

# 该数据集的维度
movie.ndim
# 输出结果
2

  • 数据的长度（行数）

# 该数据集的长度
len(movie)
# 输出结果
4916

  • 各个列的非空值的个数

# 各个列的值的个数
movie.count()
# 输出结果
color                     4897
director_name             4814
num_critic_for_reviews    4867
duration                  4901
                          ... 
actor_2_facebook_likes    4903
imdb_score                4916
aspect_ratio              4590
movie_facebook_likes      4916
Length: 28, dtype: int64

  • 各个列的最小值

# 各列的最小值
movie.min()
# 输出结果
num_critic_for_reviews        1
duration                      7
director_facebook_likes       0
actor_3_facebook_likes        0
                           ... 
actor_2_facebook_likes        0
imdb_score                  1.6
aspect_ratio               1.18
movie_facebook_likes          0
Length: 19, dtype: object

  • 对整个df的统计描述，和series的统计描述返回相同

movie.describe()

 DataFrame的布尔索引

  • 同Series一样，DataFrame也可以使用布尔索引获取数据子集。

# 使用布尔索引获取duration列的值大于平均值的数据
print(movie['duration'] > movie['duration'].mean())
movie[movie['duration'] > movie['duration'].mean()]
# 输出结果如下

  • 本质就是传入布尔值构成的列表，来获取部分数据，True所对应的数据会被保留

# 获取前5行数据中的第1、2、4个
movie.head()[[True,True,False,True,False]]
# 输出结果如下
colordirector_namenum_critic_for_reviewsdurationdirector_facebook_likesactor_3_facebook_likesactor_2_nameactor_1_facebook_likesgrossgenres...num_user_for_reviewslanguagecountrycontent_ratingbudgettitle_yearactor_2_facebook_likesimdb_scoreaspect_ratiomovie_facebook_likes
0ColorJames Cameron723.0178.00.0855.0Joel David Moore1000.0760505847.0Action|Adventure|Fantasy|Sci-Fi...3054.0EnglishUSAPG-13237000000.02009.0936.07.91.7833000
1ColorGore Verbinski302.0169.0563.01000.0Orlando Bloom40000.0309404152.0Action|Adventure|Fantasy...1238.0EnglishUSAPG-13300000000.02007.05000.07.12.350
3ColorChristopher Nolan813.0164.022000.023000.0Christian Bale27000.0448130642.0Action|Thriller...2701.0EnglishUSAPG-13250000000.02012.023000.08.52.35164000

3 rows × 28 columns

 DataFrame的运算

 DataFrame和数值进行运算

当DataFrame和数值进行运算时，DataFrame中的每一个元素会分别和数值进行运算

  • 加载数据集并观察

scientists = pd.read_csv('data/scientists.csv')
scientists.head()
	Name	Born	Died	Age	Occupation
0	Rosaline Franklin	1920-07-25	1958-04-16	37	Chemist
1	William Gosset	1876-06-13	1937-10-16	61	Statistician
2	Florence Nightingale	1820-05-12	1910-08-13	90	Nurse
3	Marie Curie	1867-11-07	1934-07-04	66	Chemist
4	Rachel Carson	1907-05-27	1964-04-14	56	Biologist

  • df和数值进行运算

scientists*2

  • 两个DataFrame之间进行计算，和series一样会根据索引的值进行对应计算

scientists+scientists
# 输出结果和 scientists*2 相同

  • 当两个DataFrame索引值不能对应时，不匹配的会返回NaN

print(scientists)
print('='*10)
print(scientists[:4])
print('='*10)
scientists+scientists[:4]

 DataFrame其他操作

 给行索引操作

 加载数据文件后指定某列为索引

加载数据文件时，如果不指定行索引，Pandas会自动加上从0开始的索引；可以通过df.set_index('列名')的方法重新对指定的列设置为索引

  • 查看数据集，注意数据的列数

movie = pd.read_csv('data/movie.csv')
movie
# 输出结果如下图

  • 指定某列为索引，并观察列数

movie2 = movie.set_index('movie_title')
movie2

  • 此时可以使用df.reset_index()重置索引，恢复为原来的df对象

 加载数据文件时指定某列为行索引

加载数据文件的时候，可以通过通过index_col参数，指定使用某一列数据作为行索引；并通过reset_index()方法可以重置索引

pd.read_csv('data/movie.csv', index_col='movie_title')

 DataFrame修改行名和列名

df.rename()函数修改行列名

DataFrame创建之后，可以通过rename()方法对原有的行索引名和列名进行修改

  • 单独运行：加载数据，并指定列作为索引

pd.read_csv('data/movie.csv', index_col='movie_title')

  • 单独运行：查看索引列前5个值

movie = pd.read_csv('data/movie.csv', index_col='movie_title')
movie.index[:5]

  • 单独运行：查看前5个列名

movie.columns[:5]

  • 单独运行：替换索引值和列名

# 构造要修改的索引值对应字典
idx_rename = {'Avatar':'Ratava', 'Spectre': 'Ertceps'} 
# 构造要修改的列名对应字典
col_rename = {'director_name':'Director Name', 'num_critic_for_reviews': 'Critical Reviews'} 
# 替换并显示前5行数据
movie.rename(index=idx_rename, columns=col_rename).head()

  • 整个执行过程如下图所示

 对df的行列名重新赋值

如果不使用dfrename()，也可以将df.index 和 df.columns属性提取出来，修改之后，再赋值回去

  • 单独运行：加载数据，并指定列作为索引，查看前3行数据

movie = pd.read_csv('data/movie.csv', index_col='movie_title')
movie.head(3)

  • 单独运行：分别查看数据的前5个索引值，和前5个列名

index_list = movie.index.tolist()
column_list = movie.columns.tolist()
print(index_list[:5],'\n',column_list[:5])

  • 单独运行：修改列表中的具体的值

index_list[0] = 'Ratava'
index_list[2] = 'Ertceps'
column_list[1] = 'Director Name'
column_list[2] = 'Critical Reviews'
print(index_list[:5], '\n', column_list[:5])

  • 单独运行：将修改值的列表分别赋值给df数据对象的index属性和columns属性

movie.index = index_list
movie.columns = column_list
movie.head(3)

 添加删除插入列

 添加列

通过dataframe['列名']添加新列，添加至最后

  • 添加列名为 has_seen 的一列，值都为0

movie = pd.read_csv('data/movie.csv')
movie['has_seen'] = 0
movie
# 输出结果如下图

  • 添加一个新列，列名为actor_director_facebook_likes，统计导演和123号主演的点赞数的总和

movie['actor_director_facebook_likes'] = (
    movie['actor_1_facebook_likes'] + 
    movie['actor_2_facebook_likes'] + 
    movie['actor_3_facebook_likes'] + 
    movie['director_facebook_likes']
)
movie.head()
# 输出结果如下图，注意：NaN与数值进行运算的结果都是NaN

 删除列

  • 调用df.drop('列名', axis='columns')方法删除列，参数axis='columns'表示对列进行删除操作

new_movie = movie.drop('actor_director_facebook_likes', axis='columns')
new_movie.head(5)

  • 注意：错误演示，此时运行的结果还是会出现指定删除的列；原因是df.drop()返回的是一个新的df对象，新df中没有指定删除的列，但原来的旧df中还是存在该列的

movie.drop('actor_director_facebook_likes', axis='columns')
movie.head(5)

插入列

使用df.insert(loc=列下标数字, column='列名', value=该列所有的值)方法插入列

  • 计算在点赞数上，主演1的比主演2多多少；将计算的值作为列插入到原来第一列的前边；显示5行5列数据

movie = pd.read_csv('data/movie.csv')
movie.insert(loc=0,column='actor1_likes-actor2_likes',value=movie['actor_1_facebook_likes'] - movie['actor_2_facebook_likes'])
movie.iloc[list(range(5)), list(range(5))]
# 输出结果如下
actor1_likes-actor2_likes	color	director_name	num_critic_for_reviews	duration
0	64.0	Color	James Cameron	723.0	178.0
1	35000.0	Color	Gore Verbinski	302.0	169.0
2	10607.0	Color	Sam Mendes	602.0	148.0
3	4000.0	Color	Christopher Nolan	813.0	164.0
4	119.0	NaN	Doug Walker	NaN	NaN

导出和导入数据

 Pickle文件

5.1.1 保存为pickle文件

  • 调用to_pickle方法将以二进制格式保存数据

  • 如要保存的对象是计算的中间结果，或者保存的对象以后会在Python中复用，可把对象保存为.pickle文件

  • 如果保存成pickle文件，只能在python中使用

  • 文件的扩展名可以是.p，.pkl，.pickle

scientists = pd.read_csv('data/scientists.csv')
names = scientists['Name']
names.to_pickle('scientists_name.pickle')
scientists.to_pickle('scientists_df.pickle')

读取pickle文件

可以使用pd.read_pickle函数读取.pickle文件中的数据

scientists_name = pd.read_pickle('scientists_name.pickle')
print(scientists_name)
# 输出结果如下
0       Rosaline Franklin
1          William Gosset
2    Florence Nightingale
3             Marie Curie
4           Rachel Carson
5               John Snow
6             Alan Turing
7            Johann Gauss
Name: Name, dtype: object

 CSV文件

我们用pd.read_csv()函数读取csv文件，使用df.to_csv()将数据保存为csv文件

  • 在CSV文件中，对于每一行，各列采用逗号分隔；使用\n换行符换行

  • 除了逗号，还可以使用其他类型的分隔符，比如TSV文件，使用制表符作为分隔符

  • CSV是数据协作和共享的首选格式，因为可以使用excel打开

# 默认使用逗号作为分隔符
names.to_csv('scientists_name.csv')
# TSV文件，设置分隔符必须为\t
scientists.to_csv('scientists_df.tsv', sep='\t')
#不在csv文件中写行名
scientists.to_csv('scientists_df_noindex.csv', index=False)

 Excel文件

注意：根据anaconda的版本不同，pandas读写excel有时需要额外安装xlwt、xlrd、openpyxl三个包

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple xlwt 
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple openpyxl
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple xlrd

 保存成Excel文件

  • Series这种数据结构不支持to_excel方法，想保存成Excel文件，需要把Series转换成DataFrame

names_df = names.to_frame()
import xlwt
names_df.to_excel('scientists_name_df.xls')
names_df.to_excel('scientists_name_df.xlsx')
# xls 是一个特有的二进制格式,其核心结构是复合文档类型的结构,而 xlsx 的核心结构是 XML 类型的结构,采用的是基于 XML 的压缩方式,使其占用的空间更小；xlsx的最后一个x表是xml
# xls是excel2003及以前版本生成的文件格式,而xlsx是excel2007及以后版本生成的文件格式。

  • DataFrame直接保存为Excel格式

scientists.to_excel('scientists_df.xlsx', sheet_name='scientists', index=False)

5.3.2 读取Excel文件

使用pd.read_excel() 读取Excel文件

pd.read_excel('scientists_df.xlsx')
# 输出结果如下

    Name	Born	Died	Age	Occupation
0	Rosaline Franklin	1920-07-25	1958-04-16	37	Chemist
1	William Gosset	1876-06-13	1937-10-16	61	Statistician
2	Florence Nightingale	1820-05-12	1910-08-13	90	Nurse
3	Marie Curie	1867-11-07	1934-07-04	66	Chemist
4	Rachel Carson	1907-05-27	1964-04-14	56	Biologist
5	John Snow	1813-03-15	1858-06-16	45	Physician
6	Alan Turing	1912-06-23	1954-06-07	41	Computer Scientist
7	Johann Gauss	1777-04-30	1855-02-23	77	Mathematician

【了解】feather格式文件

  • feather是一种文件格式，用于存储二进制对象

  • feather对象也可以加载到R语言中使用

  • feather格式的主要优点是在Python和R语言之间的读写速度要比CSV文件快

  • feather数据格式通常只用中间数据格式，用于Python和R之间传递数据

  • 一般不用做保存最终数据

【了解】数据导出的其他方法

  • 将excel中的数据读出，并导出为json文件

pd.read_excel('scientists_df.xlsx').to_json('scientists_df.json')

  • 其他导出方法清单

​
导出方法说明
to_clipboard把数据保存到系统剪贴板，方便粘贴
to_dict把数据转换成Python字典
to_hdf把数据保存为HDF格式
to_html把数据转换成HTML
to_json把数据转换成JSON字符串
to_sql把数据保存到SQL数据库
​

总结

  • 创建Series和DataFrame

    • pd.Series

    • pd.DataFrame

  • Series常用操作

    • 常用属性

      • index

      • values

      • shape,size,dtype

    • 常用方法

      • max(),min(),std()

      • count()

      • describe()

    • 布尔索引

    • 运算

      • 与数值之间进行算数运算会对每一个元素进行计算

      • 两个Series之间进行计算会索引对齐

  • DataFrame常用操作

    • 常用属性

    • 常用方法

    • 布尔索引

    • 运算

  • 更改Series和DataFrame

    • 指定行索引名字

      • dataframe.set_index()

      • dataframe.reset_index()

    • 修改行/列名字

      • dataframe.rename(index=,columns = )

      • 获取行/列索引 转换成list之后，修改list再赋值回去

    • 添加、删除、插入列

      • 添加 dataframe['新列‘']

      • 删除 dataframe.drop

      • 插入列 dataframe.insert()

  • 导入导出数据

    • pickle

    • csv

    • Excel

    • feather

莽撞少年
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
在Python中文件用Feather格式，与 CSV说再见，速度提升 150 倍！
【独钓寒江雪】的博客
09-18 2853
在Python中文件用Feather格式，与 CSV说再见，速度提升 150 倍！
Bug集和之1：读取feather格式文件和excel表格
最新发布
weixin_45775565的博客
01-25 772
读取feather和excel的几种简单方式
数据分析 NO.12 pandas数据管理
TeddyBob的博客
05-29 1412
pandas数据管理
Pandas入门知识学习
weixin_45588852的博客
03-16 1658
目录Pandas基础知识学习一、数据处理对象Pandas中的数据结构SeriesDataFrame二、读取CSV格式数据读取CSV查看前n行查看后n行修改列名三、排序操作对索引进行排序按行排序按值排序四、删除操作五、基本的算术运算算术运算（+，-，*，/）六、去重操作duplicated()drop_duplicates()七、层次化索引层次化索引索引方式内层选取数据重塑 Pandas基础知识学习 Pandas比较适合处理结构化的数据，如序列数据，表格数据等，例如csv文件，利用pandas可以快速的对数据
第3章 伪列：COLUMN_VALUE
cizhuoouyong8699的博客
10-05 1035
原文地址：http://docs.oracle.com/cd/B19306_01/server.102/b14200/pseudocolumns004.htm如果引用不带COLUMNS子句的XMLTABLE构...
用NumPy和Pandas做数据分析实战
01-14
接下来，Pandas是基于NumPy的数据分析库，它的核心数据结构DataFrame和Series极大地简化了数据操作和清洗。 1. **DataFrame**：这是Pandas的二维表格型数据结构，包含行索引和列索引，可以存储不同类型的数据，并...
用实战玩转Pandas数据分析.pdf
11-25
下面是基于本书的知识点总结： Pandas 的重要性 Pandas 是 Python 数据分析的核心库之一，它提供了高效、灵活的数据处理和分析能力，能够轻松地处理大量数据，进行数据清洁、转换、合并、去重、分组、排序等操作。...
对pandas的算术运算和数据对齐实例详解
09-19
本文将详细介绍 Pandas 中的算术运算与数据对齐的概念，并通过具体的示例来帮助读者更好地理解和掌握这些知识点。 #### 一、算术运算 Pandas 支持多种算术运算，包括加法、减法、乘法和除法等。当两个 Pandas 对象...
机器学习和数据分析-pandas对数据的选取操作
12-21
1. **Pandas DataFrame**: `DataFrame`是Pandas的核心数据结构，它是一个二维表格型数据结构，可以存储各种不同类型的数据（如字符串、整数、浮点数等），并且具有行和列索引。 2. **数据初始化**: 创建DataFrame...
Pandas使用操作(二)
ErnestW的博客
12-23 2084
获取列名 1、df.columns #返回的是array格式。 df.columns[0] 2、list(df) #返回list格式。 list(df)[0] 3、df.keys() #pandas.core.indexes.base.Index df.keys()[0] 将空字符串替换为nan dataframe.iloc[:,0].str.split(',',expand=True).replace('',np.nan) 将NaN替换成None df = df.where(df.notnull(
Nobel prize from 1901 till 2020 1901年至2020年诺贝尔奖-数据集
03-09
诺贝尔奖是瑞典和挪威机构为表彰学术、文化或科学进步而颁发的几类年度国际奖项。瑞典化学家、工程师和实业家阿尔弗雷德·诺贝尔的意志于1895年设立了五项诺贝尔奖。化学、文学、和平、物理、生理学或医学奖于1901年首次颁发。该奖项被广泛认为是各自领域最负盛名的奖项。 nobel_final.csv
pandas使用to_feather函数将dataframe保存为feather文件（需要依赖pyarrow包）提升大文件读取效率、pandas使用read_feather函数读取feather文件
data+scenario+science+insight
06-18 2389
pandas使用to_feather函数将dataframe保存为feather文件（需要依赖pyarrow包）提升大文件读取效率、pandas使用read_feather函数读取feather文件、文件读取效率提升
在Oracle中用COLUMN_VALUE
u012887743的博客
06-18 5946
            SELECT A20.*              FROM A20_ITEM A20             WHERE A20.DATE = '20181230'              AND EXISTS(                    SELECT 1 FROM TABLE(FC_MAKE_IN(NVL(TRIM(WK_JANITF_CD), A20.I...
oracle中的table函数的使用
爱码士的博客
07-16 2427
今天在公司看到一个存储过程中的一条sql,其中用到了table函数。因为之前没有接触过，所以记录一下table函数的使用。 首先介绍一下表函数: 表函数可接受查询语句或游标作为输入参数，并可输出多行数据。该函数可以平行执行，并可持续输出数据流，被称作管道式输出。应用表函数可将数据转换分阶段处理，并省去中间结果的存储和缓冲表。 select 某字段 from table(),括号中的参数可以接...
python，字典转存为pandas，key为列，value为行，索引重命名
first_three_sun的博客
09-17 5620
Python中，使用pandas进行数据处理和存储非常方便，同样，字典的使用也是很多操作中不可或缺的。本文主要是记录在使用过程中的经历，总结和分享，便于日后查看。 任务1：将字典的keys作为pandas的列名称，values作为pandas的行数据 废话不多说，直接上代码，结果一目了然： import pandas as pd dct = {'key1': [1, 4], 'key2': [2, 5], 'key3': [3, 6]} dataframe = pd.DataFrame(dct, in.
pandas数据结构(python数据分析活用pandas库)
mixiaolemy的博客
09-12 211
目录 1创建数据 1.1创建series 1.2创建dataframe 2.Series 2.1类似于ndarray的Series 2.2布尔子集：series 2.3操作自动对齐和向量化 2.3.1同长度向量 2.3.2向量和整数运算 2.3.3不同长度向量间的运算 2.3.4带有常见索引标签的向量 3.dataframe 3.1布尔子集 3.2操作自动对齐和向量化 4.更改series和dataframe 4.1添加列 4.2更改...
十分钟搞定pandas
promise_LOVE的专栏
06-27 3377
本文是对pandas官方网站上《10 Minutes to pandas》的一个简单的翻译，原文在这里。这篇文章是对pandas的一个简单的介绍，详细的介绍请参考：Cookbook 。习惯上，我们会按下面格式引入所需要的包： 一、            创建对象 可以通过 Data Structure Intro Setion 来查看有关该节内容的详细信息。 1、可以通过传递一个list
PANDAS 数据合并与重塑（join/merge篇）
热门推荐
stevenkwong的博客
09-14 8万+
在上一篇文章中，我整理了pandas在数据合并和重塑中常用到的concat方法的使用说明。在这里，将接着介绍pandas中也常常用到的join 和merge方法mergepandas的merge方法提供了一种类似于SQL的内存链接操作，官网文档提到它的性能会比其他开源语言的数据操作（例如R）要高效。和SQL语句的对比可以看这里merge的参数on：列名，join用来对齐的那一列的名字，用到这个参数的
Pandas Cookbook
weixin_44649331的博客
12-14 399
第01章 Pandas基础 引入pandas和numpy的约定 import pandas as pd import numpy as np 1. DataFrame的结构
Python pandas入门：数据结构与创建
pandas是Python中一个强大的数据处理库，它主要围绕两个核心数据结构：Series和DataFrame展开。Series是类似于NumPy数组的一维标签化数据结构，具有索引标签，支持多种数学函数和方法，并且具有自动对齐功能，方便按...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值