Python基础-函数,高阶函数

最新推荐文章于 2020-08-19 16:24:25 发布
最新推荐文章于 2020-08-19 16:24:25 发布
阅读量350 收藏
点赞数
分类专栏： python 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15204179/article/details/104593248
版权

                                  Python基础-函数

 

1.函数的定义和函数的执行流程:

"""
函数学习
"""

print('程序开始')
a = 10 # 在内存中申请内存  内存名称就是a

# 定义函数
def sayHello(): # 函数的定义: 并不会执行函数,只是在内存中做了标识
    print('hello world')
    print('hello world')


# 调用函数
sayHello() # 根据标识 找到函数并执行 函数执行结束 调用才结束

print('程序结束')

函数使用:

# 定义具备打印佛祖镇楼图 功能函数
def printFoZu():
    print("                            _ooOoo_  ")
    print("                           o8888888o  ")
    print("                           88  .  88  ")
    print("                           (| -_- |)  ")
    print("                            O\\ = /O  ")
    print("                        ____/`---'\\____  ")
    print("                      .   ' \\| |// `.  ")
    print("                       / \\||| : |||// \\  ")
    print("                     / _||||| -:- |||||- \\  ")
    print("                       | | \\\\\\ - /// | |  ")
    print("                     | \\_| ''\\---/'' | |  ")
    print("                      \\ .-\\__ `-` ___/-. /  ")
    print("                   ___`. .' /--.--\\ `. . __  ")
    print("                ."" '< `.___\\_<|>_/___.' >'"".  ")
    print("               | | : `- \\`.;`\\ _ /`;.`/ - ` : | |  ")
    print("                 \\ \\ `-. \\_ __\\ /__ _/ .-` / /  ")
    print("         ======`-.____`-.___\\_____/___.-`____.-'======  ")
    print("                            `=---='  ")
    print("  ")
    print("         .............................................  ")
    print("                  佛祖镇楼                  BUG辟易  ")
    print("          佛曰:  ")
    print("                  写字楼里写字间，写字间里程序员；  ")
    print("                  程序人员写程序，又拿程序换酒钱。  ")
    print("                  酒醒只在网上坐，酒醉还来网下眠；  ")
    print("                  酒醉酒醒日复日，网上网下年复年。  ")
    print("                  但愿老死电脑间，不愿鞠躬老板前；  ")
    print("                  奔驰宝马贵者趣，公交自行程序员。  ")
    print("                  别人笑我忒疯癫，我笑自己命太贱；  ")
    print("                  不见满街漂亮妹，哪个归得程序员？")

# 调用函数
printFoZu()
printFoZu()
printFoZu()
printFoZu()
printFoZu()
 

函数的文档注释:

def sayHello1():
    '''
    这是给张曼玉打招呼方法
    :return:
    '''
    print('hello 张曼玉')

def sayHello2():
    '''
    这是给林青霞打招呼的方法
    :return:
    '''
    print('hello 林青霞')


# 调用林青霞     Ctrl+Q
sayHello1()
sayHello2()

函数的参数:


"""------------------ 一个参数的函数 ------------------"""
# def sayHello(name):
#     '''
#     这是给女神打招呼方法
#     :param name: 传递女神姓名
#     :return:
#     '''
#     print('hello %s'%name)
#
# # 调用函数
# sayHello('高圆圆')


"""------------------ 两个参数的函数 ------------------"""
# 定义函数,传递a和b,求a+b的和
def sum(a,b):
    '''
    这个函数是求两个数据的和
    :param a: 第一个数据
    :param b: 第二个数据
    :return:
    '''
    result = a+b
    print(result)

# 调用
sum(10,20)

函数参数练习:

"""
任意给出两个数字,可以打印最大的数字值
"""
a = 30
b = 20

# 定义函数 求两个数最大值
def myMax(m,n):
    '''
    求两个数最大值
    :param m: 第一个数
    :param n: 第二个数
    :return:
    '''
    if m>n:
        print('最大值',m)
    else:
        print('最大值',n)

