python神奇的函数 python函数编程200例

Python中的常用内置函数有哪些呢？

（1）Lambda函数

用于创建匿名函数，即没有名称的函数。它只是一个表达式，函数体比def简单很多。当我们需要创建一个函数来执行单个操作并且可以在一行中编写时，就可以用到匿名函数了。

Lamdba的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

利用Lamdba函数，往往可以将代码简化许多。

（2）Map函数

会将一个函数映射到一个输入列表的所有元素上，比如我们先创建了一个函数来返回一个大写的输入单词，然后将此函数应有到列表colors中的所有元素。

我们还可以使用匿名函数lamdba来配合map函数，这样可以更加精简。

（3）Reduce函数

当需要对一个列表进行一些计算并返回结果时，reduce()是个非常有用的函数。举个例子，当需要计算一个整数列表所有元素的乘积时，即可使用reduce函数实现。

它与函数的最大的区别就是，reduce()里的映射函数(function)接收两个参数，而map接收一个参数。

（4）enumerate函数

用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在for循环当中。

它的两个参数，一个是序列、迭代器或其他支持迭代对象;另一个是下标起始位置，默认情况从0开始，也可以自定义计数器的起始编号。

（5）Zip函数

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

当我们使用zip()函数时，如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。

相关问答

Q1: python用函数给不及格成绩加分

python用函数给不及格成绩加分

Python的高级特征你知多少？来对比看看

机器之心

人工智能信息服务平台

来自专栏机器之心

Python 多好用不用多说，大家看看自己用的语言就知道了。但是 Python 隐藏的高级功能你都 get 了吗？本文中，作者列举了 Python 中五种略高级的特征以及它们的使用方法，快来一探究竟吧！

选自towardsdatascience，作者：George Seif，机器之心编译。

Python 是一种美丽的语言，它简单易用却非常强大。但你真的会用 Python 的所有功能吗？

任何编程语言的高级特征通常都是通过大量的使用经验才发现的。比如你在编写一个复杂的项目，并在 stackoverflow 上寻找某个问题的答案。然后你突然发现了一个非常优雅的解决方案，它使用了你从不知道的 Python 功能！

这种学习方式太有趣了：通过探索，偶然发现什么。

下面是 Python 的 5 种高级特征，以及它们的用法。

Lambda 函数

Lambda 函数是一种比较小的匿名函数——匿名是指它实际上没有函数名。

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

lambda 函数可以使用任意数量的参数，但表达式只能有一个。

x = lambda a, b : a * b print(x(5, 6)) # prints '30' x = lambda a : a*3 + 3 print(x(3)) # prints '12'

看它多么简单！我们执行了一些简单的数学运算，而无需定义整个函数。这是 Python 的众多特征之一，这些特征使它成为一种干净、简单的编程语言。

Map 函数

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

def square_it_func(a): return a * a x = map(square_it_func, [1, 4, 7]) print(x) # prints '[1, 16, 47]' def multiplier_func(a, b): return a * b x = map(multiplier_func, [1, 4, 7], [2, 5, 8]) print(x) # prints '[2, 20, 56]'看看上面的示例！我们可以将函数应用于单个或多个列表。实际上，你可以使用任何 Python 函数作为 map 函数的输入，只要它与你正在操作的序列元素是兼容的。

Filter 函数

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

详情请看如下示例：

# Our numbers numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] # Function that filters out all numbers which are odd def filter_odd_numbers(num): if num % 2 == 0: return True else: return False filtered_numbers = filter(filter_odd_numbers, numbers) print(filtered_numbers) # filtered_numbers = [2, 4, 6, 8, 10, 12, 14]

我们不仅评估了每个列表元素的 True 或 False，filter() 函数还确保只返回匹配为 True 的元素。非常便于处理检查表达式和构建返回列表这两步。

Itertools 模块

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

使用 Itertools 模块中的函数让你可以执行很多迭代器操作，这些操作通常需要多行函数和复杂的列表理解。关于 Itertools 的神奇之处，请看以下示例：

