当前位置：移动技术网 > IT编程>脚本编程>Python > Python函数中参数类型

Python函数中参数类型

2018年08月31日 | 移动技术网IT编程 | 我要评论

在学习python函数的时候，函数本身的定义和调用并不是很复杂，但是函数的参数类型和用法的确有些复杂。在此做一个小结，加深理解。

python参数的定义

负责给函数提供一些必要的数据或信息，以保证函数的正常运行。
形式参数（parameter）：在函数定义的时候使用到的参数，一般没有赋值（默认参数除外）。
实参（argument）：在函数调用的时候实际赋予的值。
如果在函数定义时给定了形式参数，并且没有给该参数默认值，则在调用的时候必须给定一个实参

def sayhello(person):
    print("hi {0},nice to meet you!".format(person))
    print('nice to meet you too!')

sayhello('tom')

hi tom,nice to meet you!
nice to meet you too!

python参数的类型

普通参数
- 普通参数是python函数中最常见的参数，也叫做位置参数；
- 在函数定义的时候直接给定参数的名称，调用时按照参数的位置赋予参数值
- 注意，如果在一个函数中定义了多个普通参数，在调用赋值的时候，必须按照定义的顺序依次赋值。
- ```
# python函数的定义和调用语法
def func_name(parameter1,parameter2,...):
      function_body
#调用
func_name(value1,value2,...)
```

默认参数

在函数定义的时候，给形式参数赋予一个默认值；调用函数的时候，如果没有给该参数赋新值，则使用函数定义时的默认值
如果位置参数和默认参数都存在，则必须将位置参数放在默认参数前

# 使用默认参数

def student(name,age,gender='male'):
    if gender == 'male':
        print("{0} is {1} years old, and he is a good student.".format(name,age))
    else:
        print("{0} is {1} years old, and she is a good student.".format(name,age))

# 调用上述函数student
student('wangxiaoli',20,'female')
student('zhangdayong',22)

wangxiaoli is 20 years old, and she is a good student.
zhangdayong is 22 years old, and he is a good student.

关键字参数

定义的方式和默认参数一样，只不过像多个默认参数的集合
关键字参数是以键值对的形式，再调用的时候，并不需要考虑参数的位置
如果关键字参数函数中还有普通的位置参数，则在函数定义时，需要把普通参数放在前面。并且调用的时候，普通参数也必须放在前面

# 使用关键字参数
def func_name(name='tom',age=20,addr='no addr'):
    print('i am a student.')
    print("my name is {0}, and i am {1} years old, i come from {2}.".format(name,age,addr))
    
# 调用
# 关键字参数调用时，参数的位置是不重要的
func_name(name='wangmeili',addr='china',age=23)
# 关键字参数也属于特殊的默认参数
func_name()

i am a student.
my name is wangmeili, and i am 23 years old, i come from china.
i am a student.
my name is tom, and i am 20 years old, i come from no addr.

# 同普通参数的混用
# 如果关键字参数函数中还有普通的位置参数，则在函数定义时，需要把普通参数放在前面
# 调用的时候，普通参数，也必须放在前面
# 否者就会报下面的定义错误
def func_name(age,name='tom',addr='no addr'):
    print('i am a student.')
    print("my name is {0}, and i am {1} years old, i come from {2}.".format(name,age,addr))
    
  file "<ipython-input-13-0663557d1e59>", line 5
    def func_name(name='tom',age,addr='no addr'):
                 ^
syntaxerror: non-default argument follows default argument

# 调用错误
# 强调位置参数必须放在前面
def func_name(name,age=20,addr='no addr'):
    print('i am a student.')
    print("my name is {0}, and i am {1} years old, i come from {2}.".format(name,age,addr))
 
# 错误的调用方法
 func_name(age=22,'jack',addr='china')


  file "<ipython-input-16-e8faf29fa701>", line 7
    func_name(age=22,'jack',addr='china')
                                         ^
indentationerror: unindent does not match any outer indentation level

收集参数

把没有名称，也没有位置，没有对应关系的参数放入到一个集合中（tuple），称为收集参数
实际传入的参数可以是任意多个，也可以没有

语法结构
def func_name(*args):
      function_body
   按照tuple的使用方法定义*args，得到传入的参数

   调用：
func_name(p1,p2,p3,...)
#参数名args是约定俗称的写法，前面必须加*


# 使用收集参数
# 函数模拟学生的自我介绍，介绍的内容不确定
# args可一看作是一个元组tuple

def instrostu(*args):
    print("hello everyone,allow me to introduce myself:")
    print(type(args))
    for params in args:
        print(params)
        
# 调用
# 相当于把提供的实参，装入到args中
instrostu('wangmeili',18,'nanjing','single')
instrostu('tom')

hello everyone,allow me to introduce myself:： 
<class 'tuple'>
wangmeili
18
nanjing
single
hello everyone,allow me to introduce myself:： 
<class 'tuple'>
tom

