2020年08月_Pinkman2k

原创 102 SQL基础语句

1、库操作=》文件夹-创建库：create database db1 charset utf8mb4;-显示所有库：show databases;show database db1;-改db1的字符编码格式：alter database db1 charset gbk;-删库：drop database db1;2、表操作=》文件-创建库：create database db1;-切换到db1库：use db1;-查看当前库：select database();-创建表：cre

2020-08-31 20:06:13 103

原创 101 Mysql 入门

day42mysql数据库1、定义数据库管理软件,本质就是一个套接字程序2、组成部分及相关概念字段 => 表的标题记录 => 文件中的一行内容表 => 文件库 => 文件夹数据库管理软件 => 套接字软件数据库服务器 => 运行有数据库管理软件服务端的计算机3、关系型及非关系型关系型: oracle db2 sqlserver mysql 1、SQL Server是微软, .net程序员最爱,中型和大型项目,性能高 2

2020-08-31 20:02:53 102

原创面向对象大串讲

类与对象 -class Person(): -p=Person()属性查找 -p.name:先找对象自己，找不到去类中找，再找不到报错类属性和对象属性 -分别再不同的名称空间对象的绑定方法 -特殊之处，对象来调用，会自动传值，把对象自己传过来，当那个对象来调用，self就是谁 -类也可以来调用，类调用就是普通函数，有几个参数就要传几个参数函数和方法 -类与数据类型(类即类型) -类的继承（python支持多继承）继承后属性查找顺序派生（子类中新定义的属性或方法）

2020-08-31 12:30:04 88

原创并发编程大串讲

并发编程大串讲操作系统发展史（了解）多道技术（了解）进程调度（了解） -进程状态：就绪，执行，阻塞进程三状态（就绪，阻塞，运行）同步异步阻塞非阻塞：异步+非阻塞 -同步是任务提交了，等待执行完成 -异步是任务提交了，不等待执行完成，我自己去干自己的事，任务完成有回调 -阻塞：程序运行的状态阻塞（io操作） -非阻塞：程序一直在运行的状态创建进程的两种方式(重点) -资源分配的最小单位 -两种方式 -windows下开进程，在main函数下进程jo

2020-08-31 12:29:10 105

原创 99 实现服务端协程并发

服务端：from gevent import monkey, spawn;monkey.patch_all()import timefrom socket import socketdef make_server(ip, port): server = socket() server.bind((ip, port)) server.listen(5) while True: conn, addr = server.accept() spawn(task, conn) #

2020-08-31 11:44:51 102

原创 20200827内容

昨日回顾1 GIL锁：全局解释器锁，因为垃圾回收线程不是线程安全的，所有线程必须拿到这把锁，才能执行2 GIL跟互斥锁的区别？GIL锁不能保证我们自己的数据安全，自己使用互斥锁保证自己的数据安全3 不同线程数据交互两种方式： -共享变量：不同线程修改同一份数据要加锁（互斥锁） -通过queue：不需要考虑数据安全问题（线程安全了）4 死锁现象： -1 A线程拿到了A锁，等待B锁，B线程拿到了B锁，等待A锁，相互等待，永远等下去 -2 A线程拿到了A锁，再去拿A锁5 递归锁（可重

2020-08-27 22:22:43 86

原创 98 重点---IO模型