from itertools import * # Easy joining of two lists into a list of tuples for i in izip([1, 2, 3], ['a', 'b', 'c']): print i # ('a', 1) # ('b', 2) # ('c', 3) # The count() function returns an interator that # produces consecutive integers, forever. This # one is great for adding indices next to your list # elements for readability and convenience for i in izip(count(1), ['Bob', 'Emily', 'Joe']): print i # (1, 'Bob') # (2, 'Emily') # (3, 'Joe') # The dropwhile() function returns an iterator that returns # all the elements of the input which come after a certain # condition becomes false for the first time. def check_for_drop(x): print 'Checking: ', x return (x 5) for i in dropwhile(should_drop, [2, 4, 6, 8, 10, 12]): print 'Result: ', i # Checking: 2 # Checking: 4 # Result: 6 # Result: 8 # Result: 10 # Result: 12 # The groupby() function is great for retrieving bunches # of iterator elements which are the same or have similar # properties a = sorted([1, 2, 1, 3, 2, 1, 2, 3, 4, 5]) for key, value in groupby(a): print(key, value), end=' ') # (1, [1, 1, 1]) # (2, [2, 2, 2]) # (3, [3, 3]) # (4, [4]) # (5, [5])

Generator 函数

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

比如，我们想把 1 到 1000 的所有数字相加，以下代码块的第一部分向你展示了如何使用 for 循环来进行这一计算。

如果列表很小，比如 1000 行，计算所需的内存还行。但如果列表巨长，比如十亿浮点数，这样做就会出现问题了。使用这种 for 循环，内存中将出现大量列表，但不是每个人都有无限的 RAM 来存储这么多东西的。Python 中的 range() 函数也是这么干的，它在内存中构建列表。

代码中第二部分展示了使用 Python generator 函数对数字列表求和。generator 函数创建元素，并只在必要时将其存储在内存中，即一次一个。这意味着，如果你要创建十亿浮点数，你只能一次一个地把它们存储在内存中！Python 2.x 中的 xrange() 函数就是使用 generator 来构建列表。

上述例子说明：如果你想为一个很大的范围生成列表，那么就需要使用 generator 函数。如果你的内存有限，比如使用移动设备或边缘计算，使用这一方法尤其重要。

也就是说，如果你想对列表进行多次迭代，并且它足够小，可以放进内存，那最好使用 for 循环或 Python 2.x 中的 range 函数。因为 generator 函数和 xrange 函数将会在你每次访问它们时生成新的列表值，而 Python 2.x range 函数是静态的列表，而且整数已经置于内存中，以便快速访问。

# (1) Using a for loopv numbers = list() for i in range(1000): numbers.append(i+1) total = sum(numbers) # (2) Using a generator def generate_numbers(n): num, numbers = 1, [] while num n: numbers.append(num) num += 1 return numbers total = sum(generate_numbers(1000)) # (3) range() vs xrange() total = sum(range(1000 + 1)) total = sum(xrange(1000 + 1))

Q2: Python中几个特殊的函数

1、 定义一个特殊的 __slots__ 变量，来限制该class实例能添加的属性

2、 内置的 @property(关键字) 装饰器就是负责把一个方法变成属性调用的。@property.setter(这里的property是类里面的属性名)负责把一个setter方法变成属性赋值。

3、 __str__()，__repr__()，__iter__()，__next__()，__getitem__()，__setitem__()，__delitem__()，__getattr__()，__call__()

Q3: Python 有什么奇技淫巧

Python奇技淫巧

当发布python第三方package时, 并不希望代码中所有python神奇的函数的函数或者class可以被外部import, 在 __init__.py 中添加 __all__ 属性,

该list中填写可以import的类或者函数名, 可以起到限制的import的作用, 防止外部import其他函数或者类

#!/usr/bin/env python

# -*- coding: utf-8 -*-

frombaseimportAPIBase

fromclientimportClient

fromdecoratorimportinterface, export, stream

fromserverimportServer

fromstorageimportStorage

fromutilimport(LogFormatter, disable_logging_to_stderr,

enable_logging_to_kids, info)

__all__ = ['APIBase','Client','LogFormatter','Server',

'Storage','disable_logging_to_stderr','enable_logging_to_kids',

'export','info','interface','stream']

with的魔力

