day 9

最新推荐文章于 2022-02-20 21:06:01 发布

你先等一下

最新推荐文章于 2022-02-20 21:06:01 发布

阅读量108

点赞数

分类专栏： Python笔记

Python笔记专栏收录该内容

13 篇文章 0 订阅

订阅专栏

day09
函数 function
什么是函数:
函数是可以重复执行的语句块，可以重复调用。
作用：

用于封装可重复执行的语句，提高语句的可重用性
定义用户级别的函数

函数定义语句 def语句的语法:
def 函数名(参数列表):
语句块(代码块)

函数的语法说明：

函数的名字就是语句块的名称
函数名的命名规则与变量名命名规则相同（必须为标识符)
函数名是一个变量（不要轻易对其赋值）
函数的自己的命字空间，在函数内部可以访问外部的变量，但外部的语句不能访问函数内部的变量
函数如果不需要传入参数，则参数列表可以为空
语句部分不能为空，如果为空需要填充pass语句

示例1:
def say_hello():
print(“hello world!”)
print(“hello tarena!”)
print(“hello everyone!”)

函数调用:
函数名(实际调用传递参数)
注:
实际调用传递参数简称"实参"
调用说明：
1. 函数调用是一个表达式
2. 如果没有return语句，函数执行完比后返回None对象
3. 如果函数需要返回其它的对象，需要用到return语句

# 此示例示意定义一个带有参数的函数:
def mymax(a, b):
    if a > b:
        print("最大数是", a)
    else:
        print("最大数是", b)

# 调用带有参数的函数, 第一个实参100给形参a, 第二个...

mymax(100, 200)
mymax(10000, 5000)  # 最大数是10000
mymax(4 + 7, 5 + 5)  # 最大数是11
mymax("ACD", "ABCD")  # 最大数是 ACD

练习1:
写一个函数mysum, 此函数带有两个参数x, y.
此函数功能是打印出两个参数x,y的和, 即 x + y

def my_sum(x, y):
    a = x + y
    print(a)
    
my_sum(100, 200)

