def

# 函数

# 修改全局变量
a = 10 
def func():
    global a
    a = 20
print(a)  #10
func()
print(a)  #20
-----------------
# 外部访问局部变量
def outer():
    a = 10
    def func():
        nonlocal a
        a = 20
    return a
def func():
    b = outer()
    return b
print(func()) #10

# 1 返回函数名
def outer():
    def inner():
        print("我是inner")
    return inner
ret = outer()
ret()
# 2 闭包 里面用到了外面的变量
def func():
    a = 10
    def inner(): #定义inner
        print(a)
    inner() #调用inner
    print(inner.__closure__)  # 能打印出东西就是闭包
func()

#装饰器
def wrapper(fn):
    def inner(*args,**kwargs):
        print('进站')
        ret = fn(*args,**kwargs)
        print('出检票')
    return inner

@wrapper
def train():
    print('坐火车去拉萨')

@wrapper
def bus():
    print('座公交车去拉萨')

train()
bus()

lst = ["张无忌", "胡辣汤", "赵敏", "灭绝"]
# for循环的本质
it = lst.__iter__() #  for循环的内部是用迭代器来获取数据的
while 1:
    try:
        item = it.__next__()
        print(item)
    except StopIteration:
        print("结束了")
        break

def order():  
    lst = []
    for i in range(10000):
        lst.append("衣服%s" % i)
    return lst
ret = order()
print(ret[0])
# 下面生成器  工厂生产衣服的例子
def order():
    for i in range(10000):
        yield "衣服%s" % i
gen = order()
print(next(gen))
print(gen.__next__())

# 生成器send 的传值的例子
def eat():
    print("韭菜盒子")
    a = yield "红烧肉"
    print(a)
    b = yield "吱吱冒油的大肘子"
    print(b)  # 绿豆汤
    c = yield "地三鲜"
    print(c)  # 红豆汤

g=eat()
print("外面打印:" + g.__next__())     # yield "红烧肉"
print("外面打印:" + g.send("疙瘩汤")) # yield "吱吱冒油的大肘子"
print("外面打印:" + g.send("绿豆汤")) # yield "地三鲜"
print("外面打印:" + g.send("红豆汤")) # 报错

def add(a, b):
    return a + b

def gen_fun():  # 0 1 2 3
    for i in range(4):
        yield i

g = gen_fun()   # 0 1 2 3

n=3
g = (add(i,5) for i in g)
n=5
g = (add(i,5) for i in g)
#
# for n in [3, 5]:
#     g = (add(i, n) for i in g)

print(list(g)) #[10, 11, 12, 13]

#二分法 两种逻辑
lst = [1,4,7,12,37,88,156,287,444]
法一 循环遍历 缺点是全遍历
n = 45
for item in lst:
    if n == item:
        print('找到了')
else:
    print('不存在')

法二
left = 0
right = len(lst)-1
n = 12
while left <= right:
    middle = (left+right)//2
    if n > lst[middle]:
        left = middle+1
    elif n < lst[middle]:
        right = middle-1
    else:
        print('找到了')
        break
else:
    print('找不到')
递归法
def search(lst,n,left,right):
    if left > right:
        print('不存在')
        return
    mid = (left + right)//2
    if  n > lst[mid] :
        left = mid + 1
        search(lst,n,left,right)
    elif n < lst[mid]:
        right = mid - 1
        search(lst, n, left, right)
    else:
        print('找到了')
        return
search(lst,12,0,len(lst)-1)

斐波那契数列 1,1,2,3,5,8,11
def fib(n):
    a, b = 1,1
    while a < n:
        print(a, end=' ')
        a, b = b, a+b
fib(1000) #输出的是1000以内的斐波那契数列

