Python （十三） pandas

发布时间：2023年12月21日

程序员的公众号：源1024，获取更多资料，无加密无套路！

最近整理了一份大厂面试资料《史上最全大厂面试题》，Springboot、微服务、算法、数据结构、Zookeeper、Mybatis、Dubbo、linux、Kafka、Elasticsearch、数据库等等
获取方式: 关注公众号并回复 666 领取，更多内容持续奉上

目录

Series

创建不指定索引

自定义索引

使用

DataFrame

创建

从文件中读取DataFrame对象

切片

使用中括号?

loc、iloc

列切片

行切片

数组切片

聚合运算

行聚合

列聚合

运算


pandas官方文档

Pandas 库的两种重要数据类型：

????????Series 类型（对应一维）

????????DataFrame 类型（对应二维）

Series

创建不指定索引

默认的位置索引从 0 开始

s = pd.Series(range(5))
print(s)

#输出
0    0
1    1
2    2
3    3
4    4
dtype: int64

自定义索引

s = pd.Series([1, 2, 3, 4], ['a', 'b', 'c', 'd'])
print(s)

#输出
a    1
b    2
c    3
d    4
dtype: int64

使用

#索引
print('index:',s.index)
#值
print('values:',s.values)
#指定索引值
print('索引b的值：',s['b'])

# 连续取值
print(s[1:3])
print(s['b':'c'])
# 不连续取值
print(s[[1,3]])
print(s[['b','c']])

#输出

index: Index(['a', 'b', 'c', 'd'], dtype='object')

values: [1 2 3 4]

索引b的值： 2

b    2
c    3
dtype: int64

b    2
c    3
dtype: int64

b    2
c    3
dtype: int64

DataFrame

DataFrame 是一种二维数据结构，DataFrame 由按一定顺序排列的多列数据组成，DataFrame 既有行索引，也有列索引。

创建

from pandas import DataFrame
df = pd.DataFrame(np.arange(10).reshape(3, 4))
print(df)

# Series对象创建
dt = {
    'col1': pd.Series([1, 2, 3], ['a', 'b', 'c']),
    'col2': pd.Series([1, 2, 3, 4], ['a', 'b', 'c', 'd']),
}
df = pd.DataFrame(dt)
print(df)

# 字典列表创建
lst = [{'col':1}, {'col':2}, {'col':3}]
df = pd.DataFrame(lst)
print(df)

# 指定行列
df = DataFrame([['小班','10'],['中班','15'],['大班','20']],columns=['name','num'])
print(df)

#输出
   0  1   2   3
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11


   col1  col2
a   1.0     1
b   2.0     2
c   3.0     3
d   NaN     4


   col
0    1
1    2
2    3

    name num
0   小班  10
1   中班  15
2   大班  20

从文件中读取DataFrame对象

print(pd.read_csv('test.csv'))  
# 读取.txt文件
print(pd.read_table('test.txt'))  
 # 读取.xls/.xlsx等excel文件
print(pd.read_excel('output.xlsx'))

#输出
 col1  col2  col3  col4
0     1     2     3     4
1    11    22    33    44
2   111   222   333   444
3  1111  2222  3333  4444


  1231qweqwrqweqwrqw123123qweqwe
0  13212312312312312312312312321
1          wwwwwwwwwwwwwwwwwwwww
2           eeeeeeeeeeeeeeeeeeee


                   列1    列2  列3
0        sys_user_sex  用户性别   0
1       sys_show_hide  菜单状态   0
2  sys_normal_disable  系统开关   0
3      sys_job_status  任务状态   0
4       sys_job_group  任务分组   0
5          sys_yes_no  系统是否   0
6     sys_notice_type  通知类型   0
7   sys_notice_status  通知状态   0
8       sys_oper_type  操作类型   0
9   sys_common_status  系统状态   0

切片

使用中括号，索引表示的是列索引，而切片表示的是行切片。

df = DataFrame(data = np.random.randint(1,50,size=(3,4)),columns=list('abcd'),index=list('ABC'))
print(df)

#输出
    a   b   c   d
A   4  26  16  27
B  19  23  49   5
C  14  26   4  11
使用中括号?
print(df['a'])
print(df['A':'B'])

#输出
A     4
B    19
C    14
Name: a, dtype: int32


    a   b   c   d
A   4  26  16  27
B  19  23  49   5
loc、iloc
列切片
#列切片
#显示索引
print(df.loc[:,'a':'b'])
#隐式索引，左闭右开
print(df.iloc[:,0:2])

#输出
    a   b
A   4  26
B  19  23
C  14  26


    a   b
A   4  26
B  19  23
C  14  26
行切片
#行切片
print(df.loc['A':'B'])
print(df.iloc[0:2])

#输出
    a   b   c   d
A   4  26  16  27
B  19  23  49   5


    a   b   c   d
A   4  26  16  27
B  19  23  49   5
数组切片
# bool列表切片
#行切片
bool_list = [True,True,False]
print(df.loc[bool_list])

#列切片,bool_list长度跟列数量一致
bool_list = [True,True,False,False]
print(df.loc[:,bool_list])

#输出
    a   b   c   d
A  19  33   6  19
B  23  11  27  10

    a   b
A  19  33
B  23  11
C   7  38
#行切片
iloc_list = [0,2]
print(df.iloc[iloc_list])

#列切片,bool_list长度跟列数量一致
iloc_list = [0,2]
print(df.iloc[:,iloc_list])


#输出
    a   b   c   d
A  19  33   6  19
C   7  38  24  44

    a   c
A  19   6
B  23  27
C   7  24

聚合运算

DataFrame中默认的聚合运算是针对每列的

axis='columns'，表示横向聚合，聚合每一行

axis='index'，表示纵向聚合，聚合每一列

df = DataFrame(data = np.random.randint(1,50,size=(3,4)),columns=list('abcd'),index=list('ABC'))
print(df)
#默认列聚合
print(df.sum())

#输出
    a   b   c   d
A  19  33   6  19
B  23  11  27  10
C   7  38  24  44

a    49
b    82
c    57
d    73
dtype: int64
行聚合
#行聚合
print(df.sum(axis='columns'))

#输出
A     77
B     71
C    113
dtype: int64
列聚合
a    49
b    82
c    57
d    73
dtype: int64
运算
df1 = DataFrame(data = np.random.randint(1,50,size=(3,4)),columns=list('ABCD'),index=list('abc'))

print(df1)
print(df1 + 1)

#输出
    A   B   C   D
a  33  40  38  16
b  45  16  48  27
c  22  15   5  17

    A   B   C   D
a  34  41  39  17
b  46  17  49  28
c  23  16   6  18
print(df1)
print(df2)
#行列索引互相对齐，无法对齐就补NaN。
print(df1 + df2)

#输出
    A   B   C   D
a  33  40  38  16
b  45  16  48  27
c  22  15   5  17

    A   B   C
a  47  36  38
b  10  48  33

      A     B     C   D
a  80.0  76.0  76.0 NaN
b  55.0  64.0  81.0 NaN
c   NaN   NaN   NaN NaN

?系列文章索引

MyBatis的插件能在哪些地方进行拦截？

了解MyBatis的缓存机制吗

面试官：谈谈对volatile的理解

Spring中用到了哪些设计模式

面试官：说一下SQL的执行过程

线程池的工作原理

??

文章来源:https://blog.csdn.net/feikillyou/article/details/135134200
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
最新文章