练习2:
写一个函数print_even, 传入一个数参n代表终止整数(不包含n)
打印:
2 4 6 … n之间所有偶数:
def print_even(n):
for i in range(0, n, 2):
print(i, end=’ ')

print_even(55)
结果：
0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54

函数内部有独立的运行空间,函数外部不能访问函数内的变量

  # function_variable.py
def test():
    x = 100  # 此变量是局部变量,只能在函数内部使用
    print(y)  # 这是合法的,此函数可以访问函数以外的全局变量

y = 200
test()  # 调用test

# print(x)  # 此时没有x这个变量, 出错

return 语句:
语法:
return [表达式]
注: []代表其中的内容可以省略

作用:
用于函数中,结束当前函数的执行,返回到调用函数的地方,同时返回一个对象的引用关系
说明:
1. return语句后跟的表达式可以省略,省略后相当于return None
2. 如果函数内没有return语句,则函数执行完最后一条语句后返回None(相当于在最后加了一条return None语句)
3. 函数调用能够返回一个对象的引用
# 此示例示意return语句的用法

def hello():
    print("hello aaa")
    print("hello bbb")
    return [2, 3, 5, 7]  # 用于返回到调用的地方
    print("hello ccc")
v = hello()
print('v绑定', v)
结果：
hello aaa
hello bbb
v绑定 [2, 3, 5, 7]

练习:

写一个函数mymax, 返回两个数的最大值
如:
def mymax2(a, b):
…
print(mymax(100, 200)) # 200
print(mymax(“ACD”, “ABCD”)) # ACD

# 方法1
# def mymax2(a, b):
#     if a > b:
#         s = a
#     else:
#         s = b
#     return s
# 方法2
def mymax2(a, b):
    if a > b:
        return a
    else:
        return b

print(mymax2(100, 200))  # 200
print(mymax2("ACD", "ABCD"))  # ACD
结果：
200
ACD

写一个函数input_number() 此函数用于读取用户输入的多个整数(用户输入负数时结束输入)
将用户输入的数形成列表返回给调用者
def input_number():
… # 此处自己完成

L = input_number()
print(“您输入的最大数是:”, max(L))
print(“您输入的这些数的和是:”, sum(L))

# 方法一
def input_number():
    L = []
    while True:
        number = int(input("请输入一个整数（输入负数结束输入）："))
        if number < 0:
            break
        else:
            L.append(number)
    return L
# 方法2
# def input_number():
#     lst = []  # 临时列表用于存储 用户输入的数据
#     while True:
#         i = int(input("请输入正整数: "))
#         if i < 0:
#             break
#         # 如果i为大于等于0的数,把i放入列表
#         lst.append(i)
#     return lst
L = input_number()
print("您输入的最大数是:", max(L))
print("您输入的这些数的和是:", sum(L))

python函数的参数传递
传递方式:
位置传参
序列传参
关键字传参
字典关键字传参

位置传参:
实际调用参数(实参) 的对应关系与形式参数(形参)的对应关系是按位置来依次对应的

示意:
def fx(a, b, c):
pass
# ^ ^ ^
fx( 1, 2, 3)

序列传参:
序列传参是批在函数调用过程中,用 * 将序列拆解后按位置进行传递的传参方式
实参和形参通过序列传递和匹配

示例:

  def fx(a, b, c):
      pass
  s1 = [11, 22, 33]  # 列表
  fx(*s1)  # 将s1序列拆解后按位置传入fx中

关键字传参
是指传参时,按着形参的名称给形参赋值
实参和形参按名称进行匹配

示例:

def fx(a, b, c):
pass
fx(b=22, c=33, a=11) # 11->a, 22->b, 33->c

注:
实参和形参按形参名进行匹配,可以不按位置进行匹配

字典关键字传参:
实参为字典,用**拆解字典后再进行关键字传参

示例:
def fx(a, b, c):
pass
d = {‘c’: 33, ‘b’: 22, ‘a’: 11}
fx(**d) # 拆解字内再依次按关键字传参

说明:
字典的键名和形参名必须一致
字典的键名必须为字符串
字典的键名要在形参中存在

综合传参:
函数的传参方式在能确定形参能唯一匹配到相应实参的情况下可以任意组合
注:
通常位置传参和序列传参先传递,其次是关键字传参和字典关键字传参
示例:

def fx(a, b, c, d, e, f):
    pass
fx(10, *[20, 30], e=50, **{'d':40, 'f':60}) 
# 以下是错误做法
fx(e=50, **{'d':40, 'f':60}, 10, *[20, 30])

########## 以下讲函数的形参 ##########
函数的缺省参数
语法:
def 函数名(形参名1=默认实参1, 形参名2=默认实参2, …):
语句

示例:

def info(name, age=1, address="不详"):
    print("我叫", name, '我今年:', age, '岁, 家庭住址:', address)

info("张飞", 30, "中原")    
info("Tarena", 10)
info("赵云")

说明:
缺省参数必须自右至左依次存在（非缺省的需放在缺省的前边）
缺省参数可以有0个,1个,多个,甚至全部都有缺省参数
缺省参数的绑定对象存在于函数内,同函数的生命周期一致

示例:

def fn(a, lst=[]):
    lst.append(a)
    print(lst)

L = [1,2,3,4]
fn(5, L)

fn(1.1)
fn(2.2)

函数的形参定义方式:

位置形参
星号元组形参 (*args)
命名关键字形参
双星号字典形参

位置形参:
def 函数名(形参名1, 形参名2, …):
语句块

星号元组形参:
语法:
def 函数名(*元组形参名):
语句块
作用:
收集多余的位置传参

 # 此示例示意 星号元组形参
def func(*args):
    print("实参个数是:", len(args))
    print("args的值是:", args)

func(1, 2, 3)
func("ABCD", 3.14, 100, True, None)
结果：
实参个数是: 3
args的值是: (1, 2, 3)
实参个数是: 5

args的值是: ('ABCD', 3.14, 100, True, None)

命名关键字形参
语法:
def 函数名(*, 命名关键字形参):
语句块
或
def 函数名(*args, 命名关键字形参):
语句块
作用:
所有的命名关键字形参都强制调用者采用关键字传参或字典关键字传参的方式传递

def myfun(a, *, k):
    print('a =', a)
    print('k =', k)
# myfun(100, 200) # 错误
myfun(100, k=200)  # k强制使用关键字传参
myfun(10, **{'k': 20})  # 字典关键字传参

print('===================')

def myfun2(b, *args, c, d):
    print("b=", b)
    print("args=", args)
    print("c=", c)
    print("d=", d)

myfun2(100, 200, 300, 400, d=600, c=500)
结果：
a = 100
k = 200
a = 10
k = 20
===================
b= 100
args= (200, 300, 400)
c= 500

d= 600

双星号字典形参:
语法:
def 函数名(**字典形参名):
语句块
作用:
收集多余的关键字传参
注:
字典形参名通常叫 kwargs

此示例示意双星号字典形参的用法:

def func(**kwargs):
    print("关键字传参的个数是:", len(kwargs))
    print("kwargs=", kwargs)

func(name=‘tarena’, age=15)
func(a=1, b=“BBBB”, c=[2, 3, 4], d=True)
结果：
关键字传参的个数是: 2
kwargs= {‘name’: ‘tarena’, ‘age’: 15}
关键字传参的个数是: 4
kwargs= {‘a’: 1, ‘b’: ‘BBBB’, ‘c’: [2, 3, 4], ‘d’: True}
函数参数说明:
位置形参,缺省参数,星号元组形参,命名关键字形参,双星号字典形参可以混合使用
函数参数自左至右的顺序为:

位置形参
星号元组形参
命名关键字形参
双星号字典形参
示例:
def fn(a, b, args, c, **kwargs):
pass
fn(100, 200, 300, 400,“AB”, **{‘d’:“D”}, c=100)
fn(100, 200, 300, 400,*“AB”, **{‘d’:“D”, “c”:“C”}, e=100)

可以接收任意位置传参和关键字传参的函数:

def fn(*args, **kwargs):
psss
练习:

写一个函数,mysum,可以传入任意个实参的数字,返回所有实参的和

def mysum(*args):
    return sum(args)
print(mysum(1, 2, 3, 4))  # 10
print(mysum(5, 6, 7, 8, 9))  # 35

已知内建函数 max的帮助文档为:
max(…)
max(iterable) -> value
max(arg1, arg2, *args) -> value
访造max,写一个mymax函数,实现功能与max完全相同
测试用例:
print(mymax([6,8,3,5])) # 8
print(mymax(100, 200)) # 200
print(mymax(1,3,9,7,5)) # 9

def mymax(*args):
    T = (args)
    a = len(T)
    for i in T:
        for j in T:
            if j != T[a-1]:
                if i >= j:
                    continue
                else:
                    break
            else:
                if i > T[a-1]:
                    return i
                else:
                    return T[a-1]

print(mymax(1, 2, 6, 88, 99, 756, 75))
print(mymax(6, 8, 3, 5))  # 8
print(mymax(100, 200))   # 200
print(mymax(1, 3, 9, 7, 5))  # 9



   # 2. 已知内建函数 max的帮助文档为:
    #   max(...)
    #      max(iterable) -> value
    #      max(arg1, arg2, *args) -> value
    #   访造max,写一个mymax函数,实现功能与max完全相同
    # 测试用例:
    #   print(mymax([6,8,3,5]))  # 8
    #   print(mymax(100, 200))   # 200
    #   print(mymax(1,3,9,7,5))  # 9

# 方法1
# def mymax(*args):
#     if len(args) == 1:
#         L = list(*args)  # 放到一个列表里
#         L.sort(reverse=True)
#         return L[0]
#     elif len(args) >= 2:
#         L = list(args)
#         L.sort(reverse=True)
#         return L[0]


# 方法2
# def mymax(a, *args):
#     if len(args) == 0:
#         # return max(a)
#         m = a[0]  # 先假设第一个数最大
#         i = 1
#         while i < len(a): # 遍历之后的每一个元素
#             if a[i] > m:  # 如果此元素比m大,则让m绑定大的一个
#                 m = a[i]
#             i += 1
#         return m  # 最后m一定绑定一个最大的
#     else:
#         m = a
#         for x in args:
#             if x > m:
#                 m = x
#         return m

# 方法3
def mymax(a, *args):
    def _max(*args):
        # 此函数用于求args元组的最大值
        m = args[0]  # 先假设第一个数最大
        i = 1
        while i < len(args):  # 遍历之后的每一个元素
            if args[i] > m:  # 如果此元素比m大,则让m绑定大的一个
                m = args[i]
            i += 1
        return m  # 最后m一定绑定一个最大的

    if len(args) == 0:
         return _max(*a)
    return _max(a, *args)


print(mymax([6, 8, 3, 5]))  # 8
print(mymax(100, 200))   # 200
print(mymax(1, 3, 9, 7, 5))  # 9

写一个函数minmax, 可以给出任意个数字实参,返回这些实参的最小数和最大数,
要求两个数字形成元组后返回(最小数在前,最大数在后)
调用此函数,能得到实参的最小值和最大值
def minmax(…):
…

xiao, da = minmax(5,7,9,3,1)
print("最小数是:", xiao)
print("最大数是:", da)

你先等一下

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day 9

day09函数 function什么是函数:函数是可以重复执行的语句块，可以重复调用。作用：用于封装可重复执行的语句，提高语句的可重用性定义用户级别的函数函数定义语句 def语句的语法:def 函数名(参数列表):语句块(代码块)函数的语法说明：函数的名字就是语句块的名称函数名的命名规则与变量名命名规则相同（必须为标识符)函数名是一个变量（不要轻易对其赋值）函数的...
复制链接

扫一扫