Python 函数进阶-高阶函数

高阶函数就是能够把函数当成参数传递的函数就是高阶函数，换句话说如果一个函数的参数是函数，那么这个函数就是一个高阶函数。

成都创新互联是一家专注于成都网站设计、网站建设、外贸网站建设与策划设计,临洮网站建设哪家好?成都创新互联做网站,专注于网站建设十年,网设计领域的专业建站公司;建站业务涵盖:临洮等地区。临洮做网站价格咨询:028-86922220

高阶函数可以是你使用 def 关键字自定义的函数，也有Python系统自带的内置高阶函数。

我们下面的例子中，函数 senior 的参数中有一个是函数，那么senior就是一个高阶函数；函数 tenfold 的参数不是函数，所以tenfold就只是一个普通的函数。

function：函数，可以是 自定义函数 或者是 内置函数；

iterable：可迭代对象，可迭代性数据。（容器类型数据和类容器类型数据、range对象、迭代器）

把可迭代对象中的数据一个一个拿出来，然后放在到指定的函数中做处理，将处理之后的结果依次放入迭代器中，最后返回这个迭代器。

将列表中的元素转成整型类型，然后返回出来。

列表中的每一个数依次乘 2的下标索引+1 次方。使用自定义的函数，配合实现功能。

参数的意义和map函数一样

filter用于过滤数据，将可迭代对象中的数据一个一个的放入函数中进行处理，如果函数返回值为真，将数据保留；反之不保留，最好返回迭代器。

保留容器中的偶数

参数含义与map、filter一致。

计算数据，将可迭代对象的中的前两个值放在函数中做出运算，得出结果在和第三个值放在函数中运算得出结果，以此类推，直到所有的结果运算完毕，返回最终的结果。

根据功能我们就应该直到，reduce中的函数需要可以接收两个参数才可以。

将列表中的数据元素组合成为一个数，

iterable：可迭代对象；

key：指定函数，默认为空；

reverse：排序的方法，默认为False，意为升序；

如果没有指定函数，就单纯的将数据安札ASCII进行排序；如果指定了函数，就将数据放入函数中进行运算，根据数据的结果进行排序，返回新的数据，不会改变原有的数据。

注意，如果指定了函数，排序之后是根据数据的结果对原数据进行排序，而不是排序计算之后的就结果数据。

将列表中的数据进行排序。

还有一点就是 sorted 函数可以将数据放入函数中进行处理，然后根据结果进行排序。

既然有了列表的内置函数sort，为什么我们还要使用sorted函数呢？

高阶函数就是将函数作为参数的函数。

文章来自

Python的5种高级用法

Lambda 函数

Python 函数一般使用 def a_function_name() 样式来定义，但是对于 lambda 函数来说，我们其实根本没为它命名。这是因为 lambda 函数的功能是执行某种简单的表达式或运算，而无需完全定义函数。

Map 函数

Map() 是一种内置的 Python 函数，它可以将函数应用于各种数据结构中的元素，如列表或字典。对于这种运算来说，这是一种非常干净而且可读的执行方式。

Filter 函数

filter 内置函数与 map 函数非常相似，它也将函数应用于序列结构(列表、元组、字典)。二者的关键区别在于 filter() 将只返回应用函数返回 True 的元素。

Itertools 模块

Python 的 Itertools 模块是处理迭代器的工具集合。迭代器是一种可以在 for 循环语句(包括列表、元组和字典)中使用的数据类型。

使用 Itertools 模块中的函数让你可以执行很多迭代器操作，这些操作通常需要多行函数和复杂的列表理解。

Generator 函数

其实，Generator函数是一个类似于迭代器的函数，就是它也可以用在 for 循环语句中。这大大简化了你的代码，而且相比简单的 for 循环，它节省了很多内存。

关于Python的5种高级用法，青藤小编就和您分享到这里了。如果您对python编程有浓厚的兴趣，希望这篇文章可以为您提供帮助。如果您还想了解更多关于python编程的技巧及素材等内容，可以点击本站的其他文章进行学习。

Python的函数参数总结

import math

a = abs

print(a(-1))

n1 = 255

print(str(hex(n1)))

def my_abs(x):

# 增加了参数的检查

if not isinstance(x, (int, float)):

raise TypeError('bad operand type')

if x = 0:

return x

else:

return -x

print(my_abs(-3))

def nop():

pass

if n1 = 255:

pass

def move(x, y, step, angle=0):

nx = x + step * math.cos(angle)

ny = y - step * math.sin(angle)

return nx, ny

x, y = move(100, 100, 60, math.pi / 6)

print(x, y)

tup = move(100, 100, 60, math.pi / 6)

print(tup)

print(isinstance(tup, tuple))

def quadratic(a, b, c):

k = b * b - 4 * a * c

# print(k)

# print(math.sqrt(k))

if k 0:

print('This is no result!')

return None

elif k == 0:

x1 = -(b / 2 * a)

x2 = x1

return x1, x2

else:

x1 = (-b + math.sqrt(k)) / (2 * a)

x2 = (-b - math.sqrt(k)) / (2 * a)

return x1, x2

print(quadratic(2, 3, 1))

def power(x, n=2):

