1. 并发编程：线程、进程、队列、IO多路模型
  2.  
  3. 操作系统工作原理介绍、线程、进程演化史、特点、区别、互斥锁、信号、
  4. 事件、join、GIL、进程间通信、管道、队列。
  5.  
  6. 生产者消息者模型、异步模型、IO多路复用模型、select\poll\epoll 高性
  7. 能IO模型源码实例解析、高并发FTP server开发

1、请写一个包含10个线程的程序，主线程必须等待每一个子线程执行完成之后才结束执行，每一个子线程执行的时候都需要打印当前线程名、当前活跃线程数量；

  1. from threading import Thread,currentThread,activeCount
  2. import time
  3. def task(n):
  4.     print('线程名：%s----%s'%(currentThread().name,n))
  5.     time.sleep(1)
  6.     print('数量：%s'%activeCount())
  7.     
  8. if __name__ == "__main__":
  9.     t_li = []
  10.     for i in range(10):
  11.         t = Thread(target=task,args=(i,))
  12.         t.start()
  13.         t_li.append(t)
  14.     for t in t_li:
  15.         t.join()
  16.         
  17.     print('主,end----')

2、请写一个包含10个线程的程序，并给每一个子线程都创建名为”name”的线程私有变量，变量值为“james”；

  1. from threading import Thread
  2. def task(name):
  3.     print('%s is running'%name)
  4.     print('end ---')
  5.     
  6. if __name__ == "__main__":
  7.     for i in range(10):
  8.         t = Thread(target=task,args=('james_%s'%i,))
  9.         t.start()
  10.         
  11.     print('主 end ---')

3、请使用协程写一个消费者生产者模型；

  1. def consumer():
  2.     while True:
  3.         x = yield
  4.         print('消费:', x)
  5.         
  6. def producter():
  7.     c = consumer()
  8.     next(c)
  9.     for i in range(10):
  10.         print('生产:', i)
  11.         c.send(i)
  12.         
  13. producter()

4、写一个程序，包含十个线程，子线程必须等待主线程sleep 10秒钟之后才执行，并打印当前时间；

  1. from threading import Thread,Event
  2. import time
  3. import datetime
  4. def task():
  5.     # while not event.is_set():
  6.     #     print('...')
  7.     print('...')
  8.     event.wait(10)
  9.     print('time:',datetime.datetime.now())
  10.     
  11. if __name__ == '__main__':
  12.     event = Event()
  13.     for i in range(10):
  14.         t = Thread(target=task)
  15.         t.start()
  16.         
  17.     time.sleep(10)
  18.     event.set()

5、写一个程序，包含十个线程，同时只能有五个子线程并行执行；

  1. from threading import Thread,Semaphore,currentThread
  2. import time
  3. def task(n):
  4.     sm.acquire()
  5.     print('%s---'%n,currentThread().name)
  6.     time.sleep(1)
  7.     print('end----')
  8.     sm.release()
  9.     
  10. if __name__ == '__main__':
  11.     sm = Semaphore(5)
  12.     for i in range(10):
  13.         t = Thread(target=task,args=(i,))
  14.         t.start()

6、写一个程序 ，包含一个名为hello的函数，函数的功能是打印字符串“Hello, World!”，该函数必须在程序执行30秒之后才开始执行(不能使用time.sleep())；

  1. from threading import Timer
  2. def hello(name):
  3.     print('%s say '%name,'Hello World!')
  4.     
  5. if __name__ == "__main__":
  6.     t = Timer(5,hello,args=('james',))
  7.     t.start()

