Python数据分析(三)_雨宙的博客-程序员宅基地

技术标签: pandas  python  

Python数据分析(三)

打卡第七天啦!!!

pandas库(二)

pandas索引操作

index对象

  1. Series和DataFrame中的索引都是Index对象
import pandas as pd
import numpy as np
ps = pd.Series(range(5),index=['a','b','c','d','e'])
print(ps)
print(type(ps.index)) # <class 'pandas.core.indexes.base.Index'>
pd1 = pd.DataFrame(np.arange(9).reshape(3,3),index=['a','b','c'],columns=['A','B','C'])
print(pd1)
print(type(pd1.index)) # <class 'pandas.core.indexes.base.Index'>
print(type(pd1.columns)) # <class 'pandas.core.indexes.base.Index'>
  1. 索引对象不可变,保证数据安全
  2. 常见的index种类:Index索引、Int64Index整数索引、MultiIndex层级索引、DatetimeIndex时间戳类型

重新索引

reindex创建一个符合新索引的新对象

  1. Series中的重新索引
ps1 = ps.reindex(['a','b','c','d','e','f'])
print(ps1)
# a    0.0
# b    1.0
# c    2.0
# d    3.0
# e    4.0
# f    NaN
# dtype: float64
  1. DataFrame中的重新索引
# 行索引重建
pd2 = pd1.reindex(index=['a','b','c','d'])
print(pd2)
#      A    B    C
# a  0.0  1.0  2.0
# b  3.0  4.0  5.0
# c  6.0  7.0  8.0
# d  NaN  NaN  NaN
# 列索引重建
pd3 = pd1.reindex(columns=['C','B','A'])
print(pd3)
#    C  B  A
# a  2  1  0
# b  5  4  3
# c  8  7  6

  1. Series中的增加操作
s1 = pd.Series({
    'f':999})
ps4 = ps.append(s1)
print(ps4)
# a      0
# b      1
# c      2
# d      3
# e      4
# f    999
# dtype: int64
  1. DataFrame中的增加操作
# 插入列
pd1.insert(0,'E',[9,99,999])
print(pd1)
#      E  A  B  C
# a    9  0  1  2
# b   99  3  4  5
# c  999  6  7  8
# 插入行
# 第一种方法:标签索引
pd1.loc['d'] = [1,1,1,1]
print(pd1)
#      E  A  B  C
# a    9  0  1  2
# b   99  3  4  5
# c  999  6  7  8
# d    1  1  1  1
# 第二种方法
row = {
    'E':6,'A':6,'B':6,'C':6}
pd5 = pd1.append(row,ignore_index=True)
print(pd5)
#      E  A  B  C
# 0    9  0  1  2
# 1   99  3  4  5
# 2  999  6  7  8
# 3    1  1  1  1
# 4    6  6  6  6

  1. Series中的删除操作,其中分为两种情况,一种是直接在原数据上进行删除,另外一种是先拷贝一份再进行删除
    (1)在原数据上直接进行删除
del ps['e']
print(ps)
# a    0
# b    1
# c    2
# d    3
# dtype: int64

(2)不在原数据上直接进行删除,删除后返回新对象

# 不在原有数据上修改
ps1 = ps.drop('d')
print(ps1)
# a    0
# b    1
# c    2
# dtype: int64
# 删除多条
ps1 = ps.drop(['c','d'])
print(ps1)
# a    0
# b    1
# dtype: int64
  1. DataFrame中的删除操作,其中分为两种情况,一种是直接在原数据上进行删除,另外一种是先拷贝一份再进行删除
    (1)在原数据上直接进行删除(使用del关键字,但只能删除列)
# 通过del只能删除列
del pd1['E']
print(pd1)
#    A  B  C
# a  0  1  2
# b  3  4  5
# c  6  7  8
# d  1  1  1

(2)不在原数据上直接进行删除,删除后返回新对象(使用drop方法,通过设置axis可以删除行或列)

