函数——参数

1.作用：

将重复的代码，封装到函数，只要使用直接找函数。
函数可以增强代码的模块化和提高代码的重复利用率。

2.定义函数:

• 格式:

def 函数名([参数,参数...]):
		函数体 （重复的代码）

• 注意1：
  • 1.必须使用关键字def
  • 2.函数体注意缩进
  • 3.函数名() 绑定
• 注意2：
  • 函数名命名规则同变量名，要满足标识符命名规则
  • 不能和系统函数重名，否则系统函数无法使用
  • 函数定义分两部分函数头和函数体
  • 函数体，就是实现功能的代码段，以：开头，必须缩进
  • 函数名的命名风格：一般建议用下划线分隔的小写单词组成：say_hello

3.函数调用

• 案例：产生10个随机数

import random


def generate_random():
    for i in range(10):
        ran = random.randint(1, 20)
        print(ran)


print(generate_random)  # 打印函数名
# <function generate_random at 0x0000000002071E18>


# 调用: 函数名()   找到函数并执行函数体的内容
print('------------1--')
generate_random()

print('------------2--')
generate_random()

4.带参数的函数（形参 VS 形参）

• 案例：
  求随机数的函数，产生的个数未知。

'''
定义：
 def 函数名(参数,参数,..):
    函数体
调用:
    pass
'''
def generate_random(number):   # number 是形参
    for i in range(number):
        ran = random.randint(1, 20)
        print(ran)
 
# 调用
generate_random(5)  # 5是 实参

• 案例： 求加法的函数

def add(a,b):
	result = a + b
	print('和：',result)
add(2,3)   # 和：5

• 案例
  定义一个登陆函数
  参数：username，password
  函数体：判断参数传过来的username,password是否正确，如果正确则登陆成功，否则打印登陆失败，登录失败次数超过三次，账户被锁定。

def log_in(username, password):
       # 模拟数据库
       user_name = "huahua"
       pass_word = "123456"
       for i in range(3):
              if username == user_name and password == pass_word:
                     print("登陆成功！")
                     break
              else:
                     print("登录失败！")
                     username = input('请输入用户名：')
                     password = input("请输入密码：")
       else:
              print("账户被锁定！")


username = input('请输入用户名：')
password = input("请输入密码：")
log_in(username, password)

-案例：找出列表的最大值，自己封装一个求最大值函数

def max(list):
	max = list[0]
	for i in list:
		if i > max:
			max = i
	print(max)
	
max([1, 5, 9, 7, 6, 3, 4])

tuple1 = (3, 6, 1, 0, 5)
max(tuple1)

print(type(tuple1))  # type()只能查看是什么类型

# 判断是不是什么类型： isinstance(变量,类型关键字)
# print(isinstance(2, int))  # 返回值是 True

print(isinstance(tuple1, tuple))  # 返回值是 True

if isinstance(tuple1, tuple):
    print('不能排序和翻转')

5.可变参数(个数可变)

def add(*args):
	print(args)

add() # 返回空元组（）
add(1)  # 返回 (1,)
add(1,2,3) # 返回 (1,2,3)

def add(*args):
    sum = 0
    if len(args) > 0:
        for i in args:
            sum = sum + i
        print("累加和为：", sum)
    else:
        print("没有元素可计算，sum = ", sum)

add()  # 没有元素可计算，sum =  0
add(1)  # 累加和为： 1
add(1, 2, 3) # 累加和为： 6 

# xxx 计算出来的累加和是:xxx

def add(name, *args):  # name, *args ='飞飞', 4, 6, 8
    sum = 0
    if len(args) > 0:
        for i in args:
            sum += i
        print('%s累加和是:sum:%s' % (name, sum))
    else:
        print('没有元素可计算，sum:', sum)


# 调用
add('飞飞', 4, 6, 8)

# a,*b =1,3,5,6,7   ---->a = 1    b = (3,5,6,7)

# 注意： 可变参数必须放在后面: name,*args

6.关键字参数

• 关键字参数：key = value

def add(a, b = 10):  # 关键字参数，此时b 是默认值
	result = a + b
	print(result)

