递归，装饰器，python常用内置方法

**递归**
        def calc(n):
            print(n)
            if int(n / 2) == 0:  条件判断
                return n
            return calc(int(n/2))
        calc(10)
        结果为10，5，2，1
        
        下一个是实现过程
            def calc(n):
                print(n)
                n = int(n/2)
                if n > 0:
                    calc(n)
                print(n)
            calc(10)
        结果为10，5，2，1，     0，1，2，5
        （实现过程中，递归进去几次就要出来几次）
        
        
    在函数内部，可以调用其他函数，如果一个函数在内部调用函数自身，
        这个函数就是递归函数。
        1，必须有一个明确 的结束条件
        2，每一次递归，问题规模都减少
        3，递归效率不高（栈溢出）
        
            a = '1 3 4 6 7 8 9 11 15 17 19 21 22 25 29 33 38 69 107'
            b = a.split()
            c = []
            for i in b:
                c.append(int(i))  #把数字字符串列表转化为数字列表
            print(c)
            # print(len(c))
            d =[x**2 for x in range(11,100)]
            print(d)
            c.extend(d)
            e = c
            print(c)
            print(e)
            # print(id(c))
            # print(id(e))

def binary_search(dataset,find_num):
                print(dataset)
                if len(dataset) > 1:    # 列表的长度
                    if find_num < dataset[-1]:
                        mid = len(dataset) // 2  # 列表长度的一半
                        if dataset[mid] == find_num:
                            print('find it', find_num)
                        elif dataset[mid] < find_num:
                            print('所找的数字在列表的后半边')
                            # dataset = dataset[mid + 1:]
                            return binary_search(dataset[mid + 1:],find_num)
                        else:
                            print('所找的数字在列表的前半边')
                            # dataset = dataset[:mid]
                            return binary_search(dataset[:mid],find_num)
                    else:
                        print('这个数在list外，这个数比这个列表里的所有数都大')
                else:
                    if dataset[0] == find_num:
                        print('只有一个元素',find_num)
                    else:
                        print('所找元素不在列表里')

binary_search(e,100)
            
            
**内置函数**
    https://book.apeland.cn/media/images/2019/03/21/chapter3-built-in.png
    
    内置参数详解https://docs.python.org/3/library/functions.html?highlight=built#ascii
    
    一个str或者bytes类型不能直接改，bytearray()方法把结果变成list，就可以改了
    
    isinstance()判断一个数据结构的类型
    每个函数的作用我都帮你标好了

abs # 求绝对值

all #Return True if bool(x) is True for all values x in the iterable.If the iterable is empty, return True.

any #Return True if bool(x) is True for any x in the iterable.If the iterable is empty, return False.

ascii #Return an ASCII-only representation of an object,ascii(“中国”) 返回”‘\u4e2d\u56fd’”

bin #返回整数的2进制格式

bool # 判断一个数据结构是True or False, bool({}) 返回就是False, 因为是空dict

bytearray # 把byte变成 bytearray, 可修改的数组

bytes # bytes(“中国”,”gbk”)

callable # 判断一个对象是否可调用

chr # 返回一个数字对应的ascii字符 ， 比如chr(90)返回ascii里的’Z’

classmethod #面向对象时用，现在忽略

compile #py解释器自己用的东西，忽略

complex #求复数，一般人用不到

copyright #没用

credits #没用

delattr #面向对象时用，现在忽略

dict #生成一个空dict

dir #返回对象的可调用属性

divmod #返回除法的商和余数 ，比如divmod(4,2)，结果(2, 0)

enumerate #返回列表的索引和元素，比如 d = [“alex”,”jack”]，enumerate(d)后，得到(0, ‘alex’) (1, ‘jack’)

eval #可以把字符串形式的list,dict,set,tuple,再转换成其原有的数据类型。

exec #把字符串格式的代码，进行解义并执行，比如exec(“print(‘hellworld’)”)，会解义里面的字符串并执行

exit #退出程序

filter #对list、dict、set、tuple等可迭代对象进行过滤， filter(lambda x:x>10,[0,1,23,3,4,4,5,6,67,7])过滤出所有大于10的值

float #转成浮点

format #没用

frozenset #把一个集合变成不可修改的

getattr #面向对象时用，现在忽略

globals #打印全局作用域里的值

hasattr #面向对象时用，现在忽略

hash #hash函数

help

hex #返回一个10进制的16进制表示形式,hex(10) 返回’0xa’

id #查看对象内存地址

input

int

isinstance #判断一个数据结构的类型，比如判断a是不是fronzenset, isinstance(a,frozenset) 返回 True or False

issubclass #面向对象时用，现在忽略

iter #把一个数据结构变成迭代器，讲了迭代器就明白了

len

list

locals

map # map(lambda x:x**2,[1,2,3,43,45,5,6,]) 输出 [1, 4, 9, 1849, 2025, 25, 36]

