foo

在python中，除了一些方法，属性之外，还有一些特殊成员 1 class Foo(object): 2 3 def __new__(cls, *args, **kwargs): 4 """ 5 创建一个空对象 6 :param args: 7 :param kwargs: 8 :return: 9 """ 10 print(2) 11 return object.__new__(cls) 12 13 def __init__(self, a1, a2): 14 # 为一个空对象进行数据的初始化 15 self.a1 = a1 16 self.a2 = a2 17 18 def __call__(self, *args, **kwargs): 19 print(1111) 20 21 def __getitem__(self, item): 22 print(item) 23 return 8 24 25 def __setitem__(self, key, value): 26 print(key, value, 1111111) 27 28 def __delitem__(self, key): 29 print(key) 30 31 def __add__(self, other): 32 return self.a1 + other.a1 33 34 def __enter

现在有一个新的需求，希望可以记录下函数的执行时间，于是在代码中添加日志代码： import time def foo(): start_time = time.time() print ( 'hello foo' ) time.sleep( 3 ) end_time = time.time() print ( 'spend %s' % (end_time - start_time)) foo() bar()、bar2()也有类似的需求计时，怎么做？再在bar函数里调用时间函数？这样就造成大量雷同的代码，为了减少重复写代码，我们可以这样做，重新定义一个函数：专门设定时间show_time： import time def show_time(func): start_time = time.time() func() end_time = time.time() print ( 'spend %s' % (end_time - start_time)) def foo(): print ( 'hello foo' ) time.sleep( 3 ) show_time(foo) 转载请标明出处: 实现多函数计时功能 文章来源: 实现多函数计时功能

