编程方法：
1、面向对象：类--class
2、面向过程：过程--def
3、函数式编程：函数--def
# python中函数 # 函数的定义 # 打印一个佛祖镇楼 -> 一个功能点的解释 def print_info():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(" 不见满街漂亮妹，哪个归得程序员？") a = 10 if a == 10: # pass 占位 防止语法错误 print_info() # 函数 -> python
函数是逻辑结构化和过程化的一种编程方法
python中函数定义方法：
def test(x): "The function definitions" x+=1 return x
def：定义函数的关键字
test :函数名
（）：内可定义形参
“”：文档描述（非必要，但是强烈建议为你的函数添加描述信息）
x+=1：泛指代码块或程序处理逻辑
return：定义返回值
#函数 def func1(): "testing1" print("in the func1") return 0 #过程 def func2(): "testing2" print("in the func2") x = func1() # in the func1 y = func2() # in the func2 print("from func1 return is %s"%x) # from func1 return is 0 print("from func2 return is %s"%y) # from func2 return is None
使用函数的三大优点：
1.代码重用
2.保持一致性
3.可扩展性
函数返回值
返回值数=0:返回None（没有return的情况）
返回值数=1:返回object
返回值数>1:返回tuple(返回一个元组)
如：
def test01(): pass def test02(): return 0 def test03(): return 0,10,'Hello',['alex','lb'],{'WuDaLang':'lb'} t1 = test01() t2 = test02() t3 = test03() print("from test01 return is [%s]:"%type(t1),t1) print("from test01 return is [%s]:"%type(t2),t2) print("from test01 return is [%s]:"%type(t3),t3)
函数调用
调用方法：通过 函数名() 即可完成调用
test()执行，()表示调用函数test，()内可用有参数也可以没有
注意：
- 每次调用函数时，函数都会从头开始执行，当这个函数中的代码执行完毕后，意味着调用结束了
- 当然了如果函数中执行到了return也会结束函数
参数：
1.形参和实参
- 定义时小括号中的参数，用来接收参数用的，称为 “形参”
- 调用时小括号中的参数，用来传递给函数用的，称为 “实参”
形参：形式参数，不是实际存在，是虚拟变量。在定义函数和函数体的时候使用形参，目的是在函数调用时接收实参（实参个数，类型应与形参一一对应）
实参：实际参数，调用函数时传给函数的参数，可以是常量，变量，表达式，函数，传给形参
区别：形参是虚拟的，不占用内存空间，形参变量只有在被调用时才分配内存单元，实参是一个变量，占用内存空间，数据传送单向，实参传给形参，不能形参传给实参
# 定义一个有参数的函数 # 形参: 形式参数 # 格式: def 函数名(形参1, 形参2, ...): def my_func(a, b): ret = a + b print(ret) # 执行一个有参数的函数 # 实参: 实际参数 # 格式: 函数名(实参1, 实参2,...) num1 = 80 num2 = 9 # 在执行函数的时候 就好比是a = num1 b = num2 my_func(num1, num2)
2.位置参数和关键字（标准调用：实参和形参位置一一对应；关键字调用：位置无需固定）
def test(x,y): print(x) print(y) test(1,2) #位置参数调用，实参的位置与形参的位置要一一对应 test(y=2,x=1) #关键字参数，调用函数的时候使用的是函数的形参名，与形参顺序无关 test(3,y=2) #混合使用时，位置参数在前，关键字参数在后，关键字参数是不能写在位置参数前面的
3.默认参数（缺省参数）: 给形参设置了一个默认值
def test(x,y=2): print(x) print(y) test(1) test(1,y=3) test(1,3) #默认参数特点：调用函数的时候，默认参数非必须传递
4.参数组
# *args: 接受N个位置参数，转换成元组形式 def test(*args): #参数不固定 print(args) test(1,3,2,4,5) test(*[1,2,4,5,5]) #args = tuple([1,2,4,5,5]) def test1(x,*args): print(x) print(args) test1(1,2,3,4,5,6,7)
# **kwargs:接受N个关键字参数，转换成字典的方式 def test2(**kwargs): print(kwargs) print(kwargs['name']) print(kwargs['age']) print(kwargs['sex']) test2(name='alex',age=8,sex='F') test2(**{'name':'alex','age':8,'sex':'F'}) def test3(name,**kwargs): print(name) print(kwargs) test3('alex') #后面接收一个空字典 test3('alex',age=18,sex='m') def test4(name,age=18,**kwargs): #参数组要放后面 print(name) print(age) print(kwargs) test4('alex',sex='m',hobby='tesla') test4('alex',5,sex='m',hobby='tesla') test4('alex',sex='m',hobby='tesla',age=3) def test5(name,age=18,*args,**kwargs): #参数组要放后面 print(name) print(age) print(args) print(kwargs) test5('alex',age=34,sex='m',hobby='tesla')
函数返回值
# python 学习了 一个内置函数 len(object) # 定一个字符串 my_str = "hello" # 内置函数如何实现的 def my_len(object): ret = 0 for i in object: ret += 1 # 如果有一个return 数值 成为这个函数有返回值 return ret my_l = my_len(my_str) # None 没有返回值 空值类型 print("自定义的:",my_l) # 自定义的: 5 l = len(my_str) print(l) # 5
# 四种函数的类型 # 01- 无参数无返回值 def my_print(): print("你好") print("python") # 执行函数 my_print() # 02- 无参数有返回值 def my_pi(): return 3.1415926 print(my_pi()) # 03- 有参数无返回值 def print_info(name): print("你好%s" % name) print_info("龟叔") # 04- 有参数有返回值def my_func(a, b): return a - b result = my_func(10, 5) print(result)
函数返回值之多个return
- 一个函数中可以有多个return语句，但是只要有一个return语句被执行到，那么这个函数就会结束了，因此后面的return没有什么用处
-
如果程序设计为如下，是可以的因为不同的场景下执行不同的return
# 包含多个return def my_func(score): if score < 0: print("您传入的分数有误!!!") return # 函数的执行提前结束 print("测试") # 对分数进行判断 if score >= 90: return "优" elif score >= 80: return "良" elif score >= 60: return "中" elif score >= 0: return "差" print("测试") # 不会执行 因为在前面已经执行了return # 提出需求 如果调用函数的人 传入的分数小于0 那么就人为传入的分数错误 告知函数的调用者 my_func(-10)
函数返回多个数据
- return后面可以是元组，列表、字典等，只要是能够存储多个数据的类型，就可以一次性返回多个数据
- 如果return后面有多个数据，那么默认是元组
# 需求 传入一个人名字 和年龄，例如 小明 22 # 通过调用函数后 得到两个字符串 姓名:小明 年龄:22 # 列表 def deal_name_age(name, age): # 处理后 姓名:小明 年龄:22 new_name = "姓名:%s" % name new_age = "年龄:%d" % age return [new_name, new_age] # 变量为列表 ret = deal_name_age("小明", 22) print(ret[0]) print(ret[1]) # 字典 def deal_name_age(name, age): # 处理后 姓名:小明 年龄:22 new_name = "姓名:%s" % name new_age = "年龄:%d" % age return {"name":new_name, "age":new_age} my_dict = deal_name_age("小明", 22) print(my_dict["name"]) print(my_dict["age"]) # 元组 def deal_name_age(name, age): # 处理后 姓名:小明 年龄:22 new_name = "姓名:%s" % name new_age = "年龄:%d" % age # 如果在函数内部 使用return 返回值1 返回值2,... 默认就是元组类型 不需要写小括号 return new_name, new_age my_tuple = deal_name_age("小明", 22) print(type(my_tuple)) # <class 'tuple'> print(my_tuple[0]) # 姓名:小明 print(my_tuple[1]) # 年龄:22
函数的嵌套调用
一个函数里面又调用了另外一个函数，这就是所谓的函数嵌套调用
def my_func1(): print("my_func1开始") print("my_func1结束") def my_func2(): print("my_func2开始") my_func1() print("my_func2结束") # 执行函数 my_func2() """ # 最终打印结果 my_func2开始 my_func1开始 my_func1结束 my_func2结束 """
如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置
前向引用
函数action体嵌套某一函数logger，该logger的声明必须早于action的调用，否则报错
def action(): print("in the action") logger() action() def logger(): print("in the logger") #报错：NameError: name 'logger' is not defined
def logger(): print("in the logger") def action(): print("in the action") logger() action()
def action(): print("in the action") logger() def logger(): print("in the logger") action()