七、Python 函数

最新推荐文章于 2022-08-26 16:01:06 发布

码上开花

最新推荐文章于 2022-08-26 16:01:06 发布

阅读量564

点赞数 1

分类专栏： Python学习篇文章标签： python 学习 python函数 python 关键参数 python 参数传递 python 匿名函数

本文链接：https://blog.csdn.net/FireAny2010/article/details/104751246

版权

Python学习篇专栏收录该内容

12 篇文章 2 订阅

订阅专栏

Python 函数

1、函数的了解

1)函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段
2)函数能提高应用的模块性，和代码的重复利用
3)Python提供了许多内建函数，比如print()
4)自己创建函数，这被叫做用户自定义函数

2、定义一个函数

1)函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
2)任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
3)函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
4)函数内容以冒号起始，并且缩进。
5)return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

一般格式：
def 函数名（参数列表）:
函数体

3、参数传递

1) 在 python 中，对象才有类型，变量是没有类型的
例如：
a = [m,n,k]
b = '1234'
以上代码中，[m,n,k] 是 List 类型，'1234' 是 String 类型，
而变量 a 是没有类型，它仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，
也可以是指向 String 类型对象。

2) 可更改(mutable)与不可更改(immutable)对象
在 python 中，字符串、元组和 Number 是不可更改的对象，而 list,dict 等则是可以修改的对象。
不可变类型：
变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，
再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
可变类型：
变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

3) python 函数的参数传递：
不可变类型：
类似 c++ 的值传递，如整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。
比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：
类似 c++ 的引用传递，如列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

3.1 python 传对象实战

print('3.1 python 传不可变对象实例')
def ChangeInt(a):     #定义一个函数
    a = 10   #在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它

b = 2                             # 定义一个变量   实例中有 int 对象 2，指向它的变量是 b
ChangeInt(b)                      # 调用函数  按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，
print(f'b的值为{b}:')             # 格式化字符串输出， 结果依旧是 2   并没有改变对象的值


#3.2 传可变对象实例
print()
print('3.2 传可变对象实例')
def changeme(mylist):               #定义一个函数
    mylist.append([1, 2, 3, 4])
    print("函数内取值: ", mylist)
    return

# 调用changeme函数
mylist = [10, 20, 30]
changeme(mylist)
print("函数外取值: ", mylist)

3.3参数类型

以下是调用函数时可使用的正式参数类型：
必需参数
关键字参数
默认参数
不定长参数

3.3.1 必须参数

#3.3.1 必需参数
print()
print('3.3.1 必需参数')
#必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
def power(x):            #参数x就是一个必须参数，如果调用的时候不传入 就会报错
    return x*x

#调用并打印结果  如果 pow()不传参数就会报错
print('4的平方是：',power(4))

3.3.2 关键字参数

1)关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
2)使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值
3)关键字参数与普通参数混合的时候，只能从参数的最后面匹配,否则报错
注意：
是在调用的时候指定某个参数的值

def printStr(str,str1):
    print('输出的字符串：',str,'和',str1)

#调用该函数  printStr(str=23,'abc')  如果这样调用则报错，关键字参数与普通参数混合的时候，只能从参数的最后面匹配
printStr('abc',str1=123)
printStr(str1=123,str='abc')

3.3.3 默认参数

调用函数时，如果没有传递参数，则会使用默认参数
注意：
定义函数的时候就指定了某个参数的值

def printInfo(name,age=12):
    print('名字：',name)
    print('年龄：',age)

#调用  关键参数使用  全是关键参数的时候  参数传入顺序可以打乱
printInfo(age=20, name='XiaoMing')
print("------------------------")
#关键参数+默认参数  使用
printInfo(name="XiaoMing")
#默认参数  使用
printInfo("XiaoMing")

3.3.4 不定长参数

一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，声明时不会命名
语法格式一：
def functionname([formal_args,] *var_args_tuple ):
function_suite
return [expression]

这种语法传入的其实是一个元组，加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数

语法格式二：
def functionname([formal_args,] **var_args_dict ):
function_suite
return [expression]

这种语法参数带两个星号 **的会以字典的形式导入

# 语法格式一：传递一个元组
def printInfo(arg1, *vartuple):
    print("输出参数arg1: ",end='')
    print(arg1)
    print("输出元组参数vartuple: ",end='')
    print(vartuple)

# 调用printInfo 函数
printInfo(70, 60, 50)
# 这个时候 参数 vartuple并没有被赋值，所以打印出来就是一个空的元组
printInfo('abc')


# 语法格式二  传递一个字典
def printInfo(arg1, **vardict):
    print("输出参数arg1: ", end='')
    print(arg1)
    print("输出元组参数vardict: ", end='')
    print(vardict)

# 调用printinfo 函数
printInfo(1, a=2, b=3)

3.3.5 匿名函数

python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

1) lambda 只是一个表达式，函数体比 def 简单很多
2) lambda 的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去
3) lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数
4) 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率

#lambda 函数的语法只包含一个语句
'''
语法格式：
lambda [arg1 [,arg2,.....argn]]:expression
'''
#定义一个函数
sum = lambda arg1, arg2: arg1 + arg2
#调用函数
print('两数相加后之和为:',sum(3,2))

4、给大佬奉茶

实例如下：

#1、函数的了解
print()
print('1、函数的了解')
'''
1)函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段
2)函数能提高应用的模块性，和代码的重复利用
3)Python提供了许多内建函数，比如print()
4)自己创建函数，这被叫做用户自定义函数
'''

#2、定义一个函数
print()
print('2、定义一个函数')
'''
1)函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
2)任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
3)函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
4)函数内容以冒号起始，并且缩进。
5)return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

一般格式：
def 函数名（参数列表）:
    函数体
    
'''
# 计算面积函数
#定义一个函数
def area(width, height):
    return width * height

