foo

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

基本命令 要启动 nginx，只需输入： [sudo] nginx 当你的 nginx 实例运行时，你可以通过发送相应的信号来管理它： [sudo] nginx -s signal 可用的信号： stop – 快速关闭 quit – 优雅关闭 (等待 worker 线程完成处理) reload – 重载配置文件 reopen – 重新打开日志文件 指令和上下文 nginx 的配置文件，默认的位置包括： /etc/nginx/nginx.conf, /usr/local/etc/nginx/nginx.conf，或 /usr/local/nginx/conf/nginx.conf 配置文件的由下面的部分构成: 指令 – 可选项，包含名称和参数，以分号结尾 gzip on; 上下文 – 分块，你可以声明指令 – 类似于编程语言中的作用域 worker_processes 2; # 全局上下文指令 http { # http 上下文 gzip on; # http 上下文中的指令 server { # server 上下文 listen 80; # server 上下文中的指令 } } 指令类型 在多个上下文中使用相同的指令时，必须要小心，因为继承模型不同时有着不同的指令。有三种类型的指令，每种都有自己的继承模型。 普通指令 在每个上下文仅有唯一值。而且，它只能在当前上下文中定义一次

python线程： 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') import threading class MyThread(threading.Thread): def __init__(self): threading.Thread.__init__(self) def run(self): print("线程开始运行") t1 = MyThread() t1.start() 通过类创建线程 更多方法： start 线程准备就绪，等待CPU调度 setName 为线程设置名称 getName 获取线程名称 setDaemon 设置为后台线程或前台线程（默认） t.setDaemon(True) 必须在 t.start() 之前调用 如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止 如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止 join

面向对象 ''' #类 class bar: def foo(self,arg): print(self.name,self.age,self.gender,arg) z = bar() #封装公有部分到内存里 z.name = 'hao' z.age = 11 z.gender = '男' z.foo(666) z1 = bar() z.name = 'xue' z.age= 18 z.gender = '女' z.foo('hahaha') ''' ''' class bar: def __init__(self,name,age): self.name = name self.age = age def show(self): print('%s:%s' %(self.name,self.age)) z = bar('hao',11) z.show() z1 =bar('haha',33) z1.show() #输出结果： hao:11 haha:33 ''' #继承 class F: def f1(self): print('F.f1') def f2(self): print('F.f2') class s(F): def s1(self): print('s.s1') def f2(self): super(s,self).f2() #执行父类（基类）中的方法

ES6 允许按照一定模式，从数组和对象中提取值，对变量进行赋值，这被称为解构（Destructuring）。 一.对象的解构赋值 1.基本写法 基本写法 let { foo , bar } = { foo : 'aaa' , bar : 'bbb' } ; foo // "aaa" bar // "bbb" 2.特点 ① 对象属性赋值是按照属性名匹配的，和属性顺序无关。 let { bar , foo } = { foo : 'aaa' , bar : 'bbb' } ; foo // "aaa" bar // "bbb" ② 对象解构无相应属性，赋值为 undefined let { foo } = { bar : 'baz' } ; foo // undefined ③ 对象的解构赋值可以取到继承的属性 const obj1 = { } ; const obj2 = { foo : 'bar' } ; Object . setPrototypeOf ( obj1 , obj2 ) ; const { foo } = obj1 ; foo // "bar" ④ 与数组一样，解构也可以用于嵌套结构的对象。 //一.嵌套结构 let obj = { p : [ 'Hello' , { y : 'World' } ] } ; let { p : [ x , { y } ] } =

网上文章虽多，大多复制粘贴，且晦涩难懂，我希望能够通过这篇文章，能够清晰的提升对apply、call、bind的认识，并且列出一些它们的妙用加深记忆。 　apply、call 　　在 javascript 中，call 和 apply 都是为了改变某个函数运行时的上下文（context）而存在的，换句话说，就是为了改变函数体内部 this 的指向。 　　JavaScript 的一大特点是，函数存在「定义时上下文」和「运行时上下文」以及「上下文是可以改变的」这样的概念。 　　先来一个栗子： 1 2 3 4 5 6 7 8 9 10 11 function fruits() {} fruits.prototype = { color: "red" , say: function () { console.log( "My color is " + this .color); } } var apple = new fruits; apple.say(); //My color is red 　　但是如果我们有一个对象banana= {color : "yellow"} ,我们不想对它重新定义 say 方法，那么我们可以通过 call 或 apply 用 apple 的 say 方法： 1 2 3 4 5 banana = { color: "yellow" } apple.say