# 默认删除行数据
pd2 = pd1.drop('a')
print(pd2)
#    A  B  C
# b  3  4  5
# c  6  7  8
# d  1  1  1
# 删除列数据
pd2 = pd1.drop('A',axis=1) # axis=1与axis='columns'效果相同
print(pd2)
#    B  C
# a  1  2
# b  4  5
# c  7  8
# d  1  1
  1. 需要注意的是,使用drop也可以在原数据上直接进行修改,只需要设置inplace属性
# inplace属性 在原对象上删除,并不会返回新的对象
ps.drop('d',inplace=True)
print(ps)
# a    0
# b    1
# c    2
# dtype: int64

  1. Series中的修改操作,直接使用索引修改
ps1['a'] = 999
ps1
# a    999
# b      1
# c      2
# d      3
# e      4
# dtype: int64
ps1[0] = 1000
ps1
# a    1000
# b       1
# c       2
# d       3
# e       4
# dtype: int64
  1. DataFrame中的修改操作,可以使用索引修改,或使用对象.列的方式修改,但只能修改列数据,另一种方法是使用loc标签索引修改数据,可以修改行数据,以及某一行某一列的具体数据
# 直接使用索引
pd1['A'] = 9
print(pd1)
#    A  B  C
# a  9  1  2
# b  9  4  5
# c  9  7  8
pd1['A'] = [9,10,11]
print(pd1)
#     A  B  C
# a   9  1  2
# b  10  4  5
# c  11  7  8
# 对象.列的形式
pd1.A = 6
print(pd1)
#    A  B  C
# a  6  1  2
# b  6  4  5
# c  6  7  8
# 修改行
# 使用loc标签索引
pd1.loc['a'] = 9
print(pd1)
#    A  B  C
# a  9  9  9
# b  6  4  5
# c  6  7  8
# 修改某一个具体数据
pd1.loc['a','A'] = 1000
print(pd1)
#       A  B  C
# a  1000  9  9
# b     6  4  5
# c     6  7  8

Series中的查找操作
  1. 行索引
# 行索引
ps1
# a    1000
# b       1
# c       2
# d       3
# e       4
# dtype: int64
print(ps1['a'])
# 1000
print(ps1[0])
# 1000
  1. 切片索引,需要注意的是,利用位置切片索引,不包含终止索引;利用标签切片索引,包含终止索引。
# 切片索引
# 位置切片索引,不包含终止索引
print(ps1[1:4])
# b    1
# c    2
# d    3
# dtype: int64
# 标签切片索引,包含终止索引
print(ps1['b':'d'])
# b    1
# c    2
# d    3
# dtype: int64
  1. 不连续索引
# 不连续索引
print(ps1[['b','e']])
# b    1
# e    4
# dtype: int64
print(ps1[[0,2,3]])
# a    1000
# c       2
# d       3
# dtype: int64
  1. 布尔索引
# 布尔索引
ps1[ps1>2]
# a    1000
# d       3
# e       4
# dtype: int64
DataFrame中的查找操作
  1. 列索引,通过列索引查找某一列数据,返回Series对象,需要注意的是,在取多列数据时,用两个中括号。
# 列索引
pd1['A']
# a    1000
# b       6
# c       6
# Name: A, dtype: int64
# 取多列
print(pd1[['A','C']])
#       A  C
# a  1000  9
# b     6  5
# c     6  8
  1. 通过列索引和行索引取到某一行某一列的具体数据
pd1['A']['a']
# 1000
  1. 切片索引,此时的切片是针对行来说的
# 切片
print(pd1[:2]) # 获取行
#       A  B  C
# a  1000  9  9
# b     6  4  5

高级索引

