day11-函数作业

最新推荐文章于 2025-05-13 16:43:49 发布

qq_39547531

最新推荐文章于 2025-05-13 16:43:49 发布

阅读量197

点赞数

分类专栏： python 文章标签： python

本文链接：https://blog.youkuaiyun.com/qq_39547531/article/details/123201585

版权

python 专栏收录该内容

23 篇文章

订阅专栏

本文详细介绍了Python函数的基础知识，包括定义、调用、参数类型、返回值等，并提供了多个函数实现示例，如交换字典键值、提取字母、首字母大写、判断字符串结尾、检查纯数字、转换大小写、右对齐填充、查找元素下标、统计元素个数、求序列最大值、检查元素存在性及替换字符串等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

day11函数基础学习与总结

函数的概念:
1. 函数就是实现某一特定功能的代码的封装 -> 一个函数对应一个功能（函数存储的功能）
2. a. 系统函数 - 有Python语言已经创建好的函数(Python自带的函数)，例如：print、input、type、id、max、min、sorted、sum等
  b. 自定义函数 - 由程序员自己创建的函数
3. 定义函数
  1. 语法:
    def 函数名(形参列表):
    函数说明文档
    函数体
  2. 说明：
    def - 关键字；固定写法
    函数名 - 由程序员自己命名；
    要求：是标识符，不能是关键字
    范围：见名知义(看到函数名就大概知道函数的功能是什么)、
    不使用系统的函数名、类名、模块名、
    字母都小写，多个单词用下划线隔开
    (): - 固定写法
    形参列表 - 以’变量名1, 变量名2, 变量名3,…'的形式存在，这儿每一个变量就是一个形参；形参可以一个都没有，也可以有多个。
    形参可以将函数外部的数据传递到函数内部；
    定义函数的时候需不需要形参需要几个看实现函数的功能需不需要额外的数据，需要几个
    函数说明文档 - 本质就是和def保持一个缩进多行注释；用来对函数的功能、参数和返回值进行说明的（说明书）
    函数体 - 和def保持一个缩进的一条或者多条语句，本质就是实现函数功能的代码。（电路结构和机械机构）
4. 调用函数
  1. 1）重要结论：定义函数的时候不会执行函数，调用的时候才会执行
  2. 2）语法：
    函数名(实参列表)
    说明：
    函数名 - 需要哪个函数的功能就调用哪个函数，想要调用哪个函数就写哪个函数的函数名
    注意：这儿的函数名必须是已经定义过的函数的函数名
    () - 固定写法
    实参列表 - 以 ‘数据1, 数据2, 数据3,…’ 的形式存在；实参就是真正通过形参传递到函数内部的数据
    实参的个数由形参决定，默认情况被调用的函数有多少个形参调用的时候就需要多少个实参
  3. 函数调用过程
  4. 当代码执行到函数调用语句的时候：
    第一步：回到函数定义的位置
    第二步：传参(用实参给形参赋值的过程)，传参的时候必须保证每个形参都有值
    第三步：执行函数体
    第四步：确定返回值
    第五步：回到函数调用的位置，接着往后执行
5. 函数的参数
  1. 1. 位置参数
      调用函数的时候直接将多个数据用逗号隔开，实参和形参从位置上一一对应
    2. 关键字参数
      调用函数的时候，在数据前面加上’形参名=’，实参和形参由形参名来对应
      3）两种参数混合用
      要求必须保证位置参数在关键字参数的前面
  2. 参数默认值
    1. 定义函数的时候可以给形参赋默认值，调用函数的时候已经有默认的参数可以不用传参，直接使用默认值。
    2. 如果是给部分参数赋默认值，必须保证没有默认值的参数在有默认值参数的前面
  3. 参数类型说明
    1. 1）没有默认值的参数添加类型说明
      形参名:数据类型
      2）有默认值的参数，默认值的类型就是参数的类型
    2. 不定长参数
      1. 带的不定长参数
        在形参前面加，那么这个参数就变成了一个元组，用来接收对应的所有的实参（实参是元组中的元素）
        记住：如果函数参数在带*的参数的后面，那么后面的这些参数在调用的时候必须使用关键字参数
