Python mysql、socket、多线程

最新推荐文章于 2021-07-07 16:21:17 发布

网络无法连接

最新推荐文章于 2021-07-07 16:21:17 发布

阅读量232

点赞数

本文链接：https://blog.csdn.net/g_541243027/article/details/81220851

版权

一.mysql

1.数据库设置

[root@foundation14 ~]# yum install mariadb-server.x86_64 -y #安装数据库
[root@foundation14 ~]# systemctl start mariadb  #打开设置
[root@foundation14 ~]# systemctl stop firewalld  #关闭防火墙
[root@foundation14 ~]# mysql_secure_installation  #修改数据库密码
[root@foundation14 ~]# yum install gcc -y  
[root@foundation14 ~]# yum install MySQL-python.x86_64 -y
[root@foundation14 ~]# pip install Mysql-Python           #需联网

在网页中创建数据库

[root@foundation14 ~]# yum install httpd php php-mysql.x86_64 -y #安装httpd，php
[root@foundation14 ~]# systemctl start httpd
[root@foundation14 ~]# systemctl stop firewalld
[root@foundation14 ~]# cd /var/www/html/
[root@foundation14 html]# ls
index.html  phpMyAdmin-3.4.0-all-languages.tar.bz2
[root@foundation14 html]# tar jxf phpMyAdmin-3.4.0-all-languages.tar.bz2 #解压 
[root@foundation14 html]# ls
index.html                      phpMyAdmin-3.4.0-all-languages.tar.bz2
phpMyAdmin-3.4.0-all-languages
[root@foundation14 html]# rm -fr phpMyAdmin-3.4.0-all-languages.tar.bz2 #删除压缩包 
[root@foundation14 html]# mv phpMyAdmin-3.4.0-all-languages/ mysqladmin更改为mysqladmin
[root@foundation14 html]# cd mysqladmin/
[root@foundation14 mysqladmin]# cp config.sample.inc.php config.inc.php

在网页浏览：http://172.25.254.14/mysqladmin/
这里写图片描述

[root@foundation14 mysqladmin]# mysql -uroot -p
Enter password: 
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MariaDB connection id is 20
Server version: 5.5.52-MariaDB MariaDB Server

Copyright (c) 2000, 2016, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

MariaDB [(none)]> show databases; ##显示数据库
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
+--------------------+
3 rows in set (0.00 sec)

MariaDB [(none)]> create database python; #新建数据库
Query OK, 1 row affected (0.00 sec)

MariaDB [(none)]> show databases; #显示数据库
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| python             |
+--------------------+
4 rows in set (0.00 sec)

MariaDB [(none)]> use python; #进入数据库
Database changed

MariaDB [python]> show tables; #显示数据库中的表格
Empty set (0.00 sec)

MariaDB [python]> create table userInfo(id int,name varchar(10)); #新建数据库python的表格
Query OK, 0 rows affected (0.09 sec)

MariaDB [python]> select * from userInfo; #查询userInfo表中的所有信息
Empty set (0.00 sec)

MariaDB [python]> insert into userInfo(id,name)value(1,'tom'); #在userInfo表格中插入信息
Query OK, 1 row affected (0.03 sec)

MariaDB [python]> select * from userInfo;
+------+------+
| id   | name |
+------+------+
|    1 | tom  |
+------+------+
1 row in set (0.00 sec)

MariaDB [python]> select id from userInfo;
+------+
| id   |
+------+
|    1 |
+------+
1 row in set (0.00 sec)

MariaDB [python]> update userInfo set name = 'harry'; 修改userInfo表格中的name信息
Query OK, 1 row affected (0.03 sec)
Rows matched: 1  Changed: 1  Warnings: 0

MariaDB [python]> select name from userInfo;
+-------+
| name  |
+-------+
| harry |
+-------+
1 row in set (0.00 sec)

