二、函数的参数

一、函数的传参

函数的传参：让函数封装的这个功能，盘活

分两个角度：实参，形参

def meet(sex):  #函数的定义：接受的参数形式参数
    print('打开tantan')
    print('进行筛选：性别：%s' %(sex))
    print('左滑一下')
    print('右滑一下')
    print('找美女')
    print('悄悄话....')
    print('约....走起...')
​
meet('男')  # 函数的执行传的参数 ：实际参数

 

二、函数的传参——实参角度

1. 位置参数: 从左至右，一一对应。

 def meet(sex,age,skill):
      print('打开tantan')
      print('进行筛选：性别：%s,年龄：%s,%s' %(sex,age,skill))
      print('左滑一下')
      print('右滑一下')
      print('找美女')
      print('悄悄话....')
      print('约....走起...')
​
meet('女',25,'python技术好的',)
​
#结果：
打开tantan
进行筛选：性别：女,年龄：25,python技术好的
左滑一下
右滑一下
找美女
悄悄话....
约....走起...

写一个函数，只接受两个int的参数，函数的功能是将较大的数返回。
def compile(a,b):
    c = 0
    if a > b:
        return c
    else:
        return c
print(compile(10,20))
print(compile(1000,1))
compile(1000,20)
​
​
三元与运算符： 简单的if else
a = 1000
b = 2000
if a > b:
    c = a
else:
    c = b
print(c)
​
a = 1000
b = 2000
c = a if a > b else b
def complie(a,b):
    c = a if a > b else b
    return c
​
def complie(a,b):
    return a if a > b else b
​
​

2. 关键字参数一一对应

def meet(sex,age,skill,hight,weight,):
      print('打开tantan')
      print('进行筛选：性别：%s,年龄：%s,技术：%s,身高：%s,体重%s' %(sex,age,skill,hight,weight))
      print('左滑一下')
      print('右滑一下')
      print('找美女')
      print('悄悄话....')
      print('约....走起...')
​
meet(age=25,weight=100,hight=174,skill='python技术好的',sex='女')
​
#结果：
打开tantan
进行筛选：性别：女,年龄：25,技术：python技术好的,身高：174,体重100
左滑一下
右滑一下
找美女
悄悄话....
约....走起...
​

3. 混合参数

# 混合参数
# 位置参数一定要在关键字参数的前面。
def meet(sex,age,skill,hight,weight,):
    print('打开tantan')
    print('进行筛选：性别：%s,年龄：%s,技术：%s,身高：%s,体重%s' %(sex,age,skill,hight,weight))
    print('左滑一下')
    print('右滑一下')
    print('找美女')
    print('悄悄话....')
    print('约....走起...')
    return '筛选结果：性别：%s,体重%s' %(sex,weight)
​
print(meet('女',25,weight=100,hight=174,skill='python技术好的'))
​
#结果：
打开tantan
进行筛选：性别：女,年龄：25,技术：python技术好的,身高：174,体重100
左滑一下
右滑一下
找美女
悄悄话....
约....走起...
筛选结果：性别：女,体重100

 

函数的执行传的参数：实际参数

• 位置参数：从左至右，一一对应

• 关键字参数：一一对应，可不按照顺序

• 混合参数：位置参数一定要在关键字参数前边

三、函数的传参——形参角度

（1）位置参数

 

　　　　
def meet(sex,age,skill):
    print('打开tantan')
    print('进行筛选：性别：%s,年龄：%s,%s' %(sex,age,skill))
    print('左滑一下')
    print('右滑一下')
    print('找美女')
    print('悄悄话....')
    print('约....走起...')
​
meet('女',25,'python技术好的',)
​
写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。
def func(l):
    if len(l) > 2:
        return l[:2]
    else:
        return l
# print(func([1,2,3,4,5]))
print(func([1,]))
​
def func(l):
    c = l[:2] if len(l) > 2 else l
    return c
print(func([1,2,3,4,5]))
print(func([1,]))
​
def func(l):
    return l[:2]
# l1 = [1,]
# print(l1[:2])


　　

（2）默认参数

默认值参数
默认参数设置的意义：普遍经常使用的。
​
def meet(age,skill='python技术好的',sex='女',):
    print('打开tantan')
    print('进行筛选：性别：%s,年龄：%s,技能：%s' %(sex,age,skill))
    print('左滑一下')
    print('右滑一下')
    print('找美女')
    print('悄悄话....')
    print('约....走起...')
​
# meet(25,'python技术好的',)
meet(25,'运维技术好的','男')

（3）万能参数

 

