12 - 函数的进阶

已于 2022-08-03 09:51:48 修改
阅读量104 收藏
点赞数
分类专栏： python 文章标签： python 开发语言
于 2022-08-02 20:57:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mr_suyi/article/details/126130282
版权

Day 12

一、函数的返回值

1.函数的返回值

a. 什么是返回值 - 返回就是从函数内容传递到函数外部的数据(Python中的每个函数都可以传递一个数据到函数的外部)

b. 怎么确定一个函数的返回值(怎么在函数的内容将数据传递到函数的外部)
return后面的值就是函数的返回值(执行函数体的是如果遇到return，return后面的值就是函数的返回值)

c. 怎么在函数外部获取函数返回值
获取函数调用表达式的值就是获取这个函数的返回值
函数调用表达式 - 调用函数的语句

d. 什么时候使用返回值：
如果实现函数的功能，产生了新的数据，就将新的数据作为函数的返回值返回

2.return确定返回值

  • return后面放需要返回的数据
def func1(a, b):
    # a = 10, b = 20
    result = a + b      # 30
    return result       # return 30
  • 一个函数只有一个返回值(一个函数最多只能有一个return有效)；如果想要把多个数据作为函数的返回值返回，可以在一个return后面写多个数据.
def func2(a, b):
    result1 = a + b
    result2 = a * b
    return result1, result2
  • return除了可以返回数据，还会提前结束函数(执行函数体的时候如果遇到return，函数直接结束)
def func3():
    print('++++++')
    print('------')
    return                          #  相当于 return None
    print('======')
func3()
'''
结果
++++++
------
'''

def func4(str1: str):
    # str1 = 'hsMNsh啥时间A看N'
    new_str = ''
    for x in str1:
        if x.isupper():
            new_str += x
    return new_str          # 'MNAN'

3. 获取函数的返回值

  • 函数调用表达式的值就是函数的返回值，所以返回值能干的事情，函数调用表达式都可以做

二、变量作用域

1. 变量作用域 - 变量在定义完成后可以使用的范围

  • 根据变量作用域的不同，可以将变量分为全局变量和局部变量两种

2.全局变量

  • 没有定义在函数里面或者类里面的变量都是全局变量。
  • 作用域：从定义开始，到程序结束。（程序结束前的任何位置都可以使用）
    例如 自己定义的变量和处于循环的变量皆为全局变量
# a是全局变量
a = 10
print(f'外面的a:{a}')

# 循环里面的x也是全局变量
for x in range(5):
    print(f'循环里面x:{x}')

3.局部变量

  • 定义在函数中的变量就是局部变量（形参也是局部变量；定义在类中的变量是属性）
  • 作用域：从定义开始到函数结束
def func3(c):
    d = 30
    print(f'函数里面c和d:{c}, {d}')


func3(40)


# print(f'函数外面:{c},{d}')       # 报错！函数外面不能使用函数中定义的局部变量

4. 不同变量的存储方式

  • 全局变量默认保存在全局栈区间(程序结束的时候才会被释放)，
  • 局部变量默认是保存在函数对应的临时栈区间中(函数对应的临时栈区间，创建函数的时候会创建出来，函数调用结束会自动释放)。
  • 在函数中定义变量的时候，可以在定义变量前加global关键字，让函数中定义变量可以保存在全局栈区间中。
x = 100    # 保存全局栈区间

def func4():
    y = 200    # 保存在func4对应的临时栈区间

    global z
    z = 300     # 保存在全局栈区间中


func4()
print(f'外面z:{z}')


print('------------------------------------华丽的分割线-----------------------------------')

# 如果想要在函数里面修改一个全局变量的值，必须先用global对变量进行声明
name = '小明'     # name是全局变量，保存在全局栈区间


def change_name():
    # name = '小花'     # 重新创建一个局部变量name，保存在change_name对应的临时栈区间中
    # print(f'函数里面name：{name}')

    global name
    name = '小花'
    print(f'函数里面name：{name}')


change_name()


print(f'外面name：{name}')

三、函数参数的确定

1. 调用函数的时候，实参到底应该给什么样的数据，由什么东西决定？

  • 由参数在函数体中的使用方式决定


def func1(x):
    print(x)
# 此函数的x可以为任何值

