python基础-方法参数（默认参数）、多返回值、三元、动态参数*和**、魔性用法

函数的return

def func1():
   pass

def func2():
    return

def func3():
    return None

print(func1())
print(func2())
print(func3())

输出如下：

None
None
None

函数的多返回值（元组）

#多返回值
def func():
    return  1,2

#用一个元组来接受
a = func()
print(a)
#输出元组元素
a,b = func()
print(a,b)

输出如下：

(1, 2)
1 2

方法参数

实参

按着位置传参数，按着关键字传参数
实参形参数量一样
混用可以首先传位置，然后传关键字

def func6(para1,para2):
    print(para1,para2)


func6(9,para2=5)
func6(1,3)
func6(para2=4,para1=6)
func6(para2=4,para1=6)

输出如下：

9 5
1 3
6 4

形参（默认参数）

#默认参数

def func7(name,sex = "男"):
    print("姓名：%s,姓别：%s"%(name,sex))

func7("safly")
func7("小梅",sex="nv")
func7("小梅","nv")

输出如下：

姓名：safly,姓别：男
姓名：小梅,姓别：nv
姓名：小梅,姓别：nv

默认参数魔性方法

我们来看默认参数的一个迷惑的用法

def func8(l = []):
    l.append(1)
    print(l)


func8()
func8()
func8([])
func8([])

输出如下：

E:\python\python_sdk\python.exe E:/python/py_pro/python.py
[1]
[1, 1]
[1]
[1]

分析如下：
魔性用法 默认参数尽量避免使用可变数量类型
“””
Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，
因为默认参数L也是一个变量，它指向对象[]，
每次调用该函数，如果改变了L的内容，
则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。
所以，定义默认参数要牢记一点：默认参数必须指向不变对象！

为什么要设计str、None这样的不变对象呢？因为不变对象一旦创建，
对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。
此外，由于对象不变，多任务环境下同时读取对象不需要加锁，
同时读一点问题都没有。我们在编写程序时，
如果可以设计一个不变对象，那就尽量设计成不变对象。
“”“

我们来看一个例子：

def check1(mList):
    finalList = mList[1::2]
    return finalList

def check2(mList):
    return mList[1::2]

list = [1,2,3,4,5,6]
print(check1(list))
print(list)
print("---------")
print(check2(list))
print(list)
print("===============")
def check3(mList = []):
    print(mList)
check3(list)
print(list)
print("===============")

输出如下：

E:\python\python_sdk\python.exe E:/python/py_pro/test.py
[2, 4, 6]
[1, 2, 3, 4, 5, 6]
---------
[2, 4, 6]
[1, 2, 3, 4, 5, 6]
===============
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6]
===============

三元运算符

#三元运算符

c = 0
a = 1
b = 2

if a>b:
   c = 1
else:
   c = b

print(c)

c = a if a> b else b
print(c)

输出如下：

2
2

动态参数*

在参数前面加个*，这个参数就变成动态参数了

动态参数
def func(*args):
    print(args)

元组
func(2,True,[1,3],"ss")

输出如下：
使用的时候，所有接收过来的参数都被组织成一个元组的形式

(2, True, [1, 3], 'ss')

动态参数*混合使用

混用(动态参数放后面，默认参数后面

def func(a,b,*args,c = 3):
    print(a,b,args,c)

func(2,True,"ss",c = [1,3])

输出如下：

2 True ('ss',) [1, 3]

动态参数**

顺序是：
位置、动态*args、默认参数、**kwargs(只有位置参数必传)

#字典
def funn1(**kwargs):
    print(kwargs)
funn1(a=1,b=2)
print("---------")
#位置、动态*args、默认参数、**kwargs(只有位置参数必传)
def func2(a,*args,key="sss",**kwargs,):
    print(a,args,key,kwargs)

func2(5)
print("---------")
def func(a,*args,key = 'qqxing',**kwargs):
    print('a : ',a)
    print('args : ',args)
    print('key : ',key)
    print('kwargs : ',kwargs)

func(5,6,7,key='小小酥',b='hahaha',c='hehehe')
print("---------")

输出如下：

E:\python\python_sdk\python.exe E:/python/py_pro/test.py
{'a': 1, 'b': 2}
---------
5 () sss {}
---------
a :  5
args :  (6, 7)
key :  小小酥
kwargs :  {'b': 'hahaha', 'c': 'hehehe'}
---------

动态参数魔性用法

在调用函数的时候，可以打散：*l（按顺序打散）、**dic（打散）

#魔性用法
def func5(*args):
    sum = 0
    for i in args:
        sum+=i
    return sum

print(func5(1,3,4))
print("--------------------")
#按顺序打散
print(func5(*[1,3,4,5]))
print("--------------------")
def func6(*args):
   print(args)
func6(*"sweg")
func6(*(1,2,4))
func6(*[1,2,9])
func6(*{"a":"b","c":"d"})
print("--------------------")

def func7(**kwargs):
    print(kwargs)

func7(a=1,b=2)
func7(**{"a":"1","b":"2"})

输出如下：

E:\python\python_sdk\python.exe E:/python/py_pro/test.py
8
--------------------
13
--------------------
('s', 'w', 'e', 'g')
(1, 2, 4)
(1, 2, 9)
('a', 'c')
--------------------
{'a': 1, 'b': 2}
{'a': '1', 'b': '2'}