函数基础

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:woshinidaye
'''
函数！function
几种编程方法
1、面向对象：类(class)、
2、面向过程：过程(def)
3、函数式编程：函数(def)
'''

'''
#定义一个------函数
def test(x):            #函数名
    #this is a test function       #描述
    x = x+1         #代码块
    return x        #定义返回值，并终止函数
print(test(2))

#定义一个------过程:过程是没有返回值的函数
def test2():
    #this is a test function
    print('for process')
print('====>>>',test2())    #test2没有定义返回值，python返回none

#函数的运用，可以把某一段重复性的功能用函数实现，这样实现了代码的重复利用
#而且代码的修改可以直接在函数上进行修改，
import time
def log():
    #time_format = '%Y-%m-%d %X'
    time_current = time.strftime('%z-%Y-%m-%d %X')
    with open('log.txt','a+',encoding='utf-8') as f:
        f.write('%s\ttest line\n'%time_current)
def test_log_1():
    print('function test_log_1')
    #time.sleep(3)
    log()
def test_log_2():
    print('function test_log_2')
    #time.sleep(3)
    log()
test_log_1()
test_log_2()
'''

'''
def test():
    print('this is test function!')
    return 0
    print('还对打印这一行吗？？')             #前面是return 0,说明函数已经介绍，并返回0，这一行将不会被执行
test()
print(test())
x = test()              #return的值可以赋予x
print('====>>>',x)
'''

'''
#return的类型
def test1():
    print('test1')
def test2():
    print('test2')
    return 0
def test3():
    print('test3')
    return 1,'hello world',['zhangsan','lisi'];{'zhangsan':'lisi'}
x1 = test1()        #没定义return，解释器显示返回0
x2 = test2()        #return 0
x3 = test3()        #返回元组
print(x1,'\n',x2,'\n',x3,'\n',x3[1])
'''


#定义有参数的函数
'''
def test(x,y):
    print(x)
    print(y)
test(1,2)       #形参x、Y、实参1、2。形参的数量=实参的数量 #位置参数调用，与形参一一对应
test(x=2,y=2)   #关键字调用，与形参书序无关
#关键参数不能写在位置参数前面！！！！！！！
#test(x=1,2)     #positional argument follows keyword argument
test(3,y=4)         #可以正常运行，3赋值给x
#test(3,x=3)           #test() got multiple values for argument 'x'
def test1(x,y,z):
    print(x)
    print(y)
    print(z)
test1(1,2,3)
print('>>>>>>><<<<<<<')
test1(1,z=3,y=1)
'''
#默认参数：用于默认安装、连接数据库的端口号
#def test1(x,y=2,z):         #SyntaxError: non-default argument follows default argument,默认参数后面只能跟默认参数

'''def test1(x,y,z=2):         #SyntaxError: non-default argument follows default argument,默认参数后面只能跟默认参数
    print(x)
    print(y)
    print(z)
test1(1,2,3)
test1(1,2,z=2)
test1(1,2)'''

#除开默认参数，要求形参的个数与实参的个数相等，但是如何实现任意多个实参，函数都能正常运行呢？
#参数组
#*args,接收N个位置参数，转为元组
'''
def test2(*args):
    print(args)
test2(1,2,2,2,3,4,4,4)
test2(1,2,3,4,213,5,6,7,8,9,0,12)       #结果会把实参全放到元组中
test2(*[1,2,3,4,213,5,6,7,8,9,0,12])    #结果会把实参全放到元组中 *[1,2,3,4,213,5,6,7,8,9,0,12] = *args   args=tuple([1,2,3,4,213,5,6,7,8,9,0,12])
'''

'''
def test3(x,y,z=3,*args):
    print(x)
    print(y)
    print(z)
    print(args)
test3(1,2)      #结果，x=1 y=2 z=3 元组为空
test3(1,2,4)     #结果，x=1 y=2 z=4 元组为空
test3(1,2,4,[12313,234,567])    #把[12313,234,567]这个列表作为一个合在一起的参数，等于是传入了一个参数
test3(1,2,4,*[12313,234,567])   #把args=[12313,234,567]这个列表先转换为tuple,之后再传入，等于是传入了三个参数
a = [12313]
b = tuple([12313,234,567])
print(a,type(a))
print(b,type(b))
'''

#**kwargs,接收N个关键字参数，转为字典
'''
def test3(x,y,z=3,**kwargs):            #把关键字参数转化为字典
    print(x)
    print(y)
    print(z)
    print(kwargs)
    print(kwargs['name'])
test3(1,2,name='zhangsan',age=123)
test3(1,2,3,name='zhangsan',age=123)
test3(1,2,3,**{'name':'zhangsan','age':123})

def test3(x,y,z=3,**kwargs):            #把关键字参数转化为字典
    print(x)
    print(y)
    print(z)
    print(kwargs)
    print(kwargs['name'])
    logger('test3')
def logger(source):
    print('from %s' % source)
test3(1,2,3,name=123,age=18)
'''

#局部变量
# age = 123               #全局变量，强烈不建议在函数内部修改全部变量
# name = 'zhangsan'
# def change_name(name):
#     #global age
#     print('before change,your name is %s,age is %s ' % (name,age))      #函数里面也可以直接引导全局变量
#     #age = 12345678     #要从函数内部修改全局变量，需要添加global命令
#     name = 'lisi'       #这里就是局部变量，这个变量的作用域仅存在与这个函数。。。
#     print('after change,your name is %s' %name)
#
# change_name(name)
# print(name)             #结果还时张三
# print(age)

# names = ['zhangsan','lisi','laowang']
# def change_names():
#     names[0] = 'mytest'
#     print('===>',names)
# change_names()
# print(names)            #在函数里面居然改了，全局也生效了！！
#这是因为列表、字典、集合、类，均可以在局部，对全部修改。除了字符串和整数，不能在局部修改

#递归函数
#自己调用自己，类似于贪吃蛇，
# 必须有明确的结束条件maximum recursion depth exceeded while calling a Python object
#每一次递归的问题参数逐层减少
#递归函数的处理速度较慢
# def sum(n):
#     print(n)
#     return sum(n)
# sum(10)

# def calc(n):
#     print(n)
#     if int(n/2) >= 1:
#         return calc(int(n/2))
#     print('====>>>',n)          #上面的递归函数执行完了，才会执行到这一步
# a = 1.231412
# print(a,type(a),int(a),type(int(a)))
# calc(100)

#高阶函数：将一个函数以参数的形式传给另外一个函数，这个函数就成为高阶函数
def cal(x,y,f):
    # c = x + y
    # print(c)
    # return c
    return f(x)+f(y)
# cal(1,2)
test = cal(3,-8,abs)
# print(cal(1,2))
# print(abs(123-1234))
print(test)