Python进阶–3

单例模式

常用开发模式之一

用途

确保某一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时

比如，某个服务器程序的配置信息存放在一个文件中，客户端通过一个 AppConfig 的类来读取配置文件的信息。如果在程序运行期间，有很多地方都需要使用配置文件的内容，也就是说，很多地方都需要创建 AppConfig 对象的实例，这就导致系统中存在多个 AppConfig 的实例对象，而这样会严重浪费内存资源，尤其是在配置文件内容很多的情况下。事实上，类似 AppConfig 这样的类，我们希望在程序运行期间只存在一个实例对象。

实现

用到再说

模块–基础

什么是模块？

具有类似功能的函数或类的集合，将这些放在一个文件中，通过调用文件来使用这些功能

  • 特点

不同模块内相同名字的函数不影响

模块调用
  • import 模块名
  • form 模块名 import 变量|函数|类|
  • form 模块名 import *
__all__ = [使用*号可以访问的内容]可以通过上述语句，限制*可以访问的模块内容
只针对此种导入方式有效
  • 注意：
# 被调用的模块# 函数定义
# 类定义
# 变量
# ......if __name__ == "__main__":      # 里面包含某些函数调用语句test()

通过这样写，调用模块：from 模块 import * 的时候，就不会执行这些调用语句，只是加载了这个模块的函数|类等信息

包的调用
  • 简化调用的目的吧，用到了再说
模块的循环导入
  • 有时会因为相互之间的调用，出错
  • 解决办法

改用包的形式

在函数内部导入，而不是在全局导入（比较常用）

代码重构

模块–系统模块

sys模块
time模块
import time# 得到一个时间戳
a = time.time()
print(a)# 将时间戳输出为字符串形式
b = time.ctime(a)
print(b)# 将时间戳输出为元组形式
c = time.localtime(a)
print(c)# 将元组格式的时间转换为时间戳
d = time.mktime(c)
print(d)# 将元组的时间转为字符串
e = time.strftime("%Y-%m-%d %H:%M:%S")
print(e)# 将字符串转换为元组的方式
s = time.strptime("2021/06/21", "%Y/%m/%d")

1629283055.1991527
Wed Aug 18 18:37:35 2021
time.struct_time(tm_year=2021, tm_mon=8, tm_mday=18, tm_hour=18, tm_min=37, tm_sec=35, tm_wday=2, tm_yday=230, tm_isdst=0)
1629283055.0
2021-08-18 18:37:35

datatime模块
# 时间有关模块
random模块
# 随机值模块
hashlib模块
# 加密模块

正则表达式

常用函数
  • group()|groups()|start()|end()|span()

对匹配的结果的处理

import re
line = "This is the last one"
res = re.match( r'(.*) is (.*?) .*', line, re.M|re.I)
if res:print("res.group() : ", res.group())print("res.group(1) : ", res.group(1))print("res.group(2) : ", res.group(2))print("res.groups() : ", res.groups())print("res.start() : ", res.start())print("res.end() : ", res.end())print("res.span() : ", res.span())
else:print("No match!!")

res.group() : This is the last one
res.group(1) : This
res.group(2) : the
res.groups() : (‘This’, ‘the’)
res.start() : 0
res.end() : 20
res.span() : (0, 20)

  • re.match()

尝试从字符串开头匹配一个模式

成功：返回成功匹配的对象

失败：返回None

import remsg = '4534北京欢迎你9809i、'a = re.match('北京欢迎你', msg)
print(a)a = re.match('4534', msg)
print(a.span(), a.group())

None
(0, 4) 4534

  • re.search()

扫描整个字符串，并返回第一次匹配成功的对象

失败则返回None

import re
result = re.search(r'[abc]\*\d{2}','12a*23Gb*12ad')
print(result.group())# 只返回第一次匹配成功的对象，b*12也满足，但是没有匹配

a*23

  • re.sub()

替换特定的字符串，并返回替换后的结果

替换可以是固定的格式，也可以是一种处理规则

