周总结-8week

目录

并发编程

操作系统的发展史

操作系统的发展史也可以称为并发编程的发展史
"""
回顾计算机小知识
计算机五大核心：运算器 输入设备 输出设备 控制器 存储器
三大核心硬件：CPU 硬盘 内存
                CPU:是计算机中真正干活的人
                内存：给CPU准备需要运行的代码
                硬盘：存储将来可能要被运行的代码
"""

1.穿孔卡片
	CPU利用率非常的低 好处是程序员可以一个人独占计算机
2.联机批处理系统
	缩短录入数据的时候 让CPU连续工作的时间变长>>>:提升CPU利用率
3.脱机批处理系统
	是现代计算机的雏形>>>:提升CPU的利用率

总结：
	操作系统的发展史也可以看成是CPU利用率提升的发展史

多道技术

前提：必须是一个核/一个CPU/一个真正干活的

单道技术
	所有的程序排队执行 总耗时是所有程序耗时之和
多道技术
	计算机利用空闲时间提前准备好一些数据 提高效率 总耗时较短
    
"""
多道技术
	切换+保存状态
	1.CPU在两种情况下会切换（去执行其他程序）
		① 程序自身进入IO操作
			IO操作：输入输出操作
			获取用户输入
			time.sleep()
			读取文件
			保存文件
		② 程序长时间占用CPU
	2.保存状态
		每次切换之前都要保存记录下当前执行的状态 之后切回来基于当前状态继续执行
"""
eg： 做饭耗时40min  洗衣服耗时30min  扫地耗时10min
	单道技术：40+30+10    多道技术：40

进程理论

1.如何理解进程
    程序：一堆躺在文件上的"死的”代码
    进程：正在被运行的程序“活的”
2.进程的调度算法
先来先服务算法
	针对耗时比较短的程序不太友好
短作业优先调度
	针对耗时比较长的程序不太友好
时间片轮转法+多级反馈队列
    将固定的时间均分成很多份 所有的程序来了都公平的分一份
    分配多次之后如果还有程序需要运行 则将其分到下一层
    越往下表示程序总耗时越长  每次分是时间片越多 但是优先级越低

进程的并行与并发

并行
	多个进程同时执行
    	单个CPU肯定无法实现并行 必须要有多个CPU
并发
	多个进程看上去像同时执行就可以称之为并发
    	单个CPU完全可以实现并发的效果 如果是并行 那么肯定也属于并发
eg：描述一个网站很厉害能够同时服务很多人的话术
	1.我这个网站很6 能够支持14亿人并行量（高并行）
    	不合理 哪有那么多CPU（集群也不现实）
    2.我这个网站很6 能够支持14亿并发量（高并发）
    	超级合理 国内最6的网站>>>:12306(很少很少崩溃)

进程的状态

1.所有的进程要想被运行 必须先经过就绪态
2.运行过程中如果出现IO操作 则进入阻塞态
3.运行过程中如果时间片用完 则继续进入就绪态
4.阻塞态想要进入运行态必须先经过就绪态

同步和异步

用于描述任务的提交状态
同步
	提交任务滞后原地等待任务的结果 期间不做任何事
异步
	提交完任务之后不原地等待直接去做其他事 结果自动提醒

阻塞与非阻塞

用于描述进程的执行状态
    阻塞
    	阻塞态
    非阻塞
    	就绪态 运行态

同步异步与阻塞非阻塞

同步阻塞：在银行排队 在队伍中什么都不做
同步非阻塞：在银行排毒 在队伍中可以玩手机
异步阻塞：取号 在座位上等待叫号 期间不做任何事
异步非阻塞：取号 在座位等着叫号 期间可以玩手机

创建进程的多种方式

"""
1.双击桌面程序图标
2.代码创建进程(需要掌握)
	需要掌握两种即可
"""
from multiprocessing import Process
import time


# def task(name):
#     print(f'{name}正在运行')
#     time.sleep(3)
#     print(f'{name}运行结束')
#
#
# if __name__ == '__main__':
#     p = Process(target=task, args=('jason',))  # 创建一个进程对象
#     p.start()  # 告诉操作系统创建一个进程(异步操作)
#     # task('jason')  # 普通的函数调用是同步操作
#     print('主进程')

