python基础复习10

# 函数进阶
"""
命名空间和作用域

*内置命名空间  -----python解释器
    # 就是Python解释器一启动就可以使用的名字存储在内置命名空间中
    内置的名字在启动解释器的时候被加载进内存里

*全局命名空间 -----我们写的代码，但不是函数中的代码
    # 是在程序从上到下被执行的过程中依次加载进内存的
     放置了我们设置的所有变量名和函数名

*局部命名空间  ----函数
    # 就是函数内部定义的名字
     当调用函数的时候，才会产生这个命名空间 随着函数执行的结束 这个命名空间就有消失了

在局部：可以使用全局、内置命名空间中的名字
在全局：可以使用内置命名空间中的名字，但不能使用局部的命名空间

在内置： 不可以使用全局、局部的命名空间

可以这样想像：内置就是一个大盒子，它包含了全局，全局又是一个中盒子，它包含了局部这个小盒子
局部找不到可以向上（全局）中找，没有还可以再向上（内置）中找，但不能向下去找

依赖倒置原则
"""

# 作用域 两种
# 全局作用域  --作用在全局 -- 内置和全局名字空间中的名字都属于全局作用域

# 局部作用域 -- 作用在局部 -- 函数

# 例子：

# a = 1
# def func():
#     global a
#     a += 1
#
# func()
# print(a)
# 局部变量不能修改全局变量
# 如果想要修改，需要在程序的一开始添加global声明


# def max1(a,b):
#     return a if a > b else b

# def the_max(x,y,z):  # 函数的嵌套调用
#     c = max(x,y)
#     return max(c,z)
#
# print(the_max(3,5,3))

 

# def outer():
#     a = 1
#     def inner():
#         print(a)
#         print("inner")
#
#         def inner2():
#             print(a)
#             print('inner2')
#         inner2()
#     inner()
#
# outer()

 


# 闭包：嵌套函数，内部函数调用外部函数的变量
# def outer():
#     a = 1
#     def inner():
#         print(a)
#     print(inner.__closure__) #  返回值里有cell 就是闭包函数
#
# outer()

 


# def outer():
#     a = 1
#     def inner():
#         print(a)
#     return inner
#
# inn = outer()  # 先看outer  先调用 然后执行outer这个函数，会有返回值inner，然后用inn去接收它
# inn()

 

# def qqxing(l = []):
#     l.append(1)
#     print(l)
#
# qqxing()
# qqxing()
# qqxing()


# 练习题
# 写函数，接收n个数字，求这些参数数字的和。
# def sum_func(*args):
#     total = 0
#     for i in args:
#         total += i
#     return total
# print(sum_func(1,2,4,6,3,1225))

# 读代码，回答，代码中，打印出来的值a,b,c 分别是什么？为什么？
# a = 10
# b = 20
# def test5(a,b):
#     print(a,b)
# c = test5(b,a)
# print(c)  a = 20 b = 10 c = None(因为没有返回值)

# 读代码，回答，代码中，打印出来的值a,b,c 分别是什么？为什么？
# a = 10
# b = 20
# def test5(a,b):
#     a = 3
#     b = 5
#     print(a,b)
# c = test5(b,a)
# print(c)

# 写函数，检查获取传入列表或元祖对象的所有奇数位索引对应的元素，
# 将其作为新的列表返回给调用者。

# def func(l):
#     return l[1::2]
# a = func([1,2,3,4,5,6,7,8,9])
# print(a)

# 写函数，判断用户传入的对象（字符串、列表、元祖）长度是否大于5。

# def func(l):
#     return len(l) > 5
# print(func("123455"))

# 写函数，检查传入列表的长度，如果大于2，
# 那么仅保留前两个长度的内容，并将新内容返回给调用者。

# def func(l):
#     return l[:2]  #if len(l) > 2: 切片 ：你切的长度列表中没有，它是不会报错的，所以不用判断
# print(func([1,2,3,4,5]))

# 写函数，计算传入字符串中[数字]、[字母]、[空格]、[其他]的个数，并返回结果。
# def func(s):
    # num = 0  #计算数字的个数
    # space = 0  # 空格
    # alpha = 0  # 字母
    # other = 0  # 其它