• *args，

  在函数定义时，*代表聚合。他将所有位置参数聚合成一个元组，赋值给了args

  def eat(a,b,c,d):
      print('我请你吃：%s,%s,%s,%s' %(a,b,c,d))
  ​
  eat('蒸羊羔', '蒸熊掌', '蒸鹿邑','烧花鸭')
  ​
  ​
  def eat(a,b,c,d,e,f):
      print('我请你吃：%s,%s,%s,%s,%s,%s' %(a,b,c,d,e,f))
  ​
  eat('蒸羊羔', '蒸熊掌', '蒸鹿邑','烧花鸭','烧雏鸡','烧子鹅')
  ​
  # 想增加参数，需要手动添加
  # 急需要一种形参，可以接受所有的实参。#万能参数。
  ​
  # 万能参数： *args, 约定俗称：args，
  # 函数定义时，*代表聚合。 他将所有的位置参数聚合成一个元组，赋值给了 args。
  ​
  def eat(*args):
      print(args)
      print('我请你吃：%s,%s,%s,%s,%s,%s' % args)
  ​
  eat('蒸羊羔', '蒸熊掌', '蒸鹿邑','烧花鸭','烧雏鸡','烧子鹅')

  
  # 写一个函数：计算你传入函数的所有的数字的和。
  def func(*args):
      count = 0
      for i in args:
          count += i
      return count
  print(func(1,2,3,4,5,6,7))
  ​
  ​
  # tu1 = (1, 2, 3, 4, 5, 6, 7)
  # count = 0
  # for i in tu1:
  #     count += i
  # print(count)

  **kwargs,

  在函数定义时，**将所有的关键字参数聚合到一个字典中，将这个字典赋值给了kwargs。

  
  def func(**kwargs):
      print(kwargs)
  func(name='alex',age=73,sex='laddyboy')
  ​
  #结果：{'name': 'alex', 'age': 73, 'sex': 'laddyboy'}

　

*的魔性用法

*在函数定义时，代表聚合

*在函数的调用时，代表打散（打散字符串，数列 ，'dsad'，[1,2,3,4]）

def func(*args):
    print(args) 
func([1,2,3],[22,33])
#此时，输出的结果为([1, 2, 3], [22, 33])，
#但是想要得到一个这样的结果： (1,2,3,22,33)，
​
#这样我们就需要使用到函数的调用，在一个可迭代对象前加*
def func(*args):
    print(args) 
func(*[1,2,3],*[22,33]) #就相当于 func(1,2,3,22,33)

**在函数定义时，代表聚合

**在函数的调用时，代表打散（打散字典，{'name':太白}）

def func(**kwargs):
    print(kwargs)
func(**{'name':'太白'},**{'age':18}) #就相当于 func('name'='太白','age'=18)
#结果为：{'name': '太白', 'age': 18}

　　

　　

（4）仅限关键字参数（了解）

# 形参角度第四个参数：仅限关键字参数 (了解)
​
def func(a,b,*args,sex= '男',c,**kwargs,):
    print(a,b)
    print(sex)
    print(args)
    print(c)
    print(kwargs)
func(1,2,3,4,5,6,7,sex='女',name='Alex',age=80,c='666')
​
#结果：
1 2
女
(3, 4, 5, 6, 7)
666
{'name': 'Alex', 'age': 80}
​
# 形参角度最终的顺序：位置参数,*args,默认参数，仅限关键字参数，**kwargs

• 形参的最终顺序

  
  # 形参角度的参数的顺序
  ​
  # *args 的位置？
  def func(*args,a,b,sex= '男'):
      print(a,b)
  func(1,2,3,4)
  #*args放在位置参数前，会报错，a和b得不到值，所以要放在位置参数后
  ​
  def func(a,b,sex= '男',*args,):
      print(a,b)
      print(sex)
      print(args)
  func(1,2,3,4,5,6,7,)
  # args得到实参的前提，sex必须被覆盖了，此时sex=3。可是sex是设置的默认参数，不能改变它，所以要放在默认参数前边
  ​
  def func(a,b,*args,sex= '男'):
      print(a,b)   #1  2
      print(sex)   #默认是男，可被下边修改
      print(args)  #(3, 4, 5, 6, 7)
  func(1,2,3,4,5,6,7,sex='女')
  #以上arge的位置是正确的，func()不写 sex='女' ，则sex是默认参数为男，写入则女替换掉男
  ​
  # **kwargs 位置？
  def func(a,b,*args,sex= '男',**kwargs,):
      print(a,b)
      print(sex)
      print(args)
      print(kwargs)
  func(1,2,3,4,5,6,7,sex='女',name='Alex',age=80)
  #结果为：
  1 2
  女
  (3, 4, 5, 6, 7)
  {'name': 'Alex', 'age': 80}

  形参角度参数最终顺序：位置参数------>*args------>默认参数------>仅限关键字参数------>**kwargs

 

• 形参角度的参数顺序

  位置参数------>*args------>默认参数

  默认参数------>**kwargs