一、自定义函数的固定语句

def contrast(a,b) :      #使用def来定义一个名称为contrast的方法,a与b的值是两个变量，称为形参
    if a>b :       #使用条件语句进行判定
        return a           #返回a的值
    elif b>a :
        return b           #返回b的值
    else:
        return ('a=b')    #返回字符串a=b

c = contrast(1,1)     #实例化方法contrast
print(c)           #输出c

输出结果：

a=b

可以引用随机数进行判定：

import random       #引用随机函数
x = random.randint(1,5)    #使用随机函数中的随机整数方法
y = random.randint(1,5)
c = contrast(x,y)         #调用contrast方法，这时变量x和y,称为实参
print(x,y,c)

输出结果：

1 1 a=b

二、模块化自定义代码的引用

一般我们写好某些自定义函数方法后存储在.py文件中，需要的时候我们直接调用

创建一个.py结尾的文件，并存入你自己定义的方法函数

import random
from 模块化代码 import *      #从模块化代码文件中引用所有方法，引用指定方法就写方法名称就可以
x = random.randint(1,5)
y = random.randint(1,5)
c = contrast(x,y)
print(x,y,c)

运行结果：

2 5 5

注意：*为所有方法，当我们储存自定义方法函数的文件和Python运行代码不在同一个目录，则需要写上绝对路径，例如：方法位置为：pythonProject/模块化代码.py，我们调用时需要注明路径为：from pythonProject.模块化代码 import *

三、可变变量和不可变变量

不可变变量

def f(a) :       #定义方法f()
    a = 'boy'
    return a

b = 'girl'
c = f(b)         #实例化方法f()
print(c)

输出结果：

boy    

注意：字符串是不可变变量，这样操作无意义

可变变量

def f(a) :          #定义方法f()
    a.append('boy')     #追加字符串
    return a

b = ['girl']
c = f(b)    #实例化方法f()
print(c)

输出结果：

['girl', 'boy']     #列表是可变的，使用追加方法。

四、自定义函数方法中的避免被另一个文件调用的语句

def contrast(a,b) :
    if a>b :
        return a
    elif b>a :
        return b
    else:
        return ('a=b')
if __name__ == '__main__' :  #写在这个语句下的所有代码都不会被调用，只在本文件中运行
    def f(a):
        a.append('boy')
        return a
    b = ['girl']
    c = f(b)
    print(c)

一、函数定义

# 定义一个函数
def my_func(input_text):
    print(input_text)

my_func('hello world')
 # hello world
 
 # 其中
 # def是定义函数的声明
 # my_func 是函数的名称
 # 括号里面的input_text 是函数的参数
 # print部分是函数的执行语句部分
 # 在函数最后，你可以返回调用结果(return 或 yield),也可以不返回值
 
 # 抽象出来大概就是
 def func_name(param1,param2,...,paramN):
   statements
   return/yield value

由于python是不需要编译的，所以其函数def是可执行的一条语句，也就意味着直到函数被调用前，这个函数都不存在，直到函数被调用时，def语句才会创建一个新的函数对象，并赋予名字。

函数使用小tips:

1. 如果我们的主程序调用函数时，函数没有在之前定义，那就会报出错误

my_func('hello world')
def my_func(input_text):
    print(input_text)
#NameError: name 'my_func' is not defined

2. 但是如果我们是在函数中去调用函数，那函数定义的先后就不受影响

def my_func_v1(input_text):
    my_func(input_text)
    
def my_func(input_text):
    print(input_text)
    
my_func_v1('hello world')
#hello world

二、函数参数

函数在调用参数的时候，可以为其设定一个默认的值，这样如果param没有传入，则参数默认传0；而如果传入了参数则会覆盖默认值。

def my_sum(num1, num2 = 1):
    return num1+num2

print(my_sum(1))
# 2
print(my_sum(1, 2))
# 3

注：由于python是动态类型的，也就是说python可以接受任意数据类型的值。而对于函数参数来说，这一点用样的适用。

print(my_sum([1,2],[2,3]))
#[1, 2, 2, 3]

print(my_sum('hello',' python'))
#hello python

print(my_sum('hello',[1,2]))
#TypeError: can only concatenate str (not "list") to str

# 可以看出python不用考虑输入的数据类型，程序内部会去判断执行，
# 同一个函数可以同时应用在多种数据类型操作中，而这样的行为在java等语言中被称为多态

三、函数嵌套

python 函数还有一大特性就是支持函数的嵌套。所谓的函数嵌套，就是函数里面又有函数

def f1():
    print('hello')
    def f2():
        print('python')
    f2()
f1()
#hello
#python

函数嵌套可以保证内部函数的隐私。内部函数只能被外部函数所调用和访问，不会暴露在全局作用域，因此，如果你的函数内部有一些隐私数据，不想暴露在外，那你就可以使用函数的嵌套，将其封装在内部函数中，只通过外部函数来访问。其另一个作用就是可以简化代码。