例子 下面的例子中，Trait中拥有foo方法，Foo类型中也有foo方法，并且为Foo实现特征Trait时，在其中调用自己的foo方法，代码如下： trait Trait { fn foo(&mut self, x: i32); } struct Foo; impl Foo { fn foo(&self) { println!("Foo::foo"); } } impl Trait for Foo { fn foo(&mut self, x: i32) { //self.foo(); 　　　//１、出错点１ (&*self).foo();　　//按照此方式或者Self::foo(self)调用ok println!("Trait::foo {}", x); } } fn main() { let mut a: Foo = Foo{}; a.foo(); //a.foo(3); //２、出错点２，此方式调用出错 Trait::foo(&mut a, 3); println!("Hello, world!"); } 知识点一 描述 在上述代码中，出错点１的位置，如果直接调用self.foo()会出错，但是调用(&*self).foo()或者Self::foo(self)则编译通过。 原因解释 Rust在进行方法解析的时候试用的规则比较简单，编译器查看方法“ receiver”

apply、call 在 javascript 中，call 和 apply 都是为了改变某个函数运行时的上下文（context）而存在的，换句话说，就是为了改变函数体内部 this 的指向。 JavaScript 的一大特点是，函数存在「 定义时上下文」和「 运行时上下文」以及「 上下文是可以改变的」这样的概念。 先来一个栗子： 1 2 3 4 5 6 7 8 9 10 11 function fruits() {} fruits.prototype = { color: "red" , say: function () { console.log( "My color is " + this .color); } } var apple = new fruits; apple.say(); //My color is red 但是如果我们有一个对象banana= {color : "yellow"} ,我们不想对它重新定义 say 方法，那么我们可以通过 call 或 apply 用 apple 的 say 方法： 1 2 3 4 5 banana = { color: "yellow" } apple.say.call(banana); //My color is yellow apple.say.apply(banana); //My color is yellow 所以

猜猜下面的代码会输出什么东东？ var foo = 1 ； var foobar = function ( ) { console . log ( foo ) ； var foo = 2 ； } ； foobar ( ) ； 如果你知道局部变量这个概念的话，你可能会觉得这个输出是 foo is not defined 。 如果你还知道JS里有变量提升这个概念的话，你可能觉得这个输出会是 2 。 如果你还知道JS里的变量提升只能提升变量，但不能把值也带过去的话，你会觉得这个输出会是 undefined 。 对啦，就是 undefined 。 来源： CSDN 作者： K.Sun 链接： https://blog.csdn.net/sinat_36246371/article/details/103671379

文章目录 二 继承与抽象 三 属性查找 四 继承的实现原理 五 派生与方法重用 六 组合 #一 继承介绍 继承是一种创建新类的方式，在Python中，新建的类可以继承一个或多个父类，新建的类可称为子类或派生类，父类又可称为基类或超类 class ParentClass1 : #定义父类 pass class ParentClass2 : #定义父类 pass class SubClass1 ( ParentClass1 ) : #单继承 pass class SubClass2 ( ParentClass1 , ParentClass2 ) : #多继承 pass 通过类的内置属性__bases__可以查看类继承的所有父类 >> > SubClass2 . __bases__ ( < class '__main__.ParentClass1' > , < class '__main__.ParentClass2' > ) 在Python2中有经典类与新式类之分，没有显式地继承object类的类，以及该类的子类，都是经典类，显式地继承object的类，以及该类的子类，都是新式类。而在Python3中，即使没有显式地继承object，也会默认继承该类，如下 >> > ParentClass1 . __bases__ ( < class ‘ object ' > , ) >> >