#调用函数 并打印出结果
print('长方形的面积=',area(212,369))

#3、参数传递
print()
print('3、参数传递')
'''
1)在 python 中，对象才有类型，变量是没有类型的
  例如：
     a = [m,n,k]
     b = '1234'
  以上代码中，[m,n,k] 是 List 类型，'1234' 是 String 类型，
  而变量 a 是没有类型，它仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，
  也可以是指向 String 类型对象。
2)可更改(mutable)与不可更改(immutable)对象
    在 python 中，字符串、元组和 Number 是不可更改的对象，而 list,dict 等则是可以修改的对象。
  不可变类型：
      变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，
      再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
  可变类型：
      变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

3)python 函数的参数传递：
   不可变类型：
        类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。
        比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
   可变类型：
        类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
'''
#3.1 python 传不可变对象实例
print()
print('3.1 python 传不可变对象实例')
def ChangeInt(a):     #定义一个函数
    a = 10   #在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它

b = 2                             # 定义一个变量   实例中有 int 对象 2，指向它的变量是 b
ChangeInt(b)                      # 调用函数  按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，
print(f'b的值为{b}:')             # 格式化字符串输出， 结果依旧是 2   并没有改变对象的值


#3.2 传可变对象实例
print()
print('3.2 传可变对象实例')
def changeme(mylist):               #定义一个函数
    mylist.append([1, 2, 3, 4])
    print("函数内取值: ", mylist)
    return

# 调用changeme函数
mylist = [10, 20, 30]
changeme(mylist)
print("函数外取值: ", mylist)

#3.3参数类型
'''
以下是调用函数时可使用的正式参数类型：
   必需参数
   关键字参数
   默认参数
   不定长参数
'''
#3.3.1 必需参数
print()
print('3.3.1 必需参数')
#必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
def power(x):            #参数x就是一个必须参数，如果调用的时候不传入 就会报错
    return x*x

#调用并打印结果  如果 pow()不传参数就会报错
print('4的平方是：',power(4))

#3.3.2 关键字参数
print()
print('3.3.2 关键字参数')
'''
1)关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
2)使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值
3)关键字参数与普通参数混合的时候，只能从参数的最后面匹配,否则报错
注意：
    是在调用的时候指定某个参数的值
'''
def printStr(str,str1):
    print('输出的字符串：',str,'和',str1)

#调用该函数  printStr(str=23,'abc')  如果这样调用则报错，关键字参数与普通参数混合的时候，只能从参数的最后面匹配
printStr('abc',str1=123)
printStr(str1=123,str='abc')

#3.3.3  默认参数
print()
print('3.3.3  默认参数')
'''
调用函数时，如果没有传递参数，则会使用默认参数
注意：
    定义函数的时候就指定了某个参数的值
'''
def printInfo(name,age=12):
    print('名字：',name)
    print('年龄：',age)

#调用  关键参数使用  全是关键参数的时候  参数传入顺序可以打乱
printInfo(age=20, name='XiaoMing')
print("------------------------")
#关键参数+默认参数  使用
printInfo(name="XiaoMing")
#默认参数  使用
printInfo("XiaoMing")

#3.3.4 不定长参数
print()
print('3.3.4  不定长参数')
'''
一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，声明时不会命名
语法格式一：
def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

这种语法传入的其实是一个元组，加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数


语法格式二：
def functionname([formal_args,] **var_args_dict ):
   "函数_文档字符串"
   function_suite
   return [expression]
   
   这种语法参数带两个星号 **的会以 字典 的形式导入
'''
# 语法格式一：传递一个元组
def printInfo(arg1, *vartuple):
    print("输出参数arg1: ",end='')
    print(arg1)
    print("输出元组参数vartuple: ",end='')
    print(vartuple)

# 调用printInfo 函数
printInfo(70, 60, 50)
# 这个时候 参数 vartuple并没有被赋值，所以打印出来就是一个空的元组
printInfo('abc')


# 语法格式二  传递一个字典
def printInfo(arg1, **vardict):
    print("输出参数arg1: ", end='')
    print(arg1)
    print("输出元组参数vardict: ", end='')
    print(vardict)

# 调用printinfo 函数
printInfo(1, a=2, b=3)

#3.3.5 匿名函数
print()
print('3.3.5 匿名函数')
'''
python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

1)lambda 只是一个表达式，函数体比 def 简单很多
2)lambda 的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去
3)lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数
4)虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率

'''
#lambda 函数的语法只包含一个语句
'''
语法格式：
lambda [arg1 [,arg2,.....argn]]:expression
'''
#定义一个函数
sum = lambda arg1, arg2: arg1 + arg2
#调用函数
print('两数相加后之和为:',sum(3,2))

所有输出结果

C:\Users\Administrator\AppData\Local\Programs\Python\Python38-32\python.exe F:/python-space/test/Function_study.py

1、函数的了解

2、定义一个函数
长方形的面积= 78228

3、参数传递

3.1 python 传不可变对象实例
b的值为2:

3.2 传可变对象实例
函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

3.3.1 必需参数
4的平方是： 16

3.3.2 关键字参数
输出的字符串： abc 和 123
输出的字符串： abc 和 123

3.3.3  默认参数
名字： XiaoMing
年龄： 20
------------------------
名字： XiaoMing
年龄： 12
名字： XiaoMing
年龄： 12

3.3.4  不定长参数
输出参数arg1: 70
输出元组参数vartuple: (60, 50)
输出参数arg1: abc
输出元组参数vartuple: ()
输出参数arg1: 1
输出元组参数vardict: {'a': 2, 'b': 3}

3.3.5 匿名函数
两数相加后之和为: 3223

Process finished with exit code 0