python语法

python数据类型：（按特征划分）
数字类型：

整形：布尔形、长整型L、标准整形

非整形：双精度型、复数、decimal（不是内建类型）

序列类型：

字符串（str）

元组（tuple）

列表（list）

映像类型：

字典（dict）

集合类型：

可变集合（set）

不可变集合（frozenset）

python数据类型（按可变性划分）
可哈希的，不可变数据类型：

数字类型

不可变集合（frozenset）

字符串（str）

元组（tuple）

可变数据类型：

字典（dict）

列表（list）

可变集合（set）

python中引号的作用：
‘ ‘

“ “

''' '''

单引号和双引号基本没区别，同样的作用；双引号可以内嵌单引号。三引号作为大段文字的注释。
python的编解码
ASCII

Unicode

UTF-8

python模块
import moduleName：导入一个模块

from module import functionName：从一个模块中导入一个方法

import moduleName asnewModuleName：把一个模块重新命名

python用户交互：
使用内置函数：raw_input()，该函数接收一个字符串。
input()，该函数接收一个数字类型

python流程控制：
if … else …

split

strip

len()

for variable in range(1, 10):

while True:

break

continue

python练习：登录测试账号。
要求：输入用户名密码；认证成功后显示欢迎信息；输错三次后锁定

python的基本语法、数据类型、导入模块、流程控制。

python文件处理：
读文件：代码展示
f= file(‘filename.txt’, ‘r’)
forline in f.readlines():
line= line.strip(‘\n’).split(‘:’)
printline
文件处理模式：
r：以只读模式打开文件
w：以只写模式打开文件
a：以追加模式打开文件
r+b：以读写模式打开
w+b：以写读模式打开
a+b：以追加及读模式打开

python字符串处理：
str.find(substring,[start [,end]]) #可指范围查找子串，返回索引值，否则返回-1
str.rfind(substring,[start [,end]]) #反向查找
str.index(substring,[start [,end]]) #同find，只是找不到产生valueerror异常
str.rindex(substring,[start [,end]]) #同上反向查找
str.count(substring,[start [,end]]) #返回找到子串的个数

str.lowercase()
str.capitalize()首字母大写
str.lower()转小写
str.upper()转大写
str.swapcase()大小写互换
str.split(str,‘ ‘)将string转list，以空格分割
str.join(list,’ ’)将list转string，以空格分割

len(str)字符串长度
cmp(“myfriend”, str) 字符串比较。第一个大返回1
max(‘abcxyz’)寻找字符串中最大的字符
min(‘abcxyz’)寻找字符串中最小的字符

python中的列表：
list的方法：
list.append(var)追加元素
list.insert(index,var)
list.pop(var)返回最后一个元素，并从list中删除
list.remove(var)删除第一次出现的该元素
list.count(var)该元素在列表中出现的个数
list.index(var)该元素的位置，无则抛异常
list.extend(list2)追加list2，到list上。合并
list.sort()排序
list.reverse()元素顺序反转

list[1:]片段操作符，用于子list的提取
[1,2]+[3,4]为[1,2,3,4]。同extend()
[2]*4为[2,2,2,2]

dellist[1] 删除指定下标的元素
dellist[1:3] 删除指定下表范围的元素
list= list1 list是list1的别名，内存地址相同，对list操作就是对list1的操作
list= list2[:] 生成list2的一个copy

python元组：
tuple：常量数组
tuple= (‘a’, ‘b’, ‘c’, ‘d’)
可以用list的[],:操作符提取元素，就是不能直接修改元素

little case：shopping。
初始化金钱数，商品种类、价格，选择购买商品，直到钱不够，退出时打印已购买的商品和剩余金额。

开发文件替换小程序：
使用方法：./pythonFile.py‘source string’ ‘replace string’filename.txt./pythonFile.py‘source string’ ‘replace string’filename.txt --bak filename.txt.bak

python字典DICT：
dict.get(key,0) 同dict[key]，多了个没有则返回默认值，0。[]没有则抛出异常
dict.has_key(key)有该键返回True，否则False
dict.keys()返回字典键的列表
dict.values()以列表的形式返回字典中的值，返回值的列表中可包含重复元素
dict.items()将所有的字典项以列表方式返回，这些列表中的每一项都来自于(键，值)，但是项在返回时并没有特殊的顺序
dict.update(dict2)增加合并字典
dict.popitem()得到一个pair，并从字典中删除它，已空则抛出异常
dict.clear()清空字典，同del dict
dict.copy()拷贝字典
dictNaNp(dict1,dict2) 比较字典，（优先级为元素个数、键大小、键值大小
dict1= dict2 给dict2取个dict1的别名
dict2= dict.copy() 克隆，另一个拷贝