MariaDB [python]> select * from userInfo;
+------+-------+
| id   | name  |
+------+-------+
|    1 | harry |
+------+-------+
1 row in set (0.00 sec)

*2.查看数据库数据*
1.查-01
实验：

import MySQLdb

# 打开门
conn = MySQLdb.connect(host='127.0.0.1', user='root', passwd='westos', db='python')

# 伸出手
cur = conn.cursor()

# 拿东西
recont = cur.execute('select * from userInfo')

# 把手伸回来
cur.close()

# 把门关上
conn.close

print recont

运行结果：
这里写图片描述
2.查-02（用元组行散记显示信息）
实验：

import MySQLdb

# 打开门
conn = MySQLdb.connect(host='127.0.0.1', user='root', passwd='westos', db='python')

# 伸出手
cur = conn.cursor()  # 创建了一个“手”

# 拿东西
# 这个操作影响了多少行（有多少行被操作）
recont = cur.execute('select * from userInfo')
data = cur.fetchall()
# 把手伸回来
cur.close()

# 把门关上
conn.close

print recont
print data

运行结果：
这里写图片描述
3.查-03(用字典形式显示)
实验：

import MySQLdb

# 打开门
conn = MySQLdb.connect(host='127.0.0.1', user='root', passwd='westos', db='python')

# 伸出手
#cur = conn.cursor()  # 创建了一个“手”
cur = conn.cursor(cursorclass= MySQLdb.cursors.DictCursor)
# 拿东西
# 这个操作影响了多少行（有多少行被操作）
recont = cur.execute('select * from userInfo')
data = cur.fetchall()
# 把手伸回来
cur.close()

# 把门关上
conn.close

print recont
print data

运行结果：
这里写图片描述

3.增添数据库数据

import MySQLdb

#打开门
conn = MySQLdb.connect(host='127.0.0.1', user='root', passwd='westos', db='python')

#伸出手
cur = conn.cursor()

#操作数据
sql = 'insert into usermg(id,name,address) values(%s,%s,%s)'
params = ('1','dd','usa')
recount = cur.execute(sql,params)

#提交请求
conn.commit()

#把手伸回来
cur.close()

#把门关上
conn.close()
print recount

运行结果：
这里写图片描述

4.更改数据库数据

import MySQLdb

#打开门
conn = MySQLdb.connect(host='127.0.0.1', user='root', passwd='westos', db='python')

#伸出手
cur = conn.cursor()

#操作数据
sql = 'update usermg set name = %s where id = %s'
params = ('uu','1',)
recount = cur.execute(sql,params)

#提交请求
conn.commit()

#把手伸回来
cur.close()

#把门关上
conn.close()
print recount

运行结果：
这里写图片描述

5.删除数据库数据

import MySQLdb

#打开门
conn = MySQLdb.connect(host='127.0.0.1', user='root', passwd='westos', db='python')

#伸出手
cur = conn.cursor()

#操作数据
sql = 'delete from usermg where id = %s'
params = (1,)
recount = cur.execute(sql,params)

#提交请求
conn.commit()

#把手伸回来
cur.close()

#把门关上
conn.close()
print recount

运行结果：
这里写图片描述
6.插入多条数据：

import MySQLdb

#打开门
conn = MySQLdb.connect(host='127.0.0.1', user='root', passwd='westos', db='python')

#伸出手
cur = conn.cursor()

#操作数据
# sql = 'update usermg set name = %s where id = %s'
# params = ('uu','1',)
li = [
    ('2','hahahaa','wwww'),
    ('3','lalalaa','qqqq'),
]
recount = cur.executemany('insert into usermg(id,name,address) values(%s,%s,%s)',li)

#提交请求
conn.commit()

#把手伸回来
cur.close()

#把门关上
conn.close()
print recount

运行结果：
这里写图片描述

7.commit
建立一个表名为count

import MySQLdb
conn = MySQLdb.connect(host='127.0.0.1',user='root',passwd='westos',db='python')
cur = conn.cursor()