"""
创建进程的代码在不同的操作系统中 底层原理有区别!!!
在windows中 创建进程类似于导入模块
    if __name__ == '__main__':  启动脚本
在mac、linux中 创建进程类似于直接拷贝
    不需要启动脚本 但是为了兼容性 也可以使用
"""


class MyProcess(Process):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        print(f'{self.name}正在运行')
        time.sleep(5)
        print(f'{self.name}运行结束')


if __name__ == '__main__':
    obj = MyProcess('jason')
    obj.start()
    print('主进程')

join方法

join:主进程等待子进程运行结束之后再运行
    
推导步骤1:直接在主进程代码中添加time.sleep()
	不合理 因为无法准确把握子进程执行的时间
推导步骤2:join方法
	很合理!!!

def task(name, n):
    print(f'{name}正在运行')
    time.sleep(n)
    print(f'{name}运行结束')


if __name__ == '__main__':
    p1 = Process(target=task, args=('jason', 1))  # args就是通过元组的形式给函数传参
    p2 = Process(target=task, args=('kevin', 2))  # 也可以通过kwargs={'name':'jason', 'n':1} 太麻烦 没必要
    p3 = Process(target=task, args=('jerry', 3))
    start_time = time.time()
    p1.start()
    p2.start()
    p3.start()
    p1.join()
    p2.join()
    p3.join()
    end_time = time.time() - start_time
    print('总耗时:%s' % end_time)
    print('主进程')
'''一定要看准join的执行位置 以及多任务情况下等待的目标'''

进程间数据默认隔离

多个进程数据彼此之间默认是相互隔离的
	如果真的想交互 需要借助于'管道'或者'队列'
 
from multiprocessing import Process

money = 100


def task():
    global money
    money = 666
    print('子进程打印的money', money)


if __name__ == '__main__':
    p = Process(target=task)
    p.start()
    p.join()
    print('父进程打印的money', money)

进程间通信(IPC机制)

预备知识
	什么是队列:先进先出
		  from multiprocessing import Queue
        # 1.创建队列对象
        q = Queue(3)  # 括号内指定队列可以容纳的数据个数 默认:2147483647
        # 2.往队列添加数据
        # q.put(111)
        # print(q.full())  # 判断队列是否已经存满
        # q.put(222)
        # q.put(333)
        # print(q.full())
        # q.put(444)  # 超出数据存放极限 那么程序一致处于阻塞态 直到队列中有数据被取出
        # 3.从队列中取数据
        print(q.get_nowait())
        print(q.get_nowait())
        print(q.get_nowait())  # 队列中如果没有数据可取 直接报错
        # print(q.get())
        # print(q.empty())  # 判断队列是否已经空了
        # print(q.get())
        # print(q.get())
        # print(q.empty())
        # print(q.get())  # 超出数据获取极限 那么程序一致处于阻塞态 直到队列中有数据被添加
        """
            q.full()
            q.empty()
            q.get_nowait()
        上述方法在多进程下不能准确使用(失效)!!!
        """
IPC机制
	1.主进程与子进程通信
 	2.子进程与子进程通信
 
from multiprocessing import Queue, Process


def procedure(q):
    q.put('子进程procedure往队里中添加了数据')


def consumer(q):
    print('子进程的consumer从队列中获取数据', q.get())


if __name__ == '__main__':
    q = Queue()  # 在主进程中产生q对象 确保所有的子进程使用的是相同的q
    p1 = Process(target=procedure, args=(q,))
    p2 = Process(target=consumer, args=(q,))
    p1.start()
    p2.start()
    print('主进程')

生产者消费者模型

生产者
	产生数据
消费者
	处理数据
"""
爬取红牛分公司
	生产者:获取网页数据的代码(函数)
		爬
	消费者:从网页数据中筛选出符合条件的数据(函数)
		筛选

完整的生产者消费者模型至少有三个部分
	生产者
	消息队列/数据库
	消费者
"""

进程相关方法

1.查看进程号
	from multiprocessing import current_process
	import os
	current_process().pid
	os.getpid()
	os.getppid()
2.销毁子进程
	p1.terminate()
3.判断进程是否存活
	p1.is_alive()

守护进程

如何理解守护
	伴随着守护对象的存活而存活 死亡而死亡
    
    
from multiprocessing import Process
import time


def task(name):
    print('大内总管:%s存活' % name)
    time.sleep(3)
    print('大内总管:%s嗝屁' % name)


