# client code

import socket

ip_port = ('localhost',9999)

s = socket.socket()     # 买手机

s.connect(ip_port)      # 拨号

while True:

    send_data = input(">>:").strip()    # 输入消息内容

    if len(send_data) == 0:

        continue

    s.send(bytes(send_data,encoding='utf-8'))  # 发消息,python 3.x 必须以字节码发送

    if send_data == 'exit':

        break

    recv_data = s.recv(1024)

    # 收消息

    print(str(recv_data,encoding='utf-8'))     # 打印bytes字节码

s.close()       # 挂电话

客户端示例(二)

 小知识之作用域

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

# 代码块

if 1==1:

    name = 'alex'

print(name)

输出结果：alex

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

# 函数

def func():

    name = 'alex'

func()

print(name)

输出结果：alex

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

# 作用域一

name = 'alex'

def f1():

    name = 'a'

    def f2():

        name = 'b'

        print(name)

    f2()

f1()

输出结果：b

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

# 作用域二

name = 'alex'

def f1():

    print(name)

def f2():

    name = 'eric'

    f1()

f2()

输出结果：alex

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

# 作用域三

name = 'alex'

def f1():

    print(name)

def f2():

    name = 'eric'

    return f1

ret = f2()

ret()

输出结果：alex

作用域

# I/O多路复用概述：用来监听socket对象内部是否变化了

import socket

import select

sk = socket.socket()

sk.bind(('127.0.0.1',9999))

sk.listen(5)

while True:

    rlist,w,e = select.select([sk],[],[],1)  # select()内部监听socket对象，循环等1秒；无连接，一直循环下去;

    print(rlist)                                     # sk,sk1,sk2其中哪个变化，则r返回哪个值

# r = [sk,]         # r获取socket对象列表，可判断是否有新连接

# r = [sk1,]

# r = [sk1,sk2]     # 这两个同时连接，返回两个值

    for r in rlist:

        print(r)    # r获取socket对象列表，可判断是否有新链接

conn,addrs = r.accept()  # 接收客户端链接，Conn也是socket对象

conn.sendall(bytes('hello',encoding='utf-8'))

无限循环输出结果：

[<socket.socket fd=396, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9999)>]

<socket.socket fd=396, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9999)>

服务端

import socket

sk = socket.socket()

sk.connect(('127.0.0.1',9999,))

data = sk.recv(1024)

print(data)

while True:

    input('>>>')

sk.close()

客户端

# I/O多路复用伪并发实例

import socket

import select

sk = socket.socket()

sk.bind(('127.0.0.1',9999))

sk.listen(5)

inputs = [sk,]

while True:

    rlist,w,e = select.select([sk],[],[],1)

    print(len(inputs),len(rlist))

    for r in rlist:

        if r == sk:     # 新客户端来连接

            print(r)

            conn,addrs = r.accept()

            inputs.append(conn)  # 此处将新连接客户端添加到inputs列表中

            conn.sendall(bytes('hello', encoding='utf-8'))

        else:

            r.recv(1024)

服务端

import socket

sk = socket.socket()

sk.connect(('127.0.0.1',9999,))

data = sk.recv(1024)

print(data)

while True:

    input('>>>')

sk.close()

客户端

# 连接的客户端断开后，服务端进行抛出异常处理，并移除断开的客户端

import socket

import select

sk = socket.socket()

sk.bind(('127.0.0.1',9999))

sk.listen(5)

inputs = [sk,]

while True:

    rlist,w,e = select.select([sk],[],[],1)

    print(len(inputs),len(rlist))

    for r in rlist:

        if r == sk:     # 新客户端来连接

            print(r)

            conn,addrs = r.accept()

            inputs.append(conn)  # 此处将新连接客户端添加到inputs列表中

            conn.sendall(bytes('hello', encoding='utf-8'))

        else:

            print('==============')     # 有人给我发消息了

            try:

                ret = r.recv(1024)

                if not ret:

                    raise Exception('断开连接')     # 主动抛出异常

            except Exception as e:

                inputs.remove(r)    # 如果客户端突发断开连接，此处则移除断掉的客户端

服务端

import socket

sk = socket.socket()

sk.connect(('127.0.0.1',9999,))

