pandas回顾

pandas回顾

文章目录

• pandas回顾
• • 创建对象
  • 基本功能
  • 查看数据
  • 排序
  • 选择数据
  • 数据计算
  • 条件赋值
  • 缺失值处理
  • 统计操作。
  • 合并与连接
  • 重塑和数据透视表
  • groupby
  • 字符串
  • tidy数据
  • 效率和内存
  • 因子
  • 文件读写(excel)
  • 其他

#引入模块
import pandas as pd
from pandas import Series, DataFrame
import numpy as np

创建对象

#用列表建立一个Series对象 
Series([1, 2, 3, np.NaN])
# 0    1.0
# 1    2.0
# 2    3.0
# 3    NaN
# dtype: float64#用字典直接定义一个df
DataFrame({"a":[1,2,3], "b":["yang", "jian", "shuai"]})
#   a b
# 0 1 yang
# 1 2 jian
# 2 3 shuai# 利用矩阵，索引和列名建立一个df
dates = pd.date_range('20181114', periods=3)
df = pd.DataFrame(np.random.randn(3,4), index=dates, columns=list('ABCD'))
#                  A              B       C           D
# 2018-11-14  1.263934  -1.550385 2.451117  1.319753
# 2018-11-15  -0.265367 -1.980790 1.241457  0.152994
# 2018-11-16  -1.444240 1.116383  0.873009  -2.334341

• 多重索引

#行和列都可以建立多重索引
cols = pd.MultiIndex.from_tuples([(x, y) for x in ['A', 'B', 'C'] for y in ['O', 'I']])
inde = pd.MultiIndex.from_tuples([(x, y) for x in ['x', 'y'] for y in ['n', 'm']])
df = pd.DataFrame(ndf.xs("m", level=1, axis=0)p.random.randn(4, 6), index=inde, columns=cols)
print(df)
# 可以用df.xs来选取数据，第一个参数为索引名称，axis=0表示行， level=0表示多重索引中最外层的索引
df.xs("m", level=1, axis=0)
df.xs('x', level=0, axis=0)

基本功能

• 布尔值
  empty，any()， all()

df
# class   name  value m
# 0 True  a 22.0  0
# 1 False a 33.0  0
# 2 True  b 22.0  0
# 3 False c 10.0  0
# 4 True  c 0.0   0
# 5 False c NaN   0
df.empty
#False
(df>0).any() #判断每一列是否存在大于0的元素
# class     True
# name      True
# value     True
# m        False
# dtype: bool
(df>0).all() #判断每一列所有元素是否都大于0

• 复制df

df2 = df #两个变量是指同一个数据框，修改其中一个，另一个会改变。
df3 = df.copy() #建立副本，返回新的对象，修改df3，df不受影响。

• astype()强制转换
  得到的dataframe中，需要保证每一列中的数据类型是一致的。可以用这种方法转换。

#将class列中所有数据转换成bool值
df['class'] = df['class'].astype(np.bool)

• reindex()
  reindex()重新索引，只是调整现有索引的顺序，不能重命名,这和rename()是有区别的，
  reindex()可以对横轴和纵轴的标签进行选择和排序，但不能创建新的索引名称，否则显示NaN。

df = DataFrame({"a":[1,2,3], "b":["yang", "jian", "shuai"]})
df.reindex([2,1,0], axis = 'index') #也可以是axis = 'columns',即对列名进行重命名。为什么报错？
df.reindex(index =  [2, 1, 0], columns= ["b", "a"])
#   class name  value m
# 5 False c   NaN     0
# 5 False c   NaN   0
# 4 True  c   0.0   0
# 3 False c   10.0  0
# 2 True  b   22.0  0
df.reindex(columns=['name', 'class', 'value'], index=[5, 5, 4, 3, 2, 9])
#  name class value
# 5 c False NaN
# 5 c False NaN
# 4 c True  0.0
# 3 c False 10.0
# 2 b True  22.0
# 9 NaN NaN   NaN
df.reindex(df2.index) #df2可以是df的子集，实现对df的筛选。
df.reindex_like(df2)# 让df的索引和df2的索引一致。
df.rename({""})