if __name__ == '__main__':
    p = Process(target=task, args=('基佬',))
    # p.daemon = True  # 将子进程设置为守护进程:主进程代码结束 子进程立刻结束
    p.start()
    p.daemon = True  # 必须在start之前执行
    print('天子Jason寿终正寝!!!')

僵尸进程与孤儿进程

僵尸进程
	进程已经运行结束 但是相关的资源并没有完全清空
 	需要父进程参与回收
孤儿进程
	父进程意外死亡 子进程正常运行 该子进程就称之为孤儿进程
 	孤儿进程也不是没有人管 操作系统会自动分配福利院接收

互斥锁

模拟抢票
	查票
	买票
		查票
 		买票
 
from multiprocessing import Process
import time
import json
import random


# 查票
def search(name):
    with open(r'data.json', 'r', encoding='utf8') as f:
        data = json.load(f)
    print('%s在查票 当前余票为:%s' % (name, data.get('ticket_num')))


# 买票
def buy(name):
    # 再次确认票
    with open(r'data.json', 'r', encoding='utf8') as f:
        data = json.load(f)
    # 模拟网络延迟
    time.sleep(random.randint(1, 3))
    # 判断是否有票 有就买
    if data.get('ticket_num') > 0:
        data['ticket_num'] -= 1
        with open(r'data.json', 'w', encoding='utf8') as f:
            json.dump(data, f)
        print('%s买票成功' % name)
    else:
        print('%s很倒霉 没有抢到票' % name)


def run(name):
    search(name)
    buy(name)
"""
多个程序同时操作一份数据的时候很容易产生数据错乱!!!
为了避免数据错乱 我们需要使用互斥锁
"""
互斥锁
	将并发变成串行 虽然牺牲了程序的执行效率但是保证了数据安全
如何使用
	from multiprocessing import Process, Lock
	mutex = Lock()
	mutex.acquire()  # 抢锁
	mutex.release()  # 释放锁
强调
	互斥锁只应该出现在多个程序操作数据的地方 其他位置尽量不要加
	ps:以后我们自己处理锁的情况很少 只需要知道锁的功能即可
	
悲观锁：对每次访问数据库的操作都是抱有悲观的态度，认为该操作会对数据库做出修改，所以在访问数据库的时候就加了锁
乐观锁：对每次访问数据库的操作都抱有乐观的态度，只有在做出修改的时候才会上锁

if __name__ == '__main__':
    for i in range(10):
        p = Process(target=run, args=('用户%s'%i, ))
        p.start()

线程理论

进程是资源单位
	进程相当于是车间 进程负责给内部的线程提供相应的资源
线程是执行单位
	线程相当于是车间里面的流水线 线程负责执行真正的功能
    
1.一个进程至少含有一个线程
2.多进程与多线程的区别
	多进程
    	需要申请内存空间 需要拷贝全部代码 资源消耗大
	多线程
    	不需要申请内存空间 也不需要拷贝全部代码 资源消耗小
3.同一个进程下多个线程之间资源共享

创建线程的两种方式

from threading import Thread
from multiprocessing import Process
import time

# def task(name):
#     print(f'{name}正在运行')
#     time.sleep(3)
#     print(f'{name}运行结束')


"""
开设线程不需要完整拷贝代码 所以无论什么系统都不会出现反复操作的情况 
也不需要在启动脚本中执行 但是为了兼容性和统一性 习惯在启动脚本中编写
"""


# t = Thread(target=task, args=('jason',))
# t.start()
# print('主线程')
# if __name__ == '__main__':
#     t = Thread(target=task, args=('jason',))
#     t.start()
#     print('主线程')


class MyThread(Thread):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def run(self):
        print(f'{self.name}正在运行')
        time.sleep(3)
        print(f'{self.name}运行结束')


obj = MyThread('jason')
obj.start()
print('主线程')

多线程实现TCP服务端并发

比多进程更加简单方便 消耗的资源更少
ps:课下使用多进程或者多线程对比(任务管理器)

join方法

主线程等到子线程运行结束之后再运行
from threading import Thread
import time

def task():
    print('正在执行')
    time.sleep(3)
    print('运行结束')


t = Thread(target=task)
t.start()
t.join()
print('主线程')

同一个进程下线程间数据共享

from threading import Thread

money = 1000


def func():
    global money
    money = 666


t = Thread(target=func)
t.start()
t.join()  # 确保线程运行完毕 再查找money 结果更具有说服性
print(money)