with语句需要支持 上下文管理协议的对象 , 上下文管理协议包含 __enter__ 和 __exit__ 两个方法. with语句建立运行时上下文需要通过这两个方法执行 进入和退出 操作.

其中 上下文表达式 是跟在with之后的表达式, 该表示大返回一个上下文管理对象

# 常见with使用场景

withopen("test.txt","r")asmy_file:# 注意, 是__enter__()方法的返回值赋值给了my_file,

forlineinmy_file:

print line

详细原理可以查看这篇文章, 浅谈 Python 的 with 语句

知道具体原理, python神奇的函数我们可以自定义支持上下文管理协议的类, 类中实现 __enter__ 和 __exit__ 方法

#!/usr/bin/env python

# -*- coding: utf-8 -*-

classMyWith(object):

def__init__(self):

print"__init__ method"

def__enter__(self):

print"__enter__ method"

returnself# 返回对象给as后的变量

def__exit__(self, exc_type, exc_value, exc_traceback):

print"__exit__ method"

ifexc_tracebackisNone:

print"Exited without Exception"

returnTrue

else:

print"Exited with Exception"

returnFalse

deftest_with():

withMyWith()asmy_with:

print"running my_with"

print"------分割线-----"

withMyWith()asmy_with:

print"running before Exception"

raiseException

print"running after Exception"

if__name__ =='__main__':

test_with()

执行结果如下:

__init__ method

__enter__ method

running my_with

__exit__ method

ExitedwithoutException

------分割线-----

__init__ method

__enter__ method

running before Exception

__exit__ method

ExitedwithException

Traceback(most recent call last):

File"bin/python", line34,inmodule

exec(compile(__file__f.read(), __file__, "exec"))

File"test_with.py", line33,inmodule

test_with()

File"test_with.py", line28,intest_with

raiseException

Exception

证明了会先执行 __enter__ 方法, 然后调用with内的逻辑, 最后执行 __exit__ 做退出处理, 并且, 即使出现异常也能正常退出

filter的用法

相对 filter 而言, map和reduce使用的会更频繁一些, filter 正如其名字, 按照某种规则 过滤 掉一些元素

#!/usr/bin/env python

# -*- coding: utf-8 -*-

lst = [1,2,3,4,5,6]

# 所有奇数都会返回True, 偶数会返回False被过滤掉

print filter(lambda x: x % 2!=0, lst)

#输出结果

[1,3,5]

一行作判断

当条件满足时, 返回的为等号后面的变量, 否则返回else后语句

lst = [1,2,3]

new_lst = lst[0]iflstisnotNoneelseNone

printnew_lst

# 打印结果

1

装饰器之单例

使用装饰器实现简单的单例模式

# 单例装饰器

defsingleton(cls):

instances = dict() # 初始为空

def_singleton(*args, **kwargs):

ifclsnotininstances:#如果不存在, 则创建并放入字典

instances[cls] = cls(*args, **kwargs)

returninstances[cls]

return_singleton

@singleton

classTest(object):

pass

if__name__ =='__main__':

t1 = Test()

t2 = Test()

# 两者具有相同的地址

printt1, t2

staticmethod装饰器

类中两种常用的装饰, 首先区分一下他们

普通成员函数, 其中第一个隐式参数为 对象

classmethod装饰器 , 类方法(给人感觉非常类似于OC中的类方法), 其中第一个隐式参数为 类

staticmethod装饰器 , 没有任何隐式参数. python中的静态方法类似与C++中的静态方法

#!/usr/bin/env python

# -*- coding: utf-8 -*-

classA(object):

# 普通成员函数

deffoo(self, x):

print "executing foo(%s, %s)"% (self, x)

@classmethod# 使用classmethod进行装饰

defclass_foo(cls, x):

print "executing class_foo(%s, %s)"% (cls, x)

@staticmethod# 使用staticmethod进行装饰

defstatic_foo(x):

print "executing static_foo(%s)"% x

deftest_three_method():

obj = A()

# 直接调用噗通的成员方法

obj.foo("para")# 此处obj对象作为成员函数的隐式参数, 就是self

obj.class_foo("para")# 此处类作为隐式参数被传入, 就是cls

A.class_foo("para")#更直接的类方法调用

