码迷,mamicode.com
首页 > 编程语言 > 详细

python基础之函数(动态参数,注释,名称空间,第一类对象及使用和函数嵌套)

时间:2020-01-20 20:41:30      阅读:112      评论:0      收藏:0      [点我收藏+]

标签:函数名   war   函数的参数   关键字   作用域   这一   别人   c函数   类对象   

函数的动态参数

  • 1.函数的动态参数

    位置参数,默认参数

    动态参数的作用 *args

    ? 1.能够接受不固定长度参数

    ? 2.位置参数过多时可以使用动态参数

  • 动态参数的用法:

    def func(*c): #形参位置上的 * 是聚会
      print(*c) #函数体中的 * 就是打散
    #func(1,2,3,4,5,6,7,8,9,0)
  • **def eat(a,b,*args): #位置参数,动态位置参数**

      print(a,b,args)    #结果:面条 包子 ('饺子', '馅饼', '馒头')
      print(a,b,*args)  #带上*是打散   面条 包子 饺子 馅饼 馒头

    eat("面条","包子","饺子","馅饼",”馒头“)

    按照位置面条和包子一一对应 a,b 剩余的全给了 args 动态位置参数

    错误的示例

    def eat(*args,a,b):  
    # 位置参数,动态位置参数#     
    print(a,b,args)
    ## eat("面条","米饭","馒头","包子","煎饼")
    就会报错,因为args会全部接受实参,没有实参给a,b
    def func (a,b,*args,c=2,**kwargs):  #位置参数,动态参数,默认参数
        print(a,b,c,args,c,kwargs)   #1 2 100 (3, 4, 5, 6, 7, 8, 565) 100 {'w': 3, 'd': 3}
    func(1,2,3,4,5,6,7,8,565,c=100,w=3,d=3)
  • def func(a,b,*args,m=8,**kwargs,)  #位置参数,动态参数,默认参数,动态关键字参数

位置参数,动态参数,默认参数,动态关键字参数

*args 程序之间约定(可以更换但是不建议更换)

**kwargs 程序员之间约定俗称(可以更换但是不建议更换)

*args 获取的是一个元组

**kwargs 获取的是一个字典

*args只接受多余的位置参数 一定要放到参数最后

**kwargs只接受多余的关键字参数 一定要放到参数最后

函数参数优先级 位置参数>动态位置参数>默认参数>动态关键字参数

lst = [1,2,3,4,5,7]
def func(*args):      
    print(*args) # 打散     输出结果 1 2 3 4 5 7
func(*lst)    # 函数调用  必须加*  在实参的位置上用*将lst(可迭代对象)按照顺序打散
dic = {"key":1,"key2":2}
def func(**kwargs): 
    print(*kwargs) #    key  key2  获取的是键 一个*只获取键
    print(kwargs) #{'key': 1, 'key2': 2}
    # print(**kwargs)  #报错
func(**dic)  #打散 

函数的注释(给别人看的)

def add(a,b):

"""

填写你作什么运算

:param a: a 是什么数据类型

param b: b 是什么数据类型

return:

"""

例子:

# def add(a,b):
#     """
#     数字的加法运算
#     :param a: int
#     :param b: int
#     :return: int
#     """
#     return a + b# print(add(1,2))
# print(add.__doc__)  查看函数注释    引号之间的内容都能print出来
  print(a.__name__)   查看函数名字    add
# print(add())
# print(add.__doc__) # 查看函数的注释
# print(a.__name__)   # 查看函数的名字

函数的名称空间

名称空间:

  1. 内置空间: 存放python自带的一些函数

  2. 全局空间:当前py文件顶格编写的代码开辟的空间

  3. 局部空间:函数开辟的空间

    #程序加载顺序:内置空间>全局空间>局部空间

    #程序取值顺序:局部空间>全局空间>内置空间

作用域

1.全局作用域:内置+全局 globals() #查看全局作用域

2.局部作用域:局部 locals () #查看当前作用域

a = 10
def func():   
    b = 5
    print(locals())  #{'b': 5}  说明b只能作用在函数体内,当作局部变量,全局不能使用  查看的是当前作用域中方法和属性 有b的属性(当前是局部作用域)
