python 函数笔记

函数：

在计算机中称之为函数，在现实生活中称之为功能。 函数是能够实现特定功能的计算机代码，它是一种特定的代码组结构。

函数的作用

1.提高代码的重复利用率，避免重复开发相同代码

2.提高程序的开发效率

3.便于程序维护

函数命名规则：

1.推荐使用英文，禁止使用中文

2.可以使用数字，但不能以数字开头

3.不可以使用特殊字符，除了下划线_

4.函数名严格区分大小写

5.函数名必须要有意义

6.不能和系统保留关键字冲突

7.不能和系统已存在的函数同名

基本格式：

def 函数名():

pass

带有参数的格式：

def 函数名(参数1，参数2...):

Pass

例子：

def mystar(hang,lie):
    j = 0
    while j < hang:
        i = 0
        while i < lie:
            print('*',end= '')
            i +=1
        print()
        j +=1

#调用函数
mystar(2,5)

 

注释：

形参：形式上的参数，声明函数时，括号()中的参数，是形参。

实参：实际上的参数，调用函数时，括号()中的参数，是实参。

实参将值传递给形参的本质过程，本质上就是简单的变量赋值。

带有默认值的参数的格式：

def 函数名(参数1 = 值1,参数2 = 值2...):

例子：

def mystar(hang=10,lie=10):
    j = 0
    while j < hang:
        i = 0
        while i < lie:
            print("*",end='')
            i +=1
        print()
        j +=1

#调用
mystar()
# 调用函数的时候传入实参（变量的重新赋值）
mystar(4,5)

 

    注释：

如果形参有默认值，调用时可以不需要传参，系统会直接使用参数的默认值。

调用时给有默认值的参数传参，实参会覆盖形参的默认值。本质上就是变量的重新赋值。

使用关键字参数格式：

传递实参的时候指定形参名称的格式就是关键字参数！关键字参数就是针对与实参的

函数名(形参1 = 实参1,形参2 = 实参2...)

例子：

def wang(name,color,size):
    print('你的名字', name)
    print('你的肤色', color)
    print('你的身高', size)

#调用函数
wang(name='胡宏毅',color='黄色',size=175)

'注释：

关键字参数就是调用函数时，在实参前面指定形参的做法，为了防止参数按照位置传递出现的错误。

收集参数

搜集参数仅仅收集没有形参接收的实参

1.非关键字收集参数，在形参前添加一个*即可

2.非关键字收集参数，收集的实参会组成一个元组

3.非关键字收集参数，接受没有任何形参接受的非关键字实参

4.非关键字收集参数，可以和普通的形参共存

关键字收集参数

#特征:关键字收集参数也之收集没有形灿接收的关键字参数!

#关键字实参:只能使用关键字收集参数来收集

 

如果在多种类参数的情况下，我们的参数怎么办

1. 普通参数，默认参数，收集参数，命名关键参数，关键字参数

2. 针对于任意一个函数，我想收到所有参数？

Def  renyi （*arg,**arg）:

Pass

默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！

要注意定义可变参数和关键字参数的语法：

*args是可变参数，args接收的是一个tuple；

**kw是关键字参数，kw接收的是一个dict。

以及调用函数时如何传入可变参数和关键字参数的语法：

可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过*args传入：func(*(1, 2, 3))；

关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过**kw传入：func(**{'a': 1, 'b': 2})。

使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。

命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。

定义命名的关键字参数不要忘了写分隔符*，否则定义的将是位置参数。

关于函数的返回值

#概念1:执行过程函数:函数执行完毕没有产生任何可以被接收的结果的函数就是执行过程函数(没有reutrn语句)

#概念2:具有返回值的函数:函数执行完毕会产整一个可以被变量接收的结果的函数!(有return语句)

#return的作用:

   #1.可以为函数设定一个结果,该结果可以使得函数运行完毕之后可以被变量接收

例子：

def mystar(hang,lie):
    #设定一个变量保存输出的内容
    strvar = ''
    j = 0
    while j < hang:
#输出一行
        i = 0
        while i < lie:
            strvar += '*'
            i +=1
        #输出换行
        strvar += '\n'
#       变量自增
        j +=1

#作为返回值
    return strvar

#调用函数
result=(mystar(6,6))

#可输出或者运算或者存储

result +=”hello”

print(result)

函数文档:函数的说明书

#help(print)

#help(id)

#自己设计函数

def mystar(num):

    '''

    功能:输出一行星星

    参数: num 整型

    返回值:字符个数 int

    '''

    print('*********************')

    return 20

help(mystar)

#另外一种方法查看文档

#help(id)

print(id.__doc__)

变量的作用域

变量的作用域就是指变量的有效范围。

变量按照作用范围分为两类，分别是 全局变量 和 局部变量。

