python&&socket网络编程&&学习笔记

最新推荐文章于 2022-03-11 10:22:41 发布

默行默致

最新推荐文章于 2022-03-11 10:22:41 发布

阅读量233

点赞数

分类专栏： python

本文链接：https://blog.csdn.net/dfq737211338/article/details/100173344

版权

python 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

python&&socket网络编程&&学习笔记

python&&socket网络编程&&学习笔记

python&&socket网络编程&&学习笔记

断言

#!/usr/bin/env python
#coding:utf-8
#断言示例：以'判断语句(真或假)'的形式出现
#常适用于编写的代码必须满足特定条件（如1==1）才能正常执行时使用，
assert(1==1)

python mysql

python mysql插入数据

#!/usr/bin/env python
#coding:utf-8
#导入连接数据库模块
import MySQLdb
#创建连接数据库链接
conn = MySQLdb.connect(host='127.0.0.1',user='root',passwd='123456',db='day05')
cur = conn.cursor()
#定义数据库操作,reCount返回执行sql语句影响的条数。
#reCount = cur.execute('select id,name from  userInfo')
#定义数据库操作，插入新数据
sql = 'insert into userInfo (id,name) values(%s,%s)'
params = ('3','dfq03')
#执行sql语句，但此时数据库并未插入新数据，因为执行的sql语句未添加到数据库，需执行commit操作
reCount = cur.execute(sql,params)
#执行commit方法，提交sql语句（如insert、update、delete等）请求
conn.commit()
#获取数据库操作返回的数据
data = cur.fetchall()
#关闭数据库链接
cur.close()
conn.close()
print(reCount)
print(data)

python mysql批量操作

#!/usr/bin/env python
#coding:utf-8
#导入连接数据库模块
import MySQLdb
#创建连接数据库链接
conn = MySQLdb.connect(host='127.0.0.1',user='root',passwd='123456',db='day05')
cur = conn.cursor()
#定义批量操作的序列
li = [
    ('12','dfq12'),
    ('13','dfq13'),
    ('14','dfq14'),
    ]
#执行sql语句，但此时数据库并未插入新数据，因为执行的sql语句未添加到数据库，需执行commit操作
reCount = cur.executemany('insert into userInfo(id,name) values (%s,%s)',li)
#reCount = cur.execute(sql,params)
#执行commit方法，提交sql语句（如insert、update、delete等）请求
#执行一次commit方法可以同时提交多条sql语句。
conn.commit()
#获取数据库操作返回的数据
data = cur.fetchall()
#关闭数据库链接
cur.close()
conn.close()
print(data)

python mysql数据库操作返回字典类型数据

#!/usr/bin/env python
#coding:utf-8
#导入连接数据库模块
import MySQLdb
#创建连接数据库链接
conn = MySQLdb.connect(host='127.0.0.1',user='root',passwd='123456',db='day05')
#使数据库操作获取数据时，返回结果为字典类型
cur = conn.cursor(cursorclass = MySQLdb.cursors.DictCursor)
reCount = cur.execute('select id,name from userInfo')
#reCount = cur.execute(sql,params)
#获取数据库操作返回的数据
data = cur.fetchall()
#关闭数据库链接
cur.close()
conn.close()
print(data)

python mysql fetchone示例

#!/usr/bin/env python
#coding:utf-8
#导入连接数据库模块
import MySQLdb
#创建连接数据库链接
conn = MySQLdb.connect(host='127.0.0.1',user='root',passwd='123456',db='day05')
#使数据库操作获取数据时，返回结果为字典类型
cur = conn.cursor()
#cur = conn.cursor(cursorclass = MySQLdb.cursors.DictCursor)
reCount = cur.execute('select id,name from userInfo')
#reCount = cur.execute(sql,params)
#获取数据库操作返回的数据
#第一次使用fetchone输出获取结果的第一条数据，第二次使用fetchone输出获取结果的第二条数据，以此类推。
data = cur.fetchone()
print(data)
data = cur.fetchone()
print(data)
#使用绝对模式可以让fetchone的指针回到起始位置，即实现对获取结果的第一条数据的重复打印或对获取结果打印的循环
cur.scroll(0,mode = 'absolute')
data = cur.fetchone()
print(data)