• 迭代

for col in df:print(col)print(type(col))

查看数据

• df.head(n) #返回前n行数据
• df.tail() #返回后n行数据
• df.columns #列信息。将列名放在列表中：list(df.columns)
• df.index #行索引
• df.values #返回一个表示df数据的numpy数组
• df.describe() #df的统计信息，包括各列的数量、分位点、平均值等
• df.T #转置数据，得到的也是一个DataFrame
• df.A.nlargest(n) 取A列最大的n个值 (最小：nsmallest(n))。或者df.nlargest(n, “A”)，不过返回的是DataFrame。
• df.A.quantile([0.5])

# 查看df的列属性
df.dtypes
# A    float64
# B    float64
# C    float64
# D    float64
# dtype: object
df.describe()
# A B C D
# count 3.000000  3.000000  3.000000  3.000000
# mean  -0.148558 -0.804931 1.521861  -0.287198
# std 1.357861  1.677765  0.825576  1.866394
# min -1.444240 -1.980790 0.873009  -2.334341
# 25% -0.854803 -1.765587 1.057233  -1.090674
# 50% -0.265367 -1.550385 1.241457  0.152994
# 75% 0.499284  -0.217001 1.846287  0.736374
# max 1.263934  1.116383  2.451117  1.319753

排序

（一般情况下，axis=1是对行操作，axis=0是对列操作。）

• 按索引名称排序，axis = 1对每一行数据排序，就是依据列名称排序。axis = 0 对每一列数据排序，依据行索引大小排序。
• 按某列的值排序。默认升序。

df.sort_index(axis=1, ascending=False)
#                   D         C         B           A
# 2018-11-14  1.319753  2.451117  -1.550385 1.263934
# 2018-11-15  0.152994  1.241457  -1.980790 -0.265367
# 2018-11-16  -2.334341 0.873009  1.116383  -1.444240
df.sort_index(axis=0, ascending=False)
#                   A         B         C           D
# 2018-11-16  -1.444240 1.116383  0.873009  -2.334341
# 2018-11-15  -0.265367 -1.980790 1.241457  0.152994
# 2018-11-14  1.263934  -1.550385 2.451117  1.319753
df.sort_values(by='B')
#                   A         B         C           D
# 2018-11-15  -0.265367 -1.980790 1.241457  0.152994
# 2018-11-14  1.263934  -1.550385 2.451117  1.319753
# 2018-11-16  -1.444240 1.116383  0.873009  -2.334341

选择数据

• 选择行,返回第m到n-1行数据，dataframe。

#这里必须是切片操作，如果写成df[0], 会报错。
df[m:n]

• 选择列,返回Series

df["A"]
df.A

• df.loc[,]
  第一个参数表示行索引名称，第二个参数表示列索引名称，两个参数都可以加中括号，返回的结果的维度不一样。

#两参数都有中括号，返回二维的数据框
type(df.loc[[dates[0]], ["A"]])
#pandas.core.frame.DataFrame
#返回Series
type(df.loc[dates[0], ["A"]])
# pandas.core.series.Series
#返回标量
type(df.loc[dates[0], "A"])
# numpy.float64df.loc['2018-11-14':'2018-11-15',['A','B']]
#                A             B
# 2018-11-14  1.263934  -1.550385
# 2018-11-15  -0.265367 -1.980790

• df.iloc[,]
  按索引位置的序号来选择数据。

df.iloc[0] #选择第0行数据，Series
df.iloc[0:1, 0:2] #选择第0行，第0，1列数据。切片选择范围时不包括最后一个数字。
df.iloc[0, 0] #获取第0行、第0列的标量数据。
df.iloc[[0], [0]] #获取第0行、第0列的DataFrame数据框。
df.iloc[:, 0:2] #获取所有行、第0、1列

• 布尔索引
  常用布尔结果对数据进行筛选。这里貌似只能筛选行。

