Python基础（三）函数

定义

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。

函数可以嵌套

程序运行时，函数会先编译，调用时才执行

重名函数会使用最近的

定义函数

def 函数名（参数列表）:
    函数体

函数即变量的思想？

def cal():
	print(cal)
	print('this is in cal()')
	return cal
	# 这里将返回cal函数的内存地址

print(cal())
print(cal()())

　　输出结果如下

<function cal at 0x033807C8>
this is in cal()
<function cal at 0x033807C8>
<function cal at 0x033807C8>
this is in cal()
<function cal at 0x033807C8>
this is in cal()
<function cal at 0x033807C8>
[Finished in 0.1s]

参数传递

形参

形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

实参

实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

位置实参

一一对应，多一不行缺一不行

关键字参数

无须一一对应，多一不行缺一不行。关键字参数必须在位置参数后面

默认参数

可变长参数

 **字典  *列表

def test(x, *args):
	print(args)


test(2, ['a','b','c'])
# (['a', 'b', 'c'],)
# [Finished in 0.9s]

test(2, *['a','b','c'])
# ('a', 'b', 'c')
# [Finished in 0.1s]

返回值

返回值数=0，返回None

返回值数=1，返回object

返回值数>1，返回tupel 

局部变量和全局变量

global可以操作全局变量

nonlocal可以声明上一级同名变量

全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。

当全局变量与局部变量同名时：

在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

递归

递归特性:

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

堆栈补充：https://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html 

def cal(n):
    print(n)
    if int(n / 2) == 0:
        return n
    return cal(int(n/2))

print(cal(10))

def askway(name_list):
    if len(name_list)==0:
        return 'nobody know'
    askname = name_list.pop()
    if  askname == 'c':
        return 'c answer:在china'
    print('%s do not konw, i will help you ask %s' % (askname,name_list))
    return askway(name_list)


print(askway(name_list))

　　

# 递归可以实现的，用for也可以实现
def func(start, end):
    sum = 0
    for i in range(start, end):
        if i%3==0 and i%7==0:
            sum += i
    return sum
print(func(1,22))

# 递归实现
def func(start, end, a=0, sum=0):
    """根据指定范围获取其中 3 和 7 整除的所有数的和，并返回符合条件的数字个数和数字综合"""
    if start == end:
        return a,sum
    if start%3==0 and start%7==0:
        a += 1
        sum += start
    rec = func(start+1, end, a, sum)
    return rec
print(func(1,22))

　　

匿名函数

当我们在传入函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便。

lambda 参数列表：返回值

匿名函数

lambda x:x+1
# 上方的匿名函数等价于下方的add_one()函数
def add_one(x):
    return x+1

函数式编程

编程方式：面向过程、函数式编程、面向对象

函数式编程：函数式=编程语言定义的函数+数学意义的函数

函数式就是用编程语言去实现数学函数，这种函数内对象是永恒不变的，要么参数是函数，要么返回值是函数，没有for和while循环，所有的循环都由递归去实现，无变量的赋值（即不用变量去保存状态），无赋值即不改变

函数式编程的语言有：Hashell、clean、erlang

特点：

不可变数据：不使用变量保存状态，不修改变量

第一类对象：函数即变量。函数名可以当作参数传递；返回值也可以是函数名

尾调用：在函数的最后一步（不是最后一行）调用另一个函数

函数即变量

def cal():
	print('this is in cal()')
	return cal
	# 这里将返回cal函数的内存地址

print(cal())
print(cal()())

# this is in cal()
# <function cal at 0x015A07C8>
# this is in cal()
# this is in cal()
# <function cal at 0x015A07C8>
# [Finished in 0.1s]

　

高阶函数

函数的参数是一个函数名或者返回值中包含参数

例如 map（） filter（）  reduce（）

# 把函数当作参数传递给另一个函数
def plant(name):
    print(name)

