深入理解pandas读取excel,txt,csv文件等命令_pandas read text

pandas读取文件官方提供的文档

在使用pandas读取文件之前，必备的内容，必然属于官方文档，官方文档查阅地址

http://pandas.pydata.org/pandas-docs/version/0.24/reference/io.html

文档操作属于pandas里面的Input/Output也就是IO操作，基本的API都在上述网址，接下来本文核心带你理解部分常用的命令

pandas读取txt文件

读取txt文件需要确定txt文件是否符合基本的格式，也就是是否存在\t,,,等特殊的分隔符

一般txt文件长成这个样子

txt文件举例

下面的文件为空格间隔

1 2019-03-22 00:06:24.4463094 中文测试 
2 2019-03-22 00:06:32.4565680 需要编辑encoding 
3 2019-03-22 00:06:32.6835965 ashshsh 
4 2017-03-22 00:06:32.8041945 eggg

读取命令采用 read_csv或者 read_table都可以

import pandas as pd
df =  pd.read_table("./test.txt")
print(df)

import pandas as pd
df =  pd.read_csv("./test.txt")
print(df)

但是，注意，这个地方读取出来的数据内容为3行1列的DataFrame类型，并没有按照我们的要求得到3行4列

import pandas as pd
df =  pd.read_csv("./test.txt")
print(type(df))
print(df.shape)

<class 'pandas.core.frame.DataFrame'>
(3, 1)

read_csv函数

默认: 从文件、URL、文件新对象中加载带有分隔符的数据，默认分隔符是逗号。

上述txt文档并没有逗号分隔，所以在读取的时候需要增加sep分隔符参数

df =  pd.read_csv("./test.txt",sep=' ')

参数说明，官方Source : https://github.com/pandas-dev/pandas/blob/v0.24.0/pandas/io/parsers.py#L531-L697

中文说明以及重点功能案例

 

该表格部分参考 博客 https://www.cnblogs.com/datablog/p/6127000.html 感谢博主的翻译，O(∩_∩)O哈哈~

案例1

index_col 使用

首先准备一个txt文件，这个文件最大的问题是在每行的末尾多了一个',' ，按照提示解释为，如果每行末尾都有分隔符，会出现问题，但是在实际测试的时候发现需要配合names参数，才可以出现效果

goof,1,2,3,ddd,
u,1,3,4,asd,
as,df,12,33,

该表格部分参考 博客 https://www.cnblogs.com/datablog/p/6127000.html 感谢博主的翻译，O(∩_∩)O哈哈~

案例1

index_col 使用

首先准备一个txt文件，这个文件最大的问题是在每行的末尾多了一个',' ，按照提示解释为，如果每行末尾都有分隔符，会出现问题，但是在实际测试的时候发现需要配合names参数，才可以出现效果

goof,1,2,3,ddd,
u,1,3,4,asd,
as,df,12,33,

编写如下代码

df =  pd.read_csv("./demo.txt",header=None,names=['a','b','c','d','e'])
print(df)

df =  pd.read_csv("./demo.txt",header=None,index_col=False,names=['a','b','c','d','e'])
print(df)

其实发现意义还真不是很大，可能文档并没有表述清楚他的具体作用。接下来说一下index_col的常见用途

在读取文件的时候，如果不设置index_col列索引，默认会使用从0开始的整数索引。当对表格的某一行或列进行操作之后，在保存成文件的时候你会发现总是会多一列从0开始的列，如果设置index_col参数来设置列索引，就不会出现这种问题了。

案例2

converters 设置指定列的处理函数，可以用"序号"也可以使用“列名”进行列的指定

import pandas as pd

def fun(x):
    return str(x)+"-haha"

df =  pd.read_csv("./test.txt",sep=' ',header=None,index_col=0,converters={3:fun})
print(type(df))
print(df.shape)
print(df)

read_csv函数过程中常见的问题

1. 有的IDE中利用Pandas的read_csv函数导入数据文件时，若文件路径或文件名包含中文，会报错。

解决办法

import pandas as pd
#df=pd.read_csv('F:/测试文件夹/测试数据.txt')
f=open('F:/测试文件夹/测试数据.txt')
df=pd.read_csv(f)

