python中eval函数作用是计算字符串中有效的表达式，并返回结果。将字符串转成相应的对象（如list、tuple、dict和string之间的转换）。利用反引号转换的字符串再反转回对象。
创新互联建站是一家集网站建设,绍兴企业网站建设,绍兴品牌网站建设,网站定制,绍兴网站建设报价,网络营销,网络优化,绍兴网站推广为一体的创新建站企业，帮助传统企业提升企业形象加强企业竞争力。可充分满足这一群体相比中小企业更为丰富、高端、多元的互联网需求。同时我们时刻保持专业、时尚、前沿，时刻以成就客户成长自我，坚持不断学习、思考、沉淀、净化自己，让我们为更多的企业打造出实用型网站。
eval()函数用来执行一个字符串表达式，并返回表达式的值。eval函数功能：将字符串str当成有效的表达式来求值并返回计算结果。eval函数可以实现list、dict、tuple与str之间的转化。
Python语言的介绍
Python是一种计算机程序设计语言，由吉多·范罗苏姆创造，第一版发布于1991年，可以视之为一种改良的LISP。Python的设计哲学强调代码的可读性和简洁的语法。相比于C++或Java，Python让开发者能够用更少的代码表达想法。
Python语言的简洁性、易读性以及可扩展性，在国外用Python做科学计算的研究机构日益增多，一些知名大学已经采用Python来教授程序设计课程。
1、 定义一个特殊的 __slots__ 变量，来限制该class实例能添加的属性
2、 内置的 @property(关键字) 装饰器就是负责把一个方法变成属性调用的。@property.setter(这里的property是类里面的属性名)负责把一个setter方法变成属性赋值。
3、 __str__()，__repr__()，__iter__()，__next__()，__getitem__()，__setitem__()，__delitem__()，__getattr__()，__call__()
pow()函数，是Python的内置函数,它计算并返回x的y次方的值。
import math
math.pow( x, y )
这个函数还有一个用法：
pow(x, y, z)
函数是计算 x 的 y 次方，如果 z 在存在，则再对结果进行取模，其结果等效于 pow(x,y) %z。
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))
Python奇技淫巧
当发布python第三方package时, 并不希望代码中所有的函数或者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 语句
知道具体原理, 我们可以自定义支持上下文管理协议的类, 类中实现 __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).从实现来看，这些参数都是可选的
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'
1、高阶函数
变量可以指向函数，函数的参数可以接收变量，那么函数可以接收另一个函数作为参数，这种函数称为高阶函数。
(1)把函数作为实参
(2)把函数作为返回值
2、系统的内置高阶函数
(1)map函数：接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并且把结果作为新的列表返回
(2)reduce函数：把一个函数作用到一个序列上，这个函数必须接收两个参数，reduce把结果和序列的下一个元素做累积计算
(3)filter函数：也接收一个函数和一个序列，和map函数不同的是，filter函数把传入的函数依次作用于每个元素，然后返回返回值是True的元素
(4)sorted函数：排序函数
把用户名按照首字母不区分大小写排序
(5)sorted()函数按照关键字排序
关键字：商品个数
(6)sorted()函数按照关键字排序，用键值来查找
(7)lambda匿名函数：有时候传参数时不需要显示自定义的函数，直接传入匿名函数更方便；冒号前面的x,y表示函数参数，匿名函数不需要担心函数名的冲突，匿名函数也是一个函数对象，可以把匿名函数赋值给一个变量，再利用变量来调用函数，匿名函数也可以作为返回值返回
3、高阶函数的应用：
(1)sorted函数：
(2)sorted函数默认是从小到大排序
4、装饰器
装饰器就是用来装饰函数的：想要增加原有函数的功能，但是不希望修改原有函数的定义，在代码运行期间动态增加功能的方式
(1)此装饰器的功能：计算函数的运行时间
import functools
@functools.wraps(f) ##保留原有函数的属性
运行结果：
(2)此装饰器的功能：用户登录认证
运行结果：
(3)此装饰器的功能：认证用户的同时，显示用户的转账金额
import inspect
inspect.getcallargs()将传的参数封装为一个字典，字典的key值是形式参数，value值是实参
(4)此装饰器的功能：确保收到的每个参数都是整数，是整数就求和，否则抛出错误
(5)此装饰器的功能：给装饰器传参数，是整数和浮点数就求和
python学习网，大量的免费python视频教程，欢迎在线学习！
