Pandas

最新推荐文章于 2024-05-30 18:05:01 发布

小透明z0

最新推荐文章于 2024-05-30 18:05:01 发布

阅读量309

点赞数

分类专栏：数据分析学习记录文章标签： pandas python numpy

本文链接：https://blog.csdn.net/weixin_43540299/article/details/129956876

版权

数据分析学习记录专栏收录该内容

2 篇文章 0 订阅

订阅专栏

数据分析工具Pandas

Pandas的数据结构分析

# Series 一维数据结构
# DataFrame 二维数据结构

Series

# Series 类的构造方法
# class pandas.Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)
# date：传入的数据
# index: 索引
# dtype：数据类型
# copy： 是否复制数据，默认False
import pandas as pd
ser_obj = pd.Series([1,2,3,4])
print(ser_obj)

0    1
1    2
2    3
3    4
dtype: int64

# 用列表构建Pandas对象，并指定索引
ser_obj = pd.Series([1,2,3,4],index=['a','b','c','d'])
print(ser_obj)

a    1
b    2
c    3
d    4
dtype: int64

# 可以用dict字典构建pandas对象
year_data = {2002:11,2023:1,2005:17}
year_obj = pd.Series(year_data)
year_obj

2002    11
2023     1
2005    17
dtype: int64

# index属性，返回索引值对象
year_obj.index
# type(year_obj.index)   #pandas.core.indexes.numeric.Int64Index

Int64Index([2002, 2023, 2005], dtype='int64')

# value属性，返回值数组
year_obj.values
# type(year_obj.values)   # numpy.ndarray

array([11,  1, 17], dtype=int64)

# 用索引来获取数据
year_obj[2002]

# 数组运算后，索引和数据的对应关系仍然保持

DataFrame

# DataFrame 是一个类似于二维数组或表格的对象，每列可以是不同的数据类型
# 由索引和数据组成，索引包含行索引和列索引
# Pandas的DataFrame类的对象构造方法
# pandas.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)
# index：行标签
# columns：列标签

demo_arr = np.array([[1,2,3,4],['a','b','c','d']])
demo_arr_obj = pd.DataFrame(demo_arr)
demo_arr_obj

	0	1	2	3
0	1	2	3	4
1	a	b	c	d

demo_arr_obj[2]

0    3
1    c
Name: 2, dtype: object

demo_arr_obj.2

  File "C:\Users\lenovo\AppData\Local\Temp\ipykernel_8256\527398533.py", line 1
    demo_arr_obj.2
                ^
SyntaxError: invalid syntax

# 为DataFrame增加一列数据
demo_arr_obj['No4']=[2,'k']
demo_arr_obj

	0	1	2	3	No4
0	1	2	3	4	2
1	a	b	c	d	k

element = demo_arr_obj['No4'][0]
print(type(element))

<class 'int'>

# 为DataFrame删除一列数据
del demo_arr_obj[0]
demo_arr_obj

	1	3	No4
0	2	4	2
1	b	d	k

Pandas索引操作及高级索引

索引对象

# Index索引对象不可变，已保障数据安全

# Pandas 其他常见的Index子类
# ① Int64Index：针对整数的特殊Index对象
# ② MultiIndex：层次化索引，表示单个轴上的多层索引
# ③DetimeIndex：储存纳秒时间戳

重置索引

# reindex() 方法：匹配原索引和新索引，填充未匹配的新索引对应值，并将原索引按新索引进行排序
# 格式为：DataFrame.reindex(labels=None, index=None, columns=None, axis=None, method=None, copy=True, level=None, fill_value=nan, limit=None, tolerance=None)
# 参数解释：① index：新索引序列
# ② method：插值填充方式
# ③ fill_value：引入缺失值时使用的替代值
# ④ limit：向前或向后填充是的最大填充量

import pandas as pd
ser_obj = pd.Series([1,2,3,4,5], index=['c','d','a','b','e'])
ser_obj

c    1
d    2
a    3
b    4
e    5
dtype: int64

# reindex()重置索引
ser_obj2 = ser_obj.reindex(['a','b','c','d','e','f'])
ser_obj2

a    3.0
b    4.0
c    1.0
d    2.0
e    5.0
f    NaN
dtype: float64

# 重置索引时指定填充缺失值
ser_obj2 = ser_obj.reindex(['a','b','c','d','e','f'], fill_value=0)
ser_obj2

