【python】-- 函数非固定参数,返回值(return)

函数非固定参数

1、默认参数:

代码如下:

def information_register(name,age,country,sex):
    print("----注册信息------")
    print("姓名:",name)
    print("age:",age)
    print("国籍:",country)
    print("课程:",course)
 
information_register("山炮",22,"CN","")
information_register("二狗",21,"CN","")
information_register("三傻",25,"CN","")

 

 

 以上country 这个参数 基本都 是"CN", 就像我们在网站上注册用户,像国籍这种信息,你不填写,默认就会是 中国, 这就是通过默认参数实现的,把country变成默认参数非常简单:

def information_register(name,age,sex,country="CN"):
    print("----注册信息------")
    print("姓名:",name)
    print("age:",age)
    print("国籍:",country)
    print("课程:",course)
 
information_register("山炮",22,"")
information_register("二狗",21,"")
information_register("三傻",25,"")

 

对,只需要把创建country这个形参的时候给它传一个实参就可以:country="CN"。这样就成了默认参数,这个参数在调用时不指定,那默认就是CN,指定了的话,就用你指定的值。另外要注意的一点就是 :我把country变成默认参数后,把他的位置放到了最后,这个是因为关键字参数不能放在位置参数前面,这一点我们上一节随笔有举例子验证。

2、非固定位置参数:*args

作用:接收N个位置参数,转换成元组的形式

def test(*args): #形参必须以*开头,args参数名随便定义,但是最好按规范来,定义成args
    print(args)
 
test(1,2,3,4,5) #输入多个位置参数
 
#输出
(1, 2, 3, 4, 5)  #多个参数转换成元组

 

(1)、 不传值,传入列表

 

def test(*args):
    print(args)
 
print("-------data1-----")
test() #如果什么都不传入的话,则输出空元组
print("-------data2-----")
test(*[1,2,3,4,5])  #如果在传入的列表的前面加*,输出的args = tuple([1,2,3,4,5])
print("-------data3-----")
test([1,2,3,4,5])  #如果再传入的列表前不加*,则列表被当做单个位置参数,所以输出的结果是元组中的一个元素
 
#输出
-------data1-----
()
-------data2-----
(1, 2, 3, 4, 5)
-------data3-----
([1, 2, 3, 4, 5],)

 

 (2)、位置参数和非固定位置参数*args

 

def test(x,*args):
    print(x)  #位置参数
    print(args)  #非固定参数
 
test(1,2,3,4,5,6)
 
#输出
1
(2, 3, 4, 5, 6) 

 

第一个实参是形参X 的值,后面的值就变成了非固定位置参数的*args的实参了

 

(3)、 关键字参数和非固定位置参数*args

def test(x,*args):
    print(x)
    print(args)
 
test(x=1,2,3,4,5,6)
 
#输出
  File "D:/PycharmProjects/pyhomework/day3/非固定参数/非关键字参数.py", line 21
    test(x=1,2,3,4,5,6)
            ^
SyntaxError: positional argument follows keyword argument #位置参数在关键字参数后面

 显然报错了,因为x=1是关键字参数,*args是位置参数,而关键字参数不能再位置参数前面的,所以报错,只要把关键字参数放在位置后面就可以了,代码如下:

def test(*args, x):
    print(x)
    print(args)

test(2,3,4,5,6, x=1)


#1
#(2, 3, 4, 5, 6)
View Code

 

 

 

3、非固定关键字传参:**kwargs

作用:把N个关键字参数,转换成字典形式

def test(**kwargs): #形参必须以**开头,kwargs参数名随便定义,但是最好按规范来,定义成kwargs
    print(kwargs)
 
test(name="qigao",age=18) #传入多个关键字参数
 
#输出
{'name': 'qigao', 'age': 18} #多个关键字参数转换成字典

 

(1)、传入字典

def test(**kwargs):
    print(kwargs)
 
test(**{"name":"qigao","age":18}) #传入字典时,一定要在字典前面加**,否则就会报错
 
#输出
{'name': 'qigao', 'age': 18}

 

传入字典时,一定要在字典前面加**,否则就会报错验证,代码如下:
def test(**kwargs):
    print(kwargs)
 
test({"name":"qigao","age":18})
 
#输出
Traceback (most recent call last):
  File "D:/PycharmProjects/pyhomework/day3/非固定参数/非固定关键字参数.py", line 9, in <module>
    test({"name":"qigao","age":18})
TypeError: test() takes 0 positional arguments but 1 was given #报类型错误,传入的是位置参数
View Code

 

 因为传入的字典被当做位置参数,所以被报类型错误,所以:传字典,加**

 

(2)、位置参数和非固定关键字参数:**keargs

def test(name,**kwargs):
    print(name)
    print(kwargs)
 
print("------data1-----")
test("qigao") #1个位置参数
print("------data2------")
test("qigao",age=18,sex="M") #1个位置参数,两个关键字参数
print("------data3------")
test(name="qigao",age=18,sex="M") #3个关键字参数
 
#输出
------data1-----
qigao #输出1个位置参数
{}  #没有输入关键字参数,所以输出空字典
------data2------
qigao  #第1个位置参数
{'age': 18, 'sex': 'M'} #剩下关键字参数,转换成1个字典
------data3------
qigao  #第1个关键字参数
{'age': 18, 'sex': 'M'} #剩下的关键字参数,转换成1个字典

 

 

(3)、位置参数、关键字和非固定关键字参数

def test(name,age=18,**kwargs):
    print(name)
    print(age)
    print(kwargs)
 
print("----------data1--------")
test("qigao",sex='M',hobby='tesl')
print("----------data2--------")
test("qigao",34,sex='M',hobby='tesl')
print("----------data3--------")
test("qigao",sex='M',hobby='tesl',age=34) #age关键字参数放到最后,也可以的
 
