函数-入门

函数介绍

函数的作用

解决以下问题：

  • 代码的组织结构不清晰，可读性差
  • 遇到重复的功能只能重复编写实现代码，代码冗余
  • 功能需要扩展时，需要找出所有实现该功能的地方修改之，无法统一管理且维护难度极大

函数的定义

函数的意义就是一个功能模块，用来使用，下次再用的时候只需要拿来就可以使用，减少重复的代码编写的过程，但是用之前需要先造好

函数的分类

内置函数

这种函数是Python自带的，在所有情况下都可以随时调用

自定义函数

自己定制的特殊函数，只有在自己有需要的时候，但是内置函数无法解决问题的时候来进行自定制

定义函数

如何自定义函数

# 语法

def 函数名称(参数1,参数2,参数3，....):
    """注释"""
    执行语句
    return 返回值
# 函数名要能体现具体的功能    

# 例子

def number_sum(a, b):
    c = a + b
    return c
print(number_sum(1, 3))
# 4

函数的使用规则：先定义，再调用

未定义就调用（报错NameError）

# 测试一
print(number_sum(1, 3))
def number_sum(a, b):
    c = a + b
    return c
# NameError: name ‘number_sum‘ is not defined

# 测试二
def a():
    print("from a")
def b():
    print("from b")
    a()
b()

# from b
# from a

# 测试三
def a():
    print("from a")
    b()

def b():
    print("from b")
a()

# 此时会运行吗？

# from a
# from b

‘‘‘
总结：
1、原则是先定义后调用
2、但是要注意调用的位置，区分定义阶段和调用的阶段（何时何地）
‘‘‘

def a():
    print("from a")
    b()
def b():
    print("from b")
#以上是定义阶段

a()
#调用阶段
#在调用阶段时上述函数已经被定义所以不会报错

函数在定义阶段干了什么？

只检测语法，不执行代码

也就说，语法错误在函数定义阶段就会检测出来，而代码的逻辑错误只有在执行时才会知道

定义函数的三种形式

没有参数

# 无参：定义时无参，意味着调用时也无需传入参数

def out():
    print(‘输出‘)
out()
# 输出

有参数

# 有参：定义时有参，意味着调用时则必须传入参数

def out(who):
    print("输出%s" % (who))

out(‘justin‘)
# 输出justin

空函数：设计代码结构

def auth(user, password):
    ‘‘‘
    :param user: 用户名
    :param password: 密码
    :return: 认证结果
    ‘‘‘
    pass
....

#程序的设计立体可见

调用函数以及返回值

调用函数

函数的调用：函数名加括号

  • 先找到名字
  • 根据名字调用代码

函数返回值

  • 无return->None
  • return 1个值->返回1个值
  • return 逗号，分隔多个值->元组
# 什么时候该有返回值？
‘‘‘
调用函数，经过一系列的操作，最后要拿到一个明确的结果，则必须要有返回值
通常有参函数需要有返回值，输入参数，经过计算，得到一个最终的结果
‘‘‘
　　　　
# 什么时候不需要有返回值？
‘‘‘
调用函数，仅仅只是执行一系列的操作，最后不需要得到什么结果，则无需有返回值
通常无参函数不需要有返回值
‘‘‘

调用函数的三种形式

  • 语句形式：函数名()
  • 表达式形式：3*len(‘hello‘)
  • 当中另外一个函数的参数：range(len(‘hello‘))

函数的参数

形参与实参

形参与实参是什么？

    形参（形式参数）：指的是在定义函数时，括号内定义的参数，形参其实就变量名
    实参（实际参数）：指的是在调用函数时，括号内传入的值，实参其实就变量的值

    #x,y是形参
    def func(x,y): #x=10,y=11
        print(x)
        print(y)

    #10,11是实参
    func(10,11)

注意

  • 实参值（变量的值）与形参（变量名）的绑定关系只在函数调用时才会生效/绑定
  • 实参值（变量的值）与形参（变量名）的绑定关系在函数调用结束后就立刻解除绑定

位置参数

位置即顺序，位置参参数指的就是按照从左到右的顺序依次定义的参数