df['A']>0
# 2018-11-14     True
# 2018-11-15    False
# 2018-11-16    False
# Freq: D, Name: A, dtype: bool
df[[True, False, False]] #只显示为True的行。
df[df['A']>0] #筛选A列大于0的行
df[(df['A']<0) & (df['B']>0)] #筛选A列小于0且B列大于0的行，需要括号包裹两个条件。
df[(df['A']<0) | (df['B']>0)] #筛选A列小于0或B列大于0的行，需要括号包裹两个条件。
df[(df['A']<0) ^ (df['B']>0)] #对称差集，在两集合中的并集中剔除交集的部分。
df[~(df['A']<0)]  #补集
df2 
#                 A           B         C        D     E
# 2018-11-14  1.263934  -1.550385 2.451117  1.319753  m
# 2018-11-15  -0.265367 -1.980790 1.241457  0.152994  n
# 2018-11-16  -1.444240 1.116383  0.873009  -2.334341 t
df2[df2['E'].isin(['m', 'n'])] #筛选E列中值在['m', 'n'] 范围内的数据。这里的isin()相当于R语言中的%in%.
#                 A           B         C        D     E
# 2018-11-14  1.263934  -1.550385 2.451117  1.319753  m
# 2018-11-15  -0.265367 -1.980790 1.241457  0.152994  n

• 新增及修改字段 assign()，类似R语言tideyverse包中的mutate()函数

# 修改df中的Value字段，并增加新列Value_2，返回新的数据框。这里的x是调用该方法的对象。
df = pd.DataFrame({'Color': 'Red Red Red Blue'.split(),'Value': [100, 150, 50, 50]})
df.assign(Value   = lambda x:x.Value+1,Value_2 = lambda x:x.Value+2)

数据计算

包括统计学函数、窗口函数等。参考pandas官方文档

• 移动窗口操作 rolling()

df = pd.DataFrame({"a":range(9)})
df.a.rolling(3, center=False).sum() #这里以三条记录为一组，即某一行及前两行的记录;如果center=True，则取某行及前一行和后一行的记录。
df.a.rolling(2).mean()#移动平均

或者直接用df来调用

dates = pd.date_range('20181114', periods=6)
df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=list('ABCD'))
df.rolling(2, center=True,on="A").sum()#默认是以index为观察目标的，如果用on="A"，则指定观察目标为"A"列，即对移动A列。

• resample()
  对于时间和日期索引的dataframe数据，用resample()函数可以选择不同时间间隔作为分组。

idx = pd.date_range('1/1/2019', periods=80, freq='d')
df3 = pd.DataFrame({"no":range(80), "b":range(1, 81,1)}, index=idx)
df4 = df3.drop(df3.index[[2,3]], axis = 0) #故意删掉两个日期索引2019-01-03， 2019-01-04，
df4
df4.resample('5d').sum()#统计每五天的数据之和，这里仍然是以1号到5号为一组进行求和，是以固定日期来分组，而不是日期索引的数量来分组。
df4.resample('5d').ohlc()#开始、结束、最高、最低

条件赋值

对符合某些条件的字段赋新值

#直接修改原df，注意等号左右两边的对象不一定一致，左边可以是dataframe，右边可以是常量。
df.loc['2018-11-14', "A"] = 0
#将df中大于0的数据变成负的。df[df>0]的返回结果中不符合条件的数据用NaN表示。
df[df>0] = -df 
#先根据布尔条件筛选数据，然后再设置值
df.loc[df[df['A']<0].index, "A"] = 0
df.loc[df.A<0, ["A"]] = 0
#多个条件，这里用np.where()
df['A'] = np.where(df['A'] > 5, 'high', 'low')

缺失值处理

统计操作。

• 可以使用常见的统计函数。
  df.count()
  df.mean()等
• 也可以使用自定义函数。
  apply()用于DataFrame中的列或行。
  applymap()用于DataFrame中的每一个元素。
  map()函数作用于一个Series的每一个元素，注意，mpa(f)中的参数f不但可以是函数，也可以Series的映射。

