python 理论-函数(三)（python函数的基本用法）

-- coding: utf-8 --
@Time : 2022/8/17 15:36
@Author : siyu.yang
@desc : python 第三章
                                                         函数基础
函数概念：
   函数是组织好的，可重复使用的，用来实现单一，或相关联功能更的代码段。函数能提高应用
的模块性和diamond的重复利用率，可以被用户调用。
定义函数语法：
def function(params):  #params 参数列表
    block  # 语句块
    return expression/value
(1) 在 python 中采用 def 关键字进行函数的定义，不能指定返回值的类型
(2) 函数参数 params 可以是零个、一个或者多个，函数参数也不用指定参数类型，因为
在 python 中变量都是弱类型的，python会自动根据值来维护其类型。
(3) return 语句是可选的，它可以在函数内任何地方出现，表示函数调用执行到此结束；如果没有
return 语句，会自动返回NONE，如果有 return 语句，但是 return 后面没有接表达式或者值
的话也返回 NONE
调用函数语法：
函数名(参数表)：
函数举例；
def printHello()
    print('hello')
def printNum():
    for i range(0,100):
        print(i)
        return
printHello()
printNum()
   
                            函数参数分为形参和实参
形参全称形式参数，在用def关键字定义函数时函数名后面括号里的变量称为形式参数
实参全称实际参数，在调用函数时提供的值或者变量称为实际参数
举例：
def add(a,b):   # a和b为形参，add函数实现加法功能
    return a+b
c = add(2,3)  # 2和3为实参
print(c)
备注：
    python中在定义方法之后可以机上一段字符串，对函数功能进行说明
函数：函数是组织好的，可重复使用的，永安里实现单一，或相关联共功能的代码段
def 函数名(参数列表)：
    语句块
1.有参函数
def print_info():
    print('我是一个无参函数')
    print('我可以被重复调用')

2.无参函数
def print_name(name):  # name 形参
    print('我的名字叫{}'.format(name))

# 3.有返回值
def add_1(a, b):
    a + b  # 没有给return 则返回NONE

def add_2(a, b):
    return a + b  # return 返回值之后则后面的语句不执行
    print('return 后面的语句')

def add_2(a, b):
    '''
    :param a:
    :param b:
    :return: a+b
    '''
    return a + b  # return 返回值之后则后面的语句不执行
    print('return 后面的语句')

调用函数，函数名（参数列表）
print_info()
print_name('张三')  # 张三是实参
print(add_1(2,3))
print(add_2(2,3))


                             参数传递
在 python 中，类型属于对象，变量时没有类型的：
         str = "newdream"
         str = 50
在以上代码中，newdream 是 string 类型的，50 是整型，而变量 str
 是没有类型的，它仅仅是一个对象的引用（指针），可以指向各种类型对象

               可更改(mutable)与不可更改（immutable）对象
在python中，strings,tuples 和 numbers 是不可更改的对象，而list,dict，set等
是可以修改的对象。
不可变类型 ： 变量赋值 a=5 后再赋值 a=10,这里实际是新生成一个 int值对象10，再让a指向
它，而5被丢弃，不是改变a的值，相当于新生成了a
可变类型：变量赋值 la = [1,2,3,5] 后再赋值 la[2] = 5 则是将list la
的第三个元素值更改，本身la没有懂，只是其内部的一部分值被修改了
python 函数的参数传毒：
不可变类型：类似c++的值传递，如 整型、字符串、元组。如fun(a),传递的只是a
的值，没有影响a对象本身。比如再fun(a) 内部修改a的值，只是修改另外一个赋值的
对象，不会影响a的本身
可变类型：类似c++的引用传递，如 列表，字典，集合。如fun(la),则是将la地址传过去
修改后fun外部的la也会受影响。
举例：
不可变类型：整型，字符串，元素。如fun（num） ，传递的只是num的值，没有
影响num对象本身。如果在fun(num) 内部修改num的值，只是修改另一个复制的
 对象，不会影响 num本身。
