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