import reresult = re.sub('#.*$', 'qqq', 'num = 0 #a number')
print(result)def func(temp):new = temp.group()return str(int(new) + 1)result = re.sub('\d', func, 'num = 0 #a number')
print(result)

num = 0 qqq
num = 1 #a number

  • re.split()

分割字符，返回列表信息

import re
s='abc,  abc,  defg,  dds'
result = re.split('\W+',s)
print(result)

[‘abc’, ‘abc’, ‘defg’, ‘dds’]

  • re.findall()

匹配所有满足要求的字符串，列表形式返回

import re
result = re.findall(r'\w*oo\w*', 'woo this foo is too')
print(result)

[‘woo’, ‘foo’, ‘too’]

  • re.finditer()

功能同于re.findall()

只是返回的类型是一个迭代器，而不是列表，更节省空间

import re
for i in re.finditer(r'\d+','one12two34three56four') :print(i.group())

12
34
56

  • re.compile()

将正则表达式编译成一个语句

这样就可以将常用的正则表达式写的简单一点，方便调用

import re
s = "this  is   a python test"
p = re.compile('\w+') #编译正则表达式，获得其对象
res = p.findall(s)#用正则表达式对象去匹配内容
print(res)

[‘this’, ‘is’, ‘a’, ‘python’, ‘test’]

正则匹配规则
  • 字符串匹配规则

提供一个满足匹配要求的字符串序列

待匹配的字符存在于序列内，就算匹配成功

import re# 匹配一个对象，是0-7的任一个数字
print(re.findall(r'[0-7]', '123qweAV4v'))
# 判断思路就是：1是不是0-7，是，下一个
#           2是不是0-7，是，下一个
#           3是不是0-7，是，下一个
#           q是不是0-7，不是，下一个
#           ......# 匹配一个对象，是小写a-m的任一个字母
print(re.findall(r'[a-m]', '123qweAV4v'))# 匹配一个对象，是大写A-K的任一个字母
print(re.findall(r'[A-K]', '123qweAV4v'))# 匹配一个对象，是数字或字母
print(re.findall(r'[0-9a-zA-Z]', '123qweAV4v'))

[‘1’, ‘2’, ‘3’, ‘4’]
[‘e’]
[‘A’]
[‘1’, ‘2’, ‘3’, ‘q’, ‘w’, ‘e’, ‘A’, ‘V’, ‘4’, ‘v’]

  • 字符匹配规则

匹配单个字符

import re# 匹配数字+字母这样格式的两位字符，例如：1B、2c、4D
print(re.findall(r'\d\w', '123 qw eA V4v'))# 匹配两个连在一次的数字，且第二个数字再结尾，即后边是空格或什么的
print(re.findall(r'\d\d\b', '123 qw eA V4v'))# 匹配 V数字v 这种格式的字符串，并返回这个数字
print(re.findall(r'[V](\d)[v]', '123 qw eA V4vv4v'))

[‘12’, ‘4v’]
[‘23’]
[‘4’]

  • 数量匹配规则

import re# 匹配数字+字母这样格式的两位字符，例如：1B、2c、4D
result = re.findall(r'(.{2}) is .*?', 'xxx is qqq, ooo is bbb')
print(result)

[‘xx’, ‘oo’]

标志位

重复表达式的调用
import restrs = '<html><h1>你好啊<h1><html>'result = re.match(r'(<\w+>)(<\w\d>)(.+)\2\1', strs)
print(result.group())
print(result.group(1))
print(result.group(2))
print(result.group(3))result = re.match(r'(?P<name1><\w+>)(?P<name2><\w\d>)(.+)(?P=name2)(?P=name1)', strs)
print(result.group())
print(result.group(1))
print(result.group(2))
print(result.group(3))

r’(<\w+>)(<\w\d>)(.+)\2\1’

\2 = (<\w\d>)

\1=<\w+>)

r’(?P<\w+>)(?P<\w\d>)(.+)(?P=name2)(?P=name1)’

(?P<\w+>) 表示名字为name1的正则表达式，其表达式为(<\w+>)

(?P=name2) 表示调用名字为name2的正则表达式

