day10 python学习 函数的嵌套命名空间作用域等

1、三元运算

#1.三元运算
利用已下方法就可以实现一步运算返回a b中大的值
def my_max(a,b):
    c=0
    a=int(input(‘请输入‘))
    b=int(input(‘请输入‘))
        # if a>b:
        #     c=a
        # else:
        #     c=b
    #或者这样
    c = a if a > b else b
    return c
ret=my_max(1,3)
print(ret)

2.补充上节差的知识点

形参:

#位置参数

#默认参数(关键字参数)

#动态参数

*args:接收说有按照位置传递的参数,接收到的是参数是组成的元祖

*kwargs:接收说有按关键字传递的参数,接收到的是参数组成的字典

这次讲的是动态参数

参数的排序    如果各种参数都在函数中使用,就要以以下的形式排序

def func3(a,b,c,*args,key=‘key‘,**kwargs):
#2.动态参数
def func(a,b,c,*args,key="key"):  #在参数前面加一个* 这个参数就变成了动态参数
    print(a,b,c)                   #默认参数放在动态参数后边
    print(key)               #参数
    print(args)
set=func(1,2,3,‘sd‘,11,22,33,key=‘aaa‘)以下是返回值
# 1 2 3   #前边这三个必须有,少一个都不能
# aaa   #返回的就是此次的正常结果
# (‘sd‘, 11, 22, 33)  使用的时候,所有传入的值都被组织成元祖的形式

#动态参数2  **kwargs的用法
def func3(a,b,c,*args,key=‘key‘,**kwargs):
    print(a,b,c,)
    print(key)
    print(args)
    print(kwargs)
set=func3(1,2,3,‘sdash‘,key=‘www‘,x=3,y=‘alex‘) #这里最后的kwargs要注意不要写成与
以下是返回值                                     #前边的形参的关键字参数有重复
                                                #如不能在后写成a="alex"会报错
# 1 2 3
# www
# (‘sdash‘,)
# {‘x‘: 3, ‘y‘: ‘alex‘}    #kwargs这个传入的值都会组织成字典的形式

#4魔性用法
def func4(*args):
    print(args)
li=[1,2,3,4,5]
# func4(li) #  得到以下结果
#([1, 2, 3, 4, 5],)  直接将列表传递到函数的话,他会直接弄成一个大的元祖
func4(*li)  #结果如下  在列表名前加一个*就是打散的意思,这样可以一一是放在元祖中去
#(1, 2, 3, 4, 5)       也有**dic的用法  

3.命名空间

三种命名空间之间的加载与取值顺序:

加载顺序:内置命名空间(程序运行前加载)->全局命名空间(程序运行中:从上到下加载)->局部命名空间(程序运行中:调用时才加载)

取值:

  在局部调用:局部命名空间->全局命名空间->内置命名空间

4.作用域

全局作用域

局部作用域

nonlocal的用法,和他的作用n=2
def func():
    n=4
    def func2():
        nonlocal n #想要引用上一层的并改变他得值就得用nonlocal这个,如果只是引用不用nonlocal n
        n +=1
    func2()
    print(n)     #运行程序打印的是5  说明上一层的n=1在最下层被修改成功了
func()
内层函数想要改变全局变量中的n的值的话就要用global 来引入全局变量n=2
def func():
    n=4
    def func2():
        global n#想要引用全局变量的并改变他得值就得用这个,如果只是引用不用nonlocal n
        n +=1
    func2()
    print(n)     #运行程序打印的是4  说明上一层的n=4没有被改变
func()
print(n)       #运行结果还是3  说明只是改变了全局变量n=2的值

函数的嵌套

输出的结果

输出结果是  我是qqxing

时间: 2024-10-05 23:09:06

day10 python学习 函数的嵌套命名空间作用域等的相关文章

Python:函数名称空间与作用域:

Python:函数名称空间与作用域 函数对象:(第一类对象) 定义:函数是第一类对象:函数名可以当做数据来使用 1.可以直接被引用,加()就能运行 def foo(): print("from foo") f=foo f() 2.可以当作参数传入另一个函数 def warpper(x): x() warpper(foo) 3.可以当作另外函数的返回值 def warpper2(): return foo f=warpper2() print(f is foo) 4.可以当作容器类型的一