#使用任意模式可以让fetchone的指针跳转到任意位置，即实现对获取结果自任意一条数据位置开始的打印
#如下中的'4'代表相对位置，正数为fetchone的指针右移n四位，负数为fetchone的指针左移n位
cur.scroll(4,mode = 'relative')
data = cur.fetchone()
print(data)
#关闭数据库链接
cur.close()
conn.close()

python mysql 获取自增ID

#!/usr/bin/env python
#coding:utf-8
#导入连接数据库模块
import MySQLdb
#创建连接数据库链接
conn = MySQLdb.connect(host='127.0.0.1',user='root',passwd='123456',db='day05')
#使数据库操作获取数据时，返回结果为字典类型
cur = conn.cursor()
#cur = conn.cursor(cursorclass = MySQLdb.cursors.DictCursor)
sql = "INSERT INTO Persons (FirstName,LastName) VALUES (%s,%s)"
params = ('duan','fuqiang')
#获取数据库操作返回的数据
reCount = cur.execute(sql,params)
conn.commit()
#获取自增ID
print(cur.lastrowid)
#关闭数据库链接
cur.close()
conn.close()
#print(reCount)

三层架构

数据访问层
业务处理层
表示层、UI层

项目框架

learn20190903（项目名称）
- model(文件夹，数据库内存在几个表，便需要在model文件夹下创建几个文件，且文件名称与数据库的表名称要一一对应)
  - _init_.py(文件名称)
- utility(文件夹，存放公共的功能如对数据库的操作等)
  - __init__py(文件名称)
  - sqlHelper.py(文件名称)
- conf.py(文件名称，存放配置文件（如连接数据库配置、接口URL）)
- index.py(文件名称，作为项目主文件，是项目执行的第一个文件。由主文件触发其他模块下的类与方法)

sqlHelper.py文件内容如下

#!/usr/bin/env python
#coding:utf-8
import MySQLdb
#创建类
class mysqlHelper(object):
    def __init__(self):
        pass
    #定时方法，从数据库中获取数据
    def getDict(self,sql,params):
        conn = conn = MySQLdb.connect(host='127.0.0.1',user='root',passwd='123456',db='day05')
        cur = conn.cursor(cursorclass = MySQLdb.cursors.DictCursor) 
        
        reCount = cur.execute(sql,params)
        data = cur.fetchall()
        
        cur.close()
        conn.close()
        return data
    
    def getOne(self,sql,params):
        conn = conn = MySQLdb.connect(host='127.0.0.1',user='root',passwd='123456',db='day05')
        cur = conn.cursor(cursorclass = MySQLdb.cursors.DictCursor) 
        
        reCount = cur.execute(sql,params)
        data = cur.fetchone()
        
        cur.close()
        conn.close()
        return data

helper = mysqlHelper()
sql = 'select id,name from userInfo where name = %s'
params = ("dfq20",)
sampleData = helper.getOne(sql, params)
print(sampleData)

socket

什么是socket?

所谓socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过"套接字"向网络发出请求或应答网络请求。
socket起源于Unix,而Uinx/linux基础哲学之一就是“一切皆文件”，都可以用“打开open-读写write/read-关闭close”模式来操作。socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读、写、IO、打开、关闭）

服务端一直在监听着，当客户端发送请求到服务端时，服务器与客户端建立连接，最后实现互相通信

socket示例1

示例框架
在这里插入图片描述
server.py

#!/usr/bin/env python
#coding:utf-8
import socket

#创建socket对象,"socket对象 = socket模块.socket类"
socketObj = socket.socket()
#socket绑定监听地址
bindAddress = ('127.0.0.1',9999)
socketObj.bind(bindAddress)
#设置socket最大连接数
socketObj.listen(5)
#使用"socketObj.accept()"接收请求，获取客户端连接对象clientConnObj和客户端地址clientAddress
while True:
    clientConnObj,clientAddress = socketObj.accept()
    #向客户端发送信息
    messageStr = "hello,socket"
    messageObj = messageStr.encode(encoding='utf_8', errors='strict')
    clientConnObj.send(messageObj)
    #关闭socket
    clientConnObj.close()