贪婪匹配

默认贪婪匹配，尽可能匹配多的字符串

在量词，即数量匹配后面加个？号，就变成非贪婪匹配

import restrs = 'abc123bdb'result = re.match(r'abc(\d+)', strs)
print(result.group())result = re.match(r'abc(\d+?)', strs)
print(result.group())

abc123
abc1

进程

基本概念
  • 多任务

单核CPU：操作系统轮流让各个任务交替执行

例：QQ执行2us，微信执行2us…

切换速度很快，以至于人们以为是在一起执行

多核CPU：可以真正实现多任务执行

每个任务都分配到一个核心上执行，真正实现多任务

但是任务数>>核心数，轮流调度执行还是会存在

  • 并发和并行

并发（Concurrent）：多个线程，且只有一个CPU

一次只能执行一个线程，其他线程处于挂起状态，然后轮流来执行

并行（Parallel）：系统有多个CPU

可能实现非并发，即一个线程有一个CPU来做，另外一个线程有另外的CPU来做

  • 多任务实现模式

基本模式

多进程模式

多线程模式

协程

关系

进程 > 线程 > 协程

一个进程可以有多个线程

一个线程可以有多个协程

  • 进程创建

from multiprocessing import Process

process = Process(target= 函数，name=进程的名字，args=（给函数传递的参数）)

对象调用方法:

process.start() 启动进程并执行任务

process.run() 只是执行了任务但是没有启动进程

terminate() 终止

# 进程创建
import os
from multiprocessing import Process
from time import sleepdef task1(s, name):while True:sleep(s)print('这是任务1.。。。。。。。。。。', os.getpid(), '------', os.getppid(), name)    # 进程ID，父进程IDdef task2(s, name):while True:sleep(s)print('这是任务2.。。。。。。。。。。', os.getpid(), '------', os.getppid(), name)number = 1
if __name__ == '__main__':print(os.getpid())# 子进程p = Process(target=task1, name='任务1', args=(1, 'aa'))  # 进程传参p.start()print(p.name)p1 = Process(target=task2, name='任务2', args=(2, 'bb'))p1.start()print(p1.name)while True:number += 1sleep(0.2)if number == 100:p.terminate()p1.terminate()breakelse:print('---------------->number:',number)print('--------------')print('*****************')

主进程：即整个程序的加载

子进程：程序加载后，运行到P和P1子进程的创建

进程创建之后，不能保证进程间的执行顺序，是随机的

  • 进程间的全局变量问题
# 进程创建
'''多进程对于全局变量访问，在每一个全局变量里面都放一个m变量，保证每个进程访问变量互不干扰。m = 1  # 不可变类型list1 = []  # 可变类型主进程启动子进程，启动之后无法控制是谁先谁后
'''
import os
from multiprocessing import Process
from time import sleepm = 1  # 不可变类型
list1 = []  # 可变类型def task1(s, name):global mwhile True:sleep(s)m += 1list1.append(str(m) + 'task1')print('这是任务1.。。。。。。。。。。', m, list1)def task2(s, name):global mwhile True:sleep(s)m += 1list1.append(str(m) + 'task2')print('这是任务2.。。。。。。。。。。', m, list1)if __name__ == '__main__':# 子进程p = Process(target=task1, name='任务1', args=(1, 'aa'))p.start()p1 = Process(target=task2, name='任务2', args=(2, 'bb'))p1.start()while True:sleep(1)m += 1print('--------->main:', m)
  • 进程间通信
# 进程间通信
from multiprocessing import Queueq = Queue(5)q.put('A')
q.put('B')
q.put('C')
q.put('D')
q.put('E')
print(q.qsize())
if not q.full():  # 判断队列是否满    q.empty()  判断队列是否是空的q.put('F', timeout=3)  # put() 如果queue满了则只能等待，除非有‘空地’则添加成功
else:print('队列已满！')# 获取队列的值
print(q.get(timeout=2))
print(q.get(timeout=2))
print(q.get(timeout=2))
print(q.get(timeout=2))
print(q.get(timeout=2))
print(q.get(timeout=2))# q.put_nowait()
# q.get_nowait()