obj.static_foo("para")# 静态方法并没有任何隐式参数, 但是要通过对象或者类进行调用

A.static_foo("para")

if__name__=='__main__':

test_three_method()

# 函数输出

executing foo(__main__.Aobject at0x100ba4e10, para)

executing class_foo(class'__main__.A',para)

executing class_foo(class'__main__.A',para)

executing static_foo(para)

executing static_foo(para)

property装饰器

定义私有类属性

将 property 与装饰器结合实现属性私有化( 更简单安全的实现get和set方法 )

#python内建函数

property(fget=None, fset=None, fdel=None, doc=None)

fget 是获取属性的值的函数, fset 是设置属性值的函数, fdel 是删除属性的函数, doc 是一个字符串(like a comment).从实现来看python神奇的函数，这些参数都是可选的

property有三个方法 getter() , setter() 和 delete() 来指定fget, fset和fdel。 这表示以下这行

classStudent(object):

@property #相当于property.getter(score) 或者property(score)

defscore(self):

returnself._score

@score.setter #相当于score = property.setter(score)

defscore(self, value):

ifnotisinstance(value, int):

raiseValueError('score must be an integer!')

ifvalue 0orvalue 100:

raiseValueError('score must between 0 ~ 100!')

self._score = value

iter魔法

通过yield和 __iter__ 的结合, 我们可以把一个对象变成可迭代的

通过 __str__ 的重写, 可以直接通过想要的形式打印对象

#!/usr/bin/env python

# -*- coding: utf-8 -*-

classTestIter(object):

def__init__(self):

self.lst = [1,2,3,4,5]

defread(self):

foreleinxrange(len(self.lst)):

yieldele

def__iter__(self):

returnself.read()

def__str__(self):

return','.join(map(str, self.lst))

__repr__ = __str__

deftest_iter():

obj = TestIter()

fornuminobj:

printnum

printobj

if__name__ =='__main__':

test_iter()

神奇partial

partial使用上很像C++中仿函数(函数对象).

在stackoverflow给出了类似与partial的运行方式

defpartial(func, *part_args):

defwrapper(*extra_args):

args = list(part_args)

args.extend(extra_args)

returnfunc(*args)

returnwrapper

利用用闭包的特性绑定预先绑定一些函数参数, 返回一个可调用的变量, 直到真正的调用执行

#!/usr/bin/env python

# -*- coding: utf-8 -*-

fromfunctoolsimportpartial

defsum(a, b):

returna + b

deftest_partial():

fun = partial(sum, 2)# 事先绑定一个参数, fun成为一个只需要一个参数的可调用变量

printfun(3)# 实现执行的即是sum(2, 3)

if__name__ =='__main__':

test_partial()

# 执行结果

5

神秘eval

eval我理解为一种内嵌的python解释器(这种解释可能会有偏差), 会解释字符串为对应的代码并执行, 并且将执行结果返回

看一下下面这个例子

#!/usr/bin/env python

# -*- coding: utf-8 -*-

deftest_first():

return3

deftest_second(num):

returnnum

action = { # 可以看做是一个sandbox

"para":5,

"test_first": test_first,

"test_second": test_second

}

deftest_eavl():

condition = "para == 5 and test_second(test_first) 5"

res = eval(condition, action) # 解释condition并根据action对应的动作执行

printres

if__name__ =='_

exec

exec在Python中会忽略返回值, 总是返回None, eval会返回执行代码或语句的返回值

exec 和 eval 在执行代码时, 除了返回值其他行为都相同

在传入字符串时, 会使用 compile(source, 'string', mode) 编译字节码. mode的取值为 exec 和 eval

#!/usr/bin/env python

# -*- coding: utf-8 -*-

deftest_first():

print"hello"

deftest_second():

test_first()

print"second"

deftest_third():

print"third"

action = {

"test_second": test_second,

"test_third": test_third

}

deftest_exec():

exec"test_second"inaction

if__name__ =='__main__':

test_exec() # 无法看到执行结果

getattr

getattr(object, name[, default]) Return the value of

the named attribute of object. name must be a string. If the string is

the name of one of the object’s attributes, the result is the value of

