python 函数

函数对象

在面向对象编程中 一切皆对象

具体的体现
1.函数可以被引用
2.函数可以作为函数的参数
3.函数可以作为函数的返回值
4.可以被存储到容器类型中

def pay():
    print('支付')
def save():
    print('存钱')
def cheak():
    print('查看')




dic={'1':pay,'2':save,'3':cheak}
while True:
     l=['支付','存钱','查看']
     for i,k in enumerate(l):
         print(i+1,k)
     cmd=input('>>>:')
     if cmd in dic:
         dic[cmd]()
     else:
         print('指令错误')

2.函数嵌套
1.嵌套调用 在一个函数中调用了另一个函数
2.嵌套定义 在一个函数中定义了另一个函数
定义在函数内的函数 只能函数内使用 外界不能访问

def func1():
    print("func1")


def func2():
    print("func2")

     func1()

 func2()

def func1():
     print("func1")

     def func2():
         print("func2")

     func2()

func1()

3.函数的名称空间

存储名称的空间
名称空间的分类
内置名称空间 存储解释器自带的一些名称与值的对应关系
(python解释器启动时创建 所有代码全部执行完毕 关闭解释器时 销毁)
print len max min

全局名称空间 哪些数据会存储在全局空间？
文件级别的名称 只要你的名字的定义是顶着最左边写的就在全局空间
除了内置的函数内的 都在全局中
（执行py文件创建全局名称空间 关闭解释器时 销毁）

局部名称空间 只要是函数内的名称就是局部的
(调用函数时创建 函数执行完毕就销毁)

名称空间的加载顺序
内置的 -> 全局的 ->局部的

名称的查找顺序
局部 -> 全局的 -> 内置的

4.函数的作用域

作用域（作用范围）
域 指的是区域 范围的的意思
全局的名称空间和内置的名称空间 在使用上没什么区别
局部的和全局的内置的 就区别了 局部定义的只能在局部使用
给三个空间划分范围

全局的和内置可以划分为同一个范围
global 表示的全局范围 就是所谓的全局作用域

局部的单独划分为一个范围
local 局部作用域

globals（）
locals（）

print(locals())#查看全局作用域，当locals在全局作用域时，功能和globes相同
print(globals())
def func():
     a = 100
     print(locals())#查看局部作用域

func()

age = 18
def func2():
     # 明确声明  要使用全局中的age
   global age
    age = 19

    print(age)

func2()
print(age)

a = 1
def func3():
    a = 10
    def inner():
        # 明确声明 要使用上一中的 a 如果上一层没有  则找上上层  但是注意 不能找到全局中的
        nonlocal a
        a = 100
        print(a)
    inner()
    print("这是func3中a",a)

func3()
print(a)

5.闭包函数

age = 20
# 如下就是一个闭包函数
def fun1():
    age = 18
    def inner():
        print("hello")
        print(age)
    # 在返回这个内部的函数时 不是单纯的返回函数  还把函数中访问到的局部名称一起打包了
    # 相当于将内部函数与 访问的数据打包在一起了  闭包这个名字就是这么得来的
    return inner
f = fun1() # f 就是inner
f()

# 函数的作用域在定义时就固定了  与调用没有关系

# 闭包函数的模板
def func2():
    a = 1
    b = 10
    def inner():
        print(a)
        print(b)
    return inner

什么是闭包函数
1.定义在另一个函数内的函数
2.内部的的函数访问了外部的名称数据   注意 不包含全局的)

6.装饰器

什么是装饰器
    什么是装饰 给一个已有的对象(一个函数) 添加新的功能
    为什么要装饰 增强功能
器 指一个工具  在python中 值得是具备某个功能的函数

简单的说：装饰器就是 一个用于给其他函数增加功能的函数

import time

def download():
    print('开始下载xxx.mp4')
    time.sleep(2)
    print('xxxx.mp4 下载完成')
    
    
# 请你统计下载耗时
start_time = time.time()
download()
end_time = time.time()
print('下载耗时'，(end_time-start_time))

def download2():
    start_time = time.time()
    print("开始下载xxx.mp4")
    time.sleep(2)
    print("xxxx.mp4 下载完成！")
    end_time = time.time()
    print("下载耗时", (end_time - start_time))

download2()

def max2(x,y):
    if x > y:
        return x
    else:
        return y

res=max2(10,20)

x=10
y=20

# res=x if x > y else y
# print(res)


res='OK' if False else 'No'
print(res)

def outter(func):
    def inner():
        strat_time = time.time()
        func()
        end_time = time.time()
        print('下载耗时'，(end_time-start_time))
    return inner
download=outter(download)
download()

# 叠加多个装饰器
# 1. 加载顺序(outter函数的调用顺序):自下而上
# 2. 执行顺序(wrapper函数的执行顺序):自上而下


