我的Python升级打怪之路【三】：Python函数

函数

在函数之前，我们一直遵循者：面向过程编程，即：根据业务逻辑从上到下实现功能，开发过程中最常见的就是粘贴复制。代码就没有重复利用率。

例如：有好多的重复的代码

if 条件:
    发送指令
    接收结果
elif 条件：
    发送指令
    接收结果
elif 条件：
    发送指令
    接收结果

如果我们将重复的代码提取出来

例如：代码简洁多了

def 一条操作(参数)：
    发送指令
    接收结果

if 条件：
    一条操作
elif 条件：
    一条操作
elif 条件：
    一条操作

对于以上两种方式，第二种明显要优于第一种，重用性可读性大大增加。这就是函数式编程和面向过程编程的区别

• 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅仅调用函数即可。
• 面向对象：对函数进行分类和封装。
• 函数式编程最重要的是增强代码的重用性和可读性

1.函数的定义和使用

1.定义：

def 函数名(参数)：

    函数体
    
    返回值(默认不写，返回值为空)

函数的定义要点：

• def：定义函数的关键字
• 函数名：之后会根据函数名对函数进行调用
• 函数体：函数中进行一系列的逻辑计算
• 参数：为函数提供数据
• 返回值：当函数执行完毕后，用于给调用者返回数据，默认为空

2.参数：

为什么要有参数呢？

def 操作(参数)：
    发送一条指令('ls')

if 条件：
    操作()
elif 条件：
    操作()

# 不管是if还是elif，发送的都是同一条指令ls

def 函数(参数)：
    执行指令(参数)

if 条件：
    函数(ls)
elif 条件：
    函数(pwd)

函数中有三种不同的参数：

• 普通参数
• 默认参数
• 动态参数

#************定义****************
#name 叫做函数func的形式参数，简称：形参
def func(name):
    print(name)

#************调用****************
# 'nullnull'叫做func的实际参数，简称：实参
func('nullnull')

def func(name,age=20)
    print(name,age)

# 指定参数
func('nullnull',18)
func(name="nullnull",age=20)

#使用默认参数
func("null")

def func(*args):
    print(args)

#执行方式一
func(1,2,3,4,5,6,7)

#执行方式二
li = [1,2,3,4,5,6,7]
func(*li)

def func(**kwargs):
    print(kwargs)

# 执行方式一
func(name="nullnull",age=18)

# 执行方式二
dic = {'name':'nullnull','age':18}
func(**dic)

特别的，普通参数，默认参数，动态参数是有顺序要求的

def func(普通参数,默认参数,*args,**kwargs):
    pass

Python的内置函数

函数详解

 Lambda表达式

 对于简单的函数，有一种简便的表示方式，即：lambda表达式

#*************普通函数**************
#定义函数
def func(arg):
    print(arg)

#执行函数
func('null')


#*************lambda***************
#定义函数（lambda表达式）
my_lambda = lambda arg : arg + 1

#执行函数
my_lambda(0)

递归

利用Python编写斐波那契数列：

　　斐波那契数列：0，1，1，2，3，5，8，13......

def func(arg1,arg2):
    if arg1 == 0:
        print(arg1,arg2)
    arg3 = arg1 + arg2
    print(arg3)
    func(arg2,arg3)

func(0,1)

补充：三元运算符　

 三元运算（三目运算），是对简单的条件语句的缩写

result = 值1 if 条件 else 值2

#如果条件成立，那么result = 值1，否则result = 值2

补充：深浅拷贝

 对于数字 字符串而言，赋值、浅拷贝和深拷贝无意义，因为其永远指向同一个内存地址

import copy

n1 = 1

#查看n的内存地址
print(id(n1))

#将n1赋值给n2
n2 = n1
print(id(n2))

#浅拷贝
n3 = copy.copy(n1)
print(id(n3))

#深拷贝
n4 = copy.deepcopy(n1)
print(id(n4))

你会神奇的发现打印的都是相同的

对于字典、元组、列表 而言，进行赋值、浅拷贝、深拷贝时，其内存地址的变化时不一样的

 1.赋值

n1 = {"k1":'nullnull',"k2":1,"k3":['hello','python']}

n2 = n1

 

2.浅拷贝

浅拷贝，在内存中额外创建 第一层 的数据

import copy

n1 = {"k1":"nullnull","k2":1,"k3":["hello","python"]}

n2 = copy.copy(n1)

3.深拷贝

深拷贝，在内存中将所有的数据重新创建一份(排除最后一层，即：Python内部对字符串和数字的优化)

import copy

n1 = {"k1":"nullnull","k2":1,"k3":["hello","python"]}

n2 = copy.deepcopy(n1)