金沙贵宾会官网|金沙贵宾会登录-官网

【A】金沙贵宾会官网超高的返奖率为娱乐者提供资金保障,所以金沙贵宾会登录官网更加的方便了你的娱乐,申请88元彩金,因为在当中不仅仅只有游戏。

一波神奇的Python语句,Python奇技淫巧

日期:2019-10-04编辑作者:网络软件

当公布python第三方package时, 并不指望代码中有着的函数或然class能够被外表import,在__init__.py中添加__all__质量,该list中填入能够import的类依旧函数名,能够起到限制的import的功用,防止外部import别的函数或许类。

来得有限的接口到表面

当发布python第三方package时, 并不指望代码中有所的函数或许class能够被外表import, 在__init__.py中添加__all__属性,

该list中填入能够import的类照旧函数名, 能够起到限制的import的效果与利益, 幸免外界import别的函数可能类

#!/usr/bin/env python

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

from base import APIBase

from client import Client

from decorator import interface, export, stream

from server import Server

from storage import Storage

from util import (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使用情形

with open("test.txt", "r") as my_file:  # 注意, 是__enter__()方法的再次回到值赋值给了my_file,

for line in my_file:

print line

详见原理能够查看那篇小说,浅谈 Python 的 with 语句

明亮具体原理, 我们能够自定义帮助上下文管理契约的类, 类中贯彻__enter__和__exit__方法

#!/usr/bin/env python

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

class MyWith(object):

def __init__(self):

print "__init__ method"

def __enter__(self):

print "__enter__ method"

return self  # 重回对象给as后的变量

def __exit__(self, exc_type, exc_value, exc_traceback):

print "__exit__ method"

if exc_traceback is None:

print "Exited without Exception"

return True

else:

print "Exited with Exception"

return False

def test_with():

with MyWith() as my_with:

print "running my_with"

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

with MyWith() as my_with:

print "running before Exception"

raise Exception

print "running after Exception"

if __name__ == '__main__':

test_with()

施行结果如下:

__init__ method

__enter__ method

running my_with

__exit__ method

Exited without Exception

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

__init__ method

__enter__ method

running before Exception

__exit__ method

Exited with Exception

Traceback (most recent call last):

File "bin/python", line 34, in

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

File "test_with.py", line 33, in

test_with()

File "test_with.py", line 28, in test_with

raise Exception

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] if lst is not None else None

print new_lst

# 打字与印刷结果

1

装饰器之单例

运用装饰器达成轻易的单例方式

# 单例装饰器

def singleton(cls):

instances = dict()  # 最初为空

def _singleton(*args, **kwargs):

if cls not in instances:  #假设不设有, 则创造并放入字典

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

return instances[cls]

return _singleton

@singleton

class Test(object):

pass

if __name__ == '__main__':

t1 = Test()

t2 = Test()

# 两个具备同样的地点

print t1, t2

staticmethod装饰器

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

日常性成员函数, 在那之中第一个隐式参数为目的

classmethod装饰器, 类方法(给人倍感非常相近于OC中的类措施), 当中第1个隐式参数为类

staticmethod装饰器, 未有其余隐式参数.python中的静态方法类似与C++中的静态方法

#!/usr/bin/env python

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

class A(object):

# 普通成员函数

def foo(self, x):

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

@classmethod  # 使用classmethod举办李装运修

def class_foo(cls, x):

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

@staticmethod  # 使用staticmethod进行装修

def static_foo(x):

print "executing static_foo(%s)" % x

def test_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__.A object at 0x100ba4e10>, para)

executing class_foo(, para)

