编程方法：

1、面向对象：类--class

2、面向过程：过程--def

3、函数式编程：函数--def

#python中函数#函数的定义#打印一个佛祖镇楼 -> 一个功能点的解释

defprint_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中函数定义方法：

deftest(x):"The function definitions"x+=1

return x

def：定义函数的关键字

test :函数名

()：内可定义形参

“”：文档描述(非必要，但是强烈建议为你的函数添加描述信息)

x+=1：泛指代码块或程序处理逻辑

return：定义返回值

#函数

deffunc1():"testing1"

print("in the func1")return0#过程

deffunc2():"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(返回一个元组)

如：

deftest01():pass

deftest02():return0deftest03():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, ...):

defmy_func(a, b):

ret= a +bprint(ret)#执行一个有参数的函数#实参: 实际参数#格式: 函数名(实参1, 实参2,...)

num1 = 80num2= 9

#在执行函数的时候 就好比是a = num1 b = num2

my_func(num1, num2)

2.位置参数和关键字(标准调用：实参和形参位置一一对应；关键字调用：位置无需固定)

deftest(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"

#内置函数如何实现的

defmy_len(object):

ret=0for i inobject:

ret+= 1

#如果有一个return 数值 成为这个函数有返回值

returnret

my_l=my_len(my_str)#None 没有返回值 空值类型

print("自定义的:",my_l) #自定义的: 5

l =len(my_str)print(l) #5

#四种函数的类型#01- 无参数无返回值

defmy_print():print("你好")print("python")#执行函数

my_print()#02- 无参数有返回值

defmy_pi():return 3.1415926

print(my_pi())#03- 有参数无返回值

defprint_info(name):print("你好%s" %name)

print_info("龟叔")#04- 有参数有返回值defmy_func(a, b):return a -b

result= my_func(10, 5)print(result)

函数返回值之多个return

一个函数中可以有多个return语句，但是只要有一个return语句被执行到，那么这个函数就会结束了，因此后面的return没有什么用处

如果程序设计为如下，是可以的因为不同的场景下执行不同的return

#包含多个return

defmy_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#列表

defdeal_name_age(name, age):#处理后 姓名:小明 年龄:22

new_name = "姓名:%s" %name

new_age= "年龄:%d" %agereturn[new_name, new_age]#变量为列表

ret = deal_name_age("小明", 22)print(ret[0])print(ret[1])#字典

defdeal_name_age(name, age):#处理后 姓名:小明 年龄:22

new_name = "姓名:%s" %name

new_age= "年龄:%d" %agereturn {"name":new_name, "age":new_age}

my_dict= deal_name_age("小明", 22)print(my_dict["name"])print(my_dict["age"])#元组

defdeal_name_age(name, age):#处理后 姓名:小明 年龄:22

new_name = "姓名:%s" %name

new_age= "年龄:%d" %age#如果在函数内部 使用return 返回值1 返回值2,... 默认就是元组类型 不需要写小括号

returnnew_name, new_age

my_tuple= deal_name_age("小明", 22)print(type(my_tuple)) #

print(my_tuple[0]) #姓名:小明

print(my_tuple[1]) #年龄:22

函数的嵌套调用

一个函数里面又调用了另外一个函数，这就是所谓的函数嵌套调用

defmy_func1():print("my_func1开始")print("my_func1结束")defmy_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的调用，否则报错

defaction():print("in the action")

logger()

action()deflogger():print("in the logger")#报错：NameError: name 'logger' is not defined

deflogger():print("in the logger")defaction():print("in the action")

logger()

action()

defaction():print("in the action")

logger()deflogger():print("in the logger")

action()