loc标签索引
# loc是基于标签名的索引 自定义的索引名
ps1.loc['a':'c']
# a    1000
# b       1
# c       2
# dtype: int64
ps1['a':'c']
# a    1000
# b       1
# c       2
# dtype: int64
pd1.loc['a':'b','A':'C'] # 第一个参数是索引行 第二个参数是列
iloc位置索引
ps1.iloc[1:3]
# b    1
# c    2
# dtype: int64
ps1[1:3]
# b    1
# c    2
# dtype: int64
print(pd1.iloc[0:3,0:2])
#       A  B
# a  1000  9
# b     6  4
# c     6  7
ix标签与位置混合索引(不推荐使用)

pandas库(三)

对齐运算

算术运算和数据对

s1 = pd.Series(np.arange(4),index=['a','b','c','d'])
s2 = pd.Series(np.arange(5),index=['a','c','e','f','g'])
s1+s2
# a    0.0
# b    NaN
# c    3.0
# d    NaN
# e    NaN
# f    NaN
# g    NaN
# dtype: float64
df1 = pd.DataFrame(np.arange(12).reshape(4,3),index=['a','b','c','d'],columns=list('ABC'))
df2 = pd.DataFrame(np.arange(9).reshape(3,3),index=['a','d','f'],columns=list('ABD'))
print(df1+df2)
#       A     B   C   D
# a   0.0   2.0 NaN NaN
# b   NaN   NaN NaN NaN
# c   NaN   NaN NaN NaN
# d  12.0  14.0 NaN NaN
# f   NaN   NaN NaN NaN

填充值

s1.add(s2,fill_value=0)
# a    0.0
# b    1.0
# c    3.0
# d    3.0
# e    2.0
# f    3.0
# g    4.0
# dtype: float64
print(df1.add(df2,fill_value=0))
#       A     B     C    D
# a   0.0   2.0   2.0  2.0
# b   3.0   4.0   5.0  NaN
# c   6.0   7.0   8.0  NaN
# d  12.0  14.0  11.0  5.0
# f   6.0   7.0   NaN  8.0

DataFrame和Series混合运算

  1. 匹配列索引
s3 = df1.iloc[0]
s3
# A    0
# B    1
# C    2
# Name: a, dtype: int32
print(df1 - s3)
#    A  B  C
# a  0  0  0
# b  3  3  3
# c  6  6  6
# d  9  9  9
  1. 匹配行索引
s4 = df1['A']
s4
# a    0
# b    3
# c    6
# d    9
# Name: A, dtype: int32
print(df1.sub(s4,axis=0)) # 指定轴为列
#    A  B  C
# a  0  1  2
# b  0  1  2
# c  0  1  2
# d  0  1  2

函数应用

apply和applymap

  1. 通过apply将函数应用到列或行
print(df)
#           0         1         2         3
# 0  0.256674 -1.556277  2.230852  0.682209
# 1  1.791964 -0.085436  2.139264 -0.369255
# 2  1.241260 -0.195090  0.806148 -0.670290
# 3  1.678381  1.694978  0.595143  2.214359
# 4 -0.352148 -1.230048 -0.670016 -0.071479
f = lambda x:x.max()
df.apply(f)
# 0    1.791964
# 1    1.694978
# 2    2.230852
# 3    2.214359
# dtype: float64
# 默认轴的方向 默认axis=0列
df.apply(f,axis=1)
# 0    2.230852
# 1    2.139264
# 2    1.241260
# 3    2.214359
# 4   -0.071479
# dtype: float64
  1. 通过applymap将函数应用到每个数据
f2 = lambda x:'%.2f'%x # 保留两位小数
print(df.applymap(f2))
#        0      1      2      3
# 0   0.26  -1.56   2.23   0.68
# 1   1.79  -0.09   2.14  -0.37
# 2   1.24  -0.20   0.81  -0.67
# 3   1.68   1.69   0.60   2.21
# 4  -0.35  -1.23  -0.67  -0.07

排序

  1. 索引排序