# 进程间通信
from multiprocessing import Process, Queue
from time import sleepdef download(q):images = ['girl.jpg', 'boy.jpg', 'man.jpg']for image in images:print('正在下载:', image)sleep(0.5)q.put(image)def getfile(q):while True:try:file = q.get(timeout=5)print('{}保存成功！'.format(file))except:print('全部保存完毕！')breakif __name__ == '__main__':q = Queue(5)p1 = Process(target=download, args=(q,))p2 = Process(target=getfile, args=(q,))p1.start()# p1.join()p2.start()# p2.join()      # 阻塞一下print('00000000000')
自定义进程
# 进程：自定义
from multiprocessing import Processclass MyProcess(Process):def __init__(self, name, num):super(MyProcess, self).__init__()self.name = nameself.num = num# 重写run方法def run(self):n = 1while True:# print('进程名字：' + self.name)print('{}--------->自定义进程,n:{}'.format(n, self.name))n += 1if __name__ == '__main__':p = MyProcess('小明', 10)p.start()p1 = MyProcess('小红')p1.start()
进程池
  • 基本概念

当需要创建的子进程数量不多时，可以直接利用multiprocessing中的Process动态成生多个进程，

但如果是上百甚至上千个目标，手动的去创建进程的工作量巨大，此时就可以用到multiprocessing模块提供的Pool方法。

初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，

那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，

直到池中有进程结束，才会创建新的进程来执行。

  • 非阻塞式进程
import os
from multiprocessing import Pool
import time# 非阻塞式进程
from random import randomdef task(task_name):print('开始做任务啦!', task_name)start = time.time()# 使用sleeptime.sleep(random() * 2)end = time.time()# print()# return '完成任务:{}!用时:{},进程id:{}'.format(task_name, (end - start), os.getpid())print('完成任务:{}!用时:{},进程id:{}'.format(task_name, (end - start), os.getpid()))container = []# 回调函数
def callback_func(n):container.append(n)if __name__ == '__main__':pool = Pool(5)tasks = ['听音乐', '吃饭', '洗衣服', '打游戏', '散步', '看孩子', '做饭']for task1 in tasks:pool.apply_async(task, args=(task1,), callback=callback_func)pool.close()  # 添加任务结束pool.join()  #for c in container:print(c)print('over!!!!!')
  • 阻塞式进程
# 阻塞式
import os
import time
from multiprocessing import Pool
from random import random
'''特点：添加一个执行一个任务，如果一个任务不结束另一个任务就进不来。进程池：pool = Pool(max)  创建进程池对象pool.apply()  阻塞的pool.apply_async()  非阻塞的pool.close()  pool.join()  让主进程让步'''def task(task_name):print('开始做任务啦!', task_name)start = time.time()# 使用sleeptime.sleep(random() * 2)end = time.time()print('完成任务:{}!用时:{},进程id:{}'.format(task_name, (end - start), os.getpid()))if __name__ == '__main__':pool = Pool(5)tasks = ['听音乐', '吃饭', '洗衣服', '打游戏', '散步', '看孩子', '做饭']for task1 in tasks:pool.apply(task, args=(task1,))pool.close()pool.join()print('over!!!!')

线程