1、在定义函数时，按照位置定义的形参，称为位置形参

def foo(x,y,z):
    print(x,y,z)

#注意：
#位置形参的特性是：在调用函数时必须为其传值，而且多一个不行，少一个也不行

# foo(1,2)
#TypeError: foo() missing 1 required positional argument: ‘z‘
# foo(1,2,3,4)
#TypeError: foo() takes 3 positional arguments but 4 were given

2、在调用函数时，按照位置定义的实参，称为位置实参

#注意：位置实参会与形参一一对应
foo(1,3,2)

关键字参数

在调用函数时，按照key=value的形式定义的实参，称为关键字参数

def foo(x,y,z): #x=1,y=2,z=3
    print(x,y,z)

注意：

  1. 相当于指名道姓地为形参传值，意味着即便是不按照顺序定义，仍然能为指定的参数传值
foo(2,1,3)
foo(y=2,x=1,z=3)
foo(z=2,aaaa=1)
  1. 在调用函数时，位置实参与关键字实参可以混合使用，但必须
  • 必须遵循形参的规则
# foo(1,z=3,y=2)
# foo(1,z=3)
  • 不能为同一个形参重复传值
# foo(1,x=1,y=3,z=2)
  • 位置实参必须放到关键字实参的前面
# foo(y=3,z=2,1)

默认参数

在定义阶段,已经为某个形参赋值,那么该形参就称为默认参数

注意:

  1. 定义阶段已经有值,意味着调用阶段可以不传值
# def register(name,age,sex=‘male‘):
#     print(name,age,sex)

# register(‘justin‘,18,)
# register(‘toy‘,73,‘female‘)
# register(‘lxx‘,84,)
# register(‘xxx‘,84)
# register(‘yy‘,84)
  1. 位置形参必须在默认参数的前面
# def func(y=1,x): #错误
#     pass
  1. 默认参数的值只在定义阶段赋值一次,也就是说默认参数的值再定义阶段就固定死了
# m=10
# def foo(x,y=m):
#     print(x,y)
#
# m=‘aaa‘
# foo(1)
# foo(1,11)
  1. 记住:默认参数的值应该设置为不可变类型
def register(name,hobby,l=[]): # name=‘justin‘,hobby=‘play‘
    l.append(hobby) # l=[‘play‘]
    print(name,l) # justin [‘play‘]

register(‘justin‘,‘play‘)  # justin [‘play‘]
register(‘bingo‘,‘read‘) # bingo [‘read‘]
register(‘toy‘,‘music‘) # toy [‘music‘]

register(‘justin‘,‘play‘,[])  # justin [‘play‘]
register(‘bingo‘,‘read‘,[]) # bingo [‘read‘]
register(‘toy‘,‘music‘,[]) # toy [‘music‘]

def register(name,hobby,l=None):
    if l is None:
        l=[]
    l.append(hobby) # l=[‘play‘]
    print(name,l) # lxx [‘play‘]

register(‘lxx‘,‘play‘)  # lxx [‘play‘]
register(‘justin‘,‘read‘) # justin [‘read‘]
register(‘new‘,‘music‘) # new [‘music‘]

应用:

  1. 对于经常需要变化的值,需要将对应的形参定义成位置形参
  2. 对于大多数情况值都一样的情况,需要将对应的形参定义成默认形参

可变长参数（*args,**kwargs）

可变长指的是实参值的个数不固定

而实参有按位置和按关键字两种形式定义，针对这两种形式的可变长，形参对应有两种解决方案来完整地存放它们，分别是*args，**kwargs

1、*args（多传入的变成元组）

  • 情况一
def foo(x, y, *args):
    # *args会把多传入的参数变成一个元组的形式
    print(x, y)
    print(args)
foo(1, 2, 3, 4, 5)

# 输出

# 1 2
# (3,4,5)
  • 情况二
def foo(x, y, *args):
    print(x, y, args)

foo(‘qiaofu‘, 20)

# 输出
# qiaofu 20 () #后面这个（）就是args，只是因为没有传值多以为空
  • 情况三
# 相当于解开*的传值方式
def foo(x, y, *args):
    print(x, y)
    print(args)