线程对象相关方法

1.进程号
	同一个进程下开设的多个线程拥有相同的进程号
2.线程名
	from threading import Thread, current_thread
	current_thread().name
 	主:MainThread	子:Thread-N
3.进程下的线程数
	active_count()

守护线程

守护线程伴随着被守护的线程的结束而结束

from threading import Thread
import time

def task():
    print('子线程运行task函数')
    time.sleep(3)
    print('子线程运行task结束')


t = Thread(target=task)
# t.daemon = True
t.start()
# t.daemon = True
print('主线程')
"""
进程下所有的非守护线程结束 主线程(主进程)才能真正结束!!!
"""

GIL全局解释器锁

储备知识
	1.python解释器也是由编程语言写出来的
    	Cpython  用C写出来的
 		Jpython  用Java写出来的
    	Pypython 用python写出来的
ps:最常用的就是Cpython(默认)
# 官方文档对GIL的解释
In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple native threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)

"""
1.GIL的研究是Cpython解释器的特点 不是python语言的特点
2.GIL本质也是一把互斥锁
3.GIL的存在使得同一个进程下的多个线程无法同时执行(关键)
	言外之意:单进程下的多线程无法利用多核优势 效率低!!!
4.GIL的存在主要是因为cpython解释器中垃圾回收机制不是线程安全的
"""
参考群内截图 理解上述3、4解读
1.误解:python的多线程就是垃圾 利用不到多核优势
	python的多线程确实无法使用多核优势 但是在IO密集型的任务下是有用的
2.误解:既然有GIL 那么以后我们写代码都不需要加互斥锁
	不对 GIL只确保解释器层面数据不会错乱(垃圾回收机制)
	针对程序中自己的数据应该自己加锁处理
3.所有的解释型编程语言都没办法做到同一个进程下多个线程同时执行
ps:我们平时在写代码的时候 不需要考虑GIL 只在学习和面试阶段才考虑!!!

验证python多线程是否有用

需要分情况
	情况1
    	单个CPU
    	多个CPU
	情况2
    	IO密集型(代码有IO操作)
       计算密集型(代码没有IO)
 
1.单个CPU
	IO密集型
    	多进程
        申请额外的空间 消耗更多的资源
		多线程
        消耗资源相对较少 通过多道技术
      ps:多线程有优势!!!
 	计算密集型
    	多进程
        申请额外的空间 消耗更多的资源(总耗时+申请空间+拷贝代码+切换)
 		多线程
        消耗资源相对较少 通过多道技术(总耗时+切换)
      ps:多线程有优势!!!
2.多个CPU
	IO密集型
   		多进程
         总耗时(单个进程的耗时+IO+申请空间+拷贝代码)
       多线程
    	  总耗时(单个进程的耗时+IO)
       ps:多线程有优势!!!
	计算密集型
    	多进程
       	  总耗时(单个进程的耗时)
    	多线程
          总耗时(多个进程的综合)
       ps:多进程完胜!!!
 
from threading import Thread
from multiprocessing import Process
import os
import time


def work():
    # 计算密集型
    res = 1
    for i in range(1, 100000):
        res *= i


if __name__ == '__main__':
    # print(os.cpu_count())  # 12  查看当前计算机CPU个数
    start_time = time.time()
    # p_list = []
    # for i in range(12):  # 一次性创建12个进程
    #     p = Process(target=work)
    #     p.start()
    #     p_list.append(p)
    # for p in p_list:  # 确保所有的进程全部运行完毕
    #     p.join()
    t_list = []
    for i in range(12):
        t = Thread(target=work)
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    print('总耗时:%s' % (time.time() - start_time))  # 获取总的耗时

"""
计算密集型
    多进程:5.665567398071289
    多线程:30.233906745910645
"""

def work():
    time.sleep(2)   # 模拟纯IO操作


if __name__ == '__main__':
    start_time = time.time()
    # t_list = []
    # for i in range(100):
    #     t = Thread(target=work)
    #     t.start()
    # for t in t_list:
    #     t.join()
    p_list = []
    for i in range(100):
        p = Process(target=work)
        p.start()
    for p in p_list:
        p.join()
    print('总耗时:%s' % (time.time() - start_time))

"""
IO密集型
    多线程:0.0149583816528320
    多进程:0.6402878761291504
"""