sql = 'update money set money = %s where id = 1'
params = ('0',)
recount = cur.execute(sql,params)

sql = 'update money set money = %s where id = 2'
param = ('100',)
recount = cur.execute(sql,param)
conn.commit()

运行结果：
这里写图片描述

二.多线程

多线程能干什么：
生产者消费者问题：（经典）
一直生产 一直消费 中间有阀值 避免供求关系不平衡

#线程安全问题，要是线程同时来，听谁的
#锁：一种数据结构 队列:先进线出 栈：先进后出

#生产者消费者的优点(为什么经典的设计模式)
    1.解耦（让程序各模块之间的关联性降到最低）
        假设生产者和消费者是两个类，如果让生产者直接调用消费者的某个方法，那么生产者对于消费者就会产生依赖(也就是耦合)，如果将来消费者的代码发生变换，可能会影响到生产者，而如果两者都依赖于某个缓冲区，两者之间不直接依赖，耦合也就相应降低了
    生活中的例子：我们 邮筒 邮递员
举个例子，我们去邮局投递信件，如果不使用邮筒(也就是缓冲区)，你必须得把信直接交给邮递员，有同学会说，直接交给邮递员不是挺简单的嘛，其实不简单，你必须得认识邮递员，才能把信给他(光凭身上的制服，万一有人假冒呢？？？)，这就产成你和邮递员之间的依赖了(相当于生产者消费者强耦合)，万一哪天邮递员换人了，你还要重新认识一下(相当于消费者变化导致修改生产者代码)，而邮筒相对来说比较固定，你依赖它的成本就比较低(相当于和缓冲区之间的弱耦合)
    2.支持并发
        生产者消费者是两个独立的并发体，他们之间是用缓冲区作为桥梁连接，生产者之需要往缓冲区里丢数据，就可以继续生产下一个数据，而消费者者只需要从缓冲区里拿数据即可，这样就不会因为彼此速度而发生阻塞
    接着上面的例子：如果我们不使用邮筒，我们就得在邮局等邮递员，直到他回来了，我们才能把信给他，这期间我们啥也不能干(也就是产生阻塞)，或者邮递员挨家挨户的问(产生论寻)
    3.支持忙闲不均
        如果制造数据的速度时快时慢，缓冲区的好处就体现出来了，当数据制造快的时候，消费者来不及处理，未处理的数据可以暂时存在缓冲区中，等生产者的速度慢下来，消费者再慢慢处理
    情人节信件太多了，邮递员一次处理不了，可以放在邮筒中，下次在来取

线程是操作系统能够进行运算调度的最小单位（程序执行流的最小单位）
它被包含在进程之中，是进程中的实际运作单位。一个进程中可以并发多个线程
每条线程并执行不同的任务
（线程是进程中的一个实体，是被系统独立调度和分派的基本单位）

每一个进程启动时都会最先产生一个线程，即主线程
然后主线程会再创建其他的子线程

import threading
from time import ctime,sleep
def music(a):
    for i in range(2):
        print 'I was listening to %s. %s'% (a,ctime())
        sleep(1)
def movie(b):
    for i in range(2):
        print 'I was watching to %s. %s' % (b,ctime())
        sleep(5)
# music('这一路走来')
# movie('我不是药神')
t1 = threading.Thread(target=music,args=('这一路走来',))
t1.start()
t2 = threading.Thread(target=movie,args=('我不是药神',))
t2.start()
print 'all over %s' %ctime()

运行结果：
这里写图片描述
1.线程-01

from threading import Thread
def Foo(arg):
    print arg

print 'before'
# 线程和函数建立关系
t1 = Thread(target=Foo,args=(1,))
t1.start()
print 'after'

运行结果：
这里写图片描述
2.线程-02

from threading import  Thread
def Foo(arg):
    print arg

print 'before'
t1 = Thread(target=Foo,args=(1,))
t1.start()
print t1.getName()