四、函数变量作用域

python 函数中变量的作用域和其他语言类似，分为全局变量和局部变量

# 定义局部变量，此时的file就是一个局部变量函数外部是无法访问的
def read_text(file_path):
  with open(file_path) as file:
    ...
    
# 定义全局变量,此时的MIN_VALUE & MAX_VALUE 就是全局变量，程序任意位置都可以访问
MIN_VALUE = 1
MAX_VALUE = 10
def val_check(value):
  if value > MAX_VALUE or value < MIN_VALUE:
    raise Exception('check fails')
   

在python中我们不能在函数内部随意改变全局变量的值

# 函数内部修改全局变量
MIN_VALUE = 1
MAX_VALUE = 10
def val_check(value):
  MIN_VALUE += 1
  
val_check(1)
# 这段代码在idea中会不通过。运行的话会报错：UnboundLocalError: local variable 'MIN_VALUE' referenced before assignment
# 原因是python解释器会默认函数内部的变量都为局部变量，但是有没有关于MIN_VALUE 的声明。

# 如果我们需要修改在函数中修改全局变量的值，需要加上global,通过其告诉python解释器，
# 函数内的MIN_VALUE 是我们之前定义的全局变量
MIN_VALUE = 1
MAX_VALUE = 10
def val_check(value):
    global MIN_VALUE
    MIN_VALUE += 1

val_check(1)
print(MIN_VALUE)
# 2

# 如果函数内与函数外定义了同名变量，则函数内部就是函数内部定义的值，函数外则是函数外定义的值
MIN_VALUE = 1
MAX_VALUE = 10

def val_check():
    MIN_VALUE = 3
    print(f"函数内：{MIN_VALUE}")

val_check()
print(f"函数外：{MIN_VALUE}")
# 函数内：3
# 函数外：1

# 映射至函数嵌套。如果内部函数要修改外部函数的值，需要使用nonlocal 定义一下
def out_func():
  x = 'out'
  def inn_func():
    nonlocal x 
    x = 'inn'
    print(f"inn_func:{x}")
  inn_func()
  print(f"inn_func:{x}")
out_func()

#inn_func:inn
#inn_func:inn

五、闭包

其与上讲解的嵌套函数类似，不同的是外部函数返回的是一个函数，而不是一个具体的值。其作用就是使代码更加简洁。

def out_func(out_param):
  def inn_func(inn_param):
    return out_param ** inn_param
  return inn_func # 返回一个函数

square = out_func(2) # 计算一个数的平方
cube = out_func(3) # 计算一个数的平方

print(square)
print(cube)
#<function out_func.<locals>.inn_func at 0x114e66378>
#<function out_func.<locals>.inn_func at 0x114e66400>

print(square(3))
print(cube(3))
#8
#27
# 看完可能会疑惑这不是很鸡肋嘛。其实闭包一般与装饰器一起使用！

python学习之自定义函数
一、不带参数函数
不带参数函数格式

def 函数名():
	函数体

不带参数函数的一个案例

def _factor():    #定义函数
    i=1
    nums=10
    print("%d的因数为:"%(nums))
    while i<=nums:    #循环求因数
        if nums%i==0: 
            print('%d'%i)
        i+=1
#===========================
_factor()   #调用函数
t=type(_factor)  #检查是否是函数类型
print(t)

'''结果为:
10的因数为:
1
2
5
10
<class 'function'>  #是函数类型
'''

注意：使用自定义函数，必须先定义或先引入定义模块文件，再调用自定义函数。不能先调用，再定义，否则报“找不到自定义函数错误”。

二、带参数的函数
带参数函数格式

def 函数名(参数):
	函数体

带参数函数案例
如：

def find_factors(nums):
    i = 1
    str1 = ''
    print("%d的因数为:" % nums)
    while i < nums:
        if nums % i == 0:
            str1 = str1 + ' ' + str(i)   #用字符串记录一个整数的因数
        i += 1
    print(str1)


# =======================================
num_list = [10, 18, 20, 30]
i = 0
num_length = len(num_list)
while i < num_length:
    find_factors(num_list[i])
    i += 1

与不带参数的函数相比，更加灵活，实用，可以接受任意正整数的传递并求因数。

通常把def 函数名(参数)的参数叫形式参数，调用函数时赋予的值叫实际参数。

三、带返回值的函数
格式：

def 函数名([参数]):
	函数体
	return 返回值

函数返回值：不带return语句的函数，其实默认都返回None值，如调用_factor()（不带参数案例），

def _factor():  # 定义函数
    i = 1
    nums = 10
    print("%d的因数为:" % (nums))
    while i <= nums:  # 循环求因数
        if nums % i == 0:
            print('%d' % i)
        i += 1


# ===========================
# _factor()  # 调用函数
print(_factor())
# t = type(_factor)  # 检查是否是函数类型
# print(t)
'''结果为：
10的因数为:
1
2
5
10
None'''

