函数基础之函数定义至函数的参数笔记

目录

• 函数的定义
• 定义函数的三种形式
  • 一、空函数
  • 二、有参函数
  • 三、无参函数
• 函数的调用
  • 函数的返回值
  • 有参函数
• 函数的参数
  • 例题：传10个数or列表进去，判断10个数or列表内元素的大小, 求最小值
  • 可变长参数
    • 一、可变长形参之*
    • 二、可变长实参之*

函数的定义

函数定义的特性: 函数定义过程，只检测语法，不执行代码

'''def  函数名  （等同于变量名）（）：
      """ 函数功能的描述"""
      代码块
       ...'''

print(函数名._doc_)可以打印出来函数功能的描述

def guess1():
    """给定两个数，打印较大的数"""
    x = 20
    y = 30
    if x > y:
        print(x)
print(guess1())
print(guess1.__doc__)

None
给定两个数，打印较大的数

定义函数的三种形式

一、空函数

def func():
    pass

以后写程序的时候要先用空函数写一个程序框架，再写函数内容如：

def func():
    pass


def register():
    pass

def login():
    pass

def shopping():
    pass

二、有参函数

# 有参函数
def guess1(x,y):
    """给定两个数，打印较大的数"""

    if x > y:
        print(x)
    else:
        print(y)

guess1(50,20)

50

三、无参函数

def guess2():
    """给定两个数，打印较大的数"""
    x = 30
    y = 20

    if x > y:
        print(x)
    else:
        print(y)
guess2()

30

函数的调用

函数的调用就是使用函数

guess1()# 函数名（）

print(函数名)得到函数名指向函数的内存地址，

函数的返回值

返回值：就是返回一个值，返回的值可以以函数名的方式赋值给变量，

return的特性：

1. 没有return返回none，如果没有返回值也返回none，print(函数名)得到函数名指向函数的内存地址。

   def guess1():
       """给定两个数，打印较大的数"""
       # return
       # print(1)
       x = 20
       y = 30
       if x > y:
           print(x)
   print(guess1())
   print(guess1)
   

   None

   <function guess1 at 0x00000208F3701EA0>

2. 返回一个返回值（所有数据类型）

3. return会终止函数，不运行下面的代码，假设有多个return时，运行到第一个就会结束，不会运行第二个。

   def guess1():
       """给定两个数，打印较大的数"""
       return
       print(1)
       x = 20
       y = 30
       if x > y:
           # print(x)
           return x
       else:
           # print(y)
           return y
   print(guess1())
   

   None

4. return通过逗号隔开，可以有多个返回值，返回值以元组的形式接收

   def guess1():
       """给定两个数，打印较大的数"""
   
       x = 20
       y = 30
       if x > y:
           # print(x)
           return x,y
       else:
           # print(y)
           return y,x
   print(guess1())
   

   (30, 20)

函数定义过程，只检测语法不执行代码

有参函数

有参的函数，可以通过往函数中传递参数得到希望的返回结果。

例如

# :后面规定是参数的数据类型,约定俗成的 ; ->后面规定的是返回值的数据类型，约定俗成的
def xianshiping(liangdu :int, duibidu:int) -> int:  # 形参
    """给定两个数，打印较大的数"""

    if liangdu == 0:
        print('黑屏')
        return 0

    if duibidu > 300:
        print('高清')
    else:
        print('4k画质')


xianshiping(1, 1000)  # 有参数，就必须得传参  # 实参

高清

函数的参数

形参：定义函数阶段的产物，具有接收实参的作用，具有描述意义

位置形参：从左到右依次接收实参的值。

默认形参：1、如果不给它传值，它就会使用默认值，如果调用的时候给它传值它就会使用默认值。2、默认形参必须放在位置形参后面。

实参：调用阶段的产物，传给形参一个具体的值，具有具体的值（可为所有数据类型）。

位置实参：从左到右依次给位置形参传值，一 一对应，形参有多少个，实参也必须有多少个。

关键字实参：1、位置实参必须写在关键字实参的前面。2、按照形参名给形参传值（使用情况，基本为0）函数的参数一般为0-3个，位置实参、关键字实参均可传值给默认形参和位置形参

def xianshiping(liangdu: int, duibidu: int = 150) -> int:  # 形参
    """给定两个数，打印较大的数"""#第一个为位置形参，第二个为默认形参

    if liangdu == 0:
        print('黑屏')
        return 0

    if duibidu > 299:
        print('高清')
    else:
        print('4k画质')

xianshiping(1)#此处位置实参只传值给了位置形参
xianshiping(1, 300)#此处位置实参传值给了位置形参和默认形参

4k画质

高清

def xianshiping(duibidu, liangdu, resolution_ratio, length, width):  # 形参
    """给定两个数，打印较大的数"""

    print(liangdu, duibidu, resolution_ratio, length, width)


xianshiping(1, 2, 3, 4, 5)#位置实参
xianshiping(5, liangdu=1, resolution_ratio=2, length=3, width=4)#位置实参、关键字实参

2 1 3 4 5
1 5 2 3 4

例题：传10个数or列表进去，判断10个数or列表内元素的大小, 求最小值

解法一

import random
'''产生一个有十个随机数字的列表'''
lt = [i * random.random() * 100 for i in range(1, 11)]
random.shuffle(lt)
print(lt)


def min_10(lt):#思路：先假定一个元素是最小值，然后用for循环和其他元素比较，如果有更小的值就用更小的值做最小值，一次对比。
    min_num = lt[0]
    for i in lt:
        if i < min_num:
            min_num = i
    print(min_num)