client.py

#!/usr/bin/env python
#coding:utf-8
import socket

#创建socket对象,"socket对象 = socket模块.socket类()"
clientSocketObj = socket.socket()
#客户端连接服务端器监听的地址
serverAddress = ('127.0.0.1',9999)
clientSocketObj.connect(serverAddress)
#客户端与服务端连接成功后，获取数据
data = clientSocketObj.recv(1024)
print(data)

cmd执行client.py

D:\backupAll\eclipseRoot\20190903LearnSocket\socketDemo>python client.py
b'hello,socket'
D:\backupAll\eclipseRoot\20190903LearnSocket\socketDemo>python client.py
b'hello,socket'
D:\backupAll\eclipseRoot\20190903LearnSocket\socketDemo>python client.py
b'hello,socket'

socket实现客户端与服务端简单信息交互

项目框架
在这里插入图片描述
server.py

#!/usr/bin/env python
#coding:utf-8
import socket
from pip._vendor.distlib.compat import raw_input
from distutils.tests.test_register import Inputs

#创建socket对象,"socket对象 = socket模块.socket类"
socketObj = socket.socket()
#socket绑定监听地址
bindAddress = ('127.0.0.1',9999)
socketObj.bind(bindAddress)
#设置socket最大连接数,即等待时最大阻塞数 
socketObj.listen(5)
#使用"socketObj.accept()"接收请求，获取客户端连接对象clientConnObj和客户端地址clientAddress
while True:
    '''
            等同于
    result = socketObj.accept()
    clientConnObj = result[0]
    clientAddress = result[1]
    '''
    clientConnObj,clientAddress = socketObj.accept()
    #向客户端发送信息
    messageStr = "hello,socket"
    messageObj = messageStr.encode(encoding='utf_8', errors='strict')
    clientConnObj.send(messageObj)
    #定义交互终止控制按钮flag
    flag = True
    #利用while实现重复交互
    while flag:
        #服务端接收客户端信息
        data = clientConnObj.recv(1024)
        dataDecode = str(data, encoding = "utf8")
        print("clientSay:" + dataDecode)
        #如果客户端发送exit,则终止重复交互过程
        if dataDecode == 'exit':
            flag = False
        inputStr = raw_input('server:')
        inputEncode = inputStr.encode(encoding='utf_8', errors='strict')
        clientConnObj.send(inputEncode)
    #关闭socket
    clientConnObj.close()

client.py

#!/usr/bin/env python
#coding:utf-8
import socket
from pip._vendor.distlib.compat import raw_input

#创建socket对象,"socket对象 = socket模块.socket类()"
clientSocketObj = socket.socket()
#客户端连接服务端器监听的地址
serverAddress = ('127.0.0.1',9999)
clientSocketObj.connect(serverAddress)
#客户端与服务端连接成功后，获取数据
while True:
    data = clientSocketObj.recv(1024)
    dataDecode = str(data, encoding = "utf8")
    print("serverSay:" +dataDecode)
    #客户端发送信息到服务端
    inputStr = raw_input('client:')
    inputEncode = inputStr.encode(encoding='utf_8', errors='strict')
    clientSocketObj.send(inputEncode)

效果演示
在这里插入图片描述

socket模块.socket类（）的使用

socketObj = socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)
参数一：socket.AF_INET（地址簇）
socket.AF_INET ：IPv4(默认)
socket.AF_INET6 ：IPv6
socket.AF_UNIX ：只能够用于单一的Unix系统进程间通信
参数二：类型
socket.SOCK_STREAM ：流式socket，默认TCP
socket.SOCK_DGRAM ：数据格式socket，UDP

socket对象的方法介绍