python中列表与字典的比较：
dict：
查找和插入的速度极快，不会随着key的增加而速度变慢

需要占用大量的内存，内存浪费多。

key不可变

默认无序

list：查找和插入的时间随着元素的增加而增加

占用空间小，内存浪费少。

通过下标查询

有序

python SET集合
特点：无序；元素不重复
功能：关系测试；去重

set集合运算：
a= set([1, 2, 3, 4])
b= set([3, 4, 5, 6])
a& b 求交集a.intersection(b)
a| b 求并集 a.union(b)
a– b 求差集a.difference(b)
a^ b 求对称差集a.symmetric_difference(b)
a.issubset(b) a是b的子集 a.issuperset(b) a是否包含b

查询员工信息：模糊查询员工信息，显示匹配的条数，匹配字符串高亮显示。

python中目录和python包的区别：就是包下包含一个__init__.py文件，而目录没有。

模块的常用方法：
__name__
__file__
__doc__

python中的不定参数：参数前面带一个或两个*。
def fun(arg)
def fun(*args)
def fun(**args)
dict = {‘k1’:1, ‘k2’:2}
fun(1,2,3,4,)
fun(**dict)=fun(k1=’1’, k2=’2’)

元组和集合只有一个星号，字典是两个星号

yield关键字：
yield的作用：在写多线程的时候，可以用它创建一个线程池。什么时候用，什么时候拿。它是一个生成器，不是一下就给他创建了。它还能保存函数的执行状态。
with关键字：

三元运算：
result = ‘human if 1>3 else ‘animal
result = animal

Lambda表达式：
a = lambda x, y: x+y
print a(4,10)
lambda的作用是：声明一个函数，接收参数，返回参数的运算结果。
lambda是一个匿名函数。

内置函数
help()
dir()
vars()
type()
import temp
reload(temp)
id()
更多：http://www.cnblogs.com/wupeiqi/articles/4276448.html

在使用from file import module的时候多次导入不会执行，只执行第一次导入，如果要想再次导入的话，使用reload(module)再次导入模块。

字符串的格式化占位符：
str = ‘i am {0}’
print s.format(‘alex’)
i am alex

函数的调用：
显示调用函数，直接写出该函数。
隐式调用函数，Function(arg) apply(Function, (arg))

map()函数：遍历每一个序列里面的元素。序列里面的每一个元素当作参数传给第一个function参数。
map(function, sequce, [sequce, …..])
也可以使用lambda表达式：map(lambda arg:arg+10, li) li = [11, 22, 33]
filter() 过滤
reduce() 累加
apply()
zip()
eval()
__import__()

都是对序列里面的函数进行操作，然后返回回来。
反射就是把你的导入工作当作字符串。
反射：用于开发大型程序，随时可以切换数据库的时候。设计模式里面的工厂模式需要用到这个。降低程序的耦合。
通过字符串的形式导入模块：（代码）

temp = ‘mysqlhelper’model = __import__(temp)model.cont()并以字符串的形式执行函数：（代码）

temp = ‘mysqlhelper’func = ‘count’model = __import__(temp)Funciton = getattr(model, func)

常用的模块：
随机数

random：random(m)randint(m, n)randrange(m, n)MD5加密

hash = hashlib.md5()

hash.update(‘admin’)

hash.hexdigest()

hash.digest()

序列化和json 序列化可以把一个对象和一个列表或字典，通过python特有的方式序列化一下，以二进制的方式加密一下。

import pickleli = ['alex',11, 22, 'ok', 'sb']printtype(pickle.dumps(li)) dumpsed =pickle.dumps(li)print dumpsedloadsed =pickle.loads(dumpsed)print loadsedprinttype(loadsed)pickle.dump(li,open('temp.pk' , 'w'))printpickle.load(open('temp.pk', 'r')) import jsonj_str =json.dumps(data)print j_strwithopen(‘file.json’, w’) as fp: json.dump(data, fp)RE 正则

六个函数：compile match search findall group groupsmatch：只能从你给的字符串的起始位置去匹配search：在整个字符串，在整个内容里面去匹配group：输出匹配的结果。常用格式：\d匹配数字\w\t次数： * + ? {m} {m,n}time模块

