本节内容
1. 函数基本语法及特性
2. 参数与局部变量
3. 返回值
嵌套函数
4.递归
5.匿名函数
6.函数式编程介绍
7.高阶函数
8.内置函数
函数是什么?
函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，具体区别，我们后面会讲，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。
定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可
特性:
- 减少重复代码
- 使程序变的可扩展
- 使程序变得易维护
def 函数名（）： 括号是用来传参的,灵活应用
函数名（） #调用
形参:变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
实参:可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值
def sayhi(name,age,nationality='CN'): -----name、age是形参 ，有的默认参数都放在非默认参数（位置参数）的右边 print('i am %s,' %name,age,nationality) -----如果不调用，就安默认打印， sayhi('haha',22) ------haha、22是实参 sayhi('haha',22,US) ------如果传参的话就打印传入的内容 sayhi(name = '11',22) ------指定参数传参，也的放在位置参数后面 关键参数,如果给其中一个写定，并且不按顺序写，其他的都的写定。
关键参数
正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可，但记住一个要求就是，关键参数必须放在位置参数之后。
|
1
|
stu_register(age=22,name='alex',course="python",) |
非固定参数
若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数。
def sayhi(name,age,nationality='CN',*args): *args以元组的形式存在，如果写单个元素就是元组。
def sayhi(name,age,nationality='CN',**kwargs) **kwargs以字典的形式存在，如果写name = 'lwq',就写入字典中。
全局与局部变量
login_status = False #全局变量 虽然与局部变量名字相同，但是在内存中的地址不一样 def auth(username,password): #get date from db _username = 'alex' _password = 'alex3714' if username == _username and password == _password: print('ok') #global login_status #改全局变量，要用global，并且将原来的全局变量写上 login_status = True #局部变量，只在函数中生效 print('--->',login_status) def home(): if login_status ==True: print('welcome') else: auth() def pay(): if login_status == True: print('welcome') else: auth() username = input('username:').strip() password = input('password:').strip() auth()
返回值：
1.一旦你的函数经过调用并开始执行，那你的函数外部的程序就没有办法再控制函数的执行的过程了，此时外部程序只能等待函数的执行结果，因为外部程序要根据外部函数的执行结果来决定下一步如何走，
执行结果就是以return的形式返回给外部程序。
2.return代表着一个函数的结束。
3.return可以返回python中的任何数据类型，一次能返回多个值，以元组的形式返回。
4.对于用户角度，函数可以返回任意数量的值，但对于py本身来讲，函数只能返回一个。
def auth(): username = input('username:').strip() password = input('password:').strip() #get date from db _username = 'alex' _password = 'alex3714' if username == _username and password == _password: print('ok') return True else: return False def home(): if login_status ==True: print('welcome') else: auth() def pay(): if login_status == True: print('welcome') else: auth() login_status = auth() home() pay()
嵌套函数
name = 'alex' def changeName(): name = 'jack' print(name) def changeName2(): name = 'rain' print('name2', name) changeName2() changeName()
递归函数
特性：
1.必须有一个明确的结束条件
2.每进入更深一层递归时，问题规模相比上次递归都应有所减少
3.递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过stack这种数据结构实现的）
每当进入一个函数，栈就会加一层栈帧，每当函数减少一层，栈帧就减少一层。
递归函数的典型事例：二分查找
#data = [3,5,10,1,12,14,17,11,19,20,19] #date = [1,3,5,10,11,12,14,17,19,19,20] date = range(0,10000,3) #range 出来就是列表 def binary_search(datasets,find_num): if len(datasets) > 0: middle_pos = int(len(datasets)/2) if date[middle_pos] == find_num: print('Find num:',datasets[middle_pos]) elif date[middle_pos] > find_num: print('go to left side',datasets[0:middle_pos],datasets[middle_pos]) binary_search(datasets[0:middle_pos],find_num) else: print('go to righ side',datasets[middle_pos+1:],datasets[middle_pos]) binary_search(datasets[middle_pos+1:],find_num) else: print('cannot not find num') binary_search(date,15)
匿名函数：
匿名函数就是不需要显式的指定函数
正常定义函数：
def calc(n): return n*n
print(cacl)
def calc(n,j):
return n*j
print(cacl)
匿名函数：
calc2 = lambda x:x*x print(cacl2)
calc2 = lambda x,y:x*x
calc(8)
与map函数搭配使用
data = map(lambda n:n*2 if n>5 else n,range(10))
data = map(lambda n:n*2 if n>5 else calc(n),range(10))
def cal(n):
return -n
data = map(lambda n:n**n if n>5 else cal(n),range(10))
for i in data:
print(i)
三元运算
a =4
b= 5
c = if a >10 else b
上面的匿名函数与map搭配使用中就用到了三元运算。
函数式编程介绍
函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。
函数式编程中的函数这个术语不是指计算机中的函数（实际上是Subroutine），而是指数学中的函数，即自变量的映射。也就是说一个函数的值仅决定于函数参数的值，不依赖其他状态。比如sqrt(x)函数计算x的平方根，只要x不变，不论什么时候调用，调用几次，值都是不变的。
Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。
一、定义
简单说，"函数式编程"是一种"编程范式"（programming paradigm），也就是如何编写程序的方法论。
主要思想是把运算过程尽量写成一系列嵌套的函数调用。举例来说，现在有这样一个数学表达式：
(1 + 2) * 3 - 4
传统的过程式编程，可能这样写：
var a = 1 + 2;
var b = a * 3;
var c = b - 4;
函数式编程要求使用函数，我们可以把运算过程定义为不同的函数，然后写成下面这样：
var result = subtract(multiply(add(1,2), 3), 4);
这段代码再演进以下，可以变成这样
add(1,2).multiply(3).subtract(4)
这基本就是自然语言的表达了。再看下面的代码，大家应该一眼就能明白它的意思吧：
merge([1,2],[3,4]).sort().search("2")
因此，函数式编程的代码更容易理解。
高阶函数
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
abs求绝对值 def add(x,y,f): return f(x) + f(y) def calc(n): return n+1 res = add(3,-6,cacl) print(res)
编程范式：
1.面向过程
2.面向对象
3.函数式编程
内置函数
python自带
a = [1,2,3]
all(a)
#判断是否为真
any() #列表任意一个为真就返回真
ascii() #显示成ascii表的东西
bin() #将数字转成二进制
print(bin(10))
bool #判断是否为true
bytes #0-255之间的数字，ascii表
bytearray #改bytes值
callable() #判断对象是否可以被调用
chr() #把数字转换成二进制
print(chr(97)) #打印ascii表的对应关系
print(ord('b')) #将字符对应成ascii表中的数字
f = open('递归.py',encoding='utf-8')
code = compile(f.readline(),'','exec')
print(code)
exec(code) #执行这段代码，这段代码是字符串
eval() #数字运算
complex #复数
complex(4,5)
print(dir(f)) #dir返回文件的方法
divmod() #地板除,放回商和余数
divmod(10,2)
filter #过滤
for i in filter(lambda x:x>5,range(10)):
print(i)
format() #字符串格式化
frozenset({1,4,5,5,6}) #把集合变成只读
print(a)
#就没有add方法
globals()
print(globals()) #把当前程序所在内存中所有的数据都以字典的形式打印出来
locals() #只打印局部
hex() #十六进制
print(hex(8))
max() #返回列表汇总最大值
print(max())
min() #返回最小值
oct() #八进制0o8
print(pow(4,9)) #4**9
#分隔符
msg = "又回到最初的起点"
f = open("tofile","w")
print(msg,"记忆中你青涩的脸",sep="|",end="",file=f)
data = [1,2,3,5,8]
data = reversed(data) #反转（字符串、列表）
for i in data:
print(i)
round() #五舍六入
print(round(10.25,1))
data = [10,2,4]
print(set(data)) #将列表变成集合
#切片
a = range(20)
pattern = slice(3,8,1)
for i in a[pattern]:
print(i)
a= 'alex'
a= sorted(a) #按ascii码排序
print(a) 以列表的形式打印,字符窜、集合、列表(并且其中只能由一种数据类型)
data = [10,2,3,45,56,3]
print(sum(data)) #相加 列表、集合、元组都可相加。
print(vars()) #打印当前程序在内存中的所有数据
zip # 类似拉链效应，如果对应不上，就按少的来
a = [1,3,5,7]
b = [2,4,6,8]
for i in zip(a,b):
print(i)