基本
# 线程
'''考虑？创建线程？ 如何使用线程？t = threading02.Thread(target=download, name='aa', args=(1,))t.start()线程：新建  就绪  运行  阻塞  结束'''#  非阻塞线程   不加join
#   阻塞线程     加joinimport threading# 进程： Process
# 线程:  Thread
from time import sleepdef download(n):images = ['girl.jpg', 'boy.jpg', 'man.jpg']for image in images:print('正在下载:', image)sleep(n)print('下载{}成功！'.format(image))def listenMusic():musics = ['大碗宽面', '土耳其冰淇淋', '烤面筋', '烤馒头片']for music in musics:sleep(0.5)print('正在听{}歌！'.format(music))if __name__ == '__main__':# 线程对象t = threading.Thread(target=download, name='aa', args=(1,))t.start()t1 = threading.Thread(target=listenMusic, name='aa')t1.start()# t.join()# t1.join()n = 1while True:print(n)sleep(1.5)n += 1
线程间的全局变量问题
import threading
from time import sleep'''
线程是可以共享全局变量的
GIL  全局解释器锁'''
ticket = 1000def run1():global ticketfor i in range(100):sleep(0.1)ticket -= 1# def run2():
#     global ticket
#     for i in range(100):
#         ticket -= 1if __name__ == "__main__":# 创建线程th1 = threading.Thread(target=run1, name="th1")th2 = threading.Thread(target=run1, name="th2")th3 = threading.Thread(target=run1, name="th3")th4 = threading.Thread(target=run1, name="th4")# 启动th1.start()th2.start()th3.start()th4.start()th1.join()th2.join()th3.join()th4.join()print('money:', ticket)

线程间共享全局变量

线程间的顺序问题

每个线程都有这些状态：

新建 就绪 运行 阻塞 结束

阻塞之后再运行，是进入就绪状态，然后进去运行

全局解释器GIL（Global Interpreter Lock）

优点

避免死锁，不同的对象，在Python中只能有一个锁。这也提升了单线程的开发效率

即使不是线程安全的 C 语言库，也能很容易的引入到 Python 代码中

缺点

任意时刻，python中只有一个线程在运行，多线程效率低

使用

计算密集型程序，用进程来实现

I/O密集型程序，用线程来实现

GIL在数据运算量大的时候，会释放这个GIL锁

多线程同步
'''
共享数据：如果多个线程共同对某个数据修改，则可能出现不可预料的结果，为了保证数据的正确性，需要对多个线程进行同步。
同步： 一个一个的完成，一个做完另一个才能进来。
效率就会降低。使用Thread对象的Lock和Rlock可以实现简单的线程同步，这两个对象都有acquire方法和release方法，
对于那些需要每次只允许一个线程操作的数据，可以将其操作放到acquire和release方法之间。多线程的优势在于可以同时运行多个任务（至少感觉起来是这样）。
但是当线程需要共享数据时，可能存在数据不同步的问题。
为了避免这种情况，引入了锁的概念。lock =threading.Lock()lock.acquire()  请求得到锁......
lock.release()  释放锁只要不释放其他的线程都无法进入运行状态
'''import threading
import random
import timelock = threading.Lock()list1 = [0] * 10def task1():# 获取线程锁，如果已经上锁，则等待锁的释放# lock.acquire()  # 阻塞for i in range(len(list1)):list1[i] = 1time.sleep(0.5)# lock.release()  释放锁def task2():# lock.acquire()  # 阻塞for i in range(len(list1)):print('---->', list1[i])time.sleep(0.5)# lock.release()if __name__ == '__main__':t1 = threading.Thread(target=task1)t2 = threading.Thread(target=task2)t2.start()t1.start()t2.join()t1.join()print(list1)
死锁与防止
  • 出现原因

程序1拥有A锁，等待B锁释放

程序2拥有B锁，等待A锁释放

  • 防止

代码重构

添加timeout()参数

# 死锁
'''
开发过程中使用线程，在线程间共享多个资源的时候，
如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。
尽管死锁很少发生，但一旦发生就会造成应用的停止响应，程序不做任何事情。避免死锁：
解决：
1. 重构代码
2. 使用timeout参数'''from threading import Thread, Lock
import timelockA = Lock()
lockB = Lock()class MyThread(Thread):# def __init__(self,name):#     passdef run(self):  # start()if lockA.acquire():  # 如果可以获取到锁则返回Trueprint(self.name + '获取了A锁')  #time.sleep(0.1)if lockB.acquire(timeout=5):  # 阻塞print(self.name + '又获取了B锁，原来还有A锁')lockB.release()lockA.release()class MyThread1(Thread):def run(self):  # start()if lockB.acquire():  # 如果可以获取到锁则返回Trueprint(self.name + '获取了B锁')time.sleep(0.1)if lockA.acquire(timeout=5):print(self.name + '又获取了A锁，原来还有B锁')lockA.release()lockB.release()if __name__ == '__main__':t1 = MyThread()t2 = MyThread1()t1.start()t2.start()
生产者与消费者模式
  • 概念