t2 = Thread(target=Foo,args=(2,))
t2.start()
print t2.getName()

print 'after'

运行结果：
这里写图片描述
3.线程-03

from threading import  Thread
import time
def Foo():
    for item in range(100):
        print item
        time.sleep(1)
print 'before'
t1 = Thread(target=Foo)
t1.setDaemon(True)
t1.start()
print 'after'
time.sleep(5)

运行结果：
这里写图片描述
4.线程-04

from threading import  Thread
import time
def Foo():
    for item in range(10):
        print item
        time.sleep(1)
print 'before'
t1 = Thread(target=Foo)
t1.start()
#主线程到join()就不会往下走了，直到子线程执行完
t1.join()
print'after'

运行结果：
这里写图片描述
5.线程-05

import threading
import Queue
import time
import random
def Producer(name,que):
    while True:
        que.put('baozi')
        print '%s:Made a baozi..============' % name
        time.sleep(random.randrange(3))
def Consumer(name,que):
    while True:
        que.get()
        print  '%s:Got a baozi..'% name
        time.sleep(random.randrange(5))
#创建队列
q = Queue.Queue()

p1 = threading.Thread(target=Producer,args=['chef1',q])
p2 = threading.Thread(target=Producer,args=['chef2',q])
p1.start()
p2.start()

c1 = threading.Thread(target=Consumer,args=['tom',q])
c2 = threading.Thread(target=Consumer,args=['harry',q])
c1.start()
c2.start()

运行结果：
这里写图片描述
6.线程-06

import threading
import Queue
import time
import random
def Producer(name,que):
    while True:
        if que.qsize()<3:
            que.put('baozi')
            print '%s:Made a baozi..============' % name
        else:
            print '还有三个包子'
        time.sleep(random.randrange(5))
def Consumer(name,que):
    while True:
        try:
            que.get()
            print  '%s:Got a baozi..'% name
        except Exception:
            print '没有包子了'
        time.sleep(random.randrange(3))
#创建队列
q = Queue.Queue()

p1 = threading.Thread(target=Producer,args=['chef1',q])
p2 = threading.Thread(target=Producer,args=['chef2',q])
p1.start()
p2.start()

c1 = threading.Thread(target=Consumer,args=['tom',q])
c2 = threading.Thread(target=Consumer,args=['harry',q])
c1.start()
c2.start()

这里写图片描述
7.线程-07

import threading
import time
num = 0

def run(n):
    time.sleep(1)
    global num
    # 线程锁
    lock.acquire()
    num += 1
    print '%s\n' %num
    lock.release()
lock = threading.Lock()
for i in range(1500):
    t = threading.Thread(target=run,args=(i,))
    t.start()

这里写图片描述

异步：

import threading
import time

def Producer():
    print 'chef:等人来买包子'
    # 收到了消费者的event.set 也就是把这个flag改为了true,但是我们的包子并没有做好
    event.wait()
    # 此时应该将flag的值改回去
    event.clear()
    print 'chef:someone is coming for 包子'
    print 'chef:making a 包子 for someone'
    time.sleep(5)
    # 告诉人家包子做好了
    print '你的包子好了～'
    event.set()

def Consumer():
    print 'tom:去买包子'
    # 告诉人家我来了
    event.set()
    time.sleep(2)
    print 'tom:waiting for 包子 to be ready'
    # 我在不断检测，但我已经不阻塞了
    while True:
        if event.is_set():
            print 'Thanks~'
            break
        else:
            print '怎么还没好呀～'
            # 模拟正在做自己的事情
            time.sleep(1)
event = threading.Event()

p1 = threading.Thread(target=Producer)
c1 = threading.Thread(target=Consumer)
p1.start()
c1.start()

运行结果：
这里写图片描述
事件驱动：

import threading
import time

