Python函数进阶

一、函数的参数传递

1.参数定义与传递的基本顺序
位置参数 ---- 关键字参数 ---- 可变数量参数（*args----->**args）

def test_fun(a, b=6, *c, **d):
      print("a =",a,",b =",b,",c = ",d =“,d)

tese_fun(1)
#a = 1, b = 6, c = (), d = {}
test_fun(1, 2)
#a = 1, b = 2, c = (), d = {}
test_fun(1, 2,3)
#a = 1, b = 2, c = (3,), d = {}
test_fun(1, 2, 3, 4)
#a = 1, b = 2, c = (3, 4), d = {}

test_fun(a = 1)
#a = 1, b = 6, c = () , d = {}
test_fun(a = 1, b = 2)
#a = 1, b = 2, c = () , d = {}
test_fun(a = 1, b = 2, c = 3)
#a = 1, b = 6, c = () , d = {'c':3}
test_fun(1, b = 2)
#a = 1, b = 2, c = () , d = {}
test_fun(1, 2 , 3, 4, x = 1)
#a = 1, b = 2, c = (3, 4) , d = {'x':1}
test_fun(1, 2 , 3, 4, 5, 6, x = 1,y = 2, z = 3)
#a = 1, b = 2, c = (3, 4, 5, 6) , d = {'x':1, 'y':2, 'z':3}

二、函数文档

函数定义语法：

def 函数名（[参数列表]）：
         '''注释'''
         函数体

 def fib(n):
    '''accept an integer n.
      return the numbers less then n in Fibonacci sequence.'''
     a, b - 1, 1
     while a < n:
            print(a, end = ' ')
            a, b - b, a + b
      print()

三、lambda匿名函数

1.lambda 表达式可以用来声明 匿名函数 ，也就是没有函数名 字的临时使用小函数，尤其适合需要一个作为另个函数参的场合。也可以定义 具名函数
2.lambda 表达式只可以包含一个表达式 ，该表达式的计算结果可以看作是函数的返回值， 不允许包含复合语句 ，但在表达式中可以调用其他函数

>>> f = lambda x, y, z: x+y+z  #可以给lambda表达式起名字
>>> f(1, 2, 3)  #像函数一样调用
6
>>> g = lambda x, y = 2, z = 3: x+y+z  #默认参数值
>>> g(1)
6
>>> g(2, z = 4, y = 5)  #关键参数
11

四、range/map/filter/reduce/zip/enumerate函数

1.range函数

语法

range(stop)
range(start, stop[, step])

参数	说明
srart	计数从start开始。默认是从0开始。即range(5)等价于range(0, 5)
stop	计数到stop结束，但不包括stop。即range（0, 5）是[0, 1, 2, 3, 4]没有5
step	步长，默认为1。

版本	作用
Python3	range()函数返回的是一个可选代对象(类型是对象) ,而不是列表类型,所以打印的时候不会打印列表。
Python3	lst()函数是对象迭代器,可以把range()返回的可选代对象转为一个列表,返回的变量类型为列表。
Python2	range()函数返回的是列表

2.map函数

map()会根据提供的函数对指定序列做映射。
第一个参数function以参数序列中的每一一个元素调用function函数,返回包含每次function函数返回值的新列表。

语法	参数	返回值
map(function, iterable, …)	function是函数 iterable是一个或多个序列	Python 2.x返回列表 Python 3.x返回迭代器

def square(x):
       return x *** 2
map(square, [1,2,3,4,5])
#<map at 0x5815240>

def square(x):
       return x *** 2
list(map(square, [1,2,3,4,5]))
#[1,4,9,16,25]
map(lambda x:x ** 2, [1,2,3,4,5])
#<map at 0x58077b8>

map(lambdax, y:x+y,[1,3,5,7,9],[2,4,6,8,10])
-<map at 0x5815160>

