python 函数

-- coding:utf-8 --

def printMe(nickname):
    print("hello,{0}".format(nickname))
    print('hello '+ nickname)
    pass
pass

printMe('changdong')

'''不函数能处理比当初声明时更多的参数，这些参数叫做不定常参数'''
'''语法
def 函数名称(formal_args，*args)：
    函数文档字符串
    函数体
    return [表达式]

加了星号（*）变量名会存放所有未命名的变量参数，选择不多传参也可，可变长参数类型为远足类型
'''
def employeeInfo(name,*skill):
    print('员工姓名:%s' %name)
    print('专业技能：{0}'.format(skill))
    print('~' * 20)
    return 0

employeeInfo("王晓")
employeeInfo('章三',['html','python'])
employeeInfo('里斯','java','ios','swift')
# *args接收的是一个元祖参数


'''补充：两个星号（**）代表接受一个可变长度的字典，因此参数必须以k-v结构出现
def 函数名称（formal_args,*kv）:
    函数文档
    函数体
    return 【表达式】

'''
def student(name,**kw):
    print('学生姓名：%s'%name)
    print('考试成绩：{0}'.format(kw))
    print('~'*20)
    pass

student('李四',sorce=90,shuxue=97)
student('章三',**{'sorce':90,'yuwen':98})
''' *args,**kw必须放在参数列表排名的最后的参数
    *args 代表该参数位置可放置任何个数的数据，最终转换成元组，数据类型在函数体内使用。
    **kw 代表该参数位置可放k=v格式的数据，最终都会转换成字典类型的数据在函数体内是使用。
'''

'''
lambda :表达式，比def简单的多。主体是表达式， 不是代码块，仅仅能在lambda表达式中封装有限的逻辑进去
lambda函数拥有自己命名空间，且不能访问私有参数列表之外，或者全局命名空间里的参数
语法：lambda [arg1,[arg2,[arg3]]]:表达式
语法：lambda只包含一个语句： Lambda 表达式对象 = lambda[arg1,[arg2,...argn]]:表达式（内置函数、自定义函数
运算表达式、推导式）
'''

lambdaSum = lambda x,y : x+y
res = lambdaSum(10,30)
print('num1+num2 = %d'%res)

#使用内置函数作为表达式(build-in)
'''lamExp1=lambda b:print(b)
lamExp1(3)'''

#使用自定义函数作为表达式
import time
def formatTime(nowTime):
    return time.strftime('%Y-%m-%d %H-%M-%S')
lamExp2 = lambda timedate:formatTime(timedate)
strTime = lamExp2(time.localtime())
print('当前日期：>%s'%strTime)

#使用推导式作为表达式
lamExp3 = lambda x:[i**2 for i in range(x)]
list1 = lamExp3(3)
print('结果为：>{0}'.format(list1))

'''
全局变量
全局变量想要作用与函数内，需加global
global将变量定义为全局变量，可以定义为全局变量，实现在函数内部改变变量值
一个global语句可以定义多个变量，如global x,y,z
'''
def set_globalvar_one(): #定义函数
    global globalvar         #在函数内声明全局变量的内部作用域使用权
    globalvar = 1            #赋值

def print_globalvar():
    #先检查函数内有无局部变量globalvar
    #没有在找全局，再没有报错
    print('print_globalvar函数的输出：%d'%globalvar)
    pass

set_globalvar_one()

print_globalvar()


'''
高阶函数：能接受函数做参数的函数
函数的参数可以接受变量
'''

'''
装饰器：
应用场景：插入日志，性能测试，事务处理等
有了装饰器，就能提取大量函数中与本身功能无关的代码，从二达到代码重用的目的
'''

def decoratorFunc(f):
    print("前置执行...")
    f() #调用函数
    print("后置执行...")
    pass

#装饰器使用
@decoratorFunc
def func1():
    print('hello 中软国际')
    pass

'''程序执行的性能测试'''
def calcTime(func):
    print('-->开始计时....')
    startTime = time.time()
    func() #调用传入函数
    endTime = time.time()
    print('--->结束计时.....')
    mescs = (endTime - startTime) *1000
    print('--->性能测试结果：'+func.__name__+'()函数耗时：%f ms'%mescs)
    pass

@calcTime
def func2():
    print('func2() start....')
    time.sleep(0.6)
    print('func2() end...')

'''
闭包Closure：
在一个外函数内定义了一个内函数，内函数运用了外函数的临时变量，且外函数的返回值是内函数的引用，这就构成了一个闭包
实现规则：
1.定义内部函数
2.外部函数必须有返回值，返回值必须为内部函数对象
'''
#闭包实例，outer为外部函数，a,b为外部函数的临时变量
def outer(a):
    b = 10
    def inner(c):
        print(a+b+c) #内函数中用到了外函数的临时变量
        print('c = %d'%c)
    return inner #w外函数的返回值是内函数的引用

#闭包调用
demo = outer(5)
print(type(demo))
print(demo(3)) #调用inner 18

'''
内部函数为匿名函数，为了简化代码，用lambad 
'''
def outerFunc(a):
    b = 10
    return lambda c: a+b+c

f1 = outerFunc(4)
res = f1(4)
print(res)

'''
生成器Generator
解析器事实生成数据，数据不会驻留在内存中
'''
#使用推导式快速创建一个生成器
myGenerator =(i**2 for i in range(10) if i%2 == 0)

for item in myGenerator:
    print(item)
    pass

'''
生成器yield关键字
yield是一个类似return的关键字，只是这个函数返回的是个生成器
调用该函数，函数内部不会立即执行，只是会返回一个生成器
当使用for循环时，函数中代码才会执行
'''
def createGenerator():
    for i in range(10):
        yield i ** 2
    pass

myGenerator = createGenerator()
for item in myGenerator:
    print(item)
    pass