day11-pthon函数进阶（np.ptp函数的作用）

函数：具有独立功能的代码块。

• 使用包含两个步骤：1.定义函数 2.调用函数
• 函数的作用：开发时，提高编写效率。

函数的参数：分为形参（可理解为变量），实参。

• 默认参数：在定义的时候提前设置好参数的值，调用的时候可以传参也可以不传参数
• 关键字参数：在函数调用的时候，实参可以指定对应的形参值
• 可变参数：*args：接收任意数量的参数。（本质：将传递的参数包装成了元组）**kwargs：可接收不存在的关键字的参数，将不存在的关键字包装成字典。

函数返回值：在函数执行结束后，通过 return 将结果返回给调用者，同样调用的一方也可以通过变量来接收结果。如果return返回多个值，Python会自动将数据组包成元组。

本文章内容概览:

1. 内置函数
2. 递归函数
3. 匿名函数
4. 高阶函数

内置函数

函数分为自定义函数和内置函数，所谓内置函数就是系统已经给定义好的函数，我们可以拿过来直接使用的函数，只需要关注他的如何使用就可以了，比如参数有哪些？是否存在返回值？

常见的内置函数有:

数字相关:

bool() 将给定的数据类型转换成bool值.如果不给值.返回False

int () 将给定的数据转换成int值.如果不给值,返回0

float () 将给定的数据转换成float值.也就是小数

complex () 创建一个复数.第一个参数为实部，第二个参数为虚部.或者第一个参数直接用字符串来描述复数

number = '100'
print(int(number))  # 100
print(float(number))  # 100.0
print(bool(10))  # True

进制转换:

bin() 将给的参数转换成二进制

otc() 将给定的参数转换成八进制

hex() 将给定的参数转换成十六进制

number=25
print(bin(number))   # 0b11001
print(oct(number))   # 0o31
print(hex(number))   # 0x19

数字运算:

• abs() 返回绝对值
• divmode() 返回商的余数
• round () 四舍五入
• pow(a,b) 求a 的b 次幂,如果有三个参数.则求完次幂后对第三个数取余
• sum() 求和
• min() 求最小值
• max() 求最大值

number = -10.58
print(abs(number))  # 10.58
print(round(number))  # -11
print(max(number,-9))  # -9

列表和元组:

• list() 将一个可迭代对象转换成列表
• tuple() 将一个可迭代对象转成元组
• reversed() 将一个序列翻转, 返回翻转序列的迭代器
• slice() 列表的切片

s = 'hello'
print(list(s)) # ['h','e','l','l','o']
st = "hello! I am Running"
s = slice(1, 10, 3)
print(st[s])    # eoI

字符串相关:

• str () 将数据转换成字符串
• format() 与具体数据相关,用于计算各种小数.精算等
• memoryview() 查看bytes的内存中的情况
• ord() 输入字符找带字符编码的位置
• chr() 输入位置数字找对应的字符
• ascii() 是sdcll码中的返回值 不是就返回\u

# 找到对应字符的编码位置
print(ord('s'))  # 115
print(ord('宋'))  # 23435
# 找到对应编码位置的字符
print(chr(97))   # a
print(chr(20013))  # 嵩
# 在ascii中就返回这个值. 如果不不在就返回\u...
print(ascii('a'))  # 'a'
print(ascii('好'))   # '\u597d'

数据集合:

dict() 创建一个字典

set() 创建一个集合

frozenset() 创建一个冻结的集合.冻结的集合不能进行添加和删除操作

其他相关:

• len() 返回一个对象中的元素的个数
• sorted() 对可迭代对象进行排序
• enumerate() 获取集合的枚举对象
• all() 可迭代对象中全部是True.结果才是True
• any() 可迭代对象中有一个是True,结果就是Ture
• zip() 函数用于将可迭代的对象最为参数.将对象中对应的元素打包成一个个元组
• eval() 执行字符串类型的代码,并返回最终的结果

lt = ["Song", "Running", "Ruby"]
for index, el in enumerate(lt):
  print(str(index)+"==>"+el)
    
# all() any()的使用
print(all([0,8,True,0]))
print(any([0,1,''])) 

# zip()使用
lt1 = [20,30,40]
print(zip(lt,lt1))

# eval()的使用
print(eval("2+2")) 
n = 6
print(eval("2+n")) 

结果:

0==>Song
1==>Running
2==>Ruby
False
True
('Song', 20)
('Running', 30)
('Ruby', 40)
4
8

内存相关:

hash() 获取到对像的哈希值(int str bool tuple)

id () 获取到对象的内存地址

当然还有一些内置函数，就没有给大家一一列举。

递归函数

?个函数可以调?其他函数， 如果函数在内部调?其本身，这个函数就是递归函数。

构成递归不报错的话，严格来说应该具备两个条件:

从入口开始不断的向出口靠近

必须有出口的结束条件,即不递归的代码部分

def digui(num):
    print(num)
    if num>0:
        digui(num-1)  # num-1 就是不断的向出口靠近,出口就是 num>0 的时候
    else:
        print('over')

digui(8)

注意上面的代码在调用函数本身时，它之后的代码并没有结束，而是在等待条件为False 时，再接着执行之后的代码