# myMax(10,20)
myMax(a,b)

函数形参和实参:


a = 10
print('程序开始')
b = 20
def myMax(m,n):# 形参 函数定义时,并没有创建出形参  函数调用的时候才会将实参传递给形参 只要函数执行完成 形参就销毁了
    if m>n:
        print('最大值',m)
    else:
        print('最大值',n)

# myMax(10,20)
myMax(10,20) # 10 20 实参

# print(m)
print('程序结束')
print(a)
print(b)

函数形参作用域:

# 形参作用域在函数内部
# 形参会在函数执行结束之后就销毁
# 不同的函数中可以定义同名的形参
# 形参作用域:避免参数定义重名
def sayHello(name,a): # 形参
    print('hello %s'%name)

def func1(name):
    print(name)
    # print(a)

# print(name)
sayHello('张三')# 实参
func1('李四')
# a = 10
# a = 20

函数返回值:

"""
希望前面求最大值的函数能够将最大值返回
"""

"""
任意给出两个数字,可以打印最大的数字值
"""
a = 30
b = 20

# 定义函数 求两个数最大值
def myMax(m,n):
    '''
    求两个数最大值
    :param m: 第一个数
    :param n: 第二个数
    :return:返回最大值
    '''
    if m>n:
        return m
    else:
        return n

# myMax(10,20)
result = myMax(a,b)
print(result)

函数类型:

"""
函数名不能重名
"""
"""------------------ 无参无返回值函数 ------------------"""
def sayHello():
    print('hello')
"""------------------ 无参有返回值函数 ------------------"""
import random
def getTemp():
    return random.randint(0,100)
"""------------------ 有参无返回值函数 ------------------"""
def sayHello2(name):
    print('hello %s'%name)
"""------------------ 有参有返回值函数 ------------------"""
def sum(a,b):
    return a+b

# print(getTemp())
sayHello2('张曼玉')

函数练习:

# 求三个数和的函数
def sum(a,b,c):
    '''
    求三个数的和
    :param a: 第一个数
    :param b: 第二个数
    :param c: 第三个数
    :return:  返回int数据
    '''
    return a+b+c
    # print('hello')

# result = sum(10,20,30)
# print(result)

def func(a,b,c):
    '''
    求三个数平均值
    :param a:
    :param b:
    :param c:
    :return:
    '''
    return (a+b+c)/3


print(func(10, 20, 30))

函数的嵌套调用:

a = 10
print('程序开始')
def func1():
    print('func1开始')
    print('func1结束')


def func2():
    print('func2开始')
    func1()
    print('func2结束')


# 调用func2
func2()

print('程序结束')







"""
需求1
定义一个 print_line 函数能够打印 * 组成的 一条分隔线,长度50
需求2
定义一个函数能够打印 由任意字符组成 的分隔线,长度50
需求3
定义一个函数能够打印 任意长度 的分隔线
需求4
定义一个函数能够打印 5 行 的分隔线，分隔线要求符合需求 3


"""

import random
# 定义一个 print_line 函数能够打印 * 组成的 一条分隔线,长度50
# def print_line():
#     print('*'*50)
# print_line()

# 定义一个函数能够打印 由任意字符组成 的分隔线,长度50
# def print_line(str):
#     '''
#     打印任意字符组成的分隔线
#     :param str: 组成分割线的字符
#     :return: 无返回值
#     '''
#     print(str*50)

# print_line('-')

# 定义一个函数能够打印 任意长度 的分隔线
def print_line(str,length):
    '''
    打印任意字符组成的分隔线
    :param str: 组成分割线的字符
    :param length: 分割线的长度
    :return: 无返回值
    '''
    print(str*length)

# print_line('_',40)


# 定义一个函数能够打印 5 行 的分隔线，分隔线要求符合需求 3
def printFiveLine(strList):
    for index in range(5):
        # 随机获取字符
        index = random.randint(0,len(strList)-1)
        str = strList[index]
        print_line(str,random.randint(20,50))

