zoukankan      html  css  js  c++  java
  • 1.函数的结构,调用,传参,形参,实参,args,kwargs,名称空间,高阶函数

    1.函数的初识

    1. 初始函数
    获取任意一个字符串的元素的个数
    s1='dsjdkjkfefenga'
    count=0
    for i in s1:
    	count+=1
    print(count)
    获取列表的元素的个数
    l1 = [1, 2, 3]
    count = 0
    for i in l1:
        count += 1
    print(count)
    面向过程编程
    1. 代码重复。
    2. 代码可可读性不高
    初始函数
    l1 = [1, 2, 3]
    def new_len():
        count = 0
        for i in l1:
            count += 1
        print(count)
    new_len()
    

    函数:函数是以功能为导向,一个函数封装一个功能。登录,注册,文件的改的操作.....
    函数减````少代码的重复性,增强了代码的可读性。

    2.函数的结构

    l1 = [1, 2, 3]
    def new_len():
    	count=0
    	for i in l1:
    		count +=1
    	print(count)
    new_len()
    '''
    def 关键字:定义一个函数,紧跟一个空格
    new_len函数名:与变量名规范一致。一定要具有可描述性。
    ():结构需要,传参使用。
    	:分割符
    tab键:四个空格。缩进。函数体
    '''
    

    3.函数的调用

    l1 = [1, 2, 3]
    def new_len():
        count = 0
        for i in l1:
            count += 1
        print(count)
    
    函数的执行写多少次,执行多少次。
    new_len() # 函数名() 函数的执行者。调用者。
    new_len()  # 函数名() 函数的执行者。
    new_len()  # 函数名() 函数的执行者。
    new_len()  # 函数名() 函数的执行者。
    new_len()  # 函数名() 函数的执行者。
    l1 = [1, 2, 3]
    def new_len():
        count = 0
        for i in l1:
            count += 1
        print(count)
    
    for i in range(10):
        print(111)
    
    for i in range(3):
        new_len()
    '''
    先打印111 10次,
    在调用函数3次
    

    4.函数的返回值

    一个函数就是封装一个功能,这个功能一般都会有一个最终结果的,比如你写一个登录函数,最终登录成功与否是不是需要返回你一个结果?还有咱们是不是都用过len这个函数,他是获取一个对象的元素的总个数,最终肯定会返回一个元素个数这样的结果:

    s='dsfge'
    print(len(s))
    

    函数的返回值用return表示:

    1. 结束函数。
    l1 = [1,2,3]
    def new_len():
    	print(111)
    	print(222)
    	if 	1==1:#先判断条件成立,才执行return,结束后面的函数,不然不会结束后面的函数。	
        	return
       	print(333)
       	print(444)
    new_len()
    		
    

    2.函数中没有return或者只写一个return,函数的执行者得到的是None

    l1 = [1, 2, 3]
    def new_len():
    	count=0
    	for i in l1:
    		count +=1
    	return
    print(new_len())
    '''
    3
    None
    '''
    

    3.函数中return后面是单个值,函数的执行者得到的是这个值(不改变值的类型)

    def func():
    	print(11)
    	return 1,'23',[1,2]
    ret=func()
    print(ret,type(ret))#(1,'23',[1,2])
    def func():
    	print(11)
    	return 1,'32',[22,33]
    a,b,c=func()
    print(a,b,c)#1,32,[22,33]
    def func():
    	print(123)
    	# return 1+1+2 4
    	return 2>1 True
    ret=func()
    print(ret)
    '''
    123
    True
    
    '''
    

    5.函数的传参

    我们上面研究了,函数的结构,函数的执行,以及函数的返回值。对函数有一个初步的了解,那么接下来就是一个非常重要的知识点,函数的参数。函数是以功能为导向的,上面我们写的函数里面的代码都是写死的,也就是说,这个函数里面的更改起来很麻烦,试想一下,我们使用探探,陌陌等软件,可不可以进行筛选,比如选择性别,年龄等,导出结果? 再拿我们之前学过的len 这个len是不是可以获取字符串的总个数?是不是可以获取列表的总个数?你更改了len函数内部的代码了?没有吧?你看下面的例子:

    s1 = 'sfdas'
    l1 = [1, 3, 7]
    print(len(s1))  # 5
    print(len(l1))  # 3
    
    函数的传参:函数的拓展性
    def new_len(a):
    	count=0
    	for i in a:
    		count+=1
    	return count
    l1=[1,2,3]
    s1='dsjkfejg'
    print(new_len(l1))#函数的调用者:参数 实参
    print(new_len(s1))#函数的调用者:参数 实参
    print(len(s1))
    

    实参角度:

    1. 位置参数
    2. 关键字参数
    3. 混合参数

    形参角度:

    1. 位置参数
    2. 默认参数
    3. 动态参数
    4. 仅限关键字参数(了解)
    5.1 实参角度:3种
    1. 位置参数
    位置参数:从左至右,按照顺序,一一对应
    def meet(sex,age,job):
    	print('左滑一下')
        print('左划一下')
        print('右划一下')
        print(f'寻找性别{sex},年龄{age}岁,{job}')
        print('聊天')
        print('约吗')
        print('约....')
    meet('女','18~25','讲师')
    
    

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

    def comp(a,b):
    	if a>b:
    		return a
    	else:
    		return b
    ret=comp(1,2000)
    print(ret)
    
    5.2 三元运算符:简单的if else.
    a1=1
    b2=2
    ret=a1 if a1>b2 else b2
    print(ret)
    
    def comp(a,b):	
    	ret=a if a>b else b
    	return ret
    	return a if a>b else b
    ret=comp(1,2000)
    print(ret)
    
    5.3 关键字参数。一一对应
    def meet(sex,age,job,hight,weight):
    	print('左划一下')
        print('右划一下')
        print(f'寻找性别{sex},年龄{age}岁,身高{hight},体重{weight},工作{job}')
        print('聊天')
        print('约吗')
        print('约....')
    meet(sex='女',job='学生',weight=120,hight=170,age='18-23')
    
    5.4 混合参数。

    关键字参数一定在位置参数后面,一一对应。

    def meet(sex,age,job,hight,weight,):
    	print('左划一下')
    	print('右划一下')
    	print(f'寻找性别{sex},年龄{age}岁,身高{hight},体重{weight},工作{job}')
    	print('聊天')
    	print('约....')
    meet('男',27,'ITC语言',weight=120,hight=175,)
    
    5.5 形参角度:4种

    1.位置参数:与实参角度位置参数一样。

    def meet(sex,age,job,hight,weight):
            print('左滑一下')
            print('左划一下')
            print('右划一下')
            print(f'寻找性别{sex},年龄{age}岁,{job}')
            print('聊天')
            print('约吗')
            print('约....')
    meet('女','18~25','讲师')
    

    2.默认参数:一定在位置参数后面,不传参数即沿用默认的参数。

    #open('文件的改',encoding='utf-8')
    def meet(age,job,sex='女')
        print('左划一下')
        print('右划一下')
        print(f'寻找性别{sex},年龄{age}岁,{job}')
        print('聊天')
        print('约吗')
        print('约....')
    # meet('18~25','幼师')
    # 更改默认参数
    #meet('18~25','幼师',sex='laddy_boy')#以关键字参数修改默认参数
    meet('18~25','幼师','laddy_boy')#以位置参数修改默认参数。
    

    6.函数的传参:*args,**kwargs

    第三种传参方式

    动态参数 :*args

    def eat(food1,food2,food3):
    	 print(f'我请你吃:{food1},{food2},{food3}')
    eat('蒸羊羔','蒸熊掌','蒸鹿尾','烧花鸭','烧企鹅')
    当给函数传入的参数数目不定时,之前的传参方式解决不了问题。
    

    *将实参角度:定义一个函数时, 所有的位置参数聚合到一个元组中。*

    def eat(*args):  # 将实参角度:定义一个函数时,* 所有的位置参数聚合到一个元组中。
        print(args)
        print(f'我请你吃:{args}')
    eat('蒸羊羔','蒸熊掌','蒸鹿尾','烧花鸭','烧企鹅')
    

    函数接收不定个数的数字实参,将最终的和返回出去。

    def sum1(*args):
    	print(args)(100, 2, 67, 3)
    	result=0
    	for i in args:
    		result +=i
    	return result
    print(sum1(100,2,67,3))
    

    **** **kwargs 函数的定义时:将实参角度所有的关键字参数聚合成了一个字典,给了kwargs.

    def func(**kwargs):#函数的定义时:**将实参角度所有的关键字参数聚合成了一个字典,给了kwargs.
    	print(kwargs)
    func(name='alex',age=84,hobby='唱跳rap篮球')
    
    6.1 *的魔性用法: (函数中)
    def func(*args,**kwargs):
        print(args)  # (1, 2, 3,'太白', 'wusir', '景女神')
        print(kwargs)
    
    l1 = [1, 2, 3]
    l2 = ['太白', 'wusir', '景女神']
    # func(l1,l2)
    # func(*l1,*l2)  # 当函数的执行时:*iterable 代表打散。
    func(*[1, 2, 3],*(11,22),*'fdsakl')  # 当函数的执行时:*iterable 代表打散。
    
    def func(*args,**kwargs):
        print(args)
        print(kwargs)
    func(**{'name':"alex"},**{'age': 73,'hobby': '吹'})
    当函数的执行时:**dict 代表打散。
    
    6.2 函数外:处理剩余元素
    a,b,*c = [1,2,3,4,5]
    a,*c,b, = [1,2,3,4,5]
    a,*c = range(5)
    a,*c,b = (1,2,3,4,5,6)
    print(a,c,b)
    

    7.形参角度的形参顺序

    顺序:位置参数,*args,默认参数,仅限关键字参数,**kwargs

    *args

    *args不能放在位置参数前面,a,b取不到值。
    def func(*args,a,b,sex='man',):
        print(a)
        print(b)
        print(sex)
        print(args)
        # print(kwargs)
    func(1,2,4,5,6)
    args如果想要接收到值之前,肯定要改变sex默认参数。
    def func(a,b,sex='man',*args):
        print(a)
        print(b)
        print(sex)
        print(args)
        # print(kwargs)
    func(1,2,4,5,6)
    
    def func(a,b,*args,sex='man'):
        print(a)
        print(b)
        print(sex)
        print(args)
        # print(kwargs)
    func(1,2,4,5,6)
    func(1,2,4,5,6,sex='women')
    
    

    **kwargs

    位置参数,*args,默认参数,**kwargs
    def func(a,b,*args,sex='man',**kwargs,):
        print(a)
        print(b)
        print(sex)
        print(args)
        print(kwargs)
    func(1,2,4,5,6,name='太白',age=18)
    

    形参角度第四种传参方式:仅限关键字参数 (了解)

    位置参数,*args,默认参数,仅限关键字参数,**kwargs
    def func(a,b,*args,sex='man',c,**kwargs,):
        print(a)
        print(b)
        print(sex)
        print(c)
        print(args)
        print(kwargs)
    func(1,2,4,5,6,67,c=666,name='太白',age=18,)
    

    8.三个名称空间

    变量名(函数名也叫变量)

    全局名称空间**: py文件运行时开辟的,存放的是执行的py文件(除去函数内部)的所有的变量与值(地址)的对应关系,函数名与函数内存地址的对应关系。整个py文件结束之后,才会消失。

    临时(局部)名称空间: 函数执行时,在内存中临时开辟的一个空间,存放的函数中的变量与值的对应关系,随着函数的结束而消失。

    内置名称空间:input,print,内置函数等。

    input=12
    
    print(input)
    
    从全局寻找input------->全局名称空间---------->内置
    
    input = '太白'
    def func():
    	# input = 666
    	print(input)
    func()
    从局部寻找input----->局部名称空间----->全局名称空间——————> 内置
    取值顺序:单向不可逆(LEGB)
    def func():
        name = 'alex'
    
    func()
    print(name)
    此时无法取到值,随着函数的结束内存空间消失
    name = '太白'
    def func():
        # name = 'alex'
        def inner():
            print(name)
        inner()
    func()
    '''
    太白
    
    '''
    

    9.内置函数:locals globals

    globals:全局作用域所有的内容

    locals:当前位置的变量与值的对应关系

    """
    此文件研究的是内置函数 globals locals
    """
    name = 'alex'
    l1 = [1, 2, 3]
    
    def func():
        age = '18'
    func()
    print(globals()) # 全局作用域所有的内容
    print(locals())  # 当前位置
    
    """
    此文件研究的是内置函数 globals locals
    """
    name = 'alex'
    l1 = [1, 2, 3]
    
    def func():
        age = '18'
        oldboy = '老男孩教育'
        print(globals()) # 全局作用域所有的内容
        print(locals())  # 当前位置的变量与值的对应关系
    
    func()
    '''
    {'__name__': '__main__', '__doc__': '
    此文件研究的是内置函数 globals locals
    ', '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000069B284C0F0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/Administrator/Desktop/python23期/教学代码/day10 函数的传参,args kwargs,内置函数,高阶函数/05 内置函数:locals globals.py', '__cached__': None, 'name': 'alex', 'l1': [1, 2, 3], 'func': <function func at 0x00000069B2909AE8>}
    {'oldboy': '老男孩教育', 'age': '18'}
    
    '''
    
    def func():
        age = '18'
        oldboy = '老男孩教育'
        def inner():
            name_class = 'python23期'
            print(globals()) # 全局作用域所有的内容
            print(locals())  # 当前位置的变量与值的对应关系
        inner()
    func()
    '''
    {'__name__': '__main__', '__doc__': '
    此文件研究的是内置函数 globals locals
    ', '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000038F66EC0F0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/Administrator/Desktop/python23期/教学代码/day10 函数的传参,args kwargs,内置函数,高阶函数/05 内置函数:locals globals.py', '__cached__': None, 'name': 'alex', 'l1': [1, 2, 3], 'func': <function func at 0x00000038F67A9AE8>}
    {'name_class': 'python23期'}
    '''
    

    10.高阶函数(嵌套函数)

    例1:
    
    def func1():
        print('in func1')
        print(3)
    
    def func2():
        print('in func2')
        print(4)
    
    func1()
    print(1)
    func2()
    print(2)
    '''
    in func1
    3
    1
    in func2'
    4
    2
    
    '''
    
    
    例2:
    def func1():
        print('in func1')
        print(3)
    
    def func2():
        print('in func2')
        func1()
        print(4)
    
    print(1)
    func2()
    print(2)
    
    '''
    1
    in func2
    in func1
    3
    4
    2
    '''
    
    
    例3:
    
    def fun2():
        print(2)
        def func3():
            print(6)
        print(4)
        func3()
        print(8)
    
    print(3)
    fun2()
    print(5)
    
    '''
    3 2 4 6 8 5
    
    '''
    

    11.作用域

    全局作用域:全局名称空间,内置名称空间。

    局部作用域:局部名称空间。

  • 相关阅读:
    Java学习开篇
    《我的姐姐》
    世上本无事,庸人自扰之
    这48小时
    补觉
    淡定
    es java api 设置index mapping 报错 mapping source must be pairs of fieldnames and properties definition.
    java mongodb groupby分组查询
    linux 常用命令
    mongodb too many users are authenticated
  • 原文地址:https://www.cnblogs.com/pythonblogs/p/11050884.html
Copyright © 2011-2022 走看看