python--函数的返回值、函数参数的使用、名称空间与作用域、函数嵌套、函数对象

今天学习内容有函数的返回值、函数参数的使用、名称空间与作用域、函数嵌套。

下来我们一一查看。

函数的返回值

看几个栗子：

def func(x):
    return x**2
y=func(10)
print(y)
def foo():
    return None

res=foo()
print(res)
def foo():
    return{‘a‘:1}
res=foo()
print(res[‘a‘])
def foo():
    return {‘a‘:1},1,‘a‘,[1,2]  

res=foo()
print(res)

结果：({‘a‘: 1}, 1, ‘a‘, [1, 2])
def foo():
    return 1
    print(‘======>‘)
    return 2
    return 3
    return 4

print(foo())结果：1

下面我们来总结一下返回值的效果：

‘‘‘
返回值：可以返回任意类型
没有return：默认返回None
return value: value
return val1,val2,val3 :(val1,val2,val3)   返回元祖类型

return的效果：只能返回一次值，终止函数的执行
‘‘‘

函数参数的使用

def foo(x):
    print(x)

foo(1)
foo(‘a‘)
foo({‘a‘:2})结果：1a{‘a‘: 2}
#形参与实参：
def foo(x,y):
    return x+y

print(foo(1,2))结果：3

位置参数：按照从左到右的顺序依次定义的参数

  • 按位置定义的形参,必须被传值，多一个不行，少一个也不行
  • 按位置定义的实参,与形参一一对应

关键字参数：实参在定义时，按照key=value形式定义

  • #关键字参数可以不用像位置实参一样与形参一一对应，指名道姓地传值
def foo(x,y):
    print(x)
    print(y)

foo(y=1,x=10)
结果：
10
1
def foo(x,y,z):
    print(x)
    print(y)
    print(z)
foo(1,y=2,z=10)
结果：
1
2
10
  • 注意的问题一：位置实参必须在关键字实参的前面
  • 注意的问题二：实参的形式既可以用位置实参又可以是关键字实参，但是一个形参不能重复传值

默认参数：在定义函数阶段，就已经为形参赋值,定义阶段有值，调用阶段可以不用传值

def func(x,y=10):
    print(x)
    print(y)

func(1,20)
func(1)
结果：
1
20
1
10
  • 默认参数需要注意的问题一：必须放在位置形参后面
  • 默认参数需要注意的问题二：默认参数通常要定义成不可变类型
  • 默认参数需要注意的问题三：默认参数只在定义阶段被赋值一次

形参的应用：值经常变化的需要定义成位置形参

值大多数情况下都一样，需要定义成默认参数

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

  • 按位置定义的可变长度的实参：*
  • 按关键字定义的可变长度的实参：**
def func(x,y,*args): #x=1,y=2,args=(3,4,5,6)
    print(x,y)
    print(args)

func(1,2,3,4,5,6)
结果：
1 2
(3, 4, 5, 6)
def func(x,y,*args):  #args=(3,4,5,6)
    print(x,y)
    print(args)

func(1,2,*(3,4,5,6)) #foo(1,2,3,4,5,6)
结果：
1 2
(3, 4, 5, 6)
def func(x,y,**kwargs): #x=1,y=2,kwargs={‘a‘:1,‘b‘:3,‘z‘:3}
    print(x,y)
    print(kwargs)

func(1,y=2,z=3,a=1,b=3)
结果：
1 2
{‘z‘: 3, ‘a‘: 1, ‘b‘: 3}
def func(x,y=1,z=1):
    print(x,y,z)

func(**{‘y‘:2,‘x‘:1,‘z‘:3})
结果：
1 2 3
def wrapper(*args,**kwargs): #可以接受任意形式，任意长度的参数
    print(args)
    print(kwargs)

wrapper(1,2,3,3,3,3,3,x=1,y=2,z=3)

命名关键字参数:定义在*后的形参，这类形参，必须被传值，而且要求实参必须是以关键字的形式来传值

def register(name,age,*,group,**kwargs):
    print(name)
    print(age)
    print(kwargs)
    print(group)
register(‘egon‘,18,group=‘group1‘,hobby=‘play‘)
结果：
egon
18
{‘hobby‘: ‘play‘}
group1
def register(**kwargs):
    print(kwargs)
    if ‘name‘ in kwargs:
        print(kwargs[‘name‘])
    if ‘age‘ in kwargs:
        print(kwargs[‘age‘])
register(name=‘egon‘,age=18)
register()
结果：
{‘name‘: ‘egon‘, ‘age‘: 18}
egon
18
{}
def register(*args,name=‘egon‘,age):
    print(args)
    print(name)
    print(age)
register(name=‘alex‘,age=18)
register(1,2,3,3,age=10)
结果：
()
alex
18
(1, 2, 3, 3)
egon
10