#输出
----------data1--------
qigao
18   #不传,显示默认参数
{'sex': 'M', 'hobby': 'tesl'}
----------data2--------
qigao
34   #传位置参数
{'sex': 'M', 'hobby': 'tesl'}
----------data3--------
qigao
34   #关键字参数,放在前后并没有影响
{'sex': 'M', 'hobby': 'tesl'}

 

注:如果遇到一个关键字传参和非固定关键字传参,前后放的位置是不影响传参的,但是我们一般还是按顺序来

 

(4)、位置参数、关键字参数、非固定位置参数和非固定关键字参数

def test(name,age=18,*args,**kwargs):
    print(name)
    print(age)
    print(args)
    print(kwargs)
     
print("-------第1种传参--------")
test("qigao",19,1,2,3,4,sex="m",hobby="tesla")
print("-------第2种传参--------")
test("qigao",19,*[1,2,3,4],**{'sex':"m",'hobby':"tesla"})
 
#输出
-------第1种传参--------
qigao #传name位置参数
19   #给age传位置参数
(1, 2, 3, 4)  #非固定位置参数,以转换成元组
{'sex': 'm', 'hobby': 'tesla'}  # 非固定关键字参数,转换成字典
-------第2种传参---------
qigao
19
(1, 2, 3, 4)  #以列表的形式传入,在列表前加*
{'sex': 'm', 'hobby': 'tesla'} #以字典的形式传入,在字典前加**

 关键字参数不能再位置参数前面,同样的非固定关键字参数也不能在非固定位置参数前面,代码如下:

def test(name,age=18,*args,**kwargs):
    print(name)
    print(age)
    print(args)
    print(kwargs)
 
test("qigao",19,sex="m",hobby="tesla",1,2,3,4,5)
 
#输出
 File "D:/PycharmProjects/pyhomework/day3/非固定参数/非固定关键字参数.py", line 57
    test("qigao",19,sex="m",hobby="tesla",1,2,3,4,5)
                                         ^
SyntaxError: positional argument follows keyword argument  #语法错误,关键字参数在位置参数前面
View Code

 

 

小结:

  1. 参数分为位置参数、关键字参数、默认参数、非固定位置参数和非固定关键字参数
  2. 位置参数之前传参,位置是不能调换的,多一个或者少一个参数都是不可以的。
  3. 关键字参数是不能放在位置参数前面的。
  4. 函数传参的位置顺序依次是,位置参数,默认参数、非固定位置参数、关键字参数、非固定关键字参数(def test(name,age=18,*args,**kwargs))
  5. 关键字传参,可以不用考虑位置的前后问题

 

 

返回值(return)

 

之前的随笔提到了return关键字,但是并没有详细的介绍的return关键字的用法,下面我们就来详细的阐述一下;

 

1.return的作用

 return其实有两个作用:

  • 需要用一个变量来接受程序结束后返回的结果
  • 它是作为一个结束符,终止程序运行
def test():
    print("in the test_1")
    return 0
    print("the end") #结果中没有打印
 
x = test()
print(x)
 
#输出
in the test_1 #第一次打印
0 #结果返回值

 

注:return 0后面的代码就不执行了,只执行return前面的代码;变量x接受了test()函数结束后的返回结果 

 

2.返回多个值

上面的例子是返回来一个值,下面试一试无返回值,返回一个值,返回多个值的情况:

def test_1():
    print("in the test_1")
 
def test_2():
    print("in the test_2")
    return 0
 
def test_3():
    print("in the test_3")
    return 1,"hello",["qigao","shuaigao"],{"name":"qigao"}
 
x = test_1()
y = test_2()
z =test_3()
print(x)
print(y)
print(z)
 
#输出
in the test_1
in the test_2
in the test_3
None #x的值
0  #y的值
(1, 'hello', ['qigao', 'shuaigao'], {'name': 'qigao'}) #z的值

 

返回值return的作用?  -------因为我们想要想要这个函数的执行结果,这个执行结果会在后面的程序运行过程中需要用到

 

小实验:

一个函数体内部调用另外一个函数,代码如下:

 

def test(name,age=18,**kwargs):
    print(name)
    print(age)
    print(kwargs)
    test1()
 
def test1():
    print("hello")
 
#在test1函数之后调用
test("qigao",age=23,sex="m",hobby="tesla")
 
#输出
qigao
23
{'hobby': 'tesla', 'sex': 'm'}
hello

 

这样是正常的,可以完美运行的,下面调用函数的时候换一个位置,在test1函数定义之前,调用test函数:

def test(name,age=18,**kwargs):
    print(name)
    print(age)
    print(kwargs)
    test1()
 
def test1():
    print("hello")
 
#在test1函数之后调用
test("qigao",age=23,sex="m",hobby="tesla")
 
#输出
qigao
23
{'hobby': 'tesla', 'sex': 'm'}
Traceback (most recent call last):
  File "D:/PycharmProjects/pyhomework/day3/局部变量和全局变量/test.py", line 12, in <module>
    test("qigao",age=23,sex="m",hobby="tesla")
  File "D:/PycharmProjects/pyhomework/day3/局部变量和全局变量/test.py", line 10, in test
    test1()
NameError: name 'test1' is not defined  #命名错误:test1没有被定义 

 注: 在调用函数的时候,调用函数位置也很重要,就像虽然定义了test1函数,但是调用test函数的位置在test1之前,执行test函数的时候,test1函数还没有被读到内存中,所以报错

 

posted @ 2017-04-05 15:54  Wilson_Blogs  阅读(1623)  评论(0编辑  收藏  举报