max # 求最大值

memoryview # 一般人不用，忽略

min # 求最小值

next # 生成器会用到，现在忽略

object #面向对象时用，现在忽略

oct # 返回10进制数的8进制表示

open

ord # 返回ascii的字符对应的10进制数 ord(‘a’) 返回97，

print

property #面向对象时用，现在忽略

quit

range

repr #没什么用

reversed # 可以把一个列表反转

round #可以把小数4舍5入成整数 ，round(10.15,1) 得10.2

set

setattr #面向对象时用，现在忽略

slice # 没用

sorted

staticmethod #面向对象时用，现在忽略

str

sum #求和,a=[1, 4, 9, 1849, 2025, 25, 36],sum(a) 得3949

super #面向对象时用，现在忽略

tuple

type

vars #返回一个对象的属性，面向对象时就明白了

zip #可以把2个或多个列表拼成一个， a=[1, 4, 9, 1849, 2025, 25, 36]，b = [“a”,”b”,”c”,”d”]，

list(zip(a,b)) #得结果
    [(1, 'a'), (4, 'b'), (9, 'c'), (1849, 'd')]

**名称空间**：存放名字x与1绑定关系的地方（x=1）
    名称空间有4种：LEGB
        1，locals:函数内部的名字空间，一般包括函数 的局部变量以及形式参数
        2，enclosing function:在嵌套函数 中外部函数的名字空间，若fun2嵌套在fun1里，
        对fun2来说，fun1的名字空间就是enclosing.
        3,globals:当前的模块空间，模块就是一些py文件，也就是说，globals（）类似全局变量。
        4，__builtins__:内置模块空间，也就是内置或者内置函数的名字空间，
        print(dir(__builtins__))可查看包含的值.
        
    不同变量的作用域不同就是由这个变量所在的名称空间决定的。
            a。全局范围：全局存活，全局有效
            b。局部范围：临时存活，局部有效
        查看作用域的方法：globals（），locals()
LEGB代表名字查找顺序：locals->enclosing function->globals->__builtins__

**闭包**

def outer():
        name = '小猿圈，自学编程'
    
        def inner():
            print('Inner', name)
            
        return inner
        
    func = outer()   #返回的是inner的内存地址，inner
    func（）   #相当于执行的是inner()
    
    闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外
                还包裹了一层作用域，这使得，该函数无论在何处调用，
                优先使用自己外层包裹的作用域。
                
                
**装饰器初识**    （开放--封闭原则）
        改变调用方式的（初级版）：
        account = {
            'is_authenticated' : False,  # 用户登录了就把这个改为True
            'username' : 'alex',  #  假装这是DB里存的用户信息
            'password' :'abc123'  # 假装这是DB里存的用户信息
        }
        def login(func):
            if account['is_authenticated'] is False:
                username = input('user:').strip()
                password = input('password:').strip()
                if username == account['username'] and password == account['password']:
                    print('welcome login....')
                    account['is_authenticated'] = True
                    func()  # 认证成功，执行功能函数
                else:
                    print('wrong username or password')
            else:
                print('用户已登录，验证通过')
                func()  # 认证成功，执行功能函数
        def home():
            print('---HomePage---')
        def ameica():
            #login()    #  执行前加上验证
            print('---am_area----')
        def japan():
            print('---日韩专区---')
        def henan():
            print('-----河南专区-----')
        home()
        login(ameica)
        login(henan)
        
        
        
        不改变调用方式的（入门版）：
        account = {
            'is_authenticated' : False,  # 用户登录了就把这个改为True
            'username' : 'alex',  #  假装这是DB里存的用户信息
            'password' :'abc123'  # 假装这是DB里存的用户信息
        }
        def login(func):
            def inner(*args, **kwargs):
                if account['is_authenticated'] is False:
                    username = input('user:').strip()
                    password = input('password:').strip()
                    if username == account['username'] and password == account['password']:
                        print('welcome login....')
                        account['is_authenticated'] = True
                        func(*args, **kwargs)  # 认证成功，执行功能函数
                    else:
                        print('wrong username or password')
                else:
                    print('用户已登录，验证通过')
                    func(*args, **kwargs)  # 认证成功，执行功能函数
            return inner
        def home():
            print('---HomePage---')
        @login   #  等价于ameica = login(ameica)
        def ameica():
            #login()    #  执行前加上验证
            print('---am_area----')
        def japan():
            print('---日韩专区---')
        #@pay
        @login   #  等价于henan = login(henan)  装饰器，语法糖
        def henan(vip_level):
            if vip_level > 3:
                print('解锁本专区所有高级玩法')
            else:
                print('-----河南专区vip-----')
        # home()
        # login(ameica)
        # login(henan)
        ameica = login(ameica)  # inner的内存地址
        henan = login(henan)    #inner的内存地址
        home()
        ameica()  # inner（）
        henan(4)    #inner()