foo(1, 2, *[3, 4, 5])

# 1 2
# (3,4,5)

# 或者

def foo(x, y, z):
    print(x, y, z)

foo(*[1, 2, 3])

# 1 2 3

2、**kwargs（多余的关键字参数当做字典）

  • 情况一
def foo(x, y, **kwargs):
    # **kwargs会把多传入的参数变成一个dict形式
    print(x, y)
    print(kwargs)

foo(1, y=2, a=1, b=2, c=3)

# 结果
# 1 2
# {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}
  • 情况二
def foo(x, y, **kwargs):
    print(x, y)
    print(kwargs)

foo(1, y=2, **{‘a‘: 1, ‘b‘: 2, ‘c‘: 3})  # 解开**的情况

# 结果
# 1 2
# {‘a‘: 1, ‘b‘: 2, ‘c‘: 3}
  • 情况三
def foo(x, y, *args, **kwargs):
    print(x, y, args, kwargs)

foo(1, 2, 3, 4,name=‘qiaofu‘,age = 20)

# 结果

# 1 2 (3,4) {‘name‘:‘qiaofu‘,‘age‘:20}  #如果不传入键值类型参数那么会输出空的{}
  • 情况四
def foo(x, y, z):
    print(x, y, z)

foo(**{‘z‘: 1, ‘x‘: 2, ‘y‘: 3})

# 结果
# 2 3 1

3、混合使用*args+**kwargs

def foo(x, y):
    print(x, y)

def wrapper(*args, **kwargs):
    print(‘====>‘)
    foo(*args, **kwargs)

# 相当于原封不动的传进来

命名关键字参数

*后定义的参数，必须被传值（有默认值的除外），且必须按照关键字实参的形式传递可以保证，传入的参数中一定包含某些关键字

def foo(x, y, *args, a=1, b, **kwargs):
    print(x, y)
    print(args)
    print(a)
    print(b)
    print(kwargs)

foo(1, 2, 3, 4, 5, b=3, c=4, d=5)
# 结果：
# 1
# 2
# (3, 4, 5)
# 1
# 3
# {‘c‘: 4, ‘d‘: 5}

函数练习一

题目

# 1、写函数，用户传入修改的文件名，与要修改的内容，执行函数，完成批了修改操作
#
# 2、写函数，计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数
#
# 3、写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5。
#
# 4、写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
#
# 5、写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者。
#
# 6、写函数，检查字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
#
# dic = {"k1": "v1v1", "k2": [11,22,33,44]}
#
# PS:字典中的value只能是字符串或列表

答案

# 题目一
def modify_file(filename, old, new):
    import os
    with open(filename, ‘r‘, encoding=‘utf-8‘) as read_f,             open(‘.bak.swap‘, ‘w‘, encoding=‘utf-8‘) as write_f:
        for line in read_f:
            if old in line:
                line = line.replace(old, new)
            write_f.write(line)
    os.remove(filename)
    os.rename(‘.bak.swap‘, filename)

modify_file(‘/Users/jieli/PycharmProjects/爬虫/a.txt‘, ‘alex‘, ‘SB‘)

# 题目二
def check_str(msg):
    res = {
        ‘num‘: 0,
        ‘string‘: 0,
        ‘space‘: 0,
        ‘other‘: 0,
    }
    for s in msg:
        if s.isdigit():
            res[‘num‘] += 1
        elif s.isalpha():
            res[‘string‘] += 1
        elif s.isspace():
            res[‘space‘] += 1
        else:
            res[‘other‘] += 1
    return res

res = check_str(‘hello name:aSB passowrd:alex3714‘)
print(res)

# 题目三

def check_len(obj):
    　　if len(obj) > 5:
        　　　　print(‘ture‘)

else:
print(‘false‘)
obj = input()
check_len(obj)

# 题目四
def func1(seq):
    if len(seq) > 2:
        seq = seq[0:2]
    return seq

print(func1([1, 2, 3, 4]))

# 题目五
def func2(seq):
    return seq[::2]

print(func2([1, 2, 3, 4, 5, 6, 7]))