"""一、IO操作的本质1，内存分为内核缓冲区和用户缓冲区（网络下载的资源，硬盘加载的资源，先放到内核缓冲区---> copy 到应用程序的缓冲区，应用程序才能用到这个数据）2、io模型： -阻塞io（BIO） -非阻塞io（NIO） -io多路复用（IO Multiplexing）类似于BIO，也是阻塞。只不过找了一个代理，来挂起等待，并能同时监听多个请求，数据会由用户进程完成拷贝 select 能接收一定数量的请求（1024个），是轮询机制，不断查看盒子里是否有东西，效率稍微

2020-08-27 22:21:30 86

原创 97 asyncio

import asyncioimport timefrom threading import current_thread#3.5之前这么写# @asyncio.coroutine# def task():# print('start')# yield from asyncio.sleep(1) # 模拟io# print('done!')### loop = asyncio.get_event_loop() # 获取一个事件循环对象## # 协程函数加括号，并不会真正

2020-08-27 22:20:33 76

原创 96 gevent

import geventimport time# 以后使用，这一句必写from gevent import monkey;monkey.patch_all()def eat(): print('eat a bit') gevent.sleep(1) # io操作,被猴子补丁替换后，gevent.sleep() print('eat again')def play(): print('play a bit') gevent.sleep(2) print('play aga

2020-08-27 22:19:47 68

原创 95 协程

"""携程是为了实现单线程下的并发，属性线程下协程要解决的问题：保存状态+切换yield：生成器，只要函数中有yield关键字，这个函数就是生成器，通过yield实现保存状态+切换"""import timedef func1(): for i in range(1000000): i += 1 yielddef func2(): g = func1() for i in range(1000000): i += 1 next(g)if __name__ =

2020-08-27 22:18:53 78

原创 94 定时器

from threading import Timerdef task(name): print(f'hello bro, {name}')t = Timer(2, task, args=('lqz',)) # 等待2秒t.start()

2020-08-27 22:17:49 66

原创 GIL 全局锁

#1 python的解释器有很多，cpython，jpython，pypy(python写的解释器)#2 python的库多，库都是基于cpython写起来的，其他解释器没有那么多的库#3 cpython中有一个全局大锁，每条线程要执行，必须获取到这个锁#4 为什么会有这个锁呢？因为垃圾回收线程不是线程安全的，所有线程必须拿到这把锁，才能执行。#5 python的多线程其实就是单线程#6 某个线程想要执行，必须先拿到GIL，我们可以把GIL看作是“通行证”，并且在一个python进程中，GIL只

2020-08-27 09:12:25 167

原创 92 进程池和线程池

# 为什么会出现池？不管是开进程还是开线程，不能无限制开，通过池，假设池子里就有10个，不管再怎么开，永远是这10个from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutorimport timeimport randomfrom threading import Threadpool = ThreadPoolExecutor(5) # 数字是池的大小# pool = ProcessPoolExecut

2020-08-26 21:41:23 86

原创 91 线程间通信

from queue import Queue,PriorityQueue,LifoQueue# 线程间的通信# 线程间通信，因为共享变量会出现数据不安全问题，用线程queue通信，不需要加锁，内部自带queue是线程安全的"""三种线程Queue： Queue:队列：先进先出 PriorityQueue:优先级队列 LifoQueue：栈，后进先出 """# Queue:队列：先进先出q = Queue(5)q.put('egon')q.put('jack')q.put(

2020-08-26 20:29:33 89

原创 90 事件 Event

# 一些线程需要等到其他线程执行完成之后才能执行，类似于发射信号# 比如一个线程等待另一个线程执行结束再继续执行# 一些线程需要等到其他线程执行完成之后才能执行，类似于发射信号# 比如一个线程等待另一个线程执行结束再继续执行# 相当于一种监测from threading import Thread, Eventimport timeevent = Event()def girl(name): print(f'{name} has a relationship!') time.sl

2020-08-26 20:28:31 162

原创 89 信号量Semaphore

# Semaphore:信号量可以理解为多把锁，同时允许多个线程来更改数据from threading import Thread, Semaphoreimport timeimport randomsm = Semaphore(5) # 数字表示可以同时有多少个线程操作def task(name): sm.acquire() print(f'{name}正在顿坑') time.sleep(random.randint(1, 5)) sm.release()if __name

2020-08-26 19:29:59 82

原创 88 死锁问题

# 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程，如下就是死锁# 单例模式：https://www.cnblogs.com/liuqingzheng/p/10038958.html# 死锁现象，张三拿到了A锁，等B锁，李四拿到了B锁，等A锁# 死锁from threading import Thread, Lockimport timem

2020-08-26 19:21:27 113

原创线程其他

今日内容1 验证GIL锁的存在方式from threading import Threadfrom multiprocessing import Processdef task(): while True: passif __name__ == '__main__': for i in range(6): # t=Thread(target=task) # 因为有GIL锁，同一时刻，只有一条线程执行，所以cpu不会满 t=Pro

2020-08-26 19:17:05 494

原创线程概论

昨日回顾1 开启进程的两种方式2 进程对象其他属性和方法： -pid进程id号，os.getpid() -ppid：父进程id号，os.getppid() -is_alive():当前进程是否存活 -terminate()：关闭当前进程3 守护进程 -父进程结束，子进程也跟着结束 -t.daemon=True4 进程间数据隔离 -进程之前的数据是独有的，不同进程间不能相互使用5 队列 -Queue：实现进程间通信，同一台及其上的不同进程 -q=Que

2020-08-25 15:23:57 263

原创 87 线程锁

from threading import Thread,Lock# from multiprocessing import Lockimport timeimport randommoney = 99def task(n,mutex): global money # 在修改数据的时候，枷锁 mutex.acquire() temp = money time.sleep(0.1) money = temp - 1 # 修改完以后，释放

2020-08-25 15:16:07 65

原创 86 线程

from threading import Thread, current_thread, active_countimport timeimport osdef task(n): print('start') print(current_thread().name) # 当前线程的名字，默认Thread-n print(os.getppid()) # 打印的是进程的id time.sleep(n) print('end')if __name__ == '__main__':

2020-08-25 15:12:41 70

原创 85 生产者消费者模型

# 多个生产者和多个消费者# 制造两个消费者# import time# import random# from multiprocessing import Process, Queue## def producer(name, food, q):# for i in range(10):# data = '%s 制造了%s' % (name, food)# # 模拟制造食物延迟# time.sleep(random.randin

2020-08-25 15:10:58 121

原创 84进程间的通信

# 队列from multiprocessing import Queue# 实例化得到要给对象q = Queue(5) # 默认很大，可以放很多，写了个5，只能放5个# 往管道中放值q.put(1)q.put('lqz')q.put(18)q.put(19)# q.put(20)# q.put(21)q.put_nowait(100)# 从管道中取值# print(q.get())# print(q.get())# print(q.get())print(q.g

2020-08-24 14:53:34 68

原创 83互斥锁

from multiprocessing import Process, Lockimport jsonimport timeimport randomdef search(): # 查票的函数 # 打开文件，读出ticket_count with open('ticket', 'r', encoding='utf-8') as f: dic = json.load(f) print('余票还有：', dic.get('ticket_cou

2020-08-24 14:46:07 86

原创 82 守护进程

from multiprocessing import Process, current_processimport timeimport osdef task(): # print(os.getpid()) print('子进程') time.sleep(200) print('子进程结束')if __name__ == '__main__': t = Process(target=task, ) # 守护进程：主进程一旦结束，子进程也结束

2020-08-24 14:42:41 52

原创 81 进程的一些方法

from multiprocessing import Process,current_processimport timeimport os# 每个进程都会有自己的id号piddef task(): print('子进程') # 当前进程的id号 print(current_process().pid) print(os.getpid()) # 跟上面打印出来是一模一样的 # 取出该进程父id号 print('-----',os.getppid

2020-08-24 14:41:13 88

原创 80 join方法

import osimport timefrom multiprocessing import Processdef task(n, tag): print(f'{tag} start running!') time.sleep(n) print(f'{tag} is done!')if __name__ == '__main__': p1 = Process(target=task, args=(3, '进程1')) p2 = Process(target=task, args=

2020-08-20 15:11:40 4490

原创 79 进程的应用

import osimport timefrom multiprocessing import Processdef task(n,tag): print(f'{tag} start running!') time.sleep(n) print(f'{tag} is done!')if __name__ == '__main__': p1 = Process(target=task, args=(2,'进程1')) p2 = Process(target=task, args=(1,'

2020-08-20 15:10:30 90

原创 78 并发编程

"""1、程序程序就是一堆代码文件2、进程进程是一个抽象的概念进程指的是程序的运行过程进程是操作系统最核心的概念3、操作系统 1、操作系统的作用 1：隐藏丑陋复杂的硬件接口 2：管理、调度进程，并且将多个进程对硬件的竞争变得有序多道技术ps: 串行：一个运行完毕再运行下一个并行：多个进程是真正意义上的一起运行并发：看起来是同时运行的，本质还是一个个的运行进程彼此之间的内存空间隔离，而且是物理隔离"""...

2020-08-19 16:22:48 132

原创 77 垃圾回收机制

"""引用计数：一个变量值的引用计数为0时，才会被当作垃圾回收问题1：循环引用=》内存泄漏标记-清除问题2：效率问题分代回收"""l2 = [20, 30] # 列表本身被变量名l2直接引用，包含的元素被列表间接引用x = 10 # 值10被变量名x直接引用l1 = [x, l2] # 列表本身被变量名l1直接引用，包含的元素被列表间接引用...

2020-08-19 16:22:03 59

原创 76 内置函数

class Foo: passprint(callable(Foo))print(chr(67))print(ord("C"))print(divmod(10, 3))l = ['aaa', 'bb', 'ccc']l = {'k1': 111, 'k2': 2222}for i, item in enumerate(l): print(i, item)s1 = {1,2,3}s1.add(4)s1 = frozenset({1, 2, 3})s1.add(4) #报错！

2020-08-19 16:05:44 103

原创 75 猴子补丁

import jsonimport ujsondef monkey_patch(): json.__name__ = ujson.__nmae__ json.dumps = ujson.dumps json.loads = ujson.loads

2020-08-19 16:05:10 65

原创 74 单例模式

# 六：单例模式# 实现方式1：classmethodimport settings818class MySQL: __instance = None def __init__(self, ip, port): self.ip = ip self.port = port @classmethod def singleton(cls): if cls.__instance: return c

2020-08-18 15:15:30 76

原创 73 元类

# python中一切皆对象# 一、元类介绍# 元类-> OldboyTeacher类 -> objclass OldobyTeacher(object): school = 'oldboy' def __init__(self, name, age): self.name = name self.age = age def say(self): print('welcome!')obj = OldobyTeacher('egon', 18) # 调用类 -&

2020-08-18 15:14:48 85

原创 72基于socketserver模块实现服务端并发

========================tcp的服务端的并发：# from socket import *### server=socket(AF_INET,SOCK_STREAM)# server.bind(('127.0.0.1',8080))# server.listen(5)## while True:# conn,addr=server.accept()# print(addr)## while True:# try:#

2020-08-17 15:40:34 86

原创 71 基于UDP协议的服务端

server.py:"""1、可靠性：tcp协议是可靠协议：对方必须恢复一个ack确认消息，才会将自己的这端端数据从内存中删除udp协议不可靠：发送一条消息就会立即删除，不管对方是否接收到2、有无链接tcp有链接，udp无连接3、传输数据的效率# udp更高4、粘包问题udp协议称之为数据包协议，每次发送都是一个完整的数据包，一个发送唯一对应一个接收所以udp协议没有粘包问题"""from socket import *server = socket(AF_IN