data = sk.recv(1024)

print(data)

while True:

    input('>>>')

sk.close()

客户端

# I/O多路复用之读写分离(客户端发消息，服务端回发消息)

import socket

import select

sk = socket.socket()

sk.bind(('127.0.0.1',9999))

sk.listen(5)

inputs = [sk,]

outputs = []

while True:

    rlist,wlist,e = select.select(inputs,outputs,[],1)  # outputs表示所有客户端给服务端发的消息，outputs==wlist

    print(len(inputs),len(rlist),len(outputs),len(wlist))

    for r in rlist:

        if r == sk:     # 新客户端来连接

            print(r)

            conn,addrs = r.accept()

            inputs.append(conn)  # 此处将新连接客户端添加到inputs列表中

            conn.sendall(bytes('hello', encoding='utf-8'))

        else:

            print('==============')     # 有人给我发消息了

            try:

                ret = r.recv(1024)

                r.sendall(ret)

                if not ret:

                    raise Exception('断开连接')     # 主动抛出异常

                else:

                    outputs.append(r)

            except Exception as e:

                inputs.remove(r)    # 如果客户端突发断开连接，此处则移除断掉的客户端

    for w in wlist:     # 所有给我发消息的客户端

        w.sendall(bytes('response',encoding='utf-8'))

        outputs.remove(w)

服务端

import socket

sk = socket.socket()

sk.connect(('127.0.0.1',9998,))

data = sk.recv(1024)

print(data)

while True:

    inp = input('>>>')

    sk.sendall(bytes(inp,encoding='utf-8'))   # 客户端发消息，服务端回发消息

    print(sk.recv(1024))

sk.close()

客户端

import socket

sk = socket.socket()

sk.connect(('127.0.0.1',9998,))

data = sk.recv(1024)

print(data)

while True:

    inp = input('>>>')

    sk.sendall(bytes(inp,encoding='utf-8'))   # 客户端发消息，服务端回发消息

    print(sk.recv(1024))

sk.close()

客户端

import queue

q = queue.Queue(10)     # 创建一个先进先出队列，参数表示最多放10个数据

q.put(11)               # 依次把数据11，22，33放入队列

q.put(22)

q.put(33)

print(q.qsize())    # 输出队列元素个数，检测队列真实个数

print(q.get())      # 从队列取数据

print(q.get())

print(q.get())

输出结果：

3

11

22

33

-----------------------------------------------------------------------------------------

import queue

q = queue.Queue(10)     # 创建一个先进先出队列，参数表示最多放10个数据

q.put(11)               # 依次把数据11，22，33放入队列

q.put(22)

q.put(23)

q.put(24)

q.put(25)

print(q.qsize())    # 输出队列元素个数，检测队列真实个数

q.put(33,timeout=2)     # timeout表示超时时间，等2秒如果队列有位置加入，无位置则报错

q.put(34,block=False)   # 此处不再阻塞，直接报错

print(q.get())      # 从队列取数据

print(q.get())

print(q.get())

# print(q.get(block=False))    # 不再阻塞等待取数据，直接报错

# -----------------------------------------------------------------------------------------

import queue

q = queue.Queue()

q.put(123)

q.put(456)

q.get()

q.get()

q.task_done()   # 去除元素后，告诉队列当前任务已完成

# q.join()      # 表示如果队列任务没有完成，则等待

print('end')

# task_done()与join() 一般联合使用，当队列任务执行完毕，不再阻塞

# 线程锁

import threading

import time

NUM = 10

def func(lo):

    global NUM

    lo.acquire()    # 上锁，表示同一时刻只允许一个线程来操作

    NUM -= 1

    time.sleep(2)

    print(NUM)

    lo.release()    # 开锁

# lock = threading.Lock()     # 单层锁

lock = threading.RLock()    # 多层锁

for i in range(10):

    t = threading.Thread(target=func,args=(lock,))

    t.start()

# 信号量以及事件

# 事件：表示把线程全部锁上，再一次性放开工作，相当于红绿灯，线程是车辆

import threading

def func(i,e):

    print(i)

    e.wait()    # 全部线程停止到这里，这里检测是什么灯；默认是红灯

    print(i+100)