# 题目六
def func3(dic):
    d = {}
    for k, v in dic.items():
        if len(v) > 2:
            d[k] = v[0:2]
    return d

print(func3({‘k1‘: ‘abcdef‘, ‘k2‘: [1, 2, 3, 4], ‘k3‘: (‘a‘, ‘b‘, ‘c‘)}))

函数对象

函数可以当作数据传递

  1. 可以被引用
  2. 可以当作参数传递
  3. 返回值可以是函数
  4. 可以当作容器类型的元素

优雅的取代多分支的if

def foo():
    print(‘foo‘)

def bar():
    print(‘bar‘)

dic={
    ‘foo‘:foo,  #如果值是函数名不加引号，否则需要加引号表示字符串
    ‘bar‘:bar,
}
while True:
    choice=input(‘>>: ‘).strip()
    if choice in dic:
        dic[choice]()

嵌套函数

函数的嵌套调用

def max(x,y):
    return x if x > y else y

def max4(a,b,c,d):
    res1=max(a,b)
    res2=max(res1,c)
    res3=max(res2,d)
    return res3
print(max4(1,2,3,4))

函数的嵌套定义

def f1():
    def f2():
        def f3():
            print(‘from f3‘)
        f3()
    f2()

f1()
f3() #报错，为何？名称空间与作用域

名称空间和作用域

什么是名称空间

名称空间：存放名字的地方，三种名称空间，（之前遗留的问题x=1，1存放于内存中，那名字x存放在哪里呢？名称空间正是存放名字x与1绑定关系的地方）

名称空间的加载顺序

# cmd中运行
python test.py
  1. python解释器先启动，因而首先加载的是：内置名称空间
  2. 执行test.py文件，然后以文件为基础，加载全局名称空间
  3. 在执行文件的过程中如果调用函数，则临时产生局部名称空间

名字的查找顺序

局部名称空间--->全局名称空间--->内置名称空间

需要注意的是：在全局无法查看局部的，在局部可以查看全局的，如下示例

# max=1
def f1():
    # max=2
    def f2():
        # max=3
        print(max)
    f2()
f1()
print(max)

作用域

1、作用域即范围

  • 全局范围（内置名称空间与全局名称空间属于该范围）：全局存活，全局有效
  • 局部范围（局部名称空间属于该范围）：临时存活，局部有效

2、作用域关系是在函数定义阶段就已经固定的，与函数的调用位置无关，如下

x=1
def f1():
    def f2():
        print(x)
    return f2
x=100
def f3(func):
    x=2
    func()
x=10000
f3(f1())

3、查看作用域：globals(),locals()

# LEGB 代表名字查找顺序:
#       locals -> enclosing function -> globals -> __builtins__

# locals 是函数内的名字空间，包括局部变量和形参

# enclosing 外部嵌套函数的名字空间（闭包中常见）

# globals 全局变量，函数定义所在模块的名字空间

# builtins 内置模块的名字空间

global与nonlocal关键字

global适用于函数内部修改全局变量的值

nonlocal适用于嵌套函数中内部函数修改外部变量的值

如果没有使用以上关键字，对全局变量或者外部变量进行修改，python会默认将全局变量隐藏起来

# 例1:

def outside():
    var = 5
    def inside():
        var = 3
        print(var)
    inside()
outside()

# 3

# 例2:

def outside():
    var = 5
    def inside():
        # inside函数改变了var所以python将var隐藏了起来，这里的print找不到var因而报错。
        print(var)
        var = 3
    inside()
outside()

# 例1不会显示报错，但是例2会
# UnboundLocalError: local variable ‘var‘ referenced before assignment

高阶函数

变量可以指向函数，函数的参数能接受变量，那么一个函数就可以接受另一个函数作为参数，这种函数就称为高阶函数

ef f(something):
    return something

def add(x,y,z):
    return f(x)+f(y)

res = add(3, -6,abs)
print(res)

# -3

‘‘‘
# 只需要满足以下任意一个条件都可以称这个函数为高阶函数
# 1.接受一个或多个函数作为输出
# 2.return返回另一个函数
‘‘‘

递归

递归调用的定义

递归调用是函数嵌套调用的一种特殊形式，函数在调用时，直接或间接调用了自身，就是递归调用

