【Python】学习笔记 -- CH8. 函数及常用的内置函数

于 2025-04-14 20:42:04 发布
阅读量758 收藏 24
点赞数 30
CC 4.0 BY-SA版权
分类专栏： Python学习 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Fu_Lin_13/article/details/147232464

文章目录

CH8. 函数及常用的内置函数

函数的定义及调用

  • 函数是将一段实现功能的完整代码，使用函数名称进行封装，通过函数名称进行调用。以此达到一次编写，多次调用的目的。

    • 内置函数

      • 输入函数input()
      • 输出函数print()
      • …

    • 自定义函数

      • def 函数名称(参数列表)

        ​ 函数体

        ​ <return 返回值列表>

    • 函数调用

      • 函数名(参数列表)

  • 函数的使用总结

    • 函数定义
      • 使用关键字def
      • 确定函数名称、参数名称、参数个数、编写函数体（用于实现函数功能的代码）
    • 函数调用
      • 通过函数名称调用函数
      • 对函数的各个参数进行实际的赋值
    • 函数执行
      • 使用实际参数参与函数功能的实现
    • 函数返回结果
      • 函数执行结束后，如果使用return进行返回结果，则结果被返回到函数的调用处

函数的参数传递

函数的参数类型

  • 位置参数

    • 是指调用时的参数个数和顺序必须与定义的参数个数和顺序相同
    • 位置参数在传参时，其顺序在前

  • 关键字参数

    • 是在函数调用时，使用“形参名称=值” 的方式进行传参，传递参数顺序可以与定义时参数的顺序不同

  • 默认值参数

    • 是在函数定义时，直接对形式参数进行赋值，在调用时如果该参数不传值，将使用默认值，如果该参数传值，则使用传递的值

  • 可变参数

    • 又分为个数可变的位置参数和个数可变的关键字参数两种。

    • 个数可变的位置参数是在参数前加一颗星*（*para)，para形式参数的名称，函数调用时可接收任意个数的实际参数，并放到一个元组中。

      # 个数可变的位置参数
def func(*para):
    print(type(para))
    for item in para:
        print(item)

# 函数嗲用
func(10,20,30,40)
func(10,20)
func(20)

'''
<class 'tuple'>
10
20
30
40
<class 'tuple'>
10
20
<class 'tuple'>
20
'''

func([1,2,3,4]) # 实际上是传递的一个参数
func(*[1,2,3,4]) # 解包，传递的是多个参数
'''
<class 'tuple'>
[1, 2, 3, 4]
<class 'tuple'>
1
2
3
4
'''

    • 个数可变的关键字参数是在参数前加两颗星**（**para），在函数调用时可接收任意多个 “参数=值” 形式的参数，并放到一个字典中。

      # 个数可变的关键字参数
def func2(**kwpara):
    print(type(kwpara))
    for key,value in kwpara.items():
        print(key,'---',value)

func2(name='Folin', age=18)

d={'name':'Folin', 'age':18, 'gender':'男'}
func2(**d)  # 入参为字典，进行解包

'''
<class 'dict'>
name --- Folin
age --- 18
<class 'dict'>
name --- Folin
age --- 18
gender --- 男
'''

函数的返回值

  • 如果函数的运行结果需要在其他函数中使用，那么这个函数就应该被定义为带返回值的函数
  • 函数的运行结果使用return关键字进行返回
  • return可以出现在函数中的任意一个位置，用于结束函数
  • 返回值可以是一个值，或多个值，如果返回的值是多个，结果是一个元组类型
def get_sum(num):
    odd_sum = 0  # 奇数和
    even_sum = 0 # 偶数和
    sum = 0 # 总和
    for i in range(1, num+1):
        if i % 2 != 0:
            odd_sum += i
        else:
            even_sum += i
        sum += i
    return odd_sum, even_sum, sum

result = get_sum(10)
print(type(result)) # 返回值是一个元组
print(result)

# 解包赋值
odd_sum, even_sum, sum = get_sum(10)
print(odd_sum,even_sum,sum)

'''
<class 'tuple'>
(25, 30, 55)
25 30 55
'''

变量的作用域

  • 是指变量起作用的范围，根据范围作用的大小可以分为局部变量和全局变量
  • 局部变量
    • 定义：在函数定义处的参数和函数内部定义的变量
    • 作用范围：仅在函数内部，函数执行结束，局部变量的生命周期也结束
  • 全局变量、
    • 定义：在函数外定义的变量或函数内部使用global关键字修饰的变量
    • 作用范围：整个程序，程序运行结束，全局变量的生命周期才结束
a = 100

def calc1(x, y):
    return a+x+y

def calc2(x, y):
    a = 200
    # a是局部变量，当全局变量和局部变量的名称相同时，局部变量的优先级高
    return a+x+y