func1(10)         # 10
func1('abc')      # abc
func1([10, 20])   # [10, 20]


def func2(x):
    print(x + 10)
# 此函数值为可以进行加法运算的值 如整数和浮点数

func2(10)      # 20
func2(2.34)    # 12.34


def func3(x):
    print(x * 2)
    # 此函数值为可以进行乘法运算的值 如整数、字符串、列表、元祖等


func3(10)          # 20
func3('abc')       # abcabc
func3([10, 20])    # [10, 20, 10, 20]
func3((10, 23))    # (10, 23, 10, 23)


def func4(x):
    print(x[-1])
# 此函数值为可以进行下标操作的值如字符串、列表等

func4('abc')                # c
func4([10, 20, 30])         # 30
func4({'a': 10, -1: 20})    # 20 


def func5(x):
    x.append(100)
    print(x)
# 此函数值为可以进行append操作的值如列表

func5([10, 23])   # [10, 23, 100]

2. 实参高阶函数 - 函数的参数是函数

  • 如果一个参数是函数，传参的时候有两种方法：1）用普通函数的函数名 2）使用匿名函数
# func6这个函数的参数要求是函数， 这个func6就是一个实参高阶函数
def func6(x):
    # x = temp
    x()     # temp()


def temp():
    print('临时函数')


func6(temp)


# x必须是函数，有一个参数，返回值必须是数字
def func7(x):
    # x = temp2
    print(x(10) + 20)           # print(temp2(10) + 20)   ->  print(19 + 20)


def temp2(m):
    # m = 10
    return 19


func7(temp2)

四、匿名函数

1.匿名函数

  • 匿名函数的本质还是函数，但是它只能实现简单的功能(一行语句就能实现它的功能)
    语法：
    函数名 = lambda 形参列表:返回值

相当于：
def 函数名(形参列表):
return 返回值

  • 示例1：定义一个函数求两个数的和
sum2 = lambda num1, num2: num1+num2

print(sum2(10, 20))               # 30
print(sum2(num1=100, num2=200))   # 300

2.匿名函数的应用

  • 在给实参高阶函数传参的时候，可以使用普通函数函数名，也可以使用匿名函数(能用匿名函数就使用匿名函数，不行才用普通函数)
def func1(x):
    print(x(10, 20) + 10)


#  x是一个函数；有两个参数，有一个数字对应的返回值
def temp1(m, n):
    return 12.3


func1(temp1)                     # 22.3


func1(lambda m, n: 12)			 # 22

五、常用的实参高阶函数

1.max、min、sorted

  • max(序列) - 直接比较序列中元素本身的大小，求出最大值
  • 示例：求nums中值最大的元素
nums = [18, 23, 67, 90, 56, 49]
print(max(nums))   # 90

  • max(序列,key=函数) - 按照函数制定的比较规则比较元素的大小，求出最大值

  • 函数的要求：

    • a.有且只有一个参数（这个参数代表序列中的每个元素）
    • b.需要一个返回值（返回值是比较对象 - 将参数看成元素，在这个地方来描述比较对象和元素之间的关系）

  • 示例1：求nums中值最大的元素

nums = [18, 23, 67, 90, 56, 49]
result = max(nums, key=lambda item: item)
print(result)  # 90
  • 示例2：求nums中个位数最大的元素
nums = [18, 23, 67, 90, 56, 49]
result = max(nums, key=lambda item: item % 10)
print(result)   # 49
  • 示例3：求students中年龄最大的学生
students = [
    {'name': '小明', 'age': 19, 'score': 89, 'gender': '男'},
    {'name': '小红', 'age': 22, 'score': 99, 'gender': '女'},
    {'name': '小胡', 'age': 28, 'score': 75, 'gender': '男'},
    {'name': '小花', 'age': 25, 'score': 80, 'gender': '女'},
    {'name': '李华', 'age': 17, 'score': 84, 'gender': '男'}
]
result = max(students, key=lambda item: item['age'])
print(result)
# {'name': '小胡', 'age': 28, 'score': 75, 'gender': '男'}
  • 练习1：求nums中十位数最大的元素: 90
