函数是什么？

函数

函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可

优点:

代码重用
保持一致性
可拓展性

函数的定义主要有如下要点：

def：表示函数的关键字
函数名：函数的名称，日后根据函数名调用函数
函数体：完成函数的具体功能
参数：为函数体提供数据
返回值：当函数执行完毕后，可以给调用者返回数据。

创建一个函数：

def hello():#函数名
    pass #函数体
    return ('Hello !') #返回值
hello()#调用函数

返回值

要想获取函数的执行结果，就可以用return语句把结果返回

注意:

函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
如果未在函数中指定return,那这个函数的返回值为None

参数：写在def语句中函数名后面的变量通常就做函数的形参，而调用函数的时候提供的值是实参

我们在定义函数的时候根据需求的不同会用到各种类型的参数，有关键字参数、位置参数、默认参数、可变参数等。

def test(x,y,z):
    print(x)
    print(y)
    print(z)
test(1,2,3)#位置参数
test(x=2,y=3,z=4)#关键字参数
test(5,6,z=8)#位置参数与关键字参数混用，但关键字参数必须放在位置参数后面

#默认参数
def test1(x,y,z=8):
    print(x+y+z)
test1(5,7)
test1(5,8,9)

#可变参数
# *args 会把多传入的参数变成一个元组形式,
#*将一组可变数量的位置参数集合成参数值的元组
def test2(*args):
    print(args)#集合成元组的形式
    print(args[0])
    print(*args)# 去掉元组形式

test2([1,2,3,5],'man','woman')
test2(*('boy',1,4,))


# **kwargs 会把多传入的n多个关键字参数变成一个dict形式
#**可以将关键字参数收集到一个字典当中
def test3(**kwargs):
    print( kwargs)#集合成字典的形式
    print( *kwargs)#all the keys
    print( kwargs['age'])

test3(name='Mike',age='22',sex='male')
test3(**{'name':'Jack','age':30,'sex':'male'})


def test4(args1,args2):
    return args1 ,args2 #return以元组的形式返回
res=test4(2,5)
print(res)

全局与局部变量

在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。

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

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

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

num=66 #全局变量
def func():
    num=88 #局部变量 这个变量的作用域就是该函数
    print(num)
func()

>>>88

#除了字符串、数字外，其他像列表、字典、集合、类等这些复杂的数据类型都可以在局部里修改全局变量
name='Li'
name_list=['Mike','Jack','Mar']
def change_name():
    name="chen"
    name_list[0]='二师兄'
change_name()
print(name)
print(name_list)

>>>Li
>>>['二师兄', 'Jack', 'Mar']

嵌套函数　

Python的函数是可以嵌套的，也就是说可以将一个函数放在另一个里面。

def func():
    def hello():
        print("hello!")
    hello()
func()

递归

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

#阶乘
def factorial(n):
    n=int(n)
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)
print(factorial(3))

递归特性:

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

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

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

匿名函数（lambda表达式）

power=lambda x:x*x
print(power(2))

#是不是感觉用lambda也方便不了多少？不过匿名函数主要是和其它函数搭配使用的呢，如下：

result = map(lambda x:x**2,[1,5,7,4,8])
for i in result:
    print(i)

高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

def add(a,b ,f):
    return f(a)+f(b)
add(2,3,int)

内置函数戳：https://docs.python.org/2/library/functions.html

sorted()对一个集合进行排序：

#!/usr/bin/env/ python
# -*-coding:utf-8 -*-
a={
    1:'chen',10:'alex',5:'li'
}
print(sorted(a))#把key排序后输出
print(sorted(a.items()))#按key排序
print(sorted(a.items(),key=lambda x:x[1]))#按value排序


[1, 5, 10]
[(1, 'chen'), (5, 'li'), (10, 'alex')]
[(10, 'alex'), (1, 'chen'), (5, 'li')]

View Code

zip()是Python的一个内建函数，它接受一系列可迭代的对象作为参数，将对象中对应的元素打包成一个个tuple（元组），然后返回由这些tuples组成的list（列表）。若传入参数的长度不等，则返回list的长度和参数中长度最短的对象相同。利用*号操作符，可以将list unzip（解压）。

a=[1,2,3,4,5,6]
b=['a','b','c','d','e']
print(zip(a,b))
for i in zip(a,b):
    print(i)
