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。

你可能感兴趣的:(Python,学习,机器学习,python)