直接调用本身

def f1():
    print(‘from f1‘)
    f1()
f1()

间接调用本身

def f1():
    print(‘from f1‘)
    f2()

def f2():
    print(‘from f2‘)
    f1()
f1()
  1. 调用函数会产生局部的名称空间，占用内存，因为上述这种调用会无需调用本身，python解释器的内存管理机制为了防止其无限制占用内存，对函数的递归调用做了最大的层级限制
  2. 可以修改递归最大深度
import sys
sys.getrecursionlimit()
sys.setrecursionlimit(2000)

def f1(n):
    print(‘from f1‘,n)
    f1(n+1)
f1(1)

‘‘‘
虽然可以设置，但是因为不是尾递归，仍然要保存栈，内存大小一定，不可能
无限递归，而且无限制地递归调用本身是毫无意义的，递归应该分为两个明确
的阶段，回溯与递推
‘‘‘

递推、回溯

1、递归调用应该包含两个明确的阶段：回溯，递推

  1. 回溯：

从外向里一层一层递归调用下去，回溯阶段必须要有一个明确地结束条件，每进入下一次递归时，问题的规模都应该有所减少（否则，单纯地重复调用自身是毫无意义的）

  1. 递推：

从里向外一层一层结束递归

2、示例

# salary(5)=salary(4)+300
# salary(4)=salary(3)+300
# salary(3)=salary(2)+300
# salary(2)=salary(1)+300
# salary(1)=100
#
# salary(n)=salary(n-1)+300     n>1
# salary(1) =100                n=1

def salary(n):
    if n == 1:
        return 100
    return salary(n-1)+300

print(salary(5))

递归效率低(无尾递归优化)

python中的递归：

python中的递归效率低，需要在进入下一次递归时保留当前的状态，

在其他语言中可以有解决方法：尾递归优化，即在函数的最后一步（而非最后一行)调用自己，但是python又没有尾递归，且对递归层级做了限制

总结递归的使用

  1. 必须有一个明确的结束条件
  2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
  3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

二分法(递归应用)

想从一个按照从小到大排列的数字列表中找到指定的数字，遍历的效率太低，用二分法（算法的一种，算法是解决问题的方法）可以极大低缩小问题规模

类似in的效果

l=[1,2,10,30,33,99,101,200,301,311,402,403,500,900,1000] #从小到大排列的数字列表

def search(n,l):
    print(l)
    if len(l) == 0:
        print(‘not exists‘)
        return
    mid_index=len(l) // 2
    if n > l[mid_index]:
        #in the right
        l=l[mid_index+1:]
        search(n,l)
    elif n < l[mid_index]:
        #in the left
        l=l[:mid_index]
        search(n,l)
    else:
        print(‘find it‘)

search(3,l)

类似l.index(30)的效果

l=[1,2,10,30,33,99,101,200,301,402]

def search(num,l,start=0,stop=len(l)-1):
    if start <= stop:
        mid=start+(stop-start)//2
        print(‘start:[%s] stop:[%s] mid:[%s] mid_val:[%s]‘ %(start,stop,mid,l[mid]))
        if num > l[mid]:
            start=mid+1
        elif num < l[mid]:
            stop=mid-1
        else:
            print(‘find it‘,mid)
            return
        search(num,l,start,stop)
    else: #如果stop > start则意味着列表实际上已经全部切完，即切为空
        print(‘not exists‘)
        return

search(301,l)

原文地址：https://www.cnblogs.com/chao-sir/p/12641075.html

时间： 2024-10-04 06:56:52

函数-入门的相关文章

消息钩子函数入门

Windows系统是建立在事件驱动的机制上的,说穿了就是整个系统都是通过消息的传递来实现的.而钩子是Windows系统中非常重要的系统接口,用它 可以截获并处理送给其他应用程序的消息,来完成普通应用程序难以实现的功能.钩子可以监视系统或进程中的各种事件消息,截获发往目标窗口的消息并进行处 理.这样,我们就可以在系统中安装自定义的钩子,监视系统中特定事件的发生,完成特定的功能,比如截获键盘.鼠标的输入,屏幕取词,日志监视等等.可见, 利用钩子可以实现许多特殊而有用的功能.因此,对于高级编程人员来说