#     dic = {'num': 0,'alpha': 0,'space': 0,'other': 0}
#     for i in s:
#         if i.isdigit():
#             dic['num'] += 1
#         elif i.isalpha():
#             dic['alpha'] += 1
#         elif i.isspace():
#             dic['space'] += 1
#         else:
#             dic['other'] += 1
#     return dic
# print(func("qa12wedc f  efdc32ec+++"))


# 写函数，检查传入字典的每一个value的长度，如果大于2，
# 那么仅保留前两个长度的内容，并将新内容返回给调用者。
# dic = {'k1':'v1v2', 'k2':[11,22,33,44]}
# PS:字典中的value只能是字符串或列表

# def func(dic):
#     for k in dic:
#         if len(dic[k]) > 2:
#             dic[k] = dic[k][:2]
#     return dic
# dic = {'k1':'v1v2', 'k2':[11,22,33,44]}
# print(func(dic))

 

# 写函数，接收两个数字参数，返回比较大的那个数字。
# def func(a,b):
#     if a > b:
#         return a
#     else:
#         return b
# print(func(3,5))



# 三元运算
# a = 1
# b = 5
# c = a if a > b else b  #  三元运算
# print(c)

# def func(a,b):
#     return a if a > b else b
# print(func(3,6))



# import time
# def func():
#     start = time.time()  # 获取当前时间
#     print('good moring')
#     time.sleep(2)
#     end = time.time()
#     return end - start
#
# print(func())



# 装饰器
# import time
# def func():
#     time.sleep(0.01)
#     print('good moring')
#
# def timmer(f):   #  装饰器函数
#     def inner():
#         start = time.time()
#         f()  # 被装饰的函数
#         end = time.time()
#         print(end - start)
#     return inner
# func = timmer(func)  ----->  这句话相当于语法糖 @timmer
# func()
# 不想修改函数的调用方式，但是还想在原来的函数前后添加功能
# timmer就是一个装饰器函数，只是对一个函数 有一些装饰作用

 

# 装饰器的最终形成和固定格式
# import time
# def timmer(f):
#     def inner():
#         start = time.time()
#         f()
#         end = time.time()
#         print(end - start)
#     return inner

# @timmer        #  语法糖  在被装饰的函数上面加上@装饰器的名字(必须紧挨着)
# def func():    #  被装饰的函数
#     time.sleep(0.01)
#     print('Happy New Year!')
#
# # func = timmer(func)
# func()

 

# 带返回值的装饰器函数
# import time
# def timmer(f):
#     def inner():
#         start = time.time()
#         ret = f()
#         end = time.time()
#         print(end - start)
#         return ret
#     return inner
#
# @timmer
# def func():
#     time.sleep(0.01)
#     print('Happy New Year!')
#     return '新年好！'
#
# ret = func()
# print(ret)

 

# 带参数的装饰器函数
# import time
# def timmer(f):
#     def inner(*args,**kwargs):
#         start = time.time()
#         ret = f(*args,**kwargs)
#         end = time.time()
#         print(end - start)
#         return ret
#     return inner
#
# @timmer
# def func():
#     time.sleep(0.01)
#     print('Happy New Year!')
#     return '新年好！'
#
# ret = func()
# print(ret)

 

# import time
# def wrapper(f):
#     def inner(*args,**kwargs):
#         """再被装饰的函数之前要做的事"""
#         ret = f(*args,**kwargs)
#         """在被装饰的函数之后要做的事"""
#         return ret
#     return inner
#
# @wrapper
# def func():
#     time.sleep(0.01)
#     print('Happy New Year!')
#     return '新年好！'

 

# 装饰器的固定模式
# def wrapper(func):
#     def inner(*args,**kwargs):
#         ret = func(*args,**kwargs)
#         return ret
#     return inner
#
# @wrapper
# def qqxing():
#     print(1225)
#
# ret = qqxing()
# print(ret)

 # 注：本文是根据老男孩课程内容整理而成的，本文仅供个人笔记使用，如果有侵犯，请联系我，我立即撤销。