python的@语法_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 pickle

li = ['alex',11, 22, 'ok', 'sb']

printtype(pickle.dumps(li))

dumpsed =pickle.dumps(li)

print dumpsed

loadsed =pickle.loads(dumpsed)

print loadsed

printtype(loadsed)

pickle.dump(li,open('temp.pk' , 'w'))

printpickle.load(open('temp.pk', 'r'))

import json

j_str =json.dumps(data)

print j_str

withopen(‘file.json’, w’) as fp:

json.dump(data, fp)RE 正则

六个函数：

compile   match   search  findall    group  groups

match：只能从你给的字符串的起始位置去匹配

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  返回模块的搜索路径，初始化时使用pythonpath

sys.platform   返回操作系统平台名称

sys.stdout.write(‘please:’)

val = sys.stdin.readline()[:-1]

print valOS 模块

os.getcwd()  获取当前工作目录，即当前python脚本工作的目录路径

os.chdir(“dirname”)  改变当前脚本工作目录；相当于shell下cd

os.curdir   返回当前目录；(‘.’)

os.pardir    获取当前目录的父目录字符串名：(‘..’)

os.makedirs(‘dirname1/dirname2’)   可生成多曾递归目录

os.removedirs(‘dirname1’)   若目录为空，则删除，并递归到上一

os.mkdir(‘dirname’)   生成单级目录，相当于shell中mkdir  dirname

os.rmdir(‘dirname’)  删除单级空目录，若目录不为空则无法删除，

os.listdir(‘dirname’)

os.remove()

os.rename(“oldname”, “newname”)

os.stat(‘path/filename’)

os.sep

os.linesep

os.pathsep

os.name

os.system(“bash command”)

os.environ

os.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()私有字段

在类中定义了私有字段，外部是不能访问的，只能通过在内部定义函数访问这个私有字段，外部调用该函数间接的访问该私有字段。

访问私有字段代码：

@property

def Thailand(self):

return self.__Thailand       __Thailand是之前定义的一个私有字段。

objName.Thailand  调用该对象的这个方法来访问私有字段。

私有字段一般用在不让别人改，但是可以访问的情况下。

对象的属性的只读和可改写：它们使用的装饰器不一样。 代码：

(只读的)

@property

defThailand(self):

return self.__Thailand

(可改写的)  推荐使用私有字段的操作方式：

classClassName(object):

def __init__(self, __Thailand)

@Thailand.setter    还得让这个类继承object

def 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:

xxxxxxx

except Exception, e:

xxxxxx

else:

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 = 24W

1day = 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，并配置运行参数。