1. 排除某些行 使用 参数 skiprows.它的功能为排除某一行。 要注意的是：排除前3行是skiprows=3 排除第3行是skiprows=3
2. 对于不规则分隔符，使用正则表达式读取文件 文件中的分隔符采用的是空格，那么我们只需要设置sep=" "来读取文件就可以了。当分隔符并不是单个的空格，也许有的是一个空格有的是多个空格时，如果这个时候还是采用sep=" "来读取文件，也许你就会得到一个很奇怪的数据，因为它会将空格也做为数据。 data = pd.read_csv("data.txt",sep="\s+")
3. 读取的文件中如果出现中文编码错误 需要设定 encoding 参数
4. 为行和列添加索引 用参数names添加列索引，用index_col添加行索引

read_csv该命令有相当数量的参数。大多数都是不必要的，因为你下载的大部分文件都有标准格式。

read_table函数

基本用法是一致的，区别在于separator分隔符。

csv是逗号分隔值，仅能正确读入以 “,” 分割的数据，read_table默认是'\t'(也就是tab)切割数据集的

read_fwf 函数

读取具有固定宽度列的文件，例如文件

id8141    360.242940   149.910199   11950.7
id1594    444.953632   166.985655   11788.4
id1849    364.136849   183.628767   11806.2
id1230    413.836124   184.375703   11916.8
id1948    502.953953   173.237159   12468.3

read_fwf 命令有2个额外的参数可以设置

colspecs ：

需要给一个元组列表，元组列表为半开区间，[from,to) ,默认情况下它会从前100行数据进行推断。

例子：

import pandas as pd
colspecs = [(0, 6), (8, 20), (21, 33), (34, 43)]
df = pd.read_fwf('demo.txt', colspecs=colspecs, header=None, index_col=0)

widths：

直接用一个宽度列表，可以代替colspecs参数

widths = [6, 14, 13, 10]
df = pd.read_fwf('demo.txt', widths=widths, header=None)

read_fwf 使用并不是很频繁，可以参照 http://pandas.pydata.org/pandas-docs/stable/user_guide/io.html#files-with-fixed-width-columns 学习

read_msgpack 函数

pandas支持的一种新的可序列化的数据格式，这是一种轻量级的可移植二进制格式，类似于二进制JSON，这种数据空间利用率高，在写入（序列化）和读取（反序列化）方面都提供了良好的性能。

read_clipboard 函数

读取剪贴板中的数据，可以看作read_table的剪贴板版本。在将网页转换为表格时很有用

这个地方出现如下的BUG

module 'pandas' has no attribute 'compat'

我更新了一下pandas 既可以正常使用了

还有一个比较坑的地方，就是在读取剪切板的时候，如果复制了中文，很容易读取不到数据

解决办法

1. 打开site-packages\pandas\io\clipboard.py 这个文件需要自行检索
2. 在 text = clipboard_get() 后面一行 加入这句： text = text.decode('UTF-8')
3. 保存，然后就可以使用了

read_excel 函数

依旧是官方文档一码当先：http://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_excel.html#pandas.read_excel

pandas 读取excel文件如果报错，一般处理为

错误为：ImportError: No module named 'xlrd'

pandas读取excel文件，需要单独的xlrd模块支持 pip install xlrd 即可

read_json 函数

如果JSON不可解析，解析器将产生ValueError/TypeError/AssertionError之一。

案例1

1. orient='split'

    import pandas as pd
    s = '{"index":[1,2,3],"columns":["a","b"],"data":[[1,3],[2,5],[6,9]]}'
    df = pd.read_json(s,orient='split')

1. orient='records' 成员为字典列表

import pandas as pd
s = '[{"a":1,"b":2},{"a":3,"b":4}]'
df = pd.read_json(s,orient='records')

1. orient='index' 以索引为key,以列字段构成的字典为键值。如： s = '{"0":{"a":1,"b":2},"1":{"a":2,"b":4}}'
2. orient='columns' 或者 values 自己推断即可

部分中文翻译，可以参考github> https://github.com/apachecn/pandas-doc-zh

read_json()常见BUG

读取json文件出现 ValueError: Trailing data ，JSON格式问题

原格式为

