一、函数　

　　1.面向对象　　》》类 》》class

　　2.面向过程　　》》 过程 》def  是把一段段的逻辑或功能放入一个def中，当想用的时候可以直接调用。

　　3.面向函数　　》》 函数 》def

#面向函数
def fcont1(): #定义一个函数 fcont1为函数名。
"test" #函数的一个说明，以后写函数一定要注明，主要是为后人写程序提供清晰的。
print(‘in the fcont1‘) #此处指的是逻辑。
return 0 #函数的结束及返回值。

#过程
def fcont2(): #面向过程的函数是没有返回值的。这了是其中的一个区别。
"test"
print(‘in the fcont2‘)

x = fcont1() #把函数里的值赋予给x
y = fcont2() #把函数里的值赋予给y

print(‘from fcont1 return is %s‘%x)
print(‘from fcont return is %s‘%y)

二、为什么要使用函数

　　1、可扩展性

　　2、减少代码的重复性

　　3、保持一致性

　　import time #调用系统时间的模块。

def logger(): #定义一个函数名。
"logfile" #函数注释，这个一定要养成良好的习惯。
time_formart = "%Y-%m-%d %X" #定义时间格式 %Y year年，%m(m小写 month),%d(d 小写 day天)，%X 时分秒。
time_current = time.strftime(time_formart) #给时间定义一个一变量名。
with open("log.txt","a+") as f:
f.write("%s end action\n"%time_current) #套用时间的变量名。
def data1():
"dataLog1"
print("in The data1")
logger()　　#调用logger写日志操作的函数模块。

def data2():
"dataLog2"
print("in The data2")
logger()

def data3():
"dataLog2"
print("in The data3")
logger()

data1()
data2()
data3()

三、函数的调用。

　　1、形参

　　　 形参顺序无关

　　　　形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部　　　　有效。函数调用结束返回主调用函数后则不能再使用该形参变量

　　2、实参.

　　实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

def byron(x,y,z):　　#形参
    "The is test1"
    print(x)
    print(y)
    print(z)

c =byron(1,3)  #实参
print(c)       #实参

byron(y=2,x=1)  # 此处为关键字调用 与形参顺序无关
byron(1,2)      #此处为位置参数调用 与形参一一对应。
byron(3,y=2)    #既有位置参数又有关键字，位置参数需在前，后面的需要形参关键字

 　　3、#默认参数
def byron(x,y=10):
"The is test1"
print(x)
print(y)
byron(1) #默认参数的特点：调用函数的时候，默认参数非必须传递，如没有指定参数则直接输出默认参灵敏。
　　　　 #默认参数的应用场景：安装软件时的自定义安装。
　　　　 #连接数据库的参数。

　　3、多实参,参数组如何定义一个形参？？？
def byron(*args): # *号可以理解成一个功能吧！只能接受位置参数。
"The is test"
print(args)
byron(1,2,3,4,5,90) #存放到一个元组里了。
byron(*[1,2,3,4,5]) # args = tuple([1,2,3,4,5])

#**kwargs 把N个关键字参数转换成字典的方式

def byron(**kwargs):
"test 字典"
print(kwargs)
print(kwargs["name"]) #单独取字典里的了个值。
print(kwargs["age"])
byron(name="byron",age=18) #关键字参数。
byron(**{"name":"byron","age":18}) #字典方式，与上面的一个方式输出结果一样。


def byron(name,**kwargs):
print(name)

byron(byron,**{"age":18,"job":"linux"})


def byron(name,age=10,*args,**kwargs):
print(name)
print(age)
print(args)
print(kwargs)

byron("xiaoming",50,job="it",salary=5000,)

四、作用域及局部变量。

　　在子程序中定义的变量称为局部变量.

　　在程序的一开始定义的变量称为全局变量。

 def byron(name,age=26,**kwargs):
print(name)
print(age)
print(kwargs)
logger(byron) #调用logger


def logger(source):
print("From %s"% source)
byron("lina", 62, job="IT", salary=50000) #注意，此处应该在内置函数之后，放在之前会报错！


def byron(name):
print("Before change:",name)
name = "lishi" #局部变量，此处变量只在此函数内生效，这个函数是这个变量的作用域
print("After change:",name)

name = "Lisi"
byron(name)
print(name)

school = "ByronHe"
def Byron(name):
global school #全局变量。
school = "cbc"
print("Befter change:",name,school)
name = "LiSHI"
print("After change:",name)

name = "laowang"
Byron(name)
print(name)
print(school)

list = ["xiaoming","zhangshan","lishi"]
def Byron():
print("Befter change:",list) #在局部变量中，列表，字典,集合是可以更改的，但是整数及字符串是不能更改的
list[0] = "lao"
name = "Xiaoming"
Byron()

print(list)

五、递归。

递归特性:

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

def recursion(n):
    print(n)
    return recursion(n+1)   #循环加1 加至999会结束，否则会引起主机死机，此处系统已做机制
recursion(0)



def recursion(n):
    print(n)
    if (int(n/2)) > 0:
        return recursion(int(n/2))  #此返回值为n/2的小数，但被int整形，代表结束。
    print(">>",n)

recursion(10)

六、高阶函数
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

#高阶函数
def Byron(a,b,f):
    print(f(a)+f(b))

res = Byron(3,-7,abs)
print(res)

python第四周