7、写一个程序，利用queue实现进程间通信；

  1. from multiprocessing import Process,Queue,current_process
  2. import time
  3. def consumer(q):
  4.     while True:
  5.         res = q.get()
  6.         if not res:break
  7.         print('消费了：',res,'--',current_process().name)
  8.         
  9. def producter(q):
  10.     for i in range(5):
  11.         print('生产:',i)
  12.         time.sleep(1)
  13.         q.put(i)
  14.         
  15. if __name__ == "__main__":
  16.     q = Queue()
  17.     p1 = Process(target=producter,args=(q,))
  18.     c1 = Process(target=consumer,args=(q,))
  19.     c2 = Process(target=consumer,args=(q,))
  20.     p1.start()
  21.     c1.start()
  22.     c2.start()
  23.   
  24.     p1.join()
  25.     q.put(None)
  26.     q.put(None)
  27.     print('主')
  28.     
  29. # JoinableQueue
  30. from multiprocessing import Process,JoinableQueue,current_process
  31. import time
  32. def consumer(q):
  33.     while True:
  34.         res = q.get()
  35.         print('消费了：',res,'--',current_process().name)
  36.         q.task_done()
  37.         
  38. def producter(q):
  39.     for i in range(5):
  40.         print('生产:',i,'--',current_process().name)
  41.         time.sleep(1)
  42.         q.put(i)
  43.     q.join()
  44.     
  45. if __name__ == "__main__":
  46.     q = JoinableQueue()
  47.     p1 = Process(target=producter,args=(q,))
  48.     p2 = Process(target=producter, args=(q,))
  49.     c1 = Process(target=consumer,args=(q,))
  50.     c2 = Process(target=consumer,args=(q,))
  51.     p1.start()
  52.     p2.start()
  53.     
  54.     c1.daemon = True
  55.     c2.daemon = True
  56.     c1.start()
  57.     c2.start()
  58.     
  59.     p1.join()
  60.     p2.join()
  61.     print('主')

8、写一个程序，利用pipe实现进程间通信；

  1. from multiprocessing import Process,Pipe
  2. def task(conn):
  3.     conn.send('hello world')
  4.     conn.close()
  5.     
  6. if __name__ == "__main__":
  7.     parent_conn,child_conn = Pipe()
  8.     p = Process(target=task,args=(child_conn,))
  9.     p.start()
  10.     p.join()
  11.     print(parent_conn.recv())

9、使用selectors模块创建一个处理客户端消息的服务器程序；

  1. # server  blocking IO  
  2. import socket
  3. server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
  4. server.bind(('127.0.0.1',8080))
  5. server.listen(5)
  6. while True:
  7.     conn,addr = server.accept()
  8.     print(addr)
  9.     while True:
  10.         try:
  11.             data = conn.recv(1024)
  12.             if not data: break
  13.             conn.send(data.upper())
  14.         except Exception as e:
  15.             print(e)
  16.             break
  17.             
  18. # server  IO多路复用 selectors 会根据操作系统选择select poll epoll           
  19. import socket
  20. import selectors
  21. sel = selectors.DefaultSelector()
  22. def accept(server_fileobj,mask):
  23.     conn,addr = server_fileobj.accept()
  24.     print(addr)
  25.     sel.register(conn,selectors.EVENT_READ,read)
  26.     
  27. def read(conn,mask):
  28.     try:
  29.         data = conn.recv(1024)
  30.         if not data:
  31.             print('closing..',conn)
  32.             sel.unregister(conn)
  33.             conn.close()
  34.             return
  35.         conn.send(data.upper())
  36.     except Exception:
  37.         print('closeing...',conn)
  38.         sel.unregister(conn)
  39.         conn.close()
  40.         
  41. server_fileobj = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
  42. server_fileobj.bind(('127.0.0.1',8080))
  43. server_fileobj.listen(5)
  44. server_fileobj.setblocking(False)
  45. sel.register(server_fileobj,selectors.EVENT_READ,accept)
  46. while True:
  47.     events = sel.select()
  48.     for sel_obj,mask in events:
  49.         callback = sel_obj.data
  50.         callback(sel_obj.fileobj,mask)
  51.         
  52. # client
  53. # -*- coding:utf-8 -*-
  54. import socket
  55. client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
  56. client.connect(('127.0.0.1',8080))
  57. while True:
  58.     msg = input('>>>:').strip()
  59.     if not msg:continue
  60.     client.send(msg.encode('utf-8'))
  61.     data = client.recv(1024)
  62.     print(data.decode('utf-8'))

10、使用socketserver创建服务器程序时，如果使用fork或者线程服务器，一个潜在的问题是，恶意的程序可能会发送大量的请求导致服务器崩溃，请写一个程序，避免此类问题；

  1. # server socketserver 模块内部使用IO多路复用 和多进程/多线程
  2. import socketserver
  3. class Handler(socketserver.BaseRequestHandler):
  4.     def handle(self):
  5.         print('new connection:',self.client_address)
  6.         while True:
  7.             try:
  8.                 data = self.request.recv(1024)
  9.                 if not data:break
  10.                 print('client data:',data.decode())
  11.                 self.request.send(data.upper())
  12.             except Exception as e:
  13.                 print(e)
  14.                 break
  15.                 
  16. if __name__ == "__main__":
  17.     server = socketserver.ThreadingTCPServer(('127.0.0.1',8080),Handler)
  18.     server.serve_forever()

