python基础函数

python课程总结（2）

[TOC]

函数的四种类型

# 无参数无返回值的函数
# 无参数无返回值的函数
# 无参数有返回值的函数
# 有参数有返回的函数

全局变量

# 全局变量：在函数外定义的变量叫做全局变量，全局变量可以在不同函数内使用。
# 特点： 全局变量可以在不同函数内共享全局变量的数据

# 全局变量
score = 100

def show():
    # 在这里不是对全局变量进行了修改而是定义了一个局部变量，
    # 只不过局部变量的名字和全局变量的名字相同
    # score = 99

    # 修改全局变量
    global score  # 表示要对全局变量score进行数据的修改
    score = 99

    print("分数:", score)#99

缺省参数

# 缺省参数： 在函数定义的时候参数就有值，那么像这样的参数叫做缺省参数
# 提示： 如果给缺省参数传值就是传入的值，
# 如果不给缺省参数传值那么就使用默认值(缺省值)
# # 如果有必选参数和缺省参数，那么缺省参数要放到必选参数后面

def sum_num(num1, num2=1):
    result = num1 + num2
    return result

传参方式

# 调用函数传参的方式有： 1. 使用位置参数方式参数 2. 使用关键字参数方式传参

def show(name, age):
    print(name, age)
    
# 使用位置参数方式传参必须按照函数参数的顺序去传参
show(20, "赵六")

# 使用关键字方式传参，可以不按照函数参数的顺序传参
show(age=18, name="冯七")

#可以接受先使用位置传参,在使用关键字传参数
show("王三",age=19)

不定长参数

# 函数的不定长参数： 1. 不定长位置参数 2. 不定长关键字参数

# 不定长参数： 调用函数的时候不确定传入多少个参数，可能是0个或者多个参数

# --------------不定长位置参数函数的定义及调用-------------
# 定义一个不定长位置参数(*args)
def sum_num(*args):
    # 提示： args： 会把调用函数传入的位置参数封装到一个元组里面，
    # 如果没有传入参数那么是一个空元组
    print(args, type(args))
    # 计算结果变量
    result = 0
    for value in args:
        result += value
    return result
# # 调用不定长位置参数的函数
value = sum_num(1, 4, 5, 6)
print(value)
# 注意点： *args:表示定义的函数是不定长的位置参数，
# 调用函数的时候只能使用位置参数传值，不能使用关键字
# result = sum_num(a=1, b=2, c=3)
# print(result) 会报错

# --------------不定长关键字参数函数的定义及调用-------------
# 定义不定长关键字参数函数， **kwargs: 表示的就是一个不定长关键字参数
def show_msg(**kwargs):
    # kwargs: 会把函数调用的关键字参数封装到字典里面
    print(kwargs, type(kwargs))

    for key, value in kwargs.items():
        print(key, value)

# 调用的不定长关键字参数的函数
show_msg(a=1, b=2)

# 不能使用位置参数给不定长关键字函数传参
# show_msg(1, 2)

# 定义不定长位置参数函数
def show_msg(*args):
    print(args)
    for value in args:
        print(value)


# 定义不定长位置参数函数
def show(*args):
    # print(args, type(args))
    # show_msg(args)
    # 解决办法： 对元组进行拆包
    show_msg(*args) #拆包
show(1, 2)

====================================================================================

def show_msg(**kwargs):
    print(kwargs)
    for key, value in kwargs.items():
         print(key, value)


# 定义不定长关键字函数
def show(**kwargs):
    # 把关键字参数封装到字典里面
    # print(kwargs)
    #show_msg(a=kwargs)

    # 对字典进行拆包
    show_msg(**kwargs)


show(a=1, b=2)
"""
{'a': 1, 'b': 2}
a 1
b 2
"""

# 下面的定义可以使用缺省参数
def show(name, *args, age=18, **kwargs):
    print(name, age, args, kwargs)

show("张三", '哈哈', '嘻嘻', a=1)
show("张三", '哈哈', '嘻嘻', age=20, a=1)
"""
张三 18 ('哈哈', '嘻嘻') {'a': 1}
张三 20 ('哈哈', '嘻嘻') {'a': 1}
"""

函数的注意事项

# 函数的注意事项： 1. 函数名不能相同， 2.变量名不能和函数名相同

设定必须关键字传参

# 定义必须参数使用关键字传参的函数, 注意点： *后面的参数必须使用关键字方式传参
def show(address, sex,*, name, age):
    print(address, sex)
    print("我叫:%s 年龄:%d" % (name, age))
    
# 使用位置参数传参
#show("刘八女", 38) 报错
# 使用关键字参数传参
#show(name="曹操", age=66) 报错

show("上海", '男', name="刘墉", age=92)

递归函数

import sys

# 递归函数： 在函数里面在调用函数本身就是递归函数
# # 必须要设置结束递归的条件及返回值
# 递归函数的特点: 1. 传递  2. 回归

# 5! = 5 * 4!
# 4! = 4 * 3!
# 3! = 3 * 2!
# 2! = 2 * 1!
# 1! = 1

def calc_num(num):
    # 当计算1的阶乘的时候不需要往下传递需要返回结果
    if num == 1: # 必须要设置结束递归的条件及返回值
        return 1
    else:
        return num * calc_num(num-1)

# 获取默认的递归次数
result = sys.getrecursionlimit()
print(result)

# 设置递归次数
sys.setrecursionlimit(1100)

result = sys.getrecursionlimit()
print(result)



result = calc_num(1000)
print(result)

# 注意点：1. 不能无限递归调用，默认是递归调用的次数1000，一般都是1000次所有

匿名函数

# 匿名函数： 顾名思义就是函数没有名字，使用lambda关键字定义的函数就是匿名函数
# 匿名函数只适合做一下简单的操作，返回值不需要加上return
result = (lambda x, y: x + y)(1, 2)
print(result)
# # 一般使用变量保持匿名函数
func = lambda x, y: x * y
result = func(1, 2)
print(result)

# # 判断是否是偶数
 def is_os(num):
     if num % 2 == 0:
         return True
     else:
         return False

 result = is_os(1)
 print(result)

# 匿名函数的应用场景，简化代码, 还可以使用简单的if判断
new_func = lambda num: True if num % 2 == 0 else False

result = new_func(1)
print(result)

# 对字典列表排序的时候还可以使用匿名函数
my_list = [{"name": "zs", "age": 20}, {"name": "ls", "age": 19}]
# item: 表示列中的每一项字典数据
# item["age"]: 根据字典中age对应的value值排序
# 默认是从小到大进行排序
# my_list.sort(key=lambda item: item["age"], reverse=True)
# print(my_list)

# 匿名函数也是函数

def get_value(item):
    return item["age"]

my_list.sort(key=get_value, reverse=True)
print(my_list)

# 倒着获取字符串中的每个数据
result = my_str[::-1]
print(result)