event = threading.Event()

for i in range(10):

    t = threading.Thread(target=func,args=(i,event))

    t.start()

event.clear()   # 表示全部停止，设置成红灯

inp = input('>>>:')

if inp == "":

    event.set() # 表示把上面停止的线程放行，设置成绿灯

输出结果：

0

1

2

3

4

5

6

7

8

9

>>>:1

102

104

109

106

105

100

103

107

101

108

# 条件以及定时器

# 第一种条件锁,线程等待输入条件，才能调用工作

import threading

def condition():

    ret = False

    r = input('>>>')

    if r == 'true':

        ret = True

    else:

        ret = False

    return ret

def func(i,con):

    print(i)

    con.acquire()

    con.wait()

    print(i+100)

    con.release()

c = threading.Condition()

for i in range(10):

    t = threading.Thread(target=func,args=(i,c,))

    t.start()

while True:         # 主线程

    inp = input('>>>')      # 输入几，就放出几个线程

    if inp == 'q':

        break

    c.acquire()

    c.notify(int(inp))

    c.release()

输出结果：

0

1

2

3

4

5

6

7

8

9

>>>1

>>>100

2

>>>101

102

3

>>>103

105

104

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

# 当满足某个条件时，才让线程一个一个出去

import threading

def condition():

    ret = False

    r = input('>>>')

    if r == 'true':

        ret = True

    else:

        ret = False

    return ret

def func(i,con):

    print(i)

    con.acquire()

    con.wait_for(condition)     # 等待某个条件成立，才执行。否则一直等待

    print(i+100)

    con.release()

c = threading.Condition()

for i in range(10):

    t = threading.Thread(target=func,args=(i,c,))

    t.start()

输出结果：

0

>>>1

2

3

4

5

6

7

8

9

true

>>>101

>>>true

102

>>>false

>>>

# 定时器

from threading import Timer

def hello():

    print("hello,world")

t = Timer(2,hello)      # 延迟2秒后执行hello()函数

t.start()

print('end')      # 此处立即打印后，再延迟2秒输出上面函数结果

# 流程：1.定义一个容器(最大个数)；2.取一个，少一个；3.无线程时等待；4. 线程执行完毕，交还线程；

# # 自定义线程池,每5个线程执行一次

import threading

import queue

import time

class Threadpool():

    def __init__(self,maxsize=5):       # 创建线程池，maxsize表示线程池最多有多少个线程

        self.maxsize = maxsize

        self._q = queue.Queue(maxsize)  # 队列此刻为空，最多放了5个元素，元素为类

        for i in range(maxsize):

            self._q.put(threading.Thread) # 表示把一个类名逐个放入线程池

    def get_thread(self):

        return self._q.get()        # 获取线程，取一个线程类，上面线程池少一个

    def add_thread(self):

        self._q.put(threading.Thread)   # 线程少一个时，又增加一个

pool = Threadpool(5)        # 创建线程池，最大个数为5个线程可以使用

def task(arg,p):        # 获取pool传递的参数，

    print(arg)

    time.sleep(1)

    p.add_thread()      # 表示任务执行完，再增加一个，这样会每5个任务并发执行一次

for i in range(100):    # 创建100个任务

    t = pool.get_thread() # 从线程池获取一个线程类

    obj = t(target=task,args=(i,pool))  # 获取一个线程对象，加pool参数，传递到task函数的参数p.

    obj.start()     # 执行

# 进程基本操作

# 多进程适用于linux

from multiprocessing import Process

from multiprocessing import Array

from multiprocessing import Manager  # 特殊的字典

import multiprocessing

# from multiprocessing import queues    # 特殊队列，能够让进程间数据共享；只能在linux运行

import threading

import time

def foo(i,arg):

    arg[i] = i+100

    for item in arg:

        print(item)

    print('=======================')

if __name__ == "__main__":

    li = Array('i',10)      # 这种方法不常用

    for i in range(10):

        p = Process(target=foo,args=(i,li))

        p.start()

 输出结果：

0

0

0

103

0

0

0

0

0

0

== == == == == == == == == == == =

0

0

102

103

0

0

0

0

0

0

== == == == == == == == == == == =

100

0

102

103

0