# 调用
add(5)  # 返回 15
add(4, 7)  # 返回 11   此时b = 7,覆盖原来的默认值

def add1(a, b = 10, c = 4):
    print(a, b, c)
    result = a + b + c
    print(result)


add1(1)

add1(1, 5)  # 是给b赋值成功
add1(2, 6)  # 默认6是赋值给b了，
add1(2, c=6)  # 如果想将6赋值给c，则需要结合关键字的 key 使用

• 关键字参数为字典时（**kwargs）

def func(**kwargs):  # key word  argument
	print(kwargs)

func(a=1, b=2, c=3)  # {'a': 1, 'b': 2, 'c': 3}

func()  # {}

# 传入值为字典时
dict1 = {'001': 'python', '002': 'java', '003': 'c语言', '004': 'go语言'}
func(**dict1)  
# {'001': 'python', '002': 'java', '003': 'c语言', '004': 'go语言'}

# 函数： 打印每位同学姓名和年龄
students = {'001': ('蔡徐坤', 21), '002': ('王源', 19), '003': ('王俊凯', 20), '004': ('易烊千玺', 19)}


def print_boy(name, **persons):  # persons = students
    print('{}喜欢的小鲜肉是:'.format(name))
    if isinstance(persons, dict):
        values = persons.values()
        # print(values)
        for name, age in values:
            print('{}的年龄是:{}'.format(name, age))


# 调用
print_boy('蕊蕊', **students)

• 总结
• aa(**kwargs)— 装包
• print(**dict)----- 拆包

'''
使用函数的时候:
def aa(**kwargs):
    pass

aa(a=1, b='hello', c='tom')    --->将关键字装包成字典

'''


def aa(**kwargs):
    print(kwargs)


aa(a=1, b='hello', c='tom')  # 装包：{'a': 1, 'b': 'hello', 'c': 'tom'}

# 如果在开发的时候，已知一个字典

dict1 = {'a': 1, 'b': 'hello', 'c': 'tom'}

aa(**dict1)  # a=1, b='hello', c='tom'    拆包的过程


def bb(a, b, *c, **d):
    print(a, b, c, d)


bb(1, 2)  # 1 2 () {}

bb(1, 2, 3, 4)  # 1 2 (3,4) {}

bb(1, 2, x=100, y=200)  # 1 2 () {'x':100,'y':200}

bb(1, 2, 3, x=100)  # 1 2 (3,) {'x':100}

bb(1, 2, x=100, y=200, z=100)

• 关键字为列表时( *args)

def func(a, *args, **kwargs):
    print(a, args, kwargs)
    
list1 = [2, 5, 8]
dict1 = {'1': 'a', '2': 'b', '3': 'c'}

func(1, *list1, **dict1)
# 1 (2, 5, 8) {'1': 'a', '2': 'b', '3': 'c'}
func(1, list1, **dict1)
# 1 ([2, 5, 8],) {'1': 'a', '2': 'b', '3': 'c'}

总结

'''
无参数函数:

def func():
    pass

func()  ---->调用
  
有参数函数:
  1. 普通参数
  
  def func(name,age):
        pass
  
  func('aa',18)   ----> 形参与实参的个数要一致
  
  
  2. 可变参数:
   A. def func(*args):
          pass
          
      func()  ----> 函数调用时，实参的个数可以没有，也可以多个   *不能是关键字参数
      func(4)  func(5,'h')
  
  
  B. def  func(**kwargs):
         pass
        
     func(a=1,b=2)  ----> 函数调用时，实参的个数可以没有，也可以多个   **必须是关键字参数

  C. def func(*args,**kwargs):
         pass
    
    list1 = [1,3]
    dict1 = {'1':'a','2':'b'}
    func(*list1,**dict1)  # func(1,3,'1'='a','2'='b')
     
  D. 混用
  
  def func(name,*args,**kwargs):
        pass
        
  func('tom')   ----> 必须赋值

  3. 默认值+关键字
  
  def func(name,age=18):
        pass
        
  func('tom')  ----》 tom  18
  
  func('tom',age=20)   --->关键字赋值
  
  

'''