s = 1

while n 0:

n = n - 1

s = s * x

return s

print(power(2))

print(power(2, 3))

def enroll(name, gender, age=8, city='BeiJing'):

print('name:', name)

print('gender:', gender)

print('age:', age)

print('city:', city)

enroll('elder', 'F')

enroll('android', 'B', 9)

enroll('pythone', '6', city='AnShan')

def add_end(L=[]):

L.append('end')

return L

print(add_end())

print(add_end())

print(add_end())

def add_end_none(L=None):

if L is None:

L = []

L.append('END')

return L

print(add_end_none())

print(add_end_none())

print(add_end_none())

def calc(*nums):

sum = 0

for n in nums:

sum = sum + n * n

return sum

print(calc(1, 2, 3))

print(calc())

l = [1, 2, 3, 4]

print(calc(*l))

def foo(x, y):

print('x is %s' % x)

print('y is %s' % y)

foo(1, 2)

foo(y=1, x=2)

def person(name, age, **kv):

print('name:', name, 'age:', age, 'other:', kv)

person('Elder', '8')

person('Android', '9', city='BeiJing', Edu='人民大学')

extra = {'city': 'Beijing', 'job': 'Engineer'}

person('Jack', 24, **extra)

def person2(name, age, *, city, job):

print(name, age, city, job)

person2('Pthon', 8, city='BeiJing', job='Android Engineer')

def person3(name, age, *other, city='BeiJing', job='Android Engineer'):

print(name, age, other, city, job)

person3('Php', 18, 'test', 1, 2, 3)

person3('Php2', 28, 'test', 1, 2, 3, city='ShangHai', job='Pyhton Engineer')

def test2(a, b, c=0, *args, key=None, **kw):

print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'key=', key, 'kw =', kw)

test2(1, 2, 3, 'a', 'b', 'c', key='key', other='extra')

args = (1, 2, 3, 4)

kw = {'d': 99, 'x': '#'}

test2(*args, **kw)

太全了！Python3常用内置函数总结

数学相关

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]

类型转换

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

相关操作

eval****() : 执行一个表达式，或字符串作为运算。 eval('1+1') 2

exec() : 执行python语句。 exec('print("Python")') Python

filter(func, iterable) : 通过判断函数fun，筛选符合条件的元素。 filter(lambda x: x3, [1,2,3,4,5,6]) filter object at 0x0000000003813828

map(func, *iterable) : 将func用于每个iterable对象。 map(lambda a,b: a+b, [1,2,3,4], [5,6,7]) [6,8,10]

zip(*iterable) : 将iterable分组合并。返回一个zip对象。 list(zip([1,2,3],[4,5,6])) [(1, 4), (2, 5), (3, 6)]

type()：返回一个对象的类型。

id()： 返回一个对象的唯一标识值。

hash(object)：返回一个对象的hash值，具有相同值的object具有相同的hash值。 hash('python') 7070808359261009780

help()：调用系统内置的帮助系统。

isinstance()：判断一个对象是否为该类的一个实例。

issubclass()：判断一个类是否为另一个类的子类。

globals() : 返回当前全局变量的字典。

next(iterator[, default]) : 接收一个迭代器，返回迭代器中的数值，如果设置了default，则当迭代器中的元素遍历后，输出default内容。

reversed(sequence) ： 生成一个反转序列的迭代器。 reversed('abc') ['c','b','a']

Python进阶 —— 尾递归

下面是笔者的个人理解： 把计算出的值存在函数内部（当然不止尾递归）是其计算方法，从而不用在栈中去创建一个新的，这样就大大节省了空间。函数调用中最后返回的结果是单纯的递归函数调用（或返回结果）就是尾递归。

实例还是和笔者的上一篇文章相同，建议读者阅读 Python —— 递归

常规递归阶乘：

我们来看一下执行过程：

但是如果把上面的函数写成如下形式：

我们再看下执行过程：

很直观的就可以看出，这次的 factorial 函数在递归调用的时候不会产生一系列逐渐增多的中间变量了，而是将状态保存在 acc 这个变量中。而这种形式的递归，就叫做尾递归。

常规递斐波那契数列：

而尾递归：

一下子就充满了逼格，还高效了许多，何乐而不为呢！

Python字典中几个常用函数总结

1、get() 返回指定键的值，如果值不在字典中返回default值。

语法：dict.get(key,default=None)

参数：

key 字典中要查找的键。

default 如果指定键的值不存在时，返回该默认值值。

例：

dict={'Name':'alex','Age':21}

print("Name is:%s"% dict.get('Name')+"\n"+ "Age is:%d"% dict.get('Age'))

显示结果为：

Name is:alex

Age is:21

2、update() 将一个字典中的值更新到另一个字典中。

语法：dict.update(dict2)

参数：

dict2 添加到指定字典dict里的字典。

例：

dict={'Name':'alex','Age':21}

dict2={'Sex':'female'}

dict.update(dict2)

print("Value is %s" % dict)

显示结果为：

Value is {'Name': 'alex', 'Age': 21, 'Sex': 'female'}

网站题目：python函数进阶小结 Python函数笔记
文章源于：http://csdahua.cn/article/docsgij.html