Python学习笔记之网络编程

操做MySQLphp

# 断言 assert(1==1)

#############################################################################

********************************************************************
# 建立Connection                                                   *        
-------------------------------------------------------------------*
Connection:建立了Python客户端与数据库之间的网络通路。他的参数以下 *
-------------------------------------------------------------------*
参数名        类型        说明                                       *
host        String        MySQL的服务器地址                           *
port        int            MySQL的端口号                               *
user        String        用户名                                       *
passwd        String        密码                                       *
db            String        使用的数据库                               *
charset        String        链接字符集                                   *
                                                                 *    
-------------------------------------------------------------------*
Connection支持的方法:                                               *
-------------------------------------------------------------------*
方法名        说明                                                   *
cursor()    建立而且返回游标                                       *
commit()    提交当前事物                                           *
rollback()    回滚当前事物r()                                        *
close()        关闭Connection                                         *
-------------------------------------------------------------------*
#获取Cursor.                                                       *
-------------------------------------------------------------------*
Cursor:游标对象,用于执行查询和获取结果,它支持的方法以下:        *
-------------------------------------------------------------------*
方法名                说明                                           *
execute()            用于执行一个数据库的查询命令                   * 
fetchone()            获取结果集中的下一行                           *
fetchmany(size)     获取结果集中的下(size)行                     *
fetchall()            获取结果集中剩下的全部行                       *
rowcount            最近一次execute返回数据/影响的行数             *
close()                关闭游标                                       * 
********************************************************************

#############################################################################
建立链接:conn = pymysqsl.connect(xxxx)
建立游标:cur = conn.cursor()
执行sql:cur.execute(sql)
返回全部结果:data = cur.fetchall()
返回N行结果: cur.fetchmany(3)
返回一行结果:cur.fetchone
关闭游标,数据库
cur.close()
conn.close()

#############################################################################
# 该模块防sql注入, 不支持+字符串连接,默认%s占位符
sql =  "insert into admin(name,address) values (%s,%s)"
params = ('alex_1', 'usea')
recout =  cur.execute(sql, params)
# insert、update、del的时候须要commit,select的时候不须要
con.commit

# commit 提交

#在fetch数据时按照顺序进行,可使用cursor.scroll(num,mode)来移动游标位置,如:

    cursor.scroll(1,mode='relative')  # 相对当前位置移动
    cursor.scroll(2,mode='absolute') # 相对绝对位置移动
#############################################################################
# 多条
sql =  "insert into admin(name,address) values (%s,%s)"
params = [
            ('alex_1', 'usea'),
            ('alex_2', 'usea')
        ]
recout =  cur.executemany(sql, params)

#执行多条sql,只会提交一次,失败则回滚
con.commit  

# 显示sql列名, 游标 设置为字典类型
cur = con.cursor(cursor = pymysql.cursors.DictCursor)

# 获取自增id
cur.lastrowid
#############################################################################
# 事务
    事物用于将某些操做的多个sql做为原子性操做,一旦有某一个出现错误,便可回滚到原来的状态,从而保证数据库数据完整性
    
# 事务的特性
    事务有如下四个标准属性的缩写ACID,一般被称为:
        1.原子性:确保工做单元内的全部操做都成功完成,不然事务将被停止在故障点,和之前的操做将回滚到之前的状态
        2.一致性:确保数据库正确地改变状态后,成功提交事务
        3.隔离性:使事务操做彼此独立和透明的
        4.持久性:确保提交的事务的结果或交过的系统出现故障的状况下仍然存在
    
    在MySQL中,事务开始使用commit或rollback语句开始工做和结束。开始和结束语句的sql命令之间造成大量的事务。
#COMMIT % ROLLBACK
    这俩个关键字提交和回滚主要用于MySQL的事务。
    
    当一个成功的事务完成后,发出commit命令应使全部参与表的更改才会生效
    
    若是发生故障时,应发出一个rollback命令返回的事务中引用的每个表之前的状态
    
    可控制的事务行为成为AUTOCOMMIT设置会员变量。若是AUTOCOMMIT设置为1(默认值),人后每个sql语句(在事务与否)被认为是一个完整的事务,并承诺在默认状况下,当它完成。
    AUTOCOMMIT设置为0时,发出SET AUTOCOMMIT = 0 命令,在随后的一系列语句的做用就像一个事务,知道一个明确的COMMIT语句时,没有活动的提交
    
    能够经过使用mysql_query()函数在php中执行这些sql命令
    
