Python基础知识之函数

五、函数

用于封装一个特定的功能，函数是可以重

复执行的语句块，可重复调用

（一）内置函数

1.基本函数

函数	备注	说明
print(,end=)		输出函数
input（）		输入函数
type(a)		查看a的数据类型
id()		获取变量存储的对象地址

2.数据类型转换函数

函数	说明
int(<对象>[，base])	转化为整数，base-进制转换（2，8，,16）
float(<对象>)	转化为浮点数
str(<对象>)	转换为字符串
bool(<对象>)	转化为布尔值

注：

1.数字0，空字符串、None、空列表、空字典、空元组布尔值是False，其他是True

2.在计算机里，True 和False使用数字1和0表示

（二）高阶函数

1.定义

将函数作为参数或返回值的函数

2.内置函数

函数
map(<函数>,<迭代对象>)	映射 == select,返回新的可迭代对象
filter(函数,可迭代对象)	根据条件筛选可迭代对象中的元素，返回新的可迭代对象。
sorted(可迭代对象，key =函数 ，bool)	排序
max(可迭代对象，key =函数)
min(可迭代对象,key =函数(lambda))

lists = [4,10,6,20,50,45]
for item in max(lists,key=lambda item:item):
    print(item)

（三）自定义函数

设计思想---分而治之

1.定义函数

"""
语法：
​
def <函数名>( <形式参数>):
"""文字说明功能 """
          函数体
"""
def print_hello():  #无参函数
    """
    打印hello
    """
    print("hello")
    
#有参函数    
def print_num(n):
    """
    1-n的和
    """
    result = 0
    for i in range(101):
        result += i
    return result
​
#空函数  用于构思代码
def func(x):
    pass

2.调用函数

#语法：<函数名>(<实际参数>)
"""
   *   
  ***  
 ***** 
*******
"""
def print_diagram():
     for i in range(1,8,2):
        j = int((7-i)/2)
        print(" "*j+"*"*i+" "*j)
        
print_diagram()#调用函数

3.返回值 return

#作用：返回结果，退出函数
def a(i):
    return i
print(a(1))   #1

4.作用域 LEGB

• 类型

  \1. Lobal局部作用域：函数内部。

  \2. Enclosing 外部嵌套作用域 ：函数嵌套。

  \3. Global全局作用域：模块(.py文件)内部。

  \4. Builtin内置模块作用域：builtins.py文件。

• 变量查询规则

  L =>E=>G=>B

• 函数内修改全局变量

  g01 = "ok"
  ​
  def fun01():
      a = 0 #局部变量，只能在本函数内使用
      global g01
  ​
      g01 = "no"
  ​
      global g02  #定义一个全局变量
  ​
      g02 = "20"
     
  print(a)  #a是局部变量，会报错

5.函数参数

• 实际参数

  #1.位置实参----实参与形参的位置依次对应
  def fun01(a,b,c,d):
      print(a,b,c,d)
  ​
  fun01(1,2,3,4)
  #2.关键字实参----实参与形参的根据名称进行对应
  def fun01(a,b,c,d):
      print(a,b,c,d)
      
  fun01(b=1,d=2,a=3,c=4)
  #3.序列实参
  def fun01(a,b,c,d):
      print(a,b,c,d)
  ​
  list01 = [1,2,3,4]
  fun01(*list01) #星号将序列拆分后按位置与形参进行对应 
  ​
  #4.字典实参
  def fun01(a,b,c,d):
      print(a,b,c,d)
  ​
  dict01 ={“a”:1,"b":2,"c":3,"d":4}
  fun01(**dict01)  #**将字典拆分后按名称与形参进行对应