死锁现象

"""
先抢锁 后释放锁
但是在实际项目尽量少用(你也不会用!!!)
"""
from threading import Thread, Lock
import time

mutexA = Lock()  # 类名加括号每执行一次就会产生一个新的对象
mutexB = Lock()  # 类名加括号每执行一次就会产生一个新的对象


class MyThread(Thread):
    def run(self):
        self.func1()
        self.func2()

    def func1(self):
        mutexA.acquire()
        print(f'{self.name}抢到了A锁')
        mutexB.acquire()
        print(f'{self.name}抢到了B锁')
        mutexB.release()
        print(f'{self.name}释放了B锁')
        mutexA.release()
        print(f'{self.name}释放了A锁')

    def func2(self):
        mutexB.acquire()
        print(f'{self.name}抢到了B锁')
        time.sleep(1)
        mutexA.acquire()
        print(f'{self.name}抢到了A锁')
        mutexA.release()
        print(f'{self.name}释放了A锁')
        mutexB.release()
        print(f'{self.name}释放了B锁')


for i in range(10):
    t = MyThread()
    t.start()

信号量

信号量本质也是互斥锁 只不过它是多把锁
"""
强调:
    信号量在不同的知识体系中 意思可能有区别
        在并发编程中 信号量就是多把互斥锁
        在django中 信号量指的是达到某个条件自动触发(中间件)
        ...
"""
'''
我们之前使用Lock产生的是单把锁
	类似于单间厕所
信号量相当于一次性创建多间厕所
	类似于公共厕所
'''
from threading import Thread, Lock, Semaphore
import time
import random


sp = Semaphore(5)  # 一次性产生五把锁


class MyThread(Thread):
    def run(self):
        sp.acquire()
        print(self.name)
        time.sleep(random.randint(1, 3))
        sp.release()


for i in range(20):
    t = MyThread()
    t.start()

event事件

子进程\子线程之间可以彼此等待彼此
	eg:
      子A运行到某一个代码位置后发信号告诉子B开始运行
 
from threading import Thread, Event
import time

event = Event()  # 类似于造了一个红绿灯


def light():
    print('红灯亮着的 所有人都不能动')
    time.sleep(3)
    print('绿灯亮了 油门踩到底 给我冲!!!')
    event.set()


def car(name):
    print('%s正在等红灯' % name)
    event.wait()
    print('%s加油门 飙车了' % name)


t = Thread(target=light)
t.start()
for i in range(20):
    t = Thread(target=car, args=('熊猫PRO%s' % i,))
    t.start()

进程池和线程池

"""
多进程 多线程
	在实际应用中是不是可以无限制的开进程和线程
	肯定不可以!!! 会造成内存溢出受限于硬件水平
我们在开设多进程或者多线程的时候 还需要考虑硬件的承受范围

池
	降低程序的执行效率 保证计算机硬件的安全
进程池
	提前创建好固定个数的进程供程序使用 后续不会再创建
线程池
	提前创建好固定个数的线程供程序使用 后续不会再创建
"""
submit(函数名,实参1,实参2,...)
from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
from threading import current_thread
import os
import time

# pool = ThreadPoolExecutor(5)  # 固定产生五个线程
pool = ProcessPoolExecutor(5)  # 固定产生五个线程


def task(n):
    # print(current_thread().name)
    print(os.getpid())
    # print(n)
    time.sleep(1)
    return '返回的结果'


def func(*args, **kwargs):
    print('func', args, kwargs)
    print(args[0].result())


if __name__ == '__main__':
    for i in range(20):
        # res = pool.submit(task,123)  # 朝池子中提交任务(异步)
        # print(res.result())  # 同步
        # pool.submit(task, 123).add_done_callback(func)
        """异步回调:异步任务执行完成后有结果就会自动触发该机制"""
        pool.submit(task, 123).add_done_callback(func)

协程

"""
进程:资源单位
线程:执行单位
协程:单线程下实现并发(效率极高)
	在代码层面欺骗CPU 让CPU觉得我们的代码里面没有IO操作
	实际上IO操作被我们自己写的代码检测 一旦有 立刻让代码执行别的
		核心:自己写代码完成切换+保存状态
"""
import time
from gevent import monkey;

monkey.patch_all()  # 固定编写 用于检测所有的IO操作(猴子补丁)
from gevent import spawn


