标签：总结 __ 进程 线程 time print import

UDP协议

# server
import socket

server = socket.socket(type=socket.SOCK_DGRAM)
server.bind(('127.0.0.1', 8080))
msg, address = server.recvfrom(1024)
print('msg>>>:%s' % msg.decode('utf8'))
print('addr>>>:', address)
server.sendto('我是服务端，你好！'.encode('utf8'), address)

# 客户端
import socket

client = socket.socket(type=socket.SOCK_DGRAM)
server_address = ('127.0.0.1', 8080)
client.sendto('我是客户端，你好啊'.encode('utf8'), server_address)
msg, address = client.recvfrom(1024)
print('msg>>>:%s' % msg.decode('utf8'))
print('addr>>>:', address)

'''补充说明'''
1.服务端不需要考虑客户端是否异常退出
2.UDP不存在粘包现象（UDP多用于短消息的交互）

操作系统的发展史

一、前提：三大核心硬件

CPU：是计算机中真正干活的人（强调：CPU是整个计算机执行效率的核心）

内存：给CPU准备需要运行的代码

硬盘：永久存储将来可能运行的代码

二、发展史

1.穿孔卡片

CPU利用率非常低

好处是程序员可以一个人独占计算机

2.联机批处理系统

缩短录入数据的时候，让CPU连续工作的时间变长>>>:提升CPU利用率

3.脱机批处理系统

是现代计算机的雏形>>>:提升CPU利用率

三、总结

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

多道技术

前提：一个核/一个CPU/一个真正干活的人

一、单道计数

所有程序排队执行，总耗时是所有程序耗时之和

二、多道技术

计算机利用空闲时间提前准备好一些数据，提高效率，总耗时短

切换+保存状态
1.CPU在两种情况下会切换（去执行别的程序）
	1.1.程序自身进入IO操作
    	IO操作：输入输出操作
            获取用户输入
            time.sleep()
            读取文件
            保存文件
	1.2.程序长时间占用CPU
2.保存状态
	每次切换之前要记录下当前执行的状态，之后切回来基于当前状态继续执行

进程理论

一、如何理解进程

程序：一堆躺在文件上的死代码

进程：正在被运行的程序（活的）

二、进程的调度算法

1.先来先服务算法

针对耗时比较短的程序不友好

2.短作业优先调度

针对耗时较长的程序不友好

3.时间片轮转法+多级反馈队列

将固定的时间均分成很多份，所有的程序来了都公平的分一份

多次分配后，如果还有程序需要运行，则将其分到下一层

越往下表示程序总耗时越长，每次分的时间片越多，但是优先级越低

三、进程的并行与并发

1.并行

多个进程同时执行

单个CPU无法实现，必须要有多个CPU

2.并发

多个进程看上去像同时执行就可以称之为并发

单个CPU完全可以实现并发的效果，如果并行那么也属于并发

四、进程的三状态

1.所有的进程想要被运行，必须经过就绪态

2.运行过程中如果出现了IO操作则进入阻塞态

3.运行过程中如果时间片用完，则继续进入就绪态

4.阻塞态要想进入运行状态必须经过就绪态

五、同步和异步

1.作用

用于描述任务的提交状态

2.区别

同步	异步
提交完任务之后原地等待任务的结果，期间不做任何事	提交完任务之后不原地等待直接去做其他事，结果自动提醒

六、阻塞于非阻塞

1.作用

​ 用于描述进程的执行状态

2.区别

阻塞	非阻塞
阻塞态	就绪态、运行态

七、同步异步与阻塞非阻塞

类型	意义
同步阻塞	在排队过程中，什么都不做
同步非阻塞	在排队过程中，做点别的事
异步阻塞	取号，在边上等着被叫号，期间什么都不做
异步非阻塞	取号，在边上等着被叫号，期间想做什么做什么

创建进程的多种方式

一、双击桌面程序图标

二、代码创建进程

1.代码演示

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('主进程')
    
    
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('主进程')

2.介绍

创建进程的代码在不同的操作系统中，底层原理有区别！

在Windows中，创建进程类似于导入模块

if __name__ == '__main__': 启动脚本

在mac、Linux中创建进程类似于直接拷贝

不需要启动脚本，但是为了兼容性，也可以使用

三、join方法

让主进程等待子进程运行结束之后再运行