{"a":1,"b":1},{"a":2,"b":2}

调整为

[{"a":1,"b":1},{"a":2,"b":2}]

或者使用lines参数,并且JSON调整为每行一条数据

{"a":1,"b":1}
{"a":2,"b":2}

若JSON文件中有中文，建议加上encoding参数，赋值'utf-8'，否则会报错

read_html 函数

使用方法，在网页中右键如果发现表格 也就是 table 即可使用

例如： http://data.stcn.com/2019/0304/14899644.shtml

<table class="..." id="...">
    <thead>
    <tr>
    <th>...</th>
    </tr>
    </thead>
    <tbody>
        <tr>
            <td>...</td>
        </tr>
        <tr>...</tr>
    </tbody>
</table>


<table> : 定义表格
<thead> : 定义表格的页眉
<tbody> : 定义表格的主体
<tr>    : 定义表格的行
<th>    : 定义表格的表头
<td>    : 定义表格单元

常见BUG

出现如下报错 ImportError: html5lib not found, please install it

安装html5lib即可，或者使用参数

import pandas as pd
df = pd.read_html("http://data.stcn.com/2019/0304/14899644.shtml",flavor ='lxml')

更多参考源码，可以参考 > http://pandas.pydata.org/pandas-docs/stable/user_guide/io.html

pandas 的读写函数简表

 

import pandas as pd
 2 
 3 csvframe = pd.read_csv('pandas_data_test\myCSV_01.csv')
 4 print(csvframe, "\n-----*-----")
 5 csvframe1 = pd.read_table('pandas_data_test\myCSV_01.csv',sep=',')
 6 print(csvframe1, "\n-----*-----")
 7 csvframe2 = pd.read_csv('pandas_data_test\myCSV_02.csv',header=None) # 设置header为无，就不会用数据充当表头，此时添加默认表头
 8 print(csvframe2, "\n-----*-----")
 9 csvframe20 = pd.read_csv('pandas_data_test\myCSV_02.csv',names=['white','red','blue','green','animal']) # 指定表头
10 print(csvframe20, "\n-----*-----")
11 
12 csvframe30 = pd.read_csv('pandas_data_test\myCSV_03.csv')
13 print(csvframe30, "\n-----*-----")
14 csvframe31 = pd.read_csv('pandas_data_test\myCSV_03.csv',index_col=['color','status']) #等级索引
15 print(csvframe31, "\n-----*-----")
16 
17 txtframe4 = pd.read_table('pandas_data_test\ch05_04.txt',sep='\s+') # 根据正则解析
18 print(txtframe4, "\n-----*-----")
19 txtframe5 = pd.read_table('pandas_data_test\ch05_05.txt',sep=r'\D+',header=None,engine='python')
20 print(txtframe5, "\n-----*-----")
21 # 使用skiprows选项，可以排除多余的行。把要排除的行的行号放到数组中，赋给该选项即可。
22 txtframe6 = pd.read_table('pandas_data_test\ch05_06.txt',sep=',',skiprows=[0,1,3,6])
23 print(txtframe6)
24 Out[1]:
25    white  red  blue  green animal
26 0      1    5     2      3    cat
27 1      2    7     8      5    dog
28 2      3    3     6      7  horse
29 3      2    2     8      3   duck
30 4      4    4     2      1  mouse
31 5      4    4     2      1    mou 
32 -----*-----
33    white  red  blue  green animal
34 0      1    5     2      3    cat
35 1      2    7     8      5    dog
36 2      3    3     6      7  horse
37 3      2    2     8      3   duck
38 4      4    4     2      1  mouse
39 5      4    4     2      1    mou 
40 -----*-----
41    0  1  2  3      4
42 0  1  5  2  3    cat
43 1  2  7  8  5    dog
44 2  3  3  6  7  horse
45 3  2  2  8  3   duck
46 4  4  4  2  1  mouse 
47 -----*-----
48    white  red  blue  green animal
49 0      1    5     2      3    cat
50 1      2    7     8      5    dog
51 2      3    3     6      7  horse
52 3      2    2     8      3   duck
53 4      4    4     2      1  mouse 
54 -----*-----
55    color status  iteml  item2  item3
56 0  black     up      3      4      6
57 1  black   down      2      6      7
58 2  white     up      5      5      5
59 3  white   down      3      3      2
60 4  white   left      1      2      1
61 5    red     up      2      2      2
62 6    red   down      1      1      4 
63 -----*-----
64               iteml  item2  item3
65 color status                     
66 black up          3      4      6
67       down        2      6      7
68 white up          5      5      5
69       down        3      3      2
70       left        1      2      1
71 red   up          2      2      2
72       down        1      1      4 
73 -----*-----
74    white  red  blue  green
75 0      1    5     2      3
76 1      2    7     8      5
77 2      3    3     6      7 
78 -----*-----
79    0    1    2
80 0  0  123  122
81 1  1  124  321
82 2  2  125  333 
83 -----*-----
84    white  red  blue  green animal
85 0      1    5     2      3   cat 
86 1      2    7     8      5    dog
87 2      3    3     6      7  horse
88 3      2    2     8      3  duck 
89 4      4    4     2      1  mouse

 

