内置函数和装饰器的进阶

一、30个内置函数及用法: 带key的重点标注:
# 30个你认为重要的内置函数                      带key参数的函数12.max 13.min 15.sorted
#1 打印
# print(*args, sep=' ', end='
', file=写入的文件名, flush=False  缓存是否)
# def print(self, *args, sep=' ', end='
', file=None): # known special case of print
#     print(value, ..., sep=' ', end='
', file=sys.stdout, flush=False)
#     file:  默认是输出到屏幕,如果设置为文件句柄,输出到文件
#     sep:   打印多个值之间的分隔符,默认为空格
#     end:   每一次打印的结尾,默认为换行符
#     flush: 立即把内容输出到流文件,不作缓存
# with open('a','a') as f: #l类似write
#     f.seek(4)
#     print('dadafdadad阳光',file=f)
#2 range     取范围内的数字,一般用于索引 和控制循环次数
# range()
# range(4)  range(1,6)  range(1,6,2)
#3 open 文件操作函数
# f = open('文件名','w',encoding='utf-8')
#打开模式:r、w、a、rb、wb,ab  都可带+
#编码 utf-8/GBK
#4 内存地址查看  id()
#5 input() 用户交互,结果是字符串
#input(*args, **kwargs)
# 6exec 执行一段文本代码  无返回值,格式是正常的格式
#exec("print('I can')")
# 7 exval   执行一段文本代码  有返回值,格式是正常的格式 (以变量的形式接受一段代码的返回值)
# eval("""input('>>>')
# a = 123
# print(a)""")   # 报错
# print(eval("""input('>>>')"""))
# >>>123
# 123
#8 abs 绝对值 求数字的绝对值
# print(abs(-9))
#9 divmod   商余函数
# print(divmod(2,9))  #0,2
# 10 round 四舍五入函数,可以控制小数长度  同理应该还有 进位小数抹去小数
#python 向上取整ceil 向下取整floor 四舍五入round  https://www.cnblogs.com/lipijin/p/3714312.html
# print(round(3,2))  #3   不包含转换小数点的功能
# print(round(3.12542,2))  #3.13
# 11 sum
# print(sum([1,2,3,4,5,6],-2))
# print(sum(range(100)))
#sum接收一个可迭代对象
# print(sum([1,2,],2))   #一个可迭代对象和一个数字 str 不行
#  12 min
# print(min([1,4,0,9,6]))
# print(min([],default=0))
# print(min([-9,1,23,5],key=abs))#匿名函数
# print(min({'z':1,'a':2}))
# 13 max
# t = (-25,1,3,6,8)
# print(max(t))
# print(max(t,key = abs))
# print(max((),default=100))
# print(max('',default=0))  #default可是设置没有结果时候的默认值
#14 resvered  反转函数  有返回值是一个迭代器,与方法的区别是不改变原来的可适用于所有对象
# l = [3,4,2,5,7,1,-6]       #
# ret = reversed(l)
# print(dir(ret))
# print(list(ret))
# 15sorted 排序函数  有返回值是一个新的列表  与方法的区别是不改变原来的可适用于所有对象
l = [3, 4, 2, 5, 7, 1, -6]
ret = sorted(l,key=abs)
print(ret) #[1, 2, 3, 4, 5, 5, 7]
print(list(reversed('dcba'))) #['a', 'b', 'c', 'd']
# 16 format  除了格式化字符串还有很神通广大的功能 http://www.cnblogs.com/Eva-J/articles/7266245.html
#  #字符串可以提供的参数,指定对齐方式,<是左对齐, >是右对齐,^是居中对齐
# print(format('test', '<20'))   # 后边的数字是控制的长度   想到了center 和capitalize
# print(format('test', '>20'))
# print(format('test', '^20'))
# 17 byte() 转化为字节码 ,第一个位置是str必须要指定转码类型,如果是列表则不需要。第二个位置参数是encoding
# a = 'abc张'
# print(bytes(a,'utf-8'))
# print(a.encode('utf-8'))
# 18 数字与字符串之间进行转换
#  print(ord('a'))
# print(chr(97))
# print(ord('中'))
# print(ascii('中'))
# 20013
# 'u4e2d'
# a-z:97-122
# A-Z:65-90
# 0-9:48-57
# 19  enumerate  枚举
# enumerate(可迭代对象和初始值)
# l = ['笔记本','phone','apple','banana']
# for i,j in enumerate(l,1):
#     print(i,j)
# 20 all  有一个F则F  和 any 有一个T则T  布尔返回型函数有一个
# print(all([1,2,3,4,0]))
# print(all([1,2,3,4]))
# print(all([1,2,3,None]))
# print(all([1,2,3,'']))
# print(any([True,None,False]))
# print(any([False,None,False]))
# 21 zip  拉链函数  以数量少的序列为参考,生成新的序列 元素是元组  zip的对象也可以是字典
# print(list(zip([0,1,2,3,4],[5,6,7,8],{'a':1,'b':2})))#[(0, 5, 'a'), (1, 6, 'b')]
# 22 filter #过滤函数  常常和内置函数连用,过滤掉不满足函数的对象 返回值是一个迭代器
# l = [1, 4, 6, 7, 9, 12, 17]# 过滤大于6的
# print(dir(filter(lambda x:x>4,l)))
# print(list(filter(lambda x:x>4,l)))
# print(l)
#去掉所有的空内容和字符串中的空格
# l = ['test', None, '', 'str', '  ', 'END']
# ret = filter(lambda x :x and x.strip() ,l)
# print(list(ret))
#新内容少于等于原内容的时候,才能用到filter
# 23 map
# l = [1, 4, 6, 7, 9, 12, 17]
# ret = map(lambda x:x*x,l)
# print(dir(ret))
# print(list(ret))