可变类型：列表，字典，集合。如 fun(lista),则是将lista真正的传过去，修改
 后 fun 外部的lista也会受影响
1.参数不可变类型：传递的是参数的值
def add(a, b):
    return a + b

print(add(2, 3))

2.参数可变数据类型：传递的是参数的内存地址（引用传递）
def add_info(name_info):
    name_info.append('王二')
    print('函数内部：',name_info)

names =['张三','李四','王五']
add_info(names)
print('函数外部：',names)

                             python 函数参数类型
  必备参数、关键字参数、缺省参数、任意个数参数
必备参数须以正确的顺序传入函数，也叫做位置参数，即参数是通过位置进行匹配的，从
左到右，依次进行匹配，这个对参数的位置和个数都有严格的而要求。

参数类型： 必备参数、关键字参数、缺省参数、任意个数参数
1、必备参数： 参数的顺序和个数都不能改变
举例：
def print_info(name,age,home):  # 必备参数
    print('我叫{}，今年{},家乡是{}'.format(name,age,home))

print_info('张三',25,'长沙')

2.关键字参数：参数类别的顺序可以改变
如果前面的某个参数使用了关键字传值，那么它后面的所有参数都必须使用
关键字参数
举例：
def print_info(name, age, home):  # 必备参数
    print('我叫{}，今年{},家乡是{}'.format(name, age, home))

print_info('张三', home='长沙', age=25)  # 关键字参数

3.缺省参数：缺省参数的值没有传入就是用默认值，如果传入就使用传入的
如果前面的某个参数给了默认值，那么它后面的所有参数都要给默认值
举例：
def print_info(name, age, home='上海'):  # 必备参数
    print('我叫{}，今年{},家乡是{}'.format(name, age, home))

print_info('张三', age=25)  # 关键字参数

 4.任意个数参数（收集参数，不定长参数）: 表示能够接收0到任意多个参数
 '*'表示讲没有匹配的值都放到同一个元组中
‘**’ 表示讲没有匹配的值都放到dictionary中
举例：
def print_info(name, *info_tuple):  # *后面的参数是元组
    print(name)
    print(info_tuple, type(info_tuple))

print_info('张三', 25, '上海')

def print_info(name, **info_tuple):  # ** 后面的参数只能是 key = value 的格式
    print(name)
    print(info_tuple, type(info_tuple))
print_info('张三', age=25, home='上海')

def get_number():
    return 3, 4, 5  # 函数可以有多个返回类型

print(get_number(), type(get_number()))

                                      变量作用域
   在 python 程序中创建、改变、查找变量名时，都是在一个保存变量名的空间中
进行，我们称之为命名命名空间，也被称之为作用域。python 的作用域时静态的，在
源代码中变量名被赋值的位置决定了改变量的能被访问的泛微。即python变量的作用域
由变量所在源代码的位置决定。
举例：
name = '张三'  # 全局变量，全局作用域
def info():
    # global name # 强制使用全局变量
    name = '李四'
    print(name)  # 局部变量，局部作用域

info()
print(name)

作用域是相对的，都只在局部生效，都是局部优先
a = 10  # 全局作用域

                                             作用域类型
局部作用域在函数内部定义，拥有一个局部作用域，局部变量只能在其被声明的函数
内部访问。
嵌套作用域在函数内部定义，它和局部作用域是相对的，它相对于更上层的函数而言也是属于
局部作用域。主要是为了实现 python 的闭包，而增加的实现。
全局作用域在函数外部定义，拥有全局作用域，全局变量可以在整个程序范围内访问。函数内部可以
通过 global 强制定义全局变量，当函数调用时，全局变量生效。全局作用域的作用范围仅限
单个模块文件内。
内置作用域时系统内固定模块里定义的变量。
常用的作用域时局部作用域、全局作用域。
作用域：全局作用域，局部作用域，嵌套作用域，内置作用域
变量名解析LEGB法则
搜索变量名的优先级：局部作用域 > 嵌套作用域 > 全局作用域 > 内置作用域
LEGB法则：当在函数中使用未去欸的功能的变量名时，Python会按照优先级依次搜索
4个作用域，一次来确定改变量名的意义。首先搜索局部作用域（L）
举例：
 LEGB 法则：局部作用域 > 嵌套作用域 > 全局作用域 > 内置作用域