三种表示方法：时间戳 1970.1.1之后的秒数

元组 包含了：年、日、星期等….time.struct_time

格式化的字符串 2014-11-11 11：11 print time.time()

time.mktime(time.localtime())time.gmtime() 可加时间戳参数time.localtime() 可加时间戳参数time.strptime(‘2014-11-11’, ‘%Y-%m-%d’)time.strftime(‘%Y-%m-%d’) 默认当前时间time.strftime(‘%Y-%m-%d’, time.localtime()) 默认当前时间time.asctime()time.asctime(time.localtime())time.ctime(time.time())
sys 模块

sys.argv 命令行参数list， 第一个元素是程序本身路径sys.exit(n) 退出程序， 正常退出时exit(0)sys.version 获取python解释程序的版本信息sys.maxint 最大的int值sys.maxunicode 最大的unicode值sys.path 返回模块的搜索路径，初始化时使用pythonpathsys.platform 返回操作系统平台名称sys.stdout.write(‘please:’)val = sys.stdin.readline()[:-1]print valOS 模块

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径os.chdir(“dirname”) 改变当前脚本工作目录；相当于shell下cdos.curdir 返回当前目录；(‘.’)os.pardir 获取当前目录的父目录字符串名：(‘..’)os.makedirs(‘dirname1/dirname2’) 可生成多曾递归目录os.removedirs(‘dirname1’) 若目录为空，则删除，并递归到上一os.mkdir(‘dirname’) 生成单级目录，相当于shell中mkdir dirnameos.rmdir(‘dirname’) 删除单级空目录，若目录不为空则无法删除，os.listdir(‘dirname’)os.remove()os.rename(“oldname”, “newname”)os.stat(‘path/filename’)os.sepos.linesepos.pathsepos.nameos.system(“bash command”)os.environos.path.abspath(path)os.path.split(path)os.path.dirname(path)os.path.basename(path)os.path.exists(path)os.path.isabs(path)os.path.isfile(path)os.path.isdir(path)os.path.join(path1[,path2…..])os.path.getatime(path)os.path.getmtime(path) 装饰器（示例代码）

def foo(): print ‘foo’def foo(): print ‘before dosth’ print ‘foo’ print ‘after’def foo(): print ‘foo’def wrapper(func): print ‘before’ func() print ‘after’wrapper(foo)

装饰器

面向对象编程

异常处理

断言

First. 装饰器——也是一个函数，通过这个函数装饰另一个函数。
def outer(fun): def wrapper():fun()
return wrapper
@outer
def fun1():
print ‘hello’
#后面还有无穷个函数。
func1()
@outer相当于@outer=outer(func1) func1没有括号就代表这个函数，func1()带有括号就代表执行了这个函数，结果不一样的。
如果被调用的fun1函数带有参数，该参数放在defwrapper(arg)里面。带有参数的代码：
def outer(fun): def wrapper(arg):fun(arg)
return wrapper
@outer
def fun1():
print ‘hello’, arg
#后面还有无穷个函数。
func1(‘alex’)
如果func1有返回值的：
def outer(fun): def wrapper(arg):result = fun(arg)
return result
return wrapper
@outer
def fun1():
print ‘hello’, arg
return ‘eric’
#后面还有无穷个函数。
request= func1(‘alex’)
printrequest

second. 面向对象：
类就是一个抽象实例化一个类就是一个对象，对象里面有属性和方法。类里面的__init__方法，就是一个对象的初始化。相当于java中的构造函数。定义一个类：class Person: name = ‘这是一个人’def __init__(self, name):
self.name = name
pp= Person(‘alex’)
printpp.name
printPerson.name
self代表的就是一个实例化对象。就像上面的代码，self就代表的pp这个对象。
定义在类里面的属性，属于类的，不属于对象，直接可以使用使用类名.属性名调用，如：上段代码中的Person.name。
属于类的字段称为静态字段。通过self调用的称为动态字段（比如说：在__init__中调用的字段）。
类不能直接访问对象的属性，对象可以直接访问类的属性。
在一个类中定义静态方法的办法：直接在方法上面添加@staticmethod，去掉方法中的self。因为self代表的是一个对象。
在类中定义的静态方法可以使用类来调用，也可以使用对象来调用。
对象的属性：在类中定义一个方法，在该方法上添加@property， 就把该方法变成了对象的一个属性。访问的方式：对象名.属性名 pp.property 后面没有小括号。
这个静态方法什么时候用：
Python中的私有方法和私有字段：都是以双下划线__ 开头的。
私有方法