函数入门实例、九宫格实例、判断某日是当年的第几天实例

实现环境:Python 3: 1.函数入门实例 #/usr/bin/env python # -*- coding:utf-8 -*- # @time :2018/1/26 21:37 # @Author :FengXiaoqing # @file :Hanshu.py def add(args): total = 0 for i in args: total += i return total def main(): number = list() s = input("Please inpu

九宫格、函数入门、判断某天为某年的第几天

九宫格 #!/usr/bin/env python#!--coding:utf-8 --#!shenjie :2018/1/28 22:58#[email protected] :shenjie#[email protected]: 2.py#!/usr/bin/env python#-- coding:utf-8 -- class NinePaper(object):def init(self):self.numbers = list()for i in range(1, 10):self.n

SG函数入门

SG函数入门 必胜点与必败点 概念 P点:必败点,换句话说,就是在双方都选择最优策略的情况下,谁处于此状态谁必败. N点:必胜点,换句话说,就是在双方都选择最优策略的情况下,谁处于此状态谁必胜. 性质 1.所有的终结点都是必败点P. 2.从任意的必胜点N进行操作,至少有一种方式到达一个必败点. 3.从任意的一个必败点P进行操作,只可能到达必胜点N. 我们研究必胜点与必败点的目的是以此为题来简化博弈的情况,有助于我们分析策略.通常我们分析必胜点和必败点都是以终结点为起始点进行逆序分析. 我们以一道

scala学习笔记-函数入门（3）

函数的定义与调用 在Scala中定义函数时,需要定义函数的函数名.参数.函数体. 我们的第一个函数如下所示: def sayHello(name: String, age: Int) = { if (age > 18) { printf("hi %s, you are a big boy\n", name); age } else { printf("hi %s, you are a little boy\n", name); age } sayHello(&

Swift 函数入门

1. swift 中函数是第上类型,所以函数也可以作为参数和返回结果 2. 定义形式     关键字    名字 (参数列表)-> 返回值类型.下面是一个返回元组的例子. func addNumber(a:Int,b:Int) -> (addResult : Int, timesResult : Int) { return(a+b, a*b) } let result = addNumber(1, 2) println(result.addResult) 传入两个参数 a,b 并把他们相加,相

函数入门

[函数的声明及调用]                          1.>>>函数声明的格式:                 function 函数名(参数1,参数2,--){                     // 函数体                     return 结果;                 }                                  >>>函数调用的格式:                 直接调用:函数名

关于获取、设置css样式封装的函数入门版

1 <html> 2 <head> 3 <meta charset="UTF-8"> 4 <title>CSS样式的获取和设置:简单版</title> 5 <style type="text/css"> 6 #div { 7 width: 100px; 8 height: 100px; 9 background: pink; 10 } 11 </style> 12 <scrip

JS函数入门

一. 函数的声明及调用 * 1函数的格式:function 函数名(参数1,参数2......){ * //函数体 * return 结果: * * } * 函数调用的格式: * 直接调用:函数名(参数1的值,参数2的值......): * 事件调用:事件名="函数名()"; * 2,函数声明的几点强调: * ①函数名的声明,必须符合小驼峰法则(首字母小写,之后每个单词首字母大写): * ②参数列表,可以有参数也可以没有参数,分别称为有参函数,无参函数: * ③声明函数时的参数列表,称

python进阶第1篇 函数入门

知识内容: 1.函数的作用 2.函数的定义与调用 3.函数的返回值 4.函数的参数 一.函数的作用 1.复用代码 将可能重复执行的代码封装成函数,并在需要执行的地方调用函数,不仅可以实现代码的复用,还可以保持代码的一致性,便于日后的维护 2.提高可读性 使用函数可以提高代码的可读性,便于后期的代码维护,同时也有利于软件测试的进行 二.函数的定义与调用 1. 函数的定义 (1)函数是指将一组语句的集合通过一个名字(函数名)封装起来,要想执行这个函数,只需调用其函数名即可 (2)在python中定义