python开发函数进阶:命名空间,作用域,函数的本质,闭包,内置方法(globales)

一,命名空间 #局部命名空间#全局命名空间#内置命名空间 #三者的顺序#加载顺序 硬盘上--内存里#内置-->全局(从上到下顺序加载进来的)-->局部(调用的时候加载) 1 #!/usr/bin/env python 2 #_*_coding:utf-8_*_ 3 4 #全局命名空间 5 a = 5 6 b = 8 7 #局部命名空间(函数) 8 def my_max(): 9 c = a if a > b else b 10 return c 11 m = my_max() 12 pr

Python学习笔记 | 变量 + 引用 + 拷贝 + 作用域

在Python中,变量是没有类型的,在使用变量的时候,不需要提前声明,只需要给这个变量赋值即可.但是,当用变量的时候,必须要给这个变量赋值:如果只写一个变量,而没有赋值,那么Python认为这个变量没有定义(not defined). 一.变量和对象 1. 可变对象和不可变对象 在Python中,对象分为两种:可变对象和不可变对象,不可变对象包括int,float,long,str,tuple等,可变对象包括list,set,dict等.需要注意的是:这里说的不可变指的是值的不可变.对于不可变类

函数的嵌套和作用域

函数的嵌套定义 ①内部函数可以使用外部函数的变量 作用域链 在内部函数使用变量时,是从小局部到大局部到全局到内置名字的过程中一级一级网上找,找到最近的一个就使用 nonlocal a 声明一个上层局部变量,往上走一级离得最近并且有a 1.对全局无效 2.对局部的最近的一层产生影响 闭包嵌套函数,内部函数调用外部函数的变量 不调用不是闭包是嵌套 def outer() a = 1 def inner(): print(a) outer() 闭包的应用 可以保护变量,保护上一级局部变量中a = 1

Python学习—函数

函数 函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段. 函数能提高应用的模块性,和代码的重复利用率. 1.定义函数 Python 定义函数使用 def 关键字,一般格式如下: def 函数名(参数列表): 函数体 简单的说明: 函数代码块以 def 关键词开头,后接函数标识符名称和圆括号 (). 任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数. 函数的第一行语句可以选择性地使用文档字符串-用于存放函数说明. 函数内容以冒号起始,并且缩进. return [表

函数的嵌套和作用域链

1: # 函数的嵌套调用 def max(a,b): return a if a>b else b def Max(x,y,z): c = max(x,y) return max(c,z) print(Max(5,2,0)) def max(a,b): return a if a>b else b def Max(x,y,z): c = max(x,y) return c if c>z else z print(Max(5,2,0)) 2: #函数的嵌套定义 #内部函数可以使用外部函数的

python学习——函数的参数

定义函数的时候,我们把参数的名字和位置确定下来,函数的接口定义就完成了.对于函数的调用者来说,只需要知道如何传递正确的参数,以及函数将返回什么样的值就够了,函数内部的复杂逻辑被封装起来,调用者无需了解. Python的函数定义非常简单,但灵活度却非常大.除了正常定义的必选参数外,还可以使用默认参数.可变参数和关键字参数,使得函数定义出来的接口,不但能处理复杂的参数,还可以简化调用者的代码. 位置参数 我们先写一个计算x2的函数: def power(x): return x * x 对于powe

python全栈闯关--10-2、函数的嵌套和作用域

1.全局作用域函数嵌套 def three_max(a, b, c): t = two_max(a, b) # 函数嵌套调用two_max return t if t > c else c def two_max(a, b): return a if a > b else b print(three_max(1, 2, 3)) 程序执行,按照从下往下的顺序,把变量.函数名加入到命名空间,如果还未加入到命名空间,就调用了函数,将会报错. 如上程序,如果把three_max的调用,交换到two_m

python学习之名称空间与作用域

1.命名关键字参数(了解)及组合使用 **命名关键字参数:在定义函数时,*后定义的参数,如下所示,称之为命名关键字参数** 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) func(1,2,