#22 与 23 的区别
#filter和map
#参数很相近:都是一个函数名+可迭代对象
#且返回值页很相近:都是返回可迭代对象
#区别
#filter是做筛选的,结果还是原来就在可迭代对象中的项
#map是对可迭代对象中的每一项做操作的,结果不一定是原来就在可迭代对象中的项
# 24 type()判断数据类型
#25 len()  计算数据结构的长度
#26 工厂函数 str set list dict int
# 27 import  模块导入
import time
# 28 bin,二进制  oct,八进制 hex 16 进制  进制转换
# 29 dir  查看数据的方法 用于判断是否可迭代 是否迭代器等
# 30 globals()——获取全局变量的字典
#locals()——获取执行本方法所在命名空间内的局部变量的字典

二、匿名函数:为了解决那些功能很简单的需求而设计的一句话函数
  匿名函数的格式
函数名 = lambda 参数 :返回值

#参数可以有多个,用逗号隔开
#匿名函数不管逻辑多复杂,只能写一行,且逻辑执行结束后的内容就是返回值
#返回值和正常的函数一样可以是任意数据类型

示例:

#这段代码
def calc(n):
    return n**n
print(calc(10))
 
#换成匿名函数
calc = lambda n:n**n
print(calc(10))

进阶示例:

l=[3,2,100,999,213,1111,31121,333]
print(max(l))

dic={'k1':10,'k2':100,'k3':30}


print(max(dic))
print(dic[max(dic,key=lambda k:dic[k])])
res = map(lambda x:x**2,[1,5,7,4,8])
for i in res:
    print(i)

输出
1
25
49
16
64
res = filter(lambda x:x>10,[5,8,11,9,15])
for i in res:
    print(i)

输出
11
15


装饰器的进阶
# def wrapper1(func):
#     def inner1(*args,**kwargs):
#         print('in wrapper 1,before')
#         ret = func(*args,**kwargs)   #qqxing
#         print('in wrapper 1,after')
#         return ret
#     return inner1
#
# def wrapper2(func):     #inner1
#     def inner2(*args,**kwargs):
#         print('in wrapper 2,before')
#         ret = func(*args,**kwargs)   #inner1
#         print('in wrapper 2,after')
#         return ret
#     return inner2
#
# @wrapper2
# @wrapper1
# def qqxing():
#     print('qqxing')
# qqxing()      # 多装饰器同时作用时候,会先把调用函数传入离他最近的装饰器,然后该装饰器再传入上一级装饰器中

#
def f4(flag):
    def f2():
        def f3(func):
            def inner():
                print('123')
                func()
            return inner
        return f3
    return f2
a = f4(1)
@a()                      #语法糖最多三级,
def func():
    print('hahah')
func()
# 123
# hahah
     



     

原文地址:https://www.cnblogs.com/zjchao/p/7819655.html