11、请使用asyncio实现一个socket服务器端程序；

 

  1. 1、数据库介绍、类型、特性
  2. 2、MySQL数据库安装、连接、启动、停止
  3. 3、表字段类型介绍、主键约束、表创建语句
  4. 4、常用增删改查语句、分组、聚合
  5. 5、外键管理、unique字段、表结构修改语法
  6. 6、跨表查询，inner join、left join、right join、full join语法
  7. 7、复杂SQL语句如group by、子查询、函数的使用
  8. 8、索引原理及作用、普通索引、多列索引、唯一索引、全文索引等
  9. 9、基于hash&b+树索引的实现原理，索引的优缺点剖析
  10. 10、事务原理，ACID特性，应用场景讲解
  11. 11、事务回滚
  12. 12、触发器的特性，应用场景
  13. 13、触发器的增删改查方法
  14. 14、存储过程的作用及应用场景
  15. 15、创建存储过程，参数传递，流程控制语句if\while\repeat\loop等，动态SQL的创建
  16. 16、视图的作用及使用场景，视图的增删改查
  17. 17、数据库权限管理，用户管理
  18. 18、数据库备份命令及工具讲解
  19. 19、基于不同业务的数据库表结构设计、性能优化案例
  20. 20、pymysql模块介绍和使用
  1. 语法：
  2. 1. 修改表名
  3.       ALTER TABLE 表名 
  4.                           RENAME 新表名;
  5.  
  6. 2. 增加字段
  7.       ALTER TABLE 表名
  8.                           ADD 字段名  数据类型 [完整性约束条件…],
  9.                           ADD 字段名  数据类型 [完整性约束条件…];
  10.       ALTER TABLE 表名
  11.                           ADD 字段名  数据类型 [完整性约束条件…]  FIRST;
  12.       ALTER TABLE 表名
  13.                           ADD 字段名  数据类型 [完整性约束条件…]  AFTER 字段名;
  14.  
  15. 3. 删除字段
  16.       ALTER TABLE 表名 
  17.                           DROP 字段名;
  18.  
  19. 4. 修改字段
  20.       ALTER TABLE 表名 
  21.                           MODIFY  字段名 数据类型 [完整性约束条件…];
  22.       ALTER TABLE 表名 
  23.                           CHANGE 旧字段名 新字段名 旧数据类型 [完整性约束条件…];
  24.       ALTER TABLE 表名 
  25.                           CHANGE 旧字段名 新字段名 新数据类型 [完整性约束条件…];

　　

1、创建一个表student，包含ID(学生学号)，sname(学生姓名)，gender(性别)，credit(信用卡号),四个字段，要求：ID是主键，且值自动递增，sname是可变长字符类型，gender是枚举类型, credit是可变长字符类型；

  1. create table student(
  2.     ID int primary key auto_increment,
  3.     sname varchar(16) not null,
  4.     gender enum('male','female') not null default 'female',
  5.     credit varchar(32)
  6. );

　　

2、在上面的student表中增加一个名为class_id的外键，外键引用class表的cid字段；

  1. create table class(
  2.     cid int primary key auto_increment,
  3.     cname varchar(16) not null
  4. );
  5.   
  6. alter table student add class_id int not null;
  7. alter table student add foreign key(class_id) references class(cid) on delete cascade on update cascade;

　　

3、向该表新增一条数据，ID为1，学生姓名为alex，性别女，修改ID为1的学生姓名为wupeiqi，删除该数据；

  1. insert into class(cname) values
  2. ('一班'),
  3. ('二班');
  4. insert into student values(1,'alex','female','12345',1);
  5. update student set sname = 'wupeiqi' where id = 1;
  6. delete from student where id = 1;

　　

4、查询student表中，每个班级的学生数；

  1. insert into student(sname,class_id) values
  2. ('james',1),
  3. ('durant',2),
  4. ('curry',3); 
  5. select count(ID) from student;

　　

5、修改credit字段为unique属性；

  1. alter table student modify credit varchar(32) not null unique;

　　

6、请使用命令在你本地数据库中增加一个用户，并给该用户授予创建表的权限；

  1. grant create on *.* to 'james'@'localhost' identified by '123';

　　