from multiprocessing import Process
import time


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


if __name__ == '__main__':
    p1 = Process(target=task, args=('jason', 1))
    # args 通过元组的形式给函数传值
    # 也可以通过kwargs={'name'='jason','n'=1} 但是太麻烦，不建议
    p2 = Process(target=task, args=('kevin', 2))
    p3 = Process(target=task, args=('tony', 3))
    start_time = time.time()
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    p3.start()
    p3.join()
    end_time = time.time() - start_time
    print('总耗时：%s' % end_time)
    print('主进程')

一定要看准join的执行位置，以及多任务情况下等待的目标。不同位置，得到的结果会不同。

四、进程间数据默认隔离

1.介绍

多个进程数据彼此之间默认是互相隔离的

如果真的想要交互，需要借助于 管道 或者 队列

2.代码演示

from multiprocessing import Process
import time

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)
# 子进程打印的money： 666
# 父进程打印的money 100

五、进程间通信（IPC机制）

1.预知知识

队列：先进先出

创建队列对象:

from multiprocessing import Process,Queue
import time
# 1.创建队列对象
q = Queue(3) 
# 括号内指定队列可以容纳的数据个数，默认：2147483647
# 2.往队列添加数据
q.put(111)
q.put(222)
q.put(333)
# q.put(444)  
# 超出数据存放极限，程序会一直处于阻塞态，直到队列中的数据被取出
print(q.get())
# print(q.empty()) # 判断队列是否为空
print(q.get())
print(q.get())
# print(q.get())
# 超出数据存放极限，程序会一直处于阻塞态，直到队列中的数据被添加
'''
输出：
	111
	222
	333
'''
'''
q.full()  # 判断队列是否已满
q.empty()  # 判断队列是否为空
q.get_nowait()
上述方法在多进程下不能准确使用（失效）！！
'''

2.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('主进程')
'''
主进程
子进程consumer从队列中获取数据 子进程procedure往队里添加了数据
'''

六、生产者消费者模型

1.生产者

产生数据

eg：爬虫——获取网页数据的代码（函数）

2.消费者

处理数据

eg：筛选——从网页数据中筛选出符合条件的数据（函数）

3.完整的生产者消费者模型至少有三个部分

生产者

消息队列/数据库

消费者

七、进程相关方法

1.查看进程号

from multiprocessing import current_process
import os
current_process().pid
os.getpid()
os.getppid()

2.销毁子进程

p1.terminate()

3.判断进程是否存活

p1.is_alive()

八、守护进程

与守护对象共存亡

九、僵尸进程与孤儿进程

1.僵尸进程

进程已经运行结束，但是相关的资源并没有完全清空

需要父进程参与回收

2.孤儿进程

父进程意外死亡，子进程正常运行，该子进程就称之为孤儿进程

孤儿进程也不是没有人管，操作系统会自动分配福利院接收

互斥锁

一、作用

多个程序同时操作一份数据的时候很容易产生数据错乱，为了避免错乱，我们需要使用互斥锁

互斥锁能将并发变成串行，虽然牺牲了程序的执行效率倒是保证了数据安全

二、代码演示

from multiprocessing import Process, Lock

mutex = Lock()
mutex.acquire()  # 抢锁
mutex.release()  # 释放锁

三、强调

互斥锁只应该出现在多个程序操作数据的地方，其他位置尽量不用

ps:以后我们自己处理锁的情况很少，只需要指定锁的功能即可

线程理论

一、前提

进程：是资源单位

相当于是车间，进程负责给内部的线程提供相应的资源

线程：是执行单位

线程相当于是车间里的流水线，线程负责执行真正的功能

二、多进程和多线程的区别

多进程	多线程
需要申请内存空间，需要拷贝全部代码，资源消耗大	不需要申请内存空间，也不需要拷贝全部代码，资源消耗小

三、特点

1.一个进程至少有一个线程

2.同一进程下多个线程之间资源共享

四、创建线程的两种方式

from threading import Thread
from multiprocessing import Process
import time


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('abcd')
obj.start()
print('主线程')
# abcd正在运行
# 主线程
# abcd运行结束

五、多线程实现TCP服务端并发

比多进程更加简单方便，消耗的资源更少

六、join方法

1.作用

让主线程等到子线程运行结束之后再运行

七、同一个进程下的线程共享数据

'''多线程'''