也是通过在内部定义一个公有的方法，该公有的方法调用该私有方法，在外部调用该公有的方法间接的访问该私有方法。强制访问私有方法的办法是：对象调用这个类的私有方法。具体是：对象名._类名__私有方法名()。objName._class__privateFunctionName()私有字段

在类中定义了私有字段，外部是不能访问的，只能通过在内部定义函数访问这个私有字段，外部调用该函数间接的访问该私有字段。访问私有字段代码：@propertydef Thailand(self): return self.__Thailand __Thailand是之前定义的一个私有字段。
objName.Thailand 调用该对象的这个方法来访问私有字段。
私有字段一般用在不让别人改，但是可以访问的情况下。 对象的属性的只读和可改写：它们使用的装饰器不一样。 代码：（只读的）@property defThailand(self): return self.__Thailand（可改写的） 推荐使用私有字段的操作方式：classClassName(object): def __init__(self, __Thailand)@Thailand.setter 还得让这个类继承objectdef Thailand(self, value): self.__Thailand = value 把__Thailand这个私有字段改写成了value这个值了
析构函数：就是python解释器在销毁对象的时候，我们可以干点啥，就可以写在这个析构函数里面。就是这个__del__
__call__方法：就是创建对象的时候，调用类中的__call__方法，在对象中使用对象名加上()即可。
classFoo():
def __call__(self):
print ‘我就是__call__方法。’
f1= Foo()
f1() --à直接调用对象中的__call__方法。
Foo()()的效果就等于 f1=Foo() f1()，这两步

继承：
在创建子类的时候在子类名后面的括号里写上父类的名字，就继承了父类。 方法的重写（override）：发生在类的继承中，子类重写父类的方法。
方法的重载（overload）：发生在本类中，两个重名的函数，根据参数的不同，而重载

子类调用父类的构造函数（也就是父类的__init__函数）：两种方法：
显示调用：Father.__init__(self)

隐式调用：super(son,self).__init__() 此种方法需要申明父类继承自object

继承自object的类称为新式类，未继承自object的类称为经典类。 多继承：如果在多继承中，多个父类含有同一函数的话，就从最左边的父类找到该函数并执行。 抽象类：代码如下： from abc import ABCMeta, abstractmethod class Bar: __metaclass__ = ABCMeta @abctractmethod def fun(self): pass class Foo(Bar): def __init__(self): print‘__init__’ Foo() python中的接口：没明确讲解。

Third. python中的异常处理：
使用的是try: xxxxxxxexcept Exception, e: xxxxxxelse: print ‘没有出错。’finally: print ‘这里的代码无论如何都会执行。’ 自定义的异常类：
class MyException(Exception):
def__init(self, msg):
self.error= msg
def__str__(self, *args, **kwargs):
returnself.error
主动触发异常：使用raise关键字
raiseMyException(‘自定义错误’)
为什么要主动触发异常：

Fourth. 断言
python中的断言：assert(1 == 1)

python操作mysql数据库

socket

python操作mysql数据库。

首先使用connect函数连接mysql，使用cursor获一个句柄，使用execute执行一条mysql语句，fetchall获得该数据库里面数据表的所有数据，然后关闭句柄和连接。把sql语句定义为一个字符串变量，把里面的值使用格式化字符串的形式传递一个%s，如：sql = “insert into userinfo values(%s, %s) 这里面的占位符只能是%s.params = (‘bababa’, ‘M’)reCount = cur.execute(sql, params)涉及到数据库增删改的时候需要调用commit()方法。connect.commit() 完整的代码： importMySQLdb connect =MySQLdb.connect(host=’localhost’, user=’root’, passwd=’root’, db=’dbname’) current =connect.cursor() sql = “insertinto tname(col1, col2, …) values(%s, %s, …)” params =(‘val1’, ‘val2’) reCount =cur.execute(sql, params) data =cur.fetchall() 获取所有数据 conn.commit() 与事务相关 conn.rollback() 与事务相关 cur.close() connect.close() print reCount print data 获取mysql的id值的函数：lastrowid python项目的三层架构思想

数据访问层， 业务逻辑层， 应用层。socket编程：

使用：异步、多线程、socket 处理多个请求的服务端。SocketServer：把 异步，多线程 做了处理。用socketserver和不用socketserver的区别：使用socketserver不会有阻塞，处理多个请求，可以多个客户端连接。