全局变量:在函数外部声明的变量就是全局变量:

  全局变量在函数外部可以正常使用。

全局变量在函数内部也可以正常使用(需要用global声明)

局部变量:仅在函数内部可以使用的变量称之为局部变量:

局部变量在函数内部可以正常使用

局部变量在函数外部不可以访问

global关键字

global的作用就是把局部变量提升为全局变量

格式：

def 函数名():

    global 变量名

    函数功能代码...

示例1：

def funName():

    global name #如果不使用global关键字，外部是无法访问变量name的。

name = 'dragon'  

funName()  #调用

print(name)  #尝试访问内部函数

'''注释：

global只有在函数内部对变量进行全局声明，该变量才是一个完整的全局变量(在函数外部可以对该变量进行任意操作)

示例2：

var = 99

def addone():

#全局变量

global var

#将变量var +1    #如果要更改全局变量  就要使用global声明

var +=1

addone()

print(var)

 

 

内部函数

在函数内部声明的函数就是内部函数。

格式：

def 函数名():

    局部变量...

    def 内部函数名():

        Python功能代码...

1.内部函数的本质就是局部变量(函数就是一个变量)

    2.内部函数在函数外部不可以直接调用

3.内部函数在函数内部调用(当然，必须要定义内部函数之后才能调用)

#访问的问题
#1.内部函数可以在函数外部访问？
#inner()   #内部函数的本质是局部变量   局部变量无法再函数外部访问
#2.访问外部函数之后可以访问内部函数吗？
#inner（)   #内部函数的本质是局部变量   局部变量无法再函数外部访问
#3.内部函数在函数内部可以访问吗？
#outer（）可以
#4.内部函数可以在函数定义之前访问吗？
#outer()不能

 

闭包

使用特定或特殊的方式，将局部变量(内部函数)引入到全局环境中使用，这就是闭包操作。

闭包方法1：

def 函数名():

    局部变量...

    def 内部函数名():

        pass

return (局部变量，内部函数...)

闭包方法2：

def 函数名():

    局部变量

    def 内部函数名():

        pass

    #获取所有需要进行闭包操作的函数和变量

    defall():

        return(局部变量,内部函数...)

return all

例子：

#李家
'''
def lyb():
    #局部变量
    money = '$100'
    tv = '电视'
    car = '拖拉机'
    #内部函数
    def lisisi():
        print('小女子李思思')
    def dog():
        print('wangwang')
        #包装财产
        bao=[money,tv,car,lisisi]
        #返回包
        return bao
    return dog


#周浩准备解应
zhouhao = lyb() #zhouhao = dod函数
print(zhouhao)
#调用周浩
bf = zhouhao()
print(bf)

#挨个摆放财产
qian= bf[2]
print(qian)
#输出内容
lsi= bf[3]
lsi()

#闭包的缩写格式：
#return [money,tv,lisisi,dog]

#方法2 认干爹
zhouhao = []
#李家
def lyb():
    global zhouhao
    #局部变量
    money = '199'
    car = '摩托'
    def dog():
        print('wangwang')
    zhouhao = [dog,money,car]

lyb()
print (zhouhao)
gou = zhouhao[0]
gou()
'''

#闭包的负面效果 ：内存不能释放闭包使用的局部变量
def num():
    no = 2
    n02= -200
    print(id(no))
    return [no,n02]
num()
print(id(0))

 

#查看闭包所有带有的信息

print(变量.__closure__)

#nonlocal 关键字
def outer():
    #声明变量（对于outer是局部变量，对于inner而言肯定不是全局，不是局部，只能成为是inner的外部变量）
    var = 250
    def inner():
        #变量声明
        nonlocal var
        #使用变量var
        var +=10
        print(var)
    #调用函数
    inner()
#调用函数outer()
outer()

def outer():
    #声明变量（对于outer是局部变量，对于inner而言肯定不是全局，不是局部，只能成为是inner的外部变量）
    var = 250
    def inner():
        #变量声明
        nonlocal var
        #使用变量var
        var +=10
        print(var)
    #调用函数
    inner()
#调用函数outer()
outer()

#lambda 表达式
'''
变形金刚：（人形态） ---》 函数
变形金刚：（汽车形态） --》lambda表达式

'''

#声明一个函数
def he(a,b):
    result = a + b
    return result
#调用函数
jg = he(2,3)
print(jg)


#声明一个lambda表达式
#变量名 = lambda 形参，形参。。 ：函数     函数体自带return语句
he = lambda a , b : a + b
#调用函数
jg = he(2,4)
print(jg)



#带有分支的lambda表达式
def sex(word):
    if word == 'man':
        return '男'
    else:
        return '女'


result = sex('man')
print(result)

#lambda表达式
sex = lambda word :'男' if word == 'man' else '女'
result = sex('man')
print(result)