# 通用事务例子
    这一系列事件是独立于所使用的编程语言,能够创建在任何使用的语言来建立应用程序的逻辑路径
    能够经过使用mysql_query()函数在php中执行这些sql命令
    
    BEGIN WORK开始事务发出sql命令
    
    发出一个或多个sql命令,如select、insert、update、delete
    检查是否有任何错误,一切都依据的须要
    若是有任何错误,那么问题rollback命令,不然发出commit命令
    
# 在项目设计里面,牵扯到金钱的转义,因而就要用到mysql的事务处理,来确保一组处理结果的正确性。用了事务,就不可避免的要牺牲一部分速度,来确保数据的正确性
    事务ACID Atomicity(原子性)、Consistency(稳定性)、Isolation(隔离性)、Durability(可靠性)
    1.事务的原子性
        一组事务,要么成功,要么撤回
    2.稳定性
        有非法数据(外键约束之类),事务撤回
    3.隔离性
        事务独立运行
            一个事务处理后的结果,影响了其余事务,那么其余事务会撤回
            事务的100%隔离,须要牺牲速度
    4.可靠性
        软、硬件奔溃后,InnoDB数据表驱动会利用日志文件重构修改
        可靠性和高速度不可兼得,innodb_flush_log_at_trx_commit选项,决定何时把事务保存到日志里
        
        开启事务
            START TRANSACTION 或 BEGIN
        
        提交事务(关闭事务)
            COMMIT
            
        放弃事务(关闭事务)
            ROLLBACK
            
        折返点
            SAVEPOINT adqoo_1
            ROLLBACK TO SAVEPOINT adqoo_1
            发生在折返点adqoo_1以前的事务被提交,以后的被忽略
            
        事务的终止
            设置"自动提交" 模式
            SET AUTOCOMMIT = 0
            每条SQL都是同一个事务的不一样命令,之间有COMMIT 或 ROLLBACK隔开
            掉线后,没有COMMIT的事务都被放弃
            
# 事务锁定模式
    系统默认:不须要等待某事务结束,可直接查询到结果,但不能再进行修改、删除
    缺点:查询到的结果,多是已通过期的
    优势:不须要等待某事务结束,可直接查询到结果
    
# 须要用如下模式来设定锁定模式
    1.SELECT....LOCK IN SHARE MODE(共享锁)
        查询到的数据,就是数据库在这一时刻的数据(其余已COMMIT事务的结果,已经反应到这里了)
        SELECT 必须等待,某个事务结束后才能执行
    
    2.SELECT...FOR UPDATE(排它锁)
        例如 SELECT* FROM tablename WHERE id < 200
        那么当id < 200的数据,被查询到的数据,都将不能再进行修改、删除、SELECT...LOCK IN SHARE MODE 操做  一直到事务结束
        
        共享锁和排它锁的区别:在因而否阻断其余用户发出的SELECT...LOCK IN SHARE MODE 命令
        
    3.INSERT/UPDATE/DELETE
        全部关联数据都会被锁定,加上排它锁
        
    4.防插入锁
        例如SELECT * FROM tablename WHERE id > 200
        那么id  > 200的记录没法被插入
        
    5.死锁
        自动识别死锁
        先进来的进程被执行,后来的进程收到出错的消息,并按ROLLBACK方式回滚
        innodb_lock_wait_timeout = n 来设置最长等待时间、默认50秒
                
# 事务隔离模式
    
    SET [SESSION|GLOBAL] TRANSACTION ISOLATION LEVEL
    READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE
    
    1.不带SESSION/GLOBAL的SET命令
        只对下一个事务有效
    
    2.SET SESSION|
        为当前会话设置隔离模式
        
    3.SET GLOBAL
        为之后新建的全部MYSQL链接设置隔离模式(当前了解不包括在内)
        
# 隔离模式
    READ UNCOMMITTED
    
    不隔离SELECT
        其余事务未完成的修改(未COMMIT),其结果也在考虑以内
        
    READ COMMITTED
        把其余事务的 COMMIT 修改考虑在内
        同一个事务中,同一 SELECT 可能返回不一样结果
    
    EPEATABLE READ(默认)
        不把其余事务的修改考虑在内,不管其余事务是否用COMMIT命令提交过
        同一个事务中,同一 SELECT 返回同一结果(前提是本事务,不修改)

   SERIALIZABLE
        和REPEATABLE READ相似,给全部的SELECT都加上了 共享锁

    出错处理
        根据出错信息,执行相应的处理
        