7、请使用pymsql模块连接你本地数据库，并向student表中插入一条数据；

  1. # -*- coding:utf-8 -*-
  2. import pymysql
  3. conn = pymysql.connect(
  4.     host = '127.0.0.1',
  5.     port = 3306,
  6.     user = 'root',
  7.     password = '123',
  8.     db = 'db_bj',
  9.     charset = 'utf8'
  10. )
  11. cursor = conn.cursor()
  12. sql = 'insert into student(sname,credit,class_id) values (%s,%s,%s)'
  13. rows = cursor.execute(sql,('alcie','1234567',1))
  14.     
  15. conn.commit()
  16. cursor.close()
  17. conn.close()
  18.     
  19. if rows:
  20.     print('success')
  21. else:
  22.     print('failed')

　　

8、请使用mysqldump命令备份student表；

  1. mysqldump -uroot -p123 db_bj student > /home/bj/桌面/myfile/student.sql

　　

9、创建一张名为student_insert_log的表，要求每次插入一条新数据到student表时，都向student_insert_log表中插入一条记录，记录student_id, insert_time;

  1. mysql> desc student;
  2. +----------+-----------------------+------+-----+---------+----------------+
  3. | Field    | Type                  | Null | Key | Default | Extra          |
  4. +----------+-----------------------+------+-----+---------+----------------+
  5. | ID       | int(11)               | NO   | PRI | NULL    | auto_increment |
  6. | sname    | varchar(16)           | NO   |     | NULL    |                |
  7. | gender   | enum('male','female') | NO   |     | female  |                |
  8. | credit   | varchar(32)           | NO   | UNI | NULL    |                |
  9. | class_id | int(11)               | NO   | MUL | NULL    |                |
  10. +----------+-----------------------+------+-----+---------+----------------+
  11.   
  12. create table student_insert_log(
  13.     student_id int not null,
  14.     insert_time datetime not null
  15. );
  16.     
  17. 创建一个触发器：
  18. delimiter //
  19. create trigger tri_after_insert_student after insert on student for each row
  20. begin
  21.     insert into student_insert_log values(new.ID,now());
  22. end //
  23. delimiter ;
  24.     
  25. insert into student(sname,credit,class_id) values ('alice','123',2);
  26. insert into student(sname,credit,class_id) values 
  27. ('egon1','1234',1),
  28. ('egon2','12345',2);
  29.     
  30. mysql> select * from student;
  31. +----+-------+--------+---------+----------+
  32. | ID | sname | gender | credit  | class_id |
  33. +----+-------+--------+---------+----------+
  34. |  4 | alcie | female | 123456  |        1 |
  35. |  7 | alcie | female | 1234567 |        1 |
  36. |  8 | alice | female | 123     |        2 |
  37. |  9 | egon1 | female | 1234    |        1 |
  38. | 10 | egon2 | female | 12345   |        2 |
  39. +----+-------+--------+---------+----------+
  40.     
  41. mysql> select * from student_insert_log;
  42. +------------+---------------------+
  43. | student_id | insert_time         |
  44. +------------+---------------------+
  45. |          8 | 2018-04-24 21:29:46 |
  46. |          9 | 2018-04-24 21:32:05 |
  47. |         10 | 2018-04-24 21:32:05 |
  48. +------------+---------------------+
  49. 10、创建一张名为student_update_log的表，要求每次更新student表中的记录时，都向student_update_log表中插入一条记录，记录student_id, update_time;
  50. create table student_update_log(
  51.     student_id int not null,
  52.     update_time datetime
  53. );  
  54.     
  55. 创建一个触发器
  56. delimiter //
  57. create trigger tri_after_update_student after update on student for each row
  58. begin
  59.     insert into student_update_log values(new.ID,now());
  60. end //
  61. delimiter ;
  62.     
  63. show triggers\G;
  64.     
  65. update student set sname = 'alex' where ID in (9,10);
  66. mysql> select * from student;
  67. +----+-------+--------+---------+----------+
  68. | ID | sname | gender | credit  | class_id |
  69. +----+-------+--------+---------+----------+
  70. |  4 | alcie | female | 123456  |        1 |
  71. |  7 | alcie | female | 1234567 |        1 |
  72. |  8 | alice | female | 123     |        2 |
  73. |  9 | alex  | female | 1234    |        1 |
  74. | 10 | alex  | female | 12345   |        2 |
  75. +----+-------+--------+---------+----------+
  76. 5 rows in set (0.00 sec)
  77.     
  78. mysql> select * from student_update_log;
  79. +------------+---------------------+
  80. | student_id | update_time         |
  81. +------------+---------------------+
  82. |          9 | 2018-04-24 21:47:24 |
  83. |         10 | 2018-04-24 21:47:24 |
  84. +------------+---------------------+

　　

版权声明：本文为wj-1314原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/wj-1314/p/9214440.html