python中的数据库连接、线程、socket

做数据库连接前的准备工作：
1.安装数据库
2.安装gcc yum install gcc -y
3.yum install MySQL-python.x86_64 -y
4.pip install Mysql-Python
验证：在pycharm中import Mysqldb 没有出错即可
5.安装网页版数据库

一、数据库
1.数据库的查询

import MySQLdb
# 打开门
conn = MySQLdb.connect(host='127.0.0.1', passwd='root', user='root', db='python')
# 伸出手
cur = conn.cursor()#创建一个'手'

# 拿东西
# 这个操作影响了多少行数（有多少行被调用了）
recont = cur.execute('select * from userInfo')

# 手伸回来
cur.close()
# 把门关上
conn.close()

print recont

import MySQLdb
# 打开门
conn = MySQLdb.connect(host='127.0.0.1', user='root', passwd='root', 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

2.数据库中在表中增加数据

import MySQLdb
# 连接数据库
conn = MySQLdb.connect(host='127.0.0.1', user='root', passwd='root', 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()

3.连接数据库，删除表中数据

import MySQLdb
# 连接数据库
conn = MySQLdb.connect(host='127.0.0.1', user='root',
                       passwd='root', 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

4.连接数据库，更改表中的数据

import MySQLdb
# 连接数据库
conn = MySQLdb.connect(host='127.0.0.1', user='root',
                       passwd='root', db='python')
# 进入数据库
cur = conn.cursor()
# 操作数据
sql = 'update usermg set name=%s,address=%s where id= %s'
params = ('tom', 'qwsdfg', 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='root', db='python')
# 进入数据库
cur = conn.cursor()
# 操作数据
sql = 'insert into usermg(id,name,address) values(%s,%s,%s)'
# 插入多条数据时，以列表的形式定义，数据与属于之间用元组来定义
params = [
    ('2', 'hahahaha', 'wqerghn'),
    ('3', 'wertghjn', 'qwdefgnm')
]
recount = cur.executemany(sql, params)
# 提交数据
conn.commit()
# 离开数据库
cur.close()
# 关闭数据库
conn.close()

print recount

7.数据库中数据修改后的提交和回滚：

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

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

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

在修改之后，只有提交成功后才会保存修改数据，
在提交失败后，数据会回到初始的起点，叫做回滚
二、线程
线程是操作系统能够进行运算调度的最小单位（程序执行流的最小单元）
他被包含在进程之中，是进程中的世纪运作单位。一个进程可以并发多个线程
每条线程并行执行不同的任务
（线程是进程中的一个实体，是被系统调度和分派的基本单位）

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

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(3)
# music('凉凉')
# movie('扶摇')
t1 = threading.Thread(target=music, args=('凉凉',))
t1.start()
t2 = threading.Thread(target=movie, args=('扶摇',))
t2.start()
print 'all over %s' % ctime()

from threading import Thread

def Food(arg):
    print arg

print 'before'
# 线程和函数建立联系
t1 = Thread(target=Food, args=(1,))
t1.start()
print t1.getName()

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

print 'after'

from threading import Thread
import time

def Food(arg):
    for item in range(100):
        print item
        time.sleep(1)

print 'before'
t1 = Thread(target=Food, args=(1,))
# 主线程不去等待线程的结束
t1.setDaemon(True)
t1.start()
print 'after'
# 等待10s
time.sleep(10)

在执行时，setDaemon()函数表示主线程不会去等待子线程的结束，而time.sleep()表示主进程等待子进程10s如果自己成还没有结束，主进程先行结束，但子进程只是在运行环境中看不见，在后台的进程中可以看到子进程还在继续执行。

from threading import Thread
import time

def Food():
    for item in range(10):
        print item
        time.sleep(1)

print 'before'
t1 = Thread(target=Food)
t1.start()

# 主线程到join()就不往下走了，直到子线程执行完
t1.join(5)  # 等待5秒
print 'after'

t1.join()主进程运行时碰到，主进程会停止然后子进程继续执行，等待子进程结束之后，才会执行后续中主进程的代码，但如果t1.join()中有参数，则等待的时间则是函数中的参数，等待时间结束之后，无论子进程有没有结束，主进程都会执行后续代码，直到结束。

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()

三、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这个号码，并需要打电话

socket服务端与客户端
服务端：

import socket

# 创建socket对象
sk = socket.socket()

# 绑定端口和ip
ip_port = ('127.0.0.1',9999)
sk.bind(ip_port)
# 最大连接数
sk.listen(5)

while True:
    conn, address = sk.accept()
    conn.send('hello')
    false = True
    while false:
        data = conn.recv(1024)
        print data
        if data == 'exit':
            false = False
        conn.send('sb')
    conn.close()

消费者：

import socket

client = socket.socket()

ip_port = ('127.0.0.1', 9999)
client.connect(ip_port)

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