掩码(Python实现)

关于掩码

什么是标志flag

在掩码的语境下,标志flag,是只有1位的掩码,取值范围range(flag)range(\mathrm{flag})满足:

range(flag)={0,1}range(\mathrm{flag}) = \{0, 1\}

flag可以是一个单纯的取值范围为{0,1}\{0,1\}的二值的状态量,也可以是相对于另一个取值范围是{s1,s2}\{s_1, s_2\}的二值的状态量state,所建立一一映射

flag:{s1,s2}{0,1}\mathrm{flag}: \{s_1, s_2\} \leftrightarrow \{0,1\}

Note 更一般而且常见的,标志flag是一个离散的状态量,取值范围是自然数集N\N的子集。它可以是单纯的状态量,也可以是:设存在一个状态量state,它的取值范围range(state)range(\mathrm{state})是离散的,flagrange(state)range(\mathrm{state})到自然数集N\N的映射

flag:range(state)N\mathrm{flag}: range(\mathrm{state}) \to \N

。也即,使用不同的自然数来分别枚举和指代状态量state的各个状态值。

利用异常实现越级return(Python实现)

异常是一类消息

在面向对象的世界里,对象之间的交互表现为消息的传递。

异常也是一种消息,就我的理解,异常并非错误,它经常用来表明存在错误,但本质上它是一类特殊的消息,关联着一种跳出局部范围的机制。

It is my understanding that exceptions are not errors, and that they should only be used for exceptional conditions (e.g. I try to write a file into disk and there is no more space, or maybe I do not have permission), and not for flow control.

—— Is it a good practice to use try-except-else in Python?

而在Python的世界里,所有异常都必须是BaseException的子类。
所谓异常是消息,指的是一个异常对象可以携带信息,捕获异常(就得到了一个异常对象)或者传递一个异常对象,你就可以从这个异常对象中提取信息。这个消息有时会被认为是一个指令或者信号,即便仅仅只是捕获到了一个特定类型的异常对象,例如,某个无限循环中有一个捕获异常的语句,当捕获到某个类型的异常对象时,它就认为接收到了退出的信号,快速、优雅地退出。

CPython中函数的非本地变量

函数对象的特殊属性

NOTE 当前测试的CPython解释器版本为

1
2
3
>>> print(__import__('sys').version)
3.7.3 (default, Mar 27 2019, 16:54:48)
[Clang 4.0.1 (tags/RELEASE_401/final)]

以当前版本的解释器下执行下面的代码,可得到一个Markdown表格

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def outer(freevar=None):
def inner(a, b: int=1, *args, c: str='1', **kwds) -> tuple:
'a test function'
return freevar, a, b, args, c, kwds
return inner

fn = outer()

print('attribute', 'type', 'setable', 'reason', sep=' | ')
print(*'-'*4, sep=' | ')
for attr in dir(fn):
try:
obj = getattr(fn, attr)
setattr(fn, attr, obj)
print('`%s`'%attr, type(obj), True, '', sep=' | ')
except Exception as exc:
print('`%s`'%attr, type(obj), False, '`%s`'%exc, sep=' | ')
attribute type setable reason
__annotations__ <class ‘dict’> True
__call__ <class ‘method-wrapper’> True
__class__ <class ‘type’> False __class__ assignment only supported for heap types or ModuleType subclasses
__closure__ <class ‘tuple’> False readonly attribute
__code__ <class ‘code’> True
__defaults__ <class ‘tuple’> True
__delattr__ <class ‘method-wrapper’> True
__dict__ <class ‘dict’> True
__dir__ <class ‘builtin_function_or_method’> True
__doc__ <class ‘str’> True
__eq__ <class ‘method-wrapper’> True
__format__ <class ‘builtin_function_or_method’> True
__ge__ <class ‘method-wrapper’> True
__get__ <class ‘method-wrapper’> True
__getattribute__ <class ‘method-wrapper’> True
__globals__ <class ‘dict’> False readonly attribute
__gt__ <class ‘method-wrapper’> True
__hash__ <class ‘method-wrapper’> True
__init__ <class ‘method-wrapper’> True
__init_subclass__ <class ‘builtin_function_or_method’> True
__kwdefaults__ <class ‘dict’> True
__le__ <class ‘method-wrapper’> True
__lt__ <class ‘method-wrapper’> True
__module__ <class ‘str’> True
__name__ <class ‘str’> True
__ne__ <class ‘method-wrapper’> True
__new__ <class ‘builtin_function_or_method’> True
__qualname__ <class ‘str’> True
__reduce__ <class ‘builtin_function_or_method’> True
__reduce_ex__ <class ‘builtin_function_or_method’> True
__repr__ <class ‘method-wrapper’> True
__setattr__ <class ‘method-wrapper’> True
__sizeof__ <class ‘builtin_function_or_method’> True
__str__ <class ‘method-wrapper’> True
__subclasshook__ <class ‘builtin_function_or_method’> True

标准式博弈

标准式博弈

对于33元组Γ=(I,S,π)\Gamma=(I,S,\pi)Γ\Gamma被称为标准式博弈(normal form game),如果满足以下条件:

  1. 规定II表示(在Γ\Gamma中)玩家集合II是可列的
  2. S={S[i]iI}S=\bigg\{S[i]\bigg|i \in I\bigg\},规定S[i]S[i]表示玩家ii(在Γ\Gamma中)的策略集合SS表示(在Γ\Gamma中)策略空间
  3. π={π[i]iI}\pi=\bigg\{\pi[i]\bigg|i \in I\bigg\},规定π[i]\pi[i]表示玩家ii(在Γ\Gamma中)的收益函数π\pi表示(在Γ\Gamma中)收益函数组合,即有

π[i]:SR\pi[i]:S \to \mathbb R

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×