1、内置函数

# print(all([1,2,3,4]))#判断可迭代的对象里面的值是否都为真
# print(any([0,0,0,0,0]))#判断可迭代的对象里面的值是否有一个为真
# print(bin(10))#十进制转二进制
#下面这些函数都是强制类型转换
# print(bool(‘s‘))#把一个对象转换成布尔类型
# int()#整形
# float()#小数
# str()#zifuc
# dict()#字典
# list()#列表
# set()#集合
# tuple()#元组
def func():
pass
# print(callable(func))#判断传入的对象是否可调用
# print(chr(98))#打印数字对应的ascii
# print(ord(‘b‘))#打印字符串对应的ascii码
# print(dict(a=1,b=2))#转换字典
# print(dir(‘a‘))#打印传入对象的可调用方法

# print(eval(‘a=1‘))
#执行python代码，只能执行简单的，定义数据类型和运算
# print(exec(‘def a():pass‘))#执行python代码
def func(num):
name = ‘88‘
print(locals())
print(globals())
return num
# func(11)
# print(list(filter(func,[0,1,2,3,4])))#在python3里面这么用是没问题
#print(filter(func,[0,1,2,3,4]))#在python2里面这么用是没问题

# filter(func,[1,2,3,4])
#根据前面的函数处理逻辑，依次处理后面可迭代对象里面的每个元素，返回true保存
# print(list(map(func, [0,1, 2, 3, 4])))
#根据前面的函数处理逻辑，依次处理后面可迭代对象里面的每个元素，保存前面函数返回的所有结果 </span>

# print(globals())#返回程序内所有的变量，返回的是一个字典,函数里面的局部变量不会返回
# print(locals())#返回局部变量
# print(hex(111))#数字转成16进制
# print(max(111,12,13,14,16,19))#取最大值
# print(oct(111))#把数字转换成8进制
# print(round(11.1198,2))#取几位小数,会四舍五入
#print(sorted([2,31,34,6,1,23,4],reverse=False))#排序

dic={1:2,3:4,5:6,7:8}
print(sorted(dic.items()))#按照字典的key排序
# print(sorted(dic.items(),key=lambda x:x[1]))#按照字典的value排序
# __import__(‘decorator‘)#导入一个模块

# print(bool(‘s‘))#把一个对象转换成布尔类型
# int()#整形
# float()#小数
# str()#zifuc
# dict()#字典
# list()#列表
# set()#集合
# tuple()#元组
# print(round(11.1198,2))#取几位小数,会四舍五入
#print(sorted([2,31,34,6,1,23,4],reverse=False))#排序
## print(max(111,12,13,14,16,19))#取最大值
# print(list(filter(func,[0,1,2,3,4])))#在python3里面这么用是没问题
#print(filter(func,[0,1,2,3,4]))#在python2里面这么用是没问题
# filter(func,[1,2,3,4])
#根据前面的函数处理逻辑，依次处理后面可迭代对象里面的每个元素，返回true保存
# print(list(map(func, [0,1, 2, 3, 4])))
#根据前面的函数处理逻辑，依次处理后面可迭代对象里面的每个元素，保存前面函数返回的所有结果 

装饰器

#1、递归调用
#一个函数自己调用自己就是递归调用,最多一个函数递归调用自己999
#1. 必须有一个明确的结束条件
#2、每次进入更深一层递归时，问题规模相比上次递归都应有所减少
#3、递归效率不高，少用递归
#2、高阶函数
#如果一个函数的入参是一个函数名的话，那这个函数就是一个高阶函数
#函数即变量

#3、python内置函数的用法

#装饰器
#1、函数里面也可以嵌套的定义一个函数
#2、高阶函数
#装饰器说白了就是函数嵌套+高阶函数
#装饰器的作用就是在不改变原有函数的调用方式，入参的情况下，给函数添加新功能
#偷偷摸摸的给函数加上新功能，但是不改变原来的函数
#常用模块
#什么是模块，模块其实就是一个python文件

# def test1():
# num = int(input(‘please enter a number：‘))
# if num%2==0:#判断输入的数字是不是偶数
# return True #如果是偶数的话，程序就退出了，返回true
# print(‘不是偶数请重新输入！‘)
# test1()
# test1()

# def hello(name):
# print(name)
#
# new_hello = hello
# print(type(hello))
# print(type(new_hello))
#如果不明白函数即变量，就看这里

#下面是高阶函数的列子
#如果一个函数的入参是一个函数名的话，那这个函数就是一个高阶函数
# def add(x,y,z):
# #参数z是要传入一个函数名
# res = z(x)+z(y)
# return res
# print(add(‘98‘,‘100‘,int))

#函数的作用域，是就近原则,从里往外找，如果自己函数里有，就拿过来
#如果自己的函数里面没有的话，就去它父级函数里面找
#函数只有被调用才会执行
# name = ‘python‘
# def warpper():#1
# name=‘吴冰‘
# def deco():#2
# name =‘陈冬瓜‘
# def hhh():#3
# name = ‘张莹‘
# print(‘xxx%s‘%name)
# print(‘我在里面%s‘%name)
# hhh()
# deco()
# print(‘外面的name是%s‘%name)
# warpper()
import time,os,sys
def timer(func):
def deco(*args,**kwargs):
#*args,**kwargs用来接收传入函数的参数
start_time = time.time()
res = func(*args,**kwargs)#获取返回值
end_time = time.time()
print(‘runtime‘,end_time-start_time)
return res
return deco

@timer #run = timer(run)
def run():
# start_time = time.time()
print(‘run..‘)
time.sleep(2)
# end_time = time.time()
# print(‘runtime‘, end_time - start_time)
#run == deco，
@timer
def run2(name):
print(name)
time.sleep(0.5)
run2(‘niuhanyang‘)

#上面这个函数其实就是返回了一个函数名而已
#1、调用timer函数的时候，要传入一个方法名，
# timer函数在函数内部定义了一个函数叫做deco
#又在函数deco内部调用了timer里面传入的方法
#run保存的是deco，deco是一个函数，调用run就是调用deco

20170611第五讲