#将自定义函数应用于每一列，这里的x就是默认为列，也可以指定第二个参数为0。
df = pd.DataFrame({"A":[1,2,3,4], "B":[3,4,5,6]})
df.apply(lambda x: x.max() - x.min(), 0)
#第二个参数为1，将自定义函数应用于每一行。
df.apply(lambda x: x.max() - x.min(), 1)
df.applymap(lambda x:0)
df["A"].map(lambda x : 1)
# 这里的s是Series格式，可以作为一种函数映射关系 
s = pd.Series({1:"a", 2:"b", 3:"c"})
df["A"].map(s)

合并与连接

• concat()
  pd.concat(objs, axis=0, join=‘outer’, join_axes=None, ignore_index=False,
  keys=None, levels=None, names=None, verify_integrity=False,
  copy=True)

df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],'B': ['B0', 'B1', 'B2', 'B3'],'C': ['C0', 'C1', 'C2', 'C3'],'D': ['D0', 'D1', 'D2', 'D3']},index=[0, 1, 2, 3])df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],'B': ['B4', 'B5', 'B6', 'B7'],'C': ['C4', 'C5', 'C6', 'C7'],'E': ['E4', 'E5', 'E6', 'E7']},index=[3, 5, 6, 7])
#将多个数据框放在一个列表中，默认按列操作，就是把数据框上下拼接在一起，可以存在相同的行索引。
pd.concat([df1, df2],keys=['x', 'y']) #选择所有的列，并添加外层索引['x','y']pd.concat([df1, df2], join='inner') #选择共同的列
#   A B C
# 0 A0  B0  C0
# 1 A1  B1  C1
# 2 A2  B2  C2
# 3 A3  B3  C3
# 3 A4  B4  C4
# 5 A5  B5  C5
# 6 A6  B6  C6
# 7 A7  B7  C7
pd.concat([df1, df2], axis=1) #选择所有的行
#   A B C D A B C E
# 0 A0  B0  C0  D0  NaN NaN NaN NaN
# 1 A1  B1  C1  D1  NaN NaN NaN NaN
# 2 A2  B2  C2  D2  NaN NaN NaN NaN
# 3 A3  B3  C3  D3  A4  B4  C4  E4
# 5 NaN NaN NaN NaN A5  B5  C5  E5
# 6 NaN NaN NaN NaN A6  B6  C6  E6
# 7 NaN NaN NaN NaN A7  B7  C7  E7
pd.concat([df1, df2], axis=1, join='inner') #选择共同的行
#   A B C D A B C E
# 3 A3  B3  C3  D3  A4  B4  C4  E4

• merge()
  pd.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,
  validate=None)
  类似于sql中连接操作。how参数指定连接方式， on、lef_on、right_on可以指定连接的索引名称。
• append()
  你可以DataFrame通过传递一个Series或一个dict来 向a追加一行append，这将返回一个新的DataFrame。

 s2 = pd.Series(['X0', 'X1', 'X2', 'X3'], index=['A', 'B', 'C', 'D'])df1.append(s2, ignore_index=True)
#    A  B C D
# 0 A0  B0  C0  D0
# 1 A1  B1  C1  D1
# 2 A2  B2  C2  D2
# 3 A3  B3  C3  D3
# 4 X0  X1  X2  X3

• align()

 df.align(df2, join='inner')

重塑和数据透视表

pivot() 类似于R语言tidyverse包中的spread(),就是把行转列。但是列转行用melt()
melt()
df.pivot(index=‘date’, columns=‘variable’, values=‘value’)

df
#  name subject score
# 0 A Math  84
# 1 A English 89
# 2 A History 70
# 3 B Math  90
# 4 B English 84
# 5 B History 59
# 6 C Math  72
# 7 C English 62
# 8 C History 54df2 = df.pivot(index="name", columns='subject', values='score')
# subject English History Math
# name      
# A 89  70  84
# B 84  59  90
# C 62  54  72

stack():针对多重索引

pivot_table() 类似于excel中的数据透视表，主要参数包括行，列，值，聚合函数。
pd.pivot_table(df, values=‘D’, index=[‘A’, ‘B’], columns=[‘C’], aggfunc=np.sum)
crosstab()交叉表，计算频数,对不同字段的取值进行分类统计。