# MYSQL的事务处理主要有两种方法
    1.用begin,rollback,commit 来实现
        begin开始一个事务
        rollback事务回滚
        commit事务确认
        
    2.直接用set来改变mysql的自动提交模式
        mysql默认是自动提交的,也就是你提交一个query,就直接指向!能够经过
        set autocommit = 0 禁止自动提交
        set autocommit = 1 开启自动提交
      来实现事务的处理
    
    但要注意当用set autocommit = 0 的时候,你之后全部的sql都将做为事务处理,直到你用commit确认或 rollback结束,注意当你结束这个事务的同时也开启了新的事务!按第一种方法只将当前的作为一个事务!
    MYSQL只有 INNODB和BDB类型的数据表才支持事务处理,其余的类型是不支持的!
            
    

 

 

Socketpython

 

# 三层架构(3-tier architecture) 一般意义上的三层架构就是将整个业务应用划分为:
    表现层(Presentation layer)、业务逻辑层(Business Logic Layer)、数据访问层(Data access layer)。
        1、表现层(UI):通俗讲就是展示给用户的界面,即用户在使用一个系统的时候他的所见所得。
        2、业务逻辑层(BLL):针对具体问题的操做,也能够说是对数据层的操做,对数据业务逻辑处理。
        3、数据访问层(DAL):该层所作事务直接操做数据库,针对数据的增添、删除、修改、查找等。
        
########################################################################################################################    
TCP/IP不是一个协议,而是一个协议族的统称。里面包括IP协议、IMCP协议、TCP协议。

TCP/IP分层:应用层HTTP/FTP,传输层TCP/UDP,网络层ip协议 ARP/RARP , 数据链路层

# 协议
*********************************************************
7 应用层     |                <应用层>                    *
--------------         TELNET,SSH,HTTP,SMIP,POP,          *
6 表示层     |         SSL/TLS,FTP,MIME,HTML,           *
--------------           SNMP,MIB,SIP,RTP....           *
5 会话层     |                                          * 
--------------------------------------------------------*
4 传输层     |                <传输层>                    *
             |        TCP,UDP,UDP-Lite,SCTP,DCCP        *
--------------------------------------------------------*
3 网络层     |                <网络层>                    *
             |          ARP,IPv4,IPv6,ICMP,IPsec        *
--------------------------------------------------------*
2 数据链路层 |                                          *
--------------          以太网,无线WLAN、PPP.........    *
1 物理层     |          (双纹线电缆,无线,光纤...)     *
*********************************************************

########################################################################################################################
        
# socket
    Python提供两个级别访问的网络服务
        1.低级别的网络服务支持基本的socket,他提供了标准的BSD sockets API, 能够访问底层操做系统Socket接口的所有方法
        2.高级别的网络服务模块SocketServer,它提供了服务器中心类,能够简化网络服务器的开发

# 什么是socket
    socket又称"套接字", 应用程序一般经过"套接字"向网络发出请求或者应答网请求,使主机间或者一台计算机上的进程能够通信
    
    socket的英文原义是“孔”或“插座”。做为BSD UNIX的进程通讯机制,取后一种意思。一般也
    称做"套接字",用于描述IP地址和端口,是一个通讯链的句柄,能够用来实现不一样虚拟机或不一样计算机之间的通讯。
    在Internet上的主机一 般运行了多个服务软件,同时提供几种服务。每种服务都打开一个Socket,并绑定到一个端口上,不一样的端口对应于不一样的服务。



########################################################################################################################
# TCP服务器                                              *           # TCP客户端    
1  经过socket类建立socket对象 socket()                  *        4  经过socket类建立socket对象 socket()
2  socket绑定ip,端口 bind()                          *        5  connect()链接服务,指定主机和端口
3  listen()最大的链接数,监听                          *           7  客户端连接成功,想服务器发送连接状态信息
6  经过阻塞的accept()方法得到客户端返回的连接信息     *           9  客户端向socket写入信息(或服务端向socket写入信息)
8  服务器accept方法返回,链接成功                      *        11 客户端关闭
10 服务器读取信息(客户端读取信息)
12 服务器端关闭


########################################################################################################################
# 链接原理
根据链接启动的方式以及本地套接字要链接的目标,套接字之间的链接过程能够分为三个步骤:服务器监听,客户端请求,链接确认。