0

0

0

0

0

== == == == == == == == == == == =

100

0

102

103

104

0

0

0

0

0

== == == == == == == == == == == =

100

101

102

103

104

0

0

0

0

0

== == == == == == == == == == == =

100

101

102

103

104

0

106

0

0

0

== == == == == == == == == == == =

100

101

102

103

104

0

106

107

0

0

== == == == == == == == == == == =

100

101

102

103

104

0

106

107

108

0

== == == == == == == == == == == =

100

101

102

103

104

105

106

107

108

0

== == == == == == == == == == == =

100

101

102

103

104

105

106

107

108

109

== == == == == == == == == == == =

from multiprocessing import Process

from multiprocessing import Array

from multiprocessing import Manager  # 特殊的字典

import multiprocessing

# from multiprocessing import queues    # 特殊队列，能够让进程间数据共享；只能在linux运行

import threading

import time

def foo(i, arg):

    print('say hi',i)

    arg[i] = i + 100

    print(arg.values())

if __name__ == "__main__":

    # li = Array('i', 10)  # 这种方法不常用

    obj = Manager()

    li = obj.dict()        # 常用方法

    for i in range(10):

        p = Process(target=foo, args=(i, li))

        # p.daemon = True

        p.start()

        p.join()

    print('end')

输出结果：

say hi 0

[100]

say hi 1

[100, 101]

say hi 2

[100, 101, 102]

say hi 3

[100, 101, 102, 103]

say hi 4

[100, 101, 102, 103, 104]

say hi 5

[100, 101, 102, 103, 104, 105]

say hi 6

[100, 101, 102, 103, 104, 105, 106]

say hi 7

[100, 101, 102, 103, 104, 105, 106, 107]

say hi 8

[100, 101, 102, 103, 104, 105, 106, 107, 108]

say hi 9

[100, 101, 102, 103, 104, 105, 106, 107, 108, 109]

end

# 进程锁，所有的进程同时去执行同一任务

from multiprocessing import Process,queues

from multiprocessing import Array

from multiprocessing import RLock,Lock,Condition,Semaphore

import multiprocessing

import time

def foo(i,lis):

    lis[0] = lis[0] - 1

    time.sleep(1)

    print('say hi',lis[0])

if __name__ == "__main__":

    li = Array('i',1)

    li[0] = 10

    for i in range(10):

        p = Process(target=foo,args=(i,li))   # 创建10个进程，每个进程都去执行foo方法

        p.start()

输出结果：

say hi 0

say hi 0

say hi 0

say hi 0

say hi 0

say hi 0

say hi 0

say hi 0

say hi 0

say hi 0

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

# 创建进程锁，所有的进程逐个去执行同一任务

from multiprocessing import Process,queues

from multiprocessing import Array

from multiprocessing import RLock,Lock,Condition,Semaphore

import multiprocessing

import time

def foo(i,lis,lc):  # lc参数是接收下面线程中lock的参数

    lc.acquire()    # 加锁

    lis[0] = lis[0] - 1

    time.sleep(1)

    print('say hi',lis[0])

    lc.release()    # 释放锁

if __name__ == "__main__":

    li = Array('i',1)

    li[0] = 10

    lock = RLock()    # 创建进程锁，并传递给下面的lock参数

    for i in range(10):

        p = Process(target=foo,args=(i,li,lock))   # 创建10个进程，每个进程都去执行foo方法

        p.start()

输出结果：

say hi 9

say hi 8

say hi 7

say hi 6

say hi 5

say hi 4

say hi 3

say hi 2

say hi 1

say hi 0

# 协程

# 原理：利用一个线程，分解一个线程成为多个“微线程”(程序级别在做，与操作系统无关)

# greenlet    #本质上实现协程功能

# gevent      # 内部封装了底层功能greenlet,gevent是高级功能；是协程(高性能)，是人为创建，只限I/O请求

from greenlet import greenlet

def test1():

    print(12)

    gr2.switch()   # 切换作用

    print(34)

    gr2.switch()

def test2():

    print(56)

    gr1.switch()

    print(78)

gr1 = greenlet(test1)

gr2 = greenlet(test2)

gr1.switch()

输出结果：

12

56

34