收集参数之关键字参数

与收集参数不同的是，收集关键字参数改善了收集参数无名称、无对应关系的缺点。
收集关键字参数使用字典（dict)来保存参数

#语法结构
def func_name( **kwargs):
      function_body

#调用：
func_name(p1=v1,p2=v2,...)

# 关键字收集参数
# 自我介绍

def stu(**kwargs):
    print('hello everyone,allow me to introduce myself： ')
    print(type(kwargs))
    # 对于字典的访问
    for key,value in kwargs.items():
        print(key,'--->',value)
        
# 调用
stu(name='wangmeili',age=19,add='nanjing',lover='gavin',work='teacher')

print('*' * 30)

stu(name='tom')

print('*' * 30)

stu()
hello everyone,allow me to introduce myself： 
<class 'dict'>
name ---> wangmeili
age ---> 19
add ---> nanjing
lover ---> gavin
work ---> teacher
******************************
hello everyone,allow me to introduce myself： 
<class 'dict'>
name ---> tom
******************************
hello everyone,allow me to introduce myself： 
<class 'dict'>

四种参数混合调用规则

位置参数，默认参数，收集参数（tuple），关键字参数，收集关键字参数（dict)
位置参数必须放在最前面，收集关键字参数放在最后面
说明：默认参数、关键字参数和收集参数(tuple)的位置可以进行互换。如果收集参数在前，则其后的所有参数除了收集关键字参数外，都会变成关键字参数，若要修改参数的默认值，方法同关键字参数；如果收集参数在后，那么前面所有的参数除了位置参数外，都会变成默认参数，若要修改默认值，方法同默认参数。
调用规则等同于定义规则

# 混合参数使用案例
# 自我介绍

def student(name,age=20,*args,addr='no addr',hobby='none',**kwargs):
    print('hello,大家好！')
    print("我叫{0},我今年{1}岁，我来自{2}".format(name,age,addr))
    
    if hobby == 'none':
        print('我目前没有啥特别的喜好')
    else:
        print("我的爱好是{0},有兴趣大家可以一起玩呀！".format(hobby))
        
    print('-' * 30)
    for i in args:
        print(i)
    print('-' * 30)    
    for k,v in kwargs.items():
        print(k,'--->',v)
    print('*' * 30)
        
        
# 调用
student('猪上树',22,'足球','篮球',addr='江苏南京',hobby='桌球',lover='王美丽',hate='张大熊')
student('张大熊',25,'但是我是一个环保爱好者','也是一名公益事业爱好者',addr='南邮')



hello,大家好！
我叫猪上树,我今年22岁，我来自江苏南京
我的爱好是桌球,有兴趣大家可以一起玩呀！
------------------------------
足球
篮球
------------------------------
lover ---> 王美丽
hate ---> 张大熊
******************************
hello,大家好！
我叫张大熊,我今年25岁，我来自南邮
我目前没有啥特别的喜好
------------------------------
但是我是一个环保爱好者
也是一名公益事业爱好者
------------------------------
******************************

# 上例函数可以改写为如下，将*args位置提前
def student1(name,*args,age=20,addr='no addr',hobby='none',**kwargs):
    print('hello,大家好！')
    print("我叫{0},我今年{1}岁，我来自{2}".format(name,age,addr))
    
    if hobby == 'none':
        print('我目前没有啥特别的喜好')
    else:
        print("我的爱好是{0},有兴趣大家可以一起玩呀！".format(hobby))
        
    print('-' * 30)
    for i in args:
        print(i)
    print('-' * 30)    
    for k,v in kwargs.items():
        print(k,'--->',v)
    print('*' * 30)

student1('大熊',1,3,4,5,age=22,hobby='篮球',x=1,y=2,z=3)
hello,大家好！
我叫大熊,我今年22岁，我来自no addr
我的爱好是篮球,有兴趣大家可以一起玩呀！
------------------------------
1
3
4
5
------------------------------
x ---> 1
y ---> 2
z ---> 3
******************************

两种收集参数的解包问题

不同于上面的例子，当传入的参数不再是单个字符串或者数字时，例如传入的是一个列表或集合或元组或者字典等
当传入的参数为上面上面4个之一时，我们需要访问列表中的每一个元素时，就需要用到解包

# 调用list到 *args
# 
def stu1(*args):
    print('hahahhahahha')
    for i in args:
        print(i)
        
ll = ['wangmeili',22,'shanghai']
# 这种调用方式，直接将整个list打印出来
stu1(ll)
print('---------------')
# 如果要将list中的每个元素都打印出来，就需要解包
stu1(*ll)
hahahhahahha
['wangmeili', 22, 'shanghai']
---------------
hahahhahahha
wangmeili
22
shanghai