df1
#   A B C D
# 0 A0  B0  C0  D0
# 1 A1  B1  C1  D1
# 2 A2  B2  C2  D2
# 3 A3  B3  C3  D3
pd.crosstab(df1.A, df1.B) # 如果添加参数normalize=True，得到的是比例。
# B     B0  B1  B2  B3
# A       
# A0  1 0 0 0
# A1  0 1 0 0
# A2  0 0 1 0
# A3  0 0 0 1

pd.cut()将连续变量转换成离散变量。

groupby

可以根据列名分组，也可以根据不同级别索引来分组。
分组统计,直接调用聚合函数

df = DataFrame({"name":["a","a", "b", "c", "c", "c"], "class":[1, 0, 1, 0, 1, 0], "value":[22, 33, 22, 10, 0,np.NaN]})
# class name value
# 0 1 a 22.0
# 1 0 a 33.0
# 2 1 b 22.0
# 3 0 c 10.0
# 4 1 c 0.0
# 5 0 c NaN
# 只返回某个分组下的结果
a = df.groupby(["name"])
a.get_group("a")#对name分组并统计每一列的数量，不包括np.NaN
df.groupby(["name"]).count()
#   class value
# name    
# a 2 2
# b 1 1
# c 3 2#k只统计某一列，返回的是Series
df.groupby(["name"])['value'].count()
# name
# a    2
# b    1
# c    2
# Name: value, dtype: int64
#value_counts()也可以统计不同取值的数量。
df.name.value_counts()#取每个分组第0行。first()，last()等
df.groupby(["name"]).nth(0)
#   class value
# name    
# a 1 22.0
# b 1 22.0
# c 0 10.0#分组并筛选
df.groupby(["name"])['value'].filter(lambda x:x.sum()>20)
#也可以取最大值df.groupby(["name"])['value'].max()
# 0    22.0
# 1    33.0
# 2    22.0
# Name: value, dtype: float64# 对value字段进行多方面统计，注意聚合函数放在列表中。
df.groupby(["name"])['value'].agg([np.mean, np.sum, np.min, np.size])
#   mean  sum     amin  size
# name        
# a 27.5  55.0  22.0  2.0
# b 22.0  22.0  22.0  1.0
# c 5.0     10.0  0.0     3.0#也可以对结果中列名重新定义。重命名，也可以对行索引进行重命名。
df.groupby(["name"])['value'].agg([np.mean, np.sum, np.min, np.size]).rename(columns={"mean":"me", "sum":"su", "amin":"am", "size":"si"})#分组后，对不同字段使用不同的函数
df.groupby(["name"]).agg({"class": lambda x: max(x) - min(x), "value": np.sum})
# 这种写法会提示废弃警告，可以写成下面这样：
#df.groupby(["name"]).agg(分类 = lambda x: max(x) - min(x), value =  np.sum) 字段名可以用汉字，不用引号
# class value
# name    
# a 1 55.0
# b 0 22.0
# c 1 10.0#使用get_group()获取某分组条件下的group，注意入参为元组。这里获取的是name为c,class为0的组。
df.groupby(["name", "class"]).get_group(('c', 0))
# class name  value
# 3 0 c 10.0
# 5 0 c NaN#对分组进行迭代。
for name, group in df.groupby(["name"]):print(name)print(type(group))
# a
# 
# b
# 
# c
# #对每个分组内的记录进行单独标注行数
df.groupby(["name"]).cumcount()
# 0    0
# 1    1
# 2    0
# 3    0
# 4    1
# 5    2
# dtype: int64```python
## 时间序列
- 索引为日期格式
Timestamp：  表示单个时间戳 to_datetime， Timestamp
DatetimeIndex：   Timestamp  to_datetime，date_range，bdate_range，DatetimeIndex
Period： 表示单个时间跨度  Period
PeriodIndex： Period period_range， PeriodIndexpd.date_range('2018-11-15', periods=10, freq='D')# DatetimeIndex(['2018-11-15', '2018-11-16', '2018-11-17', '2018-11-18',#               '2018-11-19', '2018-11-20', '2018-11-21', '2018-11-22',#               '2018-11-23', '2018-11-24'],#              dtype='datetime64[ns]', freq='D')