会改变主线程的数据

'''多进程'''

不会改变主进程的数据

八、线程对象相关方法

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写出来的

二、介绍

1.GIL的研究是Cpython解释器的特点，不是python语音的特点

2.GIL本质是一把互斥锁

3.GIL的存在使得同一个进程下的多个线程无法同时执行

言外之意：单进程下的多线程无法利用多核优势，效率低！！

4.GIL的存在主要是因为：Cpython解释器中垃圾回收机制不是线程安全的

三、误解

误解:python的多线程就是垃圾 利用不到多核优势

​ python的多线程确实无法使用多核优势 但是在IO密集型的任务下是有用的

误解:既然有GIL 那么以后我们写代码都不需要加互斥锁

GIL只确保解释器层面数据不会错乱(垃圾回收机制)
针对程序中自己的数据应该自己加锁处理

所有的解释型编程语言都没办法做到同一个进程下多个线程同时执行

四、验证GIL的存在

from threading import Thread

money = 100


def task():
    global money
    money -= 1


t_list = []  # 存储线程
for i in range(100):
    t = Thread(target=task)  # 创建进程
    t.start()  # 开始进程
    t_list.append(t)  # [线程1 线程2 线程3 ... 线程100]

for t in t_list:
    t.join()   # 保证所有线程结束
# 等待所有进程运行结束 查看money是多少
print(money)  # 结果是0

五、验证GIL的特点

GIL不会影响程序层面的数据，也不会保证他的修改是安全的，要保证安全得自己加锁

from threading import Thread
import time
money = 100


def task():
    global money
    tmp = money
    time.sleep(0.1)
    money = tmp-1


t_list = []
for i in range(100):
    t = Thread(target=task)  # 创建进程
    t.start()  # 开始进程
    t_list.append(t)  # [线程1 线程2 线程3 ... 线程100]

for t in t_list:
    t.join()
# 等待所有进程运行结束 查看money是多少
print(money)  # 结果是99
'''========================= lock加锁 ==========================='''
from threading import Thread, Lock
import time

money = 100
mutex = Lock()  # 设锁


def task():
    mutex.acquire()  # 抢锁
    global money
    tmp = money
    time.sleep(0.1)
    money = tmp - 1
    mutex.release()  # 解锁


t_list = []
for i in range(100):
    t = Thread(target=task)  # 创建进程
    t.start()  # 开始进程
    t_list.append(t)  # [线程1 线程2 线程3 ... 线程100]

for t in t_list:
    t.join()
# 等待所有进程运行结束 查看money是多少
print(money)  # 结果是0
'''牺牲效率，保证安全'''

六、验证python多线程是否有用

1.分情况分析

1.1.单个CPU

IO密集型
	多进程：申请额外的空间，消耗更多的资源
	多线程：消耗资源相对较少，通过多道技术
     ps:多线程更有优势！！
计算密集型
	多进程：申请额外的空间，消耗更多的资源
    	(总耗时+申请空间+拷贝代码+切换)
     多线程：消耗资源相对较少，通过多道技术
    	(总耗时+切换)
     ps:多线程更有优势！！

1.2.多个CPU

IO密集型
  多进程
	总耗时:单进程耗时+IO+申请空间+拷贝代码
  多线程
	总耗时:单进程耗时+IO
     ps：多线程有一点优势！
计算密集型
  多进程
    总耗时：单个进程耗时
  多线程
	总耗时：多个进程耗时的总和
  	 ps：多进程完胜！！
       
'''=====================多线程======================'''
from threading import Thread
import time
def work():
    # 计算密集型
    res = 1
    for i in range(1, 100000):
        res *= i
if __name__ == '__main__':
    start_time = time.time()
    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))
    # 总耗时：27.93082332611084

'''=====================多进程======================'''
from multiprocessing import Process
import time
def work():
    # 计算密集型
    res = 1
    for i in range(1, 100000):
        res *= i
if __name__ == '__main__':
    start_time = time.time()
    t_list = []
    for i in range(12):
        t = Process(target=work)
        t.start()
        t_list.append(t)
    for t in t_list:
        t.join()
    print('总耗时：%s' % (time.time() - start_time))
    # 总耗时：8.576988458633423

死锁现象

前提：虽然我们已经知道互斥锁的使用（先抢锁 再释放锁），但是实际项目尽量少用