函数：对功能或者动作的封装
    定义：
        def 函数名(参数):
            函数体

        函数名(参数)

        返回值:
            执行完函数得到的结果。
            哪里调用的就返回给哪里
            在函数体中写return语句, 如果程序执行到了return。 函数其余的内容就不再执行了

            1. 只写return, 默认返回None, 相当于return None
            2. 写return 值, 返回一个结果
            3. return 值1， 值2， 值3.。。。 返回一个元组
            4. 不写return 返回None.表示没有返回值


        参数:
            1. 形参
                函数在声明的时候， 声明的变量。 用来接收外接传递的信息
                1. 位置参数
                2. 默认值参数
                3. 不定参数
                    *args   接收位置参数
                    **kwargs接收关键字参数

                    def func(*args, **kwargs):
                        pass

                    func(*list, **dict)

                    *， **， 在形参， 聚合
                            在实参， 打散

                顺序 :
                    位置, *args, 默认值， **kwargs

            2. 实参
                调用函数， 给函数传递的信息
                1. 位置参数
                2. 关键字参数
                3. 混合参数, 位置在前， 关键字在后


        函数名:
            函数名的本质就是一个变量

        闭包:
            1. 保护变量不被侵害
            2. 让一个变量常驻内存

        装饰器:
            def wrapper(func):
                def inner(*args, **kwargs):
                    '''在执行xxx函数之前'''
                    ret = func(*args, **kwargs)
                    '''在执行xxx函数之后'''
                    return ret
                return inner

            @wrapper #  play = wrapper(play)
            def play():
                pass

            play()


        迭代器
            配合for循环使用
            作用：让不同的数据类型拥有相同的遍历方式

            通过__iter__() 获取到迭代器

            可迭代对象:
                可以获取到迭代器: __iter__()
                    list， dict, tuple, set, str
            迭代器：
                __next__(), __iter__()
                一个一个向外拿数据. 拿空报错


            特点：
                1. 只能向前， 不能反复
                2. 惰性机制
                3. 节省内存




        生成器
            本质就是迭代器, 几乎不占用内存

            1. yield   生成器函数
                def func():
                    yield 1
                1. 调用这个函数的时候。 不会执行这个函数的内容。 创建一个生成器
                2. 生成器.__next__() 可以让生成器从上一个yield执行到下一个yield
                3. 节省内存
                4. send(值) 给上一个yield位置传值

            2. 生成器表达式
                列表推导式: [结果 for循环 if条件]
                字典推导式: {key:value for if}
                集合推导式 {key for if}

                生成器表达式
                    (结果 for if)
                直接就是生成器
                    惰性机制，只能向前不能反复


        内置函数

        lambda 匿名函数

            lambda 参数: 返回值


        sorted：排序
            sorted(可迭代对象, key, reverse)
            流程:把可迭代对象中的每一项内容传递给key函数. 根据函数返回的结果进行排序

        filter(func, iter) 筛选
        map(func, iter) 映射


        eval   能够接收到返回值
        exec   没有返回值
        compile 预加载一段代码. 通过eval或者exec来执行

            s = input("请输入一段代码:") # "1+3"
            ret = eval(s)
            print(ret)

            s = input("请输入一段代码:") # "a = 10"
            exec(s)
            print(a)
            print("你好啊")

            s = '''for i in range(10):
                print(i)
            '''
            c = compile(s, "", "exec")
            exec(c)

        递归函数:
            函数自己调用自己
            树形结构遍历


        二分法查找效率比较高. 前提条件. 必须有序序列

format(数据, 格式)
print(format("abc", "<10")) #左对齐
print(format("abc", ">10")) #右对齐
print(format("abc", "^10")) #居中

print(format(5, "08b"))     #00000101
print(format(0b101, "d"))   #转10进制

print(format(1.234567,'f'))   #默认6位
print(format(1.234567,'.2f')) #更改
print(format(1.234567,'.2e')) #科学计数法

globals() #全局变量
locals()  #局部变量

print(hash('中国')) #结果一定是数字
print(hash(123)) #数字哈希值是本身

print(str('哈哈'))
print(repr("jay say he love 'his \wife'")) # repr 一个字符串官方的表示形式
print(r'jay love his \n wife') #转义字符全失效

lst = [1,2,3,4,5,6]
s = slice(2,5,1) #按索引
print(lst[s])

lambda 参数:返回值

a = lambda x:x+1  #匿名函数表达式
lst = [3,24,6,7]
res = sorted(lst,key=abs,reverse=True) #返回新列表,原列表不受影响
print(res)
print(lst)

lst1 = [2,4,5,2,1]
lst1.sort()  # 直接作用于原列表
print(lst1)

l = ['bas','footbool','pingpong']
print(list(map(lambda x:x+'杠杠的',l)))

递归  函数自己调用自己  树形结构的遍历  比较耗资源
官方1000     Windows实测998
为什么耗内存? 因为名称空间
def func():
    print('我是函数')
    func()
func()