weixin_49729516的博客

#实现delimiter //create PROCEDURE p5( OUT p_return_code tinyint)BEGIN DECLARE exit handler for sqlexception BEGIN -- ERROR set p_return_code = 1; rollback; END; DECLARE exit handler for sqlwarning

存储过程包含了一系列可执行的sql语句，存储过程存放于MySQL中，通过调用它的名字可以执行其内部的一堆sql程序与数据库结合使用的三种方式：方式一： Python:调用存储过程 MySQL:编写存储过程方式二： Python：编写纯生SQL MySQL： 方式三： Python：ORM->纯生SQL MySQL：#1、无参存储过程 delimiter // create procedure p1() BEGIN select * from db7.teache

触发器就是用户自定义对表进行【增、删、改】操作时前后的行为，注意：没有查询创建触发器# 插入前CREATE TRIGGER tri_before_insert_tb1 BEFORE INSERT ON tb1 FOR EACH ROWBEGIN ...END# 插入后CREATE TRIGGER tri_after_insert_tb1 AFTER INSERT ON tb1 FOR EACH ROWBEGIN ...END# 删除前CREATE TRIGGER

视图是一个虚拟表，根据SQL语句获取表（可以进行命名），用户使用时只需使用名称即可获取，可以将该结果当做表来使用。mysql> select * from employee;+----+------------+--------+------+--------+| id | name | sex | age | dep_id |+----+------------+--------+------+--------+| 1 | egon | male |

pymysql模块之sql注入# pip3 install pymysqlimport pymysqluser = input('user>>: ').strip()pwd = input('password>>: ').strip()# 建立链接conn = pymysql.connect( host='localhost', user='root', password='', db='db9', charset='ut.

授权表user 该表放行的权限，针对：所有数据，所有库下所有表，以及表下的所有字段db 该表放行的权限，针对：某一数据库，该数据库下的所有表，以及表下的所有字段tables_priv 该表放行的权限。针对：某一张表，以及该表下的所有字段columns_priv 该表放行的权限，针对：某一个字段1、创建账号# 本地账号create user 'winnie1'@'localhost' identified by '123'; # mysql -uwinnie1 -p123# 远

内连接：只取两张表的共同部分左连接:在内连接的基础上保留左表的记录右连接：在内连接的基础上保留右表的记录全外连接：在内连接的基础上保留左右两表没有对应关系的记录准备表#建表create table department(id int,name varchar(20) );create table employee(id int primary key auto_increment,name varchar(20),sex enum('male','female') not n.

单表查询的语法：select distinct 字段1,字段2,字段3 from 库.表 where 条件 group by 分组条件 having 过滤 order by 排序字段 limit n;关键字的执行优先级fromwheregroup byhavingselectdistinctorder bylimit练习company.employee 员工id id int 姓名

两张表之间的关系：1、多对一出版社 书2、多对多作者 —> 书allen —> 九阳神功、 九阴真经winnie —> 九阳神功、葵花宝典Yoo —> 独孤九剑、降龙十巴掌、葵花宝典zyp —> 九阳神功3、一对一customer表 student表...