executing class_foo(, 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。 那象征以下那行

class Student(object):

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

def score(self):

return self._score

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

def score(self, value):

if not isinstance(value, int):

raise ValueError('score must be an integer!')

if value < 0 or value > 100:

raise ValueError('score must between 0 ~ 100!')

self._score = value

iter魔法

通过yield和__iter__的重组, 大家能够把叁个对象产生可迭代的

通过__str__的重写, 可以一向通过想要的款型打字与印刷对象

#!/usr/bin/env python

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

class TestIter(object):

def __init__(self):

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

def read(self):

for ele in xrange(len(self.lst)):

yield ele

def __iter__(self):

return self.read()

def __str__(self):

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

__repr__ = __str__

def test_iter():

obj = TestIter()

for num in obj:

print num

print obj

if __name__ == '__main__':

test_iter()

神奇partial

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

在stackoverflow给出了近似与partial的运维格局

def partial(func, *part_args):

def wrapper(*extra_args):

args = list(part_args)

args.extend(extra_args)

return func(*args)

return wrapper

利用用闭包的风味绑定预先绑定一些函数参数, 重返贰个可调用的变量, 直到确实的调用实践

#!/usr/bin/env python

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

from functools import partial

def sum(a, b):

return a + b

def test_partial():

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

print fun(3)  # 达成执行的正是sum(2, 3)

if __name__ == '__main__':

test_partial()

# 实践结果

5

神秘eval

eval作者领悟为一种内嵌的python解释器(这种解释只怕会有不是), 会解释字符串为相应的代码并实行, 况兼将施行结果再次来到

看一下下边那一个例子

#!/usr/bin/env python

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

def test_first():

return 3

def test_second(num):

return num

action = {  # 能够视作是三个sandbox

"para": 5,

"test_first" : test_first,

"test_second": test_second

}

def test_eavl():

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

res = eval(condition, action)  # 解释condition并基于action对应的动作实行

print res

if __name__ == '_

exec

exec在Python中会忽略再次回到值, 总是回到None, eval会再次回到推行代码或言辞的再次来到值

exec和eval在实施代码时, 除了重临值别的展现都一致

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

#!/usr/bin/env python

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

def test_first():

print "hello"

def test_second():

test_first()

print "second"

def test_third():

print "third"

action = {

"test_second": test_second,

"test_third": test_third

}

def test_exec():

exec "test_second" in action

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

# 使用楷模

class TestGetAttr(object):

test = "test attribute"

def say(self):

print "test method"

def test_getattr():

my_test = TestGetAttr()

try:

print getattr(my_test, "test")

except AttributeError:

print "Attribute Error!"

try:

getattr(my_test, "say")()

except AttributeError: # 未有该属性, 且未有一些名重临值的事态下

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中读取文件, 基本和历史观文书读取类似

import csv

with open('data.csv', 'rb') as f:

reader = csv.reader(f)

for row in reader:

print row

# 向csv文件写入

import csv

with open( 'data.csv', 'wb') as f:

writer = csv.writer(f)

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

data = [

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

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

writer.writerows(data)  # 多行写入

种种时间情势调换

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

图片 1

字符串格式化

二个不行好用, 很三人又不驾驭的功用

>>> name = "andrew"

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

'my name is andrew'

# 仍是能够是 

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

参照他事他说加以考察链接

What is the difference between @staticmethod and @classmethod in Python?

Python @property versus getters and setters

How does the @property decorator work?

How does the functools partial work in Python?

What’s the difference between eval, exec, and compile in Python?

Be careful with exec and eval in Python

Python (and Python C API):newversusinit

Python ‘self’ keywordself不是任重先生而道远字, 是多个预订的变量名

Python进级必读汇总

使python类能够判明真值

Best Python Resources

Python安全编码指南

转摘自:

小编在简书的地方:

一波美妙的Python语句、函数与情势的采用才能总计,

来得有限的接口到表面 当发表python第三方package时,并不愿意代码中具备的函数大概class可以被表面import,在__init__.py中添加__all__品质,该list中填入能够import的类依然函数名, 能够起到限制的import的机能, 制止外界import其余函数或然类。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from base import APIBase
from client import Client
from decorator import interface, export, stream
from server import Server
from storage import Storage
from util import (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使用场景
with open("test.txt", "r") as my_file: # 注意, 是__enter__()方法的返回值赋值给了my_file,
  for line in my_file:
    print line

精通具体原理,大家得以自定义帮助上下文管理合同的类,类中达成__enter__和__exit__方法。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
class MyWith(object):
  def __init__(self):
    print "__init__ method"
  def __enter__(self):
    print "__enter__ method"
    return self # 返回对象给as后的变量
  def __exit__(self, exc_type, exc_value, exc_traceback):
    print "__exit__ method"
    if exc_traceback is None:
      print "Exited without Exception"
      return True
    else:
      print "Exited with Exception"
      return False
def test_with():
  with MyWith() as my_with:
    print "running my_with"
  print "------分割线-----"
  with MyWith() as my_with:
    print "running before Exception"
    raise Exception
    print "running after Exception"
if __name__ == '__main__':
  test_with()

进行结果如下:

__init__ method
__enter__ method
running my_with
__exit__ method
Exited without Exception
------分割线-----
__init__ method
__enter__ method
running before Exception
__exit__ method
Exited with Exception
Traceback (most recent call last):
 File "bin/python", line 34, in <module>
  exec(compile(__file__f.read(), __file__, "exec"))
 File "test_with.py", line 33, in <module>
  test_with()
 File "test_with.py", line 28, in test_with
  raise Exception
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] if lst is not None else None
print new_lst
# 打印结果
1

装饰器之单例 利用装饰器完毕简单的单例方式

# 单例装饰器
def singleton(cls):
  instances = dict() # 初始为空
  def _singleton(*args, **kwargs):
    if cls not in instances: #如果不存在, 则创建并放入字典
      instances[cls] = cls(*args, **kwargs)
    return instances[cls]
  return _singleton
@singleton
class Test(object):
  pass
if __name__ == '__main__':
  t1 = Test()
  t2 = Test()
  # 两者具有相同的地址
  print t1, t2

staticmethod装饰器 类中两种常用的点缀, 首先区分一下他们:

普普通通成员函数, 在那之中第三个隐式参数为对象

  • classmethod装饰器, 类方法(给人备感十一分周围于OC中的类格局), 当中第三个隐式参数为类
  • staticmethod装饰器, 没有其余隐式参数. python中的静态方法类似与C++中的静态方法
#!/usr/bin/env python

# -*- coding: utf-8 -*-
class A(object):
  # 普通成员函数
  def foo(self, x):
    print "executing foo(%s, %s)" % (self, x)
  @classmethod  # 使用classmethod进行装饰
  def class_foo(cls, x):
    print "executing class_foo(%s, %s)" % (cls, x)
  @staticmethod # 使用staticmethod进行装饰
  def static_foo(x):
    print "executing static_foo(%s)" % x
def test_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__.A object at 0x100ba4e10>, 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是贰个字符串( 像注释同样)。从贯彻来看,那么些参数都以可选的。

property有多个章程getter(), setter()和delete() 来钦赐fget, fset和fdel。 那意味着以下那行:

class Student(object):
  @property #相当于property.getter(score) 或者property(score)
  def score(self):
    return self._score
  @score.setter #相当于score = property.setter(score)
  def score(self, value):
    if not isinstance(value, int):
      raise ValueError('score must be an integer!')
    if value < 0 or value > 100:
      raise ValueError('score must between 0 ~ 100!')
    self._score = value

iter魔法 通过yield和__iter__的组成,大家得以把二个指标变成可迭代的
通过__str__的重写, 能够直接通过想要的样式打印对象

#!/usr/bin/env python
# -*- coding: utf-8 -*-
class TestIter(object):
  def __init__(self):
    self.lst = [1, 2, 3, 4, 5]
  def read(self):
    for ele in xrange(len(self.lst)):
      yield ele
  def __iter__(self):
    return self.read()
  def __str__(self):
    return ','.join(map(str, self.lst))

  __repr__ = __str__
def test_iter():
  obj = TestIter()
  for num in obj:
    print num
  print obj
if __name__ == '__main__':
  test_iter()

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

在stackoverflow给出了看似与partial的运营方式:

def partial(func, *part_args):
  def wrapper(*extra_args):
    args = list(part_args)
    args.extend(extra_args)
    return func(*args)
  return wrapper

动用用闭包的特色绑定预先绑定一些函数参数,重临三个可调用的变量, 直到确实的调用试行:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from functools import partial
def sum(a, b):
  return a + b
def test_partial():
  fun = partial(sum, 2)  # 事先绑定一个参数, fun成为一个只需要一个参数的可调用变量
  print fun(3) # 实现执行的即是sum(2, 3)
if __name__ == '__main__':
  test_partial()

# 执行结果
5

神秘eval eval我精晓为一种内嵌的python解释器(这种解释大概会有错误), 会解释字符串为对应的代码并施行, 何况将实行结果回到。

看一下底下那一个事例:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
def test_first():
  return 3
def test_second(num):
  return num
action = { # 可以看做是一个sandbox
    "para": 5,
    "test_first" : test_first,
    "test_second": test_second
    }
def test_eavl(): 
  condition = "para == 5 and test_second(test_first) > 5"
  res = eval(condition, action) # 解释condition并根据action对应的动作执行
  print res
if __name__ == '_

exec exec在Python中会忽略重临值, 总是回到None, eval会重返实施代码或言辞的再次来到值
exec和eval在施行代码时, 除了再次来到值别的展现都一致
在流传字符串时, 会使用compile(source, '<string>', mode)编写翻译字节码。 mode的取值为exec和eval

#!/usr/bin/env python
# -*- coding: utf-8 -*-
def test_first():
  print "hello"
def test_second():
  test_first()
  print "second"
def test_third():
  print "third"
action = {
    "test_second": test_second,
    "test_third": test_third
    }
def test_exec():
  exec "test_second" in action
if __name__ == '__main__':
  test_exec() # 无法看到执行结果

getattr getattr(object, name[, default])重返对象的命名属性,属性名必得是字符串。如若字符串是目的的属性名之一,结果正是该属性的值。举个例子, getattr(x, ‘foobar') 等价于 x.foobar。 假使属性名不真实,假如有暗许值则赶回暗中认可值,不然触发 AttributeError 。

# 使用范例
class TestGetAttr(object):
  test = "test attribute"
  def say(self):
    print "test method"
def test_getattr():
  my_test = TestGetAttr()
  try:
    print getattr(my_test, "test")
  except AttributeError:
    print "Attribute Error!"
  try:
    getattr(my_test, "say")()
  except AttributeError: # 没有该属性, 且没有指定返回值的情况下
    print "Method Error!"
if __name__ == '__main__':
  test_getattr()

# 输出结果
test attribute
test method

命令行管理

def process_command_line(argv):
  """
  Return a 2-tuple: (settings object, args list).
  `argv` is a list of arguments, or `None` for ``sys.argv[1:]``.
  """
  if argv is None:
    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.:
  if args:
    parser.error('program takes no command-line arguments; '
           '"%s" ignored.' % (args,))
  # further process settings & args if necessary
  return settings, args
def main(argv=None):
  settings, args = process_command_line(argv)
  # application code here, like:
  # run(settings, args)
  return 0    # success
if __name__ == '__main__':
  status = main()
  sys.exit(status)

读写csv文件

# 从csv中读取文件, 基本和传统文件读取类似
import csv
with open('data.csv', 'rb') as f:
  reader = csv.reader(f)
  for row in reader:
    print row
# 向csv文件写入
import csv
with open( 'data.csv', 'wb') as f:
  writer = csv.writer(f)
  writer.writerow(['name', 'address', 'age']) # 单行写入
  data = [
      ( 'xiaoming ','china','10'),
      ( 'Lily', 'USA', '12')]
  writer.writerows(data) # 多行写入

种种时间情势转变 只发一张英特网的图, 然后查文书档案就好了, 那么些是记不住的

图片 2

字符串格式化 贰个非常好用, 相当多个人又不了然的效劳:

>>> name = "andrew"
>>> "my name is {name}".format(name=name)
'my name is andrew'
#!/usr/bin/env python# -*- coding: utf-8 -*-from base import APIBasefrom client import Clientfrom decorator import interface, export, streamfrom server import Serverfrom storage import Storagefrom util import (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']

您大概感兴趣的稿子:

  • Python语言本事之莫斯利安运算符使用介绍
  • Python 文件操作技艺(File operation) 实例代码深入分析
  • 翻开Python安装路线以及安装包路线小才具
  • Python字符串中查找子串小能力

展现有限的接口到表面 当发表python第三方package时,并不希望代码中有所的函数或然...

with语句需求帮助上下文管理协议的对象, 上下文管理合同包涵__enter____exit__三个主意。with语句建设构造运营时上下文必要通过那八个措施实行进入和退出操作。

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

# 常见with使用场景with open("test.txt", "r") as my_file: # 注意, 是__enter__()方法的返回值赋值给了my_file,for line in my_file:print line

详细原理能够查看那篇小说, 浅谈 Python 的 with 语句。

通晓具体原理,大家得以自定义援助上下文管理左券的类, 类中实__enter____exit__方法。

#!/usr/bin/env python# -*- coding: utf-8 -*-class MyWith: def __init__: print "__init__ method" def __enter__: print "__enter__ method" return self # 返回对象给as后的变量 def __exit__(self, exc_type, exc_value, exc_traceback): print "__exit__ method" if exc_traceback is None: print "Exited without Exception" return True else: print "Exited with Exception" return Falsedef test_with(): with MyWith() as my_with: print "running my_with" print "------分割线-----" with MyWith() as my_with: print "running before Exception" raise Exception print "running after Exception"if __name__ == '__main__': test_with()

实行结果如下:

__init__ method__enter__ methodrunning my_with__exit__ methodExited without Exception------分割线-----__init__ method__enter__ methodrunning before Exception__exit__ methodExited with ExceptionTraceback (most recent call last): File "bin/python", line 34, in <module> exec(compile(__file__f.read(), __file__, "exec")) File "test_with.py", line 33, in <module> test_with() File "test_with.py", line 28, in test_with raise ExceptionException

表明了会西施行__enter__措施,然后调用with内的逻辑,末了施行__exit__做退出管理,并且, 尽管出现至极也能平日退出。

相对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] if lst is not None else Noneprint new_lst# 打印结果1

选取装饰器完结轻易的单例形式。

# 单例装饰器def singleton: instances = dict() # 初始为空 def _singleton(*args, **kwargs): if cls not in instances: #如果不存在, 则创建并放入字典 instances[cls] = cls(*args, **kwargs) return instances[cls] return _singleton@singletonclass Test: passif __name__ == '__main__': t1 = Test() t2 = Test() # 两者具有相同的地址 print t1, t2

类中三种常用的装裱,首先区分一下他们。

  • 习以为常成员函数, 个中第贰个隐式参数为对象
  • classmethod装饰器,类措施(给人深感那么些周围于OC中的类措施), 当中第八个隐式参数为
  • staticmethod装饰器,未有任何隐式参数。python中的静态方法类似与C++中的静态方法
#!/usr/bin/env python# -*- coding: utf-8 -*-class A: # 普通成员函数 def foo: print "executing foo" %  @classmethod # 使用classmethod进行装饰 def class_foo: print "executing class_foo" %  @staticmethod # 使用staticmethod进行装饰 def static_foo: print "executing static_foo" % xdef test_three_method(): obj = A() # 直接调用噗通的成员方法 obj.foo # 此处obj对象作为成员函数的隐式参数, 就是self obj.class_foo # 此处类作为隐式参数被传入, 就是cls A.class_foo #更直接的类方法调用 obj.static_foo # 静态方法并没有任何隐式参数, 但是要通过对象或者类进行调用 A.static_fooif __name__ == '__main__': test_three_method() # 函数输出executing foo(<__main__.A object at 0x100ba4e10>, para)executing class_foo(<class '__main__.A'>, para)executing class_foo(<class '__main__.A'>, para)executing static_fooexecuting static_foo
  • 概念私有类属性

property与装饰器结合贯彻属性私有化(更简便安全的完毕getset方法)。

#python内建函数property(fget=None, fset=None, fdel=None, doc=None)

fget是获得属性的值的函数,fset是安装属性值的函数,fdel是去除属性的函数,doc是叁个字符串(like a comment)。从贯彻来看,这个参数都以可选的。

property有多个章程getter()setter()delete()来内定fget,fset和fdel。 那表示以下这行:

class Student: @property #相当于property.getter 或者property def score: return self._score @score.setter #相当于score = property.setter def score(self, value): if not isinstance(value, int): raise ValueError('score must be an integer!') if value < 0 or value > 100: raise ValueError('score must between 0 ~ 100!') self._score = value
  • 通过yield和__iter__的重组, 大家能够把二个目的形成可迭代的。
  • 通过__str__的重写,可以平素通过想要的样式打印对象。
#!/usr/bin/env python# -*- coding: utf-8 -*-class TestIter: def __init__: self.lst = [1, 2, 3, 4, 5] def read: for ele in xrange(len): yield ele def __iter__: return self.read() def __str__: return ','.join(map(str, self.lst)) __repr__ = __str__def test_iter(): obj = TestIter() for num in obj: print num print objif __name__ == '__main__': test_iter()

partial使用上很像C++中仿函数。

在stackoverflow给出了就像是与partial的周转格局。

def partial(func, *part_args): def wrapper(*extra_args): args = list(part_args) args.extend(extra_args) return func return wrapper

利用用闭包的性状绑定预先绑定一些函数参数,再次来到多个可调用的变量, 直到实在的调用执行。

#!/usr/bin/env python# -*- coding: utf-8 -*-from functools import partialdef sum: return a + bdef test_partial(): fun = partial # 事先绑定一个参数, fun成为一个只需要一个参数的可调用变量 print fun # 实现执行的即是sumif __name__ == '__main__': test_partial() # 执行结果5

eval小编精通为一种内嵌的python解释器(这种解释只怕会有过错), 会解释字符串为对应的代码并实施, 并且将奉行结果回到。

看一下底下那么些事例:

#!/usr/bin/env python# -*- coding: utf-8 -*-def test_first(): return 3def test_second: return numaction = { # 可以看做是一个sandbox "para": 5, "test_first" : test_first, "test_second": test_second }def test_eavl(): condition = "para == 5 and test_second(test_first) > 5" res = eval(condition, action) # 解释condition并根据action对应的动作执行 print resif __name__ == '_
  • exec在Python中会忽略再次回到值, 总是回到None,eval会重回实践代码或言辞的再次来到值。
  • execeval在实践代码时,除了再次来到值别的表现都一模二样。在传出字符串时,会使用compile(source, '<string>', mode)编写翻译字节码。 mode的取值为execeval
#!/usr/bin/env python# -*- coding: utf-8 -*-def test_first(): print "hello"def test_second(): test_first() print "second"def test_third(): print "third"action = { "test_second": test_second, "test_third": test_third }def test_exec(): exec "test_second" in actionif __name__ == '__main__': test_exec() # 无法看到执行结果

透过string类型的name,再次回到对象的name属性对应的值,假如属性荒诞不经,则赶回暗许值,约等于object.name

# 使用范例class TestGetAttr: test = "test attribute" def say: print "test method"def test_getattr(): my_test = TestGetAttr() try: print getattr(my_test, "test") except AttributeError: print "Attribute Error!" try: getattr(my_test, "say")() except AttributeError: # 没有该属性, 且没有指定返回值的情况下 print "Method Error!"if __name__ == '__main__': test_getattr() # 输出结果test attributetest method

def process_command_line: """ Return a 2-tuple: (settings object, args list). `argv` is a list of arguments, or `None` for ``sys.argv[1:]``. """ if argv is None: argv = sys.argv[1:] # initialize the parser object: parser = optparse.OptionParser( formatter=optparse.TitledHelpFormatter, 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 # check number of arguments, verify values, etc.: if args: parser.error('program takes no command-line arguments; ' '"%s" ignored.' %  # further process settings & args if necessary return settings, argsdef main(argv=None): settings, args = process_command_line # application code here, like: # run(settings, args) return 0 # successif __name__ == '__main__': status = main() sys.exit

# 从csv中读取文件, 基本和传统文件读取类似import csvwith open('data.csv', 'rb') as f: reader = csv.reader for row in reader: print row# 向csv文件写入import csvwith open( 'data.csv', 'wb') as f: writer = csv.writer writer.writerow(['name', 'address', 'age']) # 单行写入 data = [ ( 'xiaoming ','china','10'), ( 'Lily', 'USA', '12')] writer.writerows # 多行写入

只发一张互连网的图, 然后差文档就好了, 那些是记不住的。

图片 3

二个万分好用,很几个人又不亮堂的效应。

>>> name = "andrew">>> "my name is {name}".format(name=name)'my name is andrew'
  • What is the difference between @staticmethod and @classmethod in Python?
  • Python @property versus getters and setters
  • How does the @property decorator work?
  • How does the functools partial work in Python?
  • What’s the difference between eval, exec, and compile in Python?
  • Be careful with exec and eval in Python
  • Python (and Python C API): new versus init
  • Python ‘self’ keyword self不是任重(Ren Zhong)而道远字,是八个预订的变量名。
  • Python进级必读汇总
  • 使python类能够肯定真值
  • Best Python Resources
  • Python安全编码指南

本文由金沙贵宾会官网发布于网络软件,转载请注明出处:一波神奇的Python语句,Python奇技淫巧

关键词:

MSYS2开发环境搭建,编译Windows版智能坊钱包

后天都以容器技艺,用 vagrant 恐怕 docker 布贰个 linux 的镜像,安装些linux 的工具链,比方 g++ php ngingx等等,分享给别...

详细>>

AlphaGo再次胜出,日经中文网

阿尔法狗的求学本领很强,第二盘的作战中黑狗略有失误,但黑狗是有强有力的深浅神经网络练习的,每趟对局也是...

详细>>

一个很有借鉴价值的编程故事,一个理智的生命

摘要: 七日七日,每日学一些在线课程,哪怕二回独有半个小时,只要坚韧不拔,你就会感到到温馨前日做出的决定...

详细>>

那个改变世界的人,比特学徒

乔布斯 他已经走了七年了! 你是想卖一辈子糖水呢,还是想抓住机会来改变世界? 1993年,是约翰·斯卡利(JohnScu...

详细>>