从TXT文件读取部分数据

 1 print(csvframe2, "\n-----*-----")
 2 # nrows=2指定要获取的行数，skiprows=[2]删除对应行
 3 csvfram20 = pd.read_csv('pandas_data_test\myCSV_02.csv',skiprows=[2],nrows=2,header=None)
 4 print(csvfram20)
 5 Out[2]:
 6    0  1  2  3      4
 7 0  1  5  2  3    cat
 8 1  2  7  8  5    dog
 9 2  3  3  6  7  horse
10 3  2  2  8  3   duck
11 4  4  4  2  1  mouse 
12 -----*-----
13    0  1  2  3    4
14 0  1  5  2  3  cat
15 1  2  7  8  5  dog

　　另外一项既有趣又很常用的操作是切分想要解析的文本，然后遍历各个部分，逐一对其执行 某一特定操作。

　　例如，对于一列数字，每隔两行取一个累加起来，最后把和插人到Series对象中„这个小例 子理解起来很简单，

　　　　也没有实际应用价值，但是一旦领会了其原理，你就能将其用到更加复杂的情况。

 1 csvframe1 = pd.read_table('pandas_data_test\myCSV_01.csv',sep=',')
 2 print(csvframe1, "\n-----*-----")
 3 out = pd.Series()
 4 pieces = pd.read_csv('pandas_data_test\myCSV_01.csv',chunksize=4)  # chunksize参数决定了每部分分割的行数
 5 i = 0
 6 for piece in pieces:
 7     print(piece['white'])
 8     out.at[i] = piece['white'].sum()
 9     i += 1
10 print(out, "\n-----*-----")
11 Out[3]:
12    white  red  blue  green animal
13 0      1    5     2      3    cat
14 1      2    7     8      5    dog
15 2      3    3     6      7  horse
16 3      2    2     8      3   duck
17 4      4    4     2      1  mouse
18 5      4    4     2      1    mou 
19 -----*-----
20 0    1
21 1    2
22 2    3
23 3    2
24 Name: white, dtype: int64
25 4    4
26 5    4
27 Name: white, dtype: int64
28 0    8
29 1    8
30 dtype: int64 

 

往CSV文件写入数据

 1 print(csvframe1)
 2 print(csvframe1.to_csv('pandas_data_test\ch05_07.csv'))
 3 # 使用index和 header选项，把它们的值设置为False,可取消默认写入index和header
 4 print(csvframe1.to_csv('pandas_data_test\ch05_07b.csv',index =False,header=False))
 5 print(csvframe30.to_csv('pandas_data_test\ch05_08.csv'))
 6 # 可以用to_csv()函数的na_rep选项把空字段替换为你需要的值。常用值有NULL、0和NaN
 7 print(csvframe30.to_csv('pandas_data_test\ch05_09.csv',na_rep="空"))
 8 Out[4]:
 9    white  red  blue  green animal
10 0      1    5     2      3    cat
11 1      2    7     8      5    dog
12 2      3    3     6      7  horse
13 3      2    2     8      3   duck
14 4      4    4     2      1  mouse
15 5      4    4     2      1    mou
16 None
17 None
18 None
19 None