for i in zip(*zip(a,b)):
    print(i)

(1, 'a')
(2, 'b')
(3, 'c')
(4, 'd')
(5, 'e')

(1, 2, 3, 4, 5)
('a', 'b', 'c', 'd', 'e')

View Code

eval()函数十分强大,官方demo解释为：将字符串str当成有效的表达式来求值并返回计算结果。so，结合math当成一个计算器很好用。

其他用法，可以把list,tuple,dict和string相互转化。见下例子：

a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
b = eval(a)
print(b)
print(type(b))

a = "{1: 'a', 2: 'b'}"
b = eval(a)
print(b)
print(type(b))

a = "([1,2], [3,4], [5,6], [7,8], (9,0))"
b = eval(a)
print(b)
print(type(b))

[[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]
<class 'list'>

{1: 'a', 2: 'b'}
<class 'dict'>

([1, 2], [3, 4], [5, 6], [7, 8], (9, 0))
<class 'tuple'>

# 不可谓不强大！
# ＢＵＴ！强大的函数有代价。安全性是其最大的缺点。
# 想一想这种使用环境：需要用户输入一个表达式，并求值。
# 如果用户恶意输入，例如：
# __import__('os').system('dir')
# 那么eval()之后，你会发现，当前目录文件都会展现在用户前面。
# 那么继续输入：
# open('文件名').read()
# 代码都给人看了。获取完毕，一条删除命令，文件消失。哭吧！
# 怎么避免安全问题？
# １、自行写检查函数；
# ２、使用ast.literal_eval： 自行查看DOCUMENT
#3、eval带来的潜在风险http://python.jobbole.com/82770/

View Code

数学相关

abs(a) : 求取绝对值。abs(-1)
max(list) : 求取list最大值。max([1,2,3])
min(list) : 求取list最小值。min([1,2,3])
sum(list) : 求取list元素的和。 sum([1,2,3]) >>> 6
sorted(list) : 排序，返回排序后的list。
len(list) : list长度,len([1,2,3])
divmod(a,b): 获取商和余数。 divmod(5,2) >>> (2,1)
pow(a,b) : 获取乘方数。pow(2,3) >>> 8
round(a,b) : 获取指定位数的小数。a代表浮点数，b代表要保留的位数。round(3.1415926,2) >>> 3.14
range(a[,b]) : 生成一个a到b的数组,左闭右开。 range(1,10) >>> [1,2,3,4,5,6,7,8,9]

逻辑判断

　all: 遍历一个迭代器，如果都为空，或者每个迭代元素都会true，则返回ture

　any：与all函数作用相反，如果任何迭代的一个元素为ture，或者为空，则返回false

类型转换

int(str) : 转换为int型。int('1') >>> 1
float(int/str) : 将int型或字符型转换为浮点型。float('1') >>> 1.0
str(int) : 转换为字符型。str(1) >>> '1'
bool(int) : 转换为布尔类型。 str(0) >>> False str(None) >>> False
bytes(str,code) : 接收一个字符串，与所要编码的格式，返回一个字节流类型。bytes('abc', 'utf-8') >>> b'abc' bytes(u'爬虫', 'utf-8') >>> b'xe7x88xacxe8x99xab'
list(iterable) : 转换为list。 list((1,2,3)) >>> [1,2,3]
iter(iterable)：返回一个可迭代的对象。 iter([1,2,3]) >>> <list_iterator object at 0x0000000003813B00>
dict(iterable) : 转换为dict。 dict([('a', 1), ('b', 2), ('c', 3)]) >>> {'a':1, 'b':2, 'c':3}
enumerate(iterable) : 返回一个枚举对象。
tuple(iterable) : 转换为tuple。 tuple([1,2,3]) >>>(1,2,3)
set(iterable) : 转换为set。 set([1,4,2,4,3,5]) >>> {1,2,3,4,5} set({1:'a',2:'b',3:'c'}) >>> {1,2,3}
hex(int) : 转换为16进制。hex(1024) >>> '0x400'
oct(int) : 转换为8进制。 oct(1024) >>> '0o2000'
bin(int) : 转换为2进制。 bin(1024) >>> '0b10000000000'
chr(int) : 转换数字为相应ASCI码字符。 chr(65) >>> 'A'
ord(str) : 转换ASCI字符为相应的数字。 ord('A') >>> 65