print(__file__)  #内置作用域 B
__file__ = 10  # 全局作用域 G
def pri():
    __file__ = 20  # 嵌套作用域 E
    def pri2():
        __file__ = 30  # 局部作用域 L
        print(__file__ )
    pri2()

pri()

                       函数的嵌套分为两种情况
函数的嵌套调用：即在一个函数中调用一个函数中调用其它函数的俄顷，瑞如下：
举例1：
def print1():
    a = 20  # 局部作用域

    def print2():  # 函数嵌套函数，此时函数只能在函数内部才能调用
        a = 30  # 嵌套作用域
        print(a)
    print2()
    print(a)

print(a)
print1()

嵌套函数2
1.在函数中定义一个新的函数（只能在函数内部调用该新的函数）
def print1():
    a = 20
    def print2():
        a = 30
        print(a)
    print2()
print1()
2.在一个函数中调用另外一个函数
def pri1():
    print('我是pri1函数')

def pri2():
    pri1()


                                     函数的递归
  上一个知识点中，我们讲解了函数的嵌套，在函数嵌套调用其它函数时，有一种特殊情况，
就是直接火间接地调用了函数本身，这样的一种情况称为函数的递归调用，
举例如下：
def func():
    print('kkk')  #直接调用自己
    func()
func()

def foo():  # 简介调用自己
    print('from foo')
    bar()
def bar():
    print('from bar')
    foo()
foo()
  python 在递归中没有想别的而语言对递归进行优化，所以他的每一次调用
都会基于上一次的调用进行，并且设置了最大的递归数量防止递归外溢。

def num(n):
    if n == 1:
        return 1
    return num(n-1)+2
    print(num(5))
递推：如上例，递归每一次都是基于上一次进行下一次的指向，叫递推
回溯：则是在遇到终止条件，则从最后往

 递归：函数自己调用自己
def print_hello():
    print('我是方法hello')
    print_hello()

print_hello()  # 死循环
在python中死循环,大概循环1000次左右会自动停止
递归一般在算法中使用比较多

                                          匿名函数
用lambda关键字能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。
lambda 函数能接收任何数量的参数但只能返回一个表达式的值，同时不能包含命令火多个
表达式。
匿名函数不能直接调用print，因为lambda 需要一个表达式。
lambda 函数拥有自己的名字口昂见，且不能访问自有参数列表之外或全局名字空间里的参数。
    虽然 lambda 函数看起来只能写一行，却不等同于C或C++ 的内联函数，后者的目的是
调用小函数时不占用栈内存而增加运行效率
语法：
lambda 函数的语法只包含一个语句，如下：
lambda [arg1，[,arg2,...argn]]: expression
举例1：
sum = lambda arg1,arg2:arg1+arg2
print("Value of total:",sum(10,20))
举例2：
sum = lambda  a,b : a+b
print(sum(2,3))


                                                  内置函数
    python 内置函数就是python标准库里（语言自身携带的）函数（公共函数），一般各种编程语言
都会预先定义常用内置函数。因为内置函数使用频率比较频繁，所以通过内置函数的形式提供出来。
    python 内置函数大致包含如下类型：
    数学运算、类型转换、序列操作、对象操作、反射操作
    变量操作、交互操作、文件操作、编译执行、装饰器
比如：
类型转换：int(),float(),str()
序列操作：sorted(),reversed(),next()
交互操作：print(),input() 等

内置变量：系统自带的变量，都是以__开头
print(vars())   # 查看内置变量
print(__file__)  # 查看文件路径
print(__name__)  #