that attribute. For example, getattr(x, ‘foobar’) is equivalent to

x.foobar. If the named attribute does not exist, default is returned if

provided, otherwise AttributeError is raised.

通过string类型的name, 返回对象的name属性(方法)对应的值, 如果属性不存在, 则返回默认值, 相当于object.name

# 使用范例

classTestGetAttr(object):

test = "test attribute"

defsay(self):

print"test method"

deftest_getattr():

my_test = TestGetAttr()

try:

printgetattr(my_test,"test")

exceptAttributeError:

print"Attribute Error!"

try:

getattr(my_test, "say")()

exceptAttributeError:# 没有该属性, 且没有指定返回值的情况下

print"Method Error!"

if__name__ =='__main__':

test_getattr()

# 输出结果

test attribute

test method

命令行处理

defprocess_command_line(argv):

"""

Return a 2-tuple: (settings object, args list).

`argv` is a list of arguments, or `None` for ``sys.argv[1:]``.

"""

ifargvisNone:

argv = sys.argv[1:]

# initialize the parser object:

parser = optparse.OptionParser(

formatter=optparse.TitledHelpFormatter(width=78),

add_help_option=None)

# define options here:

parser.add_option( # customized description; put --help last

'-h','--help', action='help',

help='Show this help message and exit.')

settings, args = parser.parse_args(argv)

# check number of arguments, verify values, etc.:

ifargs:

parser.error('program takes no command-line arguments; '

'"%s" ignored.'% (args,))

# further process settings args if necessary

returnsettings, args

defmain(argv=None):

settings, args = process_command_line(argv)

# application code here, like:

# run(settings, args)

return0# success

if__name__ =='__main__':

status = main()

sys.exit(status)

读写csv文件

# 从csv中读取文件, 基本和传统文件读取类似

importcsv

withopen('data.csv','rb')asf:

reader = csv.reader(f)

forrowinreader:

printrow

# 向csv文件写入

importcsv

withopen('data.csv','wb')asf:

writer = csv.writer(f)

writer.writerow(['name','address','age'])# 单行写入

data = [

( 'xiaoming ','china','10'),

( 'Lily','USA','12')]

writer.writerows(data) # 多行写入

各种时间形式转换

只发一张网上的图, 然后差文档就好了, 这个是记不住的

字符串格式化

一个非常好用, 很多人又不知道的功能

name ="andrew"

"my name is {name}".format(name=name)

'my name is andrew'

Q4: Python 几个重要的内置函数

在学习Python的过程中，有几个比较重要的内置函数：help()函数、dir()函数、input()与raw_input()函数、print()函数、type()函数。

第一、help()函数

Help()函数的参数分为两种：如果传一个字符串做参数的话，它会自动搜索以这个字符串命名的模块、方法等;如果传入的是一个对象，就会显示这个对象的类型的帮助。比如输入help(‘print’)，它就会寻找以‘print’为名的模块、类等，找不到就会看到提示信息;而print在Python里是一个保留字，和pass、return同等，而非对象，所以help(print)也会报错。

第二、dir()函数

dir()函数返回任意对象的属性和方法列表，包含模块对象、函数对象、字符串对象、列表对象、字典对象等。尽管查找和导入模块相对容易，但是记住每个模块包含什么却不是这么简单，您并不希望总是必须查看源代码来找出答案。Python提供了一种方法，可以使用内置的dir()函数来检查模块的内容，当你为dir()提供一个模块名的时候，它返回模块定义的属性列表。dir()函数适用于所有对象的类型，包含字符串、整数、列表、元组、字典、函数、定制类、类实例和类方法。

第三、input与raw_input函数

都是用于读取用户输入的，不同的是input()函数期望用户输入的是一个有效的表达式，而raw_input()函数是将用户的输入包装成一个字符串。

第四、Print()函数

Print在Python3版本之间是作为Python语句使用的，在Python3里print是作为函数使用的。

第五、type()函数

Type()函数返回任意对象的数据类型。在types模块中列出了可能的数据类型，这对于处理多种数据类型的函数非常有用，它通过返回类型对象来做到这一点，可以将这个类型对象与types模块中定义类型相比较。

关于python神奇的函数和python函数编程200例的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。