nums = [9108, 23, 167, 90, 556, 149]
result = max(nums, key=lambda item: item // 10 % 10)
print(result)
  • 练习2：求nums中绝对值最小的元素
  • abs(数据) - 返回指定数据的绝对值
nums = [-992, 12, 78, -34, 99]
# 方法一：
result = min(nums, key=lambda item: abs(item))
print(result)
# 方法二：
result = min(nums, key=lambda item: item ** 2)
print(result)
  • 练习3：nums中各个位数之和最大的元素
nums = [102, 19, 48, 221, 52]
# 3,10,12,5,7  ->  48
# 102  -> '102'  -> '1'、'0'、'2'

# 方法一：
result = max(nums, key=lambda item: sum([int(x) for x in str(item)]))
print(result)


# 方法二：
def temp(item):
    sum1 = 0
    for x in str(item):
        sum1 += int(x)
    return sum1


result = max(nums, key=temp)
print(result)

2.map - 基于原序列中的元素创建一个新的序列

  • map(函数, 序列) - 根据函数制定规则，将指定序列中的元素转换成新序列中的元素

  • 函数的要求:

    • a.有且只有1个参数（代表后面序列中的元素）
    • b.有返回值（返回对应的就是新序列中的元素）

  • map(函数, 序列1, 序列2)

  • 函数的要求:

    • a.有且只有个2参数(分别代码后面两个序列中的元素)）
    • b.有返回值（返回对应的就是新序列中的元素）

  • 示例1：创建一个列表，列表中的元素是nums中所有元素的个位数

nums = [82, 67, 89, 6617, 90, 23, 71]
# [2, 7, 9, 7, 0, 3, 1]
result = map(lambda item: item % 10, nums)
print(list(result))
  • 示例2：将A和B中的元素对应求和产生一个新的列表
A = [3000, 5600, 9800, 4200, 10000]
B = [1500, 1000, 2200, 1300, 3200]
# [4500, 6600, 12000, 5500, 13200]

result = map(lambda i1,i2: i1+i，A,B)
  • 练习1：将nums中所有的元素乘以10
nums = [82, 67, 89, 6617, 90, 23, 71]
result = map(lambda item: item * 10, nums)
print(list(result))
  • 练习2：基于scores创建一个列表，列表中元素根据nums中元素确定为’及格’或者’不及格’
scores = [82, 67, 89, 66, 90, 23, 71]
result = map(lambda item: '不及格' if item < 60 else '及格', scores)
  • 练习3：基于names、ages和scores，创建学生列表：
names = ['stu1', 'stu2', 'stu3', 'stu4']
ages = [23, 34, 19, 22]
scores = [82, 67, 89, 66]
# [{'name': 'stu1', 'age': 23, 'score': 82}, .....]
result = map(lambda i1, i2, i3: {'name': i1, 'age': i2, 'score': i3}, names, ages, scores)
print(list(result))

3. reduce - 将序列中所有的元素通过指定的规则合并成一个数据

  • reduce(函数, 序列, 默认值)
  • 函数的要求：
    • a.有且只有两个参数(第一个参数指向默认值，第二个参数指向序列中的每个元素)
    • b.需要一个返回值（描述合并方式，说清楚最后的结果是初始值和序列中元素进行什么样的操作得到的）
  • 注意：reduce使用之前要先导入
  • 示例1: 求nums中所有元素的和
nums = [10, 20, 30, 40]
# 0 + 10 + 20 + 30 + 40
result = reduce(lambda i, item: i + item, nums, 0)
print(result)
  • 示例2：求nums中所有元素的乘积
nums = [10, 20, 30, 40]
# 1 * 10 * 20 * 30 * 40
result = reduce(lambda i, item: i * item, nums, 1)
print(result)
  • 示例3：求所有元素个位数的和
nums = [23, 78, 92, 78, 12]
# 0 + 3 + 8 + 2 + 8 + 2  -> 0 + 23%10 + 78 % 10 + 92 % 10 + 78 % 10 + 12 % 10
result = reduce(lambda i, item: i + item % 10, nums, 0)
print(result)
  • 示例4：将所有元素合并成一个字符串：‘2378927812’
nums = [23, 78, 92, 78, 12]
# '' + '23' + '78' + '92' + '78' + '12'  -> '' + str(23) + ...
result = reduce(lambda i, item: i + str(item), nums, '')
print(result)
  • 示例5：求所有学生的总分
students = [
    {'name': '小明', 'age': 19, 'score': 89, 'gender': '男'},
    {'name': '小红', 'age': 22, 'score': 99, 'gender': '女'},
    {'name': '小胡', 'age': 28, 'score': 75, 'gender': '男'},
    {'name': '小花', 'age': 25, 'score': 80, 'gender': '女'},
    {'name': '李华', 'age': 17, 'score': 84, 'gender': '男'}
]
# 0 + 89 + 99 + 75 +...  -> 0 + {'name': '小明', 'age': 19, 'score': 89, 'gender': '男'}['score'] + ...
result = reduce(lambda i, item: i + item['score'], students, 0)
print(result)

习题

  1. 写一个匿名函数，判断指定的年是否是闰年
year = lambda year: '闰年' if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0 else '平年'

print(year(2000))
  1. 写一个函数将一个指定的列表中的元素逆序( 如[1, 2, 3] -> [3, 2, 1])(注意:不要使用列表自带的逆序函数)
list1 = [1, 2, 3]


def change(list1: list):
    list2 = []
    for i in range(len(list1) - 1, -1, -1):
        list2.append(list1[i])
    return list2


print(change([1, 2, 3]))
  1. 编写一个函数，计算一个整数的各位数的平方和
例如: sum1(12) -> 5（1的平方加上2的平方）    sum1(123) -> 14

def sum1(num):
    sum2 = 0
    for i in str(num):
        sum2 += int(i) ** 2
    return sum2


print(sum1(123))
  1. 求列表 nums 中绝对值最小的元素
例如：nums = [-23, 100, 89, -56, -234, 123], 最大值是：-23

nums = [-23, 100, 89, -56, -234, 123]
result = min(nums, key=lambda itme: abs(itme))
print(result)

  1. 已经两个列表A和B，用map函数创建一个字典，A中的元素是key，B中的元素是value

     A = ['name', 'age', 'sex']
 B = ['张三', 18, '女']
 新字典: {'name': '张三', 'age': 18, 'sex': '女'}

 A = ['name', 'age', 'sex']
 B = ['张三', 18, '女']
 result = map(lambda i1, i2: {i1: i2}, A, B)
 print(list(result))

  2. 已经三个列表分别表示5个学生的姓名、学科和班号，使用map将这个三个列表拼成一个表示每个学生班级信息的的字典

    names = ['小明', '小花', '小红', '老王']
nums = ['1906', '1807', '2001', '2004']
subjects = ['python', 'h5', 'java', 'python']
结果：{'小明': 'python1906', '小花': 'h51807', '小红': 'java2001', '老王': 'python2004'}

    names = ['小明', '小花', '小红', '老王']
    nums = ['1906', '1807', '2001', '2004']
    subjects = ['python', 'h5', 'java', 'python']
    result = map(lambda i1, i2, i3: {i1: i3 + i2}, names, nums, subjects)
    print(list(result))

  1. 已经一个列表message, 使用reduce计算列表中所有数字的和

    message = ['你好', 20, '30', 5, 6.89, 'hello']
结果：31.89

 from functools import reduce

  message = ['你好', 20, '30', 5, 6.89, 'hello']
 result = reduce(lambda i, item: i + item if type(item) == int or type(item) == float else i + 0, message, 0)
 print(result)

  2. 已经列表points中保存的是每个点的坐标(坐标是用元组表示的，第一个值是x坐标，第二个值是y坐标）

    points = [
  (10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)
]

    1）获取列表中y坐标最大的点

    2）获取列表中x坐标最小的点

    3）获取列表中距离原点最远的点

    4）将点按照点到x轴的距离大小从大到小排序

     points = [
  (10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)
 ]
 # 1）获取列表中y坐标最大的点
 result1 = max(points, key=lambda itme: itme[-1])
 print(result1)

 # 2）获取列表中x坐标最小的点
 result2 = min(points, key=lambda itme: itme[0])
 print(result2)
 # 3）获取列表中距离原点最远的点
 result3 = max(points, key=lambda itme: itme[0]**2 + itme[-1]**2)
 print(result3)
 # 4）将点按照点到x轴的距离大小从大到小排序
 result4 = sorted(points, key=lambda itme: abs(itme[-1]), reverse=True)
 print(result4)
Mr_suyi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python中的cell函数_python函数-函数进阶
weixin_29074295的博客
12-23 9985
python函数-函数进阶一、命名空间和作用域1.命名空间内置命名空间 —— python解释器就是python解释器一启动就可以使用的名字存储在内置命名空间中内置的名字在启动解释器的时候被加载进内存里全局命名空间 —— 我们写的代码但不是函数中的代码是在程序从上到下被执行的过程中依次加载进内存的放置了我们设置的所有变量名和函数名局部命名空间 —— 函数就是函数内部定义的名字当调用函数的时候 才会...
信息奥赛-数学-算法进阶
08-02
互质与欧拉函数 2. 同余 模运算 基本概念 同余的性质 同余类和剩余系 费马小定理 欧拉定理 裴蜀定理 扩展 逆元 逆元求解 线性求逆元：递推/倒推 线性同余方程（组） 中国剩余定理 扩展中国剩余定理 ...
【Python学习】Day-015 Day-016 认识函数、函数分类、定义函数、调用函数、函数的参数、函数的返回值、变量作用域、函数参数的确定、匿名函数、常用的实参高阶函数
ChenAi_140的博客
08-01 158
认识函数、函数分类、定义函数、调用函数、函数的参数、函数的返回值、变量作用域、函数参数的确定、匿名函数、常用的实参高阶函数
函数基础和函数参数
idwhl的博客
06-22 448
一、函数基础 1.什么是函数 1）概念 函数就是对实现某一特定功能的代码段的封装（机器） 2）分类 系统函数 - 系统已将定义了，程序员可以直接使用的函数，比如：print, input, type, ord, chr, bin, len, id等（别人造好的机器） 自定义函数 - 程序员自己定义使用的函数（自己造机器） 2.函数的定义 语法： def 函数名(形参列表)： 函数说明文档 函数体 说明： def - python定义函数的关键字，固定写法 函数名 - 程序员自己命名 标识符，不能是关键字（要
Day12-函数进阶
flank555的博客
06-08 70
Day-函数进阶
C语言-函数进阶
weixin_46597732的博客
01-15 132
ES6-8-函数进阶
weixin_43151774的博客
05-03 91
13.python-函数进阶
心猿意碼
11-26 8670
函数进阶 目标 函数参数和返回值的作用 函数的返回值 进阶 函数的参数 进阶 递归函数 01. 函数参数和返回值的作用 函数根据 有没有参数 以及 有没有返回值，可以 相互组合，一共有 4 种 组合形式 无参数，无返回值 无参数，有返回值 有参数，无返回值 有参数，有返回值 定义函数时，是否接收参数，或者是...
day10-函数进阶
songkj515的博客
10-21 58
day10-函数进阶 函数的返回值 什么是函数返回值 返回值就是从函数内部传递到函数外部的数据(默认情况下函数内部产生的新数据，在函数外部不能使用) 怎么确定函数返回值 1）python中每个函数都有返回值，返回值是什么就看执行函数体的时候遇到的return关键字后面的数据是什么；如果没有遇到return，返回值就是None。(希望作为返回值的数据在函数结束的时候放在return后面) 2）return的作用 遇到return会确定函数返回值并且直接结束函数 怎么在函数外部获取函数返回值 函数调
09-Python之路---函数进阶
Mark_Coder的博客
11-22 115
命名空间函数的嵌套：嵌套定义：定义在内部的函数无法直接在全局被调用函数名的本质：就是一个变量，保存了函数所在的内存地址闭包：内部函数包含对外部作用域而非全剧作用域名字的引用，该内部函数称为闭包函数。
Day 8 - 函数进阶1
qq_41175455的博客
10-12 85
Day 9 函数进阶 1. 函数返回值 定义 返回值就是从函数内部传递到函数外部的数据 默认情况下函数内部产生的新数据在函数外部不能使用 使用 a.确定函数返回值 Python中每个函数都有返回值； 执行函数体时遇到关键字return时其后面的数据决定返回值； 如果没有遇到return，返回值就是None def func1(a, b): print(a+b) result1 = func1(1, 2) print(result1) b.自定义函数返回值 希望作为返回值
05-python-datetime模块-SQL数据库-对象关系映射-函数进阶
02-09
python学习笔记，包含datetime模块-SQL数据库-对象关系映射-函数进阶
龙灵修-讲Lua的cocos2d-x进阶视频.rar
04-28
cocos2d-x进阶教程1_4Lua中函数、条件判断语句.mp4 cocos2d-x进阶教程1_5Lua中循环语句和逻辑运算关键字.mp4 cocos2d-x进阶教程1_6LuaTable使用1.mp4 cocos2d-x进阶教程1_7LuaTable使用2.mp4 cocos2d-x进阶教程1_8...
FridaHookAndroid:Frida-Android 进阶
05-26
Android 进阶frida 版本：12.11.18系统：Ubuntu 20.04 LTS博客地址：官方 APIJava 运行时官方API地址： ，这里给出几个常用的 APIJava.perform(fn)确保当前线程被附加到 VM 上，并且调用fn函数。此函数在内部调用 VM...
6-JAVA进阶-多线程1
08-03
1.继承线程父类，自定义子类 2.子类中重写run方法，@override，里面放你像实现的功能 3.mian()函数中创建子类对象，MyThread my =
每日一题——Python实现PAT乙级1042 字符统计（举一反三+思想解读+逐步优化）
weixin_44915521的博客
06-09 1126
这些编程思想和哲学理念在编写高效、健壮的代码时至关重要。通过理解和应用这些原则，我们不仅能够写出性能更好的代码，还能在不同情况下做出更加明智的设计决策。通过理解和应用这些哲学和编程思想，可以在不同场景中灵活运用，写出更加高效、健壮和灵活的代码。评估需求：根据实际需求选择最合适的数据结构和算法。避免冗余：尽量避免不必要的重复计算和操作。权衡利弊：在空间和时间之间找到最佳平衡点。灵活应变：根据输入数据的特性，灵活使用动态数据结构和提前决策策略。
基于JavaScript 如何实现爬山算法以及优化方案
乐闻世界
06-10 1333
爬山算法（Hill Climbing Algorithm）是一种常见的启发式搜索算法，常用于解决优化问题。其核心思想是从一个初始状态出发，通过逐步选择使目标函数值增大的邻近状态来寻找最优解。接下来，我们将通过 JavaScript 实现一个简单的爬山算法，帮助大家理解其原理和应用。从一个初始状态开始。评估当前状态的目标函数值。在当前状态的邻居中选择一个目标函数值更大的状态。如果找到了更优的邻居，则移动到该邻居并重复步骤2和步骤3。如果没有更优的邻居，则算法结束，当前状态即为局部最优解。
2024.6.13刷题记录
最新发布
lshx4658的博客
06-14 402
当时没有想到怎么保证队内全都是窗口内的元素，答案：“当队头元素在窗口的左边的时候，弹出队头”，虽然不能保证队内一直没有窗口外的元素，但是能保证使用到的队内元素（队头）全是窗口内元素。当时是有想到这个方法的，但是以为不行，一下没转过来弯。队列储存索引而不是元素，通过储存索引使我们能够快速判断元素是否出窗口。不会，思路来自题解（
Java——简单图书管理系统
m0_74100417的博客
06-09 1464
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
c语言程序函数高级进阶
01-31
C语言程序函数高级进阶主要包括指针，内存管理，函数指针和回调函数等内容。指针是C语言中非常重要的概念，通过指针可以直接操作内存地址，实现更高效的程序，但同时也需要注意指针的安全性和正确性，避免出现野指针和内存泄漏的问题。另外，内存管理是C语言程序高级进阶中的重要环节，包括动态内存分配和释放，及时释放不再需要的内存，避免内存泄漏。函数指针的概念也是C语言程序高级进阶的重点，通过函数指针可以实现回调函数，实现更加灵活的程序设计和功能扩展。 在C语言程序函数高级进阶中，还需要掌握函数指针和回调函数的使用，函数指针可以实现动态调用不同的函数，使程序更加灵活和可扩展。而回调函数则可以在特定的事件发生时被调用，实现程序的事件驱动功能。同时，还需要了解函数指针和回调函数在实际应用中的场景和用法，例如在图形界面程序开发和操作系统内核开发中都有函数指针和回调函数的应用。 总之，C语言程序函数高级进阶需要掌握指针、内存管理、函数指针和回调函数等内容，通过对这些内容的深入学习和实际应用，可以提升C语言程序的效率和灵活性，实现更加复杂、功能丰富的程序设计和开发。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值