第十一天函数

第十一天函数

函数的作用

def download():
	print('=========下载数据=========')
	print('检测网络状态')
	print('连接服务器')
	print('传输数据')
	print('接受数据')
	print('保存数据')
download()

nums1 = [12, 89, 90, 2, 61]
# max1 = nums1[0]
# for x in nums1[1:]:
#     if x > max1:
#         max1 = x
# print(max1)
print(max(nums1))

nums2 = (12, 89, 90, 2, 61, 200, 67)
# max1 = nums2[0]
# for x in nums2[1:]:
#     if x > max1:
#         max1 = x
# print(max1)
print(max(nums2))

函数的概念

'''
函数就是实现某一特定功能的代码的封装   -  不同的函数有不一样的功能
'''

def sumx(N):
    sum1 = 0
    for x in range(1, N+1):
        sum1 += x
    print(sum1)


sumx(100)
sumx(50)

函数的分类

'''
根据函数是由谁定义的（创建的）将函数分为：系统函数、自定义函数
1）系统函数   - 系统自带的函数（创建Python语言的人创建好的函数）（别人造好的机器），例如：，max、min、sum、print、type、input、...
2）自定义函数     - 由程序员自己创建的函数

'''

定义函数（创造函数）

'''
语法：
def 函数名（形参列表）：
	函数说明文档
	函数体
	
说明：
def       -  关键字：固定写法
函数名     -  有程序员自己命名；
				要求：标识符、不是关键字
				规范：见名知义、所有字母都小写，多个单词之间用下划线隔开、不适用系统的函数名、					类名和模块名
（）       -    固定写法
形参列表      -      以 '变量名1, 变量名2, 变量名3,...' 的形式存在，这儿的一个变量代表一个形参（也可以一个形参都没有）；
                    形参可以将函数外部的数据传递到函数里面。
                    定义函数的时候需不需要形参就看实现函数的功能需不需要额外的数据。
函数说明文档   -      本质就是多行注释（相当于机器的说明书）
函数体        -      和def保持一个缩进的一条或者多条语句；
                    函数体就是实现函数功能的代码。


'''

初学者定义函数的基本步骤

"""
第一步：确定函数功能
第二步：根据函数功能确定函数名字
第三步：确定参数（看实现函数的功能需不需要额外的数据，需要几个?）
第四步：实现函数功能（将形参当成数据来使用）
第五步：写函数说明文档
"""

def factorial_10():
    """
    （功能说明）求10!
    :return: (返回值说明区) None
    """
    sum1 = 1
    for x in range(1, 11):
        sum1 *= x
    print(sum1)

# 练习：定义一个函数求任意一个数的阶乘
def factorial(num):
    """
    求一个数的阶乘
    :param num: (参数说明)需要求阶乘的数
    :return: None
    """
    sum1 = 1
    for x in range(1, num+1):
        sum1 *= x
    print(sum1)

factorial(5)

# 定义一个函数求任意两个数的和
def sum_yt(num1, num2):
    """求任意两个数的和"""
    print(num1 + num2)


sum_yt(10, 20)
sum_yt(11, 22)


# 练习1： 定义一个函数统计字符串中中文的个数
def count_chinese(str1):
    """统计字符串中中文的个数"""
    count = 0
    for x in str1:
        if '\u4e00' <= x <= '\u9fa5':
            count += 1
    print(f'中文个数:{count}')



count_chinese('hsjsf试试l-s=sJs开始')
count_chinese('sfh 江苏省')


# 练习2：写一个函数，提取列表中所有的数字元素
def get_nums(list1):
    """提取列表中所有的数字元素"""
    result = [x for x in list1 if type(x) in (int, float)]
    print(result)


# 练习3：写一个函数，获取指定字典中所有的值
def get_values(dic):
    """获取指定字典中所有的值"""
    result = [dic[key] for key in dic]
    print(result)


# 练习4：写一个函数统计一个字符串中另外一个字符串出现的次数
# 'mnabc123abc-293abcp'  'abc'
def count_str(str1, str2):
    count = 0
    index = 0
    length = len(str2)
    while index < len(str1):
        if str1[index: index+3] == str2:
            count += 1
            index += length
        else:
            index += 1
    print(count)


# 练习5：写一个函数将两个列表合并成一个字典（第一个列表的元素是键，第二个列表的元素是值）
def create_dict(list_key, list_value):
    """
    将两个列表合并成一个字典。
    注意：两个列表的长度必须一致，第一个列表的元素必须是不可变的数据
    :param list_key: 提供键
    :param list_value: 提供值
    :return: None
    """
    length = len(list_key)
    result = {list_key[index]: list_value[index] for index in range(length)}
    print(result)


# 5. 调用函数
# 求10的阶乘
factorial_10()

# 求5的阶乘
factorial(5)

# 求7的阶乘
factorial(7)

调用函数

"""
语法：
函数名(实参列表)

说明：
函数名     -    需要调用的函数的函数名（必须是已经定义过的函数的函数名）
()        -    固定写法
实参列表   -     以 '数据1, 数据2, 数据3,...' 的形式存在
                实参是用来给形参赋值，实参是真正从函数外部传递到函数内部的数据
                
注意：同一个函数可以在需要它的功能的是反复调用
"""

函数调用过程

"""
1）定义函数不会执行函数体，调用函数的时候才会执行函数体
2）执行过程
第一步：回到函数定义的位置
第二步：传参（用实参给形参赋值）
第三步：执行函数体
第四步：确定函数返回值
第五步：回到函数调用的位置，接着往后执行
"""