from threading import Thread, Lock
import time

mutexA = Lock()
mutexB = Lock()
# 类加括号产生新对象


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


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()

# Thread-1抢到了A锁
# Thread-1抢到了B锁
# Thread-1释放了B锁
# Thread-1释放了A锁
# Thread-1抢到了B锁
# Thread-2抢到了A锁

信号量Semaphore

一、本质

信号量本质也是互斥锁，只不过它是多把锁

二、强调

信号量在不同的知识体系中，意思可能有区别

在并发编程中，信号量就是多把互斥锁

在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()

进程池和线程池

一、前提

多进程和多线程在实际应用中，受限于硬件的物理条件，会造成内存溢出，不可以无限制开进程或线程。

所以我们在开设多进程或多线程的时候，还需要考虑硬件的承受范围

二、定义

1.池

降低程序的执行效率，保证计算机硬件的安全

2.进程池

提前创建好固定个数的进程供程序使用，后续不会再创建

3.线程池

提前创建好固定个数的线程供程序使用，后续不会再创建

# 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):
"""异步回调:异步任务执行完成后有结果就会自动触发该机制"""
        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)  # 8.01237154006958   协程 5.015487432479858

协程实现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.文本文件

​ 文件路径可能不一致：C:\aaa.txt D:\aaa\a.txt

​ 数据格式也可能不一致：jason|123 sd$123

2.软件开发目录

​ 规定了数据文件的大致存储位置：db文件夹

​ 针对数据格式还是没有完全统一：比如统一json文件但是内部键值对不同

3.数据库服务

​ 统一了存取位置，也统一了数据格式（完全统一）

二、数据库软件应用史

1.单机游戏

​ 不同的计算机上的相同程，数据无法共享

​ 数据库服务全部在本地完成

2.网络游戏

​ 不同的计算机上的相同程序，数据可以共享

​ 数据库服务单独在网络架设（远程数据库服务）

三、数据库的本质

1.底层原理角度

​ 数据库是指：专门用于操作数据的进程

​ eg：运行在内存中的代码

2.站在现实应用角度

​ 数据库是指：拥有操作界面的应用程序

​ eg：用于操作进程的界面

3.在不做特殊说明的情况下

​ 数据库是指：数据库软件

​ 数据库软件：本质上是一款cs架构的应用程序

​ 也就是说理论上，每个程序员都可以编写数据库软件

四、数据库的分类

1.关系型数据库

1.1数据的组织方式有明确的表结构

​ ID name password

​ ps：关系型数据库存取数据的方式可以看成是表格

1.2.表与表之间可以建立数据库层面的关系

​ eg：用户表 房屋表

​ ps：只要获取到用户表的一条数据，就可以获取到与之相关的其他表的数据

1.3.对应的软件

​ MySQL、PostgreSQL、MariaDB、Oracle、sqlite、db2、sqlsever

软件	特点
MySQL	开源、使用最广泛、数据库学习必学
PostgreSQL	开源、支持二次开发
MariaDB	开源、与MySQL是同一个作者，用法也极其相似
Oracle	收费，安全性极高、主要用于银行及各大重要机关
sqlite	小型数据库，主要用于本地测试（Django框架自带带该数据库）

2.非关系型数据库

2.1.数据的组织方式没有明确的表结构，是以k：v键值对的形式组织的

​ {'name':'jason'}

​ {'username':'kevin','pwd':123}

2.2.数据之间无法直接建立数据库层面的关系

2.3.对应的软件

​ redis、mongoDB、memcache

软件	特点
redis	目前最火、使用频率最高的缓存型数据库
MongoDB	稳定性数据库、最像关系型的非关系型、主要用于爬虫、大数据
memcache	已经被redis淘汰了

MySQL简介

一、前提

​ 虽然数据库软件各式各样，但是底层操作几乎都是一样的，学会一个其他的都可以快速上手

​ 学习了MySQL基本上就可以快速上手所有的关系型数据库，甚至是非关系型数据库

二、MySQL版本问题

虽然版本有区别，但是在操作上区别不大，主要体现在底层运作

版本	特点
5.6X	前几年使用频率最高的版本
5.7X	最近尝试迁移的版本（频率↑）
8.0X	最新版，功能强大，但是线上环境几乎不用（本地用非常好用）

三、下载与安装

