foo

目录 目录 代码布局 缩进 最大行宽 空行 模块导入 字符串 表达式和语句中的空格 注释 命名规则 编程建议 代码布局 缩进 每级缩进用4个空格。 括号中使用垂直隐式缩进或使用悬挂缩进。 EXAMPLE : # (垂直隐式缩进)对准左括号 foo = long_function_name(var_one, var_two, var_three, var_four) # (悬挂缩进) 一般情况只需多一层缩进 foo = long_function_name( var_one, var_two, var_three, var_four) # (悬挂缩进) 但下面情况, 需再加多一层缩进， 和后续的语句块区分开来 def long_function_name( var_one, var_two, var_three, var_four): print(var_one) # 右括号回退 my_list = [ 1, 2, 3, 4, 5, 6, ] result = some_function_that_takes_arguments( 'a', 'b', 'c', 'd', 'e', 'f', ) 错误示范 : # 不使用垂直对齐时，第一行不能有参数。 foo = long_function_name(var_one, var_two, var_three, var_four) #

目录 一、issubclass()和isinstance() 1.1 issubclass() 1.2 isinstance() 一、issubclass()和isinstance() 1.1 issubclass() 判断第一个类是不是第二类的子类，返回true或者flase # 判断第一个类是不是第二类的子类，返回true或者flase class Foo: pass class A: pass class Bar(Foo,A): pass class Tt(Bar): pass print(A.__bases__)#(<class 'object'>,) print(Bar.__bases__) # (<class '__main__.Foo'>,)，查看所有的父类，当继承一个类后，将不会显示object,以元组的形式表示：(<class '__main__.Foo'>,) print(Bar.__base__)#<class '__main__.Foo'> 查看第一个父类 print(issubclass(Tt, object)) # True，object是所有类的祖宗 print(issubclass(Bar, Foo)) # True print(issubclass(Tt, Foo)) # True print(issubclass(Tt, A)) # False

ES6允许按照一定的模式。从数组和对象中提取值，对变量进行赋值，这被称为解构。 一、数组解构赋值 <script> //以前的赋值 let a=1; let b=2; console.log(a);//1 console.log(b);//2 //ES6赋值，从数组中提取值，按照对应位置，对变量赋值 let [c,d]=[3,5]; console.log(c);//3 console.log(d);//5 </script> 本质上，这种写法属于“模式匹配”，只要等号两边的模式相同，左边的变量就会被赋予对应的值，我们可以看看更多的例子 let [foo,[[bar],baz]]=[1,[[2],3]]; console.log(foo);//1 console.log(bar);//2 console.log(baz);//3 let [first,,third]=["aaa","bb","cc"]; console.log(first);//aaa console.log(third);//cc //将数组剩余部分赋值给一个变量。 let [head, ...tail] = [1, 2, 3, 4,5,6,7]; console.log(head);//1 console.log(tail);//[2, 3, 4, 5, 6, 7] let [x, y, ...z] = [1,

目录 第十一章、菱形继承问题 一、菱形继承问题 第十一章、菱形继承问题 一、菱形继承问题 引用：属性查找顺序中 对象自身——》子类——》父类（多继承）——》报错 中间父类多继承的查找顺序问题 而对经典类和新式类来说，属性的查找顺序是不同的。现在我们分别看一下经典类和新式类两种不同的表现： 经典类 #! /usr/bin/python # -*- coding:utf-8 -*- class P1(): def foo(self): print 'p1-foo' class P2(): def foo(self): print 'p2-foo' def bar(self): print 'p2-bar' class C1(P1,P2): pass class C2(P1,P2): def bar(self): print 'C2-bar' class D(C1,C2): pass if __name__ =='__main__': d=D() d.foo() d.bar() ​ 执行的结果： ​ p1-foo p2-bar 把代码实例画了图 从上面经典类的输出结果来看， 实例d调用foo()时，搜索顺序是 D => C1 => P1， 实例d调用bar()时，搜索顺序是 D => C1 => P1 => P2 总结：经典类的搜索方式是按照“从左至右，深度优先”的方式去查找属性

