【Python基础】10、MySQLdb

发布时间：2019-06-28 17:46:47编辑：auto阅读（1368）

一、MySQLdb模块

        python访问mariadb|mysql依赖于第三方模块MySQLdb，在pypi上下载下来

路径：https://pypi.python.org/pypi/MySQL-python/

 MySQL-python依赖于easy_install那先安装setuptools，这里省略

[root@Node3 ~]# unzip MySQL-python-1.2.5.zip

[root@Node3 ~]# cd MySQL-python-1.2.5
[root@Node3 MySQL-python-1.2.5]# ls
doc      MANIFEST.in   _mysql_exceptions.py   README.md        setup.py
GPL-2.0  metadata.cfg  MySQL_python.egg-info  setup.cfg        setup_windows.py
HISTORY  _mysql.c      PKG-INFO               setup_common.py  site.cfg
INSTALL  MySQLdb       pymemcompat.h          setup_posix.py   tests

[root@Node3 MySQL-python-1.2.5]# python2.7 setup.py install
sh: mysql_config: command not found                            #没找到这个命令
Traceback (most recent call last):
  File "setup.py", line 17, in <module>
    metadata, options = get_config()
  File "/root/MySQL-python-1.2.5/setup_posix.py", line 43, in get_config
    libs = mysql_config("libs_r")
  File "/root/MySQL-python-1.2.5/setup_posix.py", line 25, in mysql_config
    raise EnvironmentError("%s not found" % (mysql_config.path,))
EnvironmentError: mysql_config not found

[root@Node3 MySQL-python-1.2.5]# yum install mysql

[root@Node3 MySQL-python-1.2.5]# rpm -ql mysql
/usr/bin/msql2mysql
/usr/bin/my_print_defaults
/usr/bin/mysql
/usr/bin/mysql_config                   #在这里
/usr/bin/mysql_find_rows
/usr/bin/mysql_waitpid
/usr/bin/mysqlaccess
/usr/bin/mysqladmin
/usr/bin/mysqlbinlog
/usr/bin/mysqlcheck
/usr/bin/mysqldump
/usr/bin/mysqlimport
/usr/bin/mysqlshow
/usr/bin/mysqlslap
/usr/lib64/mysql/mysql_config
/usr/lib64/mysql/mysqlbug
/usr/share/doc/mysql-5.1.73

[root@Node3 MySQL-python-1.2.5]# python2.7 setup.py install

_mysql.c: In function ‘_mysql_ConnectionObject_getattr’:
_mysql.c:2666: error: ‘_mysql_ConnectionObject’ has no member named ‘open’
error: command 'gcc' failed with exit status 1    #又遇到报错，google后是需要mysql-devel


[root@Node3 MySQL-python-1.2.5]# yum install mysql-devel

[root@Node3 MySQL-python-1.2.5]# python2.7 setup.py install

Adding MySQL-python 1.2.5 to easy-install.pth file

Installed /usr/local/python27/lib/python2.7/site-packages/MySQL_python-1.2.5-py2.7-linux-x86_64.egg
Processing dependencies for MySQL-python==1.2.5
Finished processing dependencies for MySQL-python==1.2.5      #安装成功

导入MySQLdb模块：

In [4]: import MySQLdb