　　进入文件夹我们可以看到相应的文件：

　　　

读写HTML文件

 1 frame = pd.DataFrame(np.arange(4).reshape(2,2))
 2 print(frame.to_html())
 3 frame2 = pd.DataFrame( np.random.random((4,4)),index = ['white','black','red','blue1'],columns = ['up','down','right','left'])
 4 s = ['<HTML>']
 5 s.append('<HEAD><TITLE>My DataFrame</TITLE></HEAD>')
 6 s.append(' <B0DY>')
 7 s.append(frame.to_html())
 8 s.append('</BODY></HTML>')
 9 html = ''.join(s)
10 html_file = open('pandas_data_test\myFrame.html','w')
11 html_file.write(html)
12 html_file.close()
13 web_frames = pd.read_html('pandas_data_test\myFrame.html')
14 print(web_frames[0])
15 ranking = pd.read_html('http://www.meccanismocomplesso.org/en/ eccanismo-complesso-sito-2/classifica-punteggio/')
16 print(ranking[0][1:10]) # 输出网页内容的前10行
17 Out[5]:
18 <table border="1" class="dataframe">
19   <thead>
20     <tr style="text-align: right;">
21       <th></th>
22       <th>0</th>
23       <th>1</th>
24     </tr>
25   </thead>
26   <tbody>
27     <tr>
28       <th>0</th>
29       <td>0</td>
30       <td>1</td>
31     </tr>
32     <tr>
33       <th>1</th>
34       <td>2</td>
35       <td>3</td>
36     </tr>
37   </tbody>
38 </table>
39    Unnamed: 0  0  1
40 0           0  0  1
41 1           1  2  3
42     #             Nome   Exp  Livelli
43 1   2            admin  9029      NaN
44 2   3      BrunoOrsini  2124      NaN
45 3   4        Berserker   700      NaN
46 4   5         Dnocioni   543      NaN
47 5   6  albertosallusti   409      NaN
48 6   7              Jon   233      NaN
49 7   8             Mr.Y   180      NaN
50 8   9  michele sisinni   157      NaN
51 9  10           Selina   136      NaN

 

从XML读取数据

　　pandas的所有I/O API函数中，没有专门用来处理XML(可扩展标记语言）格式的。虽然没有， 但这种格式其实

　　　　很重要，因为很多结构化数据都是以XML格式存储的。pandas没有专门的处理函 数也没关系，因为Python

　　　　有很多读写XML格式数据的库（除了pandas)。其中一个库叫作lxml,它在大文件处理方面性能优异，因而从

　　　　众多同类库之中脱颖而出。这 一节将介绍如何用它处理XML文件，以及如何把它和pandas整合起来，以最

　　　　终从XML文件中获 取到所需数据并将其转换为DataFrame对象。

　　XML源文件如下图所示

　　

 1 from lxml import objectify
 2 
 3 xml = objectify.parse('pandas_data_test\\books.xml')
 4 root = xml.getroot()  # 获取根节点
 5 print(root.Book.Author)
 6 mes1 = root.Book.getchildren()
 7 print("root.Book.getchildren()获取的子标签内容：\n", mes1)
 8 mes2 = root.Book[1].getchildren()  # 取第二个Book标签
 9 print([child.tag for child in mes2])  # 获取子标签
10 print([child.text for child in mes2])  # 获取的子标签内容
11 Out[6]:
12 272103_l_EnRoss, Mark
13 root.Book.getchildren()获取的子标签内容：
14  [' 272103_l_EnRoss, Mark', 'XML Cookbook', 'Computer', 23.56, '2014-22-0l']
15 ['Author', 'Title', 'Genre', 'Price', 'PublishDate']
16 [' 272l03_l_EnBracket, Barbara', 'XML for Dummies', 'Computer', '35.95', '20l4-l2-l6']

 

读写 Microsoft Excel文件

　　read_excel()、to_excel()，能够读取.xls和.xlsx两种类型的文件。

读写JSON数据
 　　read_json()、to_json()
 
HDF5格式
　　至此，已学习了文本格式的读写。若要分析大量数据，最好使用二进制格式。Python有多 种二进制数据处理