78

协程切换操作

import gevent

def foo():

    print('Running in foo')

    gevent.sleep(0)     # 切换作用

    print('Explicit context switch to foo again')

def bar():

    print('Explicit context to bar')

    gevent.sleep(0)

    print('Implicit context switch back to bar')

gevent.joinall([            # 表示要执行下面两个协程

    gevent.spawn(foo),

    gevent.spawn(bar),

])

输出结果：

Running in foo

Explicit context to bar

Explicit context switch to foo again

Implicit context switch back to bar

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import Queue

import threading

message = Queue.Queue(10)

def producer(i):

    while True:

        message.put(i)

def consumer(i):

    while True:

        msg = message.get()

for i in range(12):

    t = threading.Thread(target=producer, args=(i,))

    t.start()

for i in range(10):

    t = threading.Thread(target=consumer, args=(i,))

    t.start()

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(

        host='10.211.55.4'))

channel = connection.channel()

channel.queue_declare(queue='hello')

def callback(ch, method, properties, body):

    print(" [x] Received %r" % body)

    import time

    time.sleep(10)

    print 'ok'

    ch.basic_ack(delivery_tag = method.delivery_tag)

channel.basic_consume(callback,

                      queue='hello',

                      no_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')

channel.start_consuming()

消费者

#!/usr/bin/env python

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(host='10.211.55.4'))

channel = connection.channel()

# make message persistent

channel.queue_declare(queue='hello', durable=True)

channel.basic_publish(exchange='',

                      routing_key='hello',

                      body='Hello World!',

                      properties=pika.BasicProperties(

                          delivery_mode=2, # make message persistent

                      ))

print(" [x] Sent 'Hello World!'")

connection.close()

生产者

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(host='10.211.55.4'))

channel = connection.channel()

# make message persistent

channel.queue_declare(queue='hello', durable=True)

def callback(ch, method, properties, body):

    print(" [x] Received %r" % body)

    import time

    time.sleep(10)

    print 'ok'

    ch.basic_ack(delivery_tag = method.delivery_tag)

channel.basic_consume(callback,

                      queue='hello',

                      no_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')

channel.start_consuming()

消费者

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(host='10.211.55.4'))

channel = connection.channel()

# make message persistent

channel.queue_declare(queue='hello')

def callback(ch, method, properties, body):

    print(" [x] Received %r" % body)

    import time

    time.sleep(10)

    print 'ok'

    ch.basic_ack(delivery_tag = method.delivery_tag)

channel.basic_qos(prefetch_count=1)

channel.basic_consume(callback,

                      queue='hello',

                      no_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')

channel.start_consuming()

消费者

#!/usr/bin/env python

import pika

import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(

        host='localhost'))

channel = connection.channel()

channel.exchange_declare(exchange='logs',

                         type='fanout')

message = ' '.join(sys.argv[1:]) or "info: Hello World!"

channel.basic_publish(exchange='logs',

                      routing_key='',

                      body=message)

print(" [x] Sent %r" % message)

connection.close()

发布者

#!/usr/bin/env python

import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(

        host='localhost'))

channel = connection.channel()

channel.exchange_declare(exchange='logs',

                         type='fanout')

result = channel.queue_declare(exclusive=True)

queue_name = result.method.queue

channel.queue_bind(exchange='logs',

                   queue=queue_name)

print(' [*] Waiting for logs. To exit press CTRL+C')

def callback(ch, method, properties, body):

    print(" [x] %r" % body)

channel.basic_consume(callback,

                      queue=queue_name,

                      no_ack=True)

channel.start_consuming()

订阅者

#!/usr/bin/env python

import pika

import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(

        host='localhost'))

channel = connection.channel()

channel.exchange_declare(exchange='direct_logs',

                         type='direct')

result = channel.queue_declare(exclusive=True)

queue_name = result.method.queue

severities = sys.argv[1:]

if not severities:

    sys.stderr.write("Usage: %s [info] [warning] [error]\n" % sys.argv[0])

    sys.exit(1)

for severity in severities:

    channel.queue_bind(exchange='direct_logs',

                       queue=queue_name,

                       routing_key=severity)

print(' [*] Waiting for logs. To exit press CTRL+C')