def Producer():
    print 'chef:等人来买包子'
    #收到了消费者的event.set 也就是把这个flag改为了true,但是我们的包子并没有做好
    event.wait()
    #此时应该将flag的值改回去
    event.clear()
    print 'chef:someone is coming for 包子'
    print 'chef:making a 包子 for someone'
    time.sleep(5)
    # 告诉人家包子做好了
    print '你的包子好了～'
    event.set()

def Consumer():
    print 'tom:去买包子'
    # 告诉人家我来了
    event.set()
    time.sleep(2)
    print 'tom:waiting for 包子 to be ready'
    event.wait()
    print '哎呀～真好吃'

event = threading.Event()

p1 = threading.Thread(target=Producer)
c1 = threading.Thread(target=Consumer)
p1.start()
c1.start()

运行结果：
这里写图片描述

三.socket

什么是socket
    网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket
    所谓socket通常也称作“套接字”，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过“套接字”向网络发出请求或应答网络请求
    socket起源于Uinx，而Unix/Linux基本哲学之一就是“一切皆文件”，都可以用“打开open-->读写write/read-->关闭close”模式来操作，socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作(读/写 IO，打开，关闭)
    Socket的英文原义是“孔”或“插座”。作为BSD UNIX的进程通信机制，取后一种意思。通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄，可以用来实现不同虚拟机或不同计算机之间的通信。在Internet上的主机一般运行了多个服务软件，同时提供几种服务。每种服务都打开一个Socket，并绑定到一个端口上，不同的端口对应于不同的服务。Socket正如其英文原义那样，像一个多孔插座。一台主机犹如布满各种插座的房间，每个插座有一个编号，有的插座提供220伏交流电,有的提供110伏交流电，有的则提供有线电视节目。 客户软件将插头插到不同编号的插座，就可以得到不同的服务

    例如：中国移动客服
    对于移动来说:一直监听一个号码10086，当有电话进来后，就分配一个客服和客户去沟通并处理请求
    对于用户：需要知道10086这个号码，并需要打电话

建立服务端（server）：

import socket

# 1.创建socket对象
sk = socket.socket()
# 2.绑定端口和ip
ip_port = ('127.0.0.1',9999)
sk.bind(ip_port)
# 3.最大连接数
sk.listen(5)

while True:
    # 获取客户端的ip和端口号
    conn,address = sk.accept()
    conn.send('hello')
    conn.close()

建立客户端（client）

import socket

# 创建一个socket对象
client = socket.socket()

# 创建连接
ip_port = ('127.0.0.1',9999)  #端口号要和server一样
client.connect(ip_port)

# 获取数据
data = client.recv(1024)
print data

运行结果：
这里写图片描述

建立一问一答：
服务端：

import socket

# 1.创建socket对象
sk = socket.socket()
# 2.绑定端口和ip
ip_port = ('127.0.0.1',9998)
sk.bind(ip_port)
# 3.最大连接数
sk.listen(5)

while True:
    # 获取客户端的ip和端口号
    conn,address = sk.accept()
    #conn = result[0]
    #address = result[1]
    #print result
    #print type(result)
    conn.send('hello')
    flag = True
    while flag:
        data = conn.recv(1024)
        print data
        if data == 'exit':
            flag = False
        conn.send('hello')
    conn.close()

客户端：

import socket

# 创建一个socket对象
client = socket.socket()

# 创建连接
ip_port = ('127.0.0.1',9998)
client.connect(ip_port)

while True:
    # 获取数据
    data = client.recv(1024)
    print data
    # 发送数据
    inp = raw_input('clent:')
    client.send(inp)
    if inp == 'exit':
        break

运行结果：
这里写图片描述

网络无法连接

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python mysql、socket、多线程

一.mysql1.数据库设置[root@foundation14 ~]# yum install mariadb-server.x86_64 -y #安装数据库[root@foundation14 ~]# systemctl start mariadb #打开设置[root@foundation14 ~]# systemctl stop firewalld #关闭防火墙[root...
复制链接

扫一扫