• 形式参数

  #1.缺省参数(默认) 若实参不提供，可以使用默认值
  def fun01(a=0,b=0,c=0,d=0):
      print(a,b,c,d)
  ​
  fun01( b=2,c=3)  #与关键字实参：调用者可以随意传递参数
  ​
  #2.位置形参     注
  def fun01(a,b,c):  #a:int 可以限制参数的数据类型
      pass
  ​
  fun01(a,b,c)
  ​
  #3.星号元组形参
  def fun01(*args）: #*args将所有实参合并为一个元组，让实参个数无限
      print(a)
  ​
  fun01(a) 
  #4.命名关键字形参  在星号元组形参以后的位置形参
  def fun01(*args,a,b）: 
  ​
      print(a,args,b)
  ​
  fun01( 1,2,3,b=2) 
  fun01( a=1,b=2) 
  #作用：强制使用关键字传参
  #5.字典形参   实参可以传递数量无限的关键字实参
  ef fun01(**kwargs）: **将所有实参合并为一个字典，让实参个数无限
      print(a)
  ​
  fun01(a=1,b=2 ) 
  #fun01(**{ }) 拆字典传参

  注：组合使用 位置形参，默认形参，*args，命名关键字形参，**kwargs

  def func(x,y=1,*args,z,**kwargs):
      pass

  函数内存图

 

矩阵装置

 

lists = [
    [1,2,3,4],
    [4,5,6,7],
    [8,9,10,11],
    [12,13,14,15]
]

for i in range(len(lists)):
    for j in range(i+1,len(lists)):
        lists[i][j],lists[j][i] =lists[j][i],lists[i][j]

print(lists)

"""
[[1, 4, 8, 12], [2, 5, 9, 13], [3, 6, 10, 14], [4, 7, 11, 15]]
"""

6.名称空间，存放名字的地方，是对栈区的划分

作用：有了名称空间，就可以在栈区中存放相同的名字，划分为3种：

（1）内置名称空间

存放的名字：存放python解释器内置的名字

print input等

存放周期：python解释器启动则产生，解释器关闭则销毁

（2）全局名称空间

非内置的名字以及非函数内定义的名字

存活周期：python文件执行则产生，文件结束则销毁

（3）局部名称空间

函数内定义的名字

存活周期：在调用函数时存活，函数结束则销毁

a = 6  #全局
c= 2
print(a)  #a= 6 
​
def func():
    a= 5   #局部  
    print(a) #a=5    采用就近原则
func()
print(a)  #a= 6 

（四）函数式编程

用一系列函数解决问题

1.函数作为参数

(1)定义

用一系列函数解决问题

函数可以赋值给变量，赋值后变量绑定函数。

允许将函数作为参数传入另一个函数。

允许函数返回一个函数。

list01=[43,4,5,5,6,7,87]
def find(func,list01): #“封装” “继承” “多态”
  for item in list01:
    if func(item):
      yield item
​
#条件类 
def func1(item):   
​
  return item %2 == 0
​
def func2(item):
​
  return item >= 10
​
def func3(item):
​
  return 10<= item <= 50
​
​
​
for item in find(func1):
​
  print(item,end=" ")
​
print("------------")
​
#lambda练习
​
for item in find(lambda item:item >= 10):#lambda item:item%2==0  
#lambda s,b :s>b
  print(item,end=" ")

（五）闭包

1.三要素：

必须有一个内嵌函数

内嵌函数必须引用外部函数中变量

外部函数返回值必须是内嵌函数

2.语法

def 外部函数名(参数):
    外部变量
    def 内部函数名(参数):
        使用外部变量
    return 内部函数名
​
#调用
变量 = 外部函数名
变量()
​
def give_money(money):
    print("得到%d钱"%money)   #外部嵌套作用域
    def buy(target,price): 
        nonlocal             #修改外部嵌套作用域用 nonlocal
        if money >=price:
            money -= price
        else:
            print("钱不够")
    return buy
​
money = give_money(1000)
money("猪肉",22)
money("零食",100)

（六）装饰器

1.定义：

在不改变原函数的调用以及内部代码情况下，为其添加新功能的函数

2.语法

"""
def 函数装饰器名称(func):
    def wrapper(*args,**kwargs):
        需要添加的功能
        return func(*args,**kwargs)
    return wrapper
    
@函数装饰器名称
def func():
    函数体
    
func()
"""

（七）函数递归

1.函数的递归调用：是函数嵌套调用的一种特殊形式

2.递归的两个阶段：

回溯：一层层调用下去

递推：满足某种结束条件，结束递归调用，然后一层一层返回

#使用递归求n项和
def num_sum(n):
    if n == 1:  #递归的结束条件，必须有，否则就成了死循环了
        return 1
    else:
        return (n-1) + n
​
num_sum(100)
​
#用递归将所有数字打印数来
lists = [1,2,[3,4,[5,6,7] ] ]
def print_num(lists):
    for item in lists:
        if type(item) == list:
            print_num(item)
         else:
            print(item)
print_num(lists)
#二分查找法 （递归）
lists = [1,2,3,4,6,8,10,13,15,16]
def get_num(num,lists):
    if bool(lists) ==Falue:
        print("没找到")
     else:
        index = len(lists) // 2
        if num == lists[index]:
            return lists[index]
        elif num < lists[index]:    #比中间的值小，
            get_num(num,lists[:index]) #查找左边的值
​
        elif num > lists[index]: # #比中间的值大，
            get_num(num,list[index+1:]) #查找右边的值
    
get_num(8,lists)