a    3
b    4
c    1
d    2
e    5
f    0
dtype: int64

# 重置索引，向前填充值
ser_obj3 = ser_obj2.reindex(['a','b','c','d','e','f','g'], method='ffill')
ser_obj3

a    3
b    4
c    1
d    2
e    5
f    0
g    0
dtype: int64

ser_obj2

a    3
b    4
c    1
d    2
e    5
f    0
dtype: int64

索引操作

Series 的索引操作

# 可以使用索引，索引名称，或切片来查询数据
import pandas as pd
arr1 = np.arange(1,6,1)
ser_obj = pd.Series(arr1, index=['a','b','c','d','e'])
ser_obj

a    1
b    2
c    3
d    4
e    5
dtype: int32

# 使用索引查询
ser_obj[2]

# 使用索引名称查询
ser_obj['e']

# 使用切片查询
ser_obj[2:4]

c    3
d    4
dtype: int32

# 查询不连续的数据
ser_obj[[0,2,4]]

a    1
c    3
e    5
dtype: int32

# 使用布尔索引
ser_bool = ser_obj>2
ser_bool

a    False
b    False
c     True
d     True
e     True
dtype: bool

ser_obj[ser_bool]

c    3
d    4
e    5
dtype: int32

DataFrame的索引操作

# DataFrame既有行索引，通过index属性进行获取，又有列索引，通过columns属性进行获取
# DataFrame中每一列都是一个Series对象

# 创建一个3*4的DataFrame对象
arr = np.arange(12).reshape((3,4))
df_obj = pd.DataFrame(arr,columns=['a','b','c','d'])
df_obj

	a	b	c	d
0	0	1	2	3
1	4	5	6	7
2	8	9	10	11

# 通过列索引名
df_obj['c']

0     2
1     6
2    10
Name: c, dtype: int32

# 通过列索引名获取不连续数据（Serise对象）
df_obj[['c','a']]

	c	a
0	2	0
1	6	4
2	10	8

# 通过切片获取数据
df_obj[0:1]

	a	b	c	d
0	0	1	2	3

df_obj[:3][['a','c']]

	a	c
0	0	2
1	4	6
2	8	10

使用Pandas提供的方法操作索引

# loc():基于标签索引，按标签取数，当执行切片操作时，既包含起始索引也包含结束索引
# loci():基于位置索引（整数索引），按位置取数，当执行切片操作时，只包含起始索引，不包含结束索引
df_obj.loc[1:2,['b','c']]
df_obj.iloc[1:2,1:2]
df_obj.iloc[1:2,[1,2]]

	b	c
1	5	6

算术运算与数据对齐

# Pandas执行算术运算时，会先按照索引进行对齐在进行运算，没有对齐的位置会用NaN补齐
# Serise是按照行索引补齐的，DataFrame是按照行索引、列索引对齐的

obj1 = pd.Series(range(1,4), index=range(3))
obj1

0    1
1    2
2    3
dtype: int64

obj2 = pd.Series(range(10,16), index=range(6))
obj2

0    10
1    11
2    12
3    13
4    14
5    15
dtype: int64

obj1 + obj2

0    11.0
1    13.0
2    15.0
3     NaN
4     NaN
5     NaN
dtype: float64

obj1.add(obj2,fill_value=0)

0    11.0
1    13.0
2    15.0
3    13.0
4    14.0
5    15.0
dtype: float64

数据排序

按索引排序

# sort_index()方法：可以用行索引或者列索引进行排序
# 格式sort_index(axis=0,level=None,ascending=true,inplace=False,kind='quicksort',na_position='last',sort_remaining=True,by=None)
# axis：轴索引
# level：若不为None，则对指定索引级别的值进行排序
# ascending：是否升序排列，默认True
# inplace：默认为False，标识对数据表进行排序，不创建新的实例
# kind：选择排序算法

ser_obj2 = pd.Series(range(7,20,3),index=range(5))
ser_obj2

0     7
1    10
2    13
3    16
4    19
dtype: int64

ser_obj2.sort_index(ascending=False)

4    19
3    16
2    13
1    10
0     7
dtype: int64

ser_obj2[5]=7

ser_obj2

0     7
1    10
2    13
3    16
4    19
5     7
dtype: int64

