Python 面向对象

# coding: utf-8
# 传参，调用时，传入实际参数
#传参 就2种方式：
#1. 位置传参，和形参依次对应
#2. 关键字传参，按照参数名称对应，与顺序无关
#这两种可以混合使用
#位置传参，不能跟在 关键字传参之后

def add(x, y):
   print(x,y)
   return x + y

#调用时，传参，传入实参的简称
result = add(4, 5) # 位置传参
print(result)
#4 5
#9

add(x=4, y=5) #关键字传参keyword，按参数名称对应，与顺序无关

add(4, y=5) # 正确
#add(x=[4], y=(5,))
#add(y=5, 4) # 错误传参。位置传参，不能跟在关键字之后

print(add) #把这个标识符对应的对象的字符串表达形式给人看
print(id(add), hex(id(add)))
#: <function add at 0x000002AE0CFA6280>
#: 2946565300864 0x2ae0cfa6280

d = dict({'a':1}, b=2, a=3) # dict 中参数按位置传参、按关键字传参
print(d)
#: {'a': 3, 'b': 2}

def add(x=4, y=5):
    return x+y

测试调用 add()、add(x=5)、add(y=7)、add(6, 10)、add(6, y=7)、add(x=5, y=6)、add(y=5, x=6)、
#add(x=5, 6)、add(11, x=20) 不能多重赋值、add(y=8, 4) 传参时缺省值在后面

能否这样定义 def add(x, y=5) 或 def add(x=4,y) ？ def add(x=4, y) 报错，缺省值在后面

# 定义一个函数login，参数名称为host、port、username、password
def login(host='localhost', port=3306, username='root', password='root'):
    print('mysql://{2}:{3}@{0}:{1}/'.format(host, port, username, password))

login()
login('127.0.0.1')
login('127.0.0.1', 3361, 'wayne', 'wayne')
login('127.0.0.1', username='wayne')
login(username='wayne', password='wayne', host='www.xxx.com')

def sum(iterable):
    s = 0
    for x in iterable:
        s += x
    return s

print(sum([1,3,5]))
print(sum(range(4)))

def sum(*nums):
    sum = 0
    for x in nums:
        sum += x
    return sum

print(sum(1, 3, 5))
print(sum(1, 2, 3))

# coding: utf-8
def fn1(*nums): # * 可变形参，可以收多个实参，多个实参被收集到一个元组对象中，元组不可变
    print(nums, type(nums))
    s = 0
    for x in nums:
        s += x
    return s

fn1(1,2,3) # 按照位置传参
#: (1, 2, 3) <class 'tuple'>
fn1()
#: () <class 'tuple'>

# coding: utf-8
def showconfig(**kwargs): # *args **kwargs
    print(type(kwargs), kwargs) # 可变关键字参数收集关键字传参，收集成字典 kv，字典可变
    # 内部，你能传入变量名我们有要求，对kwargs处理，'username' in kwargs.keys()\pop(key)
    for k,v in kwargs.items():
        print('{}={}'.format(k,v), end=', ')

showconfig()
#: <class 'dict'> {}

showconfig(host='127.0.0.1', port=8080, username='wayne', password='xxx')

可以定义为下列方式吗？
def showconfig(username, password, *args) # 只接受可变位置参数
def showconfig(username, password, **kwargs) # 只接受可变关键字参数
def showconfig(username, *args, **kwargs) #位置传参被args占用，关键字传参被kwargs占用
def showconfig(username, password, **kwargs, *args) # ? 报错，*args在前面
def showconfig(*args, **kwargs) # 接收所有参数

# coding: utf-8
def fn(x, y, *args, **kwargs):
    #print(x, y, args, kwargs, sep='\n', end='\n\n')
    print(x, y, args, kwargs)

# fn() fn(range(5)) 不能，range(5) 表示一个对象
fn(1,2), fn(1,2,3), fn(1,2,3,4), fn(1, 2, a=100)
#: 1 2 () {}
#: 1 2 (3,) {}
#: 1 2 (3, 4) {}
#: 1 2 () {'a': 100}

fn(3, 5, 7, 9, 10, a=1, b='abc')
fn(y=5, a=5, x=4)
fn(3, 5, a=1, b='abc')

#fn(x=3, y=8, 7, 9, a=1, b='abc') # ? 报错， 位置传参写在关键字之前
#fn(7, 9, y=5, x=3, a=1, b='abc') # ? 摄报错，重复传参

# keyword-only 仅仅能关键字传参的形参
# 在 * 号后的参数
def fn(*args, x, y, **kwargs): 
    print(x, y, args, kwargs, sep='\n', end='\n\n')

fn(3, 5) # 报错
fn(3, 5, 7) # 报错
fn(3, 5, a=1, b='abc') # 报错
fn(3, 5, y=6, x=7, a=1, b='abc')

def fn(*args, x):
    print(x, args, sep='\n', end='\n\n')

fn(3, 5) # 报错, 3 5 都传给args， x y 没有传参
fn(3, 5, 7) # 报错
fn(3, 5, x=7)

def fn(**kwargs, x):
    print(x, kwargs, sep='\n', end='\n\n')

def fn(*, x, y):
    print(x, y)
fn(x=6, y=7)
fn(y=8, x=9)

def fn2(a, *, x, y):
    print(a, x, y)
fn2(1, y=2, x=3)
#: 6 7
#: 9 8
#: 1 3 2

# coding: utf-8
def fn(a, /):
    print(a, sep='\n')

fn(3)
#fn(a=4) # 错误，仅位置参数，不可以使用关键字传参

def fn(a, /, b):
    print(a, b)
fn(1, 2)
fn(1, b=2)
#fn(a=1, b=2) #报错

def fn(a, b=2, /):
   print(a, b)

fn()
#fn(1, b=3) #报错

# coding: utf-8

def fn(a, b, /, x, y, z=6, *args, m=4, n, **kwargs): # *号后面，只接收关键字传参。n 
    print(a, b)
    print(x, y, z)
    print(args)
    print(m, n)
    print(kwargs)

fn(1, 2, 3, 4, 5, 6, n=10)
#: 1 2
#: 3 4 5
#: (6,)
#: 4 10
#: {}