socketObj.bind(address)
将套接字绑定地址。address地址的格式取决于地址簇。在AF_INET下，以元组（host，port）的形式表示地址。
socketObj.listen(backlog)
开始监听传入连接。backlog指定在拒绝连接之前，操作系统可以挂起的最大连接数量。该值至少为1，大部分应用程序设为5就可以了。
socketObj.accept()
接受连接并返回（conn.address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。接收TCP客户的连接（阻塞式）等待连接的到来
socketObj.connect(address)
连接到address处的套接字。一般，address的格式为元组（hostname,port），如果连接出错，返回socket error错误。
socketObj.connect_ex(address)
同上，只不过会有返回值，连接成功时返回0，连接失败时返回编码，如10061
socketObj.close()
关闭套接字
socketObj.recv(bufsize[,flag])
接收套接字的数据。数据以字符串形式返回，bufsize指定要接收的最大数据量（即多少字节，且该值的设置要小于机器缓冲区的大小（一般为8k））。flag提供有关信息的其他信息，通常可以忽略。recv也会阻塞，等待接收客户端发送的数据。
socketObj.recvfrom(bufsize[,flag])
与recv()类似，但是返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。
socketObj.send(string[,flag])
将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。
socketObj.sendall(string[,flag])
将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
socketObj.sendto(string[,flag],address)
将数据发送到套接字，address的形式为(ipaddr,port)的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议
socketObj.settimeout(timeout)
设置套接字操作的超时时间。timeout是一个浮点数，单位是秒。值为None表示没有超时时间。一般。超时时间应该在刚创建套接字时设置，因为他们可能用于连接的操作（如connect（））
socketObj.getpeername()
返回套接字的远程地址。返回值通常是元组（ipaddr,port）.
socketObj.getsockname()
返回套接字自己的地址。返回值通常是元组（ipaddr,port）.
socketObj.fileno()
套接字的文件描述符

利用SocketServer模块实现异步多线程服务端示例

示例框架
在这里插入图片描述
server.py

#!/usr/bin/env python
#coding:utf-8
from pip._vendor.distlib.compat import raw_input
from distutils.tests.test_register import Inputs
#导入socketserver模块，利用socketserver实现异步多线程服务端
import socketserver
#定义类，类继承了socketserver.BaseRequestHandler类，
class MyServer(socketserver.BaseRequestHandler):
    
    def setup(self):
        pass
    def handle(self):
        print(self.request,self.client_address,self.server)
        #定义客户端对象
        clientConnObj =self.request
        messageStr = "hello,socket"
        messageObj = messageStr.encode(encoding='utf_8', errors='strict')
        clientConnObj.send(messageObj)
        #定义交互终止控制按钮flag
        flag = True
        #利用while实现重复交互
        while flag:
            #服务端接收客户端信息
            data = clientConnObj.recv(1024)
            dataDecode = str(data, encoding = "utf8")
            print("clientSay:" + dataDecode)
            #如果客户端发送exit,则终止重复交互过程
            if dataDecode == 'exit':
                flag = False
            inputStr = raw_input('server:')
            inputEncode = inputStr.encode(encoding='utf_8', errors='strict')
            clientConnObj.send(inputEncode)
        #关闭socket
        clientConnObj.close()
    def finish(self):
        pass    
if __name__ == "__main__":
    #使用socketserver模块的ThreadingTCPServer类接收参数（监听地址、定义的类名），返回ThreadingTCPServer的对象
    server = socketserver.ThreadingTCPServer(('127.0.0.1',9999),MyServer)
    #执行server对象的serve_forever方法
    server.serve_forever()

client.py

#!/usr/bin/env python
#coding:utf-8
import socket
from pip._vendor.distlib.compat import raw_input

#创建socket对象,"socket对象 = socket模块.socket类()"
clientSocketObj = socket.socket()
#客户端连接服务端器监听的地址
serverAddress = ('127.0.0.1',9999)
clientSocketObj.connect(serverAddress)
#客户端与服务端连接成功后，获取数据
while True:
    data = clientSocketObj.recv(1024)
    dataDecode = str(data, encoding = "utf8")
    print("serverSay:" +dataDecode)
    #客户端发送信息到服务端
    inputStr = raw_input('client:')
    inputEncode = inputStr.encode(encoding='utf_8', errors='strict')
    clientSocketObj.send(inputEncode)