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"] * 3

1.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)  # 

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)  # 
# 调用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)
# 返回索引，是一个可迭代的对象
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或是false

2.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", " "]})
#只替换某一列中的某些值为NaN

2.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)
# 返回索引，是一个可迭代的对象
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.12

3.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。