In [5]: import MySQLdb.                #有众多方法和属性
MySQLdb.BINARY              MySQLdb.NULL                MySQLdb.connect
MySQLdb.Binary              MySQLdb.NUMBER              MySQLdb.connections
MySQLdb.Connect             MySQLdb.NotSupportedError   MySQLdb.constants
MySQLdb.Connection          MySQLdb.OperationalError    MySQLdb.converters
MySQLdb.DATE                MySQLdb.ProgrammingError    MySQLdb.cursors
MySQLdb.DBAPISet            MySQLdb.ROWID               MySQLdb.debug
MySQLdb.DataError           MySQLdb.STRING              MySQLdb.escape
MySQLdb.DatabaseError       MySQLdb.TIME                MySQLdb.escape_dict
MySQLdb.Date                MySQLdb.TIMESTAMP           MySQLdb.escape_sequence
MySQLdb.DateFromTicks       MySQLdb.Time                MySQLdb.escape_string
MySQLdb.Error               MySQLdb.TimeFromTicks       MySQLdb.get_client_info
MySQLdb.FIELD_TYPE          MySQLdb.Timestamp           MySQLdb.paramstyle
MySQLdb.IntegrityError      MySQLdb.TimestampFromTicks  MySQLdb.release
MySQLdb.InterfaceError      MySQLdb.Warning             MySQLdb.string_literal
MySQLdb.InternalError       MySQLdb._mysql              MySQLdb.threadsafety
MySQLdb.MySQLError          MySQLdb._mysql_exceptions   MySQLdb.times
MySQLdb.MySQLdb             MySQLdb.apilevel            MySQLdb.version_info


In [11]: help(MySQLdb)


Help on package MySQLdb:

NAME
    MySQLdb - MySQLdb - A DB API v2.0 compatible interface to MySQL.

FILE
    /usr/local/python27/lib/python2.7/site-packages/MySQL_python-1.2.5-py2.7-linux-x86_64.egg/MySQLdb/__init__.py

DESCRIPTION
    This package is a wrapper around _mysql, which mostly implements the
    MySQL C API.
    
    connect() -- connects to server
    
    See the C API specification and the MySQL documentation for more info
    on other items.
    
    For information on how MySQLdb handles type conversion, see the
    MySQLdb.converters module.

PACKAGE CONTENTS             #包内容|子模块
    connections              #连接mysql
    constants (package)      #
    converters               #将Python中的字符串转化成mysql可以处理的数据类型
    cursors                  #游标
    release
    times
    
    
In [24]: help(MySQLdb.connection)


Help on class connection in module _mysql:

class connection(__builtin__.object)
 |  Returns a MYSQL connection object. Exclusive use of
 |  keyword parameters strongly recommended. Consult the
 |  MySQL C API documentation for more details.
 |  
 |  host
 |    string, host to connect
 |  
 |  user
 |    string, user to connect as
 |  
 |  passwd
 |    string, password to use
 |  
 |  db
 |    string, database to use
 |  
 |  port
 |    integer, TCP/IP port to connect to
 |  
 |  unix_socket
 |    string, location of unix_socket (UNIX-ish only)
 |  
 |  conv
 |    mapping, maps MySQL FIELD_TYPE.* to Python functions which
 |    convert a string to the appropriate Python type
 |  
 |  connect_timeout
 |    number of seconds to wait before the connection
 |    attempt fails.
 |  
 |  compress
 |    if set, gzip compression is enabled

示例：

In [2]: import MySQLdb

In [7]: conn=MySQLdb.connect(host='127.0.0.1',user='root')   #创建连接使用conncet

In [10]: conn.
conn.DataError               conn.close                   conn.get_host_info           conn.set_character_set
conn.DatabaseError           conn.commit                  conn.get_proto_info          conn.set_server_option
conn.Error                   conn.converter               conn.get_server_info         conn.set_sql_mode
conn.IntegrityError          conn.cursor                  conn.info                    conn.show_warnings
conn.InterfaceError          conn.cursorclass             conn.insert_id               conn.shutdown
conn.InternalError           conn.default_cursor          conn.kill                    conn.sqlstate
conn.NotSupportedError       conn.dump_debug_info         conn.literal                 conn.stat
conn.OperationalError        conn.encoders                conn.messages                conn.store_result
conn.ProgrammingError        conn.errno                   conn.next_result             conn.string_decoder
conn.Warning                 conn.error                   conn.open                    conn.string_literal
conn.affected_rows           conn.errorhandler            conn.ping                    conn.thread_id
conn.autocommit              conn.escape                  conn.port                    conn.unicode_literal
conn.begin                   conn.escape_string           conn.query                   conn.use_result
conn.change_user             conn.field_count             conn.rollback                conn.warning_count
conn.character_set_name      conn.get_autocommit          conn.select_db               
conn.client_flag             conn.get_character_set_info  conn.server_capabilities   