#提供了两个列表，对相同位置的列表数据进行相加
list (map (lambda x,y:x+y,[1,3,5,7,9],[2,4,6,8,10])
[3, 7, 11, 15,19]

for i in map(lambda x, y:x+y,[1,3,5,7,9],[2,4,6,8,10]):
print(i**2, end=" It')
9  49  121  225  361

def add(x,y, z):
return x+y+z
list1 = [1,2,3]
list2 = [1,2,3, 4]
list3 = [1,2,3, 4,5]
res = map(add, list1, list2, list3)
print (list (res))
[3,6, 9]

3.filter函数

filter()函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。
该接收两个参数,第一一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判,然后返回True或False最后将返回True的元素放到新列表中。

语法	参数
filter（function，iterable）	function–判断函数 iterable–可迭代对象

内置函数filter()将一个单参数函数作用到一 个序列上,返回该序列中，使得该函数返回值为True的那些元素组成的filter对象,如果指定函数为None ,则返回序列中等价于True的元素。

>>> seq = [ 'foo'  ,'x41’, '?!', '***']
>>>> def func(x):
                return x. isalnum()  #测试是否为字母或数字
>>> filter(func, seq)      #返回filter对象
<filter object at 0000000000305D898>
>>> list(filter(func, seq))  #把filter对象转换为列表
 ['foo', 'x41']

def  is_odd(n) :
       return n%2== 1
newlist = filter(is_odd, [1,2,3,4,5,6,7,8,9,10]print Cnewlist)
#<filter object at 0x00000005815C0>

def is_odd(n) :
      return n%2==1
newlist = filter(is_odd, [1,2,3,4,5,6,7,8,9,10]
print(list (newlist))
#[1, 3, 5,7, 9]

关于filter()方法，python3和python2有一点不同
Python2.x中返回的是过滤后的列表，而Python3中返回到是一个filter类。
fiter类实现了_ itr__ 和_ .next__ 方法， 可以看成是一个迭代器, 有惰性运算的特性,相对Python2.x提升了性能，可以节约内存。

a= filter(lambda x: x %2 == 0, range(10))
print(a)
#输出
#<filter object at exe88e822EC66BB128>

4.zip函数

①.zip()函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用*号操作符,可以将元组解压为列表。
②.zip方法在Python 2和Python 3中的不同:在Python 3.x中为了减少内存, zip() 返回的是一个对象。如需展示列表，需手动list)转换。
③.zip(seq[,eq…): zip0函数 可把两个或多个序列中 的相应项合并在一 -起，并以元组的格 式返回它们，在处理完最短序列中的所有项后就停止。

语法	参数说明	返回值
zip([iterable, …])	iterabl-- 一个或多个迭代器	返回元组列表

a = [1,2,3]
b=[4,5, 6]
zip(a, b)
#<zip at 0x5a1 fa08>

a= [1,2,3]
b = [4,5,6]
list(zip(a, b))
#[(1, 4), (2, 5), (3, 6)]

a = [1,2,3]
b = [4,5,6]
zipped = zip(a, b)
list (zip(*zipped) )
#[(1, 2, 3)，(4, 5, 6)]
#与zip相反，*zipped 可理解为解压，返回二维矩阵式

5.enumerate函数

①.enumerate()函数用于将-一个可遍历的数据对象(如列表、元组或字符串)組合为一个索引序列,同时列出数据和数据下标，,一般用在for循环当中。
②.Python 2.3.以上版本可用, 2.6添加start参数。

语法	参数	返回值
enumerate(sequence,[start=0])	sequence-- 个序列、迭代器或其他支持迭代对象 start- 下标起始位置	返回enumerate(枚举)对象

seasons = [' Spring', ' Summer' ,'Fall', 'Winter']
list (enumerate (seasons))
#[(0, Spring ), (1, , Summer'), (2, 'Fall'), (3, ' Winter')]

list (enumerate (seasons, start=1))#从下标1开始
#[(1, ’Spring' ), (2, 'Summer' ), (3, 'Fall'), (4, 'Winter' )]

i=0
seq = ['Tom'  ,' Jerry, ' Bob']
for element in seq:
	print(i, seq[i])
	i +=1
#0 Tom
  1 Jerry
  2 Bob

seq = ['Tom'  ,' Jerry, ' Bob']
for i, element in enumerate(seq):
	print(i, element)
#0 Tom
  1 Jerry
  2 Bob

6.reduce函数

语法	导入方法	描述	参数	返回值
reduce(function, iterable[, initializer])	from functools import reduce i	reduce()函数会对参数序列中元素进行累积。函数将一个数据集合(链表,元组等)中的所有数据进行下列操作:用传给reduce中的函数function (有两个参数)先对集合中的第1、2个元素进行操作,得到的结果再与第三个数据用function函数运算,最后得到一个结果。	function- 函数。有两个参数 iterable–可选代对象 intalizer-- 可选，初始参数	返回函数计算结果。

from functools import reduce
def add(x, y):
	return x+ y
reduce(add, [1,2,3, 4, 5])
#15

from functools import reduce
reduce(lambda x, y: x+y, [1,2,3, 4,5])
#15

from functools import reduce
def add(x,y):
	return x+y
print (reduce(add, range(1, 101)))
#5050