结果就是打印从 8 开始逐渐减少直到 0 为止，最后打印 over

理论上，所有的递归函数都可以写成循环的方式.比如求阶乘的代码

# 循环完成
def jiecheng1(num):
    product = 1
    for i in range(1, num + 1):
        product = product * i
    return product

# 递归完成
def jiecheng2(num):
    if num == 1:
        return 1
    else:
        return num * product2(num - 1)

# 分别调用两个函数观察结果
jiecheng1()
jiecheng2()

大家也可以使用递归函数求斐波那契数列

def func(n):
    # 给递归一个出口  第一位和第二位都是1
    if n == 1 or n == 2:
        return 1
    else:
        # 从第三位开始  返回上一个数加上上一个数
        return func(n-1) + func(n-2)
        
res = func(20)
print(res)

匿名函数

简单来说，匿名函数就是没有名称的函数，不用使用def语句定义的函数，而是使用关键字 lambda。

匿名函数的声明格式如下：

变量名称 = lambda 参数：表达式

注意事项:

1. 无需使用return返回,上述格式中冒号后面的内容即是要返回的
2. 可以包含if... else等结构

比如求两个数的和，使用匿名表达式定义

func = lambda a,b:a+b      # 定义匿名表达式
result = func(1,2)
print(result)  # 3

因为没有 return 返回值，返回的内容都是表达式计算的结果。因此使用lambda声明的匿名函数能接受任何数量的参数，但只能返回一个表达式的值。

如果上面的结构改成有 if 判断的，代码如下:

func = lambda a,b:a-b if a==b else a+b  # 定义匿名表达式并添加 if 条件
result = func(1,2)
print(result)  # 3

匿名函数只能定义一些简单的函数,复杂的函数定义还是使用 def 的格式定义。

因为函数是一个变量，所以也可以作为参数传递，而匿名函数的真正作用就在此

高阶函数

一个函数可以接收另一个函数作为参数，这种函数就称之为高阶函数，常见的Python 内置的高阶函数有：

• sorted()
• max()
• min()
• map()
• filter()

排序函数sorted:

sorted(Iterable, key= None, reverse = False)
Iterable:排序规则(排序函数),在sorted内部会将可迭代对象中的每个元素传递给这个函数的参数.根据函数运算的结果进行排序
reverse:是否是倒序,  True:倒序  False:正序
key:就可以使用匿名函数

比如：现在有一个字典{'小红':20,'小明':18,'小鱼':19,'小雪':22,'小东':17}，现在按照年龄排序

dict1 = {'小红':20,'小明':18,'小鱼':19,'小雪':22,'小东':17}
order_dict = sorted(dict1.items(),key=lambda s:s[1])
print(dict(order_dict)) 
# order_dict 是一个列表[('小东', 17), ('小明', 18), ('小鱼', 19), ('小红', 20), ('小雪', 22)],所以需要转成字典

上面的案例中 key 就使用了匿名函数进行排序条件的制定，即 lambda 的返回值是就是排序条件，默认是升序

# 按照数量排序
goods = [('防脱发洗发水', 60, 3), ('格子衬衫', 156, 1), ('牛仔裤', 99, 7), ('运动鞋', 299, 2)]
goods = sorted(goods, key=lambda g: g[2], reverse=True)  # 设置成降序
print(goods)

最大值，最小值函数

这个是我们比较熟悉的 max()和 min()函数

dict1 = {'小红':20,'小明':18,'小鱼':19,'小雪':22,'小东':17}
result = max(dict1.items(),key=lambda s:s[1])
print(result)

result = min(dict1.items(),key=lambda s:s[1])
print(result)

map 函数

map 映射函数,可以对可迭代对象中的每一个元素按照 function 的定义进行映射。

map(function,iterable)
有两个参数，第一个参数是一个函数，第二个参数是可迭代的内容
函数会依次作用在可迭代的每个内容上，返回一个新的可迭代内容

比如：求列表中的每个元素的平方值，list1 = [1,2,3,4]

list1 = [1, 2, 3, 4]
result = map(lambda x: x ** 2, list1)
print(result)  # 结果: [1,4,9,16]

# 或者也可以对两个列表进行映射
list2 = [5, 6, 7, 8, 9] 
result = map(lambda x, y: x + y, list1, list2)
print(list(result))  # 结果:[6,8,10,12]

filter 函数

filter 函数 即筛选函数

语法: filter(function. Iterable)
function:用来筛选的函数,在filter中会自动的把iterable中的元素传递给function.然后根据function返回的Ture或者False来判断你是否保留此项数据
iterable:可迭代对象

比如将 list1=[1, 3, 5, 'a', 'b', 'c', 7, 'u', 'y']中的整型数字筛选出来。

list1 = [1, '3', 5, 'a', 'b', 'c', 7, 'u', 'y']
list2 = filter(lambda x: isinstance(x, int), list1)
print(list(list2))  # 结果:[1,5,7]

再或者求列表中数字的偶数[1, 2, 4, 5, 8, 9, 0, 7]

list3 = [1, 2, 4, 5, 8, 9, 0, 7]
list4 = filter(lambda x: x % 2 == 0, list3)
print(list(list4))  # 结果:[2,4,8,0]