In [14]: conn.stat
Out[14]: <function stat>

In [15]: conn.stat()
Out[15]: 'Uptime: 719  Threads: 1  Questions: 6  Slow queries: 0  Opens: 15  Flush tables: 1  Open tables: 8  Queries per second avg: 0.8'

 

In [4]: s1=conn.cursor()                #创建游标   

In [5]: s1.
s1.DataError          s1.arraysize          s1.fetchone
s1.DatabaseError      s1.callproc           s1.lastrowid
s1.Error              s1.close              s1.messages
s1.IntegrityError     s1.connection         s1.nextset
s1.InterfaceError     s1.description        s1.rowcount
s1.InternalError      s1.description_flags  s1.rownumber
s1.MySQLError         s1.errorhandler       s1.scroll
s1.NotSupportedError  s1.execute            s1.setinputsizes
s1.OperationalError   s1.executemany        s1.setoutputsizes
s1.ProgrammingError   s1.fetchall           
s1.Warning            s1.fetchmany          

In [5]: s1.execute('SHOW DATABASES;')        #执行SQL语句     
Out[5]: 3L                                   #返回的结果

In [6]: s1.fe
s1.fetchall   s1.fetchmany  s1.fetchone   

In [6]: s1.fetchall()                       #详细查看返回的结果，此时游标已经指到了尾部
Out[6]: (('information_schema',), ('mysql',), ('test',))

In [7]: s1.fetchone()                     #这里没数据了，需要调整游标的位置

In [8]: s1.fetchmany
Out[8]: <bound method Cursor.fetchmany of <MySQLdb.cursors.Cursor object at 0x2db8e90>>

In [9]: s1.fetchmany()
Out[9]: ()

In [11]: s1.scroll(0,mode='absolute')      #移到首部

In [13]: s1.fetchone()                     #读取一行
Out[13]: ('information_schema',)

In [14]: s1.fetchone()     
Out[14]: ('mysql',)

In [15]: s1.fetchone()
Out[15]: ('test',)

In [16]: s1.fetchone()

In [17]: s1.scroll(1,mode='absolute')

In [18]: s1.fetchone()
Out[18]: ('mysql',)

In [19]: s1.fetchone()
Out[19]: ('test',)

In [20]: s1.fetchone()

In [21]: s1.scroll(0,mode='absolute')

In [22]: s1.fetchmany()
Out[22]: (('information_schema',),)

In [23]: s1.fetchmany()
Out[23]: (('mysql',),)

In [24]: s1.fetchmany()
Out[24]: (('test',),)

In [25]: s1.fetchmany()
Out[25]: ()

In [26]: s1.scroll(0,mode='absolute')

In [32]: s1.fetchmany(3)                                  #可以指定一次读取几行
Out[32]: (('information_schema',), ('mysql',), ('test',))

In [33]: s1.fetchmany(2)
Out[33]: ()

In [34]: s1.scroll(0,mode='absolute')

In [35]: s1.fetchmany(2)
Out[35]: (('information_schema',), ('mysql',))

In [36]: s1.close()     #关闭游标

In [37]: conn.close()  #关闭连接




二、socket模块

Python 提供了两个级别访问的网络服务。

• 低级别的网络服务支持基本的 Socket，它提供了标准的 BSD Sockets API，可以访问底层操作系统Socket接口的全部方法。

• 高级别的网络服务模块 SocketServer， 它提供了服务器中心类，可以简化网络服务器的开发。




什么是socket?

  Socket又称"套接字"，应用程序通常通过"套接字"向网络发出请求或者应答网络请求，使主机间或者一台计算机上的进程间可以通讯。





1、编写服务器端程序


 1）创建socket

Python 中，我们用 socket（）函数来创建套接字，语法格式如下：

socket.socket([family[, type[, proto]]])

socket.socket(family,type)

     family     套接字家族

          AF_INET:

          AF_UNIX:

     type          套接字类型

          SOCK_STREAM

          SOCK_DGRAM

     proto        

          tcp

         udp