• dt
  如果某一列是日期格式，则Series可以用dt分析。

import datetime
import pandas as pd
s = pd.Series(pd.date_range('2012-1-1', periods=5, freq='D'))
print(s)
print(s.max()-s)
s2 = s + datetime.timedelta( days = 1, hours = 1, minutes = 5, seconds = 59)
print(s2)
print(s2.dt.year)# 详细点：
df = DataFrame(pd.date_range('2018-11-15', periods=6, freq='D'), columns = ["date"])
#     date
# 0 2018-11-15
# 1 2018-11-16
# 2 2018-11-17
# 3 2018-11-18
# 4 2018-11-19
# 5 2018-11-20
df['date'].dt.year
# 0    2018
# 1    2018
# 2    2018
# 3    2018
# 4    2018
# 5    2018
# Name: date, dtype: int64
df['date'][df['date'].dt.day > 18]
# 4   2018-11-19
# 5   2018-11-20
# Name: date, dtype: datetime64[ns]

字符串

Series和Index配备了一组字符串处理方法，可以轻松地对阵列的每个元素进行操作。也许最重要的是，这些方法会自动排除缺失/ NA值。这些是通过str属性访问的。
str属性是Series和Index具有的，不能用DataFrame直接调用，可以使用apply()

s = Series(["Alice B ", "  d ef  ", 'hello world', 'yang.j', 'jian.yang'])
# 0       Alice B 
# 1         d ef  
# 2    hello world
# 3         yang.j
# 4      jian.yang
# dtype: object
s.str.upper() #大写
s.str.lower() #小写
s.str.capitalize() #首字母大写
s.str.len() #长度
s.str.strip() #去掉首尾空格
s.str.lstrip()#去掉首部空格
s.str.rstrip()#去掉尾部空格
s.str.replace(" ", ".", regex=False) #把字符串中的空格替换成.符号,不使用正则。也可以支持正则及re.compile()对象。
s.str.split(' ') #根据空格分割
# 0       [Alice, B, ]
# 1    [, , d, ef, , ]
# 2     [hello, world]
# 3           [yang.j]
# 4        [jian.yang]
# dtype: object
s.str.get(0) #获取第0个字符
s.str.split(' ',expand=True, n=2) #这里的n是指只使用前n个分割符。
s.str.rsplit('_', expand=True, n=1) #反向分割
s.str[0]#获取第0个字符，和上面一样
# 0    A
# 1     
# 2    h
# 3    y
# 4    j
# dtype: object
s.str.cat(sep='_')#用符号把所有字符串连接成一个字符串。
# 'Alice B _  d ef  _hello world_yang.j_jian.yang'
s.str.cat(list('01234'), sep='_') #也可以和同样大小的列表拼接。这里也可以把df的两列拼在一起。
# 0       Alice B _0
# 1         d ef  _1
# 2    hello world_2
# 3         yang.j_3
# 4      jian.yang_4
# dtype: object#该extract方法接受具有至少一个捕获组的正则表达式。
#但要注意，所有的正则表达式必须有一个或多个分组，也就是正则的引号内要有一组或多组括号。
s.str.extract(r'a') #这样写会报错。
s.str.extract(r'(a)') #这样写是正确的。
#正则中有两个分组，并用P来命名，对应结果中两列的列名。由于直接生成多列，有时比split()好用。
s.str.extract(r'(?P\w?)(?P\w+)',expand=True) #在未来的版本，expand=True返回DataFrame.
# col_1 col_2
# 0 A lice
# 1   d
# 2 h ello
# 3 y ang
# 4 j ian
s.str.extractall()#提取所有匹配内容。#匹配，返回True或False.
pattern = r'a'
s.str.contains(pattern) #支持正则，可以理解成包含，类似于re.search()。
# 0    False
# 1    False
# 2    False
# 3     True
# 4     True
# dtype: bool
s.str.match(pattern)#支持正则，类似于re.match(),从首字符开始匹配。
# 0    False
# 1    False
# 2    False
# 3    False
# 4    False
# dtype: bool

