前言
1. virtualenv的使用
virtualenv作用是并行管理多个python程序，解决因多个python版本不兼容的问题
使用方法如下
1）安装pip: apt install pip
2）安装virtualenv：pip install virtualenv
3）建立工作目录：virtualenv test1
4）在工作目录下安装文件：cd test1, source bin/activate, pip install tornado
2. 推荐参考书
1）程序员的数学
2）大话数据结构，大话设计模式（后期再看）
3）C语言
4）python标准库
5) python基础教程
6）官方文档 docs.python.org
一，函数
进阶篇 函数 第一节
1.函数基本概念
注意点：
a: 输出函数时要加小括号
b: 函数中的return语句非常重要
c: 函数体为空的话，这里要写一个pass
def func_name():
pass# 函数体为空的话，这里要写一个pass，如果不写，函数是不成立的，
输出函数时要加小括号
def func1():
return "hello,world"
print func1()
错误例子1
print "a>b" if a>b else pass 执行的时候会报错，其实这个三元表达式是执行2个命令，print 和后面的条件语句，如果a>b 会执行print "a>b", 否则，会执行print pass，但是这个pass是一个命令体中的语句，结果就会报错，最好写成如下
if a>b:
print "a>b"
else:
pass
错误例子2
def func2():
print 123
test = func2()
print type(test)
输出结果是nonetype，所以函数中的return语句非常重要。
2.参数 <=> 抽象
例如
def add(num1,num2)：
return num1+num2
print add(1,3)
print add(3,8)
3.参数分为可选参数，必选参数
1）计算不定数量的整数相加
def add(*num): #这里*会把num定义为一个tuple类型，2个*会定义为字典类型
d = 0
for i in num:
d += i
return d
print add(1,2,3,4,5)
print add(1,2,3)
print add(2,4,6,8,1,2,3,4,12312,12314,123,123,123)
2）可选和必选语法上的区别
1.可选参数 是有默认值的
2.必须参数 是没有默认值的
默认值和没有默认值的区别在于 “=”
例如
def add(num1,num2=4)
return num1+num2
print add(1)
如果参数中的"=4"没有的话，调用add函数的时候就需要写2个参数，如果定义函数的时候，2个参数都有等号，那么调用的时候直接用print add()就行
3） 函数的健壮性--考虑到大部分结果，并得到应急反馈处理。
1）各种情况下会返回什么东西（异常处理，条件判断）
2）自定义你想要的返回结果
def add(num1 ,num2):
if isinstance(num1,int) and isinstance(num2, int):
return num1+num2
else:
return '参数里有不是数字的类型'
print add('a',(1,2,3))
print add(1,2)
测试方法，断言
assert add(1,2) == 3
assert add(2,4) == 3
在这里，如果断言正确，不会输出任何信息，如果断言错误，就会返回AssertionError
二，函数第2节
1.元组，list，字典都能迭代，int和string不能迭代
2. 怎么去学习使用函数
（1）别管那么多复杂的，先直接把功能实现了。
（2）抽象成函数：命名规范，伪代码,参数默认值。
（3）将函数变得更健壮，让它可以跑很多地方
1.假设你写的函数是要交给你的基友用 -》 功能完整
2.假设你写的函数是要交给你的学弟用 -》 异常处理完善
(4) 测试
1.assert
2.对函数的返回进行一个值和类型的测试。
3.单元测试
def func1(a,b,c,d,e):
“”“
@a:
”“”
pass
3. 命名
下划线命名线 get_doc
驼峰命名法 getDocFromUrl
为什么要用默认值：
1.更省事
2.更可配置
4.练习题
三. 函数第3节
1. assert
在开发一个程序时候，与其让它运行时崩溃，不如在它出现错误条件时就崩溃（返回错误）。这时候断言assert就显得非常有用。
assert不能放在程序流程中，它是用于程序调试的
例1. 下面使用assert的方式是不对的
for item in args:
assert isinstance(item,int),'parameter is integer only'
return max(args),min(args)
例2
这段代码用来检测数据类型的断言，因为 a_str 是 str 类型，所以认为它是 int 类型肯定会引发错误。
>>> a_str = 'this is a string'
>>> type(a_str)
<type 'str'>
>>> assert type(a_str)== str
>>> assert type(a_str)== int
Traceback (most recent call last):
File "<pyshell#41>", line 1, in <module>
assert type(a_str)== int
AssertionError
2.自省与函数---func.__code__
例如
def func1(arg1,arg2):
return arg1 == arg2
print dir(func1.__code__)
print func1.__code__.co_varnames #('arg1', 'arg2')，返回函数的参数
print func1.__code__.co_filename #test1.py，返回脚本的文件名。
print help(func1.__code__)
都试一下会输出什么
3.作用域问题再议
例子1
arg = 1
def func1():
arg = 3
func1()
print arg
返回结果是1，说明局部变量只会在函数内部生效。
例子2
arg =1
def func1():
global arg
arg = 3
def func2():
global arg
arg =4
func2()
func1()
print arg
结论：
1) func2()和func1()的顺序不同，输出结果也会不同
2) global关键字可以把局部变量变为全局变量
4.可变参数的魔法与禁忌
例子1
def func1(arg):
arg[0] = 5 用于测试
return arg
print func1([1,2,3])
结果为[5,3,4]，参数arg为列表，是可变的参数。
例子2
def func1(arg):
arg[0] = 5 用于测试
return arg
tlist = [1,2,3]
print func1(tlist)
print tlist #引入可变参数会很危险，这里引入的tlist参数自己也被修改了
四. 函数第4节
step1:lambda之再议
1.lambda是一个表达式,它没有名称，存储的也不是代码块，而是表达式。
2.它被用作执行很小的功能，不能在里面使用条件语句。但是可以执行三元表达式，比如例2
3.也可以执行列表推导式，比如例子3
例子1
d = lambda x:x+1
print d(2)
输出为3,等价于函数
def e(x)
return x+1
例子2
>>> d = lambda x:x+1 if x>0 else "error"
>>> print d(3)
4
>>> print d(-1)
error
例子3
>>> g = lambda x:[(x,i) for i in xrange(0,10)]
>>> print g(3)
[(3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), (3, 7), (3, 8), (3, 9)]
例子4
>>> t = [1,2,3,4,5]
>>> g = filter(lambda x:x>3,t) #自动把t的值代入x中
>>> print g
[4, 5]
step2:函数参数总结
1.位置匹配 func(name)
def func(arg1,arg2,arg3):
return arg1,arg2,arg3
print func(1,2,3) #按位置传参
2.关键字匹配 func(key=value)
def test(a='',b='None',c=''):
return a,b,c
print test(a=2,c=3)
print test(c=9,a=1)
print test(a=3,b=4,c=5)
print test()
输出结果如下
(2, 'None', 3)
(1, 'None', 9) #说明参数顺序变化也没关系
(3, 4, 5)
('', 'None', '')
3.收集匹配
如果是在参数中没有定义的位置参数，就会设为元组或者字典;
*kargs 元组
**kw 字典
例子
def func2(a,*kargs,**kw):#比较有位置参数a和没有的区别
return kargs
print func2(2,3,4,5,[1,2,3],{1:2,3:4})
4.参数顺序
参数位置规则：位置匹配参数 > 关键字匹配参数 > 元组参数 > 字典参数； 比如def func2(a,d,b=4,*kargs,**kw)
step3:接触递归
1.递归是调用自身
2.理解下面的函数
"""
def func(i):
if i<100:
return i + func(i+1)
return i
print func(3)
print func(10)
"""
五. 面向对象
初识class
1. class的基本定义
class test(object):
a=1 #a称为test的属性
def func_1(self): #在类中定义的函数被称为方法，方法的第一个参数必须是self。
pass
t = test()
print t.a
print t.func_1()
2. __init__方法-------构造函数，
作用：实例化之前可以先引入一些必要的参数
例子1：定义一个空方法
def __init__(self):
pass
例子2：
class Person: #类名后面不加参数也行
def __init__(self,name,age):
self.name=''
self.age=0
p=person('tom',20)
print p
这样的输出结果是
hong@hong-VirtualBox:~$ python test2.py
<__main__.person instance at 0x7f5f8104c560>
例子3：将对象的内容打印出来
class test(object): #所有的class都是object的派生类
def __init__(self,var1): #注意这里的逗号
self.var1 = var1 #把参数var1赋值给self.var1,这样self.var1就能在类中进行全局调用
def get(self,a=None): #把参数a去掉和a=None是等效的，这样就不用引入参数了
return self.var1 #全局调用self.var1，一般的函数是不能使用在其他函数中的变量的
t = test("hello,my name is hong")
print t.get()
例子4：用于生成对象的字符串表示的方法__str__
class test:
def __init__(self,var1):
self.var1 = var1
def get(self,a=None):
return self.var1
def __str__(self):
return self.var1
t = test("hello, my name is hong")
print t.get()
print type(t.get())
print str(t)
print type(str(t))
输出如下
hello, my name is hong
<type 'str'>
hello, my name is hong
<type 'str'>
注意：这里get方法和__str__方法是等效的。
例子5：把上例改成2个参数
class test:
def __init__(self,var1,var2):
self.var1 = var1
self.var2 = var2
def get(self):
return self.var1,self.var2
def __str__(self):
return self.var1,self.var2
t = test("hello",33)
print t.get()
print str(t)
这样写会返回一个错误
hong@hong-VirtualBox:~$ python test2.py
('hello', 33)
Traceback (most recent call last):
File "test2.py", line 13, in <module>
print str(t)
TypeError: __str__ returned non-string (type tuple)
改成如下代码就对了，自己琢磨一下
class test:
def __init__(self,var1,var2):
self.var1 = var1
self.var2 = var2
def get(self):
return self.var1,self.var2
def __str__(self):
return "(%s,%d)" % (self.var1,self.var2)
t = test("hello",33)
print t.get()
print type(t.get())
print str(t)
print type(str(t))
输出结果如下
hong@hong-VirtualBox:~$ python test2.py
('hello', 33)
<type 'tuple'>
(hello,33)
<type 'str'>
3. 析构函数,是用作销毁的，这种方法不常用，因为class被销毁时，python有内部机制会自动销毁里面的数据。
def __del__(self):
del self.arg1
del self.arg2
t = test(1,4)
print t.a
print t.func_1()
4. class和函数的区别
例子1：一个最基本的对象
class test(object):#如果是空类，可以继承object类
def get(self): #类里面定义函数，其中的参数self代表的是对象本身，可以在class内部全局调用
return "hello"
对比一下，定义一个基本函数
def get():
return "hello"
t = test() #t是test的一个实例
print t.get() #get称为test对象的专属方法，不能被其他函数调用，这个就是使用对象的内置方法
print get() #自定义的函数和对象的内置方法进行对比
例2. 在get()函数中增加一个参数a
class test(object):
def get(self,a): #引入一个参数a，
return a
def got(a): #自定义的函数也引入一个参数a
return a
t = test()
new_var = 4
print t.get(new_var)
print got(new_var)
输出都是4
5. 私有变量
再person中，在变量名age开头加上2个下划线，表明age是私有变量，这样age只能person类中访问；不以下划线打头的变量是公有变量，任何代码都可访问他们。
在编写大型程序时，一条实用的经验规则是，首先将所有对象变量都设置为私有的（即以2个下划线打头），再在有充分理由的情况下将其改为公有的，可以避免无意间修改对象内部变量导致的错误。
6. __repr__和__str__的区别
class Test(object):
def __init__(self, value='hello, world!'):
self.data = value #这里说明并非一定写成self.value=value
>>> t = Test()
>>> t
<__main__.Test at 0x7fa91c307190>
>>> print t
<__main__.Test object at 0x7fa91c307190>
我测试的是t和print t，效果是一样的。
# 看到了么？上面打印类对象并不是很友好，显示的是对象的内存地址# 下面我们重构下该类的__repr__以及__str__，看看它们俩有啥区别
1） 重构__repr__class TestRepr(Test):
def __repr__(self):
return 'TestRepr(%s)' % self.data
>>> tr = TestRepr()
>>> tr
TestRepr(hello, world!)
>>> print tr
TestRepr(hello, world!)
# 重构__repr__方法后，不管直接输出对象还是通过print打印的信息都按我们__repr__方法中定义的格式进行显示了
2） 重构__str__
calss TestStr(Test):
def __str__(self):
return '[Value: %s]' % self.data
>>> ts = TestStr()
>>> ts
<__main__.TestStr at 0x7fa91c314e50>
>>> print ts
[Value: hello, world!]
# 你会发现，直接输出对象ts时并没有按我们__str__方法中定义的格式进行输出，而用print输出的信息却改变了
总结：
__repr__和__str__这两个方法都是用于显示的，__str__是面向用户的，而__repr__面向程序员。
- 打印操作会首先尝试__str__和str内置函数(print运行的内部等价形式)，它通常应该返回一个友好的显示。
- __repr__用于所有其他的环境中：用于交互模式下提示回应以及repr函数，如果没有使用__str__，会使用print和str。它通常应该返回一个编码字符串，可以用来重新创建对象，或者给开发者详细的显示。
当我们想所有环境下都统一显示的话，可以重构__repr__方法；当我们想在不同环境下支持不同的显示，例如终端用户显示使用__str__，而程序员在开发期间则使用底层的__repr__来显示，实际上__str__只是覆盖了__repr__以得到更友好的用户显示
7. 装饰器
1. @property，这个东西可以直接把函数当做属性来用，例如
class test(object):
@property
def d(self):
return 4
t=test()
print t.d #使用了装饰器，这里可以直接写t.d，就可以输出值，而不是t.d()
2. @staticmethod装饰器，可以不把类test实例化，就能使用其中的方法，如下
class test(object):
@staticmethod #静态方法，把命名空间放在了类test中
def d(): #这里不需要加self参数了，类的普通内置方法的时候才会加self参数，这里和在类外面定义的函数是一样的
return 4
print test.d() #不用实例化，直接用class的名称来执行。
8. 继承
例子1
class Base(object):
def __init__(self,name)
self.name = name
class b(Base): #相当于在b中也有一个init函数
def get_name(self):
return self.name #如果写name就是错误的
new_class = b("lilei") #把b实例化
print new_class.get_name()
六. 模块
1.模块的基本概念
模块其实就是一个py文件，比如python内置模块linecache,可以用dir(linecache)查看模块内置方法
2.导入模块的方法
1）import #导入全部方法
import linecache
>>> dir(linecache)
['__all__', '__builtins__', '__doc__', '__file__', '__name__', '__package__', 'cache', 'checkcache', 'clearcache', 'getline', 'getlines', 'os', 'sys', 'updatecache']
>>> linecache.__file__ #linecache的脚本文件位置
'/usr/lib/python2.7/linecache.pyc'
2）from module import sth，只导入模块中的某个方法
from linecache import getlines，这样就可以直接使用getlines方法
>>getlines
3）from module import all 导入全部方法
from linecache import *， 这种方式不会导入以下划线 (_) 开头的名称。
注意点，
1）在linecache的脚本文件中，有__all__ =["getline","clearcache","checkcache"]，这样用from linecache import *命令导入时，只会导入getline,clearcache,checkcache这三个方法，这三个方法相当于公有方法，所有人都可以使用；其他的方法相当于linecache的私有方法，比如updatecache,其他人不能任意用，使用import linecache时，就不会有这个限制。
2）当用这个方法导入多个模块的时候，不同模块中的方法名字可能会冲突，所以要慎用！
3.自定义模块
例如自定义个模块 m1
#coding=utf-8
def hash():
return 4
那么在其他脚本中就可以使用m1
#coding=utf-8
import m1
print m1.hash()
4.包的创建
包是一群模块的组合,所以先建一个文件夹，比如m2，作为包
1）写初始化文件 __init__.py #此时为空
为了让 Python 将目录当做包，目录下必须包含 __init__.py 文件；这样做是为了防止一个具有常见名字（例如 string）的目录无意中隐藏目录搜索路径中正确的模块。最简单的情况下，__init__.py 可以只是一个空的文件，但它也可以为包执行初始化代码或设置__all__
2）定义一个url.py
#coding=utf-8
def get_page():
return "some page content"
3）在其他脚本中引用包
注意使用from package import item时，item 可以是包的子模块（或子包），也可以是包中定义的一些其它的名称，比如函数、 类或者变量。import语句首先测试 item 在包中是否有定义；如果没有，它假定它是一个模块，并尝试加载它。如果未能找到，则引发ImportError异常。
相反，使用类似 import item.subitem.subsubitem 这样的语法时，除了最后一项其它每项必须是一个包；最后一项可以是一个模块或一个包，但不能是在前一个项目中定义的类、函数或变量
#coding=utf-8
import m2
print dir(m2）#查看都什么内置模块
print m2.__file__ #会导入init文件
#print m2.url是不会调用url.py文件的，执行脚本的时候会出错，那么怎么调用呢？
方法1 -----在python命令行，以及在linux脚本中都能执行
import m2.url
print m2.url
#如果觉得m2.url比较麻烦，可以用import m2.url as url改名，as相当于一个赋值操作，代码如下
import m2.url as url
print url.get_page()
执行结果：
输出getpage（）定义的文本信息：some page content
方法2 ---这种方法可以在python命令行中执行，但是在linux的脚本中不能执行。
from m2 import url
print url.get_page()
如果只想使用url的get_page方法，怎么办呢？
方法1
from m2.url import get_page
print get_page()
方法2
from m2 import *
print url.get_page()
那么此时就需要在__init__.py中进行定义__all__ = ["url"]，但是经验证，不用在__inti__.py中定义也行。
5. 搜索模块
如果在上面的包中再写一个模块，比如test2.py, 这个在包里的模块怎么引入外部的模块呢? 比如外部模块为m1.py
import sys
sys.path.append("/tmp/m") #添加模块搜索路径，m文件夹中包含着m1.py文件，其实就是定位m1的位置。
import m1
print m1.bash() #调用m1的bash()方法，视频中多了代码 __all__ = ['hash'],测试下不会影响吗？经验证，不会影响。
6. 常用模块
1.我们去哪里找模块
pypi.python.org ---- 这个网站有大量的python的模块库
docs.python.org/2.7/ ---- python文档，其中Library Reference包含所有的内置模块的说明
2.我们应该首先选择哪些的模块
首先考虑的是内置模块， 相关文档：http://docs.python.org/2.7/
3.常用模块
3.1 urllib，urllib2 --- 网络方面的模块
import urllib #urllib可能是一个包，包和模块的用法是一样的
dir(urllib)
help(urllib)里面FILE有脚本文件的位置信息
使用方法，比如获取网页内容
d = urllib.urlopen("http://www.baidu.com";)
print d.read()
3.2 datetime, time --- 时间模块
import time
time.time() #得到一个时间戳
import datetime
使用help(datetime)，看MODULE DOCS中的网站可以看到非常详细的例子
3.3 os --- 系统模块
import os
3.4 pickle --- 对象序列化
常用数据交换格式 还有json， xml
import pickle
例子
class test(object):
def a(self):
return 4
def b(self):
return 5
d = test() #想把对象做持久化保存，比如放在文件里，那么需要把对象转变为字符串，就需要用到pickle
g=pickle.dumps(d) #对象转为字符串
type(g) #这里就转变成字符串了
g=pickle.loads(g) #反序列化，字符串转为对象
3.5 bsddb --- 一个轻量级的数据库，支持key=>value的字典形式
3.6 logging --- 日志
掌握 info, warning, error，重点看一下
七，异常
exception,中译异常，保守派的圣杯，被滥用的良药。
1. 出错的东西们，他们出了什么错，他们出错 = 被抛出了异常
2. 我们不想让他们出错，继续执行下面的程序，该怎么办？exception来了。
coding=utf-8
a = [1,2,3,4,5,6]
print a[5]
try:
print a[6]
except: #捕获异常
print u"哈哈哈哈，这里出错啦" #出错以后该做什么，这里输出出错信息
print '继续往下跑哦'
3. 基本语法
try:
" 框住了你感觉会抛出异常的代码 "
print "41223123"
print a[6] #这里抛出异常后就会跳到except语句，不会执行下面的print语句。
print "hahaha"
except:
" try代码块里的代码如果抛出异常了，该执行什么内容"
print u"哈哈"
else:
"try代码块里的代码如果没有抛出异常，就执行这里"
print "hoho"
finally:
"不管如何，finally里的代码，是总会执行的"
print "xixi"
4. 异常的应用
import urllib
#异常输出如下
sth_url = "http://wasdasdasd";
try:
d = urllib.urlopen(sth_url)
except:
print "哈哈哈出错了"
else:
content = d.read()
finally:
d.close(）
5.我们为什么不让他出错？
其实在开发阶段，我们是可以让任何东西出错的，这样能更快的排错来完善代码
6.什么时候用，怎么用？
我们什么时候用异常？ 答：不得不用的时候。
异常怎么用？
1. (我们知道会有哪些问题，分析问题，得到这些问题会抛出的指定异常)捕获不同的异常情况，最好不要只写except，这样捕获所有异常比较笼统。
比如上面的例子，可以通过写多个except语句，完善如下
sth_url = "http://wasdasdasd";
try:
d = urllib.urlopen(sth_url)
except IOError: #打不开网页的异常,这里的IOError是网页不对时python输出的异常信息。
print "网页出错了"
except 语法错误异常：
print "语法错误"
else:
content = d.read()
finally:
d.close()
2.异常的处理，要合理。要有日志。