# 调用dict到 **args
def stu2(**kwargs): 
        print('hahahhahahha')
        for k,v in kwargs.items():
            #print(type(k))
            #print(type(v))
            print(k,'>>>',v)
        
d = {'name':'wangmeili','age':'22','addr':'shanghai'}
# 此时若要将字典当作实参传递给kwargs，就必须先进性解包
stu2(**d)
print('-------------')

# 不解包传参
stu2(d)
# 不解包传参，函数会把传入的字典名称d，当作一个位置参数
hahahhahahha
name >>> wangmeili
age >>> 22
addr >>> shanghai
-------------

---------------------------------------------------------------------------
typeerror                                 traceback (most recent call last)
<ipython-input-82-09f0a7d3879b> in <module>()
     13 
     14 # 不解包传参
---> 15 stu2(d)

typeerror: stu2() takes 0 positional arguments but 1 was given

有关*args和**kwargs两者之间的区别和其他扩展用法

*args就是一个无名参数的集合，没有位置形和对应性，参数集合可以理解为一个元组tuple
**kwargs可以看作是一组由关键字参数组成的字典集合
由下面的例子可以看出，在混合或非混合使用的场景中，两种参数会自动进行分解形成相应的数据类型

def test(*args,**kwargs):
    print('args = ',args)
    print('kwargs = ',kwargs)
    print('--------------')

test(1,2,3,4)
test(a=1,b=2,c=3)
test(1,2,3,4,a=1,b=2,c=3)
test('a',none,3,a='qq',b=2,c=9)

args =  (1, 2, 3, 4)
kwargs =  {}
--------------
args =  ()
kwargs =  {'a': 1, 'b': 2, 'c': 3}
--------------
args =  (1, 2, 3, 4)
kwargs =  {'a': 1, 'b': 2, 'c': 3}
--------------
args =  ('a', none, 3)
kwargs =  {'a': 'qq', 'b': 2, 'c': 9}
--------------

# 将一串字符转变为一个元组tuple
def aas(x,*args):
    print(x)
    print(args)
    
aas(1,2,3,4,5,6,7,'a','aa','scd')
1
(2, 3, 4, 5, 6, 7, 'a', 'aa', 'scd')

# 使用**args 创建一个字典
def gen_dict(**kwargs):
    return kwargs
dict1 = gen_dict(a=1,b=2,c=3,name='jack')
print(dict1)
{'a': 1, 'b': 2, 'c': 3, 'name': 'jack'}

　　最后，python参数的定义形式虽然种类不是很多，但是使用时，尤其混合使用时一定要注意顺序。

您可能感兴趣的文章:

如对本文有疑问，点击进行留言回复！！

给Django Admin添加验证码和多次登录尝试限制的实现

django自带的admin很好用，但是放到生产环境总还差了点什么= =看看admin的介绍：django奉行python的内置电池哲学。它自带了一系列在web... [阅读全文]
3分钟看懂Python后端必须知道的Django的信号机制

概念django自带一套信号机制来帮助我们在框架的不同位置之间传递信息。也就是说，当某一事件发生时，信号系统可以允许一个或多个发送者（senders）将通知或信... [阅读全文]
利用Python实现斐波那契数列的方法实例

今天我们来使用python实现递归算法求指定位数的斐波那契数列首先我们得知道斐波那契数列是什么? 斐波那契数列又叫兔子数列斐波那契数列就是一个数列... [阅读全文]
Element Dialog对话框的使用示例

组件— 对话框基本用法<el-button type="text" @click="dialogvisible = true">点击打开 dialo... [阅读全文]
使用python求斐波那契数列中第n个数的值示例代码

斐波那契数列（fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（leonardoda fibonacci）以兔子繁殖为例子而... [阅读全文]
Element Dropdown下拉菜单的使用方法

组件— 下拉菜单基础用法<el-dropdown> <span class="el-dropdown-link"> 下拉菜单<i... [阅读全文]
Python基础教程之输入输出和运算符

在我们python中输入输出函数在程序中运用较为广泛,运算符常用于if判断的条件中,今天我来给大家讲解这两项概念.input输入和print输出input()输... [阅读全文]
自动化运维与Python的关系

一.什么是自动化运维?运维早期: 服务器体量小，部署步骤少、操作简单、对运维人员要求较低(掌握基本的Linux... [阅读全文]
用python做数据分析

看到一篇关于 Python办公自动化｜一键生成数据分析报告的文章，感觉文章写得很好，记录下来，方便继续学习... [阅读全文]
二分查找之分割数组的最大值

LeetCode 410. 分割数组的最大值给定一个非负整数数组和一个整数 m，你需要将这个数组分成 m 个非空... [阅读全文]

网友评论


验证码：

Python函数中参数类型

2018年08月31日 | 移动技术网IT编程 | 我要评论

您可能感兴趣的文章:

相关文章:

网友评论