Pandas库的学习
Posted 木白星枝
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Pandas库的学习相关的知识，希望对你有一定的参考价值。
pandas是数据处理最常用的分析库之一，可以读取各种各样格式的数据文件，一般输出dataframe格式。
如：txt、csv、excel、json、剪切板、数据库、html、hdf、parquet、pickled文件、sas、stata等等。
对于结构化的、探索性数据统计和分析场景，使用pandas方法进行读取，因为其提供了数据框，对数据进行任意翻转、切片、关联都很方便。
一.读取文件的方法
1.read_csv方法
read_csv方法用来读取csv格式文件，输出dataframe格式。
1.1 filepath_or_buffer（读取csv文件）
#filepath_or_buffer读取csv文件，可以是文件路径，也可以是一个URL，如果访问该URL会返回一个文件的话，那么pandas的read_csv函数会自动将该文件进行读取。
import pandas as pd
file_path=r'D:\\pythonProject\\数学建模\\data\\1\\附件1 弱覆盖栅格数据(筛选).csv'#'test.csv'
# 可以设置set_option展现完整数据，不设置的话就会省略。。。
pd.set_option("display.width",None)
pd.set_option("display.max_rows",None)
content=pd.read_csv(file_path)
print(content)1.2 header和names（列名称和列索引、从第几行开始）
#header设置导入 DataFrame 的列名称，默认为 "infer"
#names:当names没被赋值时，header会变成0，即选取数据文件的第一行作为列名。
#当 names 被赋值，header 没被赋值时，那么header会变成None。如果都赋值，就会实现两个参数的组合功能。
content=pd.read_csv(file_path, header=1)#从第2行开始
content=pd.read_csv(file_path, header=None)
#认为原始文件数据没有列索引,为其自动加上列索引从0开始
content=pd.read_csv(file_path, names=["1", "2", "3"])#在原csv上面加上names数据这1行
content=pd.read_csv(file_path, names=range(1,4), header=0)
#从第1行开始，并把第1行替换成names数组1.3 usecols（提取需要的列）
#usecols选择想要提取的列，选择列名的长度大于 4 的列：usecols=lambda x: len(x) > 4
content=pd.read_csv(file_path, usecols=["x", "y"])1.4 index_col（选择哪一列作为索引）
content=pd.read_csv(file_path, index_col=2)#将第一列作为索引index# index_col='y',将"y"这一列作为索引即行索引后，"y"这列即不在属于列名这类，即不能使用df['y']获取列值
# read_csv()方法中header参数和index_col参数不能混用，因为header指定列索引，index_col指定行索引，一个DataFrame对象只有一种索引
1.5 dtype（列类型）
#dtype来指定某个列的类型
content=pd.read_csv(file_path, dtype="x": str,'y':str)#dtype来指定某个列的类型
content["x"] = content["x"] * 31.6 converters（列数据变换）
#converters可以在读取的时候对列数据进行变换,好像也可以指定数据类型 #使用converters参数时，解析器默认所有列的类型为 str，所以需要显式类型转换
content=pd.read_csv(file_path, converters="id": lambda x: int(x) + 10)1.7 true_values和false_values （数据清洗）
# true_values和false_value指定哪些值应该被清洗为True，哪些值被清洗为False # 只有当某一列的数据全部出现在true_values + false_values里面，才会被替换
content=pd.read_csv(file_path, true_values=["对"], false_values=["错"])
content=pd.read_csv(file_path, false_values=["错", "对"])1.8 skiprows（过滤行）
# skiprows 表示过滤行，想过滤掉哪些行，先过滤，然后再确定表头
content=pd.read_csv(file_path,skiprows=[0])
content=pd.read_csv(file_path, skiprows=lambda x: x > 0 and x % 2 == 0)1.9 skipfooter（过滤结尾）
# skipfooter:接收整型，表示从结尾往上过滤掉指定数量的行，解析引擎退化为 Python。这是因为 C 解析引擎没有这个特性。
content=pd.read_csv(file_path, skipfooter=3, encoding="utf-8", engine="python")1.10 nrows（一次性读入行数）
#nrows 设置一次性读入的文件行数 # 它在读入大文件时很有用，比如 16G 内存的PC无法容纳几百 G 的大文件。很多时候我们只是想看看大文件内部的字段长什么样子
content=pd.read_csv(file_path, nrows=1)1.11 na_values（处理成NaN）
# na_values 参数可以配置哪些值需要处理成 NaN,针对整个csv中的全部数据,下面是只对指定的列进行替换
content=pd.read_csv(file_path, na_values=["对", "古明地觉"])
content=pd.read_csv(file_path, sep="\\t", na_values="x": ["古明地觉", "博丽灵梦"], "y": ["对"])1.12 keep_default_na（默认转换为NaN的值不转换）
# 除了 na_values 指定的值之外，还有一些默认的值也会在读取的时候被替换成空值，这些值有： # "-1.#IND"、"1.#QNAN"、"1.#IND"、"-1.#QNAN"、"#N/A N/A"、"#N/A"、"N/A"、"NA"、"#NA"、"NULL"、"NaN"、"-NaN"、"nan"、"-nan"、"" # 尽管这些值在 CSV 中的表现形式是字符串，但是 pandas 在读取的时候会替换成空值（真正意义上的 NaN）。 # 不过有些时候我们不希望这么做，比如有一个具有业务含义的字符串恰好就叫 "NA"，那么再将它替换成空值就不对了。 # 这个时候就可以将 keep_default_na 指定为 False，默认为 True，如果指定为 False，那么 pandas 在读取时就不会擅自将那些默认的值转成空值了 # 但是na_values 参数指定的不受此影响，还是会转换成NAN
content=pd.read_csv(file_path, na_values=["", "NULL"],keep_default_na=False)
1.13 na_filter和skip_blank_lines（空值监测、过滤空行）
# na_filter指定为 False，那么 pandas 在读取 CSV 的时候不会进行任何空值的判断和检测，所有的值都会保留原样。 # 因此，如果你能确保一个 CSV 肯定没有空值，则不妨指定 na_filter 为 False，因为避免了空值检测，可以提高大型文件的读取速度。 # 另外，该参数会屏蔽 keep_default_na 和 na_values，也就是说，当 na_filter 为 False 的时候，这两个参数会失效。 # skip_blank_lines 默认为 True，表示过滤掉空行，如为 False 则解析为 NaN。 # 也可以指定 keep_default_na 为 False 来改变这一点
content=pd.read_csv(file_path, na_filter=False,skip_blank_lines=False)
1.14 parse_dates和date_parser和infer_datetime_format（和keep_date_col 和dayfirst）（时间转换）
# parse_dates，指定某些列为时间类型，这个参数一般搭配下面的date_parser使用。 # date_parser是用来配合parse_dates参数的，因为有的列虽然是日期，但没办法直接转化，需要我们指定一个解析格式： # infer_datetime_format 参数默认为 False。如果设定为 True 并且 parse_dates 可用， # 那么 pandas 将尝试转换为日期类型，如果可以转换，转换方法并解析，在某些情况下会快 5~10 倍。
from datetime import datetime
content=pd.read_csv(file_path, sep="\\t", parse_dates=["date"], date_parser=lambda x: datetime.strptime(x, "%Y年%m月%d日"))# keep_date_col : boolean, default False # 如果连接多列解析日期，则保持参与连接的列。默认为False。 # # date_parser : function, default None # 用于解析日期的函数，默认使用dateutil.parser.parser来做转换。Pandas尝试使用三种不同的方式解析，如果遇到问题则使用下一种方式。 # 1.使用一个或者多个arrays（由parse_dates指定）作为参数； # 2.连接指定多列字符串作为一个列作为参数； # 3.每行调用一次date_parser函数来解析一个或者多个字符串（由parse_dates指定）作为参数。 # dayfirst : boolean, default False # DD/MM格式的日期类型
1.15 iterator（处理大文件）
# 分块读入内存，尤其单机处理大文件时会很有用。 # iterator 为 bool类型，默认为False。如果为True，那么返回一个 TextFileReader 对象，以便逐块处理文件。 # 这个在文件很大、内存无法容纳所有数据文件时，可以分批读入，依次处理。
chunk = pd.read_csv(file_path, iterator=True)
print(chunk) # <pandas.io.parsers.TextFileReader object at 0x000002550189C0A0>
print(chunk.get_chunk(1))#依次从剩余的数据中读取前1行
print(chunk.get_chunk(2))#依次从剩余的数据中读取前2行
# 文件还剩下三行，但是我们指定读取100，那么也不会报错，不够指定的行数，那么有多少返回多少
print(chunk.get_chunk(100))
try:
# 但是在读取完毕之后，再读的话就会报错了
chunk.get_chunk(5)
except StopIteration as e:
print("读取完毕")
# 读取完毕1.16 chunksize（文件块）
# chunksize 整型，默认为 None，设置读取文件块的大小。
chunk = pd.read_csv(file_path, chunksize=2)
# 还是返回一个类似于迭代器的对象
print(chunk) # <pandas.io.parsers.TextFileReader object at 0x0000025501143AF0>
# 调用get_chunk，如果不指定行数，那么就是默认的chunksize
print(chunk.get_chunk())
# 但也可以指定
print(chunk.get_chunk(100))
try:
chunk.get_chunk(5)
except StopIteration as e:
print("读取完毕")
# 读取完毕1.17 compression（读取压缩文件等）
# compression 参数取值为 'infer', 'gzip', 'bz2', 'zip', 'xz', None，默认 'infer'，这个参数直接支持我们使用磁盘上的压缩文件。
# 直接将上面的girl.csv添加到压缩文件，打包成girl.zip
content=pd.read_csv('girl.zip', sep="\\t", compression="zip")1.18 error_bad_lines和warn_bad_lines（处理某一行多一个数据）
# error_bad_lines和warn_bad_lines 两参数只能在C解析引擎下使用。 # 如果一行包含过多的列，假设csv的数据有5列，但是某一行却有6个数据，数据有问题。那么默认情况下不会返回DataFrame，而是会报错。 # 这时,我们就可以将error_bad_lines设置为False(默认为True)，遇到这种情况，直接把这一行扔掉。同时会设置 warn_bad_lines 设置为True，打印剔除的这行。
content=pd.read_csv(file_path, error_bad_lines=False, warn_bad_lines=True)1.19 sep、delimiter、delim_whitespace（分隔符）
# sep读取csv文件时指定的分隔符，默认为逗号 # sep : str , default','分隔符长于一个字符并且不是‘\\s+’,将使用python的语法分析器。并且忽略数据中的逗号。正则表达式例子：'\\r\\t' # **这里补充说明一下‘\\s+’ # 正则表达式中\\s匹配任何空白字符，包括空格、制表符、换页符等等, 等价于[ \\f\\n\\r\\t\\v] # \\f -> 匹配一个换页 # \\n -> 匹配一个换行符 # \\r -> 匹配一个回车符 # \\t -> 匹配一个制表符 # \\v -> 匹配一个垂直制表符 # 而“\\s+”则表示匹配任意多个上面的字符。 # delimiter定界符，备选分隔符，与 sep 功能相似（如果指定该参数，则sep参数失效） # delim_whitespace设置为 True 时，表示分割符为空白字符，可以是空格、"\\t"等等，等效于设定sep='\\s+'。不管分隔符是什么，只要是空白字符，那么可以通过delim_whitespace=True进行读取。如果这个参数设定为Ture那么delimiter 参数失效。
1.20 mangle_dupe_cols（重名列的处理）
# 实际生产用的数据会很复杂，有时导入的数据会含有重名的列。参数 mangle_dupe_cols 默认为 True，重名的列导入后面多一个 .1。如果设置为 False，会抛出不支持的异常
1.21 prefix（列名前缀）
# prefix 参数，当导入的数据没有 header 时，设置此参数会自动加一个前缀。比如：
content=pd.read_csv(file_path, header=None, prefix="x")
#生成的列的名称是x0,x1,x2...不指定prefix就是0,1,2...
1.22 squeeze（返回Series）
# squeeze参数为True的话，在只有一列的情况下，那么得到就是一个Series
1.23 engine（数据引擎）
# engine指定pandas解析数据时用的引擎，pandas 目前的解析引擎提供两种：c、python，默认为 c，因为 c 引擎解析速度更快，但是特性没有 python 引擎全。如果使用 c 引擎没有的特性时，会自动退化为 python 引擎。
1.24 low_memory
# low_memory这个看起来是和内存有关的，但更准确的说，其实它是和数据类型相关的。在解释这个原因之前，我们还要先从DataFrame的数据类型说起。 # 我们知道DataFrame的每一列都是有类型的，那么在读取csv的时候，pandas也是要根据数据来判断每一列的类型的。但pandas主要是靠"猜"的方法，因为在读取csv的时候是分块读取的，每读取一块的时候，会根据数据来判断每一列是什么类型；然后再读取下一块，会再对类型进行一个判断，得到每一列的类型，如果得到的结果和上一个块得到结果不一样，那么就会发出警告，提示有以下的列存在多种数据类型： # DtypeWarning: Columns (1,5,8,......) have mixed types. Specify dtype option on import or set low_memory=False. # 而为了保证正常读取，那么会把类型像大的方向兼容，比如第一个块的user_id被解析成整型，但是在解析第二个块发现user_id有的值无法解析成整型，那么类型整体就会变成字符串，于是pandas提示该列存在混合类型。 # 而一旦设置low_memory=False，那么pandas在读取csv的时候就不分块读了，而是直接将文件全部读取到内存里面，这样只需要对整体进行一次判断，就能得到每一列的类型。但是这种方式也有缺陷，一旦csv过大，就会内存溢出。 # 不过从数据库读取就不用担心了，因为数据库是规定了每一列的类型的。如果是从数据库读取得到的DataFrame，那么每一列的数据类型和数据库表中的类型是一致的。还有，我们在上面介绍了dtype，这个是我们手动规定类型，那么pandas就会按照我们规定的类型去解析指定的列，但是一旦无法解析就会报错。
1.25 memory_map
# memory_map如果你知道python的一个模块mmap，那么你肯定很好理解。如果使用的数据在内存里，那么直接进行映射即可，直接map文件使用，不会（可以避免文件）再次进行IO操作，默认为False。这个参数比较底层，我们一般用不到。
1.26 verbose
# verbose=True:打印一些额外信息
1.27 thousands
# thousands 千分位分割符，如 , 或者 .，默认为None。
1.28 encoding
# encoding 指定字符集类型，通常指定为 'utf-8'。根据情况也可能是'ISO-8859-1'
1.29 skipinitialspace
# skipinitialspace=True忽略分隔符后的空白（默认为False，即不忽略）.
1.30 补充-查看得到后的数据
print(content)
print(content.head()) # 默认返回前5行数据
print(content.head(3)) # 返回前3行数据
print(content.shape) # 返回一个元组（总行数，总列数），总行数不包括标题行
print(content.index) # RangeIndex(start=0, stop=182807, step=1)
# 返回索引，是一个可迭代的对象<class 'pandas.core.indexes.range.RangeIndex'>
print(content.columns) # 返回所有的列名 Index(['x', 'y', 'traffic'], dtype='object')
print(content.dtypes) # 返回的是每列的数据类型2.read_excel方法
read_excel 读取excel文件，包括xlsx、xls、xlsm格式，需要下载openpyxl库
read_excel大多数的方法和read_csv相同，不同的或者特别的我用红色字体标出了。
2.1 io（读取excel文件）
#io为文件类对象，一般作为读取文件的路径,默认读取第一个表
import pandas as pd
file_path=r'D:\\pythonProject\\数学建模\\data\\a.xlsx'
# 可以设置set_option展现完整数据，不设置的话就会省略。。。
pd.set_option("display.width",None)
pd.set_option("display.max_rows",None)
# 为方便演示函数效果这里创建一个excel文件，其中创建了两个表格：
excel=pd.read_excel(file_path, header=None) 2.2 sheet_name（表格名）
该参数为指定读取excel的表格名。
#sheet_name默认为0，=1指定读取第2张表
excel=pd.read_excel(file_path,sheet_name=1)#sheet_name="Sheet1" sheet_name=[0,1]2.3 header和names（列名称和列索引、从第几行开始）
excel=pd.read_excel(file_path,header=1)
#header参数为指定列表中从第2行作为列索引
excel=pd.read_excel(file_path,names=['x','y','z'])
#names:接收一个数组，将列名(第一行)重定义赋值2.4 usecols（提取需要的列）
excel=pd.read_excel(file_path,usecols=['222q'])
#usecols选择想要提取的列，选择列名的长度大于 4 的列：usecols=lambda x: len(x) > 4
excel=pd.read_excel(file_path,usecols="A,C")
#excel中上面有A，B,C，usecols="A,C:E"表示第A列和C到E列
excel=pd.read_excel(file_path,usecols=[0,2])
#选第1列和第3列2.5 index_col（选择哪一列作为索引）
excel=pd.read_excel(file_path,index_col=1)
#index_col：指定将第几列作为索引2.6 dtype（列数据类型）
excel=pd.read_excel(file_path,dtype='333q':np.float64)
#指定读取列的数据类型,可接收字典,若指定了“converters”参数，则dtype函数失效。2.7 converters（列数据变换）
excel=pd.read_excel(file_path,dtype="222q":np.float64,converters="ID":str,"vaule":lambda x: x+1)
#converters指定列数据类型转换函数，包括了dtype的功能，也可以对某一列使用Lambda函数，进行某种运算2.8 true_values和false_values （数据清洗）
excel=pd.read_excel(file_path,sheet_name=1,true_values=['female'],false_values=['male'])
#传输一个列表判断为true或是false2.9 skiprows（过滤行）
#skiprows参数为跳过行操作,仅取偶数行：skiprows=lambda x:x%2==0
excel=pd.read_excel(file_path,skiprows=[1,3])2.10 skipfooter（过滤结尾）
excel=pd.read_excel(file_path,skipfooter=2)
#从结尾往上过滤掉指定数量的行2.11 nrows（一次性读入行数）
#nrow指定需要读取前多少行，通常用于较大的数据文件中
excel=pd.read_excel(file_path,nrows=3)2.12 na_values（处理成NaN）
#na_values将指定的值或者传入中的列表中的值设置为NaN 含义：用于将某些特定的值，解析为NaN值，然后便于我们后面做缺失值的处理； na_values=”值1“表示将所有数据中值1全部替换为NaN； na_values=[”值1“,"值2"]表示将所有数据中值1、值2全部替换为NaN； na_values="列1":[”值1“,"值2"]表示将第一列中所有的值1、值2全部替换为NaN；
excel=pd.read_excel(file_path,sheet_name=1,na_values=["", "NULL"],keep_default_na=False)
#表示将所有数据中值1、值2全部替换为NaN；
excel = pd.read_excel(file_path, na_values="列2": ["0", " "])
#只替换某一列中的某些值为NaN2.13 keep_default_na（默认转换为NaN的值不转换）
#keep_default_na处理数据是否包含默认的NaN值依赖于na_values参数是否被传递，默认为True，即自动识别空值导入。
2.24 na_filter（空值监测）
# na_filter指定为 False，那么 pandas 在读取 CSV 的时候不会进行任何空值的判断和检测，所有的值都会保留原样。 # 作用：检测缺少的值标记。当数据中没有任何NA值时，na_filter设置为False可以提高处理速度，特别是处理大文件时。 # 另外，该参数会屏蔽 keep_default_na 和 na_values，也就是说，当 na_filter 为 False 的时候，这两个参数会失效。
excel=pd.read_excel(file_path, na_filter=False)2.25 parse_dates和date_parser（日期处理）
# parse_dates# 含义：指定将哪些列，解析为日期格式； # parse_dates=True是专门用于将行索引，解析为日期格式； # parse_dates=[0,1,2,3,4]和parse_dates=["列名1","列名2","列名3","列名4"]，都是将指定列一起解析为日期格式； # parse_dates=[[1,2,3]]和parse_dates=[["年","月","日"]]，都是将多个列，解析为单个日期列(列名是组合的列名)； # parse_dates="日期":[1,2,3]不仅将多个日期列解析为单个日期列，同时还为这一列命名； #重新创建个表： # 年 月 日 # 2022 4 27 # 2022 4 27
excel = pd.read_excel(file_path, parse_dates=[0, 1, 2, 3])
excel = pd.read_excel(file_path, parse_dates=[["年","月","日"]])
excel = pd.read_excel(file_path, parse_dates="日期":[0,1,2])# data_parser # 作用：设置处理日期数据的函数,利用lambda函数，将某个字符串列，解析为日期格式；一般是配合parse_dates参数，一起使用
excel=pd.read_excel(file_path,parse_dates=[0],date_parser=lambda x:pd.to_datetime(x,format='%Y年%m月%d日'))2.26 mangle_dupe_cols（重名列的处理）
# 参数 mangle_dupe_cols 默认为 True，重名的列导入后面多一个 .1。如果设置为 False，会抛出不支持的异常：
excel=pd.read_excel(file_path,mangle_dupe_cols=False)2.27 engine（数据引擎）
# engine参数为指定Excel处理引擎，一般Excel处理引擎为xlrd，openpyxl，odf：
excel=pd.read_excel(file_path,engine='openpyxl')2.28 verbose
# .verbose输出放置在非数字列中NA值的数目
excel=pd.read_excel(file_path, verbose=True)2.29 squeeze（返回Series）
squeeze：布尔值，默认为False。如果只有一列数值，则返回一个Series。
2.30 补充-查看得到后的数据
print(content)
print(content.head()) # 默认返回前5行数据
print(content.head(3)) # 返回前3行数据
print(content.shape) # 返回一个元组（总行数，总列数），总行数不包括标题行
print(content.index) # RangeIndex(start=0, stop=182807, step=1)
# 返回索引，是一个可迭代的对象<class 'pandas.core.indexes.range.RangeIndex'>
print(content.columns) # 返回所有的列名 Index(['x', 'y', 'traffic'], dtype='object')
print(content.dtypes) # 返回的是每列的数据类型2.31更多
# python用于读写excel文件的库有很多，除了前面提到的pandas，还有xlrd、xlwt、openpyxl、xlwings等等。 # 主要模块： # xlrd库：从excel中读取数据，支持xls、xlsx # xlwt库：对excel进行修改操作，不支持对xlsx格式的修改 # xlutils库：在xlw和xlrd中，对一个已存在的文件进行修改 # openpyxl：主要针对xlsx格式的excel进行读取和编辑 # xlwings：对xlsx、xls、xlsm格式文件进行读写、格式修改等操作 # xlsxwriter：用来生成excel表格，插入数据、插入图标等表格操作，不支持读取 # Microsoft Excel API：需安装pywin32，直接与Excel进程通信，可以做任何在Excel里可以做的事情，但比较慢
3.read_sql(sql语句,数据库连接对象)
# 操作数据库（pymysql、cx_Oracle等） # python几乎支持对所有数据库的交互，连接数据库后，可以使用sql语句进行增删改查。 # 主要模块： # pymysql：用于和mysql数据库的交互 # sqlalchemy：用于和mysql数据库的交互 # cx_Oracle：用于和oracle数据库的交互 # sqlite3：内置库，用于和sqlite数据库的交互 # pymssql：用于和sql server数据库的交互 # pymongo：用于和mongodb非关系型数据库的交互 # redis、pyredis：用于和redis非关系型数据库的交互
数据库表格读取、数据对象的创建，可以根据pymysql,cx_oracle等模块连接mysql或者oracle。
1.sql:sql语句。
2.con：mysql连接。
3.index_col：指定索引列，默认为None。
4.coerce_float：尝试将非字符型，非数值型转换为浮点数，默认为True。
5.params：列表，元组，字典，默认为None。传递参数到sql语句。
6.parse_datas:列表或字典，默认为None。
7.columns：指定列名，list类型。
8.chunksize：可以返回一个迭代器，默认为None。
import pymysql
import pandas as pd
def select_Tab(table):
# mysql配置参数
mysql_conf =
'host': '127.0.0.1',
'port': 3306,
'user': 'root',
'passwd': '123456',
'db': 'test',
'charset': 'utf8'
mysql_conn = pymysql.connect(host=mysql_conf['host'], port=mysql_conf['port'],
user=mysql_conf['user'], passwd=mysql_conf['passwd'],
db=mysql_conf['db'], charset=mysql_conf['charset'])
sql = "select * from " + table
rc = pd.read_sql(sql, mysql_conn)
# cursor = mysql_conn.cursor()
# try:
# cursor.execute(sql)
# rc = cursor.fetchall()
#
# except Exception as e:
# print(e)
# mysql_conn.rollback()
#
# cursor.close()
mysql_conn.close()
return rc
a = select_Tab('sc')可以看到使用pd.read_sql()函数可以保留列名，而如果使用pymysql库读取则不会保留列名。
4.read_table
读取通用分隔符分割的数据文件到数据框。参数与read_csv完全相同。
5.Pandas其他数据读取方法
# read_json 读取json格式文件 将json对象转换为Pandas对象 # read_html方法 读取html表格 # read_clipboard方法 读取剪切板内容 # read_pickle方法 读取plckled持久化文件 # read_sql方法 读取数据库数据，连接好数据库后，传入sql语句即可 ## read_dhf方法 读取hdf5文件，适合大文件读取 # read_parquet方法 读取parquet文件 # read_sas方法 读取sas文件 # read_stata方法 读取stata文件 # read_gbq方法 读取google bigquery数据
二.操作数据
numpy创建的数组中元素要求是同种数据类型，对数据分析、挖掘有较大的局限性.
pandas基于Numpy而创建可以处理不同的数据类型，而且有非常利于数据处理的数据结构：序列series和数据框dataframe.序列由两部分组成，一部分是索引，一部分是对应的值
2.1Series序列
import pandas as pd
import numpy as np
l1=(1,4,'h1') #[1,-2,2.3,'hq']#np.array([1,7.1])
s1=pd.Series(l1)# 指定列表、元祖或数组创建默序列,索引从0开始
l1 = 'red':2000,'blue':1000,'yello':500
s1 = pd.Series(l1, dtype=float)# 通过字典创建序列,索引就是字典key
# 通过dtype可以强制改变数据类型
s1 = pd.Series([-2,-2,np.nan,'hq'],index=['a','b','c','d'])# 指定列表和索引，创建个性化序列，效果和用字典差不多
# np.nan是一个float类型的数据，什么时候numpy中出现nan，我们读取本地文件为float时，如果有缺失，或者做了不合适的计算。
s1['d']='aaaa'#可以随时修改并生效
print(s1['d'])# 序列中的元素访问方式非常简单，通过索引可以访问对应的元素值
print(s1.get('a3','默认值'))#通过get方法，查找对应的索引值，找不到指定后面的默认值
print('c' in s1)#索引值在c1中返回True，不存在返回False
# 序列有两个属性，分别是值和索引，通过index和values可以获得其内容
print(s1.index)#Index(['a', 'b', 'c', 'd'], dtype='object')
print(s1.values)#[-2 -2 nan 'hq']
s2=s1.unique() #去掉序列中重复的元素值
s2=s1.fillna(999)#所有空值元素填充999
s2=s1.isin([-2,'hq'])#判断元素值是否存在，返回一个bool数组，存在为true,不存在false
s2=s1.value_counts()#统计序列元素值出现的次数,索引为序列元素的值，值为出现的次数
s2=s1.isnull()#判断序列是否有空值,返回一个bool数组，是返回true,不是返回false
s2=s1.notnull()#判断序列是否有非空值,返回一个bool数组，是返回true,不是返回false
print(s1[s2])#输出非空数据
print(s1.dropna())#清洗序列中的空值,和上面一样得出非空数据
s2 = s1[['a','b']] # 取索引号为字符a,b的元素
s2 = s1[0:1] # 索引为连续的数组
s2 = s1[[0,2,3]] # 索引为不连续的数组
s1 = pd.Series([1,2,3,4,5])
s2 = s1[s1>2] # 索引为逻辑数组，对应的s1数组必须都是数字，有字母会出错
print(s1.sum(),s1.mean(),s1.std(),s1.max(),s1.min(),s1.median(),s1.var())
#sum 求和， mean 求平均数据， std 求标准差， max 最大值， min 最小值， median 中位数， var 方差
s1 = pd.Series([1,2,3],index=['a','b','e'])
s2 = pd.Series([9,8,7,6],index=['a','b','c','d'])
print(s1+s2)#索引相同的其对应值会相加，不同的索引其内容值都为NaN
s1 = pd.Series([-2,-2,np.nan,'hq'],index=['a','b','c','d'])
s1.name='Series对象name'
s1.index.name='索引列'
print(s1)#Series对象和索引都可以有一个名字，存储在属性.name中2.2dataframe数据框
#设置输出完整、对齐的表格
pd.set_option('display.unicode.ambiguous_as_wide', True)
pd.set_option('display.unicode.east_asian_width', True)
# 通过Series对象字典创建
population_dict = "BeiJing": 2154,"ShangHai": 2424,"ShenZhen": 1303,"HangZhou": 981
population = pd.Series(population_dict)
s1=pd.DataFrame(population, columns=["population"])
s1=pd.DataFrame('population':population,'population2':population)
s1=pd.DataFrame('population':population,'population2':population,"country": "China")#数量不够的会自动补齐
df2=pd.DataFrame(np.arange(12).reshape(3,4),index=['a','c','b'],columns=[11,13,10,12]) #将二维数组转化为DataFrame类型数据
# 通过字典列表对象创建
data = ["a": i, "b": 2*i for i in range(3)]
print(data)#['a': 0, 'b': 0, 'a': 1, 'b': 2, 'a': 2, 'b': 4]
s1=pd.DataFrame(data)
data = ["a": 1, "b":1,"b": 3, "c":4]#不存在的键，会默认值为NaN
# 通过Numpy二维数组创建
data = np.random.randint(10, size=(3, 2))
s1=pd.DataFrame(data, columns=["foo", "bar"], index=["a", "b", "c"])
data = 'a':pd.Series([1,2,3],index=['i1','i2','i3']),'b':pd.Series([9,8,7,6],index=['i1','i2','i3','i4'])
data = 'a':[5,3,np.nan,1,6],'b':['d','c','a',np.nan,'q'],'c':[4,6,5,5,6]
s1=pd.DataFrame(data)#其中字典的键转化为列名，字典的值转化为列值，而索引不设置则为默认值，即从0开始由大到小排列
print(s1)
print(s1.columns,s1.index,s1.values,s1.shape,s1.size,s1.dtypes)#显示出列名，索引范围和列值的数组,形状,大小,返回每列数据类型
s1.replace('a':'A':'D','B':'E')#dataframe对象’upper’列中'A'修改成'D','B'修改成'E'
s2=s1.dropna()#去掉空值，原来的数据集不会发生改变,新数据集需要重新定义
s2=s1.dropna(axis=0,how='any')#axis=0表示行,axis=1表示列；how="any"表示存在任意一个或多个缺失值，how="all"表示全部为缺失值
# print(s1)
print(s2)
s2 = s1.fillna('love') # 所有空值元素填充love,也可以设置填充0等
print(s2)
s2 = s1.fillna('a':10,'b':1) #设置列填充，可以全部列填充也可以部分列填充
print(s2)
s2=s1.fillna(method='pad',axis=1) #使用缺失值的前一个值进行填补，axis=0表示使用前一行非缺失值进行填补；axis=1表示使用前一列进行非缺失值填补
s2=s1.fillna(method='backfill',axis=0)#使用缺失值的后一个值进行填补，axis=0表示使用后一行的非缺失值进行填补，axis=1表示使用后一列的非缺失值进行填补
s2=s1.sort_values('c',ascending=False)#指定按列值进行排序,默认按升序，这里设置为降序
print(s2)
s2=s1.sort_index(ascending=False)#按索引进行排序,默认按升序，这里设置为降序
print(s2)
s2=s1.head(2)#取数据集中的前n行
s2=s1.drop('b',axis=1)#删除数据集中的制定的列,需指定轴为1
s2 = pd.DataFrame('d':[1,2,3,4,5])
s3=s1.join(s2)#实现两个数据框之间的水平连接
print(s3)
n1=s1.to_numpy()#将数据框转换为numpy数组的形式
print(n1)
print(s2.sum())#各列求和，含有字母列会报错
print(s2.mean())#各列求平均值,含有字母列会报错
print(s1.describe())#各列做描述性统计
s2 = s1.fillna(99) # 所有空值元素填充0
print(s2)
# 利用数据框中的iloc属性进行切片
s2 = s1.iloc[1:3,2] # 获取从0开始1,2行 从0开始第2列的数据框
s2 = s1.iloc[1:3,0:2] # 获取从0开始1，2行，从0开始0,1列的数据框
s2 = s1.iloc[1:3,:] # 获取从0开始 1,2行 所有列的数据框
s2 = s1.iloc[[0,2,3],[1,2]] # 获取从0开始 0，2,3行，第1，2列数据框
TF=[True,False,False,True,True]
s2 = s1.iloc[TF,[1]] # 获取第0、3、4行 从0开始，第1列的数据
data ='a':[2,2,np.nan,5,6],'b':['kl','kl','kl',np.nan,'kl'],'c':[4,5,6,np.nan,6],'d':[7,9,np.nan,9,8]
s1 = pd.DataFrame(data)
# 利用loc属性进行切片
# 数据框中的loc属性，主要基于列标签进行索引，对列值进行行定位，通过指定列，从而实现数据切片操作
s2 = s1.loc[s1['b'] == 'kl',:] # 选取所有列，且b行有由kl的元素，组成数据框
s2 = s1.loc[s1['b']== 'kl',:].head(3) # 选取所有列，且b行有由kl的元素， 选出前三行，组成数据框
s2 = s1.loc[s1['b'] == 'kl',['a','c']].head(3) # 选取a,c列且有kl的元素，选出前三行，组成数据框
s2 = s1.loc[s1['b'] == 'kl',['a','c']] # 选取a,c列且有kl的元素，组成数据框
s2=s1.loc[[1,2]]#获取行
s2=s1[['a','b']]#获取列
s2=s1.a #通过列名直接获取
#获取某一个值
s2=s1.loc[0,'a']#通过索引和列名
s2=s1.iloc[0,1]#通过索引
s2=s1.values[0][1]#通过索引
# df[‘列名’] 返回值为Series类型
# df[[‘列名’]] 返回值为DataFrame类型
s2 = pd.date_range(start='2019-01-01', periods=6)
s2 = pd.DataFrame(np.random.randn(6,4), index=s2, columns=["A", "B", "C", "D"])
# 行切片
print(s2["2019-01-01": "2019-01-03"])
print(s2.loc["2019-01-01": "2019-01-03"])
# 列切片
print(s2.loc[:, "a": "c"])
# 行列切片
print(s2.loc["2019-01-02": "2019-01-03", "c":"d"])
# s2.loc["2019-01-04": "2019-01-06", ["a", "c"]]
# s2.iloc[3:, [0, 2]]
#取值
# s2.loc[["2019-01-04", "2019-01-06"], ["A", "D"]]
# s2.iloc[[1, 5], [0, 3]]
print('!!!'*10)
a=pd.DataFrame(np.arange(12).reshape(3,4))
b=pd.DataFrame(np.arange(20).reshape(4,5))
print(a+b)#+‐*/符号进行的二元运算产生新的对象,空缺自动补齐NaN
print(a+3)#每个值+3
print(np.exp(a))#e的a[i]次方
# 方法形式的运算
# fill_value把运算前缺省的NaN空值替换后，再参与运算，得出结果
c=b.add(a,fill_value=2)#类型间加法运算
c=b.sub(a,fill_value=2)#类型间减法运算
c=a.mul(b,fill_value=2)#类型间乘法运算
c=a.div(b,fill_value=2)#类型间除法运算
print(c)
print(a>5)#比较运算 >< >= <= == !=返回对应格式的bool数组
s2=s1['b'].isin(['kl']) #相当于Series序列中查找一列中的数据返回bool数组
print(s1[s2])#根据一列的bool数组，输出对应的行数据
print(s2)
# 添加新列
s1['e']=[2,2,np.nan,5,6]
print(s1)
s1.index = [i for i in range(len(s1))]#修改index，len返回的是行数
# df.index=[‘name1’,‘name2’] 改变数组的行索引名，对原数组修改
# df.reindex=[‘name1’,‘name2’,inplace=Falese] 若指定的索引名不是原数组的索引名，则新添加一行为NaN的数据，否则不改变原数组，返回新数组，默认不在原数组修改
# df.set_index(‘列名’，drop=True，inplace=Falese) 指定某一列为行索引名替换原来的索引名，默认删除此列，且不在原数组修改
# df3 = df1.set_index(['A','B'])
# df4 = df3.swaplevel()#设置了2个索引之后，采用这个可以互换索引列
s1.columns = [i for i in range(s1.shape[1])]#修改columns,s1.shape[1]指的是行数,[2]是列数
print(s1.head(),s1.head(2),s1.tail(),s1.tail(3),s1.info())#默认前5行,前2行,默认后5行,前3行,查看总体信息
print(s1.isnull())#判断数据是否有缺失，并返回对应的bool数组
print(np.any(s1.isnull()))#存在一个或多个空值的时候即返回True，若不存在空值则返回False
print(np.all(s1.isnull())) #当数据全部为空值时，返回为True，否则，返回为False
# df['B'].isnull()#查看某一列空值
# df['B'].unique()#查看某一列的唯一值
# 数据合并
# s3=s1.join(s2)#实现两个数据框之间的水平连接
data1=pd.DataFrame(np.arange(12).reshape(4,3),columns=['a','c','d'])
data2=pd.DataFrame(np.arange(12,24).reshape(3,4),columns=['a','b','c','d'])
df9=pd.concat([data1,data2],axis=0,ignore_index=True) #将data1与data2进行纵向合并（axis=0表示纵向，axis=1表示横向），ignore_index=True表示行索引重新取值
df11=pd.concat([data1,data2],join='inner',axis=0,ignore_index=True) #纵向合并，只合data1与data2中共有的列，默认join="outer"，
print(df11)
# df['city']=df['city'].str.lower()#大小写转换
# df['price'].astype('int')更改数据格式
# df.rename(columns='category': 'category-size')#更改列名称
# df['city'].drop_duplicates()#删除后出现的重复值
# df['city'].drop_duplicates(keep='last')#删除先出现的重复值
# df['city'].replace('sh', 'shanghai')#数据替换
df_inner=pd.merge(data1,data2,how='outer')#数据表合并，inner：交集；outer：并集，还有left、right
# result = df1.append(df2)#把2个表的内容纵向拼接起来
print(df_inner)
s2=s1.groupby(by=3)#通过指定列，把该列中数值相等的划分到一类当中去
print(s1)
for t in s2:
print(t)
# print(t[0])
# print(t[1])
# df_inner['group'] = np.where(df_inner['price'] > 3000,'high','low')
# 如果prince列的值>3000，group列显示high，否则显示low
# df_inner.loc[(df_inner['city'] == 'beijing') & (df_inner['price'] >= 4000), 'sign']=1
# 对复合多个条件的数据进行分组标记三.导出数据
3.1to_csv导出到csv
to_csv()是DataFrame类的方法，read_csv()是pandas的方法
3.1.1 path_or_buf（路径）
content.to_csv('Result.csv') #相对位置，保存在getwcd()获得的路径下
content.to_csv('C:/Users/think/Desktop/Result.csv') #绝对位置3.1.2 sep（分隔符 ）
content.to_csv(file_path,sep='?')#使用?分隔需要保存的数据，如果不写，默认是,3.1.3 na_rep（替换空值）
content.to_csv(file_path,na_rep='NA') #确实值保存为NA，如果不写，默认是空3.1.4 float_format（格式 ）
content.to_csv(file_path,float_format='%.2f') #保留两位小数3.1.5 cols（保留某列数据 ）
content.to_csv(file_path,columns=['name']) #保存索引列和name列3.1.6 header（保留列名 ）
content.to_csv(file_path,header=0) #不保存列名3.1.7 index（是否保留行索引 ）
content.to_csv(file_path,index=0) #不保存行索引3.2to_excel导出到excel
3.2.1 excel_writer文件路径
excel.to_excel(file_path)
3.2.2 sheet_name:DataFrame 的工作表的名称默认为“Sheet1”
要将单个对象写入 Excel .xlsx 文件，只需指定目标文件名。
excel1.to_excel(file_path2,sheet_name='xxx1')要写入多个工作表，需要使用目标文件名创建ExcelWriter 对象，并在文件中指定要写入的工作表。
with pd.ExcelWriter(file_path2) as writer:
excel1.to_excel(writer, sheet_name='Sheet_name_1')
excel2.to_excel(writer, sheet_name='Sheet_name_2')3.2.3 na_rep：缺少数据表示，默认“”
excel1.to_excel(file_path,na_rep='NA') #确省值保存为NA，如果不写，默认是空
3.2.4 index：索引
excel1.index.name='最左上角空着的那个索引'
excel1.to_excel(file_path2,index=False)
#默认为True 写行名,设为False则上面设置了也没有索引3.2.5 float_format：浮点数的格式字符串
excel1.to_excel(file_path2,float_format="%.2f")#会将 0.1234 格式化为 0.123.2.6 na_rep：决定将空格显示成什么
excel1.to_excel(file_path2,na_rep="空值了不起？")3.2.7 engine：设置编写Excel文件库要使用的引擎，‘openpyxl’ or ‘xlsxwriter’等
excel1.to_excel(file_path2, engine='xlsxwriter')3.2.其他
# columns：str 的序列或列表，可选 要写的列。 # header：bool 或 str 列表，默认 True 写出列名。如果给出字符串列表，则假定它是列名的别名。 # index_label：str 或序列，可选 如果需要，索引列的列标签。如果未指定，并且 header 和 index 为 True，则使用索引名称。如果 DataFrame 使用 MultiIndex，则应给出一个序列。 # startrow：整数，默认 0 左上角单元格行转储数据帧。 # startcol：整数，默认 0 左上角单元格列转储 DataFrame 。 # merge_cells：布尔值，默认为真 将 MultiIndex 和 Hierarchical Rows 写入合并单元格。 # encoding：str，可选 生成的 excel 文件的编码。只有 xlwt 需要，其他编写器原生支持 unicode。 # inf_rep：str，默认 ‘inf’ 无穷大的表示(Excel 中没有无穷大的本机表示)。 # verbose：布尔值，默认为真 在错误日志中显示更多信息。 # freeze_panes：int 元组(长度为 2)，可选 指定要冻结的从 1 开始的最底行和最右列。 # storage_options：字典，可选 对特定存储连接有意义的额外选项，例如主机、端口、用户名、密码等。对于 HTTP(S) URL，键值对作为标头选项转发到 urllib。对于其他 URL(例如以 “s3://” 和 “gcs://” 开头)，键值对被转发到 fsspec 。有关详细信息，请参阅fsspec 和urllib。
以上是关于Pandas库的学习的主要内容，如果未能解决你的问题，请参考以下文章