‘’’
生产者与消费者：两个线程之间的通信

Python的queue模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，
LIFO（后入先出）队列LifoQueue，和优先级队列PriorityQueue。这些队列都实现了锁原理
（可以理解为原子操作，即要么不做，要么就做完），能够在多线程中直接使用。
可以使用队列来实现线程间的同步。

‘’’

import threading
import queue
import random
import timedef produce(q):i = 0while i < 10:num = random.randint(1, 100)q.put("生产者产生数据：%d" % num)print("生产者产生数据：%d" % num)time.sleep(1)i += 1q.put(None)# 完成任务q.task_done()def consume(q):while True:item = q.get()if item is None:breakprint("消费者获取到：%s" % item)time.sleep(4)# 完成任务q.task_done()if __name__ == "__main__":q = queue.Queue()arr = []# 创建生产者th = threading.Thread(target=produce, args=(q,))th.start()# 创建消费者tc = threading.Thread(target=consume, args=(q,))tc.start()th.join()tc.join()print("END")

协程

  • 概念明确

进程 > 线程 > 协程

杀毒软件360这个进程可以用杀毒、清理垃圾、扫描盘符这些个线程操作，而扫描盘符这个线程操作可以有扫面C、D、E这些盘的协程操作

主要用于一些耗时操作中

比如网络请求，请求了需要一定时间来响应，如果等着响应，效率就很低

可以在出现耗时的等待响应时，切换为其他协程操作

  • next()实现协程
# 协程：微线程
# 进程 > 线程 > 协程# Process  Thread   生成器完成
import timedef task1():for i in range(3):print('A' + str(i))yieldtime.sleep(1)def task2():for i in range(3):print('B' + str(i))yieldtime.sleep(2)if __name__ == '__main__':g1 = task1()g2 = task2()while True:try:next(g1)next(g2)except:break
  • greenlet()实现
# greenlet 完成协程任务
import time
from greenlet import greenletdef a():  # 任务Afor i in range(5):print('A' + str(i))gb.switch()time.sleep(0.1)def b():  # 任务Bfor i in range(5):print('B' + str(i))gc.switch()time.sleep(0.1)def c():  # 任务Cfor i in range(5):print('C' + str(i))ga.switch()time.sleep(0.1)if __name__ == '__main__':ga = greenlet(a)gb = greenlet(b)gc = greenlet(c)ga.switch()
  • gevent()实现
# 案例
import requests
import gevent
from gevent import monkey
import urllib.requestmonkey.patch_all()      # 猴子补丁，把time.sleep()变为能被感知的耗时操作gevent.sleep()def download(url):response = urllib.request.urlopen(url)content = response.read()print('下载了{}的数据，长度:{}'.format(url, len(content)))if __name__ == '__main__':urls = ['http://www.163.com', 'http://www.qq.com', 'http://www.baidu.com']g1 = gevent.spawn(download, urls[0])g2 = gevent.spawn(download, urls[1])g3 = gevent.spawn(download, urls[2])# gevent.joinall(g1, g2, g3)  # 类似g1.join()g2.join()g3.join()

