代码详解Python的函数基础(2)

目录
  • 1.函数参数
  • 2.递归函数
  • 总结

1.函数参数

# 1.位置参数:调用函数时,传入的值需要按照位置顺序传入
# 实例:求x的n次方
def xPowN(x,n):        # 传入的值按照x,n的位置顺序传入
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s
print("2的5次方的值为:",xPowN(2,5))
print("5的2次方的值为:",xPowN(5,2))
# 结果输出:
# 2的5次方的值为: 32
# 5的2次方的值为: 25
# 2.默认参数
# 实例:求x的n次方
def xPowN(x,n = 2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s
print("2的5次方的值为:",xPowN(2,5))      # 当n有新的值传入,则使用新值计算,如果没有,则默认
print("5的2次方的值为:",xPowN(5))        # n的值默认为2
print("---------------------------")
print("---------------------------")
# 设置默认参数的注意事项:
# 1.必选参数在前,默认参数在后;
# 2.当函数有多个参数时,把变化大的参数放在前面,变化小的参数放在后面;
# 变化小的参数可以作为默认参数;
# 3.使用默认参数可以降低调用函数的难度;
# 4.定义默认参数时,默认参数必须指向不变对象,如果是可变对象,则出现问题,如:list
# 实例:学生信息登记
def studentInfo(name,gender,age,city = "Shenzhen"):
    print("学生的名字为:",name)
    print("学生的性别为:",gender)
    print("学生的年龄为:",age)
    print("学生来自的城市为:",city)

print("同学1的信息如下:")
print("-----------------------------")
studentInfo("Willard","男",18)                # 使用默认参数Shenzhen
print("*****************************")
print("同学2的信息如下:")
print("-----------------------------")
studentInfo("ChenJD","女",18,"Maoming")        # 传入新的参数Maoming替换Shenzhen

# 结果输出:
2的5次方的值为: 32
5的2次方的值为: 25
---------------------------
---------------------------
同学1的信息如下:
-----------------------------
学生的名字为: Willard
学生的性别为: 男
学生的年龄为: 18
学生来自的城市为: Shenzhen
*****************************
同学2的信息如下:
-----------------------------
学生的名字为: ChenJD
学生的性别为: 女
学生的年龄为: 18
学生来自的城市为: Maoming

# 3.可变参数:传入的参数个数是可变的,可以是0、1、2到任意个
# 传统方式传入参数时,可以以list或tuple传入
# 实例(传统方式):
def sumOfN(intNumbers):
    sum = 0
    for n in intNumbers:
        sum = sum + n
    return sum
print("前100项累加和为:",sumOfN(range(101)))
print("前50项累加和为:",sumOfN(range(51)))
print("任意项累加和为:",sumOfN([1,2,5,6,7,8,9,10]))
print("任意项累加和为:",sumOfN((1,2,3,4,5,7,8,9,12)))
print("---------------------------------------------------------")
# 可变参数:在参数前添加*号
def sumOfN(*intNumbers):
    sum = 0
    for n in intNumbers:
        sum = sum + n
    return sum

print("任意项累加和为:",sumOfN(1,2,3,4,6,7,8,9))
print("任意项累加和为:",sumOfN(1,2,4))
print("任意项累加和为:",sumOfN(3,4,5,6,7))
print("---------------------------------------------------------")
# 把list或tuple作为可变参数传入
def sumOfN(*intNumbers):
    sum = 0
    for n in intNumbers:
        sum = sum + n
    return sum
# 已经有list,*nums表示把nums的所有元素作为可变参数传入
nums = [1,2,3,5]
print("传入一个list:",sumOfN(*nums))

# 结果输出:
前100项累加和为: 5050
前50项累加和为: 1275
任意项累加和为: 48
任意项累加和为: 51
---------------------------------------------------------
任意项累加和为: 40
任意项累加和为: 7
任意项累加和为: 25
---------------------------------------------------------
传入一个list: 11

# 4.关键字参数
# 可变参数允许传入任意个参数,这些可变参数在函数调用时自动组装为一个tuple;
# 关键字参数允许传入任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict;
def personInfo(name,age,**kw):
    print("name:",name,"age:",age,"other:",kw)

print("Willard个人信息:")
personInfo("Willard",18)
print("------------------------------------------------------------------")
print("Willard更详细的个人信息:")
personInfo("Willard",18,gender = "男",job = "Enginner")
print("------------------------------------------------------------------")
print("ChenJD个人信息:")
personInfo("ChenJD",18,gender = "女")
print("------------------------------------------------------------------")
# 关键字参数:可以扩展函数的功能
# Eg:用户注册功能,用户名和年龄是必填信息,其他信息均为可选
# 可以先组装出dict,然后把dict转换为关键字参数传入
extraInfo = {"gender":"Man","city":"Shenzhen","job":"Engineer"}
print("hackerLuo个人信息如下:")
personInfo("hackerLuo",18,gender = extraInfo["gender"],job = extraInfo["job"])
print("------------------------------------------------------------------")
# 使用简化写法
print("简化写法传入hackerLuo个人信息:")
personInfo("hackerLuo",18,**extraInfo)

# 结果输出:
Willard个人信息:
name: Willard age: 18 other: {}
------------------------------------------------------------------
Willard更详细的个人信息:
name: Willard age: 18 other: {'gender': '男', 'job': 'Enginner'}
------------------------------------------------------------------
ChenJD个人信息:
name: ChenJD age: 18 other: {'gender': '女'}
------------------------------------------------------------------
hackerLuo个人信息如下:
name: hackerLuo age: 18 other: {'gender': 'Man', 'job': 'Engineer'}
------------------------------------------------------------------
简化写法传入hackerLuo个人信息:
name: hackerLuo age: 18 other: {'gender': 'Man', 'city': 'Shenzhen', 'job': 'Engineer'}

# 5.命名关键字参数
# 函数调用者可以传入任意不受限制的关键字参数;
# 传入了哪些参数,需要在函数内通过kw检查;
def personInfo(name,age,**kw):
    if "city" in kw:
        pass
    if "job" in kw:
        pass
    print("name:",name,"age:",age,"other:",kw)

# 如果要限制关键字参数的名字,可以用命名关键字参数
# 只接收gender,job作为关键字参数
# 命名关键字参数需要*作为分隔符,*后面的参数视为命名关键字参数
# 命名关键字参数必须传入参数名
def personInfo(name,age,*,gender,job):
    print(name,age,gender,job)

# 调用方式:
print("命名关键字参数调用!")
personInfo("Willard",18,gender = "男",job = "Engineer")
print("------------------------------------------------------------------")
# 如果函数定义中已经有一个可变参数,则后面跟着命名关键字参数不需要*分隔符
def personInfo(name,age,*args,gender,job):
    print(name,age,args,gender,job)

# 命名关键字参数的缺省值
def personInfo(name,age,*,gender,job = "Engineer"):
    print(name,age,gender,job)

print("命名关键字参数有缺省值!")
personInfo("Willard",18,gender = "男")

# 结果输出:
命名关键字参数调用!
Willard 18 男 Engineer
------------------------------------------------------------------
命名关键字参数有缺省值!
Willard 18 男 Engineer

# 6.参数组合
# 常用参数:必选参数、默认参数、可变参数、关键字参数、命名关键字参数
# 参数定义顺序:必选参数、默认参数、可变参数、命名关键字参数、关键字参数
def egFunc1(name,age,gender = "男",*args,**kw):
    print("name:",name,"age:",age,"gender:",gender,"args:",args,"kw:",kw)
def egFunc2(name,gender = "男",*,job,**kw):
    print("name:",name,"gender:",gender,"job:",job,"kw:",kw)

# 调用
print("egFunc1传入name和age参数:")
egFunc1("Willard",18)
print("------------------------------------------------------------------")
print("egFunc1传入name,age,gender参数:")
egFunc1("ChenJD",18,"女")
print("------------------------------------------------------------------")
print("egFunc1传入name,age,gender,args参数:")
egFunc1("hackerLuo",18,"男",170,60)
print("------------------------------------------------------------------")
print("egFunc1传入name,age,gender,args,kw参数:")
egFunc1("Willard",18,"男",170,60,job = "Engineer")
print("------------------------------------------------------------------")
print("egFunc2传入name,gender,job,kw参数:")
egFunc2("Willard",job = "Engineer",ext = None)
print("------------------------------------------------------------------")
print("egFunc1通过tuple和dict传入参数:")
args = ("Willard",18,"男",170,60)
kw = {"job":"Engineer"}
egFunc1(*args,**kw)

# Tips:
# 1.默认参数一定要用不可变对象,如果是可变对象,程序运行时出现逻辑错误;
# 2.*args是可变参数,args接收的是一个tuple;
# 3.**kw是关键字参数,kw接收的是一个dict;
# 4.可变参数可以直接传入:func(1,2,3,4),也可以先组装list或tuple,
# 通过*args传入:func(*(1,2,3,4));
# 5.关键字参数可以直接传入:func(a = 1,b = 2),也可以先组装dict,
# 通过**kw传入:func(**{"a":1,"b":2});
# 6.命名关键字参数在没有可变参数的情况下需要写分隔符*

# 结果输出:
egFunc1传入name和age参数:
name: Willard age: 18 gender: 男 args: () kw: {}
------------------------------------------------------------------
egFunc1传入name,age,gender参数:
name: ChenJD age: 18 gender: 女 args: () kw: {}
------------------------------------------------------------------
egFunc1传入name,age,gender,args参数:
name: hackerLuo age: 18 gender: 男 args: (170, 60) kw: {}
------------------------------------------------------------------
egFunc1传入name,age,gender,args,kw参数:
name: Willard age: 18 gender: 男 args: (170, 60) kw: {'job': 'Engineer'}
------------------------------------------------------------------
egFunc2传入name,gender,job,kw参数:
name: Willard gender: 男 job: Engineer kw: {'ext': None}
------------------------------------------------------------------
egFunc1通过tuple和dict传入参数:
name: Willard age: 18 gender: 男 args: (170, 60) kw: {'job': 'Engineer'}

2.递归函数

# 在函数内部,可以调用其他函数,亦可以调用函数本身,则为递归函数
# 计算阶乘:n!=1×2×3...×n
def fact(n):
    if n == 1:
        return 1
    return n * fact(n - 1)

print("5的阶乘为:",fact(5))
print("100的阶乘为:",fact(50))
# print("10000的阶乘为:",fact(10000))
# print("10000的阶乘为:",fact(10000))    # 栈溢出
# 在计算机中,函数调用是通过栈数据结构实现,每进入一个函数调用,
# 栈会加一层栈帧,当函数返回,栈减少一层栈帧,递归调用次数过多,会导致栈溢出;
# 读者尝试fact(1000),fact(10000),可能fact(1000)就已经栈溢出,
# 笔者测试fact(1000)还是可以正常输出的,fact(10000)栈溢出

# 结果输出:
5的阶乘为: 120
100的阶乘为: 30414093201713378043612608166064768844377641568960512000000000000

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

(0)

相关推荐

  • python基础之类型转换函数

    类似于and操作 类似于or操作 # 类型转换 # sorted li=[2,45,1,67,23,10] li.sort() #list的排序方法 print(li) # sorted li=[2,45,1,67,23,10] # li.sort() #list的排序方法 print(li) # sorted() sorted(li) print(li) # 类型转换 # sorted li=[2,45,1,67,23,10] # li.sort() #list的排序方法 print(li)

  • Python基础知识之函数,类,模块

    目录 1.Function 函数 1)定义函数 2)参数设置 3)全局和局部变量 2.Class类 1)定义class 2)class的功能 3)继承 4)私有属性和功能 5)特殊方法 3.Module模块 1)引用module 2)大项目的模块管理 总结 1.Function 函数 编程中,需要重复写的功能,可以包装成一个函数 1)定义函数 定义函数之前,实现给一个字符串增加前缀和后缀的操作: f1 = "f1" f2 = "f2" f1 += ".tx

  • python基础之递归函数

    # 递归满足的条件 # 1.自己调用自己 # 2.必须有一个明确的结束条件 # 优点:逻辑简单\定义简单 # 缺点:防止内存消耗过多,容易导致栈溢出,内存资源紧张,甚至内存泄漏事件发生 # 求阶乘 # 循环的方式去实现 def jiecheng(n): result=1 for item in range(1,n+1): result*=item pass return result #普通函数必须指定返回值 print('4的阶乘为{}'.format(jiecheng(4))) def di

  • python基础之函数的定义和调用

    # 第一题 # 写函数,接受n个数字,求这些参数数字的和 def sumFunc(*args): # 处理接受的数据 result=0 for item in args: result+=item pass return result pass # 调用 rs=sumFunc(1,2,3,4) print('rs={}'.format(rs)) #填坑法 format格式化输出 # 写函数找出传入的列表或元组的奇数位对应的元素,并返回一个新的列表 def processFunc(con): li

  • Python编程基础之函数和模块

    目录 二.函数 (一)定义函数 1.语法格式 2.函数类型 3.案例演示 (二)调用函数 1.简要说明 2.案例演示 (三)函数参数 1.参数的多态性 2.参数赋值传递 三.利用函数实现模块化 1.创建多级菜单系统 2.启动程序,查看效果 总结 一.函数和模块概述 (一)函数概述 函数可以看成是语句的集合,通过函数调用来执行其包含的语句.函数可以返回一个计算结果,根据每次函数调用的参数,可以返回不同的计算结果.Python利用函数提高代码的重用率,减少了代码冗余. 执行dir(__builtin

  • python基础之内置函数

    https://docs.python.org/3/library/function.html #python官方网址 # 取绝对值 print(abs(-34)) # 取参数的近似值,精度与版本有关 print(round(3.66)) # 求次方 print(3**5) print(pow(3,5)) #求3的5次方 # max求最大值 print(max([23,123,13455,14664345,243565])) # eval 执行表达式 a,b,c=1,2,3 print('动态执

  • python基础之匿名函数介绍

    目录 前言 一.创建一个匿名函数: 二.创建一个带参数的匿名函数 三.求两个数的中的最大的值 四.练习题: 前言 在定义函数的时候,不想给函数起一个名字.这个时候就可以用lambda来定义一个匿名函数 语法: 变量名= lambda 参数:表达式(block) 参数:可选,通常以逗号分隔的变量表达式形式,也就是位置参数 表达式:不能包含循环.return,可以包含if-else- 注意: 1.表达式中不能包含 循环,return.可以包含 if-else-语句. 2.参数可有可无,如果有多个参数

  • Python基础学习之深浅拷贝问题及递归函数练习

    目录 一.深浅拷贝问题 二.递归函数练习 1. 求阶乘 2. 猴子吃桃问题 3. 打印斐波那契数列 一.深浅拷贝问题 在实际工作中,经常涉及到数据的传递,在数据传递使用过程中,可能会发生数据被修改的问题.为了防止数据被修改,就需要在传递一个副本,即使副本被修改,也不会影响原数据的使用.为了生成这个副本,就产生了拷贝.下面先了解一下几个概念:对象.可变类型.引用 Python对象:在 Python 中,对象有一种很通俗的说法是,万物皆对象.说的就是构造的任何数据类型都是一个对象,无论是数字,字符串

  • 代码详解Python的函数基础(1)

    目录 1.函数调用 2.函数定义 总结 1.函数调用 # 1.调用函数,需要知道函数的名称和参数 # 2.调用函数传入的参数需要和函数定义的参数数量和类型一致 # 如调用abs函数 print("-2的绝对值为:",abs(-2)) print("100的绝对值为:",abs(100)) # 3.函数名是指向一个函数对象的引用,可以把函数名赋给一个变量,相当于给这个函数起别名 abs1 = abs # 变量abs1指向abs函数 print("-1的绝对值

  • 代码详解Python的函数基础(2)

    目录 1.函数参数 2.递归函数 总结 1.函数参数 # 1.位置参数:调用函数时,传入的值需要按照位置顺序传入 # 实例:求x的n次方 def xPowN(x,n): # 传入的值按照x,n的位置顺序传入 s = 1 while n > 0: n = n - 1 s = s * x return s print("2的5次方的值为:",xPowN(2,5)) print("5的2次方的值为:",xPowN(5,2)) # 结果输出: # 2的5次方的值为:

  • 详解Python+OpenCV进行基础的图像操作

    目录 介绍 形态变换 腐蚀 膨胀 创建边框 强度变换 对数变换 线性变换 去噪彩色图像 使用直方图分析图像 介绍 众所周知,OpenCV是一个用于计算机视觉和图像操作的免费开源库. OpenCV 是用 C++ 编写的,并且有数千种优化的算法和函数用于各种图像操作.很多现实生活中的操作都可以使用 OpenCV 来解决.例如视频和图像分析.实时计算机视觉.对象检测.镜头分析等. 许多公司.研究人员和开发人员为 OpenCV 的创建做出了贡献.使用OpenCV 很简单,而且 OpenCV 配备了许多工

  • 详解Python map函数及Python map()函数的用法

    python map函数 map()函数 map()是 Python 内置的高阶函数,它接收一个函数 f 和一个 list,并通过把函数 f 依次作用在 list 的每个元素上,得到一个新的 list 并返回. 例如,对于list [1, 2, 3, 4, 5, 6, 7, 8, 9] 如果希望把list的每个元素都作平方,就可以用map()函数: 因此,我们只需要传入函数f(x)=x*x,就可以利用map()函数完成这个计算: def f(x): return x*x print map(f,

  • 详解Python匿名函数(lambda函数)

    匿名函数lambda Python使用lambda关键字创造匿名函数.所谓匿名,意即不再使用def语句这样标准的形式定义一个函数.这种语句的目的是由于性能的原因,在调用时绕过函数的栈分配.其语法是: lambda [arg1[, arg2, ... argN]]: expression 其中,参数是可选的,如果使用参数的话,参数通常也会在表达式之中出现. 下面举例来说明lambda语句的使用方法(无参数). # 使用def定义函数的方法 def true(): return True #等价的l

  • 详解python while 函数及while和for的区别

    1.while循环(只有在条件表达式成立的时候才会进入while循环) while 条件表达式: pass while 条件表达式: pass else: pass 不知道循环次数,但确定循环条件的时候用while # 如果说年利率是6%,存入1000到第几年本钱翻倍 money = 10000 year = 0 while money < 20000: money = money*(1+0.06) year += 1 print('第 {0} 年本钱翻倍了,总共有 {1} 元'.format(

  • 详解python eval函数的妙用

    python eval函数功能:将字符串str当成有效的表达式来求值并返回计算结果. 函数定义: eval(expression, globals=None, locals=None) 将字符串str当成有效的表达式来求值并返回计算结果.globals和locals参数是可选的,如果提供了globals参数,那么它必须是dictionary类型:如果提供了locals参数,那么它可以是任意的map对象. python的全局名字空间存储在一个叫globals()的dict对象中:局部名字空间存储在

  • 详解Python的函数与异常

    目录 1. 函数 1.1 自定义函数 1.2 函数与参数 1.3 函数与返回值 2. 异常处理 2.1 raise 语句 2.2 异常捕获 2.3 finally 子句 总结 1. 函数 抽象是程序能够被人理解的关键所在.程序应非常抽象,如获取用户输入构造列表,查找列表中最大的值,并进行打印: list_a = get_input() max_value = max(list_a) print(max_value) 看到这些代码,可以很容易这个程序是做什么的,至于这些操作的具体细节,将在独立的函

  • 详解Python函数可变参数定义及其参数传递方式

    Python函数可变参数定义及其参数传递方式详解 python中 函数不定参数的定义形式如下 1. func(*args)  传入的参数为以元组形式存在args中,如: def func(*args): print args >>> func(1,2,3) (1, 2, 3) >>> func(*[1,2,3]) #这个方式可以直接将一个列表的所有元素当作不定参数 传入(1, 2, 3) 2.func( **kwargs) 传入的参数为以字典形式存在args中,如: d

  • python操作列表的函数使用代码详解

    python的列表很重要,学习到后面你会发现使用的地方真的太多了.最近在写一些小项目时经常用到列表,有时其中的方法还会忘哎! 所以为了复习写下了这篇博客,大家也可以来学习一下,应该比较全面和详细了 列表(list): 用来存放相同或者不同元素(字符)用逗号隔开的一个存储方式. list我个人认为最重要的有一点大家可能都容易忽略那就是复制列表,这点文章最后来讲解 定义三个列表的样例 lis = [1, 2, 3, 4, 5, 6] lis = ['a', 'b', 'c', 'd'] lis =

随机推荐