　　　　工具。HDF5库在这个方面取得了一定的成功。HDF代表等级数据格式（hierarchical data format )。HDF5

　　　　库关注的是HDF5文件的读写，这种文件的数据结构由节点组成，能够存储大量数据集。该库全部用c语言

　　　　开发，提供了python/matlab和Java语言接口。它的迅速扩展得益于开发人 员的广泛使用，还得益于它的效

　　　　率，尤其是使用这种格式存储大量数据，其效率很高。比起其他处理起二进制数据更为简单的格式，HDF5

　　　　支持实时压缩，因而能够利用数据结构中的重复模式压缩文件。目前，Python提供两种操纵HDF5格式数据

　　　　的方法：PyTables和h5py。这两种方法有几点不同，选用哪一种很大程度上取决于具体需求。

　　h5py为HDF5的高级API提供接口。PyTables封装了很多HDF5细节，提供更加灵活的数据容器、索引表、搜索

　　　　功能和其他计算相关的介质。pandas还有一个叫作HDFStore、类似于diet的类，它用PyTables存储pandas

　　　　对象。使用HDF5格式之前，必须导人HDFStore类。

 1 from pandas.io.pytables import HDFStore
 2 # 注意这里需要tables这个包，没有请自行安装
 3 frame = pd.DataFrame(np.arange(16).reshape(4,4),index=['white','black1','red','blue'],columns=['up','down','right','left'])
 4 store = HDFStore('pandas_data_test\mydata.h5')
 5 store['obj1'] = frame
 6 frame1 = pd.DataFrame(np.random.rand(16).reshape(4,4),index=['white','black1','red','blue'],columns=['up','down','right','left'])
 7 store['obj2'] = frame1
 8 print(store['obj1'])
 9 print(store['obj2'])
10 Out[7]:
11         up  down  right  left
12 white    0     1      2     3
13 black1   4     5      6     7
14 red      8     9     10    11
15 blue    12    13     14    15
16               up      down     right      left
17 white   0.251269  0.422823  0.619294  0.273534
18 black1  0.593960  0.353969  0.966026  0.104581
19 red     0.964577  0.625644  0.342923  0.638627
20 blue    0.246541  0.997952  0.414599  0.908750
21 Closing remaining open files:pandas_data_test\mydata.h5...done

 

实现对象序列化

　　pickle模块实现了一个强大的算法，能够对用Python实现的数据结构进行序列化（pickling) 和反序列化操作。

　　序列化是指把对象的层级结构转换为字节流的过程。序列化便于对象的传输、存储和重建，仅用接收器就能重

　　建对象，还能保留它的所有原始特征。

　　用pandas库实现对象序列化（反序列化）很方便，所有工具都是现成的，无需在Python会话中导入cPickle模

　　块，所有的操作都是隐式进行的。 pandas的序列化格式并不是完全使用ASCII编码。

 1 import pickle
 2 data = { 'color': ['white','red'], 'value': [5, 7]}
 3 pickled_data = pickle.dumps(data)
 4 print(pickled_data)
 5 nframe = pickle.loads(pickled_data)
 6 print(nframe)
 7 
 8 # 用pandas序列化
 9 frame = pd.DataFrame(np.arange(16).reshape(4,4), index = ['up','down','left','right'])
10 frame.to_pickle('pandas_data_test\\frame.pkl')  # 同json数据类似
11 print(pd.read_pickle('pandas_data_test\\frame.pkl'))  # 反序列化，读取数据
12 Out[8]:
13 b'\x80\x03}q\x00(X\x05\x00\x00\x00colorq\x01]q\x02(X\x05\x00\x00\x00whiteq\x03X\x03\x00\x00\x00redq\x04eX\x05\x00\x00\x00valueq\x05]q\x06(K\x05K\x07eu.'
14 {'color': ['white', 'red'], 'value': [5, 7]}
15         0   1   2   3
16 up      0   1   2   3
17 down    4   5   6   7
18 left    8   9  10  11
19 right  12  13  14  15

 

 

对接数据库
 　  在很多应用中，所使用的数据来自于文本文件的很少，因为文本文件不是存储数据最有效的方式。

　　数据往往存储于SQL类关系型数据库，作为补充，NoSQL数据库近来也已流行开来。

