pandas概述
- pandas是python第三方库，提供高性能易用数据类型和分析工具
- pandas基于numpy实现，常与numpy和matplotlib一同使用
- pandas中有两大核心数据结构：Series（一维数据）和DataFrame（多特征数据，既有行索引，又有列索引）。
- series
- series是一维数组，跟numpy中的一维array类似。
- series、numpy中的一维array和python中的list也很相近，其区别是：list中的元素可以是不同的数据类型，而array和series中则只允许存储相同的数据类型。
- series可以更好的使用内存，提高运算效率
- series的数据结构为“键值对”的形式，其中键可以重复。
|
index
|
value
|
|
0
|
12
|
|
1
|
4
|
|
2
|
7
|
|
3
|
9
|
- Time-Series：以时间为索引的Series
- DataFrame
- 可以进行行索引，列索引，是pandas中重要的数据结构。
- 带标签且大小可变的二维表格型数据结构，可以将DateFrame理解为Series的容器。
|
index
|
writer
|
title
|
price
|
|
0
|
mark
|
cookbook
|
23.56
|
|
1
|
barket
|
HTML5
|
50.70
|
|
2
|
tom
|
Python
|
12.30
|
|
3
|
job
|
Numpy
|
28.00
|
- Panel：三维的数组，可以理解为DataFrame的容器。
series
创建函数：
语法：
pandas.Series(data,index,dtype,copy)
|
参数
|
描述
|
data
|
数据采用各种方式，如：ndarray，list，constants
|
index
|
索引值必须是唯一的和散列的，与数据的长度相同。默认np.arange(n)。如果没有索引被传递
|
dtype
|
用于数据类型。如果没有，将推断数据类型
|
copy
|
复制数据，默认为false
|
- 创建的三种方式：
- 使用python数组创建
- 使用numpy数组创建
- 使用python字典创建
- PS：与字典不同的是：series允许索引重复。
import numpy as np
import pandas as pd
a = pd.Series([11,12],index = ["北京","上海"])
print(a)
#输出：
北京 11
上海 12
dtype: int64b = pd.Series(np.arange(3,6))
print(b)
#输出：
0 3
1 4
2 5
dtype: int32c = pd.Series({'北京':11,'上海':12,'深圳':14})
print(c)
#输出：
北京 11
上海 12
深圳 14
dtype: int64
Series索引
import numpy as np
import pandas as pd
obj = pd.Series([4,7,-5,3])
print(obj.values)
#输出：[ 4 7 -5 3]print(obj.index)
#输出：RangeIndex(start=0, stop=4, step=1)print(obj[2])
#输出：-5obj[1] = 8
print(obj[[0,1,3]])
#输出：
0 4
1 8
3 3
dtype: int64
Series重要功能
import numpy as np
import pandas as pd
obj1 = pd.Series({"Ohio":3500,"Oregon":1600,"Texas":7000,"Utah":5000})
obj2 = pd.Series({"California":np.nan, "Ohio":3500,"Oregon":1600,"Texas":7100})
print(obj1 + obj2)
#输出：
California NaN
Ohio 7000.0
Oregon 3200.0
Texas 14100.0
Utah NaN
dtype: float64#当我们想让没有的数据默认为0，然后进行计算，我们需要用到 add()函数
print(obj1.add(obj2,fill_value = 0)) #fill_value 为数据缺失时的默认值
#输出：
# California 2000.0
# Ohio 7000.0
# Oregon 3200.0
# Texas 14100.0
# Utah 5000.0
# dtype: float64
|
方法（pandas四则运算）
|
说明
|
add()
|
加法，s1.add(s2,fill_value = 0)
|
sub()
|
减法，s1.sub(s2,fill_value = 0)
|
mul()
|
乘法，s1.mul(s2,fill_value = 0)
|
div()
|
除法，s1.div(s2,fill_value = 0)
|
- Series对象本身及其索引都有一个name属性
- Series的索引可以通过赋值的方式就地修改
import numpy as np
import pandas as pd
obj1 = pd.Series({"Ohio":3500,"Oregon":1600,"Texas":7000,"Utah":5000})
obj2 = pd.Series({"California":np.nan, "Ohio":3500,"Oregon":1600,"Texas":7100})
obj3 = obj1 + obj2obj3.name = 'population'
obj3.index.name = 'state'
print(obj3)#输出：
state
California NaN
Ohio 7000.0
Oregon 3200.0
Texas 14100.0
Utah NaN
Name: population, dtype: float64——————————————————————————————————分割线——————————————————————————————————import numpy as np
import pandas as pd
obj1 = pd.Series([4,7,-5,3])
obj1.index = ['bob','steve','jeff','ryan']
print(obj1)#输出：
bob 4
steve 7
jeff -5
ryan 3
dtype: int64
DataFrame
- DataFrame是一个表格型的数据类型，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔值等）
- DataFrame既有行索引又有列索引，它可以被看作由Series组成的字典（共用同一个索引）
- 跟其他类似的数据结构相比（比如R语言的data.frame），DataFrame中面向行和面向列的操作基本是平衡的。
- DataFrame中的数据是以一个或多个二维块存放的（而不是列表，字典或别的一维数据结构）
DataFrame特点
- 潜在的列是不同的类型
- 大小可变
- 标记轴（行和列）
- 可以对行和列执行算数运算
DataFrame构造函数
语法：
pandas.DataFrame(data,index,columns,dtype,copy)
|
参数
|
描述
|
data
|
数据采用各种方式，如：ndarray，series，map，list，dict，constants 和另一个DataFrame
|
index
|
行标签，要用于结果帧的索引是可选缺省值np.arange(n),如果没有传递索引值。
|
columns
|
列标签，可选的默认语法是np.arange(n)。这只有在没有索引传递的情况下才是这样。
|
dtype
|
每一列的数据类型
|
copy
|
如果默认值为False，则此命令用于赋值数据。
|
创建DataFrame
- 当DataFrame中有中文时，由于中文占用的字符和英文、数字占用的字符不一样，会出现对不齐的情况出现，需要调用
pd.set_option()函数，使表格对齐。
pd.set_option('display.unicode.ambiguous_as_wide', True)
pd.set_option('display.unicode.east_asian_width', True)
- 创建一个空的DataFrame：函数不指定参数时返回空的DataFrame
import pandas as pd
df = pd.DataFrame()
print(df)
#输出：
Empty DataFrame
Columns: []
Index: []
import pandas as pd
#从单个列表创建DataFrame
data = [1,2,3,4]
df = pd.DataFrame(data)
print(df)
#输出：0 #这个0为列标签
0 1
1 2
2 3
3 4#从嵌套列表创建DataFrame，并指定数据类型
data1 = [['Alex',10],['Bob',12],['Clarke',13]]
df1 = pd.DataFrame(data1,columns = ['Name','age'],dtype = float)
print(df1)
#输出：Name age
0 Alex 10.0
1 Bob 12.0
2 Clarke 13.0
- 由等长列表或numpy数组组成的字典创建DataFrame
- DataFrame结果会自动加上索引（和series一样），且全部会被有序排列
- 如果指定了列顺序，则DataFrame的列就会按照指定顺序进行排列
- 跟原series一样，如果传入的列在数据中找不到，就会产生NaN值。
import pandas as pd
data = {'state':['Ohio','Ohio','Ohio','Nevada','Nevada'],'year':[2000,2001,2002,2001,2002],'pop':[1.5,1.7,3.6,2.4,2.9]}
df = pd.DataFrame(data)
print(df)
#输出：state year pop
0 Ohio 2000 1.5
1 Ohio 2001 1.7
2 Ohio 2002 3.6
3 Nevada 2001 2.4
4 Nevada 2002 2.9#改变了列顺序，数据也跟着改变
df1 = pd.DataFrame(data,columns = ['year','pop','state'])
print(df1)
#输出：year pop state
0 2000 1.5 Ohio
1 2001 1.7 Ohio
2 2002 3.6 Ohio
3 2001 2.4 Nevada
4 2002 2.9 Nevada#列索引不到值时，返回NaN值
df2 = pd.DataFrame(data,columns = ['year','pop','state','debt'],index = ['one','two','three','four','five'])
print(df2)
#输出：year pop state debt
one 2000 1.5 Ohio NaN
two 2001 1.7 Ohio NaN
three 2002 3.6 Ohio NaN
four 2001 2.4 Nevada NaN
five 2002 2.9 Nevada NaN
DataFrame简单操作
- 通过类似字典标记的方式或属性的方式，可以将DataFrame的列获取为一个Series
- 返回的Series拥有原DataFrame相同的索引，且其name属性也已经被相应的设置好了
import pandas as pd
data = {'state':['Ohio','Ohio','Ohio','Nevada','Nevada'],'year':[2000,2001,2002,2001,2002],'pop':[1.5,1.7,3.6,2.4,2.9]}
df = pd.DataFrame(data)print(df['state'])
#输出：
0 Ohio
1 Ohio
2 Ohio
3 Nevada
4 Nevada
Name: state, dtype: object
import pandas as pd
import numpy as np
data = {'state':['Ohio','Ohio','Ohio','Nevada','Nevada'],'year':[2000,2001,2002,2001,2002],'pop':[1.5,1.7,3.6,2.4,2.9]}
df = pd.DataFrame(data)
df['debt'] = 16.5
print(df)
#输出：state year pop debt
0 Ohio 2000 1.5 16.5
1 Ohio 2001 1.7 16.5
2 Ohio 2002 3.6 16.5
3 Nevada 2001 2.4 16.5
4 Nevada 2002 2.9 16.5df['debt'] = np.arange(5.) #np.arange()中的5. 表示5个浮点式的数
print(df)
#输出：state year pop debt
0 Ohio 2000 1.5 0.0
1 Ohio 2001 1.7 1.0
2 Ohio 2002 3.6 2.0
3 Nevada 2001 2.4 3.0
4 Nevada 2002 2.9 4.0
- 将列表或数组赋值给某个列时，其长度必须跟DataFrame的长度相匹配
- 如果赋值的是一个Series，就会精确匹配到DataFrame的索引，所有空位都将被填上缺失值
import pandas as pd
import numpy as np
data = {'state':['Ohio','Ohio','Ohio','Nevada','Nevada'],'year':[2000,2001,2002,2001,2002],'pop':[1.5,1.7,3.6,2.4,2.9]}
df = pd.DataFrame(data,columns = ['state','pop','year','debt'],index = ['one','two','three','four','five'])val = pd.Series([-1.2,-4.5,-1.7],index = ['two','four','five'])
df['debt'] = val
print(df)
#输出：state pop year debt
one Ohio 1.5 2000 NaN
two Ohio 1.7 2001 -1.2
three Ohio 3.6 2002 NaN
four Nevada 2.4 2001 -4.5
five Nevada 2.9 2002 -1.7
- 为不存在的列赋值会创建一个新列
- 删除列:del 或者 drop()
- drop()函数中有三个参数：第一个参数是要删除的列名或索引。axis 表示针对行或列进行删除，axis = 0 表示删除对应的行，axis = 1 表示删除对应的列，axis 默认为 0。 inplace = True 表示直接修改原数据，否则 drop() 方法只是返回删除后的表格，对原表格没有影响。
df.drop('列名或行索引',axis,inplace = True)
import pandas as pd
import numpy as np
data = {'state':['Ohio','Ohio','Ohio','Nevada','Nevada'],'year':[2000,2001,2002,2001,2002],'pop':[1.5,1.7,3.6,2.4,2.9]}
df = pd.DataFrame(data,columns = ['state','pop','year','debt'],index = ['one','two','three','four','five'])df['eastern'] = df.state == 'Ohio'
print(df)
#输出：state pop year debt eastern
one Ohio 1.5 2000 NaN True
two Ohio 1.7 2001 NaN True
three Ohio 3.6 2002 NaN True
four Nevada 2.4 2001 NaN False
five Nevada 2.9 2002 NaN False******************以下是删除列方法******************
''' del 删除 '''del df['eastern']
print(df)
#输出：state pop year debt
one Ohio 1.5 2000 NaN
two Ohio 1.7 2001 NaN
three Ohio 3.6 2002 NaN
four Nevada 2.4 2001 NaN
five Nevada 2.9 2002 NaN''' drop()函数删除 '''
df.drop('pop',axis = 1,inplace = True)
print(df)
#输出：
# state year debt
# one Ohio 2000 NaN
# two Ohio 2001 NaN
# three Ohio 2002 NaN
# four Nevada 2001 NaN
# five Nevada 2002 NaN
- 将嵌套字典（字典的字典）传给DataFrame，他就会被解释为：外层字典的键为列，内层键为行索引。也可以对结果进行转置。
import pandas as pd
import numpy as np
data = {'Nevada':{2001:2.4,2002:2.9},'Ohio':{2001:2.4,2002:2.9,2003:1.6}}
df = pd.DataFrame(data)print(df)
#输出：Nevada Ohio
2001 2.4 2.4
2002 2.9 2.9
2003 NaN 1.6print(df.T)
#输出：2001 2002 2003
Nevada 2.4 2.9 NaN
Ohio 2.4 2.9 1.6'''如果设置了DataFrame的index和columns的name属性，则这些信息也会显示出来
'''
df.index.name = 'years'
df.columns.name = 'states'
print(df)
#输出：
states Nevada Ohio
years
2001 2.4 2.4
2002 2.9 2.9
2003 NaN 1.6
pandas常用方法
数据的读取与写入
- pandas支持常用的文本格式数据（csv、json、html、剪贴板）、二进制数据（excel、hdf5格式、feather格式、parquet格式、msgpack、stata、SAS、pkl）、SQL数据（SQL、谷歌BigQuery云数据）等。
- 一般情况下，读取文件的方法以
pd.read_开头，而写入文件的方法以pd.to_开头。
|
数据类型
|
描述符
|
读方法
|
写方法
|
|
text
|
CSV
|
read_csv
|
to_csv
|
|
text
|
JSON
|
reak_json
|
to_json
|
|
text
|
HTML
|
read_csv
|
to_csv
|
|
text
|
剪贴板
|
read_clipboard
|
to_clipboard
|
|
二进制
|
Excel
|
read_excel
|
to_excel
|
|
二进制
|
HDF5
|
read_hdf
|
to_hdf
|
|
二进制
|
PKL
|
read_pickle
|
to_pickle
|
|
SQL
|
SQL
|
read_sql
|
to_sql
|
import pandas as pd
import numpy as np
from pandas import Series,DataFrame'''示例1，读入剪贴板数据，写入csv，转换为json、html、excel等格式
'''#剪贴板内容
# A B C
# x 1 4 p
# y 2 5 q
# z 3 6 r#从剪贴板读取数据
df1 = pd.read_clipboard()
df1.to_clipboard()#将剪贴板中的内容写入到df1.csv文件中
df1.to_csv('df1.csv')
数据读取函数read_csv示例
- read_csv（）
- 自定义索引：可以指定csv文件中的一列来使用index_clo定制索引
- dtype：数据类型转换
- skiprows：跳过指定的行数
import pandas as pd
import numpy as np
from pandas import Series,DataFrame'''示例2-1 read_csv'''
df = pd.read_csv('temp.csv')
print(df)
#输出：
# S.No Name Age City Salary
# 0 1 Tom 28 Toronto 20000
# 1 2 Lee 32 HongKong 3000
# 2 3 Steven 43 Bay Area 8300
# 3 4 Ram 38 Hyderabad 3900'''示例2——2 自定义索引：可以指定csv文件中的一列来使用index_col指定索引。'''
df = pd.read_csv('temp.csv',index_col=['S.No'])
print(df)
#输出：
# Name Age City Salary
# S.No
# 1 Tom 28 Toronto 20000
# 2 Lee 32 HongKong 3000
# 3 Steven 43 Bay Area 8300
# 4 Ram 38 Hyderabad 3900'''示例2-3 转换器 dtype'''
df = pd.read_csv('temp.csv',dtype = {'Salary':np.float64})
print(df)
print(df.dtypes) #df.dtypes可以查看DataFrame的每一列的类型
#输出：
# S.No Name Age City Salary
# 0 1 Tom 28 Toronto 20000.0
# 1 2 Lee 32 HongKong 3000.0
# 2 3 Steven 43 Bay Area 8300.0
# 3 4 Ram 38 Hyderabad 3900.0
# S.No int64
# Name object
# Age int64
# City object
# Salary float64
# dtype: object'''示例2-4 使用names参数指定标题的名称'''
#如果names的元素个数多于文件列数，多出的列将补充为NaN值；如果少于文件列数，将从右往左，进行排列
df = pd.read_csv('temp.csv',names = ['a','b','c','d','e'])
print(df)
#输出：
# a b c d e
# 0 S.No Name Age City Salary
# 1 1 Tom 28 Toronto 20000
# 2 2 Lee 32 HongKong 3000
# 3 3 Steven 43 Bay Area 8300
# 4 4 Ram 38 Hyderabad 3900#可以看到，标题名称附加了自定义名称，但是文件中的标题还没有被消除。现在使用header参数来删除它。
# 如果标题不是第一行，则将行号传递给标题，这将跳过前面的行。
df = pd.read_csv('temp.csv',names = ['a','b','c','d','e'],header = 0)
print(df)
#输出：
# a b c d e
# 0 1 Tom 28 Toronto 20000
# 1 2 Lee 32 HongKong 3000
# 2 3 Steven 43 Bay Area 8300
# 3 4 Ram 38 Hyderabad 3900'''示例2-5 skiprows跳过指定的行数'''
df = pd.read_csv('temp.csv',skiprows = 2)
print(df)
#输出：
# 2 Lee 32 HongKong 3000
# 0 3 Steven 43 Bay Area 8300
# 1 4 Ram 38 Hyderabad 3900
描述性统计方法
|
函数
|
描述
|
count()
|
非空观测数量
|
sum()
|
所有值之和，默认为axis = 0
|
mean()
|
所有值得平均值，默认为axis = 0
|
median()
|
所有值得中位数
|
mode()
|
值的模值
|
std()
|
值得标准差，默认为axis = 0
|
min()
|
所有值中的最小值
|
max()
|
所有值中的最大值
|
abs()
|
绝对值
|
prod()
|
数组元素的乘积
|
cumsum()
|
累计总和
|
sumprod()
|
累计乘积
|
实用小方法
pd.describe(include = [ ])
- include参数是用于传递关于什么列需要考虑用于总结得必要信息的参数。获取值列表；默认情况下是“数字值”。
|
参数值
|
说明
|
|
object
|
汇总字符串列
|
|
number
|
汇总数组列
|
|
all
|
将所有列汇总在一起（不应将其作为列表值传递）
|
import pandas as pdpd.set_option('display.unicode.ambiguous_as_wide', True)
pd.set_option('display.unicode.east_asian_width', True)
df = pd.read_csv('2019年销售数据.csv')
print(df,'\n')
print(df.describe(include = ['number']))
#输出：
# 销售员 团队 第一季度 第二季度 第三季度 第四季度
# 0 刘一 A 6324 5621 6069 6005
# 1 陈二 B 4508 3391 5933 5002
# 2 张三 C 3426 3549 5872 5759
# 3 李四 D 2104 3939 3285 3461
# 4 王五 A 4830 5763 2923 4033
# 5 赵六 B 2545 3747 2232 3472
# 6 孙七 C 3964 5053 6499 5056
# 7 周八 D 5584 6176 5405 6683
# 8 吴九 A 2769 5440 5724 4338
# 9 郑十 B 4935 2617 2424 3833
# 10 冯十一 C 4360 4846 4355 5182
# 11 蒋十二 D 4509 3673 4717 3489
# 12 毕十三 A 4873 5403 3889 2567
# 13 朱十四 B 3338 4965 5800 4061
# 14 秦十五 C 1501 2238 1272 2265
# 15 许十六 D 5369 3420 5169 5790
# 16 钱十七 A 6924 5912 5907 5263
# 17 沈十八 B 2733 2649 3402 3164
# 18 韩十九 C 1519 1553 1411 2091
# 19 杨二十 D 3268 5090 3898 4180
#
# 第一季度 第二季度 第三季度 第四季度
# count 20.000000 20.000000 20.000000 20.000000
# mean 3969.150000 4252.250000 4309.300000 4284.700000
# std 1518.736084 1352.492275 1646.188871 1286.032377
# min 1501.000000 1553.000000 1272.000000 2091.000000
# 25% 2760.000000 3412.750000 3194.500000 3469.250000
# 50% 4162.000000 4392.500000 4536.000000 4120.500000
# 75% 4888.500000 5412.250000 5818.000000 5202.250000
# max 6924.000000 6176.000000 6499.000000 6683.000000
pd.head()
- 读取到表格数据后，可能表格数据很多，我们想大致确认一下表格内容，不需要打印出完整的表格。这时我们可以使用
head() 方法来查看前 5 条数据。
import pandas as pd
df = pd.read_csv('2019年销售数据.csv')
print(df.head()) #head()函数中也可以输入参数，控制显示前多少条数据
#输出：销售员 团队 第一季度 第二季度 第三季度 第四季度
0 刘一 A 6324 5621 6069 6005
1 陈二 B 4508 3391 5933 5002
2 张三 C 3426 3549 5872 5759
3 李四 D 2104 3939 3285 3461
4 王五 A 4830 5763 2923 4033
tail()
- 同head()函数类似，tail()函数默认显示末尾的5条数据。
import pandas as pd
df = pd.read_csv('2019年销售数据.csv')
print(df.tail())
#输出：销售员 团队 第一季度 第二季度 第三季度 第四季度
15 许十六 D 5369 3420 5169 5790
16 钱十七 A 6924 5912 5907 5263
17 沈十八 B 2733 2649 3402 3164
18 韩十九 C 1519 1553 1411 2091
19 杨二十 D 3268 5090 3898 4180
info()
import pandas as pddf = pd.read_csv('2019年销售数据.csv')
print(df.info())
#输出：
<class 'pandas.core.frame.DataFrame'> #df类型
RangeIndex: 20 entries, 0 to 19 #行信息，总共20行
Data columns (total 6 columns): #列信息，总共6列
#每一列的信息，非空数值和数据类型
销售员 20 non-null object
团队 20 non-null object
第一季度 20 non-null int64
第二季度 20 non-null int64
第三季度 20 non-null int64
第四季度 20 non-null int64
dtypes: int64(4), object(2)
memory usage: 1.1+ KB
None
apply()
apply() 方法的第一个参数是一个函数，当我们传入函数后，apply() 方法会将该函数应用到表格列里的每一个数据中，并将表格数据作为参数传给函数。
#将“价格”这一列的数据去掉单位“元”
df['价格'] = df['价格'].str.replace('元', '').astype('float')#使用apply()方法，需要事先定义一个函数，然后使用apply方法调用：
def format_price(x):return float(x.replace('元', ''))df['价格'] = df['价格'].apply(format_price)
agg()
agg()方法是pandas中的聚合方法，可以针对多列同时进行操作。- 给
agg() 方法传入一个字典，字典的键是要进行操作的列名，值为一个函数。函数的参数是每一列中的数据，函数的返回值将替换原来的值。
agg()方法可以理解为同时针对多列进行不同操作的apply()函数。
df_rfm = df.groupby('用户名').agg({'订单日期': lambda x: (pd.to_datetime('2019-12-31') - x.max()).days, # 计算 R'用户名': lambda x: len(x), # 计算 F'订单金额': lambda x: x.sum() # 计算 M
})
rename（）：更新列的名称
语法：#columns参数为一个字典
df.rename(columns = {'原列表名1':'新列表名1','原列表名2':'新列表名2'}
迭代与遍历
- pandas对象之间的基本迭代的行为取决于类型。当迭代一个系列时，它被视为数组式，基本迭代产生这些值。其他数据结构如：DataFrame，遵循类似惯例迭代对象的键。
基本迭代（对于i在对象中）
- Series - 值
- DataFrame - 列标签
'''迭代DataFrame，获得列标签'''
import pandas as pd
import numpy as np
N = 5
df = pd.DataFrame({'D':pd.date_range(start = '2020-01-01',periods = N,freq = 'M'),'x':np.linspace(0,stop = N - 1,num = N), #等差数列'y':np.random.rand(N),'z':np.random.choice(['low','medium','high'],N).tolist()}) #.tolist()函数将其它形式转换为列表形式print(df,'\n')for i in df:print(i)#输出：
# D x y z
# 0 2019-01-31 0.0 0.941287 low
# 1 2019-02-28 1.0 0.031393 medium
# 2 2019-03-31 2.0 0.972314 medium
# 3 2019-04-30 3.0 0.438651 high
# 4 2019-05-31 4.0 0.279574 medium
#
# D
# x
# y
# z
遍历数据帧（DataFrame）中的行
- iteritems（） - 迭代（key，value）对
- iterrows（） - 将行迭代为（索引，Series）对
- itertuples（） - 以namedtuples的形式迭代行
import pandas as pd
import numpy as np'''iteritems()函数将每一列作为名称，将行索引和值作为键和列值迭代为series对象
'''
df = pd.DataFrame(np.random.rand(4,3),columns = ['col1','col2','col3']) print(df,'\n')for k,v in df.iteritems():print(k,v)#输出：
# col1 col2 col3
# 0 0.002167 0.251851 0.241612
# 1 0.524773 0.133777 0.789641
# 2 0.199759 0.163257 0.157641
# 3 0.317832 0.927168 0.397268
#
# col1 0 0.002167
# 1 0.524773
# 2 0.199759
# 3 0.317832
# Name: col1, dtype: float64
# col2 0 0.251851
# 1 0.133777
# 2 0.163257
# 3 0.927168
# Name: col2, dtype: float64
# col3 0 0.241612
# 1 0.789641
# 2 0.157641
# 3 0.397268
# Name: col3, dtype: float64
'''iterrows()函数将每一行索引作为名称，将列索引和值作为键和列值迭代为series对象
'''
df = pd.DataFrame(np.random.rand(4,3),columns = ['col1','col2','col3'])print(df,'\n')for row_index,row in df.iterrows():print(row_index,row,'\n')#输出：
# col1 col2 col3
# 0 0.611373 0.441767 0.781915
# 1 0.951751 0.093661 0.361174
# 2 0.504481 0.913220 0.475225
# 3 0.660986 0.576074 0.256999
#
# 0 col1 0.611373
# col2 0.441767
# col3 0.781915
# Name: 0, dtype: float64
#
# 1 col1 0.951751
# col2 0.093661
# col3 0.361174
# Name: 1, dtype: float64
#
# 2 col1 0.504481
# col2 0.913220
# col3 0.475225
# Name: 2, dtype: float64
#
# 3 col1 0.660986
# col2 0.576074
# col3 0.256999
# Name: 3, dtype: float64
'''itertuples()函数将DataFrame中的每一行返回一个产生一个命名元组的迭代器。元组的第一个元素将是行的相应索引值，而剩余的值是行值）
'''
df = pd.DataFrame(np.random.rand(4,3),columns = ['col1','col2','col3'])print(df,'\n')for row in df.itertuples():print(row,'\n')#输出：
# col1 col2 col3
# 0 0.230343 0.381542 0.459821
# 1 0.692532 0.763662 0.362820
# 2 0.794490 0.334475 0.872344
# 3 0.550152 0.724963 0.025850
#
# Pandas(Index=0, col1=0.23034304346439394, col2=0.38154191529049264, col3=0.45982101309486256)
#
# Pandas(Index=1, col1=0.6925323623736783, col2=0.7636624762929697, col3=0.36282048371606546)
#
# Pandas(Index=2, col1=0.7944901643600082, col2=0.33447509347016335, col3=0.8723443757840903)
#
# Pandas(Index=3, col1=0.5501519404139207, col2=0.7249626759644334, col3=0.02585026696010806)
排序
按索引排序
- 使用sort_index()方法，通过传递axis参数和排序顺序，可以对DataFrame进行排序，默认情况下，按照升序对行标签进行排序。
按数值排序
- sort_values()是按值排序的方法。他接受一个by参数，它将使用要与其排序值的DataFrame的列名称。
排序顺序
- 通过将布尔值传递给升序参数ascending，可以控制排序顺序。
- 按行或列排序：通过设置axis = 0或1，默认为0
- inplace参数：inplace = True时表示直接修改原数据，否则对原数据没有影响
import pandas as pd
import numpy as npunsort_df = pd.DataFrame(np.random.rand(10,2),index = [0,1,3,7,4,5,6,2,8,9],columns = ['A','B'])
print(unsort_df,'\n')
#输出：
# A B
# 0 0.233271 0.360613
# 1 0.114895 0.210990
# 3 0.792729 0.875864
# 7 0.930750 0.401930
# 4 0.331400 0.686031
# 5 0.751914 0.765402
# 6 0.190863 0.111702
# 2 0.199795 0.369930
# 8 0.860544 0.420991
# 9 0.177416 0.180246sort_index_df = unsort_df.sort_index(ascending = True) #将行标签进行排序
print(sort_index_df,'\n')
#输出：
# A B
# 0 0.233271 0.360613
# 1 0.114895 0.210990
# 2 0.199795 0.369930
# 3 0.792729 0.875864
# 4 0.331400 0.686031
# 5 0.751914 0.765402
# 6 0.190863 0.111702
# 7 0.930750 0.401930
# 8 0.860544 0.420991
# 9 0.177416 0.180246sort_value_df = unsort_df.sort_values(by = 'B') #将B这一列的数值进行排序
print(sort_value_df)
#输出：
# A B
# 6 0.190863 0.111702
# 9 0.177416 0.180246
# 1 0.114895 0.210990
# 0 0.233271 0.360613
# 2 0.199795 0.369930
# 7 0.930750 0.401930
# 8 0.860544 0.420991
# 4 0.331400 0.686031
# 5 0.751914 0.765402
# 3 0.792729 0.875864
缺失值处理
- 缺失值主要是指数据丢失的现象，也就是数据集中的某一块数据不存在。
- 除了原始数据集就已经存在缺失值以外，当用到索引对齐（reindex（），选择等）方法时，也容易人为导致缺失值的产生。
- 缺失值处理包括：
- pandas为了更方便的检测缺失值，将不同数据的缺失均采用NaN标记。这里的NaN代表t Not a Number，它仅仅作为一个标记。
缺失值标记
- 主要用到两个方法：
isnull()和notnull()，顾名思义就是【是缺失值】和【不是缺失值】。默认会返回布尔值用于判断。
import pandas as pd
import numpy as np
# 使用reindex()人为生成缺失值
df = pd.DataFrame(np.random.rand(4,3),index = ['a','b','e','f'],columns = ['one','two','three'])
print(df,'\n')
#输出：
# one two three
# a 0.256053 0.863923 0.148101
# b 0.793878 0.926672 0.922084
# e 0.886787 0.384176 0.765768
# f 0.175942 0.678231 0.640846df = df.reindex(['a','b','c','d','e','f','g'])
print(df,'\n')
#输出：
# one two three
# a 0.256053 0.863923 0.148101
# b 0.793878 0.926672 0.922084
# c NaN NaN NaN
# d NaN NaN NaN
# e 0.886787 0.384176 0.765768
# f 0.175942 0.678231 0.640846
# g NaN NaN NaNprint(df['one'].isnull(),'\n')
#输出：
# a False
# b False
# c True
# d True
# e False
# f False
# g True
# Name: one, dtype: bool print(df['one'].notnull(),'\n')
# 输出：
# a True
# b True
# c False
# d False
# e True
# f True
# g False
# Name: one, dtype: bool
缺失值填充
fillna()函数可以通过几种方法用非空数据“填充”NaN值。
- 用标量值替换NaN
- 向前填充：
pad/fill
- 向后填充：
bfill/backfill
import pandas as pd
import numpy as npdf = pd.DataFrame(np.random.rand(4,3),index = ['a','b','e','f'],columns = ['one','two','three'])df = df.reindex(['a','b','c','d','e','f','g'])
print(df,'\n')
#输出：
# one two three
# a 0.256053 0.863923 0.148101
# b 0.793878 0.926672 0.922084
# c NaN NaN NaN
# d NaN NaN NaN
# e 0.886787 0.384176 0.765768
# f 0.175942 0.678231 0.640846
# g NaN NaN NaN'''用0填充
'''
print(df.fillna(0),'\n')
#输出：
# one two three
# a 0.417406 0.545082 0.709453
# b 0.380341 0.196010 0.120429
# c 0.000000 0.000000 0.000000
# d 0.000000 0.000000 0.000000
# e 0.318109 0.128851 0.647815
# f 0.028383 0.705625 0.808282
# g 0.000000 0.000000 0.000000
'''向前填充：需要填充的行的值跟前一行数值一样。
'''
print(df.fillna(method = 'pad'),'\n')
#输出：
# one two three
# a 0.032463 0.679820 0.468832
# b 0.520895 0.645980 0.737983
# c 0.520895 0.645980 0.737983
# d 0.520895 0.645980 0.737983
# e 0.083174 0.448117 0.821530
# f 0.010777 0.518605 0.232660
# g 0.010777 0.518605 0.232660print(df.fillna(method = 'backfill'))
#输出：
# one two three
# a 0.644131 0.188982 0.239654
# b 0.590636 0.208429 0.058639
# c 0.424696 0.475144 0.056139
# d 0.424696 0.475144 0.056139
# e 0.424696 0.475144 0.056139
# f 0.364732 0.930029 0.664242
# g NaN NaN NaN
缺失值丢弃
- 丢弃缺少的值：如果只想排序缺少的值，则使用
dropna()函数。
dropna()函数对原数据没有影响，如果需要保存修改结果，函数内添加inplace = True即可。
df.dropna(axis,how,thresh,subset)
|
参数
|
说明
|
axis
|
axis = 0表示行方向，axis = 1表示列方向
|
how
|
how = 'all' 表示全部为NaN才删除行；how = 'any'表示只要有NaN就删除行
|
thresh
|
值为该行中NaN的数量，大于该数量，删除行
|
subset
|
值为列表名称，当这几列中出现NaN，删除行
|
import pandas as pd
import numpy as npdf = pd.DataFrame(np.random.rand(4,3),index = ['a','b','e','f'],columns = ['one','two','three'])df = df.reindex(['a','b','c','d','e','f','g'])
print(df,'\n')
#输出：
# one two three
# a 0.256053 0.863923 0.148101
# b 0.793878 0.926672 0.922084
# c NaN NaN NaN
# d NaN NaN NaN
# e 0.886787 0.384176 0.765768
# f 0.175942 0.678231 0.640846
# g NaN NaN NaNprint(df.dropna(),'\n') #丢弃含有NaN值的行
#输出：
# one two three
# a 0.432727 0.889990 0.210190
# b 0.690693 0.727836 0.104449
# e 0.601218 0.685058 0.013489
# f 0.818722 0.055420 0.469208print(df.dropna(axis = 1)) #丢弃含有NaN值的列
#输出：
# Empty DataFrame
# Columns: []
# Index: [a, b, c, d, e, f, g]
替换缺失（或通用）值
- 用一些具体的值取代一个通用的值或缺失值。用标量替换NaN和使用
fillna()函数等效。
import pandas as pd
import numpy as npdf = pd.DataFrame({'one':[10,20,30,40,50,2000],'two':[1000,0,30,40,50,60]})
print(df,'\n')
#输出：
# one two
# 0 10 1000
# 1 20 0
# 2 30 30
# 3 40 40
# 4 50 50
# 5 2000 60print(df.replace({1000:10,2000:60}),'\n')
#输出：
# one two
# 0 10 10
# 1 20 0
# 2 30 30
# 3 40 40
# 4 50 50
# 5 60 60
数据处理小方法
统一数据格式
- 在pandas中使用python的字符串函数，需要先使用pandas中的
str方法
pd.str.replace()/upper()/lower()/split()
去除重复数据
- 当数据中有重复数据，我们可以使用
drop_duplicates()方法删除完全重复的行，即每一列数据都相同。
- 我们还可以通过设置
subset参数在指定列去重，即只要这一列的数据重复就会删除整行内容，默认是保留第一条不重复数据。如果想保留最后一条，可以使用keep='last'。
查看重复数据
|
方法
|
说明
|
unique()
|
查看不重复内容
|
nunique()
|
查看不重复个数
|
数据筛选
- 与numpy中的布尔索引一样，同时满足的条件用
&连接，只满足一个条件即可用|连接，每个条件用括号括起来。
import pandas as pdpd.set_option('display.unicode.ambiguous_as_wide', True)
pd.set_option('display.unicode.east_asian_width', True)df = pd.read_csv('2019年销售数据.csv')
df['总和'] = df['第一季度'] + df['第二季度'] + df['第三季度'] + df['第四季度']
# 筛选出总和大于 10000 且小于 12000 的
print(df[(df['总和'] > 10000) & (df['总和'] < 12000)],'\n')# 筛选出总和小于 5000 或大于 12000 的
print(df[(df['总和'] < 10000) | (df['总和'] > 24000)])#输出：
# 销售员 团队 第一季度 第二季度 第三季度 第四季度 总和
# 5 赵六 B 2545 3747 2232 3472 11996
# 17 沈十八 B 2733 2649 3402 3164 11948
#
# 销售员 团队 第一季度 第二季度 第三季度 第四季度 总和
# 0 刘一 A 6324 5621 6069 6005 24019
# 14 秦十五 C 1501 2238 1272 2265 7276
# 16 钱十七 A 6924 5912 5907 5263 24006
# 18 韩十九 C 1519 1553 1411 2091 6574
给数据打标签
pd.cut(df[' '], bins=[ ], labels=[' '])
|
参数
|
说明
|
df[' ']
|
选取需要进行分类的列
|
bins
|
分类区间，如填入0，20，30，40则表示为（0，20],(20,30],(30,40]，默认为左开右闭，如果想要左闭右开，则添加参数right = False即可
|
labels
|
对应区间的标签名
|
import pandas as pdpd.set_option('display.unicode.ambiguous_as_wide', True)
pd.set_option('display.unicode.east_asian_width', True)df = pd.read_csv('2019年销售数据.csv')
df['总和'] = df['第一季度'] + df['第二季度'] + df['第三季度'] + df['第四季度']
df['绩效'] = pd.cut(df['总和'], bins = [0,df['总和'].mean()*0.9,df['总和'].mean()*1.2,df['总和'].max()], labels = ['不合格','合格','优秀'])
print(df.head())#输出：销售员 团队 第一季度 第二季度 第三季度 第四季度 总和 绩效
0 刘一 A 6324 5621 6069 6005 24019 优秀
1 陈二 B 4508 3391 5933 5002 18834 合格
2 张三 C 3426 3549 5872 5759 18606 合格
3 李四 D 2104 3939 3285 3461 12789 不合格
4 王五 A 4830 5763 2923 4033 17549 合格
对数据进行分组
- pandas 提供了
groupby() 方法用于数据的分组，第一个参数用于指定按哪一列进行分组
- 但仅仅进行分组是没有结果的，还需要调用
max()、min()、mean()、sum() 等方法进行分组后的计算。
import pandas as pdpd.set_option('display.unicode.ambiguous_as_wide', True)
pd.set_option('display.unicode.east_asian_width', True)df = pd.read_csv('2019年销售数据.csv')
df['总和'] = df['第一季度'] + df['第二季度'] + df['第三季度'] + df['第四季度']
df['绩效'] = pd.cut(df['总和'], bins = [0,df['总和'].mean()*0.9,df['总和'].mean()*1.2,df['总和'].max()], labels = ['不合格','合格','优秀'])
sum_by_team = df.groupby('团队').sum()
sum_by_team.sort_values('总和', ascending=False, inplace=True)
print(sum_by_team)#输出：
# 第一季度 第二季度 第三季度 第四季度 总和
# 团队
# A 25720 28139 24512 22206 100577
# D 20834 22298 22474 23603 89209
# B 18059 17369 19791 19532 74751
# C 14770 17239 19409 20353 71771
pandas行操作
- 之前的数据操作都是从列的角度进行的，如果要从行角度进行，需要用到
loc。
loc 并不是一个方法，而是类似于字典。所以我们使用的是 [] 而不是 ()，这里千万不要用错。
查看行
- 当
loc[]中只有行索引值时，为行索引；
- 当
loc[]中既有行索引值，又有列索引值时，为具体的某个值。
import pandas as pd
df = pd.DataFrame({'辣条': [14, 20], '面包': [7, 3], '可乐': [8, 13], '烤肠': [10, 6]})
print(df,'\n')
#============只有行索引==============
print(df.loc[0]) #如果设置的单独的行索引，我们也可以使用相应的索引值
#输出：辣条 面包 可乐 烤肠
0 14 7 8 10
1 20 3 13 6 辣条 14
面包 7
可乐 8
烤肠 10
Name: 0, dtype: int64#============行索引和列索引都有==============
print(df.loc[0, '辣条'])
#输出：14#============行列切片、切片左右都可以取到（与list不同）==============
# 行分片
print(df.loc[0:1, '辣条'],'\n')
#输出：
# 0 14
# 1 20
# Name: 辣条, dtype: int64# 列分片
print(df.loc[0, '辣条':'可乐'],'\n')
#输出：
# 辣条 14
# 面包 7
# 可乐 8
# Name: 0, dtype: int64# 同时分片
print(df.loc[0:1, '辣条':'可乐'],'\n')
#输出：
# 辣条 面包 可乐
# 0 14 7 8
# 1 20 3 13 #============布尔索引==============、
print(df.loc[df['辣条'] > 15, ['辣条', '面包']])
#输出：
# 辣条 面包
#1 20 3
iloc[]方法
- 与
loc[]方法类似，区别在于 loc 使用的参数是索引，而 iloc 的参数是位置，即第几行。
- 在不指定索引的情况下，
loc 和 iloc 的效果是一样的。
- 但当单独指定了索引，想要按位置获取数据的话只能使用
iloc，这时如果使用 df.loc[:3] 将会报错。
iloc 的分片和 Python 的列表分片一样，要和 loc 的分片规则区分开来。
import pandas as pddata = {'辣条': [14, 20, 12, 15, 17],'面包': [7, 3, 8, 3, 9],'可乐': [8, 13, 23, 12, 19],'烤肠': [10, 6, 21, 24, 18]
}
df = pd.DataFrame(data, index=['2020-01-01', '2020-01-02', '2020-01-03', '2020-01-04', '2020-01-05'])
print(df.iloc[:3]) # :3 表示 0、1、2 前三个
#输出：辣条 面包 可乐 烤肠
2020-01-01 14 7 8 10
2020-01-02 20 3 13 6
2020-01-03 12 8 23 21
修改、新增行
删除行
- 使用
drop()函数
- 其中参数
axis = 0，即为对行操作
表格合并
纵向合并
- 将表格内容从上往下进行叠加
- 表格要求：每张表格的格式一样，都有相同的列名
- 方法：
pd.concat(df1，df2)
import pandas as pdpd.set_option('display.unicode.ambiguous_as_wide', True)
pd.set_option('display.unicode.east_asian_width', True)df_a = pd.read_csv('2019年团队A销售数据.csv')
df_b = pd.read_csv('2019年团队B销售数据.csv')
df_c = pd.read_csv('2019年团队C销售数据.csv')
df_d = pd.read_csv('2019年团队D销售数据.csv')df = pd.concat([df_a,df_b,df_c,df_d])
print(df)
#输出：销售员 团队 第一季度 第二季度 第三季度 第四季度
0 刘一 A 6324 5621 6069 6005
1 王五 A 4830 5763 2923 4033
2 吴九 A 2769 5440 5724 4338
3 毕十三 A 4873 5403 3889 2567
4 钱十七 A 6924 5912 5907 5263
0 陈二 B 4508 3391 5933 5002
1 赵六 B 2545 3747 2232 3472
2 郑十 B 4935 2617 2424 3833
3 朱十四 B 3338 4965 5800 4061
4 沈十八 B 2733 2649 3402 3164
0 张三 C 3426 3549 5872 5759
1 孙七 C 3964 5053 6499 5056
2 冯十一 C 4360 4846 4355 5182
3 秦十五 C 1501 2238 1272 2265
4 韩十九 C 1519 1553 1411 2091
0 李四 D 2104 3939 3285 3461
1 周八 D 5584 6176 5405 6683
2 蒋十二 D 4509 3673 4717 3489
3 许十六 D 5369 3420 5169 5790
4 杨二十 D 3268 5090 3898 4180
横向合并
语法：
pd.merge(df1,df2,on,how)
|
参数
|
说明
|
on
|
参数 on 表明用于合并的列名，可以使用列表指定多个列名，这些列名必须同时存在于两个表格当中。如果没有指定参数 on，那么 pandas 会自动将两个表格都有的列名作为参数 on 的值。
|
how
|
参数 how 指定了合并的方式，总共有 left、right、outer 和 inner 四种方式可选，默认为 inner。
|
how = left
|
left（左连接）表示将df2合并到df1中，具体指保留df1的全部数据，将df2中两表中共同的数据进行合并，剔除df2中独有的数据。缺失数据同样也是用 NaN 填充。
|
how = right
|
right（右连接）正好与left相反，表示将df1合并到df2中.
|
how = inner
|
inner（内连接）表示只保留参数 on 指定的列中df1和df2都出现的部分。
|
how = outer
|
outer（外连接）和 inner 相反，它会保留df1和df2中所有的数据，数据缺失部分以 NaN 填充。
|
import pandas as pdpd.set_option('display.unicode.ambiguous_as_wide', True)
pd.set_option('display.unicode.east_asian_width', True)df1 = pd.read_csv('2019年团队A上半年销售数据.csv')
print("df1:",df1,'\n',sep = '\n')df2 = pd.read_csv('2019年团队A下半年销售数据.csv')
print("df2:",df2,'\n',sep = '\n')df_right = pd.merge(df1,df2,on = '销售员',how = 'right')
print("df_right:",df_right,'\n',sep = '\n')df_left = pd.merge(df1,df2,on = '销售员',how = 'left')
print('df_left:',df_left,'\n',sep = '\n')df_inner = pd.merge(df1,df2,on = '销售员',how = 'inner')
print('df_inner:',df_inner,'\n',sep = '\n')df_outer = pd.merge(df1,df2,on = '销售员',how = 'outer')
print('df_outer:',df_outer,'\n',sep = '\n')
#输出：
df1:销售员 第一季度 第二季度
0 刘一 6324 5621
1 王五 4830 5763
2 吴九 2769 5440
3 毕十三 4873 5403
4 钱十七 6924 5912df2:销售员 第三季度 第四季度
0 王五 2923 4033
1 吴九 5724 4338
2 毕十三 3889 2567
3 钱十七 5907 5263
4 黄帮主 6666 8888df_right:销售员 第一季度 第二季度 第三季度 第四季度
0 王五 4830.0 5763.0 2923 4033
1 吴九 2769.0 5440.0 5724 4338
2 毕十三 4873.0 5403.0 3889 2567
3 钱十七 6924.0 5912.0 5907 5263
4 黄帮主 NaN NaN 6666 8888df_left:销售员 第一季度 第二季度 第三季度 第四季度
0 刘一 6324 5621 NaN NaN
1 王五 4830 5763 2923.0 4033.0
2 吴九 2769 5440 5724.0 4338.0
3 毕十三 4873 5403 3889.0 2567.0
4 钱十七 6924 5912 5907.0 5263.0df_inner:销售员 第一季度 第二季度 第三季度 第四季度
0 王五 4830 5763 2923 4033
1 吴九 2769 5440 5724 4338
2 毕十三 4873 5403 3889 2567
3 钱十七 6924 5912 5907 5263df_outer:销售员 第一季度 第二季度 第三季度 第四季度
0 刘一 6324.0 5621.0 NaN NaN
1 王五 4830.0 5763.0 2923.0 4033.0
2 吴九 2769.0 5440.0 5724.0 4338.0
3 毕十三 4873.0 5403.0 3889.0 2567.0
4 钱十七 6924.0 5912.0 5907.0 5263.0
5 黄帮主 NaN NaN 6666.0 8888.0
python——pandas相关推荐
- python pandas库读取excel/csv中指定行或列数据详解
通过阅读表格,可以发现Pandas中提供了非常丰富的数据读写方法,下面这篇文章主要给大家介绍了关于python利用pandas库读取excel/csv中指定行或列数据的相关资料,需要的朋友可以参考下 ...
- Python pandas用法
Python pandas用法 无味之味关注 12019.01.10 15:43:25字数 2,877阅读 91,914 介绍 在Python中,pandas是基于NumPy数组构建的,使数据预处理. ...
- python pandas 独热编码
python pandas 独热编码 import pandas as pd df1 = pd.DataFrame({'姓名': ['周', '武', '郑'],'成绩': [100, 96, 77] ...
- python pandas 读写 csv 文件
python pandas 读写 csv 文件 具体看官方文档 https://www.pypandas.cn/docs/user_guide/io.html#csv-文本文件 import pand ...
- python pandas DataFrame 替换 NaN 值 和 删除 NaN 所在的行。
python pandas DataFrame 替换 NaN 值 和 删除 NaN 所在的行. import pandas as pd import numpy as np df1 = pd.Data ...
- python pandas DataFrame 查找NaN所在的位置
python pandas DataFrame 查找 NaN 所在的位置 import pandas as pd import numpy as np df1 = pd.DataFrame({'日期' ...
- python pandas dataframe 列 转换为离散值
python pandas dataframe 列 转换为离散值 import pandas as pd import numpy as np df1 = pd.DataFrame({'日期': [' ...
- python pandas DataFrame 排序
python pandas DataFrame 排序 import pandas as pd import numpy as np df1 = pd.DataFrame({'日期': ['2021-7 ...
- python pandas DataFrame 字符串转日期格式
python pandas DataFrame 字符串转日期格式 import pandas as pd import numpy as np df1 = pd.DataFrame({'日期': [' ...
- python pandas DataFrame 数据替换
python pandas DataFrame 替换 import pandas as pd import numpy as np df1 = pd.DataFrame({'日期': ['2021-7 ...
最新文章
- 浅析volatile原理及其使用
- ArcGIS桌面基本操作 和 ArcSDE数据库基本概念
- 【PC工具】在线MP3转WAV工具，MP3文件转换成arduino可以直接播放的wav格式
- 第八届java c组,2015年Java方向C组第八题
- 关于hibernate中提示can not create table ******
- mysql查询新建查询报错_mysql开启慢查询报错：
- 新款 Azure .NET SDK 如何设定 Content-Type
- JS之获取指定位置Unicode的charCodeAt()方法
- glibc版本查看_Linux开发必知内容整理 | libc、glibc和glib的关系
- 2020年天猫双11官宣：分两波购买 比往年多3天
- python etree xpath_【Python】爬虫之使用etree进行xpath元素定位
- mysql 数据增量抽取_通过Maxwell实时增量抽取MySQL binlog并通过stdout展示
- Java最新面试题大全
- FileNet入门学习
- 华为Play 4T Pro批量添加联系人
- Android OnDeviceAppPrediction 优化
- 阿里云香港节点全面故障给我们的启示
- vue h5分享微信节日头像合成”
- FTP协议（文件传输协议）
- MuseScore批量化插件使用
热门文章
- 14 Python之生成器，生成器函数以及推导式
- 量化策略要素_成功的产品发布策略的三个要素
- canvas rotate中心点问题
- Dell戴尔灵越笔记本电脑Inspiron 15 7510原装出厂Windows10系统恢复原厂OEM系统
- 上网部署（锐捷睿易篇）
- （AM3517）修改u-boot与Linux调试串口以及文件系统显示终端串口（瑞泰ICETEK-AM3517）
- mysql提示Your password does not satisfy the current policy requirements的解决方案
- 教师德育工作计算机教师总结,计算机教师个人年度工作总结
- CSS中规定的五种一般字体家族
- continue语句