print(locals()) #结果中有“a”:10 没有b  查看的是当前作用域中方法和属性 有a的属性 说明全局作用域无法使用局部的变量
    

函数的第一类对象及使用

函数名是一个变量, 但它是一个特殊的变量, 与括号配合可以执行函数的变量
1.函数名可以当作值,赋值给一个变量

示例
def func():
?   print(1)
a = func
print(func)  #函数的内存地址
print(a) #函数的内存地址

a( ) 执行函数, 因为func赋值给了aa()func()一样,调用函数func()

2.函数名可以当作另一个函数的参数来使用

示例
def func():
    print(1)
def foo(a):   #a = func?
    print(a)  #func这个函数的内存地址
foo(func)  

3.函数名可以当作另一个函数的返回值

示例
def func():
    print(1111)
?   return 1 
def foo(a):# a= func函数的内存地址
?   return a   #return func函数的内存地址
cc = foo(func)
print(cc)    func函数的内存地址  <function func at 0x0000020BA0A5CD90>
cc()   1111  执行func函数了

4.函数名可以当作元素存储在容器中

示例

def func():
   print(1)

def foo():
   print(2)

def f():
    print(3)

lst = [func,foo,f]

for i in lst:

    i()    #调用i   这个意思是将func  foo  f 三个函数整体调用   
若只是print(i) 得到的是三个函数的内存地址

示例:

def login():                   
print("登录")
def register():  
print("注册")
def shopping():  
print("逛")
def add_shopping_car():  
print("加")
def buy_goods():   
print("买")

msg ="""1.注册2.登录3.逛4.加5.买请输入您要选择的序号:"""
func_dic ={"1":register,"2":login,"3":shopping,"4":add_shopping_car,"5":buy_goods}
while True:  
    choose = input(msg)    
    if choose in func_dic:      
        func_dic[choose]()    
    else:      
        print("滚")

函数的嵌套

  1. 只要遇见了()就是函数的调用. 如果没有()就不是函数的调用
  2. 函数的执行顺序
def func():
    print(1)    
    print("我太难了")   
    print(2) 

def foo(b): 
    print(3)  
    ss = b()  
    print(ss)  
    print(4)  

def f(a,b): 
    a(b)   

f(foo,func)   输出   3 1 我太难了 2 none 4  
def func(a,b):
    def foo(b,a):
        print(b,a)
    return foo(a,b)   #先执行函数调用

a = func(4,7)

print(a)   输出结果是4,7   NONE     a = func  赋值的是地址,输出地址
                                   a = func()  输出的是return  默认是none
def func(): 
print(1)

def foo(a,b):
    def f(a,b):   
        print(a,b)      
        func()   
    f(b,a)
foo(1,2)       输出2  1  1  
def func(a,b): 
    a = a + b  
    b = a + 10   
    def foo(a,d):  
        def f(e,f):         
            print(f,e)           
            return "我太难了"    
        return f(d,a) # return "我太难了"  
    return foo(b,a) # return "我太难了
print(func(2,3))  # print "我太难了"

global

# global只修改全局空间中的变量
# 在局部空间中可以使用全局中的变量,但是不能修改,如果要强制修改需要添加global
# 当变量在全局存在时global就是申明我要修改全局的变量
# 当变量在全局中不存在时global就是申明要在全局创建一个变量
def func():
    global a  #申明修改的全局变量,如果外层全局没有此变量就是创建
    a = 10 
    b = a + 12
    print(b)
func()   #22
print(a)  #10   外层print(a)  得到了10,说明global创建了全局变量

nonlocal

# nonlocal: 只修改局部空间中的变量,最外层的一个函数
# 只修改离nonlocal最近的一层,如果这一层没有就往上一层查找,只能在局部
# nonlocal 不能进行创建

python基础之函数(动态参数,注释,名称空间,第一类对象及使用和函数嵌套)

标签:函数名   war   函数的参数   关键字   作用域   这一   别人   c函数   类对象   

原文地址:https://www.cnblogs.com/zzsy/p/12219298.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!