属性选择符，根据部分属性值选择 使用属性选择符匹配子串 [foo|="bar"] 选择的元素有foo属性，且其值以bar和一个英文破折号（U+002D）开头，或者本身就是bar本身 [foo|="bar"]选择的元素有foo属性，且其值是包含bar这个词的一组词 [foo|="bar"]选择的元素有foo属性，且其值包含子串bar [foo|="bar"]选择的元素有foo属性，且其值以bar开头 [foo|="bar"]选择的元素有foo属性，且其值以bar结尾 eg：[ lang | = "en" ] { 　　　　color:white; 　　　} 这个规则选择lang属性值为en或以en-开头的元素 <h1 lang="en">属性选择符匹配子串</h1><p lang="en-us">选择en或者以en-开头的元素</p><div lang="en-au">头三个适用上述规则</div><p lang="fr">这个不会被选中</p><h2 lang="cy-en">这个也不会被选中</h2> 一般来说，[ att | = "val" ]形式可用于选择任何属性及其值。假设一个html文档中有一系列插图，而插图的文件名是figure-1.gif和figure-2.jpg这样的。 使用下述选择符可以匹配所有插图： img[src|="figure"] { 　　border:

引言 开发过程中，有很多时候获取到的是类似数组的对象。比如元素的集合（elementcollection,nodeList，以及今天开发时发现classList也是类数组）。有时我们需要类数组去调用数组的方法，怎么办？ 办法一 遍历类数组，将类数组里面的元素依次放入一个新的数组 类数组本身虽然不是数组，但是有interator接口，所以可遍历。（interator指可遍历、可迭代） let foo = { 0 : 1, 1 : 2, 2 : 3, length : 3 } let arr = []; for(let item of foo){ arr.push(item) } 办法二 使用 es6 中 Array.from()方法转换 let foo = { 0 : 1, 1 : 2, 2 : 3, length : 3 } let arr = Array.from(foo) 办法三 使用 apply 和 call apply方法的第二个参数是数组，也可以是类数组，在调用的时候会将第二个参数依次展开。 let foo = { 0 : 1, 1 : 2, 2 : 3, length : 3 } // apply let arr = [].concat.apply([],foo) // call let arr = Array.prototype.slice.call(foo)

class SingletonType(type): def __init__(self,*args,**kwargs): super(SingletonType,self).__init__(*args,**kwargs) def __call__(cls, *args, **kwargs): # 这里的cls，即Foo类 print('cls',cls) obj = cls.__new__(cls,*args, **kwargs) cls.__init__(obj,*args, **kwargs) # Foo.__init__(obj) return obj class Foo(metaclass=SingletonType): # 指定创建Foo的type为SingletonType def __init__(self，name): self.name = name def __new__(cls, *args, **kwargs): return object.__new__(cls) obj = Foo('xx') 来源： https://www.cnblogs.com/zhaogang0104/p/11938683.html

面向对象中除了__init__之外还有很多特殊方法 1.__init__ :数据初始化，当类名()进行调用的时候会自动执行 class ms(object): def __init__(self,a1,a2): self.a1=a1 self.a2 = a2 obj = ms(12,34) 2.__call__：对象() 自动执行 __call__,有返回值 class ms(object): def __call__(self, *args, **kwargs): print(666,args,kwargs) return 123 ret = obj(2,3,4,k=234) <<<< 666 (2, 3, 4) {'k': 234} 3.__getitem__ / __setitme__ / __delitme__ 主要用于索引操作 class ms(object): def __getitem__(self, item): # 获取 print(item) return 8 def __setitem__(self, key, value): #设置 print(key,value,1234) def __delitem__(self, key): # 删除 print(key) obj = ms(1,2) ret = obj["666"] #对象["..."] 自动执行

1.普通嵌套 class province(object): # 省份 def __init__(self,address): self.address = address class park(object): # 公园 def __init__(self,name,start,end,address=None): self.name=name self.start=start self.end=end self.address = address class people(object): # 人数 def __init__(self,number,didian=None): self.number = number self.didian = didian p1 = province("香港") p2 = province("北京") p3 = province("深圳") pname = park("迪士尼","7:00","19:00",p1) pname2 = park("天安门","5:00","19:00",p2) pname3 = park("世界之窗","9:00","18:00",p3) num1 = people(1200,pname) num2 = people(1500,pname2) num3 = people(800,pname3) print

今天给大家分享一些面试题，以及我个人的见解，话不多说，上题！ var person={fname:"John",lname:"Doe",age:25}; var txt=""; for (x in person){ txt= txt + x+ person[x]; } alert(txt); 输出为？ person是一个对象，对象的遍历是遍历它的下标，所以x指的便是对象中的 fname，lname，age。 而对象有又是以关联数组的形式来访问里面的值，就是person[x]，而不是person.x 所以txt是下标和值的相加 最后输出的是: fnameJohnlnameDoeage25 var a =100; function f(){ var a = 200; function g(){ return a; } return g; } console.log(f()()); 题目要求输出f()(),注意是两次执行 第一次执行： var a = 200; function g(){ return a; } return g; 返回函数g，第二次执行： 调用函数g，return a，这是返回的a是f函数中的a，因为它沿着 作用域链找a的话，f函数里面刚好有，不会去window里面找的，所以输出结果为 200 Object.prototype.bar = 1; var foo =