按值排序

# sortvalues(by,axis=0,ascending=True,inplace=False,king='quicksort',na_position='last')
# by：表示排序的列
# na_position 的参数只有两个值，first表示 NaN会放在开头，last表示NaN放在末尾，默认放在末尾
ser_obj2.sort_values()

0     7
5     7
1    10
2    13
3    16
4    19
dtype: int64

ser_obj2

0     7
1    10
2    13
3    16
4    19
5     7
dtype: int64

ser_obj2.sort_values(inplace=True)

ser_obj2

0     7
5     7
1    10
2    13
3    16
4    19
dtype: int64

data = np.arange(1,13,1).reshape(3,4)
df_obj2 = pd.DataFrame(data)
df_obj2

	0	1	2	3
0	1	2	3	4
1	5	6	7	8
2	9	10	11	12

df_obj2.sort_values(by=2,ascending=False)

	0	1	2	3
2	9	10	11	12
1	5	6	7	8
0	1	2	3	4

统计计算与描述

常用的统计计算

# sum:计算和
# mean:均值
# median：中位数
# max，min：最大值，最小值
# idxmax，idxmin：最大索引，最小索引
# count 计算非NaN个数
# var:方差
# head：获取前N个值
# std:样本值的标准差
# skew:样本值的偏度（三阶矩）
# kurt:样本值的峰度（四阶矩）
# cumsum:样本值的累计和
# cummin,cummax：yapf_reformat本值的累积最小值和累积最大值
# cumprod：样本的累计积
# describe：对Series和DataFrame列计算汇总统计

# 求每列的和
df_obj2.sum()

0    15
1    18
2    21
3    24
dtype: int64

# 求每行的和
df_obj2.sum(axis=1)

0    10
1    26
2    42
dtype: int64

df_obj2.head(1)

	0	1	2	3
0	1	2	3	4

统计描述

df_obj2.describe().loc[['std'],0:3]

	0	1	2	3
std	4.0	4.0	4.0	4.0

层次化索引

认识层次化索引

①在构造方法的index参数中上传一个嵌套列表

# 创建两层索引结构的Series对象
multiindex_ser_obj = pd.Series(range(145875,746431,80456),index=[['a','a','a','a','b','b','b','b'],['aa','ab','ac','ad','ba','bb','bc','bd']])
multiindex_ser_obj

a  aa    145875
   ab    226331
   ac    306787
   ad    387243
b  ba    467699
   bb    548155
   bc    628611
   bd    709067
dtype: int64

# 创建两层索引结构的DataFrame对象
multiindex_df_obj = pd.DataFrame(range(145875,746431,80456),index=[['a','a','a','a','b','b','b','b'],['aa','ab','ac','ad','ba','bb','bc','bd']],columns=['占地面积'])
multiindex_df_obj

		占地面积
a	aa	145875
	ab	226331
	ac	306787
	ad	387243
b	ba	467699
	bb	548155
	bc	628611
	bd	709067

②通过MultiIndex类的方法构建一个层次化索引

# MultiIndex.from_tuples():将元组列表转换为MultiIndex
# MultiIndex.from_arrays():将数组列表转换为MultiIndex
# MultiIndex.from_product():从多个集合的笛卡尔积中创建一个MultiIndex

# MultiIndex.from_tuples():将元组列表转换为MultiIndex
from pandas import MultiIndex

list_tuples = [('A','A1'),('A','A2'),('A','A3'),('A','A4'),('A','A5'),('B','B1'),('B','B2'),('B','B3')]
multiIndex = MultiIndex.from_tuples(tuples=list_tuples,names=['外层索引','内层索引'])
data = np.arange(1,41,1).reshape(8,5)
df_obj3 = pd.DataFrame(data,index=multiIndex)
df_obj3

		0	1	2	3	4
外层索引	内层索引
A	A1	1	2	3	4	5
	A2	6	7	8	9	10
	A3	11	12	13	14	15
	A4	16	17	18	19	20
	A5	21	22	23	24	25
B	B1	26	27	28	29	30
	B2	31	32	33	34	35
	B3	36	37	38	39	40