printFiveLine(['*','_','@'])

局部变量和全局变量:

# 全局变量
m = 10
n = 20

print('程序开始')
def func(a):# 形参a
    # 局部变量

    # 变量生命周期:调用函数并且执行到定义局部变量代码时创建  函数执行结束就会销毁
    # 变量作用域:函数内部可以使用局部变量 超出函数不能使用
    # 如果形参名和局部变量名一致 在局部变量定义后使用的都是局部变量
    print(a)
    a = 10 # 局部变量
    print('hello world %d'%a)
    print('m是:',m)

def func1():
    b = 20
    # print(a)
    print('hello%d'%b)

# print(a)
func(30)
# func1()
# print('程序结束')

函数内修改全局变量:

"""
函数内部修改全局变量 需要在使用前加上global关键字
"""

# 定义全局变量
m = 10

def func():
    # 将m修改成20
    # 定义了局部变量m 值是30
    global m
    m = 30
    print('函数内部m=%d'%m)

# 函数调用前打印m
print('函数调用前m:%d'%m)
func()
# 函数调用后打印m
print('函数调用后m:%d'%m)

函数多返回值:

"""
需求:
需求:定义函数接收参数a和参数b,并返回a和b的和以及a和b的差

"""
# go

def cacl(a, b):
    '''
    求a+b以及a-b的结果
    :param a:
    :param b:
    :return:
    '''
    sum = a + b
    result = a-b
    return sum,result # 返回多个数据,把多个数据进行组包 变成元组返回出去

# result = cacl(10,20)
sum,result = cacl(10,20)
print(sum,result)

# open:
# success,file = open()

 

2.高阶函数

"""
需求:
1.定义一个求两个数和的函数
2.定义一个求两个数差的函数
3.定义一个函数既可以求和又可以求差

"""


# 1.定义一个求两个数和的函数
def sum(a, b):
    '''
    求两个数的和
    :param a:
    :param b:
    :return:
    '''
    return a + b


# 2.定义一个求两个数差的函数
def sub(a, b):
    return a - b

def div(a,b):
    return a/b

m = 10
n = 20


# print(sum(m, n))
# print(sub(m,n))
# 3.定义一个函数既可以求和又可以求差
# def cacl(a,b):
#     return a+b,a-b

# result1,result2 = cacl(m,n)
# print(result1,result2)
"""------------------ 高阶函数 ------------------"""
# 函数中有函数参数的函数称为高阶函数
# 数据  运算规则
def cacl(a, b, func):
    '''
    根据传递的计算规则 将两个数据处理完返回结果
    :param a:
    :param b:
    :param func: 计算规则,函数类型
    :return:
    '''
    # 调用func<=>sum
    return func(a, b)


# 调用cacl 求m和n的和
# cacl(m,n,sum) # 传递函数 只需要传递函数名
# result = cacl(m, n, sum)
# print(result)
# 通过cacl求m和n的差
# result = cacl(m,n,sub)
# print(result)

# 求m和n的商
# result = cacl(m,n,div)
# print(result)

"""------------------ 返回值为函数的高阶函数 ------------------"""
def func():
    return sum

result = func()
# print(result)
# 调用result
print(result(20, 30))

 

lambda表达式:

"""
需求:
1.定义一个求两个数和的函数
2.定义一个求两个数差的函数
3.定义一个函数既可以求和又可以求差

"""

m = 10
n = 20

def cacl(a, b, func):
    '''
    根据传递的计算规则 将两个数据处理完返回结果
    :param a:
    :param b:
    :param func: 计算规则,函数类型
    :return:
    '''
    # 调用func<=>sum
    return func(a, b)
"""------------------ lambda表达式:不要通过return返回数据 ------------------"""
# 第三个参数就可以通过lambda表达式传递
# result = cacl(m,n,lambda a,b:a+b)
# print(result)

"""------------------ 通过变量保存lambda表达式 ------------------"""
# func = lambda a,b:a+b
# print(func(20, 30))

