pandas是数据处理最常用的分析库之一，可以读取各种各样格式的数据文件，一般输出dataframe格式。
如：txt、csv、excel、json、剪切板、数据库、html、hdf、parquet、pickled文件、sas、stata等等。
对于结构化的、探索性数据统计和分析场景，使用pandas方法进行读取，因为其提供了数据框，对数据进行任意翻转、切片、关联都很方便。
1.read_csv方法
read_csv方法用来读取csv格式文件，输出dataframe格式。
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)
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数组
usecols选择想要提取的列，选择列名的长度大于 4 的列：usecols=lambda x: len(x) > 4
content=pd.read_csv(file_path, usecols=["x", "y"])
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对象只有一种索引
dtype来指定某个列的类型
content=pd.read_csv(file_path, dtype={"x": str,'y':str})#dtype来指定某个列的类型
content["x"] = content["x"] * 3
#converters可以在读取的时候对列数据进行变换,好像也可以指定数据类型
#使用converters参数时，解析器默认所有列的类型为 str，所以需要显式类型转换
content=pd.read_csv(file_path, converters={"id": lambda x: int(x) + 10})
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=["错", "对"])
skiprows 表示过滤行，想过滤掉哪些行，先过滤，然后再确定表头
content=pd.read_csv(file_path,skiprows=[0])
content=pd.read_csv(file_path, skiprows=lambda x: x > 0 and x % 2 == 0)
skipfooter:接收整型，表示从结尾往上过滤掉指定数量的行，解析引擎退化为 Python。这是因为 C 解析引擎没有这个特性。
content=pd.read_csv(file_path, skipfooter=3, encoding="utf-8", engine="python")
#nrows 设置一次性读入的文件行数
它在读入大文件时很有用，比如 16G 内存的PC无法容纳几百 G 的大文件。很多时候我们只是想看看大文件内部的字段长什么样子
content=pd.read_csv(file_path, nrows=1)
na_values 参数可以配置哪些值需要处理成 NaN,针对整个csv中的全部数据,下面是只对指定的列进行替换
content=pd.read_csv(file_path, na_values=["对", "古明地觉"])
content=pd.read_csv(file_path, sep="\t", na_values={"x": ["古明地觉", "博丽灵梦"], "y": ["对"]})
除了 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)
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)
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格式的日期类型
分块读入内存，尤其单机处理大文件时会很有用。
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("读取完毕")
读取完毕</pandas.io.parsers.textfilereader>
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("读取完毕")
读取完毕</pandas.io.parsers.textfilereader>
compression 参数取值为 {'infer', 'gzip', 'bz2', 'zip', 'xz', None}，默认 'infer'，这个参数直接支持我们使用磁盘上的压缩文件。
直接将上面的girl.csv添加到压缩文件，打包成girl.zip
content=pd.read_csv('girl.zip', sep="\t", compression="zip")
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)
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 参数失效。
实际生产用的数据会很复杂，有时导入的数据会含有重名的列。参数 mangle_dupe_cols 默认为 True，重名的列导入后面多一个 .1。如果设置为 False，会抛出不支持的异常
prefix 参数，当导入的数据没有 header 时，设置此参数会自动加一个前缀。比如：
content=pd.read_csv(file_path, header=None, prefix="x")
#生成的列的名称是x0,x1,x2...不指定prefix就是0,1,2...
squeeze参数为True的话，在只有一列的情况下，那么得到就是一个Series
engine指定pandas解析数据时用的引擎，pandas 目前的解析引擎提供两种：c、python，默认为 c，因为 c 引擎解析速度更快，但是特性没有 python 引擎全。如果使用 c 引擎没有的特性时，会自动退化为 python 引擎。
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就会按照我们规定的类型去解析指定的列，但是一旦无法解析就会报错。
memory_map如果你知道python的一个模块mmap，那么你肯定很好理解。如果使用的数据在内存里，那么直接进行映射即可，直接map文件使用，不会（可以避免文件）再次进行IO操作，默认为False。这个参数比较底层，我们一般用不到。
verbose=True:打印一些额外信息
thousands 千分位分割符，如 , 或者 .，默认为None。
encoding 指定字符集类型，通常指定为 'utf-8'。根据情况也可能是'ISO-8859-1'
skipinitialspace=True忽略分隔符后的空白（默认为False，即不忽略）.
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) # 返回的是每列的数据类型</class>
2.read_excel方法
read_excel 读取excel文件，包括xlsx、xls、xlsm格式，需要下载openpyxl库
read_excel大多数的方法和read_csv相同，不同的或者特别的我用红色字体标出了。
#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)
该参数为指定读取excel的表格名。
#sheet_name默认为0，=1指定读取第2张表
excel=pd.read_excel(file_path,header=1)
#header参数为指定列表中从第2行作为列索引
excel=pd.read_excel(file_path,names=['x','y','z'])
#names:接收一个数组，将列名(第一行)重定义赋值
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列
excel=pd.read_excel(file_path,index_col=1)
#index_col：指定将第几列作为索引
excel=pd.read_excel(file_path,dtype={'333q':np.float64})
#指定读取列的数据类型,可接收字典,若指定了“converters”参数，则dtype函数失效。
excel=pd.read_excel(file_path,dtype={"222q":np.float64},converters={"ID":str,"vaule":lambda x: x+1})
#converters指定列数据类型转换函数，包括了dtype的功能，也可以对某一列使用Lambda函数，进行某种运算
excel=pd.read_excel(file_path,sheet_name=1,true_values=['female'],false_values=['male'])
#传输一个列表判断为true或是false
#skiprows参数为跳过行操作,仅取偶数行：skiprows=lambda x:x%2==0
excel=pd.read_excel(file_path,skiprows=[1,3])
excel=pd.read_excel(file_path,skipfooter=2)
#从结尾往上过滤掉指定数量的行
#nrow指定需要读取前多少行，通常用于较大的数据文件中
excel=pd.read_excel(file_path,nrows=3)
#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
#keep_default_na处理数据是否包含默认的NaN值依赖于na_values参数是否被传递，默认为True，即自动识别空值导入。
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)
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日'))
参数 mangle_dupe_cols 默认为 True，重名的列导入后面多一个 .1。如果设置为 False，会抛出不支持的异常：
excel=pd.read_excel(file_path,mangle_dupe_cols=False)
engine参数为指定Excel处理引擎，一般Excel处理引擎为xlrd，openpyxl，odf：
excel=pd.read_excel(file_path,engine='openpyxl')
.verbose输出放置在非数字列中NA值的数目
excel=pd.read_excel(file_path, verbose=True)
squeeze：布尔值，默认为False。如果只有一列数值，则返回一个Series。
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) # 返回的是每列的数据类型</class>
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库读取则不会保留列名。
读取通用分隔符分割的数据文件到数据框。参数与read_csv完全相同。
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" 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) t 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.1 to_csv导出到csv
to_csv()是DataFrame类的方法，read_csv()是pandas的方法
content.to_csv('Result.csv') #相对位置，保存在getwcd()获得的路径下
content.to_csv('C:/Users/think/Desktop/Result.csv') #绝对位置
content.to_csv(file_path,sep='?')#使用?分隔需要保存的数据，如果不写，默认是,
content.to_csv(file_path,na_rep='NA') #确实值保存为NA，如果不写，默认是空
content.to_csv(file_path,float_format='%.2f') #保留两位小数
content.to_csv(file_path,columns=['name']) #保存索引列和name列
content.to_csv(file_path,header=0) #不保存列名
content.to_csv(file_path,index=0) #不保存行索引
3.2to_excel导出到excel
excel.to_excel(file_path)
要将单个对象写入 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')
excel1.to_excel(file_path,na_rep='NA') #确省值保存为NA，如果不写，默认是空
excel1.index.name='最左上角空着的那个索引'
excel1.to_excel(file_path2,index=False)
#默认为True 写行名,设为False则上面设置了也没有索引
excel1.to_excel(file_path2,float_format="%.2f")#会将 0.1234 格式化为 0.12
excel1.to_excel(file_path2,na_rep="空值了不起？")
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。
Original: https://blog.csdn.net/qq_42759120/article/details/125190614
Author: 木白星枝
Title: Pandas库的学习
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/618088/
转载文章受原作者版权保护。转载请注明原作者出处！