def callback(ch, method, properties, body):

    print(" [x] %r:%r" % (method.routing_key, body))

channel.basic_consume(callback,

                      queue=queue_name,

                      no_ack=True)

channel.start_consuming()

消费者

#!/usr/bin/env python

import pika

import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(

        host='localhost'))

channel = connection.channel()

channel.exchange_declare(exchange='direct_logs',

                         type='direct')

severity = sys.argv[1] if len(sys.argv) > 1 else 'info'

message = ' '.join(sys.argv[2:]) or 'Hello World!'

channel.basic_publish(exchange='direct_logs',

                      routing_key=severity,

                      body=message)

print(" [x] Sent %r:%r" % (severity, message))

connection.close()

生产者

发送者路由值              队列中

old.boy.python          old.*  -- 不匹配

old.boy.python          old.#  -- 匹配

#!/usr/bin/env python

import pika

import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(

        host='localhost'))

channel = connection.channel()

channel.exchange_declare(exchange='topic_logs',

                         type='topic')

result = channel.queue_declare(exclusive=True)

queue_name = result.method.queue

binding_keys = sys.argv[1:]

if not binding_keys:

    sys.stderr.write("Usage: %s [binding_key]...\n" % sys.argv[0])

    sys.exit(1)

for binding_key in binding_keys:

    channel.queue_bind(exchange='topic_logs',

                       queue=queue_name,

                       routing_key=binding_key)

print(' [*] Waiting for logs. To exit press CTRL+C')

def callback(ch, method, properties, body):

    print(" [x] %r:%r" % (method.routing_key, body))

channel.basic_consume(callback,

                      queue=queue_name,

                      no_ack=True)

channel.start_consuming()

消费者

消费者

#!/usr/bin/env python

import pika

import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(

        host='localhost'))

channel = connection.channel()

channel.exchange_declare(exchange='topic_logs',

                         type='topic')

routing_key = sys.argv[1] if len(sys.argv) > 1 else 'anonymous.info'

message = ' '.join(sys.argv[2:]) or 'Hello World!'

channel.basic_publish(exchange='topic_logs',

                      routing_key=routing_key,

                      body=message)

print(" [x] Sent %r:%r" % (routing_key, message))

connection.close()

生产者

生产者

下载

        http://dev.mysql.com/downloads/mysql/

安装

        windows:

            点点点

        Linux:

            yum install mysql-server

        Mac:

            点点点

MySQL Community Server 5.7.16

http://dev.mysql.com/downloads/mysql/

cd c:\mysql-5.7.16-winx64\bin

mysqld --initialize-insecure

# 进入可执行文件目录

cd c:\mysql-5.7.16-winx64\bin

# 启动MySQL服务

mysqld

# 进入可执行文件目录

cd c:\mysql-5.7.16-winx64\bin

# 连接MySQL服务器

mysql -u root -p

# 提示请输入密码，直接回车

yum install mysql-server　

mysql.server start

连接：

    mysql -h host -u user -p

    常见错误：

        ERROR 2002 (HY000): Can't connect to local MySQL server through socket '/tmp/mysql.sock' (2), it means that the MySQL server daemon (Unix) or service (Windows) is not running.

退出：

    QUIT 或者 Control+D

SHOW DATABASES;

# utf-8

CREATE DATABASE 数据库名称 DEFAULT CHARSET utf8 COLLATE utf8_general_ci;

# gbk

CREATE DATABASE 数据库名称 DEFAULT CHARACTER SET gbk COLLATE gbk_chinese_ci;

USE db_name;

创建用户

    create user '用户名'@'IP地址' identified by '密码';

删除用户

    drop user '用户名'@'IP地址';

修改用户

    rename user '用户名'@'IP地址'; to '新用户名'@'IP地址';;

修改密码

    set password for '用户名'@'IP地址' = Password('新密码')

PS：用户权限相关数据保存在mysql数据库的user表中，所以也可以直接对其进行操作（不建议）

show grants for '用户'@'IP地址'                  -- 查看权限

grant  权限 on 数据库.表 to   '用户'@'IP地址'      -- 授权

revoke 权限 on 数据库.表 from '用户'@'IP地址'      -- 取消权限