def outter1(func1): #func1=wrapper2的内存地址
    print('加载了outter1')
    def wrapper1(*args,**kwargs):
        print('执行了wrapper1')
        res1=func1(*args,**kwargs)
        return res1
    return wrapper1

def outter2(func2): #func2=wrapper3的内存地址
    print('加载了outter2')
    def wrapper2(*args,**kwargs):
        print('执行了wrapper2')
        res2=func2(*args,**kwargs)
        return res2
    return wrapper2

def outter3(func3): # func3=最原始的那个index的内存地址
    print('加载了outter3')
    def wrapper3(*args,**kwargs):
        print('执行了wrapper3')
        res3=func3(*args,**kwargs)
        return res3
    return wrapper3



@outter1 # outter1(wrapper2的内存地址)======>index=wrapper1的内存地址
@outter2 # outter2(wrapper3的内存地址)======>wrapper2的内存地址
@outter3 # outter3(最原始的那个index的内存地址)===>wrapper3的内存地址
def index():
    print('from index')

print('======================================================')
index()

'''

 

有参装饰器

import time

current_user={'user':None}

def auth(engine='file'):
    def outter(func):
        def wrapper(*args,**kwargs):
            if current_user['user']:
                res=func(*args,**kwargs)
                return res

            user=input('username>>>: ').strip()
            pwd=input('password>>>: ').strip()

            if engine == 'file':
                # 基于文件的认证
                if user == 'egon' and pwd == '123':
                    print('login successfull')
                    current_user['user']=user
                    res=func(*args,**kwargs)
                    return res
                else:
                    print('user or password error')
            elif engine == 'mysql':
                # 基于mysql的认证
                print('基于mysql的认证')
            elif engine == 'ldap':
                # 基于ldap的认证
                print('基于ldap的认证')
            else:
                print('不知道engine')
        return wrapper
    return outter

@auth('ldap') #@outter #index=outter(index) # index=wrapper
def index():
    time.sleep(1)
    print('from index')

@auth('mysql') #@outter # home=outter(home) #home=wrapper
def home(name):
    print('welcome %s' %name)

index()
home('egon')

def max2(x,y):
    if x > y:
        return x
    else:
        return y

res=max2(10,20)

x=10
y=20

# res=x if x > y else y
# print(res)


res='OK' if False else 'No'
print(res)

 

# 列表生成式
# l=[]
# for i in range(10):
#     if i > 4:
#         l.append(i**2)
#
#
#
# l=[i**2 for i in range(10) if i > 4]
# print(l)


# names=['egon','alex_sb','kevin_sb','hxx_sb','cxx_sb']
# sbs=[]
# for name in names:
#     if name.endswith('sb'):
#         sbs.append(name)

# sbs=[name.upper() for name in names if name.endswith('sb')]



# print([name.upper() for name in names])
# print([name for name in names if name.endswith('sb')])


# 字典生成式
# res={i:i**2 for i in range(10) if i > 3}
# print(res)

# func()
# func()
# func()
# 匿名函数就是只定义了一个函数的内存地址,主要用于临时使用一次的场景
# func=lambda x,y:x+y
# print(func)
# print(func(1,2))

# res=(lambda x,y:x+y)(1,2)
# print(res)


# print(max([10,11,-3,23]))
# salaries={
#     'egon':3000,
#     'alex':100000000,
#     'wupeiqi':10000,
#     'yuanhao':2000
# }
# def func(k):
#     return salaries[k]

# print(max(salaries,key=lambda k:salaries[k]))
# print(min(salaries,key=func))
# for循环的结果         比较依据
# 'egon'                3000
# 'alex'                100000000
# 'wupeiqi'             10000
# 'yuanhao'             2000

# l=[4,2,3]
# l_new=sorted(l,reverse=True)
# print(l_new)
#
#
# print(sorted(salaries,key=lambda k:salaries[k],reverse=True))
#

迭代器

1. 什么是迭代器
    什么是迭代?
        迭代是一个重复的过程,但是每次重复都是基于上一次重复的结果而继续
        #下列循环知识单纯的重复
        while True:
            print(1)

        # 基于索引的迭代取值
        l=['a','b','c']
        i=0

        while i < len(l):
            print(l[i])
            i+=1
    什么是迭代器?
        迭代取值的工具

2. 为什么要用迭代器
    迭代器
        优点
            1. 提供一种不依赖索引的迭代取值方式
            2. 更节省内存
        缺点:
            1. 不如按照索引的取值方式灵活
            2. 取值一次性的,只能往后取,无法预测值的个数

3. 如何用迭代器
    可迭代的对象:strlist	upledictset文件对象
        但凡内置有__iter__方法的对象都称之为可迭代对象

    迭代器对象: 文件对象
        既内置有__iter__方法又内置有__next__方法的对象都称之为迭代器对象


    调用可迭代对象下__iter__方法,会有一个返回值,该返回值就是内置的迭代器对象

 

# s='abcdef'
# l=['a','b','c']
# d={'k1':111,'k2':222,'k3':333}

# iter_d=d.__iter__()
# # print(iter_d)
#
# try:
#     print(iter_d.__next__())
#     print(iter_d.__next__())
#     print(iter_d.__next__())
#     print(iter_d.__next__())
# except StopIteration:
#     print('取值完毕')


d={'k1':111,'k2':222,'k3':333}
# d={1,2,3,4,5}
# d=[1,2,3,4]

# iter_d=d.__iter__()
# iter_d=iter(d) #d.__iter__

# print(next(iter_d)) #iter_d.__next__()

# print(len(d))
print(d.__len__())


# print(iter_d.__iter__().__iter__().__iter__() is iter_d)

# print(d.__iter__().__next__())
# print(d.__iter__().__next__())
# print(d.__iter__().__next__())



# while True:
#     try:
#         v=iter_d.__next__()
#         print(v)
#     except StopIteration:
#         break
#
# print('第二次取值')
#
# iter_d=d.__iter__()
# while True:
#     try:
#         v=iter_d.__next__()
#         print(v)
#     except StopIteration:
#         break
#

# for k in d:
#     print(k)

#for循环的底层原理:
# 1. 调用in后面那个值/对象的__iter__方法,拿到一个迭代器对象iter_obj
# 2. 调用迭代器对象iter_obj.__next__()将得到的返回值赋值变量名k,循环往复直到取值完毕抛出异常StopIteration
# 3. 捕捉异常结束循环

生成器就是一种自定义的迭代器

如何得到生成器?
    但凡函数内出现yield关键字,再去调用函数不会立即执行函数体代码,会得到一个返回值,该返回值就是生成器对象,
即自定义的迭代器

# def func():   
#     print('first')
#     yield 1
#     print('second')
#     yield 2
#     print('third')
#     yield 3
#
#
# g=func()
# # print(g)
#
# res1=next(g)
# print(res1)
#
# res2=next(g)
# print(res2)
#
# res3=next(g)
# print(res3)
#
# next(g)

# 总结yield:
# 1. 提供一种自定义迭代器的解决方案
# 2. yield & return
#    相同点: 都可以返回值,返回值没有类型限制个数限制
#    不同点: return只能返回一次值,yield却可以让函数暂停在某一个位置,可以返回多次值



# def my_range(start,stop,step=1):
#     while start < stop: # 5 < 5
#         yield start # 3
#         start+=step #start=5

# range(1,5,2) # 1 3
# for i in my_range(1,5000000000000000000000000000000000000000000,2): # 1 3
#     print(i)

函数的递归调用与二分法

1. 函数的递归调用:
    在调用一个函数的过程又直接或者间接地调用该函数本身,称之为递归调用

    递归必须满足两个条件:
        1. 每进入下一次递归调用,问题的规模都应该有所减少
        2. 递归必须有一个明确的结束条件

递归有两个明确的阶段:
    1. 回溯
    2. 递推

# age(5)=age(4)+2
# age(4)=age(3)+2
# age(3)=age(2)+2
# age(2)=age(1)+2
# age(1)=18

# age(n)=age(n-1)+2  # n > 1
# age(1)=18          # n = 1

# def age(n):
#     if n == 1:
#         return 18
#     return age(n-1)+2
#
# print(age(5))


# l=[1,[2,[3,[4,[5,[6,[7,[8,[9,]]]]]]]]]
#
# def func(list1):
#     for item in list1:
#         if type(item) is not list:
#             print(item)
#         else:
#             # 如果是列表,应该...
#             func(item)
#
# func(l)


# nums=[3,5,7,11,13,23,24,76,103,111,201,202,250,303,341]
#
# find_num=203
# for num in nums:
#     if num == find_num:
#         print('find it')
#         break
# else:
#     print('not exists')


nums=[3,5,7,11,13,23,24,76,103,111,201,202,250,303,341]


def binary_search(list1,find_num):
    print(list1)
    if len(list1) == 0:
        print('not exist')
        return
    mid_index=len(list1) // 2
    if find_num > list1[mid_index]:
        # in the right
        binary_search(list1[mid_index + 1:],find_num)
    elif find_num < list1[mid_index]:
        # in the left
        binary_search(list1[:mid_index],find_num)
    else:
        print('find it')

binary_search(nums,203)

 res=[i for i in range(10)  if i > 5]

print(res)#这是列表生成式

g=(i for in range(10) if i >5)

print(g)

print(next(g))

print(next(g))

print(next(g))

print(next(g))#这是生成器表达式

with open('a.txt','rt,encoding='utf8')as f:
#print(len(f.read())) 统计文件中字符个数
res = sum(len(line) for line in f)
print(res) #用生成器表达式的方法统计文件字符个数