def fruit(name):
    print('my name is %s' % name)

plant(fruit('apple'))

# 返回值中包含函数名
def earth():
    print('from earth')
    return earth
earth()
earth()()
earth()()()

　　

尾调用

尾调用的关键就是在函数的最后一步调用了函数，好处呢？根据函数即‘变量’的定义，定义a函数，a内调用函数b，b内调用函数c，在内存中会形成一个调用记录（又称为‘调用帧’ call frame），用于保存调用位置和内部变量等信息，即a→b→c，直到c返回结果给b，c的调用记录才会消失，b返回给a，b的调用记录消失，a返回结果，a的调用记录消失，所有的调用记录都是先进后出，形成了一个‘调用帧'

在函数a中对其他函数的调用不是a函数的最后一步，则会占用很大的内存，如果是最后一步，则不会占用过多内存

# 函数b在a内为尾调用
def b(n):
    return n
def a(n):
    return b(n)

# 函数b和c在a内均为尾调用，二者在if下具有可能成为函数a的最后一步
def c(n):
    return n
def b(n):
    return n+1
def a(n):
    if type(n) is int:
        return c(n)
    else:
        return b(n)

# 函数b在a内为非尾调用
def b(n):
    return n
def a(n):
    x = b(n)
    return x

# 函数c在a内为非尾调用
def c(n):
    return n
def a(n):
    return c(n)+1

　　

偏函数

内置函数

bin()

print(bin(10)) #10进制->2进制
print(hex(12)) #10进制->16进制
print(oct(12)) #10进制->8进制
# 0b1010
# 0xc
# 0o14

bool()

bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。

bool 是 int 的子类。

bytes()

name = '你好'

print(bytes(name, encoding='utf-8'))
print(bytes(name, encoding='utf-8').decode('utf-8'))

# ascii不能编码中文
# print(bytes(name,encoding=ascii))

chr()

chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。

返回值是当前整数对应的 ASCII 字符。

eval()

eval（）可以提取字符串中的数据结果和表达式

dic = {'name':'alex'}
dic_str = str(dic)
print(type(dic_str))

print((eval(dic_str)))
print(type(eval(dic_str)))

print(eval('1+1*2'))
# <class 'str'>
# {'name': 'alex'}
# <class 'dict'>
# 3

filter()

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换

li_name = ['aliex', 'cn_liming', 'cn_xiaohong', 'ea_zhangsan']

def start_cn(name):
    return name.startswith('cn')

def filter_test(fun, array):
    list_test = []
    for i in array:
        if fun(i):
            list_test.append(i)
    return list_test

print(filter_test(start_cn, li_name))
print(filter_test(lambda a:a.startswith('ea'), li_name))

print('使用内置函数filter', filter(lambda x:x.startswith('cn'),li_name))
print('使用内置函数filter', list(filter(lambda x:x.startswith('cn'),li_name)))

　　

hash()

hash() 用于获取取一个对象（字符串或者数值等）的哈希值。

可hash的数据类型即不可变数据类型，不可hash的数据类型即可变数据类型

hash() 函数的对象字符不管有多长，返回的 hash 值都是固定长度的，也用于校验程序在传输过程中是否被第三方（木马）修改，如果程序（字符）在传输过程中被修改hash值即发生变化，如果没有被修改，则 hash 值和原始的 hash 值吻合，只要验证 hash 值是否匹配即可验证程序是否带木马（病毒）。

在 hash() 对对象使用时，所得的结果不仅和对象的内容有关，还和对象的 id()，也就是内存地址有关。

print(hash('hello'))
print(hash('hello world'))
# -1495515718
# 973284469

help()

help() 函数用于查看函数或模块用途的详细说明

返回对象帮助信息

id()

id() 函数用于获取对象的内存地址

input()

Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。

int()

int() 函数用于将一个字符串或数字转换为整型。

返回整型数据。

type（）

返回对象的类型

len()