def func1():
    print('func1 running')
    time.sleep(3)
    print('func1 over')


def func2():
    print('func2 running')
    time.sleep(5)
    print('func2 over')


if __name__ == '__main__':
    start_time = time.time()
    # func1()
    # func2()
    s1 = spawn(func1)  # 检测代码 一旦有IO自动切换(执行没有io的操作 变向的等待io结束)
    s2 = spawn(func2)
    s1.join()
    s2.join()
    print(time.time() - start_time)

协程实现TCP服务端并发

import socket
from gevent import monkey;monkey.patch_all()  # 固定编写 用于检测所有的IO操作(猴子补丁)
from gevent import spawn


def communication(sock):
    while True:
        data = sock.recv(1024)
        print(data.decode('utf8'))
        sock.send(data.upper())


def get_server():
    server = socket.socket()
    server.bind(('127.0.0.1', 8080))
    server.listen(5)
    while True:
        sock, addr = server.accept()  # IO操作
        spawn(communication, sock)

s1 = spawn(get_server)
s1.join()

数据存取演变史

1.文本文件
    文件路径不一致
    	eg：C:\a.txt   D:\aaa\b.txt  E:\ccc.txt
    数据格式不一致
    	eg：curry|666  oscar$123 green@456
2.软件开发目录规范
    规定了数据文件的大致存储位置：db文件夹
    针对数据格式还是没有完全统一：比如统一json文件 但是内部键值对不同
3.数据库服务
	统一了存取位置 也统一了数据格式（完全统一）

数据库软件应用史

1.单机游戏
    不同计算机上的相同程序 数据无法共享
    	数据库服务全部在本地完成
2.网络游戏
    不同计算机上的相同程序 数据可以共享
		数据库服务全部在本地完成
"""
远程数据库服务
数据库集群
	1.数据安全性问题
	2.服务器负载问题
让多台服务器运行相同的数据库服务
"""

数据库的本质

"""
数据库三字在不同角度下描述的意思不一样
1.站在底层原理的角度
	数据库指的是专用与操作数据的进程
		eg：运行在内存中的代码
2.站在现实应用的角度
	数据库指的是拥有操作界面的应用程序
		eg：用于操作进程的界面
"""
通常在不做特殊说明的下提数据库其实都是在指数据库软件
	我们也称数据库软件本质是一款cs架构的应用程序
    言外之意所有的程序员理论上都可以编写>>>:市面上已经有很多数据库软件

数据库的分类

1.关系型数据库
	1.数据的组织方式有明确的表结构
    id name password
    ps：关系型数据库存取数据的方式可以看成是表格
	2.表与表之间可以建立数据库层面的关系
    eg：
    	用户表 房屋表
    ps：只要获取到用户表的一条数据 就可以获取到与之相关的其他表数据
MySQL、PostgreSQL、MariaDB、Oracle、sqlite、db2、sq1 server
MySQL:快源 使用最为广泛 数据库学习必学
PostgreSQL：开源 支持二次开发
MariaDB：开源 与MySQL是同一个作者 用法也及其相似
Oracle：收费 安全性极高 主要用于银行及各大重要机关
sqlite：小型数据库 主要用于本地测试（django框架自带该数据库）

2.非关系型数据库
    1.数据的组织方式没有明确的表结构 是以k:v键值对的形式组织的
        {'name':'curry'}
        {'username':'green','pwd':666}
    2.数据之间无法直接建立数据库层面的关系
    
redis、mongoDB、memcache 
redis:目前最火 使用频率最高的缓存性数据库
mongoDB：稳定性数据库 最像关系型的非关系型 主要用于爬虫、大数据
memcache：已经被redis淘汰

MySQL

1.MySQL版本问题
	5.6X：前几年使用频率最高的版本
    5.7X：最近尝试迁移的版本（频率+）
    8.0X:最新版 功能最强大 但是线上环境几乎不用（本地自己用很好用）
    """
    虽然版本有区别 但是操作上几乎没有区别 主要体现在底层运作
    """
2.下载与安装
	1.访问官网
 	2.点击DOWNLOADS
 	3.点击GPL
 	4.点击community server
 	5.点击archives
	6.点击download
3.解压安装
	上述方式下载的压缩包里含有服务端和客户端 支持本地操作
4.主要文件介绍
	bin文件夹
    	mysqld.exe服务端    mysql.exe客户端
    data文件夹
    	存取数据
    my-default.ini
    	默认配置文件