# MultiIndex.from_arrays():将数组列表转换为MultiIndex
MIDX = np.array([['A','B','A','B','A','A','B','B'],['A1','B2','A2','B1','A4','A3','B3','B3']])
MIDX_obj = MultiIndex.from_arrays(arrays=MIDX,names=['外层索引','内层索引'])
df_obj4 = pd.DataFrame(data,index=MIDX_obj)
df_obj4

		0	1	2	3	4
外层索引	内层索引
A	A1	1	2	3	4	5
B	B2	6	7	8	9	10
A	A2	11	12	13	14	15
B	B1	16	17	18	19	20
A	A4	21	22	23	24	25
A	A3	26	27	28	29	30
B	B3	31	32	33	34	35
B	B3	36	37	38	39	40

# MultiIndex.from_product():从多个集合的笛卡尔积中创建一个MultiIndex
nums = [0,1,2,3]
colors = ['r','g']
MPROD = multiIndex.from_product(iterables=[nums,colors],names=['nums','colors'])
df_obj5 = pd.DataFrame(data,index=MPROD)
df_obj5

		0	1	2	3	4
nums	colors
0	r	1	2	3	4	5
0	g	6	7	8	9	10
1	r	11	12	13	14	15
1	g	16	17	18	19	20
2	r	21	22	23	24	25
2	g	26	27	28	29	30
3	r	31	32	33	34	35
3	g	36	37	38	39	40

层次化索引的操作

①选取子集操作

maidx = np.array([['小说','小说','小说','随笔散文','随笔散文','随笔散文','传记','传记','传记'],['高山上的小邮局','失踪的总统','绿毛水怪','皮囊','浮生六记','自在独行','梅西','老舍自传','库里传']])
maidx_obj = MultiIndex.from_arrays(maidx,names=['书籍类别','书籍名称'])
nums = np.array([50,60,40,94,63,101,200,56,45])
book_obj = pd.Series(nums,index=maidx_obj)
book_obj

书籍类别  书籍名称   
小说    高山上的小邮局     50
      失踪的总统       60
      绿毛水怪        40
随笔散文  皮囊          94
      浮生六记        63
      自在独行       101
传记    梅西         200
      老舍自传        56
      库里传         45
dtype: int32

book_obj.loc[['传记'],:]

书籍类别  书籍名称
传记    梅西      200
      老舍自传     56
      库里传      45
dtype: int32

book_obj[:,'自在独行']

书籍类别
随笔散文    101
dtype: int32

② 交换分层索引

# 交换内外层索引
# swaplevel()

book_obj.swaplevel()

书籍名称     书籍类别
高山上的小邮局  小说       50
失踪的总统    小说       60
绿毛水怪     小说       40
皮囊       随笔散文     94
浮生六记     随笔散文     63
自在独行     随笔散文    101
梅西       传记      200
老舍自传     传记       56
库里传      传记       45
dtype: int32

③排序分层

# sort_index()
# sort_index(axis=0,level=None,ascending=true,inplace=False,kind='quicksort',na_position='last',sort_remaining=True,by=None)
# 未传入by参数时，会首先选择按照外层索引进行排序，在按照内层索引进行排序

读写数据操作

读写文本文件

① 通过to_csv()方法将数据写入到CSV文件

# 格式
# to_csv(path_or_buf=None,sep='',na_rep='',float_format=None,columns=None,header=True,index=None,index_label=None,mode='w',encoding=None,compression=None,quoting=None,quotechar='',...)
# 常用参数：path_or_buf：文件路径
# index，
# sep：分隔符，默认为‘.’

# 将DataFrame写入到csv文件中
df = pd.DataFrame({'one':[1,2,3],'two':[4,5,6]})
df.to_csv(r'D:\python数据分析资料\csv文件读写.csv')
'写入完毕'

'写入完毕'

② 通过pd.read_csv()函数读取CSV文件的数据

# read_csv(filepath_or_buffer,sep='',delimiter=None,header='infer',names=None,index_col-None,usecols=None,squeeze=False,prefix=None,...)
# filepath_or_buffer:文件路径
# sep：分隔符，默认','
# names:用于结果的列名，如果读取的文件中没有列名，则默认为0，如果有，设置为None
# index_col：用作行索引的列编号或列名，如果给定一个序列，则表示有多个行索引

file=open(r'D:\python数据分析资料\csv文件读写.csv')
file_data = pd.read_csv(file)
file_data

	Unnamed: 0	one	two