引用形参顺序：位置形参，默认参数，*args，命名关键字参数，**kwargs

名称空间与作用域

名称空间：存放名字与值的绑定关系

名称空间分为三种：

  • 内置名称空间：python解释器自带的名字，python解释器启动就会生成
  • 全局名称空间：文件级别定义的名字都会存放与全局名称空间，执行python文件时会产生
x=1def func():    pass

class Foo:    pass

import os

if 1 > 2 :    y=3
  • 局部名称空间：定义在函数内部的名字，局部名称空间只有在调用函数时才会生效，函数调用结束则失效

三者的加载顺序：内置名称空间->全局名称空间->局部名称空间

取值：局部名称空间->全局名称空间->内置名称空间

max=10
def func():
    max=20
    print(max)
func()
结果：
20
max=10def func():    # max=20    print(max)

func()

结果：10
x=0
def f1():
    x=1
    def f2():
        x=2
        def f3():
            x=3
            print(x)
        f3()
    f2()

f1()
结果：
3

作用域：作用范围

全局作用域：内置名称空间与全局名称空间的名字属于全局范围，在整个文件的任意位置都能被引用，全局有效
局部作用域：局部名称空间的名字属于局部范围，只在函数内部可以被引用，局部有效

x=1
def foo():
    def f2():
        print(x)
    f2()
def bar():
    print(x)

foo()
bar()
结果：
1
1
def f1():
    x=1
    def f2():
        x=2
        print(x)
    f2()
f1()
结果：
2

函数嵌套

函数的嵌套调用

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

def max4(a,b,c,d):
    res1=max2(a,b)
    res2=max2(res1,c)
    res3=max2(res2,d)
    return res3

print(max4(11,23,-7,31))
结果：
31

函数的嵌套定义

def f1():
    def f2():
        def f3():
            print(‘from f3‘)
        print(‘from f2‘)
        f3()
    print(‘from f1‘)
    f2()
# print(f1)
f1()
结果：
from f1
from f2
from f3

函数对象

函数是第一类对象： 指的是函数可以被当做数据传递

def func():
    print(‘from func‘)

#可被引用
# f=func

#可以当做函数的参数

def func():
    print(‘from func‘)
def foo(x):
    print(x)
    x()

foo(func)
结果：
C:\Users\Administrator\AppData\Local\Programs\Python\Python36\python.exe C:/Users/Administrator/PycharmProjects/untitled/课堂练习.py
<function func at 0x00000000005D3E18>
from func

Process finished with exit code 0

#可以当做函数的返回值

def foo():
    print(‘from foo‘)
def bar():
    return foo
f=bar()
print(f)
print(foo)
结果：
C:\Users\Administrator\AppData\Local\Programs\Python\Python36\python.exe C:/Users/Administrator/PycharmProjects/untitled/课堂练习.py
<function foo at 0x0000000001D73E18>
<function foo at 0x0000000001D73E18>

Process finished with exit code 0
x=0
def f1():
    x=1
    def f2():
        # x=2
        print(x)
    return f2
f=f1()
# print(f)
f()
结果：
1

#可以当做容器类型的元素

def select():
    print(‘select function‘)

func_dic={
    ‘select‘:select,
}

# print(func_dic[‘select‘])
func_dic[‘select‘]()
结果：
select function

def select():
    print(‘select func‘)

def delete():
    print(‘delete func‘)

def change():
    print(‘change func‘)

def add():
    print(‘add func‘)

while 1:
    cmd=input(‘>>: ‘).strip()
    if not cmd:
        continue
    if cmd == ‘select‘:
        select()
    elif cmd == ‘delete‘:
        delete()
    elif cmd == ‘change‘:
        change()
    elif cmd == ‘add‘:
        add()
    else:
        print(‘无效的命令‘)

def select(cmd_l):
    filename=cmd_l[-1]
    pattern=cmd_l[1]

with open(filename,‘r‘,encoding=‘utf-8‘) as f:
        for line in f:
            if pattern in line:
                print(line)

def delete():
    print(‘delete func‘)

def change():
    print(‘change func‘)

def add():
    print(‘add func‘)

def check():
    print(‘check func‘)

func_dic={
    ‘select‘:select,
    ‘delete‘:delete,
    ‘change‘:change,
    ‘add‘:add,
    ‘check‘:check,
}

while 1:
    inp=input(‘>>: ‘).strip()
    if not inp:continue
    cmd_l=inp.split()
    # print(cmd_l)
    cmd=cmd_l[0]
    if cmd in func_dic:
        func_dic[cmd](cmd_l)
    else:
        print(‘无效的命令‘)

时间： 2024-10-05 03:01:33

python--函数的返回值、函数参数的使用、名称空间与作用域、函数嵌套、函数对象的相关文章