Socket 对象(内建)方法

函数	描述
服务器端套接字
s.bind()	绑定地址（host,port）到套接字， 在AF_INET下,以元组（host,port）的形式表示地址。
s.listen()	开始TCP监听。backlog指定在拒绝连接之前，操作系统可以挂起的最大连接数量。该值至少为1，大部分应用程序设为5就可以了。
s.accept()	被动接受TCP客户端连接,(阻塞式)等待连接的到来
客户端套接字
s.connect()	主动初始化TCP服务器连接，。一般address的格式为元组（hostname,port），如果连接出错，返回socket.error错误。
s.connect_ex()	connect()函数的扩展版本,出错时返回出错码,而不是抛出异常
公共用途的套接字函数
s.recv()	接收TCP数据，数据以字符串形式返回，bufsize指定要接收的最大数据量。flag提供有关消息的其他信息，通常可以忽略。
s.send()	发送TCP数据，将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。
s.sendall()	完整发送TCP数据，完整发送TCP数据。将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
s.recvform()	接收UDP数据，与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。
s.sendto()	发送UDP数据，将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。
s.close()	关闭套接字
s.getpeername()	返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。
s.getsockname()	返回套接字自己的地址。通常是一个元组(ipaddr,port)
s.setsockopt(level,optname,value)	设置给定套接字选项的值。
s.getsockopt(level,optname[.buflen])	返回套接字选项的值。
s.settimeout(timeout)	设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如connect()）
s.gettimeout()	返回当前超时期的值，单位是秒，如果没有设置超时期，则返回None。
s.fileno()	返回套接字的文件描述符。
s.setblocking(flag)	如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）。非阻塞模式下，如果调用recv()没有发现任何数据，或send()调用无法立即发送数据，那么将引起socket.error异常。
s.makefile()	创建一个与该套接字相关连的文件

示例：

        tcpconn=scoket.socket(socket.AF_INET,sockot.SOCK_STREAM)

In [44]: import socket

In [45]: tcpconn=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

In [46]: tcpconn.
tcpconn.accept         tcpconn.getsockname    tcpconn.recvfrom_into
tcpconn.bind           tcpconn.getsockopt     tcpconn.send
tcpconn.close          tcpconn.gettimeout     tcpconn.sendall
tcpconn.connect        tcpconn.listen         tcpconn.sendto
tcpconn.connect_ex     tcpconn.makefile       tcpconn.setblocking
tcpconn.dup            tcpconn.proto          tcpconn.setsockopt
tcpconn.family         tcpconn.recv           tcpconn.settimeout
tcpconn.fileno         tcpconn.recv_into      tcpconn.shutdown
tcpconn.getpeername    tcpconn.recvfrom       tcpconn.type

 2）绑定地址


     使用套接字对象bind方法绑定于某地址和端口


tcpconn.bind(('ip',port))




In [47]: help(tcpconn.bind)

Help on method bind:

bind(...) method of socket._socketobject instance
    bind(address)
    
    Bind the socket to a local address.  For IP sockets, the address is a
    pair (host, port); the host must refer to the local host. For raw packet
    sockets the address is a tuple (ifname, proto [,pkttype [,hatype]])
(END) 

In [48]: tcpconn.bind("192.168.10.3",8023)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-48-a9abfbcc4351> in <module>()
----> 1 tcpconn.bind("192.168.10.3",8023)

/usr/local/python27/lib/python2.7/socket.pyc in meth(name, self, *args)
    222 
    223 def meth(name,self,*args):
--> 224     return getattr(self._sock,name)(*args)
    225 
    226 for _m in _socketmethods:

TypeError: bind() takes exactly one argument (2 given)