约束条件not null与defaultmysql> create table t16( -> id int, -> name char(6), -> sex enum('male','female') not null default 'male' -> );Query OK, 0 rows affected (0.35 sec)mysql> insert into t16(id,name) values(1,'vivian.

mysql> create table consumer( -> id int, -> name char(16), -> sex enum('male','female','other'), -> level enum('vip1','vip2','vip3'), -> hobbies set('play','music','read','run') -> );Query OK, 0 rows affected (

char:定长varchar：变长mysql> create table t13(name char(5));Query OK, 0 rows affected (0.23 sec)mysql> insert into t13 values('李杰 '); # 李杰+空格Query OK, 1 row affected (0.04 sec)mysql> select * from t13;+------+| name |+------+| 李杰 |+-----

create table student( id int, name char(6), born_year year, birth_date date, class_time time, reg_time datetime);insert into student values(1,'winnie',now(),now(),now(),now());insert into student values(2,'allen',"1997","1997-12-12","12:12:12"

1、什么是存储引擎？存储引擎就是表的类型2、查看MySQL支持的存储引擎show engines;3、指定表类型/存储引擎create table t1(id int)engine=innodb;create table t2(id int)engine=memory;create table t3(id int)engine=blackhole;create table t4(id int)engine=myisam;insert into t1 values(1);insert

操作文件夹（库）增 create database db1 charset utf8;查 show create database db1; show databases;改 alter database db1 charset gbk;删 drop database db1;操作文件（表）切换文件夹：use db1;查看当前所在文件夹：select database();增 create table t1(id int,name char);查 show cr.

1、数据库服务器：运行数据库管理软件的计算机2、数据库管理软件：mysql，oracle，db2，slqserver3、库：文件夹4、表:文件5、记录：事物一系列典型的特征：winnie,female,18,girl6、数据：描述事物特征的符号...

阻塞IOblocking IO的特点就是在IO执行的两个阶段（等待数据和拷贝数据两个阶段）都被block了# 服务端from socket import *from threading import Threaddef communicate(conn): while True: try: data = conn.recv(1024) if not data: break conn.send(.

gevent实现并发的套接字通信

Gevent 是一个第三方库，可以轻松通过gevent实现并发同步或异步编程，在gevent中用到的主要模式是Greenlet，它是以C扩展模块形式接入Python的轻量级协程。 Greenlet全部运行在主程序操作系统进程的内部，但它们被协作式地调度。import timefrom gevent import monkey;monkey.patch_all()import geventdef eat(name): print('%s eat 1' % name) time.s

如果我们在单个线程内有多个任务，要想实现在多个任务之间切换，使用yield生成器的方式过于麻烦（需要先得到初始化一次的生成器，然后再调用send，非常麻烦），而使用greenlet模块可以非常简单地实现这多个任务直接的切换import timefrom greenlet import greenletdef eat(name): print('%s eat 1' % name) time.sleep(10) g2.switch('winnie') print('%

协程概念：单线程实现并发在应用程序里控制多个任务的切换+保存状态优点： 应用程序级别速度要远远高于操作系统的切换缺点： 多个任务一旦有一个阻塞没有切，整个线程都阻塞在原地 该线程内的其他的任务都不能执行了 一旦引入协程，就需要检测单线程下所有的IO行为, 实现遇到IO就切换,少一个都不行，以为一旦一个任务阻塞了，整个线程就阻塞了， 其他的任务即便是可以计算，但是也无法运行了2、协程序的目的：想要在单线程下实现并发并发指的是多个任务看起来是同时运行的并发=切换..

服务端from socket import *from threading import Threaddef communicate(conn): while True: try: data = conn.recv(1024) if not data: break conn.send(data.upper()) except ConnectionResetError:

提交任务的两种方式：同步调用：提交完任务后，就在原地等待任务执行完毕，拿到结果，再执行下一行代码，程序是串行执行import randomimport timefrom concurrent.futures import ThreadPoolExecutordef la(name): print('%s is laing' % name) time.sleep(random.randint(3, 5)) res = random.randint(7, 13) * '

concurrent.futures模块提供了高度封装的异步调用接口ThreadPoolExecutor：线程池，提供异步调用ProcessPoolExecutor: 进程池，提供异步调用submit(fn, *args, **kwargs)异步提交任务shutdown(wait=True) 相当于进程池的pool.close()+pool.join()操作import osimport randomimport timefrom concurrent.futures import Proc

先进先出->队列import queueq = queue.Queue(3) # 先进先出->队列q.put('first')q.put(2)q.put('third')# q.put(4,block=False) #q.put_nowait(4)# q.put(4, block=True, timeout=3)print(q.get())print(q.get())print(q.get())# print(q.get(block=False)) # print

定时器，指定n秒后执行某操作from threading import Timerdef task(name): print('hello %s' % name)t = Timer(5, task, args=('allen',))t.start()结果：hello allenfrom threading import Timerimport randomclass Code: def __init__(self): self.make_cac

event.isSet()：返回event的状态值；event.wait()：如果 event.isSet()==False将阻塞线程；event.set()： 设置event的状态值为True，所有阻塞池的线程激活进入就绪状态， 等待操作系统调度；event.clear()：恢复event的状态值为False。import timefrom threading import Thread, Eventevent = Event()# event.wait()# event.set()

Semaphore管理一个内置的计数器， 每当调用acquire()时内置计数器-1； 调用release() 时内置计数器+1； 计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。import randomimport timefrom threading import Thread, Semaphore, currentThreadsm = Semaphore(3)def task(): # sm.acquire() # p

所谓死锁： 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程，如下就是死锁import timefrom threading import Thread, LockmutexA = Lock()mutexB = Lock()class MyThread(Thread): def run(self): self.f1()

GIL全局解释器锁，每个线程在执行的过程中都需要先获取GIL，保证同一时刻只有一个线程在运行，目的是解决多线程同时竞争程序中的全局变量而出现的线程安全问题。计算密集型：用多进程import osimport timefrom multiprocessing import Processfrom threading import Threaddef work(): res = 0 for i in range(10000): res *= iif __

import timefrom threading import Threadn = 100def task(): global n # mutex.acquire() temp = n time.sleep(0.1) n = temp - 1 # mutex.release()if __name__ == '__main__': # mutex = Lock() t_1 = [] for i in range(100

单线程：import timefrom threading import Threaddef sayhi(name): time.sleep(2) print('%s say hello' % name)if __name__ == '__main__': t = Thread(target=sayhi, args=('allen',)) # t.setDaemon(True) # 必须在t.start()之前设置 t.daemon = True

Thread实例对象的方法isAlive(): 返回线程是否活动的。getName(): 返回线程名。setName(): 设置线程名。threading模块提供的一些方法threading.currentThread(): 返回当前的线程变量。threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。threading.activeCount(): 返回正在运行的线程数量，与len(threading.

开进程的开销远大于开线程import timefrom multiprocessing import Processfrom threading import Threaddef piao(name): print('%s piaoing' % name) time.sleep(2) print('%s piao end' % name)if __name__ == '__main__': # p1 = Process(target=piao, args.

方法一：import randomimport timefrom threading import Threaddef piao(name): print('%s piaoing' % name) time.sleep(random.randrange(1, 5)) print('%s piao end' % name)if __name__ == '__main__': t1 = Thread(target=piao, args=('allen',))

在传统操作系统中，每个进程有一个地址空间，而且默认就有一个控制线程线程顾名思义，就是一条流水线工作的过程，一条流水线必须属于一个车间，一个车间的工作过程是一个进程车间负责把资源整合到一起，是一个资源单位，而一个车间内至少有一个流水线流水线的工作需要电源，电源就相当于cpu所以，进程只是用来把资源集中到一起（进程只是一个资源单位，或者说资源集合），而线程才是cpu上的执行单位。多线程（即多个控制线程）的概念是，在一个进程中存在多个控制线程，多个控制线程共享该进程的地址空间，相当于一个车间内有多条流水

服务端：server.pyfrom multiprocessing import Processfrom socket import *def talk(conn): while True: try: data = conn.recv(1024) if not data: break conn.send(data.upper()) except ConnectionResetError

什么是生产者消费者模式生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。例：import timefrom multiprocessing import Queue, Processdef producer(q): for i in range(

进程彼此之间互相隔离，要实现进程间通信（IPC），multiprocessing模块支持两种形式：队列和管道，这两种方式都是使用消息传递的from multiprocessing import Queueq = Queue(3) # 队列中允许最大项数q.put('hello') # 用以插入数据到队列中q.put({'a': 1})q.put([1, 2, 3])print(q.full()) # 调用此方法时q已满则返回Trueprint(q.get()) # 可以从队列读取并

进程之间数据不共享，但是共享同一套文件系统，所以访问同一文件，或同一打印终端，是没有问题的，而共享带来的是竞争，竞争带来的结果就是错乱，如何控制，就是加锁处理。例1：多个进程共享同一个打印终端并发运行效率高，但竞争同一个打印终端，带来了打印错乱import timefrom multiprocessing import Processdef task(name): print('%s 1' % name) time.sleep(1) print('%s 2' %