返回对象（字符、列表、元组等）长度或项目个数

list()

list() 方法用于将元组转换为列表。

返回列表。

max()

max() 方法返回给定参数的最大值，参数可以为序列。

dic = {'alex':200, 'liming':400, 'bluce':100}
print(max(dic.values()))
# max处理的是可迭代对象，相当于一个for循环取出每个元素进行比较，注意，不同类型之间不能比较

#运行结果
#400

map()

map() 会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

利用参数中提供的函数对每一个序列中的元素进行操作

语法  

map(function, iterable, ...)
function -- 函数
iterable -- 一个或多个序列

Python 2.x 返回列表。
Python 3.x 返回迭代器。

　作用

def increase_one(num):
    return num+1


def map_test(fuc, array):
    '''自定义map函数'''
    res = []
    for i in array:
        res.append(fuc(i))
    return res


li_test = [1, 2, 3, 4, 5,]
print(map_test(increase_one, li_test))
print(map_test(lambda x:x**2, li_test))

print('使用内置函数map（）', map(lambda x:x*82,li_test))
print('使用内置函数map（）', list(map(lambda x:x*82,li_test))) 

min()

min() 方法返回给定参数的最小值，参数可以为序列。

print()

print() 方法用于打印输出，最常见的一个函数。

无返回值

python3.x中实现print不换行：

　　print('contents', end=' ')

　　end就表示print将如何结束，默认为end=" "（换行）

# 在每个字符间插入相同的符号
print('root','0','0',sep=':')
# 运行结果如下：
# root:0:0

常用占位符

name= "张三"
age = 19
height = 180
print("我叫%s,今年%s岁,身高是%s"  % (name,age,height))
print("我叫{},今年{}岁,身高是{}".format(name,age,height))
"""
占位符 整数占位 用%d
小数占位符 用 %.6d    保留几位为整数，位数不够 用0补齐，往前补
"""
a = "我的钱包余额是%.5d"  % age
print(a)
#打印结果是：我的钱包余额是00019
a = "我的身高是%f米" % height
# print(a ) 
#打印结果是：我的身高是180.000000米（默认保留的小数）
#打印结果是b = "我的身高是%.2f米" % height
print(b)
#打印结果是：我的身高是180.00米

　　

range()

 range() 函数可创建一个整数列表，一般用在 for 循环中

python2

　　range立即创建

　　xrange for循环时创建

python3

　　range for循环时创建

reduce()

reduce() 函数会对参数序列中元素进行累积

nums = [1, 3, 100]

def reduce_test(func, nums, init=1):
    if init is None:
        res = nums.pop(0)
    else:
        res = init
    for num in nums:
        res = func(res, num)
    return res

print(reduce_test(lambda x,y:x*y,nums))
print(reduce_test(lambda x,y:x*y,nums,init=2))


from functools import reduce
print('使用函数reduce', reduce(lambda x,y:x+y,nums,100))

　　

sum()

sum() 方法对系列进行求和计算。

sotred()

dic = {'alex':200, 'liming':400, 'bluce':100}
# 默认对key进行排序
print(sorted(dic))

# 对values进行排序
print(sorted(dic.values()))

# 对values进行排序，并取出key
print(sorted(dic, key=lambda n:dic[n]))

print(sorted(zip(dic.values(), dic.keys())))

type()

type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象

tuple()

tuple() 函数将列表转换为元组

zip()

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。 

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表

dic = {'alex':200, 'liming':400, 'bluce':100}
print(list(zip(dic.values(), dic.keys())))
l = list(zip(dic.values(), dic.keys()))
# zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
# 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。


# 运行结果
# [(200, 'alex'), (400, 'liming'), (100, 'bluce')]

 参考

菜鸟教程python3内置函数https://www.runoob.com/python3/python3-built-in-functions.html

https://www.cnblogs.com/linhaifeng/articles/6113086.html#_label2