Python是通过python解释器执行的。
1.第一个python程序
print "hello world" # 存为hello.py文件
如何运行？在命令行下执行python hello.py执行即可。
2.变量和算数表达式
principal = 1000 # python是弱类型语言，变量声明之前不用指定类型 rate = 0.5 numyears = 5 year = 1 while year <= numyears: # :一般代表一个新代码块的开始 principal = principal * (1 + rate) #python中一般以四个空格缩进来定义一个新代码块 print year, principal # 使用print输出一行，多个变量之间使用,隔开 year += 1
python中可以格式化输出变量
print "%3d %0.2f" % (year, principal) print "%s" % "hello world"
%d代表输出整数，%s代表输出字符串，%f代表输出浮点数 此外还可以指定输出变量的宽度
例如0.2f 表示小数点之后保留两位小数。%3d代表整数宽度为3，右对齐
3.条件控制语句
a = 1 b = 2 if a < b: print "a < b" else: print "a > b" # 多个分支判断 用if elif else if suffix == ".html": content = "text/html" elif suffix == ".jpeg": content = "image/jpeg" elif suffix == ".png": content = "image/png" else: print "Unknown type" print content # 使用in来判断一个值包含在一个对象（字符串 列表 字典 ）中 str = "hello world" if "he" in str: has_he = True else: has_he = False print has_he
4.文件的输入输出
f = open("1.txt") #打开一个文件，返回一个文件对象
line = f.readline() #读取一行内容
while line:
print line, #读取一行内容 ,用于将line末尾的换行符去掉，因为print打印的时候默认在末尾添加一个换行符
line = f.readline()
f.close() #关闭文件
# 遍历一个数据的集合的过程称为迭代，python提供了for来进行迭代 ,可以这样说，凡是可以迭代的
对象都可以使用for 进行迭代，上面的程序也可以改写为
for line in open("1.txt"):
print line,
# 向一个文件中写数据
f = open("1.txt",‘w‘); # w代表使用写方式打开文件
f.write("hello world")
f.close()
# 从python解释器的标准输入输出流中读取数据
name = raw_input("input your name:")
5.字符串
python中的字符串可以使用‘‘ "" ‘‘‘‘‘‘括起来进行表示
不同于‘‘ "" 使用三引号括起来的字符串可以保留了字符串的格式，而单引号 双引号默认都是在一行上的。
str = ‘‘‘hello world I am a good student I love python‘‘‘ print str
在python中，字符串作为字符组成的列表（索引从0开始）使用索引可以提取python的单个字符
str = "hello world" print str[1] # e
如果提取一个子字符串，可以使用切片
str = "01234567" str = "01234567" str1 = str[0:4] #包含开头，不包含结尾 str2 = str[1:] str3 = str[:] print str1 #0123 print str2 #1234567 print str3 #01234567
使用加号，可以连接两个字符串
print str + "89" # 0123456789
就像php perl一样，python从来不将数字字符串隐式解释为数字，如果要进行数字运算必须进行强转
num1 = "12" num2 = "23" print int(num1) + int(num2)
非字符串类型的数据可以使用str()转为字符串
num = 213 num_str = str(num)
format用于将一个值格式化某种格式的字符串
format(9.8,"0.5f") # 9.80000
通过一个字符串split(delimiter)方法可以根据指定的分隔符，将一个字符串分为一个字符串列表
str = "pear,apple,orange"
fruit = str.split(",") ["pear","apple","orange"]
6.列表 python中的列表是任意对象组成的序列
names = ["joe", "sam", "tom"]
列表可以通过数字来索引，索引从0开始
print names[0] # joe
names[0] = "jeff" #将names的第一个元素改为jeff
names.append("lam") #将lam添加到列表的末尾 ["jeff","sam","tom", "lam"]
names.insert(2,"han") #在指定位置添加一个元素 ["jeff","sam","han","tom", "lam"]
可以使用切片来对列表进行复制，原理同字符串的操作
使用加号来连接两个列表
a = [1,2,3] + [4,5] # [1,2,3,4,5]
创建一个空链表
a = [] # 或者a = list()
列表里面还可以包含列表 类似于二维数组
li = [[1,2],[3,4,5]] print li[1][2] # 5
通过下面的程序我们来了解列表的一些高级特性
import sys #导入sys模块，用来获取命令行参数 if len(sys.argv) != 2: print "please supply a filename" raise SystemExit(1) file = open(sys.argv[1]) lines = file.readlines() #读取所有行，返回一个字符串列表 file.close() fvalues = [float(line) for line in lines] #通过遍历列表 生成一个浮点数列表python comprehension print "the max of the values", max(fvalues) print "the min of the values", min(fvalues) # 通过内建的函数返回列表中的最大值，最小值
列表对象提供了很多有用的方法，刚兴趣的可以自行查看python api
7.元组 tuple
元组即不可变的列表 通过元组可以构建一些简单的数据结构
address = (" 80 )
person = (first_name, second_name, age)
stock = "GOOG", 10, 90.9 #创建元组的时候，小括号可以省略
a = () #创建一个空元组
b = (1,) #创建一个元素的元组 注意，小括号不能省略
first_name, second_name, age = person #可以通过unpack一个元组同时来给多个变量复制
print person[1] #当然，也可以通过索引来获得元组元素的值 second_name
注意：元组在创建之后，元组的元素内容是不可以改变的。
在实际的编程中，如果需要创建许多的小列表的话，会消耗大量内存。为了使得list添加元素效率更高，通常创建一个列表在分配内存时候，会稍微比实际大小多分配一些内存。而元组则不会出现这种情况。
如果一个列表的元素是元祖的话，一种简单的遍历方式
stock = [("baidu",10,100.2), ("google",90,12.4), ("sina", 80， 124.5)]
for name, amount, price in stock:
print name, amount, price
8.集合 set
集合通常用来存放 无序 的对象集合
如何创建一个集合 使用set(),并且传入一个列表
s = set([1, 2, 3, 4])
s = set("hello")
由于集合是无序的，所以不能使用索引来获取元素 此外 集合元素的值是不能重复的 比如上图的hello
实际创建的集合中只含有一个l
集合可以进行集合间的运算 交集 合集 差集 对称差集
a = set([1, 2]) b = set([2, 3]) print a & b # both in a and b print a | b # a and b print a - b # in a but not in b print a ^ b # in a or in b but not both
对集合中的元素进行操作
a.add(4) # 向集合中添加一个元素 a.update([5, 6, 7]) # 通过添加多个元素 a.remove(3) # 移除一个元素
9.字典 dictionary
python的字典可以
理解为数据结构中的哈希表，即键值对的集合。
stock = {
"name": "baidu",
"amount": 100
"price": 23.2
}
对字典进行操作
stock["name"] = "google" #更新字典的值 stock["date"] = "2016-09-28" #新添加一个项
python的字典通常使用字符串（也可以使用数字，或者元组）作为键，字典的键必须是不可变对象，列表和字典不可以作为键，因为它们的内容是可以改变的。
字典可以作为查找无序数据的容器，并且查找速度很高。
定义一个空字典
stock = {} # 或者 stock = dict()
判断字典中是否存在某个键
price = {
"apple": 10,
"pear": 12,
"peach": 23,
"tomato": 24
}
if "apple" in price:
print price["apple"]
else:
print "no apple"
# 上面的代码可以用以下一行代码来代替
print price.get("apple", 0.0) # 如果"apple"存在则返回price["apple"],否则返回0.0
获取字典的所有键
keys = list(price)
删除字典中的某个元素
del price["apple"]
10.循环和迭代 looping and iteration
python中用的最多的循环语句就是for 迭代通常用于遍历一个集合(set list tuple dictionary)中的所有元素 例如
for i in [1,2,3,4,5]: print i # 或者 for i in range(1,6): #包含开头不包含结尾 print i
range()用来返回一个列表
range 函数的常用用法
range(1,4) # [1, 2, 3] range(5) # [0, 1, 2, 3, 4] range(0,12,3) # 3为步长 生成的列表为[0, 3, 6, 9] 注意，不包含12 range(5, 0, -1) # [5, 4, 3, 2, 1]
range()返回的列表会为元素分配全部内存，当生成一个很大的列表的时候，会很消耗内存，所以实际中当需要生成一个很大的列表的时候，通常会使用xrange()函数。
for语句可以用来遍历很多类型的对象（列表 元素 字典 字符串 文件）
str = "hello world"
for c in str:
print c
# 遍历字典
for key in price:
print key, price[key]
# 遍历文件的所有行
for line in open("1.txt"):
print line
11 函数
定义一个函数
def remainder(a, b): c = a // b # 商 d = a - b*c # 余数 return (c, d) # 借助元组可以返回多个值
调用函数
quotient, remainder = remainder(10, 3)
可以为函数的参数设置默认值
def connect(hostname, port, timeout = 300):
pass
connect(" 80 ) # 当为参数设置默认值的时候，参数可以省略
定义在函数内部的变量的作用域是局部的，当函数返回的时候，变量即被销毁。如果想要在函数内部修改一个全局变量可以这样做
count = 0 def foo(): global count count += 1 foo() print count # 变为了2
12 生成器 generator
通过yield语句，函数可以生成一个结果的列表
如果一个函数使用了yield语句，那么这个函数叫做一个生成器，通过调用一个生成器函数可以返回一个对象，通过连续调用这个对象的next()函数，可以得到一个结果的列表
# generator.py def countdown(n): print "counting down" while n > 0: yield n n -= 1
但是实际中，我们通常不会手动的调用next()函数，而是通过for来访问生成器返回的结果列表
for i in countdown(5): print i, # 5 4 3 2 1
生成器在管道，数据流处理中很有用。例如下面的生成器函数模仿了linux中的tail -f 命令
tail -f 通常用来检测一个日志文件动态增长的过程。
import time
def tail(f):
f.seek(0, 2) #将文件指针定位到文件尾部
while True:
line = f.readline()
if not line:
time.sleep(1)
continue
yield line
# 下面这个生成器用来检查字符串列表中是否含有某个关键字
def grep(lines, searchtext):
for line in lines:
if searchtext in line:
yield line
# 接下来通过把两个生成器结合起来，动态监测access.log生成的信息中是否含有python关键字
wwwlog = tail(open("access.log"))
pylines = grep(wwwlog, "python")
for line in pylines:
print line
13 协同程序 coroutines
通常函数通过接受一系列单一固定的参数来执行，此外函数还可以作为一个进程通过动态接受传递（没传递参数之前这个进程是阻塞的）给他的参数来执行 这种函数被称为协同程序，通过表达式(yield)来实现
# coroutine.py def print_matches(matchtext): print "looking for", matchtext while True: line = (yield) # 等待接受参数 if matchtext in line: print line
接下来我们首先通过next()第一次调用这个函数，此时函数阻塞在yield处，此时我们通过send来向函数传递参数，此时函数往下执行之后，又一次阻塞到yield处，继续等待send参数来
协同程序在写基于生产者消费者并发程序的时候很有用。我们这里的程序很明显是作为消费者（“消费”数据）
下面这个例子将生成器与协同程序结合起来
matchers = [
print_matches("python"),
print_matches("jython"),
print_matches("java")
]
for matcher in matchers:
matcher.next()
wwwlog = tail(open("access.log"))
for line in wwwlog:
for m in matchers:
m.send(line)
14 对象和类
在一个程序中用到的所有的值被称为对象 一个对象包括其内部数据和操作数据的方法 例如我们前面已经看到了string和list对象的很多方法。
使用dir函数可以看到一个对象的所有方法
类用于定义一类对象
class Stack(object): # object是所有类的基类
def __init__(self): #注意，所有的对类的数据操作的时候，必须使用self.引用
self.stack = [] # __init__方法用于初始化类对象，类似于C++ Java里的构造函数
def push(self, object):
self.stack.append(object)
def pop（self）:
return self.stack.pop()
return self.stack.pop()
s = Stack() # 新建一个类的对象
s.push("hanguodong")
s.push("bullshit")
s.push([1, 2, 3])
top = s.pop()
print top # [1, 2, 3]
top = s.pop()
print top # bullshit
由于栈跟python内建的list很相似 因此可以直接通过继承list来实现Stack类
class Stack(list): def push(self,object): self.append(object)
一般来说，在一个类内定义的方法，一般适用于那个类的对象 我们也可以通过装饰器（decorator）来修饰定义C++或者Java里的静态方法
class EventHandler(object): @staticmethod def dispatcherThread(self): #静态方法 while True: # wait for requests pass EventHandler.dispatchThread() # 直接通过类名就可以调用静态方法，不是实例化一个对象。
15 异常 Exception
如果python程序出现错误，将会抛出一个异常，然后打印处堆栈信息。
堆栈信息通常会打印处出错的位置和错误的类型
我们可以通过try except语句来捕获异常进而进行处理
try:
f = open("text.txt", "r")
except IOError as e:
print e
当出现IOError的时候，错误的详细信息会传递给e,然后交由except块处理
如果没有异常的话，except代码块则会被忽略
raise语句用于手动抛出一个异常
raise RuntimeError("go to hell")
当然我们也可以通过继承exception类来自定义自己的异常
此外如果涉及到系统资源（锁，文件，网络连接等）的异常处理的时候，使用with语句可以简化异常的处理 例如
import threading message_lock = threading.Lock() pass with message_lock: messages.add(message)
当程序执行到with语句的时候，程序获得锁，执行完with语句块之后，则释放锁。如果异常发生的话，当控制离开上下文代码块之后，锁被释放掉。
with语句一般用于系统资源的管理（锁，文件，网络连接） 而用户可以通过上下文管理协议来自定义自己的处理过程。
16 模块 module
模块即一个python文件，通过import这个python文件，我们可以使用这个.py文件里面的变量，函数，类等等。例如
# div.py def division(a, b): return a // b
如果导入一个模块。主要有三种方式
- import div # 注意，不要加.py后缀
a = div.division(10, 4)
2. from div import division
a = division(10, 3)
3. from div import *
a = division(12, 5)
17如何获取帮助
查阅api文档