x = 10
y = 20
print(calc1(x,y))
print(a)

print(calc2(x,y))
print(a)

'''
130
100
230
100
'''

def calc3(x, y):
    global s # 定义全局变量
    s = 300 # 全局变量的声明和赋值需要分两步进行
    return s+x+y

print(calc3(x, y))
print(s)
'''
330
300
'''

def calc4(x, y):
    global a
    a += 92 # 修改全局变量a的值
    return a+x+y

print(calc4(x, y))
print(a)
'''
222
192
'''

匿名函数lambda

  • 匿名函数是指没有名字的函数，这种函数只能使用一次，一般是在函数的函数体只有一句代码且只有一个返回值时，可以使用匿名函数来简化
  • 语法结构：result=lambda 参数列表:表达式
def sum(a,b):
    return a+b

print(sum(10,20))

# 匿名函数
s = lambda a,b:a+b  # s表示一个匿名函数
print(type(s)) # <class 'function'>
# 调用匿名函数
print(s(10,20))

print('-'*30)
# 列表取值
lst = [10,20,30,40,50]
for i in range(len(lst)):
    get_value = lambda x:x[i]
    print(get_value(lst))

print('-'*30)
# 排序
student_scores = [
    {'name':'zhangsan', 'score':98},
    {'name':'lisi', 'score':95},
    {'name':'wangwu', 'score':100},
    {'name':'chenliu', 'score':60}
]
student_scores.sort(key=lambda d:d.get('score'), reverse=True) # 按score降序排序
print(student_scores)
'''
30
<class 'function'>
30
------------------------------
10
20
30
40
50
------------------------------
[{'name': 'wangwu', 'score': 100}, {'name': 'zhangsan', 'score': 98}, {'name': 'lisi', 'score': 95}, {'name': 'chenliu', 'score': 60}]
'''

递归函数

  • 在一个函数的函数体内调用该函数本身，该函数就是递归函数
  • 一个完整的递归操作有两部分组成，一部分是递归调用，一部分是递归终止条件，一般可使用if-else结构来判断递归的调用和递归的终止
# 计算n的阶乘
def fac(n):
    if n == 1:
        return 1 # 1! = 1
    else:
        return n*fac(n-1)  # 递归调用自己

print(fac(3))
# 6
  • 斐波拉契数列（Fibonacci sequence）：f(n) = f(n-1) + f(n-2)
def fib(n):
    if n == 1 or n == 2:
        return 1
    else:
        return fib(n-1) + fib(n-2)

n = 10
for i in range(1, n+1):
    print(fib(i), end=' ')
print()

'''
1 1 2 3 5 8 13 21 34 55
'''

常用的内置函数

数据类型转换函数

函数名称描述
bool(obj)获取指定对象obj的布尔值
str(obj)将指定对象obj转换成字符串类型
int(x)将x转换成int类型
float(x)将x转换成float类型
list(sequence)将序列转换成列表类型
tuple(sequence)将序列转换成元组类型
set(sequence)将序列转换成集合类型

数学函数

函数名称描述
abs(x)求绝对值
divmod(x,y)求x和y的商和余数
max(sequence)获取序列sequence的最大值
min(sequence)获取序列sequence的最小值
sum(iter)对可迭代对象进行求和运算
pow(x,y)获取x的y次幂
round(x,d)对x进行保留d位小数，结果四舍五入

迭代器操作函数

函数名称描述
sorted(iter)对可迭代对象进行排序
reversed(sequence)反转序列生成新的迭代器对象
zip(iter1, iter2)将iter1和iter2打包成元组，并返回一个可迭代的zip对象
enumerate(iter)根据iter对象创建一个enumerate对象
all(iter)判断可迭代对象iter中所有元素的布尔值是否都为True
any(iter)判断可迭代对象iter中所有元素的布尔值是否都为False
next(iter)获取迭代器的下一个元素
filter(function, iter)通过制定条件过滤序列并返回一个迭代器对象
map(function, iter)通过函数function对可迭代对象iter的操作返回一个迭代器对象
lst = [54,56,77,4,567,34]
asc_lst = sorted(lst)
desc_lst = sorted(lst, reverse=True)
print('原列表', lst)
print('升序列表', asc_lst)
print('降序列表', desc_lst)

print('-'*30)
new_lst = reversed(lst)
print(type(new_lst)) # 迭代器对象
print(new_lst)
print(list(new_lst))

print('-'*30)
x = ['a','b','c','d']
y = [1,2,3,4,5]
zipobj = zip(x, y)
print(type(zipobj))
print(list(zipobj))

print('-'*30)
e = enumerate(x, start=1) # (index, val)
print(type(e))
print(tuple(e))

print('-'*30)
lst2 = [10,20,'', 30]
print(all(lst2))
print(all(lst))

print('-'*30)
lst3 = [{}, '', ()]
print(any(lst2))
print(any(lst3))

print('-'*30)
zipobj2 = zip(x, y)
print(next(zipobj2))
print(next(zipobj2))
print(next(zipobj2))
print(next(zipobj2))

print('-'*30)
def func(num):
    return num % 2 == 1

filter_obj = filter(func, range(10)) # 将range(10)的整数，都执行一此func函数调用
print(type(filter_obj))
print(list(filter_obj))

print('-'*30)
def upper(x):
    return x.upper()

str = ['hello', 'python', 'world']
map_obj = map(upper, str)
print(type(map_obj))
print(list(map_obj))

'''
原列表 [54, 56, 77, 4, 567, 34]
升序列表 [4, 34, 54, 56, 77, 567]
降序列表 [567, 77, 56, 54, 34, 4]
------------------------------
<class 'list_reverseiterator'>
<list_reverseiterator object at 0x000001D9B0BFBBB0>
[34, 567, 4, 77, 56, 54]
------------------------------
<class 'zip'>
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
------------------------------
<class 'enumerate'>
((1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'))
------------------------------
False
True
------------------------------
True
False
------------------------------
('a', 1)
('b', 2)
('c', 3)
('d', 4)
------------------------------
<class 'filter'>
[1, 3, 5, 7, 9]
------------------------------
<class 'map'>
['HELLO', 'PYTHON', 'WORLD']
'''

其他内置函数

函数名称描述
format(value, format_spec)将value以format_spec格式（参见格式化字符详细格式）进行显示
len(s)获取s的长度或s元素的个数
id(obj)获取对象的内存地址
type(x)获取x的数据类型
eval(s)执行s这个字符串所表示的Python代码
print(format(3.14, '20')) # 数值类型默认右对齐
print(format('hello', '20')) # 字符串默认左对齐

print(format('hello python', '*^20')) # 居中对齐，显示宽度20，空白字符填充*

'''
                3.14
hello
****hello python****
'''

函数实战

实战1

  • 编写函数实现计算列表中元素的最大值
    • 随机产生10个元素，存储到列表中，编写函数获取这个列表中元素的最大值（不能使用内置函数max()）
import random


def get_max(lst):
    max = lst[0]
    for value in lst:
        if max < value:
            max = value;
    return max

lst = [random.randint(1, 100) for _ in range(10)]
print('lst:',lst)
max = get_max(lst)
print('get_max(lst) =', max)

'''
lst: [18, 37, 48, 60, 14, 81, 31, 67, 70, 33]
get_max(lst) = 81

lst: [25, 92, 74, 91, 52, 76, 65, 35, 49, 59]
get_max(lst) = 92
'''

实战2

  • 编写函数实现提取指定字符串中的数字并求和
    • 使用input()获取一个字符串，编写函数并传参，使用isdigit()方法提取字符串中所有数字，并对提取的数字进行求和计算，最后将存储数字的列表和累加和返回
def get_number_listandsum(str):
    sum = 0
    number_lst = []
    for i in range(len(str)):
        if str[i].isdigit():
            num = int(str[i])
            number_lst.append(num)
            sum += num
    return number_lst, sum

str = input('请输入一个字符串：')
number_lst,sum = get_number_sum(str)
print('提取的数字列表为：', number_lst)
print('累加和为：', sum)

'''
请输入一个字符串：hello123world456
提取的数字列表为： [1, 2, 3, 4, 5, 6]
累加和为： 21
'''

实战3

  • 编写函数实现将字符串中字母的大小写转换
    • 使用input()获取一个字符串，编写函数并传参，将字符串中所有的小写字母转换为大写字母，将大写字母转换为小写字母
def trans_upper_lower(str):
    new_str = ''
    for i in range(len(str)):
        if 'A' <= str[i] <= 'Z':
            new_str += str[i].lower()
        elif 'a' <= str[i] <= 'z':
            new_str += str[i].upper()
        else:
            new_str += str[i]
    return new_str

str = input('请输入一个字符串：')
print(trans_upper_lower(str))

'''
请输入一个字符串：HELLO我是123world
hello我是123WORLD
'''

实战4

  • 编写函数实现操作符in的功能
    • 使用input()从键盘获取一个字符串，判断这个字符串在列表中是否存在（函数体不能使用in），返回结果为True或False
def is_str_in_list(str, lst):
    for item in lst:
        if str == item:
            return True
    return False

lst = ['hello','world', 'python']
str = input('请输入一个字符串：')
print('存在' if is_str_in_list(str, lst) else '不存在')

'''
请输入一个字符串：hello
存在

请输入一个字符串：html
不存在
'''
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值