dutc

# only works for kwargs
class autoinit(type):
    def __call__(self, *args, **kwargs):
        rv =  super().__call__(*args, **kwargs)
        for k,v in rv.__init__.__annotations__.items():
            setattr(rv, k, eval(v, kwargs))
        return rv

class Foo(metaclass=autoinit):
    def __init__(self, x: 'x + y', y: 'y * 10', z):

dutc

cut -d ';' -f 2- ~/.zsh_history | \
 tr '|;' '\n' | \
 FS=' ' awk '{ print $1 }' | \
 cut -d '/' -f -1 | \
 awk '/^[a-zA-Z]/ { cmds[$0] += 1 } END { for (cmd in cmds) print cmd, cmds[cmd] }' | \
 awk '{ first = tolower(substr($1,1,1)); count = int($2); if (max[first] < count) { max[first] = count; cmds[first] = $1 } } END { for (f in cmds) print f, cmds[f], max[f] }' | \
 sort

dutc

Linux可執行文件ㄉ內容分析工具

NOTE: This is a working copy. This tutorial is unfinished and may contain inaccuracies.

I've written the title of this tutorial in Chinese, as I suspect that its contents may, at first glance, appear similarly incomprehensible to the audience.

However, just as I can sketch for you the following...

可執行文件 = (可 = can) + (執行 = execute) + (文件 = file) = executable (file)

dutc

dutc

from itertools import cycle, chain
xs = [1,2,3]
ys = [4,5,6]
for x,y in chain(zip(cycle([2]), xs), zip(cycle([9]), ys)):
	print(x+y)

dutc

from functools import update_wrapper
from collections import Callable
from logging import info, basicConfig, INFO
 
basicConfig(level=INFO)
 
def dec(name, obj, meth):
    def wrapped(*args, **kwargs):
        rv = meth(*args, **kwargs)
        info('%r:0x%x:%s.%r(*%r, **%r) -> %r', obj, id(obj), name, meth, args, kwargs, rv)

dutc

from collections import deque
class CircularBuffer(deque):
    def __init__(self, *args, **kwargs):
        self.size = kwargs.pop('size', 3)
        super(CircularBuffer, self).__init__(*args, **kwargs)

    def append(self, item):
        while len(self) >= self.size:
            self.popleft()
        super(CircularBuffer, self).append(item)

dutc

def cumsum(xs):
 xs = iter(xs)
 rv = [next(xs)]
  for x in xs:
   rv.append(rv[-1] + x)
 return rv
 
def cumsum(xs):
 tot = 0
 for x in xs:

dutc

class BaseMeta(type):
    def __new__(cls, name, bases, dict):
        if 'foo' not in dict:
            raise RuntimeError('class must have its own foo method!')
        return type.__new__(cls, name, bases, dict)

class Base(metaclass=BaseMeta):
    def foo(self): pass

class Derived(Base):

dutc

class FoobarMeta(type):
    def __instancecheck__(self, obj):
        return hasattr(obj, 'foo') and hasattr(obj, 'bar')

class Foobar(metaclass=FoobarMeta):
    pass

class A:
    def foo(self):
        pass