0	0	1	4
1	1	2	5
2	2	3	6

③ read_table()函数

# read_table()与read_csv()的区别在于使用的分隔符不同，前者为‘\t’,后者为‘，’

读写excle文件

① 使用to_excle()方法写入excle文件

# 语法格式：
# to_excle(excle_writer,sheet_ame='Sheet1',na_rep='',float_format=None,columns=None,header=True,index=True,index_label=None,startrow=0,startcol=0,engine=None,merge_cells=True,encoding=None,inf_rep='inf',verbose=True,freeze_panes=None)
# excle_writer：文件读取路径
# sheet_name：工作表名称
# na_rep：表示缺失数据
# index：表示是否写入行索引，默认True

import numpy as np
import pandas as pd

df1 = pd.DataFrame({'col1':['数','据'],'col2':['分','析']})
df1.to_excel(r'D:\python数据分析资料\数据分析.xlsx','数据分析Pandas')

② 使用read_excel()函数读取Excel文件

# pandas.read_excel(io,sheet_name=0,header=0,names=None,index_col=None,usecols=None,squeeze=False,dtype=None,engine=None,converters=None,true_values=None,False_values=None,skiprows=None,nrows=None,ma_values=None,paarse_dates=False,data_parser=None,thousands=None,omment=None,skipfooter=0,convert_float=True,**kwds)
# io：接受字符串，表示路径对象
# sheet_name：指定要读取的工作表，可接受字符串或int类型，字符串表示工作表名称，int类型表示工作表索引
# header:用于解析列标签。如果传入一个整数列表，则表示这些行为会合并为一个MultiIndex对象
# index_col：用作行索引的列编号或者列名，如果给定一个序列，则表示有多个行索引

data = pd.read_excel(r'D:\python数据分析资料\数据分析.xlsx',engine='xlrd')
data

---------------------------------------------------------------------------

XLRDError                                 Traceback (most recent call last)

~\AppData\Local\Temp\ipykernel_14516\723589026.py in <module>
----> 1 data = pd.read_excel(r'D:\python数据分析资料\数据分析.xlsx',engine='xlrd')
      2 data


D:\anaconda\lib\site-packages\pandas\util\_decorators.py in wrapper(*args, **kwargs)
    309                     stacklevel=stacklevel,
    310                 )
--> 311             return func(*args, **kwargs)
    312 
    313         return wrapper


D:\anaconda\lib\site-packages\pandas\io\excel\_base.py in read_excel(io, sheet_name, header, names, index_col, usecols, squeeze, dtype, engine, converters, true_values, false_values, skiprows, nrows, na_values, keep_default_na, na_filter, verbose, parse_dates, date_parser, thousands, decimal, comment, skipfooter, convert_float, mangle_dupe_cols, storage_options)
    455     if not isinstance(io, ExcelFile):
    456         should_close = True