"""------------------ lambda表达式其它写法 ------------------"""
# python的lambda表达式比较简单 只适用于替换函数体只有一行代码的函数
# python的lambda表达式  :后面只能有一行代码
def myMax(a,b):
    if a>b:
        return a
    else:
        return b

# 通过lambda表达式替换myMax
func = lambda a,b:a if a>b else b
result = func(10,20)
print(result)

 

sort函数:

"""
l = ['abd','ewetrwef','fered','qwszfgfsaffs']
元素按照长度从小到大排序
"""
# l = ['abd','qwszfgfsaffs','ewetrwef','fered']
#    'a'     'q'     'e'   'f'
#     a       e       f     q
# 默认排序方式 依次比较字符 比较出大小即可
# l.sort()
# print(l)

# [3  12  8  5]
# [3  5   8   12]
# def func(ele):
#     return len(ele)

# 元素按照长度从小到大排序
# def sort(key):
#     row = 0
#     while row < len(l) - 1:
#         col = 0
#         while col<len(l)-1-row:
#             # 当前元素:  l[col]
#             # 下一个元素:l[col+1]
#             # 如果下一个元素比当前元素小 交换
#             # if l[col]>l[col+1]:
#             if key(l[col])>key(l[col+1]):
#                 # 交换
#                 tmp = l[col]
#                 l[col]=l[col+1]
#                 l[col+1] = tmp
#
#             col += 1
#         row += 1
#
#     print(l)

# 使用高阶函数
# l.sort(key=func)
# print(l)

# l.sort(key=lambda ele:len(ele))
# print(l)

l = ['abd','qwszfgfsaffs','ewetrwef','fered']
# 列表按照最后一个元素进行排序
l.sort(key=lambda ele:ele[len(ele)-1])
print(l)

map:

"""
[1, 2, 3, 4, 5, 6, 7, 8, 9]
将列表中元素变成它的平方

"""
l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 将列表中元素变成它的平方
# index = 0
# while index < len(l):
#     l[index] = l[index] ** 2
#     index += 1
#
# print(l)

def func(ele):
    return ele**2
# map
# map 两个参数:第一个参数:函数  第二个参数:容器
# 遍历容器每一个元素 传递给函数  处理完之后返回
# result = map(func,l)
# print(list(result))

result = map(lambda ele:ele**2,l)
print(list(result))

filter:

"""
l = ['林青霞','张曼玉','胡慧中','高圆圆','张曼玉']
       false   true    false   false   true
找到列表中所有的张曼玉
"""
l = ['张三','林青霞','张曼玉','胡慧中','高圆圆','张曼玉']

def func(ele):
    return ele=='张曼玉'
# 两个参数
# 第一个参数:function  参数接收元素  返回True或False
# result = filter(func,l)
# print(list(result))

# result = filter(lambda ele:ele=='张曼玉',l)
# print(list(result))

# 找到列表中所有姓张的
result = filter(lambda ele:ele[0]=='张',l)
print(list(result))

 

 