不使用socketserver效果相反。

在之后的所有socket编程都使用socketserver库。

线程

进程

ftp服务器

paramiko库

ftp服务器就是使用socketserver库建立一个ftp服务器数据的传输。
线程：python中的多线程：
使用threading.Thread模块。常用的方法有：
–start
–getName()–setName()–isDaemon()–setDaemon()–join(timeout)主线程启动了子线程后，一直等到子线程执行结束，再执行主线程的其他东西。加了timeout后，就是主线程等到timeout时间后或者子线程执行结束，再执行主线程。–run() 使这个线程与某件事情建立关系，使用target传递参数。
t1= Thread(target=function, args=(1, ))
target=function,这个是传递的某个方法，args=(1,)) args是传递该方法中的参数， 参数传递完毕后需要接一个逗号，
代码示例：
defFoo(arg, v):
foritem in range(100):
printitem
time.sleep(1)
print‘before’
t1= Thread(target=Foo, args=(‘ddfdfdffd’,11, ))
t1.setDaemon(True)
t1.start()
自建线程类：新建类继承Thread
classMyThread(Thread):
defrun(self):
print‘I am a thread.’
执行线程，其实就是调用了Thread类中的run方法。

线程安全的问题，使用锁的功能：线程锁，能很好的保护线程安全。
线程安全：队列

队列：先进先出
线程栈：后进先出
多线程的使用：python不是一个线程安全语言，需要自己控制。
生产者消费者模型： 生产者生产一个放到队列或者栈里面，然后消费者从队列或栈里面取一个。

线程安全的问题： 使用线程锁

lock = threading.Lock()定义一个锁lock.acquire()获取锁 给需要加锁的代码加锁。加锁的代码执行完后要释放锁：lock.release()python中防止死锁：定义锁的时候使用递归锁。lock = threading.Rlock()信号量：同时执行的线程几个。samp = threading.BoundedSemaphore(n)异步：

paramiko模块的使用：sshlinux主机批量管理。 ssh的rsa原理：使用非对称加密。 公钥：在服务器端做加密。 私钥：在客户端做解密。

多进程

Paramiko

审计开发

select异步模型

进程：使用multiprocessing模块的Pool类。
多进程多线程可以绕过GlobalInterpreter Lock（全局解释器锁）
多进程示例代码：
frommultiprocessing import Pool
deff(x):
returnx*x
if__name__ == ‘__main__’:
p= Pool(5)
print(p.map(f,[1,2,3]))

创建多个子进程的方法2，示例代码：
frommultiprocessing import Process
importos
definfo(title):
ifhasattr(os, ‘getppid’):
print‘parent process:’, os.getppid()
print‘process id:’, os.getpid()

if__name__ == ‘__main__’:
info(‘mainline’)
p= Process(target = f, args = (‘bbbbb’, ))
p.start()
p.join()

进程间通信：使用队列。
frommultiprocessing import Process,Queue

进程间同步：加上锁，使用Manager()方法。也可以使用Value和Array

进程池：通过Pool创建多进程。

python异步：select vs poll&epoll 异步IO

审计工具：web工具：shellinabox

第8天的主要内容：实战练习：python开发一个类似nagios的监控软件。

python的 socket 开源框架：twistedmatrix

主题：使用PYTHON开发类Nagios监控软件知识点：1. 使用Reids发布\订阅功能做服务器和客户端的通信通道2. 利用面向对象思想开发监控模板3. 实现监控项目插件化，允许用户自行开发监控插件 需求： 1. 每个客户端需要监控的服务不同
2. 每个服务的监控间隔不同
3. 允许模板的形式批量修改监控指标
4. 不同设备的监控阀值不同
5. 可自定最近n分钟内hit\max\avg\last\... 指标超过阈值
6. 报警策略、报警等级、报警自动升级
7. 历史数据的存储和优化
8. 跨机房、区域代理服务器
1000*20=20000 总指标，没5分钟一次，1hour = 24W1day = 576W *4Byte、Cpu :iowait 20 idle 80 system 30 user 50 What the client side has to know before itcan invoke a plugin?Answer: plugin_name \ interval \service name

python web框架 Django
Controller：该模型里面存放的是一组对业务逻辑的描述代码。
Model：该模型里面存放的是一组对数据库进行操作的代码。
View：该模型里面存放的是一组html文件。
http://www.cnblogs.com/wupeiqi/articles/4491246.html
创建django程序，使用IDE创建一个django application，并配置运行参数。