return语句在函数中除了返回值外，还起中断函数执行作用。
如：

def test():
    return 1  #return 将终止函数执行并返回值1
    print("Yes") #该语句不会执行
print(test())

带返回值的函数的案例（求因数）

def find_factors(nums):
    i = 1
    str1 = ''
    while i < nums:
        if nums % i == 0:
            str1 = str1 + ' ' + str(i)   #用字符串记录一个整数的因数
        i += 1
    # print(str1)
    return str1


# =======================================
num_list = [10, 18, 20, 30]
i = 0
num_length = len(num_list)
return_str=''
while i < num_length:
    return_str=find_factors(num_list[i]) #循环调用函数，并返回因数字符串
    print("%d的因数为：%s"%(num_list[i],return_str))
    i += 1

结果为：

该案例的好处：
1、可以灵活获取处理结果，为调用代码所用
2、把附加的打印功能转移到函数体外，提高了调用者处理打印信息的灵活性。

四、自定义函数的完善

def find_factors(nums):
    '''
    find_factors是自定义函数
    nums是传递正整数的参数
    以字符串形式返回一个正整数的所有因数'''  #用一对三个单引号来包括描述文档
    i = 1
    str1 = ''
    while i < nums:
        if nums % i == 0:
            str1 = str1 + ' ' + str(i)   #用字符串记录一个整数的因数
        i += 1
    # print(str1)
    return str1

help(find_factors) #help函数用来获取函数的使用功能的信息。

可以得到以下结果：得到函数的相关信息，是用一对三个单引号的描述文档的内容。

健壮性考虑

函数的参数是传递值的入口，必须考虑所传递的值是否符合要求。
如向find_factors(nums)传递一个字符，一个符号
如find_factors(‘a’)，
会出现
TypeError: ‘<’ not supported between instances of ‘int’ and ‘str’
错误。

实际应用中出现这样的错误会非常糟糕，所以要对函数进一步完善。

我们需要在函数中进行如下完善：

if type(nums)!=int:
	print('输入值类型出错，必须是整数')
	return
if nums<=0:
	print('输入值范围出错，必须是正整数')
	return

五、把函数放到模块中
自定义函数建立后，如果需要被其他代码文件调用（以.py为扩展名的文件），或者需要通过共享，让其他程序员使用，需要把函数代码单独存放到一个可以共享的地方。
在Python语言中，通过建立独立的函数模块（Module）文件（以.py为扩展名的文件），共享给其他代码文件调用。
1、建立函数模块
1）首先新建一个空白的代码文件，存放自定义函数代码，如建立一个test.py的空函数模块文件。

2）编写并调试完成自定义函数代码，如前面的find_factors(nums)函数。
3）把只属于自定义函数的代码复制到函数模块文件上，若有多个自定义函数，按照顺序复制即可。

test.py函数模块文件，实现了对find_factors(nums)函数代码的完整保存，完成这个过程后，该函数被其他python文件中的代码进行调用成了可能。

2、调用函数模块
在python语言编辑器里，除了默认内置函数外，其他函数的调用，必须先通过import语句进行导入，才能使用。

1）import语句导入整个函数模块
格式：import 函数模块名
（1）新建一个python文件，文件中输入调用代码

（2）执行后结果为：

import语句直接导入模块后，调用模块文件里的函数格式如下：
模块名.函数名
通过模块名中间连接点号与函数名连接方式调用函数。
注意：必须要保证 调用.py 和模块文件test.py在同一个文件夹下，不然会报“找不到模块错误(ModuleNotFoundError)”。

2）import导入指定函数
格式：from 模块名 import 函数名1[,函数名2,…]

# import test
# print(test.find_factors(9))
from test import find_factors
print(find_factors(9))

该方法可以像内置函数一样使用模块中的自定义函数。

3）import导入所以函数
格式：from 模块名 import *
"*"代表指定模块里的所有函数。

4）模块名、函数名别名方式
如果导入模块，函数时发现名称过长，可以通过as定义别名的方式解决。
格式：模块名[函数名] as 别名

import test as t #给模块名定义别名

print(t.find_factors(9))

from test import find_factors as f #为自定义函数定义别名

print(f(9))

as语句还可以解决函数名称发生冲突的问题。

3、模块搜索路径
主要是解决在不同文件夹下模块调用的访问路径的问题，不然会报“找不到模块”的错误。

用sys.path方法指定需要访问的函数模块文件。

import sys

sys.path[0] = 'C:\应用\Pycharm\文件\\function'  # 模块路径
from test import find_factors

print(find_factors(10))
# 结果为：
#  1 2 5

正常的路径格式为’C:\应用\Pycharm\文件\function’格式，当时”\f“为”换页“转义字符，所以为了得到正确的路径，要在”\f“前在加一个”\“,让’\f‘原样输出。