函数的返回值与参数

一.函数的返回值 1.什么是返回值 返回值是一个函数的处理结果, 2.为什么要有返回值 如果我们需要在程序中拿到函数的处理结果做进一步的处理,则需要函数必须有返回值 3.函数的返回值的应用 函数的返回值用return去定义 格式为: return 值 注意: 1.return是一个函数结束的标志,函数内可以有多个return, 但只要执行一次,整个函数就会结束运行 2.return 的返回值无类型限制,即可以是任意数据类型 3.return 的返回值无个数限制,即可以用逗号分隔开多个任意类型的值

为什么类的拷贝构造参数加引用、重载赋值函数的返回值和参数加引用

class string { public: string(const char *str=NULL); string(const string& str);     //copy构造函数的参数为什么是引用呢? string& operator=(const string & str); //赋值函数为什么返回值是引用呢?参数为什么是引用呢? ~string(); }; 下面我就给大家解释一下: class String1 { public: String1(const char*

函数参数补充、名称空间与作用域、global与nonlocal

函数参数补充 # 1. 命名关键字参数(了解)# 命名关键字参数:在定义函数时,*后定义的参数,如下所示,称之为命名关键字参数# 特点:# 1.命名关键字实参必须按照key=value的形式为其传值# def func(x,y,*,a,b): # 其中,a和b称之为命名关键字参数# print(x,y)# print(a,b)## # func(1,2,b=222,a=111) # 示例# def func(x,y,*,a=11111,b):# print(x,y)# print(a,b)##

2.3 函数的返回值、参数与变量

函数可以返回一个值,也可以不返回值. 不返回值是定义为void void show(){ std::cout << "Hello World!"; } 如果返回一个整数 int show(int a,int b){ return a + b; }

Python全栈__函数的初识、函数的返回值、函数的参数

1.函数的初识 def关键字 空格 函数名(与变量名命名规则相同):英文冒号 函数体 执行函数:函数名+() 函数是以功能为导向的. def login(): pass def register(): pass 1 def my_len(): 2 l1 = [1, 2, 3, 1, 6, 9, 10] 3 count = 0 4 for i in l1: 5 count += 1 6 my_len() 2.函数的返回值 return: 1.函数中遇到 return 结束函数,下面代码不执行. d

新手,对函数,函数指针,回调函数, 函数指针作为函数的返回值和block的一些见解

很多初学者,学c语言时,看到函数都觉得难,我也是,一开始觉得函数太难了,后来慢慢就理解了 第一:函数 在c语言中最简单的函数一般有四种: 1, 无返回值, 无参数. 2, 无返回值,有参数. 3, 有返回值,无参数. 4, 有返回值,有参数 1, 无返无参  定义方式:      void 函数名(); 一般不怎么用这种形式的函数,可用来输出,打印 void functionOne() { printf("无返回值,无参数"); // 没有返回值不能写return } int main

python基础之====函数对象、函数嵌套、名称空间与作用域、装饰器

阅读目录 一 函数对象 二 函数嵌套 三 名称空间与作用域 四 闭包函数 五 装饰器 六 练习题 一 函数对象 一 函数是第一类对象,即函数可以当作数据传递 #1 可以被引用 #2 可以当作参数传递 #3 返回值可以是函数 #3 可以当作容器类型的元素 二 利用该特性,优雅的取代多分支的if def foo(): print('foo') def bar(): print('bar') dic={ 'foo':foo, 'bar':bar, } while True: choice=input(

可变长参数、函数对象、嵌套、名称空间和作用域

目录 可变长参数.函数对象.嵌套.名称空间和作用域 一.可变长参数 1.1 可变长形参之* 1.2 可变长实参之* 1.3 可变长形参之** 1.4 可变长实参之** 二.函数对象 2.1.引用 2.2.当做实参参数传给一个形参参数 2.3.可以作为容器类数据类型中的元素 2.4 可以当做函数的返回值 三.函数的嵌套 3.1 函数的嵌套定义 3.2 函数的嵌套调用 四.名称空间和作用域 4.1 名称空间 4.1.1 内置名称空间 4.1.2 全局名称空间 4.1.3 局部名称空间 4.1.4 三

python开发编程基础：函数定义，返回值，参数

一,函数的定义 1,函数mylen叫做函数名 #函数名 #必须由字母下划线数字组成,不能是关键字,不能是数字开头 #函数名还是要有一定的意义能够简单说明函数的功能2,def是关键字 (define)3,():必须写4,函数体内尽量写注释,方便查看代码5,函数的调用:函数名+括号 1 #!/usr/bin/env python 2 #_*_coding:utf-8_*_ 3 4 def mylen(): #函数名 5 ''' 6 计算字符串长度的函数 这里写的是注释,方便查看代码 7 ''' 8