fn(1, 2, n=20, x=5, y=6, t=10
#1 2
#5 6 6
#()
#4 20
#{'t': 10}

# 可变位置参数、keyword-only参数、缺省值
def fn(*args, x=5):
    print(x)
    print(args)

fn() # 等价于fn(x=5)
fn(5) # 5给了args
fn(x=6)
fn(1,2,3,x=10)

# 普通参数、可变位置参数、keyword-only参数、缺省值
def fn(y, *args, x=5):
    print('x={}, y={}'.format(x, y))
    print(args)

fn() #报错，y 必须给
fn(5)
fn(5, 6)
fn(x=6) #报错，y 没给
fn(1, 2, 3, x=10)
fn(y=17, 2, 3, x=10) #语法错误，关键字在后面
fn(1, 2, y=3, x=10) #错误，重复传参
fn(y=20, x=30)

# 普通参数、缺省值、可变关键字参数
def fn(x=5, **kwargs):
    print('x={}'.format(x))
    print(kwargs)

fn()
fn(5)
fn(x=6)
fn(y=3, x=10)
fn(3, y=10)
fn(y=3, z=20)

# a和b是仅位置参数，只能用在python3.8后
def fn(a, b, /, x, y, z=3, *args, m=4, n, **kwargs):
    print(a, b)
    print(x, y, z)
    print(m, n)
    print(args)
    print(kwargs)
    print('-' * 30)

def connect(host='localhost', user='admin', password='admin', port='3306',**kwargs):
    print('mysql://{}:{}@{}:{}/{}'.format(
        user, password, host, port, kwargs.get('db', 'test')
    ))

connect('127.0.0.1', 'admin', 'abcdef', debug=True, db='blog')
connect(db='cmdb') # 参数的缺省值把最常用的缺省值都写好了
connect(host='192.168.1.123', db='cmdb')
connect(host='192.168.1.123', db='cmdb', password='mysql')

def foo():
    x = 100
print(x) # 可以访问到吗

# 局部变量
def fn1():
    x = 1 # 局部作用域，x为局部变量，使用范围在fn1内

def fn2():
    print(x) # x能打印吗？可见吗？为什么？ 
print(x) # x能打印吗？可见吗？为什么？ 不可见，x 的可见范围就在fn1函数里。全局环境中没有定义x

# coding: utf-8
# 全局变量
x = 5 # 全局变量，也在函数外定义
def foo():
    y = x + 1
    print(x) # 可见吗？为什么？ 可见。函数局部变量，对外不可见；外部对内可见，向内穿透
    print(y)

foo()
#: 5
#: 6

def outer():
    def inner():
        print("inner")
    inner()
    print("outer")
outer() # 可以吗？ 可以
inner() # 可以吗？ 内部函数不能在外部直接使用，因为它在函数外部不可见

x = 5
def foo():
   x += 1

foo() # 报错如下， UnboundLocalError

x = 5
def foo(): # 函数被解释器解释，foo指向函数对象，同时解释器会理解x是什么作用域
    print(x) # x 在函数解析时就被解释器判定为局部变量
    x += 1 # x = x + 1
foo() # 调用时

# coding: utf-8
x = 5
def foo():
    global x # 全局变量。 将x声明为全局变量
    x += 1
    print(x)

foo()
#: 6

# 有错吗？
def foo():
    global x
    x += 1
    print(x)

foo()

# 有错吗？
def foo():
    global x
    x = 10
    x += 1
    print(x)

foo()
print(x) # 可以吗

# coding: utf-8

def counter():
    c = [0]
    def inc():
        c[0] += 1
        return c[0]
    return inc #有意为之，就是要返回函数，函数用foo变量记住，c闭包必需保留

#出错吗？
#有闭包吗？

foo = counter() #? 可执行，不出错。foo 就是 inc，但是counter已经调用结束，内部局部变量按道理要消亡
print(foo(), foo()) #? 1 2 foo指向inc函数对象，没有被释放。c[0] 是闭包上的c
c = 100
print(foo()) #? 3 foo中的c是局部变量，随着counter()函数执行完，c标识符已经消亡了

def counter():
    c = [0]
    def inc():
        c[0] += 1 # 报错吗？ 为什么 # line 4
        return c[0]
    return inc

foo = counter() # line 8
print(foo(), foo()) # line 9
c = 100
print(foo()) # line 11

def counter():
    count = 0
    def inc():
        count += 1
        return count
    return inc

foo = counter()
print(foo(), foo())

def counter():
    global count
    count = 0
    def inc():
        global count
        count += 1
        return count
    return inc

foo = counter()
print(foo(), foo())
count = 100
print(foo()) # 打印几？

# coding: utf-8
#阶乘公式。三元表达式

def factorial(n):
#    if n == 1:
#        return 1
#    elif n == 2:
#        return 2
#    if n == 2:
#        return 2
    if n < 3:
        return n
    return n * factorial(n-1) #公式


def factorial(n):
    return n if n < 3 else n * factorial(n-1)

print(factorial(3))

#循环
def factorial(n=6):
    p = 1
    for i in range(1, n+1):
        p *= i
    return p

def factorial(n=6, p=1): #将上次结果带入
    if n == 1:
        return p
    return factorial(n-1, p * n)

def factorial(n=6, p=1): #将上次结果带入
    return p if n == 1 else factorial(n-1, p * n)

print(factorial(6))

# coding: utf-8

#循环版本
def  peach():
    total = 1
    for i in range(9):
        total = 2*(total + 1)
    return total

#递归
def peach(days=10):
    if days == 1:
        return 1
    return 2 * (peach(days-1) + 1)

print(peach())
#: 1534

# coding: utf-8
def peach(days=1):
    if days == 10:
        return 1
    return 2 * (peach(days+1) +1)

print(peach()) #第10下只是为了进入函数解底反弹的

def peach(days=9, p=1):
    if days == 0:
        return p
    return peach(days-1, 2*(p+1))

# coding: utf-8
#内建函数实现
print(list(map(int, reversed(str(1234)))))
#: [4, 3, 2, 1]

x = 1234
while x != 0:
    x, y = divmod(x, 10)
    print(x, y)
    print(y, '~~')

#字符串递归切片
x = str(1234)

def revert(data):
    if not data:
        return []
    return [data[-1]] + revert(data[:-1])

print(revert(x))
#['4', '3', '2', '1']

#字符串
x = str(1234)

target = []

def revert(data):

    if not data:
        return
    target.append(data[-1])
    return revert(data[:-1])

revert(x)
print(target)
#['4', '3', '2', '1']
del target

#字符串
x = str(1234)
#target = []
def revert(data, target=[]):
    if not data:
        return target
    target.append(data[-1])
    return revert(data[:-1], target)
print(revert(x))
#['4', '3', '2', '1']

#数值
x = 123045
x = 100

def revert(data, target=[]):
    if data == 0:
        return target
    x, y = divmod(data, 10) #10 0; 1 0; 0 1
    target.append(y)
    return revert(x, target)

print(revert(x))


#数值
x = 123045

def revert(data, target=None):
    if target is None:
        target = []
    if data == 0:
        return target
    x, y = divmod(data, 10) #10 0; 1 0; 0 1
    target.append(y)
    return revert(x, target)

print(revert(x))
print(revert(x, None))
#[5, 4, 0, 3, 2, 1]

# coding: utf-8

d = {'a':{'b':1, 'c':2}, 'd':{'e':3, 'f':{'g':4}}}

target = {}

def flat_map(src:dict): # :dict参数注解，说明src的类型，但不强制
    for k, v in src.items():
        print(k)
        if isinstance(v, dict):
            print(v, 'recursion')
            flat_map(v)
        else:
            target[k] = v
print(flat_map(d))
print(target)
#{'b': 1, 'c': 2, 'e': 3, 'g': 4}


#改进
d = {'a':{'b':1, 'c':2}, 'd':{'e':3, 'f':{'g':4}}}
#d = {'h': 5}
#d = {'a': {'b':1}}
#d = {'d': {'f':{'g':4}}}
target = {}

def flat_map(src:dict, prefix=''): # :dict参数注解，说明src的类型，但不强制
    for k, v in src.items():
        if isinstance(v, dict):
            flat_map(v, prefix + k + '.')
        else:
            target[prefix + k] = v

print(flat_map(d))
print(target)
#None
#{'a.b': 1, 'a.c': 2, 'd.e': 3, 'd.f.g': 4}
del target

#改进
d = {'a':{'b':1, 'c':2}, 'd':{'e':3, 'f':{'g':4}}}
#target = {}
def flat_map(src:dict, target=None, prefix=''): # :dict参数注解，说明src的类型，但不强制
    if target is None:
        target = {}
    for k, v in src.items():
        if isinstance(v, dict):
            flat_map(v, target, prefix + k + '.')
        else:
            target[prefix + k] = v
    return target

print(flat_map(d))
#{'a.b': 1, 'a.c': 2, 'd.e': 3, 'd.f.g': 4}

#改进，使用都只需要传入一个参数就够了

d = {'a':{'b':1, 'c':2}, 'd':{'e':3, 'f':{'g':4}}}
def flat_map(src:dict): # :dict参数注解，说明src的类型，但不强制
    target = {}

    def _flat(s:dict, prefix=''):
        for k, v in s.items():
            if isinstance(v, dict):
                _flat(v, prefix + k + '.')
            else:
                target[prefix + k] = v

    _flat(src)
    return target

print(flat_map(d))
#{'a.b': 1, 'a.c': 2, 'd.e': 3, 'd.f.g': 4}

# coding: utf-8

def counter():
    i = 0
    while True:
        i += 1
        yield i

c = counter() # c generator object
print(next(c))
#: 1

for i in range(5):
    print(i, next(c))
#: 0 2
#: 1 3
#: 2 4
#: 3 5
#: 4 6

# coding: utf-8

def counter():
    def inc():
        i = 0
        while True:
            i += 1
            yield i

    c = inc()
    return next(c)

g = counter() # function
print(g)
print(g)

#: 1
#: 1

# coding: utf-8

def counter():
    def inc():
        i = 0
        while True:
            i += 1
            yield i

    c = inc()
    def fn():
        return next(c) #有闭包，c对应的对象不能释放
    return fn

foo2 = counter() # 返回什么
print(foo2())
print(foo2())

#: 1
#: 2

# coding: utf-8

def counter():
    def inc():
        i = 0
        while True:
            i += 1
            yield i

    c = inc()
#    def fn():
#        return next(c) #有闭包，c对应的对象不能释放
#    return fn
    return lambda : next(c)


f = counter() # 返回什么
print(f())
print(f())
print(f())

#: 1
#: 2
#: 3

# coding: utf-8
def fib():
    a = 0
    b = 1
    yield b
    while True:
        a, b = b, a+b
        yield b

f = fib()
for i in range(5):
    print(i+1, next(f))
#: 1 1
#: 2 1
#: 3 2
#: 4 3
#: 5 5

# coding: utf-8
def bar():
    for i in range(3):
        x = yield 100
        print(x, '+++')

g = bar()
print(next(g)) # 不打印，返回100。yield 100 抛出后，暂停了。next 函数只能驱动迭代器
print(next(g)) #打印None +++，返回100
print(next(g)) #打印None +++，返回100
#print(next(g)) #打印None +++，报错 StopIteration


g = bar()
print(next(g)) 
print(g.send(1)) #打印1 +++，返回100。驱动，send的实参作为yield语句的表达式的返回值
print(g.send('abc')) #打印abc +++，返回100

# coding: utf-8
def counter():
    def inc():
        i = 0
        while True:
            i += 1
            response = yield i
            if response is not None:
                i = response

    c = inc()
    def fn(reset=False):
        return c.send(0) if reset else next(c)
    return fn

g = counter()
print(g)
print(g())
print(g(True)) # 重置 i = 0
#: <function counter.<locals>.fn at 0x0000029F98069550>
#: 1
#: 1

print(g())
#: 2

# coding: utf-8
def counter():
    def inc():
        i = 0
        while True:
            i += 1
            response = yield i
            if response is not None:
                i = response

    c = inc()
#    def fn(reset=False):
#        return c.send(0) if reset else next(c)
#    return fn
    return lambda reset=False, start=0: c.send(start) if reset else next(c)

g = counter()
print(g)
print(g())
print(g(True)) # 重置 i = 0
print(g())
#: <function counter.<locals>.<lambda> at 0x000002A189F39550>
#: 1
#: 1
#: 2

# coding: utf-8
def abc():
    pass

print(abc, type(abc), abc.__name__) #abc.__name__ 表示abc的名字是什么？是一个字符串。type(abc)中abc是标识符
#: <function abc at 0x0000020652EA6280> <class 'function'> abc

# coding: utf-8

def counter(base):
    def inc(step=1):
        base += step
        return base
    return inc

#1 是高阶函数吗？为什么。是，return inc 输出函数
#2 有没有嵌套函数，有闭包吗？base += step,用到base，因为base是形参，形参就是局部变量
#3 代码对吗？如果不对，怎么改。不对


def counter(base):
    def inc(step=1):
        nonlocal base #声明base不是本地变量
        base += step
        return base
    return inc

c = counter(10)
print(c())
#: 11

#4 f1 == f2?
f1 = counter(10) #f1 -> inc 所指向的对象，inc标识符随着counter调用结束而消亡
#inc所指向
f2 = counter(10)
print(f1 == f2) #函数没法比较内容，代表f1 is f2
print(f1 is f2)
#: False
#: False

# coding: utf-8
def add(x,y):
    """Add function

    x int:
    y int:
    return int:
    """

    return x + y

print("{}'s doc = {}".format(add.__name__, add.__doc__))
print(help(add))


#add's doc = Add function
#
#    x int:
#    y int:
#    return int:
#    
#Help on function add in module __main__:
#
#add(x, y)
#    Add function
#    
#    x int:
#    y int:
#    return int:
#
#None

# coding: utf-8
import datetime
import time

def logger(fn):
   def wrapper(*args, **kwargs): 
      """Wrapper function +++"""
      start = datetime.datetime.now()
      ret = fn(*args, **kwargs)
      delta = (datetime.datetime.now() - start).total_seconds()
      print("Function {} took {}s".format(fn.__name__, delta))

      return ret
   return wrapper

@logger
def add(x, y): #add = logger(add) => add = wrapper
   """Add function~~~"""
   time.sleep(2)
   return x + y

print(add.__name__, add.__doc__)
#: wrapper Wrapper function +++

# coding: utf-8
import datetime
import time

#伪装 函数名字和文档

def logger(fn):
   def wrapper(*args, **kwargs): 
      """Wrapper function +++"""
      start = datetime.datetime.now()
      ret = fn(*args, **kwargs)
      delta = (datetime.datetime.now() - start).total_seconds()
      print("Function {} took {}s".format(fn.__name__, delta))

      return ret
   print(wrapper.__name__, '***', wrapper.__doc__)
   wrapper.__name__ = fn.__name__
   wrapper.__doc__ = fn.__doc__
   print(wrapper.__name__, '###', wrapper.__doc__)
   return wrapper

@logger
def add(x, y): #add = logger(add) => add = wrapper
   """Add function~~~"""
   time.sleep(2)
   return x + y

print(add.__name__, add.__doc__)
#: wrapper *** Wrapper function +++
#: add ### Add function~~~
#: add Add function~~~



#伪装 函数名字和文档

def logger(fn): #fn 被包装函数wrapped
   def wrapper(*args, **kwargs):  # 包装函数wrapper
      """Wrapper function +++"""
      start = datetime.datetime.now()
      ret = fn(*args, **kwargs)
      delta = (datetime.datetime.now() - start).total_seconds()
      print("Function {} took {}s".format(fn.__name__, delta))

      return ret

   def copy_properties(dst, src):
      print(dst.__name__, '***', dst.__doc__)
      dst.__name__ = src.__name__
      dst.__doc__ = src.__doc__
      #其他属性覆盖略去
      print(dst.__name__, '###', dst.__doc__)

   copy_properties(wrapper, fn)
   return wrapper

@logger
def add(x, y): #add = logger(add) => add = wrapper
   """Add function~~~"""
   time.sleep(2)
   return x + y

print(add.__name__, add.__doc__)
#: wrapper *** Wrapper function +++
#: add ### Add function~~~
#: add Add function~~~



#属性拷贝通用函数

def copy_properties(dst, src):
   print(dst.__name__, '***', dst.__doc__)
   dst.__name__ = src.__name__
   dst.__doc__ = src.__doc__
   #其他属性覆盖略去
   print(dst.__name__, '###', dst.__doc__)

def logger(fn): #fn 被包装函数wrapped
   def wrapper(*args, **kwargs):  # 包装函数wrapper
      """Wrapper function +++"""
      start = datetime.datetime.now()
      ret = fn(*args, **kwargs)
      delta = (datetime.datetime.now() - start).total_seconds()
      print("Function {} took {}s".format(fn.__name__, delta))

      return ret

   copy_properties(wrapper, fn)
   return wrapper

@logger
def add(x, y): #add = logger(add) => add = wrapper
   """Add function~~~"""
   time.sleep(2)
   return x + y

print(add.__name__, add.__doc__)

# coding: utf-8
import datetime
import time

def copy_properties(dst): #柯里化
   def _copy(src):
      dst.__name__ = src.__name__
      dst.__doc__ = src.__doc__
      #其他属性覆盖略去
   return _copy

def logger(fn): #fn 被包装函数wrapped
   #@copy_properties(fn) #带参装饰器
   def wrapper(*args, **kwargs):  # 包装函数wrapper
      """Wrapper function +++"""
      start = datetime.datetime.now()
      ret = fn(*args, **kwargs)
      delta = (datetime.datetime.now() - start).total_seconds()
      print("Function {} took {}s".format(fn.__name__, delta))

      return ret

   #copy_properties(wrapper, fn)
   copy_properties(wrapper)(fn) # _copy(fn)
   return wrapper

@logger
def add(x, y): #add = logger(add) => add = wrapper
   """Add function~~~"""
   time.sleep(2)
   return x + y

print(add.__name__, add.__doc__)
#: add Add function~~~

# coding: utf-8
import datetime
import time

#def copy_properties(dst): #柯里化
#   def _copy(src):
#      dst.__name__ = src.__name__
#      dst.__doc__ = src.__doc__
#      #其他属性覆盖略去
#   return _copy

#def copy_properties(src): #柯里化，适应装饰器的使用调整一下形参
#   def _copy(dst):
#      dst.__name__ = src.__name__
#      dst.__doc__ = src.__doc__
#      #其他属性覆盖略去
#   return _copy

def copy_properties(src): #柯里化，适应装饰器的使用调整一下形参
   def _copy(dst):
      dst.__name__ = src.__name__
      dst.__doc__ = src.__doc__
      return dst  #这一句返回值特别重要
      #其他属性覆盖略去
   return _copy
def logger(fn): #fn 被包装函数wrapped
   #@copy_properties(fn) #带参装饰器 #等价于 wrapper = copy_properties(wrapper)(fn)
   @copy_properties(fn) #带参装饰器 #等价于 wrapper = copy_properties(fn)(wrapper)
   #装饰器语法是把下面的函数的标识符提上来作为实参，即copy_properties(fn)(wrapper) -> _copy(wrapper) => wrapper = wrapper
   def wrapper(*args, **kwargs):  # 包装函数wrapper
      """Wrapper function +++"""
      start = datetime.datetime.now()
      ret = fn(*args, **kwargs)
      delta = (datetime.datetime.now() - start).total_seconds()
      print("Function {} took {}s".format(fn.__name__, delta))

      return ret

   #copy_properties(wrapper)(fn) # _copy(fn)
   #copy_properties(fn)(wrapper) # _copy(wrapper)
   return wrapper

@logger
def add(x, y): #add = logger(add) => add = wrapper
   """Add function~~~"""
   time.sleep(2)
   return x + y

print(add.__name__, add.__doc__)

#报错
#Traceback (most recent call last):
#  File "<stdin>", line 41, in <module>
#AttributeError: 'NoneType' object has no attribute '__name__'
#因为@copy_properties(fn) 即 copy_properties(fn)(wrapper) -> _copy(wrapper) => wrapper = wrapper
#_copy(wrapper)返回None，None是没有__name__和__doc__的
#解决 _copy(dst): 返回 return dst

# coding: utf-8
import datetime
import time

def copy_properties(src): #柯里化
   def _copy(dst):
      dst.__name__ = src.__name__
      dst.__doc__ = src.__doc__
      return dst  #这一句返回值特别重要
      #其他属性覆盖略去
   return _copy
def logger(fn): #fn 被包装函数wrapped
   @copy_properties(fn) #带参装饰器 #等价于 wrapper = copy_properties(fn)(wrapper)
   #copy_properties(fn)(wrapper) -> _copy(wrapper) => wrapper = wrapper
   def wrapper(*args, **kwargs):  # 包装函数wrapper
      """Wrapper function +++"""
      start = datetime.datetime.now()
      ret = fn(*args, **kwargs)
      delta = (datetime.datetime.now() - start).total_seconds()
      duration = 5 # s
      if delta > duration:
         print("Function {} took {}s. Slow".format(fn.__name__, delta))
      else:
         print("Function {} took {}s. Fast".format(fn.__name__, delta))
      return ret
   #wrapper = copy_properties(fn)(wrapper) # _copy(wrapper)
   return wrapper

@logger
def add(x, y): #add = logger(add) => add = wrapper
   """Add function~~~"""
   time.sleep(6)
   return x + y

add(4, 5)
#: Function add took 6.012711s. Slow

#将阈值提出来，柯里化
def copy_properties(src): #柯里化
   def _copy(dst):
      dst.__name__ = src.__name__
      dst.__doc__ = src.__doc__
      return dst  #这一句返回值特别重要
      #其他属性覆盖略去
   return _copy

def logger(duration):
   def _logger(fn): #fn 被包装函数wrapped
      @copy_properties(fn) #带参装饰器 #等价于 wrapper = copy_properties(fn)(wrapper)
      #copy_properties(fn)(wrapper) -> _copy(wrapper) => wrapper = wrapper
      def wrapper(*args, **kwargs):  # 包装函数wrapper
         """Wrapper function +++"""
         start = datetime.datetime.now()
         ret = fn(*args, **kwargs)
         delta = (datetime.datetime.now() - start).total_seconds()
         #duration = 5 # s
         #if delta > duration:
         #   print("Function {} took {}s. Slow".format(fn.__name__, delta))
         #else:
         #   print("Function {} took {}s. Fast".format(fn.__name__, delta))
         print("Function {} took {}s. {}".format(fn.__name__, delta, "Slow" if delta > duration else "Fast"))

         return ret
      #wrapper = copy_properties(fn)(wrapper) # _copy(wrapper)
      return wrapper
   return _logger

@logger(5) # add = logger(5)(add) -> add = _logger(add) -> add = wrapper
def add(x, y): #add = logger(add) => add = wrapper
   """Add function~~~"""
   time.sleep(2)
   return x + y

add(4, 5)
#: Function add took 6.005283s. Slow

# coding: utf-8
import datetime
import time

def copy_properties(src): #柯里化
   def _copy(dst):
      dst.__name__ = src.__name__
      dst.__doc__ = src.__doc__
      return dst  #这一句返回值特别重要
      #其他属性覆盖略去
   return _copy

def logger(duration, output=lambda name, delta: print('{} took {:.2f}s. slow'.format(name, delta))):
   def _logger(fn): #fn 被包装函数wrapped
      @copy_properties(fn) #带参装饰器 #等价于 wrapper = copy_properties(fn)(wrapper)
      #copy_properties(fn)(wrapper) -> _copy(wrapper) => wrapper = wrapper
      def wrapper(*args, **kwargs):  # 包装函数wrapper
         """Wrapper function +++"""
         start = datetime.datetime.now()
         ret = fn(*args, **kwargs)
         delta = (datetime.datetime.now() - start).total_seconds()
         #如果超出阈值，记录，为了灵活，我们对超出阈值的信息使用一个函数记录
         if delta > duration:
            output(fn.__name__, delta) #发网络、记录文件、控制台。函数名、delta

         return ret
      #wrapper = copy_properties(fn)(wrapper) # _copy(wrapper)
      return wrapper
   return _logger

@logger(1) # add = logger(1, output)(add) -> add = _logger(add) -> add = wrapper
def add(x, y): #add = logger(add) => add = wrapper
   """Add function~~~"""
   time.sleep(2)
   return x + y

add(4, 5)
#: add took 2.01s. slow

# coding: utf-8
import datetime
import time
from functools import update_wrapper

def copy_properties(src): #柯里化
   def _copy(dst):
      dst.__name__ = src.__name__
      dst.__doc__ = src.__doc__
      return dst  #这一句返回值特别重要
      #其他属性覆盖略去
   return _copy

def copy_properties(wrapper, wrapped): #柯里化 update_wrapper(wrapper, wrapped,
   assigned = ('__name__', '__doc__')
   wrapper.__name__ = wrapped.__name__
   wrapper.__doc__ = wrapped.__doc__

   wrapper.__wrapped__ = wrapped #在函数对象上自定义一个特殊属性，记录被包装者fn

   return wrapper 

def logger(duration, output=lambda name, delta: print('{} took {:.2f}s. slow'.format(name, delta))):
   def _logger(fn): #fn 被包装函数wrapped
      #@copy_properties(fn) #带参装饰器 #等价于 wrapper = copy_properties(fn)(wrapper)
      #opy_properties(fn)(wrapper) -> _copy(wrapper) => wrapper = wrapper
      def wrapper(*args, **kwargs):  # 包装函数wrapper
         """Wrapper function +++"""
         start = datetime.datetime.now()
         ret = fn(*args, **kwargs)
         delta = (datetime.datetime.now() - start).total_seconds()
         #如果超出阈值，记录，为了灵活，我们对超出阈值的信息使用一个函数记录
         if delta > duration:
            output(fn.__name__, delta) #发网络、记录文件、控制台。函数名、delta

         return ret
      #wrapper = copy_properties(fn)(wrapper) # _copy(wrapper)
      update_wrapper(wrapper, fn)
      return wrapper
   return _logger

@logger(1) # add = logger(1, output)(add) -> add = _logger(add) -> add = wrapper
def add(x, y): #add = logger(add) => add = wrapper
   """Add function~~~"""
   time.sleep(2)
   return x + y

print(add.__name__, add.__doc__)
#: add Add function~~~
#add(4, 5)

# coding: utf-8
import datetime
import time
from functools import update_wrapper, wraps

def copy_properties(src): #wraps 偏函数实现
   def _copy(dst):
      dst.__name__ = src.__name__
      dst.__doc__ = src.__doc__
      return dst  #这一句返回值特别重要
      #其他属性覆盖略去
   return _copy

def copy_properties(wrapper, wrapped): #柯里化 update_wrapper(wrapper, wrapped,
   assigned = ('__name__', '__doc__')
   wrapper.__name__ = wrapped.__name__
   wrapper.__doc__ = wrapped.__doc__

   wrapper.__wrapped__ = wrapped #在函数对象上自定义一个特殊属性，记录被包装者fn

   return wrapper 

def logger(duration, output=lambda name, delta: print('{} took {:.2f}s. slow'.format(name, delta))):
   def _logger(fn): #fn 被包装函数wrapped
      #@copy_properties(fn) #带参装饰器 #等价于 wrapper = copy_properties(fn)(wrapper)
      #opy_properties(fn)(wrapper) -> _copy(wrapper) => wrapper = wrapper
      @wraps(fn) #wraps = wraps(fn)(wrapper) 也就是wraps(fn)必须返回等效于一个单参函数
      def wrapper(*args, **kwargs):  # 包装函数wrapper
         """Wrapper function +++"""
         start = datetime.datetime.now()
         ret = fn(*args, **kwargs)
         delta = (datetime.datetime.now() - start).total_seconds()
         #如果超出阈值，记录，为了灵活，我们对超出阈值的信息使用一个函数记录
         if delta > duration:
            output(fn.__name__, delta) #发网络、记录文件、控制台。函数名、delta

         return ret
      #wrapper = copy_properties(fn)(wrapper) # _copy(wrapper)
      #update_wrapper(wrapper, fn)
      return wrapper
   return _logger

@logger(1) # add = logger(1, output)(add) -> add = _logger(add) -> add = wrapper
def add(x, y): #add = logger(add) => add = wrapper
   """Add function~~~"""
   time.sleep(2)
   return x + y

print(add.__name__, add.__doc__)
#: add Add function~~~
#add(4, 5)

def partial(func, /, *args, **keywords):
    def newfunc(*fargs, **fkeywords):
        newkeywords = {**keywords, **fkeywords}
        return func(*args, *fargs, **newkeywords)
    newfunc.func = func
    newfunc.args = args
    newfunc.keywords = keywords
    return newfunc

# coding: utf-8
from functools import partial

def partial(func, /, *args, **keywords): #add, (), {x:10, y:20}
    def newfunc(*fargs, **fkeywords): #newfunc诞生了
        newkeywords = {**keywords, **fkeywords}
        return func(*args, *fargs, **newkeywords)
    newfunc.func = func #指向原函数
    newfunc.args = args #args kwargs分别记录了传入的实参
    newfunc.keywords = keywords
    return newfunc

def add(x, y, *args):
    print(x, y, args)
    return x + y + sum(args)

newadd = partial(add, y=20, x=10) #返回新函数
print(newadd.func, hex(id(add)))
#: <function add at 0x0000026283C36280> 0x26283c36280

#分析如何调用
newadd(4, 5) #add(4,5,x=10, y=20)

def partial(func, /, *args, **keywords): #add, (), {x:10, y:20}
    def newfunc(*fargs, **fkeywords): #newfunc诞生了 newfunc(4, 5) (4,5) {}
        newkeywords = {**keywords, **fkeywords} #{x:10, y:20}
        #如果你固定的时候，关键字传参，后期还可以更新它
        #如果固定了按位置传参，将前后2次位置传参都解开，把关键字传参也解开
        return func(*args, *fargs, **newkeywords) #retrun add(4,5, x=10, y=20)
    newfunc.func = func #指向原函数
    newfunc.args = args #args kwargs分别记录了传入的实参
    newfunc.keywords = keywords
    return newfunc

def update_wrapper(wrapper,
                   wrapped,
                   assigned = WRAPPER_ASSIGNMENTS,
                   updated = WRAPPER_UPDATES):
    pass
    return wrapper

def wraps(wrapped,
          assigned = WRAPPER_ASSIGNMENTS,
          updated = WRAPPER_UPDATES):
    newfunc = partial(update_wrapper, wrapped=wrapped,
                   assigned=assigned, updated=updated) #固定了3参
    return newfunc

wraps(fn) => newfunc 有一个参数wrapper
wraps(fn)(wrapper) => newfunc(wrapper)
return func(*args, *fargs, **newkeywords)
return update_wrapper(wrapper, wrapped=fn, assigned=assigned, updated=updated)

# coding: utf-8
from functools import lru_cache 

@lru_cache #fn = lru_cache(fn)
def fn():
    pass

@lru_cache() # fn = lru_cache()(fn) # fn = lru_cache(128, False)(fn)
# add = lru_cache()(add) => add decorating_function(add)
#add = wrapper => _lru_cache_wrapper(add, maxsize, typed, _CacheInfo)
def fn():
    pass

def lru_cache(maxsize=128, typed=False):
    if isinstance(maxsize, int):
        # Negative maxsize is treated as 0
        if maxsize < 0:
            maxsize = 0
    elif callable(maxsize) and isinstance(typed, bool): #python 3.8 增加的代码
        # The user_function was passed in directly via the maxsize argument
        user_function, maxsize = maxsize, 128 #
        wrapper = _lru_cache_wrapper(user_function, maxsize, typed, _CacheInfo)
        return update_wrapper(wrapper, user_function)
    elif maxsize is not None:
        raise TypeError(
            'Expected first argument to be an integer, a callable, or None')
    def decorating_function(user_function):
        wrapper = _lru_cache_wrapper(user_function, maxsize, typed, _CacheInfo)
        return update_wrapper(wrapper, user_function)

    return decorating_function

...

def _lru_cache_wrapper(user_function, maxsize, typed, _CacheInfo):
    # Constants shared by all lru cache instances:
    sentinel = object()          # unique object used to signal cache misses
    make_key = _make_key         # build a key from the function arguments
...

    elif maxsize is None:

        def wrapper(*args, **kwds):
            # Simple caching without ordering or size limit
            nonlocal hits, misses
            key = make_key(args, kwds, typed)

...
def _make_key(args, kwds, typed,
             kwd_mark = (object(),),
             fasttypes = {int, str},
             tuple=tuple, type=type, len=len):
    key = args
    if kwds:
        key += kwd_mark
        for item in kwds.items():
            key += item
    if typed:
        key += tuple(type(v) for v in args)
        if kwds:
            key += tuple(type(v) for v in kwds.values())
    elif len(key) == 1 and type(key[0]) in fasttypes:
        return key[0]
    return _HashedSeq(key)

# coding: utf-8
from functools import _make_key

print(_make_key((4, 5), {}, False))
print(_make_key((4,), {'y': 5}, False))
print(_make_key((), {'x':4, 'y': 5}, False))
print(_make_key((4, 5), {}, True))
#: [4, 5]
#: [4, <object object at 0x0000020BD8EC4E90>, 'y', 5]
#: [<object object at 0x0000020BD8EC4E90>, 'x', 4, 'y', 5]
#: [4, 5, <class 'int'>, <class 'int'>]

# coding: utf-8
from functools import lru_cache

@lru_cache #斐波那契数列 fib(b) = fib(n-1) + fib(n-2) 这个版本背过
def fib(n): #n >= 1
    return 1 if n <3 else fib(n-1) + fib(n-2)

print(fib(35))
#: 9227465

#为什么算这么快？ 空间换时间。计算的结果都被缓存下来，这次只是命中了。

# coding: utf-8
from functools import lru_cache
import datetime

#maxsize cache = {} 字典的大小上限，kv对有个50个上限，LRU
@lru_cache(50) #斐波那契数列 fib(b) = fib(n-1) + fib(n-2) 这个版本背过
def fib(n): #n >= 1
    return 1 if n <3 else fib(n-1) + fib(n-2)

for i in [35, 101]: 
    start = datetime.datetime.now()
    print(fib(i))
    delta = (datetime.datetime.now() - start).total_seconds()
    print(i, delta)

#: 9227465
#: 35 0.0
#: 573147844013817084101
#: 101 0.0

#为什么算这么快？ 空间换时间。计算的结果都被缓存下来，这次只是命中了。

# coding: utf-8
#base64编码
import base64

#s = 'abc' # 内部用的unicode
#print(base64.b64encode(s)) #报错TypeError: a bytes-like object is required, not 'str'

s = b'abc' # 内部用的unicode b'YWJj' #内存中大端 0x616263
print(base64.b64encode(s))
#: b'YWJj'

#打印base64码表
from string import ascii_lowercase, ascii_uppercase
alphabet = ascii_uppercase + ascii_lowercase + '0123456789+/'
print(alphabet)
#: ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/

# coding: utf-8

import base64

alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"


#print(8 >> 1, 0b1000 >> 1) #0b0100
#print(8 >> 2, 0b1000 >> 2) #0b10
#print(0b1000000000 >> 5)
##: 4 4
##: 2 2
##: 16

def b64encode(src:str, encoding='utf-8') ->bytes:
    #3字节断开，4 * 6 -> 4 * 8 bits前面补零，移位计算正好，简单效率高
    if isinstance(src, str):
        _src = src.encode(encoding=encoding)
    else:
        return None # 故意返回None就是告诉你，我不返回bytes类型数据b''

    #print(_src >> 18) #: b'abc' 0x61 62 63 b'\x616263' bytes类型不支持移位，整数支持。
    print(_src) #: b'abc' 0x61 62 63 b'\x616263' bytes类型不支持移位，整数支持。
    # 整数支持 >>
    b = int.from_bytes(_src, 'big') #bytes转int
    print(b, hex(b), b >> 18) #24 - 18 = 6 # 返回int类型，至少认为你是一个字节的
    #0b 011000 >>18  010110  001001 100011
    #0b 00011000
    #0x 18
    index = b >> 18
    #: 6382179 0x616263 24
    # index  base64 中使用index找到字符
    print(alphabet[index]) #: Y 处理的第一个字符出来了。

print(b64encode('abc'))

# coding: utf-8
print(8 >> 1, 0b1000 >> 1) #0b0100
print(8 >> 2, 0b1000 >> 2) #0b10
print(0b1000000000 >> 5)
#: 4 4
#: 2 2
#: 16

print(0b1 << 1) # 0b10 左移1位
#: 2

# 位与
# x & 0x0000000000000000000111111
# 3 & 0x3F


#0b 011000 010110  001001 100011  >> 12#先右移12位
#0b 011000 010110 & 0x3F #去掉前6位，位与0x3F，拿到最后6位
#0b 000000 111111 #0x3F
#ob 010110 #结果拿到后6位，即第二个字符


#第三个字符

#0b 011000 010110  001001 100011  >> 6#先右移6位
#0b 011000 010110  001001 & 0x3F  #位与0x3F，拿到最后6位
#0b 000000 000000  111111 #0x3F
#0b 001001 #9

# coding: utf-8

import base64

alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"


#print(8 >> 1, 0b1000 >> 1) #0b0100
#print(8 >> 2, 0b1000 >> 2) #0b10
#print(0b1000000000 >> 5)
##: 4 4
##: 2 2
##: 16

def b64encode(src:str, encoding='utf-8') ->bytes:
    #3字节断开，4 * 6 -> 4 * 8 bits前面补零，移位计算正好，简单效率高
    if isinstance(src, str):
        _src = src.encode(encoding=encoding)
    else:
        return None # 故意返回None就是告诉你，我不返回bytes类型数据b''

    #print(_src >> 18) #: b'abc' 0x61 62 63 b'\x616263' bytes类型不支持移位，整数支持。
    print(_src) #: b'abc' 0x61 62 63 b'\x616263' bytes类型不支持移位，整数支持。
    # 整数支持 >>
    b = int.from_bytes(_src, 'big') #bytes转int
    print(b, hex(b), b >> 18) #24 - 18 = 6 # 返回int类型，至少认为你是一个字节的
    #0b 011000 >>18  010110  001001 100011
    #0b 00011000
    #0x 18
    index = b >> 18 & 0x3F #可以不写& 0x3F，无用功
    #: 6382179 0x616263 24
    # index  base64 中使用index找到字符
    print(alphabet[index]) #: Y 处理的第一个字符出来了。

    index = b >> 12 & 0x3F
    print(alphabet[index]) #: W 处理的第二个字符出来了。

    index = b >> 6 & 0x3F
    print(alphabet[index]) #: J 处理的第三个字符出来了。

    index = b >> 0 & 0x3F
    print(alphabet[index]) #: J 处理的最后字符出来了。

print(b64encode('abc'))

# coding: utf-8
import base64

alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

#print(8 >> 1, 0b1000 >> 1) #0b0100
#print(8 >> 2, 0b1000 >> 2) #0b10
#print(0b1000000000 >> 5)
##: 4 4
##: 2 2
##: 16

def b64encode(src:str, encoding='utf-8') ->bytes:
    #3字节断开，4 * 6 -> 4 * 8 bits前面补零，移位计算正好，简单效率高
    if isinstance(src, str):
        _src = src.encode(encoding=encoding)
    else:
        return None # 故意返回None就是告诉你，我不返回bytes类型数据b''

    print(_src) #: b'abc' 0x61 62 63 b'\x616263' bytes类型不支持移位，整数支持。
    # 整数支持 >>
    b = int.from_bytes(_src, 'big') #bytes转int

    for i in range(18, -1, -6):
        #print(b, hex(b), b >> 18) #24 - 18 = 6 # 返回int类型，至少认为你是一个字节的
        #index = b >> i & 0x3F #无用功 18
        index = b >> i if i = 18 else b >> i & 0x3F #处理无用功问题
        # index  base64 中使用index找到字符
        print(alphabet[index]) #: Y 处理的第一个数字出来了。

print(b64encode('abc'))
#: b'abc'
#: Y
#: W
#: J
#: j
#: None

# coding: utf-8
import base64

alphabet = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

#print(8 >> 1, 0b1000 >> 1) #0b0100
#print(8 >> 2, 0b1000 >> 2) #0b10
#print(0b1000000000 >> 5)
##: 4 4
##: 2 2
##: 16

def b64encode(src:str, encoding='utf-8') ->bytes:
    #3字节断开，4 * 6 -> 4 * 8 bits前面补零，移位计算正好，简单效率高
    if isinstance(src, str):
        _src = src.encode(encoding=encoding)
    else:
        return None # 故意返回None就是告诉你，我不返回bytes类型数据b''

    ret = bytearray() #目标
    print(_src) #: b'abc' 0x61 62 63 b'\x616263' bytes类型不支持移位，整数支持。
    # 整数支持 >>
    b = int.from_bytes(_src, 'big') #bytes转int

    for i in range(18, -1, -6):
        #print(b, hex(b), b >> 18) #24 - 18 = 6 # 返回int类型，至少认为你是一个字节的
        #index = b >> i & 0x3F #无用功 18
        index = b >> i if i == 18 else b >> i & 0x3F #处理无用功问题
        # index  base64 中使用index找到字符
        print(alphabet[index]) #: Y 处理的第一个字符出来了。bytes的索引返回整数。返回字符对应的整数出来
        ret.append(alphabet[index]) #ret.append()追加的是字节，不是字符串，需要把alphabet变量换成bytes类型，bytes的索引返回整数
    return ret

print(b64encode('abc'))
#: b'abc'
#: 89
#: 87
#: 74
#: 106
#: bytearray(b'YWJj')

# coding: utf-8
import base64

alphabet = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

#print(8 >> 1, 0b1000 >> 1) #0b0100
#print(8 >> 2, 0b1000 >> 2) #0b10
#print(0b1000000000 >> 5)
##: 4 4
##: 2 2
##: 16

def b64encode(src, encoding='utf-8') ->bytes:
    #3字节断开，4 * 6 -> 4 * 8 bits前面补零，移位计算正好，简单效率高
    if isinstance(src, str):
        _src = src.encode(encoding=encoding)
    elif isinstance(src, (bytes, bytearray)):
        _src = bytes(src)
    else:
        return None # 故意返回None就是告诉你，我不返回bytes类型数据b''

    ret = bytearray() #目标
    print(_src) #: b'abc' 0x61 62 63 b'\x616263' bytes类型不支持移位，整数支持。
    # 整数支持 >>
    b = int.from_bytes(_src, 'big') #bytes转int

    for i in range(18, -1, -6):
        #print(b, hex(b), b >> 18) #24 - 18 = 6 # 返回int类型，至少认为你是一个字节的
        #index = b >> i & 0x3F #无用功 18
        index = b >> i if i == 18 else b >> i & 0x3F #处理无用功问题
        # index  base64 中使用index找到字符
        print(alphabet[index]) #: Y 处理的第一个字符出来了。bytes的索引返回整数。返回字符对应的整数出来
        ret.append(alphabet[index]) #ret.append()追加的是字节，不是字符串，需要把alphabet变量换成bytes类型，bytes的索引返回整数
    return bytes(ret) #返回bytes类型

print(b64encode('abc'))
#: b'abc'
#: 89
#: 87
#: 74
#: 106
#: b'YWJj'