本文目录一览：
- 1、Python有哪些黑魔法？
- 2、有多少人按@萧井陌大神给出的Python+Flask路线找到工作了
- 3、求《Python黑魔法指南2.0》全文免费下载百度网盘资源,谢谢~
- 4、Python有哪些黑魔法
- 5、40.少有人知的 Python“重试机制”
- 6、Python 有什么奇技淫巧
Python有哪些黑魔法？
当然，Python的黑魔法是所有的内省和动态绑定。
例如，Python可以重新绑定解释器的异常，以便在程序异常结束时可以进行一些自定义处理。
一旦你重置了异常钩子，一旦你的代码抛出一个异常，整个解释器的环境将被ipdb接管，然后被用作交互模式。通常，我将检查堆栈并pickle必要的对象，因此稍后再犯错误更容易。
由于IPython是一个非gui程序，所以即使在SSH中也可以使用它，这是SSH缺少IDE的完美解决方案。
动态绑定的另一个用途是，当程序依赖于修改后的库时，可以将修改后的部分剥离，并在运行时动态绑定到相应的库。
在内省中，Python可以通过dir()和help()函数获取列表并帮助对象的成员，当您找不到库文档时，这些函数非常有用。只要开发人员在函数下面写注释，您就可以在帮助中看到它。
除了上面提到的特性之外，python还有一些小技巧，还有一些其他的答案。尽管它们中的许多都是语法上的糖，但它们可以使程序更有python:使用槽使成员静态，您可以节省大量的内存。装饰器，常用的功能，例如函数计时，也可以用来生成新的函数签名。函数签名可以影响传递检查和ide完成，这对于具有不确定的长参数的函数非常有用。许多库使用这种方法来处理不同版本的API。生成器，它可以为仅仅遍历数据保存大量的内存。参数也展开了。
典型的例子是zip(listx)和链(listx)，它们分别对应于转置和连接。如果name==“main”:检查主程序是否被调用，主程序必须与多处理并行使用这个框。例如，枚举将列表转换为list2index可以用于((x，I)for I，枚举列表中的x(listx))namedtuple，生成类似于C语言的结构，并支持所有元组的语法。不初始化该词的defaultdictionary可以使用lambda来实现嵌套结构默认的结构的嵌套结构(lambda:defaultdictionary(int))，或者甚至是递归字典树=lambda:defaultdictionary(树)
有多少人按@萧井陌大神给出的Python+Flask路线找到工作了
今天拿到offer了，一直围观此问题，终于可以轮到我装逼了233
找工作前后花了整好一个月，我是一个月前的今天飞北平。不过第一张简历是上周日投的，投的知乎，然后被拒了，气得我当场卸载了知乎app。然后每天投一份，直到昨天接到面试通知，今天面了一下午通过。
先说一下背景吧。说真的楼上你们这些科班出身甚至本来就从事web前后端的号称花了一个月成功找到相关工作的，真是太打击我们这些转大行的了。
本人211土木专业本科，去年毕业还去工地吃了一年的屎，今年十一月裸辞。Python是大四学的，不过主要是为NumPy去的。
没有任何项目经历，截止到今天为止唯一的项目还是自己的博客，还是两周前动工的，还没写完，前端真的太恶心了，再让我写css自杀。
没做过ACM，没用过Linux，没写过Vim。
没学过网络原理、操作系统、数据结构、数据库。
Matlab技能点倒是丰富；我本科真的毁在数学建模上了。人在做，天在看，数学建模留祸患！
基本就是这样。
到北平后的四周里有两周都花在LeetCode上。不得不说LeetCode大法好啊，今天面试的算法题全是原题，我心里跟撕了一万条藏獒一样爽。
剩下的时间基本都是在Flask里来回折腾，不过真的啃不动啊，我真的不懂什么是TCP协议，什么的socket。今天面试的web基础问题全部跪了，唯一一道答上来的是“说说四种请求方式”，而我只知道get, post, put，太JB感人了。
面试全靠算法和Python基础拿分，稍微问了问MySQL，问的很简单，LeetCode的DB题比这些高到不知道哪里去了；Python问的最高语法居然是生成器，我听说有人都被问到修饰符了吓得我赶紧买了本Python Pocket Reference通宵背了一遍；问了一个Maximum Subarray这个题，我做的时候是用的分治法做的，他们居然不满意，非要引导我想出线性时间算法，但是我根本理解不了面试官在说啥，硬着头皮想出一个双指针算法居然得到了好评；二面的时候问的如何列表去重，空间复杂度和时间复杂度一步步做要求时的不同算法，然后让我实现了一遍MergeSort；问了问Vim的几个常用命令，小case。
然后HR来谈待遇，就过了。。。
说一下公司，A轮融资完成，130人规模，O2O，待遇没超过10k，爬虫岗，虽然我从来没有写过爬虫。
列一下书单吧：
Python类
Python CookBook，我一直把这书翻译为Python黑魔法，尤其到元编程那章，真他妈黑。
Learning Python，大四时候就是抱着这书入门的，不过坑爹的中译本居然把装饰器、修饰符、元类这么重要的部分给贸然截除了，我已经报警很多次了。
编写高质量代码——改善Python程序的91个建议，我完全用来当做查漏补缺的作用了，比如看看自己对mro的理解有没有偏差什么的。
Python Pocket Reference，纯粹是为了应付面试，我怕他问我内置函数或者常用的标准库。
没有了
Web类
Flask Web开发，就是萧大推荐的啦，虽然一遍一遍地看也还是停留在默写出代码的水平，但是我会努力把Flask源码也背下来的！（大误）
Head First HTML and CSS，我真的好想说，这本书的信息量密度好低啊，书又那么贵又厚，害得我花了一天时间才看完，而且看完后基本忘完了。
深入理解Bootstrap，纯粹是为了写我的博客买的，买了以后才发现，妈的，不是有中文官网吗。
图解TCP/IP，花了一天看完，看完后觉得自我感觉良好，结果还是看不懂Python Cookbook第11章，很难过。
没有了
其他
Learning SQL，好书啊，真的推荐，虽然概念解释得稀烂，比如我是直到今天早上才知道应该怎么回答“谈谈事务吧”，还是上网搜的。
GitHub入门，千万别买，因为你就算看完后还是不知道该如何push你的代码到你的repository，直接上GitHub看tutorial好了。
挑战程序设计竞赛，非常低调的书名，但是真的太棒了！我的数据结构和算法全是从上面学到的！应付面试的话图论之后的不用看了，但是我不得不说网络流那章非常精彩！
Vim实用技巧，非常棒，让你逼格提升一个数量级。
没有了
我不去继续写我的博客又在知乎装逼了，今天的contribution又废了。。
祝愿所有的转行生都一切顺利！
说完了，求赞。
求《Python黑魔法指南2.0》全文免费下载百度网盘资源,谢谢~
《Python黑魔法指南2.0》百度网盘pdf最新全集下载:
链接：
?pwd=8mkk 提取码：8mkk
简介：作者（明哥）是一个从事云计算多年的 Python 重度用户，他把自已多年的 Python 编码经验整理成小册子。
全书合计将近 5 万字，收录了近 100 条的 Python Tips，没有长篇大论，每一篇都是精品，可以让你一天之内，就能收获别人几年的 Python 技能及魔法知识。
Python有哪些黑魔法
说到python黑魔法，必然要提到python的第三方协程库gevent的底层实现——greenlet。
greenlet直接在内存层面，通过保存和替换Python进程的运行栈来实现不同协程的切换。
这个切换对于python解释器是透明的，如果python解释器对环境有感知的话，则每当协程切换的时候，它的感觉可能类似一个人前一秒还在在路上走路，下一秒突然自己又出现在了地铁上。
对于普通python用户而言，直接操作python的运行时栈，这就是在刀尖上跳舞有木有，这要求对内存的操作100%精确，任何错误都可能导致python进程崩溃！
那
作者又是如何又是如何来保证正确性呢？除了要熟悉python、操作系统、编译器等等的底层机制，明确设计方案，还需要对不同的系统以及硬件环境做对应的
适配工作。我们在使用python的时候，在不同的系统或者硬件下感觉都一样，那是因为python本身为我们屏蔽了底层细节，在做这种python底层
hack的事情的时候，显然就没那么轻松了。
举个例子，由于CPU有很多种，例如i386、x86_64、arm等等，每种CPU的设计不尽相同，于是作者为每种CPU写了对应的汇编操作指令来完成栈的保存和替换，这些操作都是与操作系统和硬件高度绑定的。
虽然greenlet的实现这么bt，但就是有人做到了，加上gevent的封装，用起来比python自带协程好用太多。
我想任何对python比较熟悉的童鞋，在初次接触gevent的时候，都会好奇它是如何做到的，在进一步了解其底层greenlet实现机理之后，无不惊叹其鬼斧神工。
这种事情就是那种，别人不说，你可能永远不会想到的事情。
转载
40.少有人知的 Python“重试机制”
为了避免由于一些网络或其他不可控因素，而引起的功能性问题。比如在发送请求时，会因为网络不稳定，往往会有请求超时的问题。
这种情况下，我们通常会在代码中加入重试的代码。重试的代码本身不难实现，但如何写得优雅、易用，是我们要考虑的问题。
这里要给大家介绍的是一个第三方库 - Tenacity ，它实现了几乎我们可以使用到的所有重试场景，比如：
在使用它之前 ，先要安装它
无条件重试，重试之间无间隔
无条件重试，但是在重试之前要等待 2 秒
只重试7 次
重试 10 秒后不再重试
或者上面两个条件满足一个就结束重试
在出现特定错误/异常（比如请求超时）的情况下，再进行重试
在满足自定义条件时，再进行重试。
如下示例，当 test_retry 函数返回值为 False 时，再进行重试
如果想对一个异常进行重试，但是最多重试3次。
下面这个代码是无效的，因为它会一直重试，重试三次的限制不会生效，因为它的条件是有顺序的，在前面的条件会先被走到，就永远走不到后面的条件。
如果你把 stop_after_attempt 写到前边，就没有问题了。
当出现异常后，tenacity 会进行重试，若重试后还是失败，默认情况下，往上抛出的异常会变成 RetryError，而不是最根本的原因。
因此可以加一个参数（ reraise=True ），使得当重试失败后，往外抛出的异常还是原来的那个。
当最后一次重试失败后，可以执行一个回调函数
输出如下
摘自黑魔法手册
Python 有什么奇技淫巧
我复制 的，仅供参考，版权归原作者：
1. 元类（metaclass）
PyPy的源码里有个pair和extendabletype
"""
Two magic tricks for classes:
class X:
__metaclass__ = extendabletype
...
# in some other file...
class __extend__(X):
... # and here you can add new methods and class attributes to X
Mostly useful together with the second trick, which lets you build
methods whose 'self' is a pair of objects instead of just one:
class __extend__(pairtype(X, Y)):
attribute = 42
def method((x, y), other, arguments):
...
pair(x, y).attribute
pair(x, y).method(other, arguments)
This finds methods and class attributes based on the actual
class of both objects that go into the pair(), with the usual
rules of method/attribute overriding in (pairs of) subclasses.
For more information, see test_pairtype.
"""
class extendabletype(type):
"""A type with a syntax trick: 'class __extend__(t)' actually extends
the definition of 't' instead of creating a new subclass."""
def __new__(cls, name, bases, dict):
if name == '__extend__':
for cls in bases:
for key, value in dict.items():
if key == '__module__':
continue
# XXX do we need to provide something more for pickling?
setattr(cls, key, value)
return None
else:
return super(extendabletype, cls).__new__(cls, name, bases, dict)
def pair(a, b):
"""Return a pair object."""
tp = pairtype(a.__class__, b.__class__)
return tp((a, b)) # tp is a subclass of tuple
pairtypecache = {}
def pairtype(cls1, cls2):
"""type(pair(a,b)) is pairtype(a.__class__, b.__class__)."""
try:
pair = pairtypecache[cls1, cls2]
except KeyError:
name = 'pairtype(%s, %s)' % (cls1.__name__, cls2.__name__)
bases1 = [pairtype(base1, cls2) for base1 in cls1.__bases__]
bases2 = [pairtype(cls1, base2) for base2 in cls2.__bases__]
bases = tuple(bases1 + bases2) or (tuple,) # 'tuple': ultimate base
pair = pairtypecache[cls1, cls2] = extendabletype(name, bases, {})
return pair
先说extendabletype。嘛 其实注释已经说得听明白了，就是一个C#里面的partial class的Python实现。
然后是pair和pairtype。pairtype就是根据两个类创建一个新的类，这个类继承自使用这两个类的基类构造的pairtype（有点绕……）或者tuple。
有啥用呢？可以拿来实现multimethod。
class __extend__(pairtype(int, int)):
def foo((x, y)):
print 'int-int: %s-%s' % (x, y)
class __extend__(pairtype(bool, bool)):
def bar((x, y)):
print 'bool-bool: %s-%s' % (x, y)
pair(False, True).foo() # prints 'int-int: False, True'
pair(123, True).foo() # prints 'int-int: 123, True'
pair(False, True).bar() # prints 'bool-bool: False, True'
pair(123, True).bar() # Oops, no such method
好像这个例子里元类只是个打辅助的角色，好玩的都在那个pair里……
再换一个。
class GameObjectMeta(type):
def __new__(mcls, clsname, bases, _dict):
for k, v in _dict.items():
if isinstance(v, (list, set)):
_dict[k] = tuple(v) # mutable obj not allowed
cls = type.__new__(mcls, clsname, bases, _dict)
all_gameobjects.add(cls)
for b in bases:
game_objects_hierarchy.add((b, cls))
return cls
@staticmethod
def _dump_gameobject_hierarchy():
with open('/dev/shm/gomap.dot', 'w') as f:
f.write('digraph {\nrankdir=LR;\n')
f.write('\n'.join([
'"%s" - "%s";' % (a.__name__, b.__name__)
for a, b in game_objects_hierarchy
]))
f.write('}')
def __setattr__(cls, field, v):
type.__setattr__(cls, field, v)
if field in ('ui_meta', ):
return
log.warning('SetAttr: %s.%s = %s' % (cls.__name__, field, repr(v)))
这个是从我写的三国杀游戏中提取的一段代码（点我签名上的链接）。大意就是把class上所有可变的容器都换成不可变的，然后记录下继承关系。
曾经被这个问题坑过，class上的值是全局共享的，逻辑代码一不小心修改了class上的值，单机测试的时候是测不出来的，然后放到线上……就悲剧了……当时绞尽脑汁没有想到是这个问题硬生生的回滚了……发现了问题之后就加上了这个东西，不允许修改class上的东西。
记录下继承关系是为了画类图。
还有就是常用的做数据注入
metadata = {}
def gen_metafunc(_for):
def metafunc(clsname, bases, _dict):
meta_for = getattr(_for, clsname)
meta_for.ui_meta = UIMetaDescriptor()
if meta_for in metadata:
raise Exception('%s ui_meta redefinition!' % meta_for)
metadata[meta_for] = _dict
return metafunc
from gamepack.thb import characters
__metaclass__ = gen_metafunc(characters.sakuya)
class Sakuya:
# 于是这个就不是类了， 而是作为数据存到了metadata这个dict里
char_name = u'十六夜咲夜'
port_image = 'thb-portrait-sakuya'
figure_image = 'thb-figure-sakuya'
miss_sound_effect = 'thb-cv-sakuya_miss'
description = (
u'|DB完全潇洒的PAD长 十六夜咲夜 体力：4|r\n\n'
u'|G月时计|r：|B锁定技|r，准备阶段开始时，你执行一个额外的出牌阶段。\n\n'
u'|G飞刀|r：你可以将一张装备牌当【弹幕】使用或打出。按此法使用的【弹幕】无距离限制。\n\n'
u'|DB（画师：小D@星の妄想乡，CV：VV）|r'
)
Ruby党不要喷，我知道你们可以做的更优雅……
2. Python沙盒逃逸
刷新三观的Python代码
3. PEP302 New Import Hook
最近在把刚才提到的纯Python游戏向Unity引擎上移植。
玩过Unity的就会知道，Unity的游戏的资源都是打包在一起的，没有单独的文件，Python解释器就不高兴了……于是写了import hook，用Unity提供的API来读py文件。
# -*- coding: utf-8 -*-
# -- stdlib --
import imp
import sys
# -- third party --
# -- own --
from clr import UnityEngine, WarpGateController
# -- code --
class UnityResourceImporter(object):
known_builtin = (
'sys',
'imp',
'cStringIO',
'gevent_core',
'gevent_ares',
'gevent_util',
'gevent_semaphore',
'msgpack_packer',
'msgpack_unpacker',
'UnityEngine',
)
def __init__(self, bases, unity_loader):
self.bases = bases
self.last_fullname = ''
self.last_text = ''
self.last_ispkg = False
self.unity_load = unity_loader
def find_module(self, fullname, path=None):
if fullname in sys.modules:
return self
head = fullname.split('.')[0]
if head in self.known_builtin:
return None
rst = self.do_load_module(fullname)
if rst:
self.last_text, self.last_ispkg = rst
self.last_fullname = fullname
return self
else:
return None
def load_module(self, fullname):
if fullname in sys.modules:
return sys.modules[fullname]
if fullname != self.last_fullname:
self.find_module(fullname)
try:
code = self.last_text
ispkg = self.last_ispkg
mod = sys.modules.setdefault(fullname, imp.new_module(fullname))
mod.__file__ = "UnityResource: %s" % fullname
mod.__loader__ = self
if ispkg:
mod.__path__ = []
mod.__package__ = fullname
else:
mod.__package__ = fullname.rpartition('.')[0]
co = compile(code, mod.__file__, 'exec')
exec(co, mod.__dict__)
return mod
except Exception as e:
UnityEngine.Debug.LogError('Error importing %s %s' % (fullname, e))
raise ImportError(e)
def do_load_module(self, fullname):
fn = fullname.replace('.', '/')
asset = self.try_load(fn + '.py')
if asset is not None:
return asset, False
asset = self.try_load(fn + '/__init__.py')
if asset is not None:
return asset, True
def try_load(self, filename):
for b in self.bases:
asset = self.unity_load(b + filename)
if asset is not None:
return asset
return None
sys.meta_path.append(UnityResourceImporter([
'Python/THBattle/',
'Python/Site/',
'Python/Stdlib/',
], WarpGateController.GetTextAsset))
需要的extension module都静态编译到解释器里了，所以没考虑。
4. 可以批量执行操作的list
class BatchList(list):
def __getattribute__(self, name):
try:
list_attr = list.__getattribute__(self, name)
return list_attr
except AttributeError:
pass
return list.__getattribute__(self, '__class__')(
getattr(i, name) for i in self
)
def __call__(self, *a, **k):
return list.__getattribute__(self, '__class__')(
f(*a, **k) for f in self
)
class Foo(object):
def __init__(self, v):
self.value = v
def foo(self):
print 'Foo!', self.value
foo = Foo(1)
foo.foo() # Foo! 1
foos = BatchList(Foo(i) for i in xrange(10))
foos.value # BatchList([0, 1, 2, 3, ..., 9])
foos.foo() # 你能猜到的
这个其实不算很黑魔法了，只是感觉很好用也有些危险，所以放上来。
暂时就想到这么多了，以后发现了再补。