In [49]: tcpconn.bind(("192.168.10.3",8023)

 3）使用listen方法进行监听状态

tcpconn.listen(backlog)             #backlog  等待队列的长度

tcpconn.listen(100)

In [50]: tcpconn.listen(30)


[root@Node3 ~]# ss -nlt
State       Recv-Q Send-Q                       Local Address:Port                         Peer Address:Port 
LISTEN      0      128                                      *:7500                                    *:*     
LISTEN      0      128                                      *:7501                                    *:*     
LISTEN      0      100                                      *:9422                                    *:*     
LISTEN      0      128                                     :::22                                     :::*     
LISTEN      0      128                                      *:22                                      *:*     
LISTEN      0      30                            192.168.10.3:8023                                    *:*     
LISTEN      0      100                                    ::1:25                                     :::*     
LISTEN      0      100                              127.0.0.1:25                                      *:*     
LISTEN      0      128                              127.0.0.1:6010                                    *:*     
LISTEN      0      128                                    ::1:6010                                   :::*     
LISTEN      0      128                              127.0.0.1:6011                                    *:*     
LISTEN      0      128                                    ::1:6011                                   :::*     
LISTEN      0      50                                       *:3306                                    *:*

 4）循环监听状态


     使用套接字对象的accept方法接收用户请求

In [51]: help(tcpconn.accept)     #返回（客户端Ip地址，端口）
       
Help on method accept in module socket:

accept(self) method of socket._socketobject instance
    accept() -> (socket object, address info)
    
    Wait for an incoming connection.  Return a new socket representing the
    connection, and the address of the client.  For IP sockets, the address
    info is a pair (hostaddr, port).
    
    
 In [52]: ci,cp=tcpconn.accept()      #此时服务端阻塞




2、编写客户端程序

 1）创建一个socket对象，以连接服务器端

      clientsock=socket.socket(socket.AF_INET,sock.SOCK_STREAM)

In [6]: import socket

In [7]: clientsock=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

 2）连接至服务器

      clientscok.connect(('server_ip',server_port))

In [8]: clientsock.connect(('192.168.10.3',8023))

此时再观察服务器端：

In [55]: ci,cp=tcpconn.accept()         #服务器端收到数据，结束阻塞

In [56]: ci
Out[56]: <socket._socketobject at 0x2f16590>

In [57]: ci()
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-57-3d2081a2327e> in <module>()
----> 1 ci()

TypeError: '_socketobject' object is not callable

In [58]: ci,cp             #返回2各对象，ci是一个socket对象，cp是一个元祖对象
Out[58]: (<socket._socketobject at 0x2f16590>, ('192.168.10.3', 34873))

 3）发送请求


      clientscok.send()

In [9]: clientsock.send('hello server') 
Out[9]: 11

   但这么操作当客户端连接进服务器端后，连接就断开了，我们应该写脚本来实现服务器处于循环监听状态





脚本文件：

[root@Node3 ~]# cat server.py                #服务器端
#!/usr/local/bin/python2.7
#
import socket
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sa=("192.168.10.3",8030)
s.bind(sa)
s.listen(20)
while True:
    cinfo,caddr=s.accept()
    print "Got a connection from %s" %caddr[0]
    data=cinfo.recv(1024)
    print "Receive data:%s" %data
    cinfo.send("echo: " + data)
    cinfo.close()

[root@Node3 ~]# cat client.py                   #客户端
#!/usr/local/bin/python2.7
#
import socket
c=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
saddr=("192.168.10.3",8030)
c.connect(saddr)
c.send("Hello Server")
data=c.recv(1024)
print "Reply from server %s" %data

执行脚本：

[root@Node3 ~]# python2.7 server.py     #执行服务器端脚本
                                        #阻塞状态

[root@Node3 ~]# python2.7  client.py    #执行客户端脚本
Reply from server echo: Hello Server

再看服务器端：

[root@Node3 ~]# python2.7 server.py 
Got a connection from 192.168.10.3
Receive data:Hello Server
                                         #仍阻塞状态

修改下客户端脚本再执行一次：

[root@Node3 ~]# vi client.py 
[root@Node3 ~]# python2.7  client.py 
Reply from server echo: Hello SB

服务器端：

[root@Node3 ~]# python2.7 server.py 
Got a connection from 192.168.10.3
Receive data:Hello Server
Got a connection from 192.168.10.3
Receive data:Hello SB

关键字：