1.下载步骤

​ 1.1.访问官网https://www.mysql.com/

​ 1.2.点击DOWNLOADS

​ 1.3.点击GPL

​ 1.4.点击community server

​ 1.5.点击archives

​ 1.6.点击download

2.解压安装

​ 上述方式下载的压缩包里含有服务端和客户端，支持本地操作

3.主要文件介绍

文件	内容
bin文件夹	mysqld.exe服务端 mysql.exe客户端
data文件夹	存取数据
my-default.ini	默认配置文件

四、基本使用

1.先启动服务器

​ 可能会报错：拷贝关键信息去百度

2.查找mysqld文件位置

​ 启动mysql

​ cmd窗口就是服务端，不要关闭

3.再次开启新的cmd窗口

​ 输入mysql运行

​ 直接回车进入游客模式，功能很少

4.用户名密码登录

​ myaql -u 用户名 -p 密码

​ mysql默认管理员账户：

​ 用户名：root 密码：空

5.退出

​ exit()

​ quit

五、系统服务制作

1.如何解决每次都需要切换路径查找文件的缺陷

​ 添加环境变量

2.将mysql服务端制作成系统服务（随着计算机的开启而启动，关闭而关闭）

1.以管理员身份打开cmd窗口
2.执行系统服务命令
	mysql --install
3.启动服务端两种方式
	在服务里直接启动
    命令启动：net start mysql
'''
1.查看系统服务
	service.msc
2.关闭mysql服务端
	net stop mysql
3.移除系统服务
	先确保服务已经关闭
	执行移除命令：mysqld --remove

'''

六、密码相关操作

1.修改密码mysqladmin命令

通用方式：直接在cmd里写

mysqladmin -u用户名 -p原密码 password 新密码
# 第一次修改（初始用户名：root 初始密码：空）
mysqladmin -uroot -p password 123

偏门方法（有些版本无法使用）：需要先登录

set password=PASSWORD(新密码)；

2.忘记密码

直接重装/拷贝对应文件

先关闭服务端，然后以不需要校验用户身份的方式欺负，再修改，最后再安装正常方式启动

1.net stop mysql
2.mysqld --skip-grant-tables
3.mysql -uroot -p
4.updata mysql.user set password=password(123) where Host='localhost' and User='root';
5.net stop mysql
6.net start mysql

七、SQL与NoSQL

1.SQL：操作关系型数据库的语法

2.NoSQL：操作非关系型数据库的语法

ps：SQL有时候也用来表示关系型数据库，NoSQL也用来表示非关系型数据库

3.相关知识

3.1.数据库的服务端支持各种语言充当客户端

​ eg：以MySQL服务端为例

​ MySQL客户端、python代码编写的客户端、Java代码编写的客户端

3.2.为了能够兼容所有类型的客户端，有两种策略

​ 服务端兼容：不合理，消耗数据库服务端资源！！

​ 制定统一标准：SQL语句、NoSQL语句

八、数据库重要概念

​ 为了更好地理解，以类比来形容

​ 库 ==== 文件夹

​ 表 ==== 文件夹里的文件

​ 记录 ==== 文件里的一行行的数据

九、针对库的基本SQL语句

1.常识

SQL结束符：； 取消SQL语句的执行：\c

语句	功能
create database 库名;	增库
show databases； show create database 库名；	查库
alter database 库名 charset='gbk';	改库
drop database 库名;	删库
create table 表名（字段名 字段类型，字段名 字段类型）	新建表
select * from mysql.user;	查看user表里面的所有记录
show tables;	查看所有表
show creat table 表名; describe 表名; desc 表名；	查指定表
after table 旧表名 rename 新表名;	改表名
drop table 表名;	删表
insert into 表名 values(数据，数据);	添加一条数据
insert into 表名 values(数据，数据),(数据，数据),(数据，数据);	在同一个表添加多条数据
select * from 表名;	查看所有字段
select 字段1，字段2 from 表名； ps：如果表中字段较多出现了错乱，结尾可以写\G	查找指定字段
updata 表名 set 字段名=新数据 where 筛选条件；	该记录数据
delete from 表名;	删除表中所有数据
delete from 表名 where 筛选条件	按照条件删除数据

标签：总结,__,进程,线程,time,print,import
来源： https://www.cnblogs.com/Zhang614/p/16586029.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。