s1 = pd.Series(np.arange(4),index=list('dbca'))
s1
# d    0
# b    1
# c    2
# a    3
# dtype: int32
s1.sort_index() # 默认升序
# a    3
# b    1
# c    2
# d    0
# dtype: int32
s1.sort_index(ascending = False)
# d    0
# c    2
# b    1
# a    3
# dtype: int32
pd1 = pd.DataFrame(np.arange(12).reshape(4,3),index=list('bdca'),columns=list('BCA'))
# 按照行排序
print(pd1.sort_index())
#    B   C   A
# a  9  10  11
# b  0   1   2
# c  6   7   8
# d  3   4   5
# 按照列排序
print(pd1.sort_index(axis=1))
#     A  B   C
# b   2  0   1
# d   5  3   4
# c   8  6   7
# a  11  9  10
  1. 按值排序
    (1)NAN值排最后
    (2)指定ascending属性可以降序或升序排列
    (3)DataFrame需要指定列进行排序,也可以指定多列
s1.sort_values() # 根据值的大小进行排序
# d    0
# b    1
# c    2
# a    3
# dtype: int32
s1['a'] = np.nan
s1.sort_values() # 根据值的大小进行排序,当有缺失值,默认排最后
# d    0.0
# b    1.0
# c    2.0
# a    NaN
# dtype: float64
s1.sort_values(ascending = False)
# c    2.0
# b    1.0
# d    0.0
# a    NaN
# dtype: float64
pd2 = pd.DataFrame({
    'a':[3,7,9,0],'b':[1,-1,4,8],'c':[0,6,-3,2]})
print(pd2)
#    a  b  c
# 0  3  1  0
# 1  7 -1  6
# 2  9  4 -3
# 3  0  8  2
# 指定一列排序
print(pd2.sort_values(by='a'))
#    a  b  c
# 3  0  8  2
# 0  3  1  0
# 1  7 -1  6
# 2  9  4 -3
# 指定多列排序
print(pd2.sort_values(by=['a','b']))

唯一值和成员属性

  1. 使用unique方法查找唯一值
s1 = pd.Series([2,6,8,9,3,6],index=['a','a','c','c','e','e'])
s2 = s1.unique()
# array([2, 6, 8, 9, 3], dtype=int64)
  1. 使用is_unique判断是否唯一
s1.index.is_unique
# False
s1.is_unique
# False
  1. 使用value_counts方法计算每个值出现的个数
# 计算值的个数
s1 = pd.Series([2,6,8,9,3,6])
s1.value_counts() # 返回Series
# 6    2
# 3    1
# 2    1
# 9    1
# 8    1
# dtype: int64
  1. 判断数据是否存在
s1.isin([8]) # 判断数据是否存在,返回布尔类型,也可以判断多个值
# 0    False
# 1    False
# 2     True
# 3    False
# 4    False
# 5    False
# dtype: bool
data = pd.DataFrame({
    'a':[3,7,9,0],'b':[1,-1,4,8],'c':[0,6,-3,2]})
print(data.isin([2,4]))
#        a      b      c
# 0  False  False  False
# 1  False  False  False
# 2  False   True  False
# 3  False  False   True

处理缺失数据

  1. 判断是否存在缺失值
df3 = pd.DataFrame([np.random.randn(3),[1.,2.,np.nan],
                   [np.nan,4.,np.nan],[1.,2.,3.]])
df3.isnull()
#        0      1      2
# 0  False  False  False
# 1  False  False   True
# 2   True  False   True
# 3  False  False  False
  1. 丢弃缺失数据
df3.dropna() # 默认丢弃行
df3.dropna(axis=1) # 丢弃列
  1. 填充缺失数据
df3.fillna(-1)
#           0         1         2
# 0 -0.931614  0.612775 -0.070913
# 1  1.000000  2.000000 -1.000000
# 2 -1.000000  4.000000 -1.000000
# 3  1.000000  2.000000  3.000000

层级索引

  1. 选取指定外层索引和内层索引
