4 print dic
#### **2.112.12print 语句**
1 print 'a', 'b' #print可以接受多个参数，参数的输出之间以空格相隔。 2 print 'a', #如果逗号之后没有参数，则不会换行。 3 print 'b'
### **2.12序列解包**
1 x, y, z = 1, 2, 3 2 print x, y, z 3 (x, y, z) = (1, 2, 3) 4 print x, y, z 5 (x, y, z) = [1, 2, 3] 6 print x, y, z
### **2.13bool值**
1 #下面的输入全部返回False。 2 print(bool(None)) 3 print(bool(())) 4 print(bool([])) 5 print(bool({})) 6 print(bool("")) 7 print(bool(0)) 8 9 #虽然这些值在条件运算中会当做False，但是本身不等于False。 10 print(True and "") 11 print(not "") 12 print(False == "") 13 print(False == 0) #0除外，bool类型的内部表示就是int类型。
### **2.14bool运算**
1 print(0 < 1 < 10) 2 print(0 < 1 and 1 < 10) 3 print(not(0 > 1 > 10)) 4 print(not(0 > 1 or 1 > 10))
### **2.15语句块**
:开始语句快，缩进的所有内容都是一个语句块。
1 if(10 > 1): 2 print("10 > 1") 3 else: 4 print("不可能发生")
### **2.16三元运算符**
1 print("10 > 1" if 10 > 1 else "不可能发生")
### **2.17相等比较**
1 #== 和 is的差别，==比较的是内容，is比较的是引用。 2 x = [1, 2, 3] 3 y = x 4 z = [1, 2, 3] 5 print(x == y) 6 print(x == z) 7 print(x is y) 8 print(x is z)
### **2.18循环**
1 #for循环类似C#的foreach，注意for后面是没有括号的，python真是能简洁就尽量简洁。 2 for x in range(1, 10): 3 print(x) 4 5 for key in {"x":"xxx"}: 6 print(key) 7 8 for key, value in {"x":"xxx"}.items(): 9 print(key, value) 10 11 for x, y, z in [["a", 1, "A"],["b", 2, "B"]]: 12 print(x, y, z)
1 #带索引的遍历 2 for index, value in enumerate(range(0, 10)): 3 print(index, value) 4 5 #好用的zip方法 6 for x, y in zip(range(1, 10), range(1, 10)): 7 print(x, y) 8 9 #循环中的的else子句 10 from math import sqrt 11 for item in range(99, 1, -1): 12 root = sqrt(item) 13 if(root == int(root)): 14 print(item) 15 break 16 else: 17 print("没有执行break语句。")
**pass、exec和eval**
1 #pass、exec、eval 2 if(1 == 1): 3 pass 4 5 exec('print(x)', {"x": "abc"}) 6 print(eval('x*2', {"x": 5}))
## 三.函数部分
形参和实参之间是按值传递的，当然有些类型的值是引用（对象、列表和字典等）。
1 # 基本函数定义。 2 def func(): 3 print("func") 4 5 func() 6 7 # 带返回值的函数。 8 def func_with_return(): 9 return ("func_with_return") 10 11 print(func_with_return()) 12 13 # 带多个返回值的函数。 14 def func_with_muti_return(): 15 return ("func_with_muti_return", "func_with_muti_return") 16 17 print(func_with_muti_return()) 18 19 # 位置参数 20 def func_with_parameters(x, y): 21 print(x, y) 22 23 func_with_parameters(1, 2) 24 25 # 收集多余的位置参数 26 def func_with_collection_rest_parameters(x, y, *rest): 27 print(x, y) 28 print(rest) 29 30 func_with_collection_rest_parameters(1, 2, 3, 4, 5) 31 32 #命名参数 33 def func_with_named_parameters(x, y, z): 34 print(x, y, z) 35 36 func_with_named_parameters(z = 1, y = 2, x = 3) 37 38 #默认值参数 39 def func_with_default_value_parameters(x, y, z = 3): 40 print(x, y, z) 41 42 func_with_default_value_parameters(y = 2, x = 1) 43 44 #收集命名参数 45 def func_with_collection_rest_naned_parameters(args, **named_agrs): 46 print(args) 47 print(named_agrs) 48 49 func_with_collection_rest_naned_parameters(1, 2, 3, x = 4, y = 5, z = 6) 50 51 #集合扁平化 52 func_with_collection_rest_naned_parameters([1, 2, 3], {"x": 4, "y": 4, "z": 6}) #这会导致args[0]指向第一个实参，args[1]指向第二个实参。 53 func_with_collection_rest_naned_parameters([1, 2, 3], **{"x": 4, "y": 4, "z": 6}) #这里的执行相当于func_with_collection_rest_naned_parameters(1, 2, 3, x = 4, y = 5, z = 6)。
## 四.作用域
1 # coding=utf-8 2 3 # 只有函数执行才会开启一个作用域。 4 if(2 > 1): 5 x = 1 6 7 print(x) # 会输出1。 8 9 10 # 使用vars()函数可以访问当前作用域包含的变量。 11 x = 1 12 print(vars()["x"]) 13 14 # 使用globals()函数可以访问全局作用域。 15 x = 1 16 17 def func(): 18 print(globals()["x"]) 19 20 func() 21 22 # 使用locals()函数可以访问局部作用域。 23 def func(): 24 x = 2 25 print(locals()["x"]) 26 27 func() 28 29 # 每个函数定义时都会记住所在的作用域。 30 # 函数执行的时候会开启一个新的作用域，函数内变量访问的规则是：先访问当前作用域，如果没有就访问函数定义时的作用域，递归直到全局作用域。 31 x = 1 32 33 def func(): 34 y = 2 35 print(x, y) # 输出1 2 36 37 func() 38 39 40 # 变量赋值始终访问的是当前作用域。 41 x = 1 42 43 def func(): 44 x = 2 45 y = 2 46 print(x, y) # 输出2 2 47 48 func() 49 print(x) #输出 1 50 51 # 局部变量会覆盖隐藏全局变量，想访问全局变量可以采用global关键字或globals()函数。 52 x = 1 53 54 def func(): 55 global x 56 x = 2 57 y = 2 58 print(x, y) # 输出2 2 59 60 func() 61 print(x) #输出 2
1 # python支持闭包 2 def func(x): 3 def inner_func(y): 4 print(x + y) 5 6 return inner_func 7 8 inner_func = func(10) 9 inner_func(1) 10 inner_func(2)
1 #函数作为对象 2 def func(fn, arg): 3 fn(arg) 4 5 func(print, "hello") 6 func(lambda arg : print(arg), "hello")
## 五.模块
几个模块相关的规则：
* 一个文件代表一个模块。
* 可以用import module导入模块，也可以用form module import member导入模块的成员。
* 如果导入的是module，必须使用module.member进行访问；如果导入的member，可以直接访问member。
* 导入的module或member都会变成当前module的member。
b.py
1 # coding=utf-8 2 3 print name 4 5 def say_b(): 6 print "b"
a.py
1 # coding=utf-8 2 3 import b 4 from b import * 5 6 print name 7 8 def say_a(): 9 print "a"
test.py
1 # coding=utf-8 2 3 import a 4 5 print name 6 7 a.say_a(); 8 a.say_b(); 9 a.b.say_b()
输出
1 b 2 a 3 main 4 a 5 b 6 b
## 六.异常管理
1 # coding=utf-8 2 3 # 自定义异常 4 class HappyException(Exception): 5 pass 6 7 # 引发和捕获异常 8 try: 9 raise HappyException 10 except: 11 print("HappyException") 12 13 try: 14 raise HappyException() 15 except: 16 print("HappyException") 17 18 # 捕获多种异常 19 try: 20 raise HappyException 21 except (HappyException, TypeError): 22 print("HappyException") 23 24 # 重新引发异常 25 try: 26 try: 27 raise HappyException 28 except (HappyException, TypeError): 29 raise 30 except: 31 print("HappyException") 32 33 #访问异常实例 34 try: 35 raise HappyException("都是我的错") 36 except (HappyException, TypeError), e: 37 print(e) 38 39 #按类型捕获 40 try: 41 raise HappyException 42 except HappyException: 43 print("HappyException") 44 except TypeError: 45 print("TypeError") 46 47 #全面捕获 48 try: 49 raise HappyException 50 except: 51 print("HappyException") 52 53 #没有异常的else 54 try: 55 pass 56 except: 57 print("HappyException") 58 else: 59 print("没有异常") 60 61 #总会执行的final 62 try: 63 pass 64 except: 65 print("HappyException") 66 else: 67 print("没有异常") 68 finally: 69 print("总会执行")
## 七.面向对象
### **7.1先上一张图**
### **7.2几个规则：**
1. 一切都是对象，python中一切都是对象，每个对象都包含一个\_\_class\_\_属性以标记其所属类型。
2. 每个对象（记得一切都是对象啊）都包含一个\_\_dict\_\_属性以存储所有属性和方法。
3. 每个类型都包含一个\_\_bases\_\_属性以标记其父类。
4. 属性和方法的访问规则：依次搜索instance、子类、父类、父类的父类、直到object的\_\_dict\_\_，如果找到就返回。
5. 属性和方法的设置规则：直接设置instance.\_\_dict\_\_。
6. 以上属性和方法访问或设置规则没有考虑“魔法方法”，下文会解释。
### **7.3 示例**
1 # coding=utf-8 2 3 metaclass = type 4 5 # 类型定义 6 # 实例方法必的第一个参数代表类型实例，类似其他语言的this。 7 class Animal: 8 name = "未知" # 属性定义。 9 10 def init(self, name): #构造方法定义。 11 self.name = name 12 13 def getName(self): # 实例方法定义。 14 return self.name 15 16 def setName(self, value): 17 self.name = value 18 19 print(Animal.name) # 未知 20 print(Animal.dict["name"]) # 未知 21 22 animal = Animal("狗狗") 23 print(animal.name) # 狗狗 24 print(animal.dict["name"]) # 狗狗 25 print(Animal.name) # 未知 26 print(Animal.dict["name"]) # 未知 27 print(animal.class.name) # 未知 28 print(animal.class.dict["name"]) # 未知
1 # 类型定义中的代码会执行，是一个独立的作用域。 2 class TestClass: 3 print("类型定义中") #类型定义中
### **7.4绑定方法和未绑定方法**
1 class TestClass: 2 def method(self): 3 print("测试方法") 4 5 test = TestClass() 6 print(TestClass.method) # 7 print(test.method) #<bound method TestClass.method of <main.TestClass object at 0x021B46D0>> 8 9 TestClass.method(test) #测试方法 10 test.method() #测试方法
绑定方法已经绑定了对象示例，调用的时刻不用也不能传入self参数了。
注：使用对象访问实例方法为何会返回绑定方法？这个还得等到学完“魔法方法”才能解释，内部其实是拦截对方法成员的访问，返回了一个Callable对象。
### **7.5私有成员**
1 # 私有成员 2 class TestClass: 3 __private_property = 1 4 5 def __private_method(): 6 pass 7 8 print(TestClass.dict) # {'module': 'main', '_TestClass__private_method': <function __private_method at 0x0212B970>, '_TestClass__private_property': 1
难怪访问不了了，名称已经被修改了，增加了访问的难度而已。
### **7.6多重继承**
1 #多重继承 2 class Base1: 3 pass 4 5 class Base2: 6 pass 7 8 class Child(Base2, Base1): 9 pass 10 11 child = Child() 12 print(isinstance(child, Child)) # True 13 print(isinstance(child, Base2)) # True 14 print(isinstance(child, Base1)) # True
如果继承的多个类型之间有重名的成员，左侧的基类优先级要高，上例子Base2会胜出。
### **7.7接口那里去了，鸭子类型比接口更好用。**
1 class TestClass1: 2 def say(self): 3 print("我是鸭子1") 4 5 class TestClass2: 6 def say(self): 7 print("我是鸭子2") 8 9 def duck_say(duck): 10 duck.say() 11 12 duck_say(TestClass1()) # 我是鸭子1 13 duck_say(TestClass2()) # 我是鸭子2
### **7.8调用父类**
1 # 调用父类 2 class Base: 3 def say(self): 4 print("Base") 5 6 class Child(Base): 7 def say(self): 8 Base.say(self) 9 super(Child, self).say() 10 print("Child") 11 12 child = Child() 13 child.say()
## 八.魔法方法
对象构造相关：\_\_new\_\_、\_\_init\_\_、\_\_del\_\_。
1 from os.path import join 2 3 class FileObject: 4 '''Wrapper for file objects to make sure the file gets closed on deletion.''' 5 6 def init(self, filepath='~', filename='sample.txt'): 7 # open a file filename in filepath in read and write mode 8 self.file = open(join(filepath, filename), 'r+') 9 10 def del(self): 11 self.file.close() 12 del self.file
运算符重载：所有运算符都能重载。
1 class Word(str): 2 '''Class for words, defining comparison based on word length.''' 3 4 def new(cls, word): 5 # Note that we have to use new. This is because str is an immutable 6 # type, so we have to initialize it early (at creation) 7 if ' ' in word: 8 print "Value contains spaces. Truncating to first space." 9 word = word[:word.index(' ')] # Word is now all chars before first space 10 return str.new(cls, word) 11 12 def gt(self, other): 13 return len(self) > len(other) 14 15 def lt(self, other): 16 return len(self) < len(other) 17 18 def ge(self, other): 19 return len(self) >= len(other) 20 21 def le(self, other): 22 return len(self) <= len(other) 23 24 print(Word("duan") > Word("wei"))
属性访问。
1 class AccessCounter: 2 '''A class that contains a value and implements an access counter. 3 The counter increments each time the value is changed.''' 4 5 def init(self, value): 6 super(AccessCounter, self).setattr('counter', 0) 7 super(AccessCounter, self).setattr('value', value) 8 9 def setattr(self, name, value): 10 if name == 'value': 11 super(AccessCounter, self).setattr('counter', self.counter + 1) 12 # Make this unconditional. 13 # If you want to prevent other attributes to be set, raise AttributeError(name) 14 super(AccessCounter, self).setattr(name, value) 15 16 def delattr(self, name): 17 if name == 'value': 18 super(AccessCounter, self).setattr('counter', self.counter + 1) 19 super(AccessCounter, self).delattr(name)
集合实现。
1 class FunctionalList: 2 '''A class wrapping a list with some extra functional magic, like head, 3 tail, init, last, drop, and take.''' 4 5 def init(self, values=None): 6 if values is None: 7 self.values = [] 8 else: 9 self.values = values 10 11 def len(self): 12 return len(self.values) 13 14 def getitem(self, key): 15 # if key is of invalid type or value, the list values will raise the error 16 return self.values[key] 17 18 def setitem(self, key, value): 19 self.values[key] = value 20 21 def delitem(self, key): 22 del self.values[key] 23 24 def iter(self): 25 return iter(self.values) 26 27 def reversed(self): 28 return FunctionalList(reversed(self.values)) 29 30 def append(self, value): 31 self.values.append(value) 32 def head(self): 33 # get the first element 34 return self.values[0] 35 def tail(self): 36 # get all elements after the first 37 return self.values[1:] 38 def init(self): 39 # get elements up to the last 40 return self.values[:-1] 41 def last(self): 42 # get last element 43 return self.values[-1] 44 def drop(self, n): 45 # get all elements except first n 46 return self.values[n:] 47 def take(self, n): 48 # get first n elements 49 return self.values[:n]
可调用对象，像方法一样调用对象。
1 class Entity: 2 '''Class to represent an entity. Callable to update the entity's position.''' 3 4 def init(self, size, x, y): 5 self.x, self.y = x, y 6 self.size = size 7 8 def call(self, x, y): 9 '''Change the position of the entity.''' 10 self.x, self.y = x, y 11 print(x, y) 12 13 entity = Entity(5, 1, 1) 14 entity(2, 2)
资源管理
1 class Closer: 2 def enter(self): 3 return self 4 5 def exit(self, exception_type, exception_val, trace): 6 print("清理完成") 7 return True; 8 9 with Closer() as closer: 10 pass
对象描述符。
1 class Meter(object): 2 '''Descriptor for a meter.''' 3 4 def init(self, value=0.0): 5 self.value = float(value) 6 def get(self, instance, owner): 7 return self.value 8 def set(self, instance, value): 9 self.value = float(value) 10 11 class Foot(object): 12 '''Descriptor for a foot.''' 13 14 def get(self, instance, owner): 15 return instance.meter * 3.2808 16 def set(self, instance, value): 17 instance.meter = float(value) / 3.2808 18 19 class Distance(object): 20 '''Class to represent distance holding two descriptors for feet and 21 meters.''' 22 meter = Meter() 23 foot = Foot()
## 九.Mixin（也叫掺入）
### **9.1掺入模块：playable.py**
1 # coding=utf-8 2 3 def paly(self): 4 print("游戏中...")
### **9.2掺入目标模块：test.py**
1 # coding=utf-8 2 3 class Animal: 4 from playable import paly 5 6 animal = Animal() 7 animal.paly() # 游戏中...
## 十.Open Class（打开类型，从新定义成员）
1 #coding:utf-8 2 3 class TestClass: 4 def method1(self): 5 print("方法1") 6 7 def method2(self): 8 print("方法2") 9 10 TestClass.method2 = method2 11 12 test = TestClass() 13 test.method1() # 方法1 14 test.method2() # 方法2
## 十一.Meta Programming（元编程）
1 TestClass = type("TestClass", (object,), { 2 "say": lambda self : print("你好啊") 3 }) 4 5 test = TestClass() 6 test.say()
1 def getter(name):
2 def getterMethod(self):
3 return self.getattribute(name)
4 return getterMethod
5
6 def setter(name):
7 def setterMethod(self, value):
8 self.setattr(name, value)
9 return setterMethod
10
11 class TestClass:
12 getName = getter("name")
13 setName = setter("name")
14
15 test = TestClass()
16 test.setName("段光伟")
17 print(test.getName())
## 十二.AOP（面向切面编程）
内容比较多：
## 十三.背景
学习了Javascript才知道原来属性的取值和赋值操作访问的“位置”可能不同、还有词法作用域这个东西，这也是我学习任何一门语言会注意的两个知识点，Python的作用域和Javascript几乎一致，这里就不做解释，本文重点介绍一下三个概念：
1. 属性取值和赋值过程
2. 属性描述符
3. 装饰器
本文最好会利用这些知识介绍：如何实现自定义的@staticmethod和@classmethod。
## 十四.属性取值和赋值过程
* 一切皆是对象，类型也是对象。
* 对象包含一个\_\_class\_\_属性指向其所属类型。
* 对象包含一个\_\_dict\_\_属性指向其所包含的成员（属性和方法）。
### 14.1取值过程（下面是伪代码）
1 getattribute(property) logic: 2 3 descripter = find first descripter in class and bases's dict(property) 4 if descripter: 5 return descripter.get(instance, instance.class) 6 else: 7 if value in instance.dict 8 return value 9 10 value = find first value in class and bases's dict(property) 11 if value is a function: 12 return bounded function(value) 13 else: 14 return value 15 16 raise AttributeNotFundedException
### 14.2赋值过程（下面是伪代码）
1 setattr(property, value)logic: 2 3 descripter = find first descripter in class and bases's dict(property) 4 if descripter: 5 descripter.set(instance, value) 6 else: 7 instance.dict[property] = value
### 14.3根据取值和赋值过程的逻辑可以得出以下结论
1. 赋值和取值的位置可能不同。
2. 取值过程的伪代码第11行会返回绑定方法（我们在Javascript经常会让某个函数绑定到指定的作用域，和这个概念是一样的）。
3. 取值和赋值过程都会先查找属性描述符，也就是说：属性描述的优先级最高，下文会介绍属性描述符。
## 十五.属性描述符
什么是属性描述符？属性描述符就是一个类型，实现了三个魔法方法而已：\_\_set\_\_、\_\_get\_\_和\_\_del\_\_，属性描述符一般不会独立使用，必须存储在类型的\_\_dict\_\_中才有意义，这样才会参与到属性的取值和赋值过程，具体参见上文。
### **15.1属性描述符**
1 #属性描述符 2 class Descripter: 3 def get(self, instance, owner): 4 print(self, instance, owner) 5 6 def set(self, instance, value): 7 print(self, instance, value)
### **15.2测试代码**
1 class TestClass: 2 Des = Descripter() 3 4 5 def getattribute(self, name): 6 print("before getattribute") 7 return super(TestClass, self).getattribute(name) 8 print("after getattribute") 9 10 def setattr(self, name, value): 11 print("before setattr") 12 super(TestClass, self).setattr(name, value) 13 print("after setattr") 14 15 test1 = TestClass() 16 test2 = TestClass() 17 18 test1.Des = None 19 test2.Des
### **15.3输出结果**
1 before setattr 2 <main.Descripter object at 0x01D9A030> <main.TestClass object at 0x01D9A090> None 3 after setattr 4 before getattribute 5 <main.Descripter object at 0x01D9A030> <main.TestClass object at 0x01D9A0B0> <class 'main.TestClass'>
### **15.4结论**
类型的多个实例共享同一个属性描述符实例，属性描述符的优先级高于实例的\_\_dict\_\_，具体自己可以测试一下。
## 十六.装饰器（AOP）
### **16.1最基本的函数装饰器**
1 print("\n最基本的函数装饰器\n") 2 def log(fun): 3 def return_fun(*args, **kargs): 4 print("开始输出日志") 5 6 fun(*args, **kargs) 7 8 print("结束输出日志") 9 10 return return_fun 11 12 @log 13 def say(message): 14 print(message) 15 16 say("段光伟") 17 18 print("\n等价方法\n") 19 20 def say(message): 21 print(message) 22 23 say = log(say) 24 say("段光伟")
### **16.2带参数的函数装饰器**
1 print("\n带参数的函数装饰器\n")
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
了解详情》docs.qq.com/doc/DSlVlZExWQ0FRSE9H
