• 初始函数


    初始函数

    一、定义函数

    s="太白金鑫老师"
    def my_len():     #def定义函数关键字    my_len()函数名
        i=0
        for k in s:
            i+=1
        print(i)
    my_len()          #调用函数

    函数特点:

    1、定义了之后,可以在任何需要他的地方调用 

    2、没有返回长度,只是单纯的打印

    len()

    1、不能变,只能计算s字符串的长度

    2、只是输出了结果

    自定义函数:

    s="太白金鑫老师"
    def my_len():    #自定义函数
        i=0
        for k in s:
            i+=1
        return i     #返回值
    
    length=my_len()
    print(length)

    二、返回值的三个情况:

    没有返回值 —— 返回None
    不写return
    只写return:结束一个函数的继续
    return None —— 不常用
    返回1个值
    可以返回任何数据类型
    只要返回就可以接收到
    如果在一个程序中有多个return,那么只执行第一个
    返回多个值
    用多个变量接收:有多少返回值就用多少变量接收
    用一个变量接收: 得到的是一个元组
    def func():
        l = ['金老板','二哥']
        for i in l:
            print(i)
            if i=='金老板':
                return None
        print('='*10)
    ret = func()
    print(ret)

    三、参数

    def my_len(s):  #自定义函数只需要0个参数,接收参数,形式参数,形参
        i = 0
        for k in s:
            i += 1
        return i  #返回值
    
    ret = my_len('金老板小护士')  #传递参数:传参,实际参数,实参
    ret = my_len([1,2,3,4,5])  #传递参数:传参
    print(ret)

    参数三种情况

    没有参数
    定义函数和调用函数时括号里都不写内容
    有一个参数
    传什么就是什么
    有多个参数
    位置参数
    def my_sum(a,b):
        print(a,b)
        res = a+b  #result
        return res
    
    ret = my_sum(1,2)
    print(ret)
    站在实参的角度上:
    按照位置传参
    按照关键字传参
    混着用可以:但是 必须先按照位置传参,再按照关键字传参数
    不能给同一个变量传多个值

    站在形参的角度上:
    位置参数:必须传,且有几个参数就传几个值
    默认参数: 可以不传,如果不传就是用默认的参数,如果传了就用传的
    #默认参数
    def classmate(name,sex=''):
        print('%s : %s'%(name,sex))
    
    classmate('二哥')
    classmate('小孟')
    classmate('大猛')
    classmate('朗哥','')
    调用函数的时候
    按照位置传 : 直接写参数的值
    按照关键字: 关键字 = 值

    定义函数的时候
    位置参数 : 直接定义参数
    默认参数,关键字参数 :参数名 = '默认的值'
    动态参数 : 可以接受任意多个参数
    参数名之前加*,习惯参数名args,
    参数名之前加**,习惯参数名kwargs
    顺序:位置参数,*args,默认参数,**kwargs
    #关键字传参
    def classmate(name,sex):
        print('%s : %s'%(name,sex))
    
    classmate('二哥','')
    classmate(sex='',name = '二哥')

    注意:使用关键字传参,位置随意放

    #默认值传参
    def classmate(name,sex=''):     #默认性别为男
        print('%s : %s'%(name,sex))
    
    classmate('二哥')       #使用默认值
    classmate('朗哥',sex= '')     #使用实参女

    注意:没有特意强调就用默认值,提供实参就用传递的值

    动态参数有两种:可以接受任意个参数
    *args : 接收的是按照位置传参的值,组织成一个元组
    **kwargs: 接受的是按照关键字传参的值,组织成一个字典
    args必须在kwargs之前
    #添加无数多个值都行
    def sum(*args):
        n = 0
        for i in args:
            n+=i
        return n
    
    print(sum(1,2))        #3
    print(sum(1,2,3))      #6
    print(sum(1,2,3,4))    #10

    注意:*args : 接收的是按照位置传参的值,组织成一个元组

    def func(**kwargs):
        print(kwargs)
    
    func(a = 1,b = 2,c =3)   #{'a': 1, 'c': 3, 'b': 2}
    func(a = 1,b = 2)        #{'a': 1, 'b': 2}
    func(a = 1)             #{'a': 1}

    注意:**kwargs: 接受的是按照关键字传参的值,组织成一个字典

    def func(*args,default = 1,**kwargs):
        print(args,kwargs)
    
    func(1,2,3,4,5,default=2,a = 'aaaa',b = 'bbbb',)   #*args 位置传参的值,组织成一个元组;**kwargs:关键字传参的值,组织成一个字典
    #调用结果:(1, 2, 3, 4, 5) {'a': 'aaaa', 'b': 'bbbb'}

    注意:args必须在kwargs之前

    动态参数的另一种传参方式:

    def func(*args):#站在形参的角度上,给变量加上*,就是组合所有传来的值。
        print(args)
    
    func(1,2,3,4,5)
    l = [1,2,3,4,5]
    func(*l)  #站在实参的角度上,给一个序列加上*,就是将这个序列按照顺序打散

    四、函数的注释:

    def func():
    '''
    这个函数实现了什么功能
    参数1:
    参数2:
    :return: 是字符串或者列表的长度
    '''
    pass

     五、三元运算

     变量=条件返回True的结果   if条件   else  条件返回False的结果
    #返回最大值
    def func(a,b):
        c=a if a>b else b
        return c
    print(func(1,5))
    
    

    注意点:

    1)、必须要有结果

    2)、必须要有if 和else

    3)、只能是简单的情况

    六、命名空间

    1、内置命名空间-------python解释器

            #就是python解释器一启动,就可以使用的名字存储在内置命名空间中。

            #内置的名字启动解释器的时候被加载进内存里

    2、全局命名空间-------我们写的代码但不是函数中的代码

           #是在程序从上至下被执行的过程中依次加载在内存的

          #放置了我们设置的所有变量名和函数

    3、局部命名空间-------函数

          #就是函数内部定义的名字

         #当调用这个函数的时候,才会产生这个名称空间,随着函数执行的结束,这个命名空间有有消失啦。

    注意:

    在局部,可以使用全局,内置命名空间中的名字;

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

    在内置,不能使用全局和局部的名字的

    def max(l):
        print('in max func')
    print(max([1,2,3]))          #in max func
                                  #None

    注意:

    #在正常情况下,直接使用内置的名字
    #当我们在全局定义了和内置名字空间中同名的名字时,会使用全局的名字
    #当我自己有的时候 我就不找我的上级要了
    #如果自己没有 就找上一级要 上一级没有再找上一级 如果内置的名字空间都没有 就报错
    # 多个函数应该拥有多个独立的局部名字空间,不互相共享
    func  --> 函数的内存地址
    #函数名() 函数的调用
    #函数的内存地址() 函数的调用

    七、作用域

     作用域两种
    全局作用域 —— 作用在全局 —— 内置和全局名字空间中的名字都属于全局作用域 ——globals()
    局部作用域 —— 作用在局部 —— 函数(局部名字空间中的名字属于局部作用域) ——locals()
    a = 1
    def func():
        global a
        a = 2
    func()
    print(a)     #2
    
    

    注意点:

    1)、对于不可变数据类型 在局部可以查看全局作用域中的变量,但是不能直接修改

    2)、如果想要修改,需要在程序的一开始添加global声明
    3)、如果在一个局部(函数)内声明了一个global变量,那么这个变量在局部的所有操作将对全局的变量有效

    globals: 永远打印全局的名字

    locals: 输出什么 根据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))
    a = 1
    def outer():
        a = 1
        def inner():
            a = 2
            def inner2():
                nonlocal a  #声明了一个上面第一层局部变量
                a += 1   #不可变数据类型的修改
            inner2()
            print('##a## : ', a)
        inner()
        print('**a** : ',a)
    
    outer()
    print('全局 :',a)
    nonlocal
    1)、只能用于局部变量,找上层中离当前函数最近一层的局部变量
    2)、声明了nonlocal的内部函数的变量修改会影响到 离当前函数最近一层的局部变量
    3)、对全局无效
    4)、对局部 也只是对 最近的 一层 有影响

    函数名的用法:

     1)、函数名就是内存地址

     2)、函数名可以赋值

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

     4)、函数名可以作为函数的返回值

     5)、函数名可以作为函数的参数

    九、闭包        

    闭包:嵌套函数,内部函数调用外部函数的变量

    def outer():
        a = 1
        def inner():
            print(a)
        return inner
    inn = outer()
    inn()      #1
  • 相关阅读:
    test
    VS dll 引用依赖
    Git配置
    编码--文字输入的前因后果
    base64相关
    异或
    UNION / UNION ALL 区别
    数据库使用规范
    chrome插件开发学习(一)
    缓存穿透 缓存雪崩 缓存并发
  • 原文地址:https://www.cnblogs.com/gaoya666/p/8118098.html
Copyright © 2020-2023  润新知