知识点 —— Python进阶-3相关推荐

  1. 知识点 —— Python进阶-2

    Python进阶–2 面向对象–基础 引入理解 https://blog.csdn.net/shenzixincaiji/article/details/83576687 类.对象.属性.方法 基础 ...

  2. 知识点 —— Python进阶-1

    Python进阶–1 装饰器 作用 保证在不改变原有函数结构的基础上,实现其功能的添加 即开放封闭原则: 开放:可以增加新的功能 封闭:原函数的代码不能修改 可应用的场景 引入日志 函数执行时间统计 ...

  3. Python 进阶_生成器 生成器表达式

    目录 目录 相关知识点 生成器 生成器 fab 的执行过程 生成器和迭代器的区别 生成器的优势 加强的生成器特性 生成器表达式 生成器表达式样例 小结 相关知识点 Python 进阶_迭代器 & ...

  4. Python 进阶 之 知识点记忆

    Python 进阶 PEP8 编码规范, 及开发中的一些惯例和建议 练习: 规范化这段代码 from django.conf import settings from user.models impo ...

  5. Python进阶6——序列操作

    1.序列的拼接和复制 Python中使用+对序列进行拼接,使用*对序列进行复制 s=str(1234) l=list(range(2,13)) print(s,l) print('---------- ...

  6. Python 进阶之路 (十二) 尾声即是开始

    Python进阶之路总结 大家好,我的<< Python进阶之路>>到这一期就到此为止了,和 <<Python 基础起步>>不同,在掌握了一些基础知识后 ...

  7. 【Python进阶】Python进阶专栏、编程与开源框架知识星球上线，等你来follow

    大家好,今天我将在有三AI开设新专栏<Python进阶>.在这个专栏中,我们会讲述Python的各种进阶操作,包括Python对文件.数据的处理,Python各种好用的库如NumPy.Sc ...

  8. python进阶记录之基础篇二十六_Python进阶记录之基础篇（十六）

    回顾 在Python进阶记录之基础篇(十五)中,我们介绍了面向对象的基本概念以及Python中类和对象的基础知识,需要重点掌握类的创建和对象的使用.今天我们继续讲一下Python中面向对象的相关知识点 ...

  9. python进阶05并发之一基本概念

    原创博客地址:python进阶05并发之一基本概念 大多编程语言,一旦涉及并发,都会比较复杂,知识点也较多(大多为历史问题,很多技术点现在非常少使用了,但语言层面也提供支持,对于这些冷门点,只需要知道 ...

最新文章

  1. 蓝桥杯国赛-矩阵计数三种解法-java实现
  2. Java设计模式(二十二)：原型设计模式
  3. 【译】Private AI — Federated Learning with PySyft and PyTorch
  4. 栈大小和内存分部问题
  5. js文件中怎么使用thymeleaf标签_007、Spring Boot集成Thymeleaf模板引擎
  6. python工程师工资状况_【python工程师工资|python工程师待遇怎么样】-看准网
  7. 【报告分享】2021年中国新锐品牌增长潜力报告.pdf（附下载链接）
  8. 用牛顿法求方程的根的c语言编程,用牛顿迭代法和二分法求方程的根【C语言】...
  9. 我的世界java版_我的世界Java版1.15版本
  10. 汇编调用C函数--利用堆栈传递参数
  11. linux 7启动xserver,linux7.x下配置nginx开机自启动
  12. 【今日CV 计算机视觉论文速览 第95期】Fri, 5 Apr 2019
  13. 【雕爷学编程】Arduino动手做（69）---GY-30环境光传感器
  14. Win10 Synaptics触摸板无法实现双指单击模拟鼠标右键点击的解决办法
  15. Android带数字拼音与带音标拼音互转工具类
  16. 在职研究生读计算机专业,读计算机专业在职研究生让我择业自如高升有望
  17. LINUX--创建新用户为新用户设置权限
  18. P6617 查找 Search (线段树)
  19. 新唐 M451系列APROM与LDROM间跳转
  20. matlab 距平,MATLAB及其在地学中地应用.PDF

热门文章

  1. [转]一个纸杯的测试用例
  2. 【快速入门】华为交换机eNSP简单配置（附缩写总结）
  3. 10大网络美女排行榜(组图)(*^__^*) ……
  4. JQuery 入门 - 附案例代码
  5. html文字加描边效果,怎么用css给文字加描边？
  6. CSDN博客2014年4月24日清理缓存
  7. 英伟达 linux 官方驱动 双显卡,反复几次：今天终于弄好双显卡驱动了！
  8. “2009福布斯中国名人榜”榜单
  9. 基于JMP公差设计探索稳健性的配方和工艺
  10. Acrgis实例操作11--计算整个栅格区域值的总和、人口密度分布趋势图、点数据批量生成面数据