学习内容：

在函数内部可以通过关键字 global 来定义全局变量。
如果函数中没有return语句或者return语句不带任何返回值，那么该函数返回值为 None 。
包含 yield 语句的函数可以用来创建生成器。
调用带有默认值参数的函数时，不能为默认值参数传递任何值，必须使用函数定义时设置的默认值（错）。
Lambda表达式只能用来创建匿名函数，不能为这样的函数起名字（错）

学习内容：编写函数，判断一个整数是否为素数，并编写主程序调用该函数。

编写函数，判断一个整数是否为素数，并编写主程序调用该函数。

def Prime_numer(s):
    if s < 2:
        return True
    else:
        for i in range(2, s):
            if s % i == 0:
                print("不是素数")
                break
            else:
                print("是素数")
                break


if __name__ == '__main__':
    a = int(input("请输入一个整数："))
    Prime_numer(a)

运行结果截图：

学习内容：编写函数，接收一个字符串，分别统计大写字母、小写字母、数字、其他字符的个数，并以元组的形式返回结果。

编写函数，接收一个字符串，分别统计大写字母、小写字母、数字、其他字符的个数，并以元组的形式返回结果。

def chack(x):
    a = [0, 0, 0, 0]
    for i in x:
        if 'A' <= i <= 'Z':
            a[0] += 1
        elif 'a' <= i <= 'z':
            a[1] += 1
        elif '0' <= i <= '9':
            a[2] += 1
        else:
            a[3] += 1
    return a


if __name__ == '__main__':
    x = input("请输入一个字符串：")
    y = tuple(chack(x))
    print("大写字母、小写字母、数字、其他字符的个数分别为：")
    print(y)

第二种方法：

from string import ascii_letters, digits


def check(s):
    result = [0, 0, 0, 0]
    for i in s:
        if i in ascii_letters[26:]:
            result[0] = result[0] + 1
        elif i in ascii_letters[:26]:
            result[1] = result[1] + 1
        elif i in digits:
            result[2] = result[2] + 1
        else:
            result[3] = result[3] + 1
    return tuple(result)


if __name__ == '__main__':
    a = input("请输入字符串：")
    txt = '''大写字母：{}个\n小写字母：{}个\n数字：{}个\n其他：{}个'''.format(*check(a))
    print(txt)

运行结果示例：

学习内容：编写函数，可以接收任意多个整数并输出其中的最大值和所有整数之和。

编写函数，可以接收任意多个整数并输出其中的最大值和所有整数之和。

def Max_Number_Count(*a):
    print("最大值：", max(a))
    print("和为：", sum(a))


if __name__ == '__main__':
    Max_Number_Count(1, 2, 3, 4, 5,)
    Max_Number_Count(1, 2, 3, 4, 5, 6, 7, 8,)

运行结果示例：

学习内容：编写函数，模拟内置函数sum()。

编写函数，模拟内置函数sum()。

def Lhb_sum(a, start=0):
    b = start
    for i in a:
        b = b + i
    return b


if __name__ == '__main__':
    c = Lhb_sum([1, 2, 3, 4, 5])
    print(c)

运行结果示例：

学习内容：编写函数，模拟内置函数sorted()。

编写函数，模拟内置函数sorted()。

def Lhb_sorted(a):
    temp = a[:]
    result = []
    while temp:
        u = min(temp)
        result.append(u)
        temp.remove(u)
    return result  # 利用min函数来判断大小


if __name__ == '__main__':
    c = Lhb_sorted([1, 7, 3, 8, 5])
    print(c)

运行结果示例：

学习内容：编写函数，模拟内置函数map()。

编写函数，模拟内置函数map()。

def Lhb_map(a, b):
    assert callable(a)
    for i in b:
        yield a(i)


if __name__ == '__main__':
    for i in Lhb_map(len, ['11', '555', '6668']):
        print(i)

运行结果示例：

学习内容：编写函数，模拟内置函数filter()。

编写函数，模拟内置函数filter()。

def Lhb_filter(a, b):
    if a is None:
        a = bool
    for i in b:
        if a(i):
            yield i


if __name__ == '__main__':
    print(list(Lhb_filter(lambda x:x>0, range(-10, 4))))

运行结果示例：