函数和enumerate枚举函数

函数一:

注意：

1、在调用函数时， 一旦其中一个参数采用了关键字参数形式传递 ，那么其后的所有参 数都必须采用关键字参数形式传递

2、Python 中可变参数有两种，即参数前加 ＊或＊＊ 形式，＊可变参数在函数中被组装成为一 个元组，＊＊可变参数在函数中被组装成为一个字典

3、＊一个星，可变参数不是最后一个参数时，后面的参数需要采用关键字参数形式传递。

4、** 两个星 可变 参数必须在 所有参数之后，其次是有默认值参数，再次是可变参数

# 加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数
# 如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例：
def printinfo(arg1, *vartuple):
    '''这是函数说明文档'''
    print("输出: ")
    print(arg1)
    print(vartuple)


print(printinfo.__doc__)  # 这是函数说明文档
printinfo(70, 60, 50)
printinfo(100)

'''
输出: 
70
(60, 50)
输出: 
100
()
'''
# -----------------------------------------------------------------------------------


# 加了两个星号 ** 的参数会以字典的形式导入。
def printinfo1(arg1, **vardict):
    print("输出: ")
    print(arg1)
    print(vardict)  # vardict是一个字典


printinfo1(1, a=2, b=3, c=4)  # 调用**的参数要用关键字传入
'''
输出: 
1
{'a': 2, 'b': 3, 'c': 4}
'''
# -----------------------------------------------------------------------------------


def printinfo2(name, *args, age=35):  # 默认参数在最后,
    "打印任何传入的字符串"
    print("名字: ", name)
    print("年龄: ", age)
    print(args)
    return name, age  # 函数可以返回多个值，多个值以元组tuple的方式返回:


printinfo2('tj', 1, 2, 3, age=42)  # age在不定长参数后面,所以要用关键字传递.
'''
名字:  tj
年龄:  42
(1, 2, 3)
'''
# -----------------------------------------------------------------------------------

# 匿名函数 只能有一行代码，必须返回值，省略return
g = lambda x, y: x ** 2 + y ** 2
print(g(2, 3))  # 13
# 同样地，lambda 匿名函数也可以设定默认值
g = lambda x=0, y=0: x ** 2 + y ** 2
# -----------------------------------------------------------------------------------


# 函数可以嵌套
def outer():
    x = 100

    def inner():
        print(x)

    inner()


outer()
# -----------------------------------------------------------------------------------

# 函数要修改全局变量的值需要用global加于引用.
a = 10


def sum():
    global a
    a = 11  # 如果没有global,那么此处其实是创建了一个局部变量a


sum()
print(a)  # 11
# -----------------------------------------------------------------------------------

a = 10


def sum(n):
    # n += a  这行代码会出错,因为下面有变量a,说明a是局部变量,并不是外面的全局变量,变量要先定义,后使用
    a = 11


sum(1)
# -----------------------------------------------------------------------------------


# 函数的装饰器  不要求掌握
def log(pr):  # 将被装饰函数传入
    def wrapper():
        print("**********")
        return pr()  # 执行被装饰的函数
    return wrapper  # 将装饰完之后的函数返回（返回的是函数名）
@log
def pr():
    print("我是小小洋")

pr()
# **********
# 我是小小洋
# -----------------------------------------------------------------------------------


# 在编写函数的过程中，可以显式指定函数的参数类型及返回值类型：
# 但是,不会强制执行,只是pycharm用色块给于友情提示
def function_demo(param_A: int,  param_B: float,  param_C: list,  param_D: tuple) -> dict:
    print(param_A)
    return False


print(function_demo("abc2222", "sdfdf", 222223, 4333333))

 

 二、函数参数的拆分

list 用一个* 拆分

dist用两个**拆分

lis = ['tangjun', 43]
dic = {'name': 'tangjun', 'age': 43}


def f(*l, **d):
    print(l, *l)
    print(d)
    # print(l, d)


f(*lis, **dic)  # 这里是重点

 

 

四、三大基础函数

# 三大基础函数
# 1、filter() 过滤
users = ['Tony ', 'Tom', 'Ben ', 'Alex']


def fun(args):
    return args.startswith('T')


# filter 位于buitins.模块，点击进去查看源代码就会发现它是一个迭代器(类）。
users_filter = filter(fun, users)

# 既然是迭代器，就可以用for in迭代出它的所有成员。
for u in users_filter:
    print(u)

# 既然是迭代器 就可以包装成list
# 这里需要重先创建对象，因为上面的user_filter已经迭代到最后了
users_filter = filter(fun, users)
l = list(users_filter)
print(l)  # ['Tony ', 'Tom']


# 上面的方法可以用推导式代替
users_filer = [item for item in users if item.startswith('T')]
print(users_filer)

# --------------------------------------------------------------------------------- 
# 2、map() 置换 
users_map = map(lambda u: u.lower(), users)
s = set(users_map)
print(s) # {'ben ', 'tom', 'alex', 'tony '} 

# 上面的方法可以用推导式代替
users_map = {item.lower() for item in users}
print(users_map)

# ---------------------------------------------------------------------------------


# 3、reduce 聚合

from functools import reduce


# 求1+2+3.....99的和
def fc(a, b):
    # print(a, b)
    # return a + b  # 求1+2+3.....99的和 # 4950
    # return max(a, b)  # 求1...99最大值 99
    return min(a, b)  # 求1...99最小值 0


sum = reduce(fc, range(100))
print(sum)

 五、enumerate函数

第二个参数start，索引默认从0开始，可以修改从１开始或者……

 

 # enumerate( ):
# 该类包含的一些方法
#  def __init__(self, iterable, start=0):  # known special case of enumerate.__init__
#  def __iter__(self, *args, **kwargs):
# def __next__(self, *args, **kwargs): # real signature unknown
seasons = ['Spring', 'Summer', 'Fall', 'Winter']

enum = enumerate(seasons)  # 从它包含的方法可以看出它是一个迭代器
print(enum)  # 注意：它是一个类，内置函数和类没什么本质区别
# 既然是迭代器，就可for in
for e in enum:
    print(e)

# (0, 'Spring')
# (1, 'Summer')
# (2, 'Fall')
# (3, 'Winter')

# 既然是迭代器，就可以包装成tuple list set dict
enum = enumerate(seasons)
dt = dict(enum)
print(dt)  # {0: 'Spring', 1: 'Summer', 2: 'Fall', 3: 'Winter'}

# 有什么用途：
# 在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到
for i, v in enumerate(['tic', 'tac', 'toe']):
    print(i, v)
    
# 0 tic
# 1 tac
# 2 toe

 六、

global 和 nonlocal关键字

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。

以下实例修改全局变量 num：

num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1()
print(num)

def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()

# 也可以通过函数参数传递：
a = 10
def test(a):
    a = a + 1
    print(a)
test(a)