6. 返回值
  - 1）意义：返回值就是从函数内部传递到函数外部的数据
    2）怎么确定返回值(怎么将函数内部的数据作为返回值传递到函数外部)：
    在函数体中，将需要返回的数据放到return的后面;
    return后面的值是多少，函数的返回值就是多少，如果没有return，返回值None
    3）怎么获取返回值(在函数外部怎么获取从函数内部传递出来的数据)：
    在函数外部获取函数调用表达式的结果;
    函数调用表达式的值就是函数的返回值
    4）什么时候需要返回值：如果实现函数的功能产生了新的数据，将新的数据作为返回值返回

作业:

编写一个函数，交换指定字典的key和value。

def exchange(x):
    """
    交换字典的键和值
    :param x:
    :return:
    """
    z={}
    for y,h in enumerate(x):
        e=x[h]
        z.setdefault(e,h)
    return z
exchange({'a':1, 'b':2, 'c':3})
print(exchange({'a':1, 'b':2, 'c':3}))

  例如:dict1={'a':1, 'b':2, 'c':3}  -->  dict1={1:'a', 2:'b', 3:'c'}

编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串

def extract_letter(x):
    """
    提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串 
    :param x:
    :return:
    """
    z=''
    for y in x:
      if 'a'<=y<='z' or 'A'<=y<='Z':
        z+=y
    return z
extract_letter('12a&bc12d-+')
print(extract_letter('12a&bc12d-+'))

   例如: 传入'12a&bc12d-+'   -->  'abcd'

写一个自己的capitalize函数，能够将指定字符串的首字母变成大写字母

def capitalize1(x):
    """
    指定字符串的首字母变成大写字母
    :param x:
    :return:
    """
    z=''
    c=''
    for y in x:
        if 'a'<=y<='z':
            z+=chr(ord(y)-32)
            break
        elif 'A'<=y<='Z':
            z+=y
            break
        else:
            z+=y
    c=z+x[len(z)::]
    return c
capitalize1('12a&bc12d-+')
print(capitalize1('12a&bc12d-+'))#使第一个字母大写,一直往后查找,知道直到使第一个字母大写为止

  例如: 'abc' -> 'Abc'   '12asd'  --> '12asd'

写一个自己的endswith函数，判断一个字符串是否已指定的字符串结束

def endswith1(x,y):
    """
    判断一个字符串是否已指定的字符串结束
    :param x:
    :return:
    """
    for z in x:
        if z==y[0]:
            if x[-1:-len(y)-1:-1]==y[-1:-len(y)-1:-1]:
                v=True
            else:
                v=False
    return v
endswith1('abc231ab','ab')
print(endswith1('abc231ab','ab'))

   例如: 字符串1:'abc231ab' 字符串2:'ab' 函数结果为: True
        字符串1:'abc231ab' 字符串2:'ab1' 函数结果为: False

写一个自己的isdigit函数，判断一个字符串是否是纯数字字符串

def isdigit1(x):
    """
   判断一个字符串是否是纯数字字符串
    :param x:
    :return:
    """
    for z in x:
        if not'0'<=z<='9':
            v=False
        else:
            v=True
    return v
isdigit1('1234921' )
isdigit1( '23函数' )
print(isdigit1('1234921' ))
print(isdigit1( '23函数' ))

   例如: '1234921'  结果: True
         '23函数'   结果: False
         'a2390'    结果: False

写一个自己的upper函数，将一个字符串中所有的小写字母变成大写字母

def upper1(x):
    """
   将一个字符串中所有的小写字母变成大写字母
    :param x:
    :return:
    """
    v=''
    for z in x:
        if 'a'<=z<='z':
            v+=chr(ord(z)-32)
        else:
            v+=z
    return v
upper1('abH23好rp1'  )
print(upper1('abH23好rp1'  ))

    例如: 'abH23好rp1'   结果: 'ABH23好RP1'

写一个自己的rjust函数，创建一个字符串的长度是指定长度，原字符串在新字符串中右对齐，剩下的部分用指定的字符填充

def rjust1(x:str,y,z):
    """
    :param x:一个字符串
    :param y:指定长度
    :param z:指定的字符
    :return:
    """
    d=''
    e=''
    c=y-len(x)
    while c>=0:
        d+=z
        c-=1
    e=d+x
    return e
rjust1('abc',7,'^')
print(rjust1('abc',7,'^'))

   例如: 原字符:'abc'  宽度: 7  字符:'^'    结果: '^^^^abc'
        原字符:'你好吗'  宽度: 5  字符:'0'    结果: '00你好吗'

