13518219792
Queue 叫队列，是数据结构中的一种，基本上所有成熟的编程语言都内置了对 Queue 的支持。
在馆陶等地区，都构建了全面的区域性战略布局，加强发展的系统性、市场前瞻性、产品创新能力，以专注、极致的服务理念，为客户提供成都网站建设、网站设计 网站设计制作按需定制设计,公司网站建设,企业网站建设,品牌网站制作,成都营销网站建设,成都外贸网站建设,馆陶网站建设费用合理。
Python 中的 Queue 模块实现了多生产者和多消费者模型，当需要在多线程编程中非常实用。而且该模块中的 Queue 类实现了锁原语，不需要再考虑多线程安全问题。
该模块内置了三种类型的 Queue，分别是 class queue.Queue(maxsize=0) ， class queue.LifoQueue(maxsize=0) 和 class queue.PriorityQueue(maxsize=0) 。它们三个的区别仅仅是取出时的顺序不一致而已。
Queue 是一个 FIFO 队列，任务按照添加的顺序被取出。
LifoQueue 是一个 LIFO 队列，类似堆栈，后添加的任务先被取出。
PriorityQueue 是一个优先级队列，队列里面的任务按照优先级排序，优先级高的先被取出。
如你所见，就是上面所说的三种不同类型的内置队列，其中 maxsize 是个整数，用于设置可以放入队列中的任务数的上限。当达到这个大小的时候，插入操作将阻塞至队列中的任务被消费掉。如果 maxsize 小于等于零，则队列尺寸为无限大。
向队列中添加任务，直接调用 put() 函数即可
put() 函数完整的函数签名如下 Queue.put(item, block=True, timeout=None) ，如你所见，该函数有两个可选参数。
默认情况下，在队列满时，该函数会一直阻塞，直到队列中有空余的位置可以添加任务为止。如果 timeout 是正数，则最多阻塞 timeout 秒，如果这段时间内还没有空余的位置出来，则会引发 Full 异常。
当 block 为 false 时，timeout 参数将失效。同时如果队列中没有空余的位置可添加任务则会引发 Full 异常，否则会直接把任务放入队列并返回，不会阻塞。
另外，还可以通过 Queue.put_nowait(item) 来添加任务，相当于 Queue.put(item, False) ，不再赘述。同样，在队列满时，该操作会引发 Full 异常。
从队列中获取任务，直接调用 get() 函数即可。
与 put() 函数一样， get() 函数也有两个可选参数，完整签名如下 Queue.get(block=True, timeout=None) 。
默认情况下，当队列空时调用该函数会一直阻塞，直到队列中有任务可获取为止。如果 timeout 是正数，则最多阻塞 timeout 秒，如果这段时间内还没有任务可获取，则会引发 Empty 异常。
当 block 为 false 时，timeout 参数将失效。同时如果队列中没有任务可获取则会立刻引发 Empty 异常，否则会直接获取一个任务并返回，不会阻塞。
另外，还可以通过 Queue.get_nowait() 来获取任务，相当于 Queue.get(False) ，不再赘述。同样，在队列为空时，该操作会引发 Empty 异常。
Queue.qsize() 函数返回队列的大小。注意这个大小不是精确的，qsize() 0 不保证后续的 get() 不被阻塞，同样 qsize() maxsize 也不保证 put() 不被阻塞。
如果队列为空，返回 True ，否则返回 False 。如果 empty() 返回 True ，不保证后续调用的 put() 不被阻塞。类似的，如果 empty() 返回 False ，也不保证后续调用的 get() 不被阻塞。
如果队列是满的返回 True ，否则返回 False 。如果 full() 返回 True 不保证后续调用的 get() 不被阻塞。类似的，如果 full() 返回 False 也不保证后续调用的 put() 不被阻塞。
queue.Queue() 是 FIFO 队列，出队顺序跟入队顺序是一致的。
queue.LifoQueue() 是 LIFO 队列，出队顺序跟入队顺序是完全相反的，类似于栈。
优先级队列中的任务顺序跟放入时的顺序是无关的，而是按照任务的大小来排序，最小值先被取出。那任务比较大小的规则是怎么样的呢。
注意，因为列表的比较对规则是按照下标顺序来比较的，所以在没有比较出大小之前 ，队列中所有列表对应下标位置的元素类型要一致。
好比 [2,1] 和 ["1","b"] 因为第一个位置的元素类型不一样，所以是没有办法比较大小的，所以也就放入不了优先级队列。
然而对于 [2,1] 和 [1,"b"] 来说即使第二个元素的类型不一致也是可以放入优先级队列的，因为只需要比较第一个位置元素的大小就可以比较出结果了，就不需要比较第二个位置元素的大小了。
但是对于 [2,1] 和 1 [2,"b"] 来说，则同样不可以放入优先级队列，因为需要比较第二个位置的元素才可以比较出结果，然而第二个位置的元素类型是不一致的，无法比较大小。
综上，也就是说， 直到在比较出结果之前，对应下标位置的元素类型都是需要一致的 。
下面我们自定义一个动物类型，希望按照年龄大小来做优先级排序。年龄越小优先级越高。
本章节介绍了队列以及其常用操作。因为队列默认实现了锁原语，因此在多线程编程中就不需要再考虑多线程安全问题了，对于程序员来说相当友好了。
函数签名说的已经比较清楚了啊：
In [7]: random.randrange?
Signature: random.randrange(start, stop=None, step=1, _int=type 'int', _maxwidth=L)
Docstring:
Choose a random item from range(start, stop[, step]).
This fixes the problem with randint() which includes the
endpoint; in Python this is usually not what you want.
File: /usr/lib/python2.7/random.py
Type: instancemethod
In [8]: random.uniform?
Signature: random.uniform(a, b)
Docstring: Get a random number in the range [a, b) or [a, b] depending on rounding.
File: /usr/lib/python2.7/random.py
Type: instancemethod
randrange 是从 range(start, stop[, step]) 随机挑选一个，生成的一定是 int ；
uniform 是从 [a, b) 或 [a, b] 中生成一个随机数，生成的是 float；
这两个使用场景完全不一样啊，没有什么相互替代的说法
input("提示性信息")
如：
input("请输入数字")
因为 Python 没有特别人为规定数据类型，数据类型是由计算机进行判定，所以我们 input() 输入的数据均默认作为字符串处理，而如果要输入一些数字，着需要 eval() 评估函数对字符串进行评估，化为语句（数字）。
print(...)
默认空一行，如果想不空行，则
print(...., end = "")
特性：
进制：
特性：
浮点数间运算存在不确定尾数，不是 bug
如：0.1+0.3 → 0.4
0.1+0.2 → 0.30000000000000004
这是由于在计算机中一切数据都是化为二进制进行存储的，而有的浮点数并不能完全化为相等的二进制数，只能无限趋近于二进制数。
如：0.1 →
解决方法：
四舍五入：
例如：z = 1.23e-4 + 5.6e+89j
z.real 获得实部，z.imag 获得虚部
三种类型存在一种逐渐“扩展”或“变宽”的关系：
整数 → 浮点数 → 复数
特点：
字符串有 2 类共 4 种表示方法：
扩展：
使用[]获取字符串中一个或多个字符
使用[M:N:K]根据步长对字符串切片
{参数序号:格式控制标记}
右对齐
^ 居中对齐 | 槽设定的输出宽度 | 数字的千位分隔符 | 浮点数小数精度 或 字符串最大输出长度 | 整数类型
b , c , d , o , x , X
浮点数类型
e , E , f , % |
填充、对齐、宽度这三个一组，例如：
"{0:=^20}".format("PYTHON")
→ '=======PYTHON======='
"{0:*20}".format("BIT")
→ '*****************BIT'
"{:10}".format("BIT")
'BIT '
剩下的三个一组，例如：
"{0:,.2f}".format(12345.6789)
→ '12,345.68'
"{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}x".format(425)
→ '110101001,Σ,425,651,1a9,1A9'
"{0:e},{0:E},{0:f},{0:%}".format(3.14)
'3.140000e+00,3.140000E+00,3.140000,314.000000%'
↓CloseCode↓
使用 raise 语句抛出一个指定的异常。
raise [Exception [, args [, traceback]]]
紧凑形式：适用于简单表达式的二分支结构
表达式1 if 条件 else 表达式2
例如：
↓CloseCode↓
↓CloseCode↓
↓CloseCode↓
↓CloseCode↓
例如：
↓CloseCode↓
运行结果：
↓CloseCode↓
↓CloseCode↓
例如：
↓CloseCode↓
运行结果：
↓CloseCode↓
↓CloseCode↓
例如：
↓CloseCode↓
运行结果：
↓CloseCode↓
↓CloseCode↓
例如：
↓CloseCode↓
运行结果：
↓CloseCode↓
↓CloseCode↓
例如：
↓CloseCode↓
运行结果：
↓CloseCode↓
由条件控制的循环运行方式
↓CloseCode↓
例如：
↓CloseCode↓
运行结果：
↓CloseCode↓
↓CloseCode↓
↓CloseCode↓
例如：
↓CloseCode↓
运行结果：
↓CloseCode↓
例如：
↓CloseCode↓
运行结果：
↓CloseCode↓
↓CloseCode↓
可选参数例如：
↓CloseCode↓
运行结果：
↓CloseCode↓
可变参数例如：
↓CloseCode↓
运行结果：
↓CloseCode↓
在函数定义中，经常会碰到 *args(arguments) 和作为参数 **kwargs(keyword arguments)。
（事实上在函数中，和才是必要的，args 和 kwargs 可以用其他名称代替）
*args 是指不定数量的非键值对参数。
**kwargs 是指不定数量的键值对参数。
*args 作为作为元组匹配没有指定参数名的参数。而 **kwargs 作为字典，匹配指定了参数名的参数。
*args 必须位于 **kwargs 之前。
args( 通常紧跟一个标识符，你会看到a或者args都是标识符)是python用于接收或者传递任意基于位置的参数的语法。当你接收到一个用这种语法描叙参数时（比如你在函数def语句中对函数签名使用了星号语法），python会将此标识符绑定到一个元祖，该元祖包含了所有基于位置的隐士的接收到的参数。当你用这种语法传递参数时，标识符可以被绑定到任何可迭代对象（事实上，它也可以是人和表达式，并不必须是一个标识符），只要这个表达式的结果是一个可迭代的对象就行。
**kwds(标识符可以是任意的，通常k或者kwds表示)是python用于接收或者传递任意基于位置的参数的语法。（python有时候会将命名参数称为关键字参数，他们其实并不是关键字--只是用他们来给关键字命名，比如pass,for或者yield，还有很多，不幸的是，这种让人疑惑的术语目前仍是这门语言极其文化根深蒂固的一个组成部分。）当你接收到用这种语法描叙的一个参数时（比如你在函数的def语句中对函数签名使用了双星号语法）python会将标识符绑定到一个字典，该字典包含了所有接收到的隐士的命名参数。当你用这种语法传递参数时，标识符只能被绑定到字典（我ID号I它也可以是表达式，不一定是一个标识符，只要这个表达式的结果是一个字典即可）。
当你在定义或调用一个函数的时候，必须确保a和k在其他所有参数之后。如果这两者同时出现，要将k放在a之后。
lambda函数返回函数名作为结果
↓CloseCode↓
例如：
↓CloseCode↓
运行结果：
↓CloseCode↓
谨慎使用lambda函数
正文
你有没有想过 with 语句是什么以及我们为什么使用它呢？请阅读这篇文章！我们中的许多人在 Python 代码中一遍又一遍地看到这个代码片段： with open( 'Hi.text' , 'w' ) as f:
f.write( "Hello, there" )
但是，我们中的一些人不知道 with 有什么用，以及为什么我们需要在这里使用它。在此阅读中，您将找到关于 with 可解决的几乎所有问题。让我们开始吧！
首先，让我们考虑一下如果不使用 with 关键字我们需要做什么。在这种情况下，我们需要先打开文件并 尝试 执行 write 。不管成功与否，我们最好在 最后 关闭它，所以我们的代码将如下所示：
f = open( 'Hi.text' , 'w' )
try :
f.write( 'Hello, there' )
finally :
f.close()
那么， with 关键字有什么用呢？它只是有助于将我们的 try..finally 代码缩短为 with... 的单个语句！这就是 with 语句用法。
那么，它到底是什么？事实上， with 语句本身在 Python 中并没有什么特别之处，它只是 Python 中 上下文管理器 的一个特性。 上下文管理器 ，引用自 Python 官方文档， 是一种让您在需要时准确分配和释放资源的方法 ，或者简单来说： 当您在某些资源上做某事时缩短您的代码片段 ，这意味着您可以自己定义 with 语句的用法！
我们如何做到这一点？嗯，很简单，你只需要实现两个 魔术函数 ：一个叫做 __enter__ ，另一个叫做 __exit__ 。第一种方法是编写一个实现这两个函数的类，如下所示：
class My_file :
def __init__ (self, fname):
self.fname = fname
def __enter__ (self):
self.file = open(self.fname, 'w' )
return self.file
def __exit__ (self, exc_type, exc_val, exc_trace_back):
if self.file:
self.file.close()
在这里，我们创建了一个普通的 Python 类，实现了两个魔术函数。注意这两个函数的签名： __enter__ 只接受 self ，而 __exit__ 将接受更多参数，示例中的这三个是标准形式。这样，我们就可以直接使用：
with My_file( 'hello.txt' ) as f:
f.write( 'hello, world!' )
这里的 with 语句会先调用 __init__ 构造一个新对象，然后再调用 __enter__ 方法；最后，它会在代码块完成之前触发 __exit__ 方法。所以，上面代码的大致等价如下：
myfile = My_file( 'hello.txt' )
f = myfile.__enter__()
f.write( 'hello, world!' )
myfile.__exit(...)
实现 上下文管理器 的第二种方法是通过 装饰器 ，如下：
1.你 import contextmanager from contextlib
2.你写一个函数来实现你想要的 with 语句。
3.在函数上方添加一个装饰器 @contextmanager 。
4.使用你的 with your_function ！
根据上面的介绍，让我们写一个 装饰器上下文管理器 ！
from contextlib import contextmanager
@contextmanager
def my_file_open (fname):
try :
f = open(fname, 'w' )
yield f
finally :
print( 'Closing file' )
f.close()
with file_open( 'hi.txt' ) as f:
f.write( 'hello world' )
@contextmanager
def closing (f):
try :
f.write( "Finish writing" )
finally :
f.close()
with closing(open( "hi.text" )):
f.write( "hello world" )
例如，在上面的代码中，我们可以直接调用 with close(your_way_of_getting_resource) ，在你下面写的代码块即将完成之前（ f.write("hello world") ），它会执行 try..finally 我们在上面定义的块。另一个是使用 suppress 工具。我们知道，在很多情况下，如果我们尝试获取一些资源，很可能在打开文件时会出现 FileNotFoundException 等错误。在某些情况下，我们希望捕获错误或抑制错误，以便程序继续正常运行。 suppress 是我们可以抑制警告的一种方式。你需要做的就是弄清楚你想要抑制哪个异常，并编写 with suppress(your_choice_of_exception) ，Python 将从这里开始处理它。在其他情况下，您可能只想在输入 with 代码块时执行某些操作。在这种情况下， nullcontext 对你来说会很方便。 nullcontext 只会返回你在 __enter__ 函数中定义的东西，而不会做任何其他事情。如果您在 Python 中处理 async 操作以访问资源，则 aclosure 是处理这种情况的实用工具。
总结
本文介绍了 with 语句的一些基本概念和用法及其底层工作原理。还有很多有趣的东西，请查看 Python 的 contextlib 文档。最后，祝您能像往常一样快乐学习和快乐编码！
链接：
你还有什么想要补充的吗？