min_10(lt)

[357.97774156435185, 285.60871932623206, 165.85975724860756, 372.5521242876386, 52.64341234742332, 363.732152168682, 131.28241910234735, 179.79659653254961, 68.1211837254447, 266.05364719222325]
52.64341234742332

解法二

import random
'''产生一个有十个随机数字的列表'''
lt = [i * random.random() * 100 for i in range(1, 11)]
random.shuffle(lt)
print(lt)

def min_2(x, y):#两个数比较返回较小值
    if x > y:
        return y
    else:
        return x


def min_4(a, b, c, d):#四个数比较返回较小值
    res1 = min_2(a, b)
    res2 = min_2(c, d)
    return min_2(res1, res2)


def min_8(a, b, c, d, e, f, g, h):#八个数比较返回较小值
    res1 = min_4(a, b, c, d)
    res2 = min_4(e, f, g, h)
    return min_2(res1, res2)


def min_10(a, b=0, c=0, d=0, e=0, f=0, g=0, h=0, i=0, j=0):
    if str(a).startswith('['):#牛逼，竟然能抓住列表有中括号的特点去判断传过来的是数字还是列表，知识点使用的贼活
        a, b, c, d, e, f, g, h, i, j = a
        res1 = min_8(a, b, c, d, e, f, g, h)
        res2 = min_2(i, j)
        return min_2(res1, res2)
    else:
        res1 = min_8(a, b, c, d, e, f, g, h)
        res2 = min_2(i, j)
        return min_2(res1, res2)
res = min_10(lt)
print(res)

[28.556941131003466, 192.20648972103524, 24.314943623629137, 57.94512024495347, 266.90967628465285, 320.99843380065136, 7.59270680429438, 367.5753000504373, 229.6700789109444, 721.9425970703763]
7.59270680429438

解法三

import random
'''产生一个有十个随机数字的列表'''
lt = [i * random.random() * 100 for i in range(1, 11)]
random.shuffle(lt)
print(lt)


for i in range(len(lt)):
    for j in range(len(lt)):
        if lt[i]<lt[j]:
            lt[i],lt[j] = lt[j],lt[i]
print(lt[0])#先排序，然后选出最小的

[60.949066784670606, 119.20663454087268, 546.0087969234381, 153.2821497836315, 48.74967848355873, 221.11327860510306, 208.46011833902242, 428.2476064845898, 14.110065198471666, 556.1645865395742]
14.110065198471666

个人评价：个人认为如果比较的数不多的情况下可以使用解法二，解法二判断列表的方法值得学习，要抓住要判断事物的一切特征。在数据比较多的情况下第一种方法好一些，第三种方法虽然也得出了答案但是没必要把所有的元素的大小顺序都排出来，因为我们要的只有最小值。

可变长参数

指的是在调用函数时，传入的参数个数可以不固定

调用函数时，传值的方式无非两种，一种是位置实参，另一种是关键字实参，因此形参也必须得有两种解决方法，以此来分别接收溢出的位置实参(*)与关键字实参(**)

一、可变长形参之*

形参中的*会将溢出的位置实参全部接收，然后存储元组的形式，然后把元组赋值给*后的参数。需要注意的是：*后的参数名约定俗成为args。

def min_2(x, y):
    if x > y:
        return y
    else:
        return x


def min_4(a, b, c, d):
    res1 = min_2(a, b)
    res2 = min_2(c, d)
    return min_2(res1, res2)


def min_8(a, b, c, d, e, f, g, h):
    res1 = min_4(a, b, c, d)
    res2 = min_4(e, f, g, h)
    return min_2(res1, res2)


def min_10(a, b, c, *lt):  # *lt，把所有传过来的实参全部接收，并且以元组的形式存储
    print(lt)
    a, b, c, d, e, f, g, h, i, j, *_ = lt
    print(_)
    res1 = min_8(a, b, c, d, e, f, g, h)
    res2 = min_2(i, j)
    return min_2(res1, res2)


res = min_10(1, 2, 3, 4, 5, 6, 7, -1, 9, 10, 11, 12, 13, 1, 1, 1, 1, 1, 1, 1, 11,
             1, )  # *,相当于做了解压缩，也就是把lt内的元素一个一个取出来传给形参
print(res)

(4, 5, 6, 7, -1, 9, 10, 11, 12, 13, 1, 1, 1, 1, 1, 1, 1, 11, 1)
[1, 1, 1, 1, 1, 1, 1, 11, 1]
-1

二、可变长实参之*

实参中的*，*会将*后参数的值循环取出，打散成位置实参。以后但凡碰到实参中带*的，它就是位置实参，应该马上打散成位置实参去看。

def min_2(x, y):
    if x > y:
        return y
    else:
        return x


def min_4(a, b, c, d):
    res1 = min_2(a, b)
    res2 = min_2(c, d)
    return min_2(res1, res2)


def min_8(a, b, c, d, e, f, g, h):
    res1 = min_4(a, b, c, d)
    res2 = min_4(e, f, g, h)
    return min_2(res1, res2)


def min_10(a, b, c, d, e, f, g, h, i, j):
    print(a, b, c, d, e, f, g, h, i, j)
    res1 = min_8(a, b, c, d, e, f, g, h)
    res2 = min_2(i, j)
    return min_2(res1, res2)


lt = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
res = min_10(*lt)  # *,相当于做了解压缩，也就是把lt内的元素一个一个取出来传给形参
print(res)

1 2 3 4 5 6 7 8 9 10
1