_无往而不胜_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
python 函数
宋星愿测试博客
07-03 177
函数通过def关键字定义。def关键字后跟一个函数的 标识符 名称，然后跟一对圆括号。圆括号 之中可以包括一些变量名，该行以冒号结尾。接下来是一块语句，它们是函数体。 def sayHello(): print ('hello python') sayHello() 结果： hello python 函数取得的参数是你提供给函数的值，这样函数就可以利用这些值 做...
查找字符个数--查找一个字符串中第一个只出现两次的字符。比如：“abcdefabcdefabc”中第一个只出现两次为‘d’，要求时间复杂度为O(N)，空间复杂度为O(1)
sayhello_world的博客
07-19 965
思路： 建立一个str2[256]的定长数组存放字符个数。 先遍历str1，将str1的元素个数逐个写入str2对应的下标处。 由于要找第一个出现的，所以遍历str1，按照每个元素依次查找，找到次元素对应下标的str2==‘2’的时候，返回该元素。这里有两个循环但是不嵌套，所以时间复杂度O（N），用到了一个定长的辅助空间，所以空间复杂度也满足题意。char FindSencond(char *
python语言篇（7练习4）
Jason_Edison的博客
03-27 207
# 02_def_mymax.py # 此示例示意定义一个带有参数的函数: def mymax(a, b): if a > b: print("最大数是", a) else: print("最大数是", b) # 调用带有参数的函数, 第一个实参100给形参a, 第二个... mymax(100, 200) mymax(10000, ...
Python150（分隔线演练01—利用参数增加分隔线的灵活度）
weixin_42681308的博客
10-31 636
函数嵌套的演练——打印分隔线 体会一下工作中需求是多变的 需求1 定义一个print_line函数能够打印*组成的一条分隔线 需求2 定义一个函数能够打印由任意字符组成的分隔线 需求3 定义一个函数能够打印任意重复次数的分隔线    ...
Python151（分隔线演练02—打印多条分隔线）
weixin_42681308的博客
11-01 1733
需求4 定义一个函数能够打印5行的分隔线，分隔线要求符合需求3 提示：工作中针对需求的变化，应该冷静思考，不要轻易修改之前已经完成的，能够正常执行的函数！ ...
python基础-函数详解
12-21
例如，`map()`、`filter()`和`reduce()`等内建函数，以及`lambda`表达式，都是高阶函数的例子。 **六、函数的注意事项** 1. 避免过大的函数，遵循“单一职责原则”，每个函数应只做一件事情。 2. 使用`return`语句...
详解Python高阶函数
09-16
【Python高阶函数详解】 高阶函数是Python编程中一种非常重要的特性，它是指能够接收一个或多个函数作为参数，并且能够返回一个函数或者对函数进行操作的函数。这一概念基于Python语言中函数也是对象的基本原理，即...
python- 笔记 高阶函数map reduce fileter
12-20
在Python编程语言中，高阶函数是能够接受一个或多个函数作为参数，或者返回一个函数的函数。在Python中，有三个重要的高阶函数：`map()`、`reduce()` 和 `filter()`，它们在处理数据时非常有用。下面将详细解释这三...
python高阶函数心得笔记,python高阶函数知识.doc
10-01
Python 高阶函数心得笔记 1. 递归函数 递归函数是一种特殊的函数，它可以调用自己本身。递归函数的作用是将复杂的问题分解成更小的子问题，然后通过解决这些子问题来解决原始的问题。例如，计算阶乘 n! = 1 * 2 * ...
Python中函数的定义及其调用
热门推荐
柠檬精哒博客
07-19 17万+
所谓函数，就是把具有独立功能的代码块组织成为一个小模块，在需要的时候调用 函数的使用包含两个步骤 1.定义函数–封装独立的功能 2.调用函数–享受封装的成果 函数的作用:在开发时，使用函数可以提高编写的效率以及代码的重用‘’ 函数： 函数是带名字的代码块，用于完成具体的工作 需要在程序中多次执行同一项任务时，你无需反复编写完成该任务的代码，而只需调用该...
Python学习入门基础 -- 第五章 函数基础、函数进阶
hhladminhhl的博客
08-19 2547
一、函数基础 函数的快速体验 函数的基本使用 函数的参数 函数的返回值 函数的嵌套调用 在模块中定义函数 01. 函数的快速体验 1.1 快速体验 所谓函数，就是把 具有独立功能的代码块 组织为一个小模块，在需要的时候 调用 函数的使用包含两个步骤： 定义函数 —— 封装 独立的功能 调用函数 —— 享受 封装 的成果 函数的作用，在开发程序时，使用函数可以提高编写的效率以及代码的 重用 演练步骤 新建 04_函数 项目 复制之前完成的 乘法表 文件 修改文件，增加函数定义 multiple
Python3基础知识学习（二）
远方
08-25 393
for循环 可以用for循环来迭代一系列数值。for循环的一般形式是： for var in sequence: 缩进代码块 其中sequence可以是等差数列、字符串、列表、元组或者是一个文件对象。变量依次被赋予序列中的每个值，然后在缩进的语句块中的语句将在每一次赋值后执行依次，直到每个值都被执行。 for循环常见错误 range()可以用来产生一个等差数列。如果m和n是...
Python中的函数
qq_39376481的博客
03-24 421
1.Python中的函数定义 (1)定义函数 #如果不主动调用函数，函数不会执行 -------->题目要求 定义一个名为say_hello的值，使其可以输出hello的值 -------->代码如下 #如果不主动调用函数，函数不会执行 def say_hello(): print('hello1') print('hello2') print('hello3'...
cacl的使用
weixin_30337251的博客
07-25 697
1、居中元素 使用calc()给我们提供另一个垂直元素的解决方案。如果我们知道元素的尺寸，一个典型的解决方案使用负外边距移动自身距离高于宽的一般，如下： /*对于300px*300px*/ position:absolute; top: 50%; left: 50%; margin-top: -150px; margin-left: -150px; 如果使用calc()函数，那么我...
Python学习第五课 函数基础
黎明前最后的黑暗的博客
04-11 280
函数基础 目标 ● 函数的快速体验 ● 函数的基本使用 ● 函数的参数 ● 函数的返回值 ● 函数的嵌套调用 ● 在模块中定义函数 01.函数的快速体验 1.1 快速体验 ● 所谓函数，就是把具有独立功能的代码块组织为一个小模块，在需要的时候调用 ● 函数的使用包括两个步骤： 1、定义函数——封装独立的功能 2、调用函数——享受封装的成果 ● 函数的作用，在开发程序时，使用函数可以提高编写的效率以...
Python函数的参数（有问题）
qq_42194697的博客
08-07 149
位置参数 def enroll(name,gender): print('name: ', name) print('gender: ', gender) enroll('张三丰','本科') 默认参数 def enroll(name, gender, age=66, city='Wudang'): print('name: ', name) print(...
（九）python 传参，函数定义
zh__quan的博客
08-19 1034
目录 函数的定义: return 语句 函数的参数传递     位置传参:        序列传参：     关键字传参:     字典关键字传参：     函数的综合传参: 函数的定义和创建时形参的定义     函数形参的定义方式:     函数的参数说明： 函数的定义:     def 函数名(形参列表)         语句块     作用:         创建一...
python中函数的定义和使用---函数基础
Fantasy_worm的博客
08-12 727
函数基础   01. 函数的快速体验 1.1 快速体验 所谓函数，就是把 具有独立功能的代码块 组织为一个小模块，在需要的时候 调用 函数的使用包含两个步骤： 定义函数 —— 封装 独立的功能 调用函数 —— 享受 封装 的成果 函数的作用，在开发程序时，使用函数可以提高编写的效率以及代码的 重用 02. 函数基本使用 2.1 ...
python期末复习精简版
weixin_40184069的博客
07-03 950
期末复习精简版 第1章 1.6 Python编程规范与代码优化建议 注释 以符号#开始，表示本行#之后的内容为注释。 缩进 类定义、函数定义、选择结构、循环结构、with快，行尾的冒号表示缩进的开始。 Python是依靠代码块的缩进来体现代码之间的逻辑关系的，缩进结束就表示一个代码块结束了。 同一个级别的代码块的缩进量必须相同。 以4个空格为基本缩进单位。 最好在每个类、函数定义和一段完整的功能代码之后增加一个空行 尽量不要写过长的语句。如果语句确实太长而超过屏幕宽度，最好使用续行符\，
Python基础：函数作用域与高阶函数
在Python中，`map`、`filter`和`sorted`等都是内建的高阶函数。`map`函数接收一个函数和一个或多个可迭代对象，然后将函数应用于可迭代对象的每个元素，返回一个新的可迭代对象。例如，可以使用`map`函数和自定义的`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_无往而不胜_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值