Python函数

函数基本知识

1、函数（Function）：通过专门的代码组织，用来实现特定功能的代码段，具有相对独立性，可供其他代码重复调用

自定义函数第一步

1、不带参数函数

#求因数
def factor_no_para():
    i=1
    nums=10
    print('%d的因数是：'%(nums))
    while i<=nums:
        if nums%i == 0:
            print('%d'%(i))
        i+=1

factor_no_para()
tt=type(factor_no_para)
print('不带参数的函数：',tt)

2、带参数函数

#求因数
def find_factor(nums):
    ''' 是自定义函数
        nums是传递一个正整数的参数
        以字符串轻视返回一个正整数的所有因数'''
    i=1
    str1=''
    print('%d的因数是：'%(nums))
    while i<=nums:
        if nums%i==0:
            str1=str1+' '+str(i)
        i+=1
    print(str1)

num2_L=[10,15,18,25]
i=0
num_len=len(num2_L)
while i<num_len:
    find_factor(num2_L[i])
    i+=1

3、带返回值函数

#求因数
def find_r_factor(nums):
    i=1
    str1=''
    while i<=nums:
        if nums%i==0:
            str1=str1+' '+str(i)
        i+=1
    return str1

num3_L=[10,15,18,25]
i=0
num_len=len(num3_L)
return_str=''
while i<num_len:
    return_str=find_r_factor(num3_L[i])
    print('%d的因数是：%s'%(num3_L[i],return_str))
    i+=1

4、自定义函数的完善
1> 函数文档
    定义函数文档：方法内用三括号描述
    查看函数文档：

#查询函数文档
help(find_factor)

2> 健壮性考虑（比如对输入的类型进行校验）

if type(nums)!=int:
    print('输入值类型出错，必须是整型！')

代码演示：

#求因数
def find_factor(nums):
    ''' 是自定义函数
        nums是传递一个正整数的参数
        以字符串轻视返回一个正整数的所有因数'''
    if type(nums)!=int:
        print('输入值类型出错，必须是整型！')
        return
    i=1
    str1=''
    while i<=nums:
        if nums%i==0:
            str1=str1+' '+str(i)
        i+=1
    retune str1

5、把函数放到模块中
1> 建立函数模块 test_function.py

def print_num(num):
    '''print_num是自定义函数，用来打印数字
        num是传递一个正整数的参数
        int形式返回打印的数字'''
    if type(num)!=int:
        print('输入值类型出错，必须是整数')
        return
    if num<=0:
        print('输入值')
    print(num)
    retun num

2> 调用函数模块
 a、导入函数模块

import test_function
test_function.print_num(11)

 b、导入指定函数

from test_function import print_num
print_num(12)

 c、导入所有函数

from test_function import *
print_num(13)

 d、模块名、函数名别名方式

import test_function as t1
t1.print_num(14)

3> 模块搜索路径

import sys
sys.path[0]='/Python/function'
from test_function2 import *
print_num2(20)

自定义函数第二步

1、参数的变化

def test1(name='',age=18):
    print('姓名：%s，年龄：%d'%(name,age))

print('默认值：')
test1(18)
    
print('位置参数：')
test1('Tom',11)

print('关键字参数：')
test1(name='John',age=20)


def watemelon(name,*attributes):
    print(name)
    print(type(attributes))
    destription=''
    for get_t in attributes:
        destription+=' '+get_t
    print(destription)

print('传递任意数量的参数值(元组)：')
watemelon('西瓜','甜','圆形','绿色')

def watermelon(name,**attributes):
    print(name)
    print(type(attributes))
    return attributes

print('传递任意数量的键值对(字典)')
print(watermelon('西瓜',taste='甜',shape='圆形',color='绿色'))

2、传递元组、列表、字典值
  在自定义函数内获取从参数传递过来的列表、字典对象后，若在函数内部对它们的元素进行变动，则会同步影响函数外部传递前的变量的元素

3、函数与变量作用域
1> 全局变量（Global Variable）：自赋值定义开始，后续代码都可以访问该变量
  还输内部默认只能读取全局变量的值，若需要修改全局变量，则需要使用global关键字进行事先声明。
  global j
2> 局部变量（Local Variable）：只能在被定义的函数或类内部被访问
3> 闭包（Closure）：是介于全局变量和局部变量之间的一种特殊变量
    要改变闭包变量k，需要事先用nonlocal关键字声明k，修改结果k也变成了sum1的局部变量，不鼓励使用该方法传递值及修改值。

j=5
def sum0():
    k=2
    def sum1():
        i=k+j
        return i
    return sum1()
print('调用sum0结果：%d'%(sum0()))

4、 匿名函数

a=lambda x,y:x*y
print('定义匿名函数：',a(2,3))

5、递归函数
 递归（Recursion Algorithm，递归算法）：在计算机科学中是指一种通过重复将问题分解为同类的字问题而解决问题的方法。

def recursion_sum(num):
    if num==1:
        return num
    tt=recursion_sum(num-1)+num
    print('第%d次递归'%(num))
    print('返回值%d 在内存中地址：%d'%(tt,id(tt)))
    return tt
print('递归求解1-n的和：',recursion_sum(10))

#二分查找递归实现
def r_dichotomy(nums,find,left,right):
    if left>right:
        return -1
    middle=(right+left)//2
    if nums[middle]==find:
        return middle
    elif nums[middle]<find:
        return r_dichotomy(nums,find,middle+1,right)
    elif nums[middle]>find:
        return r_dichotomy(nums,find,left,middle-1)

num_L=[1,2,3,4,8,16,20,30]
print('二分查找递归实现：',r_dichotomy(num_L,2,0,len(num_L)-1))