tidy数据

与R语言中的管道符号相似，pandas也有类似的使用方式。
比如以下示例中，每一步操作都用“点”符号连接，且是在上一步的返回结果上进行的。整个代码需要放在一个括号中，否则会报错。

df = pd.DataFrame({'Color': 'Red Red Red Blue'.split(),'Value': [100, 150, 50, 50]})
res = (df .rename(columns={"Color":"color"}) #修改字段名，返回新的数据框，这一步的返回结果已经不是df了。.assign(x = lambda x:x.color, #注意：这里的x是调用该方法的新数据框，不是df，所以用小写的colory = df.Color)         #这里用的是原数据框df，所以字段名是大写的Color.sort_index().groupby(["color"]).agg("count").loc[:,["x", "y"]]#最后只选择新增的两个字段x,y
)
print(res)

效率和内存

• 可以使用cython、numba等方法，提升程序运行速度。

import numba
import numpy as np
import pandas as pd
@numba.jit
def abc(x):for i in range(10000):for j in range(100):for k in range(100):x = 0
%timeit abc(10) #jupyter中可以使用这个命令来计算运行时间。

• 节约存储空间：
  如果某一字段是存量大量重复值的字符串，如性别、省份、学历等，可以把这一列转换成category类型时，pandas会用一种最省空间的int子类型去表示这一列中所有的唯一值，以节省存储空间。

data['a'] = data['a'] .astype('category')

另外，由于数值型数据有多种存储格式，如int8、int32等，函数pd.to_numeric()可以对数值型数据进行向下类型转换，以节省存储空间

因子

指分类数据 dtype=“category”，类似于R语言中的factor。
df[“B”] = df[“A”].astype(‘category’)。可以降低字符串数据占用的内存。

文件读写(excel)

• 生成和读取excel

#生成
DataFrame.to_excel(excel_writer, sheet_name='Sheet1', na_rep='', float_format=None, columns=None, header=True, index=True, index_label=None, startrow=0, startcol=0, engine=None, merge_cells=True, encoding=None, inf_rep='inf', verbose=True, freeze_panes=None)
'''
该函数主要参数为:excel_writer。
excel_writer:写入的目标excel文件，可以是文件路径、ExcelWriter对象;
sheet_name:被写入的sheet名称，string类型，默认为'sheet1';
engine:也很重要，可以与openpyxl库对接。
na_rep:缺失值表示，string类型;
header:是否写表头信息，布尔或list of string类型，默认为True;
index:是否写行号，布尔类型，默认为True;
encoding:指定写入编码，string类型。
'''
import pandas as pd
writer = pd.ExcelWriter(path) #path为工作簿的路径和名称
data.to_excel(writer, 'sheet1') #sheet1为工作表的名称， data为DataFrame数据
writer.save()#保存数据的步骤不能少#读取
pd.read_excel(io, sheetname=0, header=0, skiprows=None, skip_footer=0, index_col=None, names=None, parse_cols=None, parse_dates=False, date_parser=None, na_values=None, thousands=None, convert_float=True, has_index_names=None, converters=None, dtype=None, true_values=None, false_values=None, engine=None, squeeze=False, **kwds)'''该函数主要的参数为io、sheetname、header、names、encoding。io:excel文件，可以是文件路径、文件网址、file-like对象、xlrd workbook;sheetname:返回指定的sheet，参数可以是字符串（sheet名）、整型（sheet索引）、list（元素为字符串和整型，返回字典{'key':'sheet'}）、none（返回字典，全部sheet）;header:指定数据表的表头，参数可以是int、list of ints，即为索引行数为表头;names:返回指定name的列，参数为array-like对象。encoding:关键字参数，指定以何种编码读取。该函数返回pandas中的DataFrame或dict of DataFrame对象，利用DataFrame的相关操作即可读取相应的数据。'''
data = pd.read_excel('excel文件的路径和名称')
print(data)

其他

找出出现次数最多的元素。

s = pd.Series([1, 1, 3, 3, 5, 5, 7, 7, 7])
s.mode()

pd.mode()
参考文档

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！