s1 = pd.Series(np.random.randn(12),index=[['a','a','a','b','b','b','c','c','c','d','d','d'],[0,1,2,0,1,2,0,1,2,0,1,2]])
print(type(s1.index))
# <class 'pandas.core.indexes.multi.MultiIndex'>
# 选取
# 外层选取
s1['b']
# 0   -0.685567
# 1    0.227194
# 2    0.453674
# dtype: float64
# 内层选取
s1[:,2] # 选取所有的外层索引,内层索引为2
# a    1.908277
# b    0.453674
# c   -0.350985
# d    0.893875
# dtype: float64
s1['a',2]
# 1.908276903906101
  1. 交换内层索引和外层索引
# 交换内层索引和外层索引
s1.swaplevel()

pandas统计计算和描述

df = pd.DataFrame([[1.4,np.nan],[7.1,-4.5],
                 [np.nan,np.nan],[0.75,-1.3]],
                 index=['a','b','c','d'],
                 columns=['one','two'])
df.sum() # 默认按列求和
# one    9.25
# two   -5.80
# dtype: float64
df.sum(axis=1) # nan自动排除
# a    1.40
# b    2.60
# c    0.00
# d   -0.55
# dtype: float64
df.sum(axis=1,skipna=False)
# a     NaN
# b    2.60
# c     NaN
# d   -0.55
# dtype: float64
df.idxmax() # 返回最大值的索引
# one    b
# two    d
# dtype: object
df.cumsum() # 样本值的累计和
#     one  two
# a  1.40  NaN
# b  8.50 -4.5
# c   NaN  NaN
# d  9.25 -5.8
df.describe() # 汇总统计
#             one       two
# count  3.000000  2.000000
# mean   3.083333 -2.900000
# std    3.493685  2.262742
# min    0.750000 -4.500000
# 25%    1.075000 -3.700000
# 50%    1.400000 -2.900000
# 75%    4.250000 -2.100000
# max    7.100000 -1.300000
s1 = pd.Series(['a','a','b','c']*4)
s1.describe()
# count     16
# unique     3
# top        a
# freq       8
# dtype: object
版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/rainy_universe/article/details/119428834

智能推荐

Angular最新教程-第二节使用git、svn和码云做版本控制_weixin_30299539的博客-程序员宅基地

