背景
PHP的$和->让人输入的手疼（PHP确实非常简洁和强大，适合WEB编程），Ruby的#、@、@@也好不到哪里（OO人员最该学习的一门语言）。
Python应该是写起来最舒服的动态语言了，一下是一些读书笔记，最后会介绍一下高级的用法：Mixin、Open Class、Meta Programming和AOP。
文中有些地方是用2.7开发的，如果您安装的是3.x，有几点需要注意：
-
print "xxx" 要换成 print("xxx")
-
__metaclass__ = type 删除掉。
类型和表达式部分
你好，世界！
1 # coding=utf-8
2
3 print "你好，世界。"
乘方
1 print 2**10
变量
1 var = 1
2 print var
3
4 var = "段光伟"
5 print var
注：这里的var = xxxx不叫变量赋值，而叫变量绑定，python维护了一个符号表（变量名）以及符合对应的值，这个对应关系就叫做绑定，一个符号可以绑定任意类型的值。
获取用户输入
1 #获取用户输入
2 x = input("x:")
3 y = input("y:")
4
5 print x*y
注：input接受的是Python代码，输入中可以访问当前执行环境中的变量，如果想获取原始输入需要使用 raw_input。
函数定义
1 def say_b():
2 print "b"
强类型
Javascript和Php是弱类型的，Python和Ruby是强类型的。弱类型允许不安全的类型转换，强类型则不允许。
1 #1 + “1” 这行代码在Python中会报错。
2 print 1 + int("1")
3 print str(1) + "1"
字符串
#字符串
print '''' 段
光
伟'''
print r'C:\log.txt'
print 'C:\\log.txt'
序列
这里先介绍三种序列：列表、元祖和字符串。
序列通用操作
seq = "0123456789"
print seq[0] #从0开始编码。
print seq[-1] #支持倒着数数，-1代表倒数第一。
print seq[1:5] #支持分片操作，seq[start:end]，start会包含在结果中，end不会包含在结果中。
print seq[7:] #seq[start:end]中的end可以省略。
print seq[-3:] #分片也支持负数。
print seq[:3] #seq[start:end]中的start也可以省略。
print seq[:] #全部省略会复制整个序列。
print seq[::2] #支持步长。
print seq[::-2] #支持负步长。
print seq[9:1:-1] #支持负步长。
print [1, 2, 3] + [4, 5, 6] # 序列支持相加，这解释了为啥字符串可以相加。
print [1, 2, 3] * 3 #序列支持相乘，这解释了为啥字符串可以相称。
print [None] * 10 #生成一个空序列。
print 1 in [1, 2, 3] #成员判断。
可变的列表
data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
data[0] = "a" #修改元素。
print data
data[0] = 0
del data[10] #删除元素。
print data
del data[8:] #分片删除。
print data
data[8:] = [8, 9, 10] #分片赋值
print data
不可变的元祖
1 print (1, 2) #元祖以小括号形式声明。
2 print (1,) #一个元素的元祖。
字符串格式化
print "% 10s" % "----"
print '''
%(title)s
%(body)s
''' % {"title": "标题", "body": "内容"}
字典
1 print {"title": "title", "body": "body"}
2 print dict(title = "title", body = "body")
3 print dict([("title", "title"), ("body", "body")])
1 dic = {"title": "title", "body": "body"};
2 print dic["title"]
3 del dic["title"]
4 print dic
print 语句
1 print 'a', 'b' #print可以接受多个参数，参数的输出之间以空格相隔。
2 print 'a', #如果逗号之后没有参数，则不会换行。
3 print 'b'
序列解包
x, y, z = 1, 2, 3
print x, y, z
(x, y, z) = (1, 2, 3)
print x, y, z
(x, y, z) = [1, 2, 3]
print x, y, z
bool值
#下面的输入全部返回False。
print(bool(None))
print(bool(()))
print(bool([]))
print(bool({}))
print(bool(""))
print(bool(0))
#虽然这些值在条件运算中会当做False，但是本身不等于False。
print(True and "")
print(not "")
print(False == "")
print(False == 0) #0除外，bool类型的内部表示就是int类型。
语句块
:开始语句快，缩进的所有内容都是一个语句块。
1 if(10 > 1):
2 print("10 > 1")
3 else:
4 print("不可能发生")
三元运算符
1 print("10 > 1" if 10 > 1 else "不可能发生")
相等比较
#== 和 is的差别，==比较的是内容，is比较的是引用。
x = [1, 2, 3]
y = x
z = [1, 2, 3]
print(x == y)
print(x == z)
print(x is y)
print(x is z)
循环
#for循环类似C#的foreach，注意for后面是没有括号的，python真是能简洁就尽量简洁。
for x in range(1, 10):
print(x)
for key in {"x":"xxx"}:
print(key)
for key, value in {"x":"xxx"}.items():
print(key, value)
for x, y, z in [["a", 1, "A"],["b", 2, "B"]]:
print(x, y, z)
#带索引的遍历
for index, value in enumerate(range(0, 10)):
print(index, value)
#好用的zip方法
for x, y in zip(range(1, 10), range(1, 10)):
print(x, y)
#循环中的的else子句
from math import sqrt
for item in range(99, 1, -1):
root = sqrt(item)
if(root == int(root)):
print(item)
break
else:
print("没有执行break语句。")
pass、exec和eval
#pass、exec、eval
if(1 == 1):
pass
exec('print(x)', {"x": "abc"})
print(eval('x*2', {"x": 5}))
函数部分
形参和实参之间是按值传递的，当然有些类型的值是引用（对象、列表和字典等）。
# 基本函数定义。
def func():
print("func")
func()
# 带返回值的函数。
def func_with_return():
return ("func_with_return")
print(func_with_return())
# 带多个返回值的函数。
def func_with_muti_return():
return ("func_with_muti_return", "func_with_muti_return")
print(func_with_muti_return())
# 位置参数
def func_with_parameters(x, y):
print(x, y)
func_with_parameters(1, 2)
# 收集多余的位置参数
def func_with_collection_rest_parameters(x, y, *rest):
print(x, y)
print(rest)
func_with_collection_rest_parameters(1, 2, 3, 4, 5)
#命名参数
def func_with_named_parameters(x, y, z):
print(x, y, z)
func_with_named_parameters(z = 1, y = 2, x = 3)
#默认值参数
def func_with_default_value_parameters(x, y, z = 3):
print(x, y, z)
func_with_default_value_parameters(y = 2, x = 1)
#收集命名参数
def func_with_collection_rest_naned_parameters(*args, **named_agrs):
print(args)
print(named_agrs)
func_with_collection_rest_naned_parameters(1, 2, 3, x = 4, y = 5, z = 6)
#集合扁平化
func_with_collection_rest_naned_parameters([1, 2, 3], {"x": 4, "y": 4, "z": 6}) #这会导致args[0]指向第一个实参，args[1]指向第二个实参。
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)。
作用域
# coding=utf-8
# 只有函数执行才会开启一个作用域。
if(2 > 1):
x = 1
print(x) # 会输出1。
# 使用vars()函数可以访问当前作用域包含的变量。
x = 1
print(vars()["x"])
# 使用globals()函数可以访问全局作用域。
x = 1
def func():
print(globals()["x"])
func()
# 使用locals()函数可以访问局部作用域。
def func():
x = 2
print(locals()["x"])
func()
# 每个函数定义时都会记住所在的作用域。
# 函数执行的时候会开启一个新的作用域，函数内变量访问的规则是：先访问当前作用域，如果没有就访问函数定义时的作用域，递归直到全局作用域。
x = 1
def func():
y = 2
print(x, y) # 输出1 2
func()
# 变量赋值始终访问的是当前作用域。
x = 1
def func():
x = 2
y = 2
print(x, y) # 输出2 2
func()
print(x) #输出 1
# 局部变量会覆盖隐藏全局变量，想访问全局变量可以采用global关键字或globals()函数。
x = 1
def func():
global x
x = 2
y = 2
print(x, y) # 输出2 2
func()
print(x) #输出 2
# python支持闭包
def func(x):
def inner_func(y):
print(x + y)
return inner_func
inner_func = func(10)
inner_func(1)
inner_func(2)
#函数作为对象
def func(fn, arg):
fn(arg)
func(print, "hello")
func(lambda arg : print(arg), "hello")
模块
几个模块相关的规则：
-
一个文件代表一个模块。
-
可以用import module导入模块，也可以用form module import member导入模块的成员。
-
如果导入的是module，必须使用module.member进行访问；如果导入的member，可以直接访问member。
-
导入的module或member都会变成当前module的member。
b.py
# coding=utf-8
print __name__
def say_b():
print "b"
a.py
# coding=utf-8
import b
from b import *
print __name__
def say_a():
print "a"
test.py
# coding=utf-8
import a
print __name__
a.say_a();
a.say_b();
a.b.say_b()
输出
b
a
__main__
a
b
b
出自：博客园
原创作者：幸福框架
原链接:http://mp.weixin.qq.com/s?__biz=MjM5MTYxNjQxOA==&mid=2652841225&idx=1&sn=7f942129e2a288e0094369dbe19b2a01&chksm=bd5959c48a2ed0d266839037ab615b19c2778126e7da2254f117ba3f42728773096c649d3602&mpshare=1&scene=23&srcid=03278Xbr1eyFKYcEkfu5HZvo#rd
浙公网安备 33010602011771号