--> 457         io = ExcelFile(io, storage_options=storage_options, engine=engine)
    458     elif engine and engine != io.engine:
    459         raise ValueError(


D:\anaconda\lib\site-packages\pandas\io\excel\_base.py in __init__(self, path_or_buffer, engine, storage_options)
   1417         self.storage_options = storage_options
   1418 
-> 1419         self._reader = self._engines[engine](self._io, storage_options=storage_options)
   1420 
   1421     def __fspath__(self):


D:\anaconda\lib\site-packages\pandas\io\excel\_xlrd.py in __init__(self, filepath_or_buffer, storage_options)
     23         err_msg = "Install xlrd >= 1.0.0 for Excel support"
     24         import_optional_dependency("xlrd", extra=err_msg)
---> 25         super().__init__(filepath_or_buffer, storage_options=storage_options)
     26 
     27     @property


D:\anaconda\lib\site-packages\pandas\io\excel\_base.py in __init__(self, filepath_or_buffer, storage_options)
    516             self.handles.handle.seek(0)
    517             try:
--> 518                 self.book = self.load_workbook(self.handles.handle)
    519             except Exception:
    520                 self.close()


D:\anaconda\lib\site-packages\pandas\io\excel\_xlrd.py in load_workbook(self, filepath_or_buffer)
     36         if hasattr(filepath_or_buffer, "read"):
     37             data = filepath_or_buffer.read()
---> 38             return open_workbook(file_contents=data)
     39         else:
     40             return open_workbook(filepath_or_buffer)


D:\anaconda\lib\site-packages\xlrd\__init__.py in open_workbook(filename, logfile, verbosity, use_mmap, file_contents, encoding_override, formatting_info, on_demand, ragged_rows, ignore_workbook_corruption)
    170         raise XLRDError(FILE_FORMAT_DESCRIPTIONS[file_format]+'; not supported')
    171 
--> 172     bk = open_workbook_xls(
    173         filename=filename,
    174         logfile=logfile,


D:\anaconda\lib\site-packages\xlrd\book.py in open_workbook_xls(filename, logfile, verbosity, use_mmap, file_contents, encoding_override, formatting_info, on_demand, ragged_rows, ignore_workbook_corruption)
     77         t1 = perf_counter()
     78         bk.load_time_stage_1 = t1 - t0
---> 79         biff_version = bk.getbof(XL_WORKBOOK_GLOBALS)
     80         if not biff_version:
     81             raise XLRDError("Can't determine file's BIFF version")


D:\anaconda\lib\site-packages\xlrd\book.py in getbof(self, rqd_stream)
   1282             bof_error('Expected BOF record; met end of file')
   1283         if opcode not in bofcodes:
-> 1284             bof_error('Expected BOF record; found %r' % self.mem[savpos:savpos+8])
   1285         length = self.get2bytes()
   1286         if length == MY_EOF:


D:\anaconda\lib\site-packages\xlrd\book.py in bof_error(msg)
   1276 
   1277         def bof_error(msg):
-> 1278             raise XLRDError('Unsupported format, or corrupt file: ' + msg)
   1279         savpos = self._position
   1280         opcode = self.get2bytes()


XLRDError: Unsupported format, or corrupt file: Expected BOF record; found b'c\x14#e\x08\x00\xf8\x01'

读取HTML表格数据

# pandas.read_html(io,match='.+',flavor=None,header=None,index_col=None,skiprows=None,attrs=None,parse_dates=False,tupleize_cols=None,thousands=',',encoding=None,decimal='.',converters=None,na_values=None,keep_default_na=True,displayed_only=True)
# io：表示路径对象
# header：表示指定列标题所在的行
# index_col：表示指定的行标题所在的列
# attrs：用于表示表格的属性值

# 使用read_html()读取网页中的表格数据时，需要注意网页的编码格式

import pandas as pd
import requests
html_data=requests.get('https://www.runoob.com/html/html-tables.html')
html_table_data=pd.read_html(html_data.content,encoding='utf-8')
html_table_data[1]

	标签	描述
0	<table>	定义表格
1	<th>	定义表格的表头
2	<tr>	定义表格的行
3	<td>	定义表格单元
4	<caption>	定义表格标题
5	<colgroup>	定义表格列的组
6	<col>	定义用于表格列的属性
7	<thead>	定义表格的页眉
8	<tbody>	定义表格的主体
9	<tfoot>	定义表格的页脚

读写数据库

# 常用函数
# read_sql_table()：将读取整张数据表中的数据转换成DataFrame对象
# read_sql_query()：将SQL语句读取的结果转换成DataFrame对象
# read_sql()：上述两个语句的结合
# to_sql():将数据写入到SQL数据库中

注：连接Mysql数据库时，使用的是mysqlconnector驱动，如果当前环境中没有该模块，需使用pip install mysql-connector 命令安装该模块

① 使用read_sql()函数读取数据

# pandas.read_sql(sql,con,index_col=None,coerce_float=True,params=None,parse_dates=None,columns=None,chunksize=None)
# sql：表示被执行的SQL
# con：接收数据库连接，表示数据库的连接信息
# index_col：如果传入一个列表，则表示层次化索引
# coerce_float：将费字符串，非数字对象的值转换为浮点数类型
# params：传递给执行方法的参数列表，如params={'name':'value'}
# columns：接收list表示读取数据的列名，默认为None

from mysql import connector

---------------------------------------------------------------------------

ModuleNotFoundError                       Traceback (most recent call last)

~\AppData\Local\Temp\ipykernel_14516\3642983536.py in <module>
----> 1 from mysql import connector


ModuleNotFoundError: No module named 'mysql'

pip install mysql-connector

^C
Note: you may need to restart the kernel to use updated packages.

from sqlalchemy import create_engine

from mysql import connector

from mysql import connector

# 读取数据库步骤
# 导入sqlalchemy 模块，通过create_engine()函数创建连接数据库的信息，然后调用read_sql()函数读取数据库中的actor数据表，并转换成DataFrame对象
# create_engine()函数创建链接时，格式如下
# 数据库类型+数据库驱动名称://用户名：密码：@机器地址：端口号/数据库名

import pandas as pd
from sqlalchemy import create_engine
engine = create_engine('mysql+mysqlconnector://root:aa123456'
                       '@127.0.0.1:3306/sakila')
sql = 'SELECT * FROM actor WHERE actor_id<10;'
pd.read_sql(sql,engine)

	actor_id	first_name	last_name	last_update
0	1	PENELOPE	GUINESS	2006-02-15 04:34:33
1	2	NICK	WAHLBERG	2006-02-15 04:34:33
2	3	ED	CHASE	2006-02-15 04:34:33
3	4	JENNIFER	DAVIS	2006-02-15 04:34:33
4	5	JOHNNY	LOLLOBRIGIDA	2006-02-15 04:34:33
5	6	BETTE	NICHOLSON	2006-02-15 04:34:33
6	7	GRACE	MOSTEL	2006-02-15 04:34:33
7	8	MATTHEW	JOHANSSON	2006-02-15 04:34:33
8	9	JOE	SWANK	2006-02-15 04:34:33

② 使用to_sql()方法将数据写入到数据库中

# 语法格式：
# to_sql(name,con,schema=None,if_exists='fail',index=True,index_label=None,chunksize=None,dtype=None)
# name：数据库表的名称
# con：数据库的连接信息
# if_exists：可以取值为fail,replace,append
    # fail：如果表存在，则不执行写入操作
    # replace：如果表存在，则将源数据库表删除后在重新创建
    # append：如果表存在，name在原数据库表的基础上追加数据
# index：表示是否将DataFrame行索引作为数据传入数据库，默认True
# index_label：表示是否引用索引名称

create database students_info charset=utf-8

  File "C:\Users\lenovo\AppData\Local\Temp\ipykernel_11032\3890836627.py", line 1
    create database students_info charset=utf-8
           ^
SyntaxError: invalid syntax

import pandas as pd
from pandas import DataFrame,Series
from sqlalchemy.types import *
from sqlalchemy import create_engine
from mysql import connector
df = DataFrame({'班级':['一年级','二年级','三年级','四年级'],'男生人数':[25,23,27,30],'女生人数':[19,17,20,20]})
engine = create_engine('mysql+mysqlconnector://root:aa123456'
                       '@127.0.0.1:3306/data_analysis_test')
df.to_sql('students',engine)

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

~\AppData\Local\Temp\ipykernel_20440\1417353508.py in <module>
      7 engine = create_engine('mysql+mysqlconnector://root:aa123456'
      8                        '@127.0.0.1:3306/data_analysis_test')
----> 9 df.to_sql('students',engine)


D:\anaconda\lib\site-packages\pandas\core\generic.py in to_sql(self, name, con, schema, if_exists, index, index_label, chunksize, dtype, method)
   2949         from pandas.io import sql
   2950 
-> 2951         return sql.to_sql(
   2952             self,
   2953             name,


D:\anaconda\lib\site-packages\pandas\io\sql.py in to_sql(frame, name, con, schema, if_exists, index, index_label, chunksize, dtype, method, engine, **engine_kwargs)
    696         )
    697 
--> 698     return pandas_sql.to_sql(
    699         frame,
    700         name,


D:\anaconda\lib\site-packages\pandas\io\sql.py in to_sql(self, frame, name, if_exists, index, index_label, schema, chunksize, dtype, method, engine, **engine_kwargs)
   1730         sql_engine = get_engine(engine)
   1731 
-> 1732         table = self.prep_table(
   1733             frame=frame,
   1734             name=name,


D:\anaconda\lib\site-packages\pandas\io\sql.py in prep_table(self, frame, name, if_exists, index, index_label, schema, dtype)
   1629             dtype=dtype,
   1630         )
-> 1631         table.create()
   1632         return table
   1633 


D:\anaconda\lib\site-packages\pandas\io\sql.py in create(self)
    832         if self.exists():
    833             if self.if_exists == "fail":
--> 834                 raise ValueError(f"Table '{self.name}' already exists.")
    835             elif self.if_exists == "replace":
    836                 self.pd_sql.drop_table(self.name, self.schema)


ValueError: Table 'students' already exists.

# http://gaokao.xdf.cn/201805/10784342.html

案例

import pandas as pd
import requests
html_data = requests.get('https://gaokao.xdf.cn/201805/10784243.html')
html_table_data = pd.read_html(html_data.content,encoding='utf-8')
score = html_table_data[0].loc[:,0:4]
score

	0	1	2	3	4
0	年份	一本分数线	一本分数线	二本分数线	二本分数线
1	年份	文科	理科	文科	理科
2	2020	542	537	469	449
3	2019	542	507	481	432
4	2018	546	516	476	432
5	2017	518	481	452	400
6	2016	518	519	460	438
7	2015	513	515	462	442
8	2014	526	534	478	462
9	2013	507	493	459	440
10	2012	539	530	492	476
11	2011	543	570	496	520
12	2010	533	536	492	491
13	2009	548	547	507	505
14	2008	545	546	510	511
15	2007	580	572	553	439
16	2006	561	552	528	515

score.to_csv('D:\python数据分析资料\score.csv')
'写入完成'

'写入完成'

df_obj = pd.read_csv('D:\python数据分析资料\score.csv',header=[0,1,2])

df_obj

	Unnamed: 0_level_0	0	1	2	3	4
	0	年份	一本分数线	一本分数线	二本分数线	二本分数线
	1	年份	文科	理科	文科	理科
0	2	2020	542	537	469	449
1	3	2019	542	507	481	432
2	4	2018	546	516	476	432
3	5	2017	518	481	452	400
4	6	2016	518	519	460	438
5	7	2015	513	515	462	442
6	8	2014	526	534	478	462
7	9	2013	507	493	459	440
8	10	2012	539	530	492	476
9	11	2011	543	570	496	520
10	12	2010	533	536	492	491
11	13	2009	548	547	507	505
12	14	2008	545	546	510	511
13	15	2007	580	572	553	439
14	16	2006	561	552	528	515

import pandas as pd
from pandas import DataFrame,Series
from sqlalchemy.types import *
from sqlalchemy import create_engine
from mysql import connector
engine = create_engine('mysql+mysqlconnector://root:aa123456'
                       '@127.0.0.1:3306/data_analysis_test')
df_obj.to_sql('score',engine)
'写入完成'

'写入完成'

sorted_obj = pd.read_sql('score',engine)

sorted_obj.max()

index                               None
('Unnamed: 0_level_0', '0', '1')      16
('0', '年份', '年份')                   2020
('1', '一本分数线', '文科')                 580
('2', '一本分数线', '理科')                 572
('3', '二本分数线', '文科')                 553
('4', '二本分数线', '理科')                 520
dtype: object

sorted_obj.describe()

	('Unnamed: 0_level_0', '0', '1')	('0', '年份', '年份')	('1', '一本分数线', '文科')	('2', '一本分数线', '理科')	('3', '二本分数线', '文科')	('4', '二本分数线', '理科')
count	15.000000	15.000000	15.000000	15.000000	15.000000	15.000000
mean	9.000000	2013.000000	537.400000	530.333333	487.666667	463.466667
std	4.472136	4.472136	19.111702	25.819889	28.050125	37.061468
min	2.000000	2006.000000	507.000000	481.000000	452.000000	400.000000
25%	5.500000	2009.500000	522.000000	515.500000	465.500000	438.500000
50%	9.000000	2013.000000	542.000000	534.000000	481.000000	449.000000
75%	12.500000	2016.500000	545.500000	546.500000	501.500000	498.000000
max	16.000000	2020.000000	580.000000	572.000000	553.000000	520.000000

小透明z0

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Pandas

注：连接Mysql数据库时，使用的是mysqlconnector驱动，如果当前环境中没有该模块，需使用pip install mysql-connector 命令安装该模块。② 通过pd.read_csv()函数读取CSV文件的数据。② 使用read_excel()函数读取Excel文件。① 通过to_csv()方法将数据写入到CSV文件。① 使用to_excle()方法写入excle文件。② 使用to_sql()方法将数据写入到数据库中。① 使用read_sql()函数读取数据。
复制链接

扫一扫