上一节课我们已经创建了一个新的项目, 这节课我们了解一下如何创建码云(https://git.oschina.net/)管理我们的代码。 在工作中,不管是自己一个人开发,还是团队开发,都会涉及到版本控制。 比较常用的版本控制软件有svn和git。 (如果你会使用git,会版本控制,那你就不需要在往下看了。git clone这个地址https://git.osch...

html 触发自定义事件,HUI - 自定义事件及事件触发_泊叶叶的博客-程序员宅基地

使用addeventlistener方法为元素绑定自事件语法 : 原生dom.addeventlistener()示例 :testvarbtn=document.getElementById('btn');btn.addEventListener('click',function(){hui.toast('hi.');});使用 removeEventListener() 方法来移除 ad...

PDF如何合并,PDF文件合并的技巧_weixin_33975951的博客-程序员宅基地

说起PDF文件,很多人都为这种文件感觉得很反感,原因就是PDF文件不能直接进行编辑,那更不要说PDF合并了,其实合并PDF文件是需要专门的一些软件的,比如PDF编辑器、PDF转换器等等,下面就为大家分享一下PDF合并的操作方法。操作方法如下:方法一:迅捷PDF编辑器1:首先将PDF编辑器下载http://bianji.xjpdf.com/download.html 到自己的电脑中双击打开PDF编辑...

QT5跨平台界面编程原理和实战大全_时代曙光的博客-程序员宅基地

QT5跨平台界面编程原理和实战大全链接:https://pan.baidu.com/s/1lJR945-7tf6fZZ5EoALvfg提取码:2zyl

与计算机密度相关的指标,通信原理(第六版)课后思考题及习题答案讲解_weixin_39834475的博客-程序员宅基地

第一章绪论1.1以无线广播和电视为例,说明图1-1模型中的信息源,受信者及信道包含的具体内容是什么在无线电广播中,信息源包括的具体内容为从声音转换而成的原始电信号,收信者中包括的具体内容就是从复原的原始电信号转换乘的声音;在电视系统中,信息源的具体内容为从影像转换而成的电信号。收信者中包括的具体内容就是从复原的原始电信号转换成的影像;二者信道中包括的具体内容分别是载有声音和影像的无线电波1.2何谓...

随便推点

MIT博士推荐的几本数学书_datoubo的博客-程序员宅基地

Dahua Lin早在几年前就已经冒尖出来了,现在在MIT攻读博士学位,前途不可限量。他总是有无穷的精力,学习,同时几篇几篇的写paper,几万行几万行的写code,几万字几万字的写blog。。他扎实的数学功底和相关知识的功底,以及深睿的洞察和理解问题的能力,注定他将在machine learning和computer vision等相关领域取得大量的成果,甚至是突破性的成果。期待他在这些领域做出

java常用集合类详解(有例子,集合类糊涂的来看!)_BruceZhang的博客-程序员宅基地

Framework集合框架是一个统一的架构,用来表示和操作集合.集合框架主要是由接口,抽象类和实现类构成.接口:蓝色;实现类:红色Collection|_____Set(HashSet)|         |_____SortedSet(TreeSet)|_____List(LinkedList,ArrayList)Collection:集合层次中的根接口,JDK没有提供这个接口的实现类。Set:

中兴盒子B860AV2.1-M_晶晨S905L3芯片_线刷_刷机固件_fatiaozhang9527的博客-程序员宅基地_s905l芯片短接刷机

刷机方法:1、打开刷机工具,并导入机顶盒升级固件,刷机工具右上角打钩处全部取消,如下图; 2、根据固件里面短接点提示,短接短接点进行操作(有2022年的晶晨系列HDMI免拆机免短接工具的可以直接用);3、把USB双公线一头插到机顶盒上面的靠近高清线的USB的端口上,另外一端插到电脑上(台式机插到电脑主机后端主板USB端口),我们把机顶盒的电源线插到电源上并连接机顶盒同时打开机顶盒上面的电源开关,短接,此时刷机工具会显示“连接成功”,; 4、点击刷机工具“开始”按钮,刷机工具自动读取升级固件,并开始自动把固件

2021-04-06_xiaokanfuchen86的博客-程序员宅基地

&lt;div id="article_content" class="article_content clearfix"&gt; &lt;link rel="stylesheet" href="https://csdnimg.cn/release/blogv2/dist/mdeditor/css/editerView/ck_htmledit_views-b5506197d8.css"&gt; &lt;div id="content_views" class.

【CTF/MISC】图片隐写_mengmeng0510的博客-程序员宅基地_ctfmisc图片隐写

图片隐写题目解题思路TweakPNG工具010editer心得体会题目链接题目题目是一张PNG的图片,将图片打开之后显示如下内容:解题思路TweakPNG工具TweakPNG工具是一个可以查看PNG图片信息的工具,我们采用这个工具打开这个图片。首先弹出了一个CRC校验的错误:这时我们点击确定,便可以看到图片的详细信息:这时我们发现了一些问题,图片的像素大小是47244724,但是图片的宽和高确实500420,因此我们可以通过010editer调整图片的高度为500010editer通

攻防世界Re第一题Hello, CTF_a859900546的博客-程序员宅基地

首先判断程序是32位的;用ida打开程序,对main反汇编分析发现一段可疑字符串,继续往下分析;发现scanf读入一段字符串 存于v9,且对该字符串有输入长度限制,初步怀疑v9为用户输入的flag往下分析发现v9赋与v4,且里用sprintf()函数将v4 16进制转换为字符串后面发现buffer赋与v10后,v10与可疑字符串有比较,所以v13可能为flag尝试将v13 进行16进制到字符串转换成功!!!!完结!...

推荐文章

热门文章

相关标签