上个星期，我写了篇《 Function call by name in Golang 》。由于是英文的，所以被人诟病（说谁，谁知道！）。好吧，现在用中文重新写一遍。 Golang 中的函数跟 C 的一样，是个代码块，不过它可以像其他类型那样赋值给一个变量。 如果你对函数不熟悉，《 Codewalk: First-Class Functions in Go 》应该是个不错的起点。已经有所了解？那么继续吧！ 首先，来看看这段 PHP 代码： functionfoobar() { echo"Hello Golang\n"; } $funcs=array( "foobar"=>"foobar", "hello" =>"foobar", ); $funcs["foobar"](); $funcs["hello"](); 它会输出： mikespook@mikespook-laptop:~/Desktop$ php foobar.php Hello Golang Hello Golang 用这个方法调用匹配名字的函数，非常有效。 那么，在 Golang 中是否可能用函数的名字来调用某个函数呢？ 作为一个静态、编译型语言，答案是否定的……又是 肯定的 ！ 在 Golang 中，你 不能 这样做： func foobar() { // bla...bla...bla... } funcname :

特殊成员的补充： # __str__ class Foo(object): def __init__(self): pass def func(self): pass def __str__(self): return "F1" #返回的结果必须是字符串，别的都不行 obj = Foo() print(obj,type(obj)) #### __doc__ class Foo(object): """ asdfasdfasdfasdf """ def __init__(self): pass def func(self): pass obj = Foo() print(obj.__doc__) #打印注释里面的内容 ## __dict__ class Foo(object): def __init__(self,name,age): self.name = name self.age = age def func(self): pass obj1 = Foo('刘博文',99) obj2 = Foo('史雷',89) print(obj1.__dict__) # {'name': '刘博文', 'age': 99} print(obj2.__dict__) # {'name': '史雷', 'age': 89} ### __iter__ # l1是list类的一个对象，可迭代对象

文章出处 https://www.cnblogs.com/wupeiqi/articles/5040827.html Python线程 Threading用于提供线程相关的操作，线程是应用程序中工作的最小单元。 ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 #!/usr/bin/env python # -*- coding:utf-8 -*- import threading import time def show(arg): time.sleep( 1 ) print 'thread' + str (arg) for i in range ( 10 ): t = threading.Thread(target = show, args = (i,)) t.start() print 'main thread stop' 上述代码创建了10个“前台”线程，然后控制器就交给了CPU，CPU根据指定算法进行调度，分片执行指令。 更多方法： start 线程准备就绪，等待CPU调度 setName 为线程设置名称 getName 获取线程名称 setDaemon 设置为后台线程或前台线程（默认） 如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止 如果是前台线程，主线程执行过程中，前台线程也在进行

Python的星号（*、**）的作用 1. 函数的可变参数 当函数的参数前面有一个星号*的时候表示这是一个可变的位置参数，两个星号**表示是可变的关键字参数。 #!env python #coding=utf-8 # def foo (*args, **kwarg) : for item in args: print item for k,v in kwarg.items(): print k,v print 30 * '=' if __name__ == '__main__' : foo( 1 , 2 , 3 , a= 4 , b= 5 ) foo( 2 , 3 , a= 4 , b= 5 , c= 1 ) 输出如下： lxg@web-Dev ~/station $ python test_param.py 1 2 3 a 4 b 5 = ============================= 2 3 a 4 c 1 b 5 = ============================= 这样我们可以传入任意个数的参数。 2. unpack参数 星号*把序列/集合解包（unpack）成位置参数，两个星号**把字典解包成关键字参数。下面通过示例来进一步加深理解： #!env python #coding=utf-8 def foo (*args, **kwarg) : for

了解闭包之前我们需要懂的东西：需要知道JS的作用域链以及预解析。 进入话题，作用域链上面的东西是存在哪里的呢。 是一个栈结构，最底层是window对象。 栈就是类似一个桶装结构，如图1： 图一 ： 栈结构具有的特点就是先入后出。 好比你放进桶里的东西，你需要从最上面开始拿出来。 JS代码的解析过程中：例如JS代码里有一个函数foo. <script> 　　　　　　　　　　　　　　　　　　　var a = 1; function foo() { } 　　　　　　　　　　　　　　　　　　 foo(); </script> 预解析：那么预解析到这个函数时，发生了如下的事情： 由于函数是引用类型的对象，实际数据存在堆里，那么在栈里只存放了地址。0x1101这个地址指向堆的实际数据。 运行到这个函数时，它会创建一个foo的作用域链对象。然后存入一个栈里，这个栈底层永远是window. 函数执行=>foo() 又会发生的事情：栈里面的foo创建了一个活动对象。即执行了这个函数。 当函数执行完毕：foo的作用域链出栈，没有被指向的活动对象即销毁。但是window不会被销毁。 （PS:橡皮擦太小了，没擦干净） 闭包是什么呢？ 官方解答是有权去访问函数内的变量。 我们现在来写一个函数： function foo(){ var n = 0;　　 //返回了一个函数。 这个函数的n 是从foo里面找的n

class Enity: # '''调用实体来改变实体的位置。''' def __init__(self,size,x,y): self.x,self.y=x,y self.size=size def __call__(self,x,y): self.x,self.y=x,y e=Enity(1,2,3) e(4,5) # 实例可以象函数那样执行，并传入x y值，修改对象的x y # 下面提供一个my_length_check()函数，用于验证name长达是否长于50个字符。 def length_check(form,field): if len(field.data)>50: raise ValidationError("less than 50") class Myform(Form): name=StringField['name',[InputRequired(),length_check]] def length(min=-1,max=-1,message=None): if not message: message='must be %d and %d'%(min,max) def _length(form,field): l = field.data and len(field.data) or 0 if l < min or max!=-1 and l>max:

面向对象高级语法部分 经典类vs新式类 把下面代码用python2 和python3都执行一下 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 #_*_coding:utf-8_*_ class A: def __init__( self ): self .n = 'A' class B(A): # def __init__(self): # self.n = 'B' pass class C(A): def __init__( self ): self .n = 'C' class D(B,C): # def __init__(self): # self.n = 'D' pass obj = D() print (obj.n) classical vs new style： 经典类：深度优先 新式类：广度优先 super()用法 抽象接口 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 import abc class Alert( object ): '''报警基类''' __metaclass__ = abc.ABCMeta @abc .abstractmethod def send( self ): '''报警消息发送接口''' pass class

没有优先队列的dijkstra不算真的dijkstra 所以我又回来补常识了 <1>priority_queue::emplace <7>priority_queue::top 1 // priority_queue::emplace 2 #include <iostream> // std::cout 3 #include <queue> // std::priority_queue 4 #include <string> // std::string 5 6 int main () 7 { 8 std::priority_queue<std::string> mypq; 9 10 mypq.emplace("orange"); 11 mypq.emplace("strawberry"); 12 mypq.emplace("apple"); 13 mypq.emplace("pear"); 14 15 std::cout << "mypq contains:"; 16 while (!mypq.empty()) 17 { 18 std::cout << ' ' << mypq.top(); 19 mypq.pop(); 20 } 21 std::cout << '\n'; 22 23 return 0; 24 } 25 //Ooutput:mypq contains: