• python函数之基础


    一: 函数的定义与调用

     1.1 :函数的定义

    • def 关键字必需写
    • 函数名必需是字母,数字,下划线组合,并且不能以数字开头
    • 函数名后面要加括号然后“:”
    • 为函数写注释是一个好习惯
    # 函数的定义
    
    def 函数名():
        函数体

    1.2: 函数的调用

    • 使用函数名加括号进行函数的调用
    • 函数名就时变量名,值为内存地址,加小括号就可以调用函数
    # 函数的调用
    
    函数名()

    1.3:示例

    # 示例
    s = 'sdfsd'
    # 函数的定义 def my_len():
    def my_len(): i = 0 for k in s: i+=1 return i

    # 函数的调用 my_len() length
    = my_len() print(length)

      

    二:函数的返回值

    函数的返回值很重要

    return 关键字
    如果想得到函数返回值
    1:函数有返回的动作即函数有返回值
    2:通过变量赋值的方式获取这个返回值
    变量 = 函数调用

    return 会将函数终止

    2.1  没有返回值

    默认是 None

    1:不写return ------比较常用-比如我们只关注这个函数的功能,不关系他的返回值

    def func():
        l = ['wangys','xiaogongzhu']
        for i in l:
            print(i)
    print(func())

    2: 只写return ------- 比较常用-比如说只要满足某个条件就终止函数

    def func():
        l = ['wangys','xiaogongzhu']
        for i in l:
            if i == 'wangys':
                print(i)
                return
    print(func())

    3: return None ------不常用

    2.2   返回一个值

    1:可以返回任意数据类型

    2:只要返回就可以接受到i

    def func():
        return 1
    print(func())
    
    def func():
        return 'wangys'
    print(func())
    
    def func():
        return [1,2,3,4]
    print(func())
    
    def func():
        return {'name':'wangys'}
    print(func())

    2.3  返回多个值

    1:多个返回值用多个变量接收,有多少返回值,就用多少变量接收

    2:也可以用一个变量接收,值是一个元祖(返回值组成)

    def func():
        return 1,2,3
    r1,r2,r3=func()
    print(r1,r2,r3)
    
    
    def func():
        return 1,2,3
    r=func()
    print(r)

    2.4  序列解压

    # l 列表,通过与列表元素个数相当的变量接收
    l=[1,2,3]
    a,b,c=l
    print(a,b,c)
    
    # 可以选择性的接收
    l = [1,2,3,4,5]
    a,*_=l
    print(a)
    print(*_)
    
    1
    2 3 4 5
    
    # 

    三: 函数的参数

    参数分形参和实参之分

    如下

    def my_len(s):  # s---形式的参数---形参
        i = 0
        for k in s:
            i+=1
        return i
    print(my_len('sdfsd')) # sdfsd 实际的参数---实参

    3.1  实参

    传递参数时,分位置传参和按关键字传参。

    位置在前,关键字在后

    3.1.1 : 按照位置传参

    def  my_sum(a,b):
        res = a+b
        return res
    my_sum(1,2)

    3.1.2  按照关键字传参

    def my_sum(a,b):
        res = a+b
        return  res
    
    print(my_sum(a=1,b=2))
    print(my_sum(b=2,a=1))

    3.1.3 :可以混用

    但是位置实参必须在前,关键字实参必须在后,而且不能给参数传递多个值

    # 位置参数在关键字参数的后面
    SyntaxError: positional argument follows keyword argument
    
    def my_sum(a,b):
        res = a+b
        return res
    ret = my_sum(a=1,2)
    print(ret)
    
    
    
    # 给参数传递了多个值
    TypeError: my_sum() got multiple values for argument 'a'
    
    def my_sum(a,b):
        res = a+b
        return res
    ret = my_sum(1,a=2)
    print(ret)
    
    
    # 正确的传参 关键字参数在后 位置参数在前
    
    def my_sum(a,b):
        res = a+b
        return res
    
    ret = my_sum(1,b=2)
    print(ret)

    3.2   形参

    位置参数--*args---默认参数---**kwargs

    位置参数:必须传

    默认参数:可以不传参,如果不传,则使用默认值,如果传递了则使用传递的参数

    函数的形参和实参并没有强的绑定关系,可以随意按照规则传递

    3.2.1  位置形参

    # 定义一个函数,函数有两个位置形参
    def func(a,b):
        return a,b  # 返回传递的参数
    
    ret = func(1,2) # 按照位置传参,并获取函数的返回值
    
    # 打印含绘制
    print(ret)
    def func(a,b):
        return a,b
    ret = func(a=1,b=2) # 按照关键字传参
    print(ret)

    3.2.2  动态参数*args

    *args 可以传递多个参数   *参数名称 但习惯参数名称为args

    不能接收关键字参数

    按照位置参数传参的值

    def my_sum(*args):
        n = 0
        for i in args:
            n+=i
        return n
    print(my_sum(1,2))
    print(my_sum(1,2,5,6))
    
    
    def my_sum(*a):
        n = 0
        for i in a:
            n+=i
        return n
    print(my_sum(1,2))
    print(my_sum(1,2,5,6))

    关键字参数传递报错

    def func(*args):
        pass
    
    ret = func(1,2,3,a=b)
    print(ret)

     3.2.3 : 默认参数

    默认参数可以不传递,如果不传递就使用默认值,如果传递就使用传递的参数

    def classmate(name,sex=''):
        res =  ('%s:%s'%(name,sex))
        return res
    ret = classmate('wangys')  # sex是默认参数,没有传递参数
    print(ret)
    def classmate(name='wangys',sex=''):
        res = '%s:%s'%(name,sex)
        return res
    
    ret = classmate('wangc','') # name是默认参数,通过位置传递
    print(ret)

    3.2.4   动态参数**kwargs

    按照关键字字参数的值,组织成一个字典,可以接收任意多个关键字参数

    def func(**kwargs):
        print(kwargs)
    func(a = '1',b = '2')

    3.2.5 *args **kwargs 组合使用,可以接收任意传参

    def func(*args,**kwargs):
        print(args,kwargs)
    
    func(1,2,3,a = '4',b = '5')

    3.2.6  给*args和**kwargs传参的另一种方式

    def  func(*args):  # 将传递的参数聚合
        print(args)
    
    l = [1,2,4,5]
    func(*l)  # 将列表打散传递参数
    
    
    def func(**kwargs): # 将传递的参数聚合
        print(kwargs)
    
    d = {'a':1,'b':2}
    func(**d)  # 将字典打散

    3.3  可变数据类型做参数的陷阱

    • 错误用法 每次调用修改的都是同一个列表
    # 来自官方文档
    def f(a, l=[]):
        l.append(a)
        return l
    
    print(f(1))
    print(f(1))
    print(f(1))
    print(f(1))
    
    [1]
    [1, 1]
    [1, 1, 1]
    [1, 1, 1, 1]
    • 正确用法
    def f(a, L=None):
        if L is None:
            L = []
        L.append(a)
        return L
    print(f(1))
    print(f(1))
    print(f(1))
    print(f(1))
    
    [1]
    [1]
    [1]
    [1]

    四 函数的注释

    第一行应该是对象目的的简要概述。为简洁起见,它不应显式声明对象的名称或类型,因为这些可通过其他方式获得(除非名称恰好是描述函数操作的动词)。这一行应以大写字母开头,以句点结尾。

    如果文档字符串中有更多行,则第二行应为空白,从而在视觉上将摘要与其余描述分开。后面几行应该是一个或多个段落,描述对象的调用约定,它的副作用等。

    Python 解析器不会从 Python 中删除多行字符串文字的缩进,因此处理文档的工具必须在需要时删除缩进。 这是使用以下约定完成的。 文档字符串第一行 之后 的第一个非空行确定整个文档字符串的缩进量。(我们不能使用第一行,因为它通常与字符串的开头引号相邻,因此它的缩进在字符串文字中不明显。)然后从字符串的所有行的开头剥离与该缩进 “等效” 的空格。 缩进更少的行不应该出现,但是如果它们出现,则应该剥离它们的所有前导空格。 应在转化制表符为空格后测试空格的等效性(通常转化为8个空格)。

    下面是一个多行文档字符串的例子:

    >>>
    >>> def my_function():
    ...     """Do nothing, but document it.
    ...
    ...     No, really, it doesn't do anything.
    ...     """
    ...     pass
    ...
    >>> print(my_function.__doc__)
    Do nothing, but document it.
    
        No, really, it doesn't do anything.
    def func(a,b):
        '''
        函数的主要功能
        :param a: 参数a的含义
        :param b: 参数的含义
        :return: 返回值说明
        '''
        pass    

    五:命名空间及作用域

    5.1 命名空间

    5.1.1 内置命名空间

    python解释器启动就可以使用的名字存储的命名空间

    一旦python解释器启动,内置命名空间存储的名称就会放到内存中

    在内置命名空间,不能使用全局和局部名称

    5.1.2 全局命名空间

    是在程序从上到下被执行的过程以此加载到内存中

    可以使用内置的命名空间,但是不能使用局部的命名空间

    5.1.3 局部命名空间

    函数内部定义的名字

    当函数被调用的时候,才会产生这个名称

    可以使用全局的命名空间,也可以使用内置的命名空间

    5.2  作用域

    全局作用域----内置和全局名称空间内的名称  globals()

    局部作用域--函数内部的 locals()

    六  函数的嵌套

    def max(a,b):
        return a if a>b else b
    
    def the_max(x,y,z):
        c = max(x,y)
        return max(c,z)
    
    print(the_max(1,2,3))
    nonlocal 声明一个局部变量,该变量首先是局部变量,而且是里改函数最近的上一层函数内部局部变量
    a=1
    def outer():
        a = 2
        def inner1():
            a = 3
            def inner2():
                nonlocal a
                a +=1
            inner2()
            print('inner1局部变量a=3,现在是:', a)
        inner1()
        print("outer局部变量a=2,现在是:", a)
    outer()
    print('全局变量a=1现在是:',a)

    七 函数的本质

    函数名就是内存地址

    def func():
        print(123)
    print(func)

    函数名可以赋值

    def func():
        print(123)
    
    func2 = func
    func2()

    函数名可以作为容器类型的元素

    def func():
        print(123)
    
    func2 = func
    l = [func2,func]
    for i in l:
        i()

    函数名可以作为函数的参数

    def  func():
        print('133')
    
    def wangys(f):
        f()
    wangys(func)

    函数名可以作为函数的返回值

    def func():
        print('123')
    
    def wangys(f):
        return f
    wangys(func)()

    八:闭包函数

    • 闭包函数:内部函数含有对外部作用域而非全局作用域名字的引用,那么该内部函数就称位闭包函数,通常我们会将闭包函数名进行返回,然后在外部进行调用 
    • 可以保护变量
    • 变量常驻内存
    def  outer():
        a =1
        def inner():
            print(a+1)
        return inner
    
    func = outer()
    func()

    闭包函数的嵌套

    def outer():
        name='wangys'
        def func():
            age=18
            def inner():
                print('My name is %s,i am %d year old'%(name,age))
            return inner
        return func
    f = outer()  # f=func
    print(f.__name__)
    i = f() # i=inner
    print(i.__name__)
    i()
    from urllib.request import urlopen
    
    def index():
        url='http://www.baidu.com'
        def inner():
            return urlopen(url).read()
        return inner
    
    func = index()  # func = inner
    ret = func() # 调用inner并且将返回值赋值给ret
    print(ret)

    九:小练习题

     计算 n个数字之和

    def my_sum(*args):
        total =0
        for i in args:
            total+=i
        return total
    print(my_sum(1,2,3))

    写函数,检查获取传入列表或元组对象的所有奇数位索引对应的元素,并将其作为新列表返回给调用者。

    当去有规律去取一个列表或者元祖的元素的时候,可以使用切片

    def func(l):
        return l[1::2]
    print(func([1,2,3,4,5]))

    写函数,判断用户传入的值(字符串、列表、元组)长度是否大于5。

    def func(x):
        return len(x)>5
    print(func('wangys'))

    写函数,检查传入列表的长度,如果大于2,
    那么仅保留前两个长度的内容,并将新内容返回给调用者。

    def func(x):
        return x[:2]

    写函数,计算传入字符串中【数字】、【字母】、【空格】 以及 【其他】的个数,并返回结果。

    def func(s):
        dic = {'num':0,'alpha':0,'space':0,'other':0}
        for i in s:
            if i.isdigit():
                dic['num']+=1
            elif i.isalpha():
                dic['alpha']+=1
            elif i.isspace():
                dic['space']+=1
            else:
                dic['other']+=1
        return dic
    print(func('123sdfsd  _+'))

    写函数,检查传入字典的每一个value的长度,如果大于2,

     那么仅保留前两个长度的内容,并将新内容返回给调用者。

     dic = {"k1": "v1v1", "k2": [11,22,33,44]}
     PS:字典中的value只能是字符串或列表

    def func(dic):
        for i in dic:
            if len(dic[i])>2:
                dic[i]=dic[i][:2]
        return dic
    dic = {"k1": "v1v1", "k2": [11,22,33,44]}
    print(func(dic))

    写函数,接收两个数字参数,返回比较大的那个数字。

    #三元运算
    # 变量= 条件为True的返回值 if 条件 else 条件为false的返回值
    def func(a,b):
        c = a if a>b else b
        return c
    print(func(1,2))
    
    
    def func(a,b):
        return a if a>b else b
    print(func(1,2))
  • 相关阅读:
    25个完美的Opencart模板,让顾客无法抗拒!
    来自极客标签10款最新设计素材-系列十
    Creating Contextual Menus创建上下文菜单
    java解惑之常常忘记的事
    java 泛型实例详解(普通泛型、 通配符、 泛型接口)
    Java 泛型、通配符? 解惑
    Java中public,private,protected,和默认的区别
    windows 环境下dos 命令符下进D盘(非c盘系统盘)根目录
    I/O流之--转换流:InputStreamReader 和InputStreamWriter
    java 代码执行cmd 返回值异常 (关于JAVA Project.waitfor()返回值是1)
  • 原文地址:https://www.cnblogs.com/wc89/p/10261809.html
Copyright © 2020-2023  润新知