　　从SQL数据库加载数据，将其转换为DataFrame对象很简单pandas提供的几个函数简化了该过程。

　　pandas.io.sql模块提供独立于数据库、叫作sqlalchemy的统一接口。该接口简化了连接模式， 不管对于

什么类型的数据库，操作命令都只有一套。连接数据库使用create_engine()函数，你可以用它配置驱动器所

需的用户名、密码、端口和数据库实例等所有属性。 数据库URL的典型形式是：

　　　　　　　　　　　　　　　　dialect+driver://username:password@host:port/database

 

名称的标识名称，例如sqlite，mysql，postgresql，oracle，或mssql。drivername是用于使用全小写字母连接

到数据库的DBAPI的名称。如果未指定，则将导入“默认”DBAPI（如果可用） - 此默认值通常是该后端可用的

最广泛的驱动程序。

 1 from sqlalchemy import create_engine
 2 
 3 # PostgreSQL数据库
 4 # default
 5 engine = create_engine('postgresql://scott:tiger@localhost/mydatabase')
 6 # pg8000 驱动器
 7 engine = create_engine('postgresql+pg8000://scott:tiger@localhost/mydatabase')
 8 # psycopg2 驱动器
 9 engine = create_engine('postgresql+psycopg2://scott:tiger@localhost/mydatabase')
10 # MySql
11 # default
12 engine = create_engine('mysql://scott:tiger@localhost/foo')
13 
14 # mysql-python 注意驱动器后面的对应关系
15 engine = create_engine('mysql+mysqldb://scott:tiger@localhost/foo')
16 
17 # MySQL-connector-python
18 engine = create_engine('mysql+mysqlconnector://scott:tiger@localhost/foo')
19 # OurSQL
20 engine = create_engine('mysql+oursql://scott:tiger@localhost/foo')
21 # Oracle
22 engine = create_engine('oracle://scott:tiger@127.0.0.1:1521/sidname')
23 
24 engine = create_engine('oracle+cx_oracle://scott:tiger@tnsname')
25 # Microsoft SQL
26 # pyodbc
27 engine = create_engine('mssql+pyodbc://scott:tiger@mydsn')
28 
29 # pymssql
30 engine = create_engine('mssql+pymssql://scott:tiger@hostname:port/dbname')

　　SQLite：

　　　　由于SQLite连接到本地文件，因此URL格式略有不同。URL的“文件”部分是数据库的文件名。

　　　　对于相对文件路径，这需要三个斜杠：engine = create_engine('sqlite:///foo.db')

 　　　  对于绝对文件路径，三个斜杠后面是绝对路径：

　　　　　   Unix/Mac - 4 initial slashes in total

　　　　　　engine = create_engine('sqlite:absolute/path/to/foo.db')

　　　　　　Windows

　　　　　　engine = create_engine('sqlite:///C:\path\to\foo.db')

　　　　　　Windows alternative using raw string

　　　　　　engine = create_engine(r'sqlite:///C:\path\to\foo.db')

 

　　SQLite3数据读写
　　　　学习使用Python内置的SQLite数据库sqlite3。SQLite3工具实现了简单、 轻量级的DBMS SQL,

　　因此可以内置于用Python语言实现的任何应用。它很实用，你可以在单个文件中创建一个嵌入式数据库。

 

　　　　若想使用数据库的所有功能而又不想安装真正的数据库，这个工具就是最佳选择。若想在使用真正

　　的数据库之前练习数据库操作，或在单一程序中使用数据库存储数据而无需考虑接口， SQLite3都是不

　　错的选择。

 1 from sqlalchemy import create_engine
 2 frame = pd.DataFrame( np.arange(20).reshape(4,5),columns=['white','red','blue','black','green'])
 3 # 连接SQLite3数据库
 4 engine = create_engine('sqlite:///pandas_data_test/foo.db')
 5 # 把DataFrame转换为数据库表。
 6 # to_sql(self, name, con, schema=None, if_exists='fail', index=True,
 7 #                index_label=None, chunksize=None, dtype=None)
 8 frame.to_sql('colors',engine)
 9 
10 # 读取
11 print(pd.read_sql('colors',engine))

 

　　运行结果：