(1)服务器监听:是服务器端套接字并不定位具体的客户端套接字,而是处于等待链接的状态,实时监控网络状态。

(2)客户端请求:是指由客户端的套接字提出链接请求,要链接的目标是服务器端的套接字。为此,客户端的套接字必须首先描述它要链接的服务器的套接字,指出服务器端套接字的地址和端口号,而后就向服务器端套接字提出链接请求。

(3)链接确认:是指当服务器端套接字监听到或者说接收到客户端套接字的链接请求,它就响应客户端套接字的请求,创建一个新的线程,把服务器端套接 字的描述发给客户端,一旦客户端确认了此描述,链接就创建好了。而服务器端套接字继续处于监听状态,继续接收其余客户端套接字的链接请求。


########################################################################################################################
服务器端

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.close()
# 关闭套接字


s.recvform()     
# 接收UDP数据,与recv()相似,但返回值是(data,address)。其中data是包含接收数据的字符串,address是发送数据的套接字地址。
s.sendto()     
# 发送UDP数据,将数据发送到套接字,address是形式为(ipaddr,port)的元组,指定远程地址。返回值是发送的字节数。
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()     
# 建立一个与该套接字相关连的文件


########################################################################################################################
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)
参数一:地址簇
    socket.AF_INET IPv4(默认)
    socket.AF_INET6 IPv6
    socket.AF_UNIX 只可以用于单一的Unix系统进程间通讯
参数二:类型
    socket.SOCK_STREAM  流式socket , for TCP (默认)
    socket.SOCK_DGRAM   数据报式socket , for UDP
    socket.SOCK_RAW 原始套接字,普通的套接字没法处理ICMP、IGMP等网络报文,而
    SOCK_RAW能够;其次,SOCK_RAW也能够处理特殊的IPv4报文;此外,利用原始套接字,能够
    经过IP_HDRINCL套接字选项由用户构造IP头。
    socket.SOCK_RDM 是一种可靠的UDP形式,即保证交付数据报但不保证顺序。
    SOCK_RAM用来提供对原始协议的低级访问,在须要执行某些特殊操做时使用,
    如发送ICMP报文。SOCK_RAM一般仅限于高级用户或管理员运行的程序使用。
  socket.SOCK_SEQPACKET 可靠的连续数据包服务
参数三:协议
    0  (默认)与特定的地址家族相关的协议,若是是 0 ,
    则系统就会根据地址格式和套接类别,自动选择一个合适的协议

recv 从缓存区拿数据,最多只能拿1024字节

########################################################################################################################
 
 

#!/usr/bin/evn python3
# _*_ coding:utf-8 _*_
import socketmysql

 
 

# #############客户端####################sql

 
 

# 第一步建立一个socket对象
client = socket.socket()数据库

 
 

# 第二步链接服务
ip_port = ('127.0.0.1', 8080)
client.connect(ip_port)编程

 
 

while True:
# 第三步 获取数据
data = client.recv(1024)
print(data.decode('utf-8'))
# 发送数据
inp = input('clent:')
client.send(inp.encode("utf-8"))
if inp == 'exit':
break缓存

 

 

#!/usr/bin/evn python3
# _*_ coding:utf-8 _*_
import socket服务器

# #############服务端####################网络

# 第一步建立一个socket对象
sk = socket.socket()多线程

# 第二步绑定ip、端口
ip_port = ('127.0.0.1', 8080)
sk.bind(ip_port)

# 第四步 设置监听
sk.listen(5)

while True:
# 第五步 接收请求,获取到客户端的socket对象和ip端口
conn, address = sk.accept()
# 第六步,给客户端发信息
conn.send('hello'.encode('utf-8'))
# 第七步,close
flag = True
while flag:
data = conn.recv(1024)
print(data)
if data == 'exit':
flag = False
conn.send('pm 是个煞笔'.encode('utf-8'))
conn.close()

 

 

#!/usr/bin/evn python3
# _*_ coding:utf-8 _*_
import socketserver


# #############多线程服务端####################


class MyServer(socketserver.BaseRequestHandler):

def handle(self):
conn = self.request
conn.sendall('hello'.encode('utf-8'))
flag = True
while flag:
data = conn.recv(1024)
if data == 'exit':
flag = False
conn.send('pm 是个煞笔'.encode('utf-8'))
conn.close()

if __name__ == '__main__': server = socketserver.ThreadingTCPServer(('127.0.0.1', 8080), MyServer) server.serve_forever()

相关文章
相关标签/搜索