基本使用

1.先启动服务端
	可能会报错：拷贝关键信息去百度
    	两种报错
2.查找mysqld文件位置
	msqld
    	cmd窗口就是服务端 不要关闭
3.再次开启新的cmd窗口
	mysql
    	直接回车会以游客模式进入  功能很少
4.用户名密码登录
	mysql-u用户名 -p密码
    	mysql默认管理员账号  用户名是root  密码是 空
5.退出
    exit
    quit

系统服务操作

1.如何解决每次都需要切换路径查找文件的缺陷？
	在此电脑里添加环境变量
2.将MySQL服务端制作成系统服务（随着计算机的开启而启动 关闭而结束）
    1.以管理员身份打开cmd窗口
    2.执行系统服务命令
    	MySQL--install
    3.启动服务器
        1.右键直接点击启动
        2.命令启动
        	net start MySQL
"""
1.查看系统服务的命令
	services.msc
2.关闭MySQL服务端
	net stop mysql
3.移除系统服务	
	1.先确保服务已经关闭
	2.执行移除命令
		myqsd--remove
"""

密码相关操作

1.修改密码
	mysqladmin命令
    	通用方式：  # 直接在cmd中写
        	mysqladmin -u用户名 -p原密码 password 新密码
            第一次修改
            	mysqladmin -uroot -p password 123
            第二次修改
            	mysqladmin -uroot -p123 password 321
         偏门方式（有些版本无法使用）：  # 需要先登录
        	set password = PASSWORD(新密码);
2.忘记密码
    直接重装\拷贝对应文件
    先关闭服务端 然后以不需要校验用户身份的方式启动 再修改 最后再安装正常方式启动
    1.net stop mysql
    2.mysqld --skip-grant-tables
    3.mysql -uroot -p
    4.update mysql.user set password = password(123)  where Host='localhost'and User='root',
    5.net stop mysql
    6.net satart mysql

SQL与NoSQL

数据库的服务端支持各种语言充当客户端
	eg：以MySQL服务端为例
    	MySQL客户端、python代码编写的客户端、Java代码编写的客户端
    为了能够兼容所有类型的客户端 有两种策略
        1.服务端兼容
        	不合理 消耗数据库服务端资源
        2.制定统一标准
        	SQL语句、NOSQL语句
SQL与NOSQL
	SQL语句的意思是操作关系型数据库的语法
    NOSQL语句的意思操作非关系型数据库的语法
ps：SQL有时候也用来表示关系型数据库 NOSQL也用来表示非关系型数据库

数据库重要概念

'''下述概念仅仅是为了小白更快的理解 并不是完全准确'''
库	文件夹

表	文件夹里面的文件

记录	文件里一行行的数据
"""
show databases;  查看所有的数据库
show tables;  查看所有的表
select * from mysql.user; 查看user表里面所有的记录
"""
补充：
1.SQL语句结束符是分号    ;
2.取消SQL语句的执行      \c

针对库的基本SQL语句

1.增
	create database 库名;
2.查
	show databases;
    show create database 库名;
3.改
	alter database 库名 charset = 'gbk'
4.删
	drop database 库名;

针对表的基本SQL语句

"""
查看当前所在的库名
	select database();
		如果没有切换指定的库 那么默认是NULL
	use 库名;
"""
1.增
	create table 表名（字段名 字段类型，字段名 字段类型，字段名 字段类型）;
2.查
	show tables;
    show create table 表名;
    describe 表名;
    desc 表名;
3.改
	alter table 旧表名 rename 新表名;  # 改表名
4.删
	drop table 表名;

针对记录的基本SQL语句

"""
既然想操作记录 那么肯定的现有库和表
"""
1.增
    insert into 表名 values(数据,数据);
    insert into 表名 values(数据,数据),(数据,数据),(数据,数据);
2.查
	select * from 表名;  # *表示产看所有字段
    select 字段1,字段2 from 表名;
    ps: 如果表中字段较多出现了错乱 可以结尾写\G
3.改
	update 表名 set 字段名=新数据 where 筛选条件;
4.删
	delete from 表名; # 删除表中所有的数据
    delete from 表名 where 筛选条件  # 按照条件删除数据
posted @ 2022-08-14 21:55  初学者-11  阅读(23)  评论(0)  编辑  收藏  举报