def func1(x):
    # x = 10
    print('===============')
    print('++++++++++++++++')
    # print('abc'[10])


print('------------------华丽的分隔线-----------------')
func1(10)
print('end')

位置参数和关键字参数 -实参

"""
1）位置参数
以 '数据1, 数据2, 数据3,...' 的形式存在，让实参和形参从位置上一一对应
（第一个实参给第一个形参赋值，第二实参给第二个形参赋值，...）

2）关键字参数
以 '形参1=实参1, 形参2=实参2,...'的形式存在

3）混用
如果位置参数和关键字参数一起用，那么位置参数必须在关键字参数的前面
"""


def func1(x, y, z):
    print(f'x:{x}, y:{y}, z:{z}')


# 位置参数
func1(10, 20, 30)
func1(20, 10, 30)

# 关键字参数
func1(x=100, y=200, z=300)
func1(y=200, z=300, x=100)

# 位置参数和关键字参数一起用
func1(10, y=20, z=30)
func1(10, z=30, y=20)
func1(10, 20, z=30)
# func1(x=10, 20, z=30)     # SyntaxError: positional argument follows keyword argument

默认参数值 -形参

"""
定义函数的时候可以用 '形参=值' 的方式给参数赋默认值；
调用函数的时候有默认值的参数可以不用传参。

如果定义函数的时候有的参数有默认值，有的参数没有默认值，没有默认值的参数必须在有默认值参数的前面
"""


def func2(x=10, y=20, z=30):
    """func2"""
    print(f'x:{x}, y:{y}, z:{z}')


func2()
func2(100)
func2(100, 200)
func2(100, 200, 300)
func2(y=200)
func2(z=300)


def func3(x, y=20, z=30):
    print(f'x:{x}, y:{y}, z:{z}')


# def func4(x=10, y=20, z):             # SyntaxError: non-default argument follows default argument
#     print(f'x:{x}, y:{y}, z:{z}')

# def func4(x=10, y, z):             # SyntaxError: non-default argument follows default argument
#     print(f'x:{x}, y:{y}, z:{z}')

# 3. 参数类型说明     -   形参
"""
情况1：没有默认值的参数，在参数后加 ':类型名'
情况2：有默认值的参数，值的类型就是参数的说明类型
"""


def func5(str1: str, list1=[]):
    pass


# 4. *不定长参数 (了解)     -   形参
"""
1）带*的不定长参数
在定义函数的时候可以在某个参数前加*，那么这个带*的参数就是一个不定长参数，可以同时接收多个实参。
带*的参数会自动变成一个元组，接收到实参是元组中的元素。
调用的时候带*的不定长参数必须用位置参数传参

2）带**的不定长参数（了解）
"""


def func6(*x):
    print(x)


func6()
func6(10)
func6(10, 20)
func6(10, 20, 30, 40, 50)


# 思考：一个函数可不可以既有不定长参数又参数？如果可以有没有什么问题存在（需要注意的地方）？
# 定长在不定长前面，都使用位置参数
def func7(x, *y):
    print(f'x:{x}, y:{y}')


func7(10, 20, 30, 40)


# 定长在不定长后面，定长必须使用关键字参数
def func7(*x, y):
    print(f'x:{x}, y:{y}')


func7(10, 20, 30, 40, y=50)


# 这儿*的作用只是强迫调用func8的时候，b和c必须使用关键字参数传参
def func8(a, *, b, c):
    pass


# 练习：定义一个参数可以求多个数的和
# sum1(10, 20)
# sum1(10, 20, 30)
# sum1(90, 8, 78, 27, 17)


def func9(**x):
    print(f'x:{x}')


func9()         # {}
func9(a=10)     # {'a': 10}
func9(m=100, n=200)     # {'m': 100, 'n': 200}
func9(name='余婷', age=19)        # {'name': '余婷', 'age': 19}
func9(name='小明', age=20, gender='男', hobby='篮球')    # {'name': '小明', 'age': 20, 'gender': '男', 'hobby': '篮球'}


# 保证func10调用的时候足够灵活
def func10(*args, **kwargs):
    pass


func10()
func10(10, 20)
func10(a=10, b=23)
func10(10, 20, x=10, y=23)

返回值

"""
1）返回值的意义
返回值就是从函数内部传递到函数外部的数据

2）怎么确定函数返回值
返回值就是return关键字后面的表达式值(执行函数体的是如果遇到return，return后面是什么，函数返回值就是什么)
如果没有遇到return，返回值None

3）怎么在函数外部使用函数返回值
函数调用表达式的值就是函数的返回值，所以返回值能做的事情，函数调用表达式都可以做
函数调用表达式  - 调用函数的语句
"""

def func1():
    print('abc')
    return 100


result = 100
result = func1()    # 100
print(f'result: {result}')

print(100, func1())

print(100 * 2, func1()*2)

list1 = [100, func1(), 200]
print(list1)


def func2(x: str):
    # x = 'abc'
    return x*2      # return 'abc'*2  -> return 'abcabc'


func2('abc')        # 'abcabc'
print(func2('abc')[-1])    # 'abcabc'[-1] -> 'c'
# print('abcabc'[-1])


def func3():
    return [10, 20]


result = func3()        # result = [10, 20]
result.append(100)
print(result)

return的作用

"""
作用1：确定函数返回值
作用2：提前结束函数 -  如果执行函数体的时候遇到return，函数直接结束
"""

def func4(num):
    print('+++')
    if num == 0:
        return 0
    print('----')
    print('====')
    return 100


result = func4(0)
print(result)