2020-08-17 15:31:58 92

原创 70制定复杂报头-从服务器下载文件

server.pyimport subprocessimport osimport structimport jsonfrom socket import *server = socket(AF_INET, SOCK_STREAM)# print(server)server.bind(('127.0.0.1', 8082))server.listen(5)while True: conn, client_addr = server.accept() print(conn

2020-08-14 16:10:13 81

原创 69 解决粘包问题

server.pyfrom socket import *import subprocessimport pickleimport structserver = socket(AF_INET, SOCK_STREAM) # SOCK_STREAM基于TCP的# print(server)server.bind(('127.0.0.1', 8080))server.listen(5)print('服务器127.0.0.1:8080启动')while True: print('等待链接

2020-08-14 16:05:39 81

原创 68 socket- 远程执行命令

server：import socket# 1、买手机phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # SOCK_STREAM=>tcp协议# 2、插手机卡phone.bind(('127.0.0.1', 8086)) # 本机回环地址# 3、开机phone.listen(5) # 半链接池大小为1print('服务器启动')# 4、等电话连接while True: # 链接循环 conn, c

2020-08-13 15:54:55 167

原创 68 socket编程

server："""服务端应该满足的要求： 1、一直对外提供服务 2、并发的提供服务（目前不能实现）"""import socket# 1、买手机phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # SOCK_STREAM=>tcp协议# 2、插手机卡phone.bind(('127.0.0.1', 8080)) # 本机回环地址# 3、开机phone.listen(5) # 半链接池大小为1

2020-08-13 15:52:50 108

空空如也

空空如也