写一个自己的index函数，统计指定列表中指定元素的所有下标，如果列表中没有指定元素返回-1

def index1(x:list,z):
    """
    统计指定列表中指定元素的所有下标，如果列表中没有指定元素返回-1
    :param x:一个列表
    :return:
    """
def index1(x:list,z):
    """
    统计指定列表中指定元素的所有下标，如果列表中没有指定元素返回-1
    :param x:一个列表
    :return:
    """
    k=[]
    for y,h in enumerate(x):
        if h==z:
            k.append(y)
    if k:
        return ','.join(str(x) for x in k)
    return -1
index1([1, 2, 45, 'abc', 1, '你好', 1, 0] ,1)
print(index1([1, 2, 45, 'abc', 1, '你好', 1, 0] ,1))
index1(['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权'],'赵云')
print(index1(['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权'],'赵云'))
index1(['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权'],'关羽' )
print(index1(['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权'],'关羽' ))

   例如: 列表: [1, 2, 45, 'abc', 1, '你好', 1, 0]  元素: 1   结果: 0,4,6  
        列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']  元素: '赵云'   结果: 0,4
        列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']  元素: '关羽'   结果: -1

写一个自己的len函数，统计指定序列中元素的个数

def len1(x):
    """
    统计指定序列中元素的个数
    :param x:一个元素
    :return:
    """
    c=0
    for y in x:
       c+=1
    return c
len1([-7, -12, -1, -9])
print(len1([-7, -12, -1, -9]))
len1((1, 34, 'a', 45, 'bbb'))
print(len1((1, 34, 'a', 45, 'bbb')))
len1('hello w')
print(len1('hello w'))

    例如: 序列:[1, 3, 5, 6]    结果: 4
         序列:(1, 34, 'a', 45, 'bbb')  结果: 5  
         序列:'hello w'    结果: 7

写一个自己的max函数，获取指定序列中元素的最大值。如果序列是字典，取字典值的最大值

def max1(x):
    """
    获取指定序列中元素的最大值
    :param x:一个序列
    :return:
    """
    c=-19
    d='a'
    if type(x)==dict:
        for u,i in x.items():
            if i>c:
                c=i
    elif type(x)==str:
        for g in x:
            if g>d:
                d=g
        c=d
    else:
        for y in x:
            if y>c:
                c=y
    return c
max1([-7, -12, -1, -9] )
print(max1([-7, -12, -1, -9] ))
max1('abcdpzasdz')
print(max1('abcdpzasdz'))
max1({'小明':90, '张三': 76, '路飞':30, '小花': 98})
print(max1({'小明':90, '张三': 76, '路飞':30, '小花': 98}))

    例如: 序列:[-7, -12, -1, -9]    结果: -1   
         序列:'abcdpzasdz'    结果: 'z'  
         序列:{'小明':90, '张三': 76, '路飞':30, '小花': 98}   结果: 98

写一个函数实现自己in操作，判断指定序列中，指定的元素是否存在

def in1(x,y):
    """
    判断指定序列中，指定的元素是否存在
    :param x:指定序列
    :param y:指定的元素
    :return:
    """
    for z in x:
        if z==y:
            g=True
            break
        else:
            g=False
    return g
in1((12, 90, 'abc') ,'90')
print(in1((12, 90, 'abc'),'90'))
in1([12, 90,'abc'],90)
print(in1([12, 90,'abc'],90))

    例如: 序列: (12, 90, 'abc')   元素: '90'     结果: False
         序列: [12, 90, 'abc']   元素: 90     结果: True

写一个自己的replace函数，将指定字符串中指定的旧字符串转换成指定的新字符串

def replace1(x,y,z):
    """
    将指定字符串中指定的旧字符串转换成指定的新字符串
    :param x:原字符串
    :param y:旧字符串
    :param z:新字符串
    :return:
    """
    d=''
    for g,h in enumerate(x):
        if h==y[0]:
            if x[g:g+len(y):]==y:
                k=g
                d+='me'
        elif h==y[1]:
            if x[g-1:g + len(y)-1:] == y:
                pass
        elif h==y[2]:
            if x[g - 2:g + len(y) - 2:] == y:
                pass
        else:
            d+=h
    return d
replace1('how are you? and you?','you','me' )
print(replace1('how are you? and you?','you','me' ))

    例如: 原字符串: 'how are you? and you?'   旧字符串: 'you'  新字符串:'me'  结果: 'how are me? and me?'