Python

Python

老男孩Python开发2016最新14期前10周视频【限免】

编程语言Target 回复了问题 • 5 人关注 • 4 个回复 • 1112 次浏览 • 2017-01-07 22:33 • 来自相关话题

python FTP问题

编程语言采菊篱下 回复了问题 • 3 人关注 • 2 个回复 • 142 次浏览 • 2016-12-27 11:38 • 来自相关话题

Python最差实践变更

编程语言chris 发表了文章 • 0 个评论 • 104 次浏览 • 2016-12-20 17:28 • 来自相关话题

最近在看一些陈年老系统,其中有一些不好的代码习惯遗留下来的坑;加上最近自己也写了一段烂代码导致服务器负载飙升,所以就趁此机会总结下我看到过/写过的自认为不好的Python代码习惯,时刻提醒自己远离这些“最差实践”,避免挖坑。

下面所举的例子中,有一部分会造成性能问题,有一部分会导致隐藏bug,或日后维护、重构困难,还有一部分纯粹是我认为不够pythonic。所以大家自行甄别,取精去糟吧。
 

函数默认参数使用可变对象​

这个例子我想大家应该在各种技术文章中见过许多遍了,也足以证明这是一个大坑。
 
先看错误示范吧:
def use_mutable_default_param(idx=0, ids=[]):
ids.append(idx)
print(idx)
print(ids)

use_mutable_default_param(idx=1)
use_mutable_default_param(idx=2)输出:
1
[1]
2
[1, 2]理解这其中的原因,最重要的是有两点:
函数本身也是一个对象,默认参数绑定于这个函数对象上append这类方法会直接修改对象,所以下次调用此函数时,其绑定的默认参数已经不再是空list了
 
正确的做法如下:
def donot_use_mutable_default_param(idx=0, ids=None):
if ids is None:
ids = []
ids.append(idx)
print(idx)
print(ids)

try…except不具体指明异常类型

虽然在Python中使用try…except不会带来严重的性能问题,但是不加区分,直接捕获所有类型异常的做法,往往会掩盖掉其他的bug,造成难以追查的bug。

一般的,我觉得应该尽量少的使用try…except,这样可以在开发期尽早的发现问题。即使要使用try…except,也应该尽可能的指定出要捕获的具体异常,并在except语句中将异常信息记入log,或者处理完之后,再直接raise出来。
 

关于dict的冗余代码

我经常能够看到这样的代码:
d = {}
datas = [1, 2, 3, 4, 2, 3, 4, 1, 5]
for k in datas:
if k not in d:
d[k] = 0
d[k] += 1其实,完全可以使用collections.defaultdict这一数据结构更简单优雅的实现这样的功能:
default_d = defaultdict(lambda: 0)
datas = [1, 2, 3, 4, 2, 3, 4, 1, 5]
for k in datas:
default_d[k] += 1 同样的,这样的代码:
# d is a dict
if 'list' not in d:
d['list'] = []
d['list'].append(x)完全可以用这样一行代码替代:
# d is a dict
d.setdefault('list', []).append(x)同样的,下面这两种写法一看就是带有浓浓的C味儿:
# d is a dict
for k in d:
v = d[k]
# do something

# l is a list
for i in len(l):
v = l[i]
# do something应该用更pythonic的写法:
# d is a dict
for k, v in d.iteritems():
# do something
pass

# l is a list
for i, v in enumerate(l):
# do something
pass另外,enumerate其实还有个第二参数,表示序号从几开始。如果想要序号从1开始数起,可以使用enumerate(l, 1)。 
 

使用flag变量而不使用for…else语句

同样,这样的代码也很常见:
search_list = ['Jone', 'Aric', 'Luise', 'Frank', 'Wey']
found = False
for s in search_list:
if s.startswith('C'):
found = True
# do something when found
print('Found')
break

if not found:
# do something when not found
print('Not found') 其实,用for…else更优雅:
search_list = ['Jone', 'Aric', 'Luise', 'Frank', 'Wey']
for s in search_list:
if s.startswith('C'):
# do something when found
print('Found')
break
else:
# do something when not found
print('Not found')

 

过度使用tuple unpacking

在Python中,允许对tuple类型进行unpack操作,如下所示:
# human = ('James', 180, 32)
name,height,age = human这个特性用起来很爽,比写name=human[0]之类的不知道高到哪里去了。所以,这一特性往往被滥用,一个human在程序的各处通过上面的方式unpack。

然而如果后来需要在human中插入一个表示性别的数据sex,那么对于所有的这种unpack都需要进行修改,即使在有些逻辑中并不会使用到性别。
# human = ('James', 180, 32)
name,height,age, _ = human
# or
# name, height, age, sex = human有如下几种方式解决这一问题:
老老实实写name=human[0]这种代码,在需要使用性别信息处加上sex=human[3]使用dict来表示human使用namedtuple
 
# human = namedtuple('human', ['name', 'height', 'age', 'sex'])
h = human('James', 180, 32, 0)
# then you can use h.name, h.sex and so on everywhere.

到处都是import *

import *是一种懒惰的行为,它不仅会污染当前的命名空间,并且还会使得pyflakes等代码检查工具失效。在后续查看代码或者debug的过程中,往往也很难从一堆import *中找到一个第三方函数的来源。

可以说这种习惯是百害而无一利的。
 

文件操作

文件操作不要使用裸奔的f = open(‘filename’)了,使用with open(‘filename’) as f来让context manager帮你处理异常情况下的关闭文件等乱七八糟的事情多好。
 

野蛮使用class.name判断类型

我曾经遇见过一个bug:为了实现某特定功能,我新写了一个class B(A),在B中重写了A的若干函数。整个实现很简单,但是就是有一部分A的功能无法生效。最后追查到的原因,就是在一些逻辑代码中,硬性的判断了entity.__class__.__name__ == ‘A’。

除非你就是想限定死继承层级中的当前类型(也就是,屏蔽未来可能会出现的子类),否则,不要使用__class__.__name__,而改用isinstance这个内建函数。毕竟,Python把这两个变量的名字都刻意带上那么多下划线,本来就是不太想让你用嘛。
 

循环内部有多层函数调用

循环内部有多层函数调用,有如下两方面的隐患:
Python没有inline函数,所以函数调用本来就会导致一定的开销,尤其是本身逻辑简单的时候,这个开销所占的比例就会挺可观的。更严重的是,在之后维护这份代码时,会容易让人忽略掉函数是在循环中被调用的,所以容易在函数内部添加了一些开销较大却不必每次循环都调用的函数,比如time.localtime()。如果是直接一个平铺直叙的循环,我想大部分的程序员都应该知道把time.localtime()写到循环的外面,但是引入多层的函数调用之后,就不一定了哦。
 
所以我建议,在循环内部,如非特别复杂的逻辑,都应该直接写在循环里,不要进行函数调用。如果一定要包装一层函数调用,应该在函数的命名或注释中,提示后续的维护者,这个函数会在循环内部使用。
 

总结

Python是一门非常容易入门的语言,严格的缩进要求和丰富的内置数据类型,使得大部分Python代码都能做到比较好的规范。但是,不严格要求自己,也很容易就写出犯二的代码。上面列出的只是很小的一部分,唯有多读、多写、多想,才能培养敏锐的代码嗅觉,第一时间发现坏味道啊。
 

分享阅读:http://blog.guoyb.com/2016/12/03/bad-py-style/
作者:yubo 查看全部
python.png
最近在看一些陈年老系统,其中有一些不好的代码习惯遗留下来的坑;加上最近自己也写了一段烂代码导致服务器负载飙升,所以就趁此机会总结下我看到过/写过的自认为不好的Python代码习惯,时刻提醒自己远离这些“最差实践”,避免挖坑。

下面所举的例子中,有一部分会造成性能问题,有一部分会导致隐藏bug,或日后维护、重构困难,还有一部分纯粹是我认为不够pythonic。所以大家自行甄别,取精去糟吧。
 


函数默认参数使用可变对象​


这个例子我想大家应该在各种技术文章中见过许多遍了,也足以证明这是一个大坑。
 
先看错误示范吧:
def use_mutable_default_param(idx=0, ids=[]):
ids.append(idx)
print(idx)
print(ids)

use_mutable_default_param(idx=1)
use_mutable_default_param(idx=2)
输出:
1
[1]
2
[1, 2]
理解这其中的原因,最重要的是有两点:
  1. 函数本身也是一个对象,默认参数绑定于这个函数对象上
  2. append这类方法会直接修改对象,所以下次调用此函数时,其绑定的默认参数已经不再是空list了

 
正确的做法如下:
def donot_use_mutable_default_param(idx=0, ids=None):
if ids is None:
ids = []
ids.append(idx)
print(idx)
print(ids)


try…except不具体指明异常类型


虽然在Python中使用try…except不会带来严重的性能问题,但是不加区分,直接捕获所有类型异常的做法,往往会掩盖掉其他的bug,造成难以追查的bug。

一般的,我觉得应该尽量少的使用try…except,这样可以在开发期尽早的发现问题。即使要使用try…except,也应该尽可能的指定出要捕获的具体异常,并在except语句中将异常信息记入log,或者处理完之后,再直接raise出来。
 


关于dict的冗余代码


我经常能够看到这样的代码:
d = {}
datas = [1, 2, 3, 4, 2, 3, 4, 1, 5]
for k in datas:
if k not in d:
d[k] = 0
d[k] += 1
其实,完全可以使用collections.defaultdict这一数据结构更简单优雅的实现这样的功能:
default_d = defaultdict(lambda: 0)
datas = [1, 2, 3, 4, 2, 3, 4, 1, 5]
for k in datas:
default_d[k] += 1
同样的,这样的代码:
# d is a dict
if 'list' not in d:
d['list'] = []
d['list'].append(x)
完全可以用这样一行代码替代:
# d is a dict
d.setdefault('list', []).append(x)
同样的,下面这两种写法一看就是带有浓浓的C味儿:
# d is a dict
for k in d:
v = d[k]
# do something

# l is a list
for i in len(l):
v = l[i]
# do something
应该用更pythonic的写法:
# d is a dict
for k, v in d.iteritems():
# do something
pass

# l is a list
for i, v in enumerate(l):
# do something
pass
另外,enumerate其实还有个第二参数,表示序号从几开始。如果想要序号从1开始数起,可以使用enumerate(l, 1)。 
 


使用flag变量而不使用for…else语句


同样,这样的代码也很常见:
search_list = ['Jone', 'Aric', 'Luise', 'Frank', 'Wey']
found = False
for s in search_list:
if s.startswith('C'):
found = True
# do something when found
print('Found')
break

if not found:
# do something when not found
print('Not found')
其实,用for…else更优雅:
search_list = ['Jone', 'Aric', 'Luise', 'Frank', 'Wey']
for s in search_list:
if s.startswith('C'):
# do something when found
print('Found')
break
else:
# do something when not found
print('Not found')

 


过度使用tuple unpacking


在Python中,允许对tuple类型进行unpack操作,如下所示:
# human = ('James', 180, 32)
name,height,age = human
这个特性用起来很爽,比写name=human[0]之类的不知道高到哪里去了。所以,这一特性往往被滥用,一个human在程序的各处通过上面的方式unpack。

然而如果后来需要在human中插入一个表示性别的数据sex,那么对于所有的这种unpack都需要进行修改,即使在有些逻辑中并不会使用到性别。
# human = ('James', 180, 32)
name,height,age, _ = human
# or
# name, height, age, sex = human
有如下几种方式解决这一问题:
  1. 老老实实写name=human[0]这种代码,在需要使用性别信息处加上sex=human[3]
  2. 使用dict来表示human
  3. 使用namedtuple

 
# human = namedtuple('human', ['name', 'height', 'age', 'sex'])
h = human('James', 180, 32, 0)
# then you can use h.name, h.sex and so on everywhere.


到处都是import *


import *是一种懒惰的行为,它不仅会污染当前的命名空间,并且还会使得pyflakes等代码检查工具失效。在后续查看代码或者debug的过程中,往往也很难从一堆import *中找到一个第三方函数的来源。

可以说这种习惯是百害而无一利的。
 


文件操作


文件操作不要使用裸奔的f = open(‘filename’)了,使用with open(‘filename’) as f来让context manager帮你处理异常情况下的关闭文件等乱七八糟的事情多好。
 


野蛮使用class.name判断类型


我曾经遇见过一个bug:为了实现某特定功能,我新写了一个class B(A),在B中重写了A的若干函数。整个实现很简单,但是就是有一部分A的功能无法生效。最后追查到的原因,就是在一些逻辑代码中,硬性的判断了entity.__class__.__name__ == ‘A’。

除非你就是想限定死继承层级中的当前类型(也就是,屏蔽未来可能会出现的子类),否则,不要使用__class__.__name__,而改用isinstance这个内建函数。毕竟,Python把这两个变量的名字都刻意带上那么多下划线,本来就是不太想让你用嘛。
 


循环内部有多层函数调用


循环内部有多层函数调用,有如下两方面的隐患:
  1. Python没有inline函数,所以函数调用本来就会导致一定的开销,尤其是本身逻辑简单的时候,这个开销所占的比例就会挺可观的。
  2. 更严重的是,在之后维护这份代码时,会容易让人忽略掉函数是在循环中被调用的,所以容易在函数内部添加了一些开销较大却不必每次循环都调用的函数,比如time.localtime()。如果是直接一个平铺直叙的循环,我想大部分的程序员都应该知道把time.localtime()写到循环的外面,但是引入多层的函数调用之后,就不一定了哦。

 
所以我建议,在循环内部,如非特别复杂的逻辑,都应该直接写在循环里,不要进行函数调用。如果一定要包装一层函数调用,应该在函数的命名或注释中,提示后续的维护者,这个函数会在循环内部使用。
 


总结


Python是一门非常容易入门的语言,严格的缩进要求和丰富的内置数据类型,使得大部分Python代码都能做到比较好的规范。但是,不严格要求自己,也很容易就写出犯二的代码。上面列出的只是很小的一部分,唯有多读、多写、多想,才能培养敏锐的代码嗅觉,第一时间发现坏味道啊。
 


分享阅读:http://blog.guoyb.com/2016/12/03/bad-py-style/
作者:yubo


Python调用Zabbix API实例

开源技术Nock 发表了文章 • 0 个评论 • 137 次浏览 • 2016-12-06 19:59 • 来自相关话题

#!/usr/bin/python
#coding:utf-8


import json
import urllib2
from urllib2 import URLError
import sys,argparse

class zabbix_api:
def __init__(self):
self.url = 'http://192.168.210.13:81/zabbix/api_jsonrpc.php' #修改URL
self.header = {"Content-Type":"application/json"}
#验证信息
def user_login(self):
data = json.dumps({
"jsonrpc": "2.0",
"method": "user.login",
"params": {
"user": "Admin", #修改用户名
"password": "zabbix" #修改密码
},
"id": 0
})

request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "\033[041m 用户认证失败,请检查 !\033[0m", e.code
else:
response = json.loads(result.read())
result.close()
#print response['result']
self.authID = response['result']
return self.authID
#主机查询
def host_get(self,hostName=''):
data = json.dumps({
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": "extend",
"filter":{
"host":hostName
}
},
"auth": self.user_login(),
"id": 1
})
request = urllib2.Request(self.url,data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
if hasattr(e, 'reason'):
print 'We failed to reach a server.'
print 'Reason: ', e.reason
elif hasattr(e, 'code'):
print 'The server could not fulfill the request.'
print 'Error code: ', e.code
else:
response = json.loads(result.read())
#print response
result.close()
print "主机数量: \033[31m%s\033[0m"%(len(response['result']))
for host in response['result']:
status={"0":"OK","1":"Disabled"}
available={"0":"Unknown","1":"available","2":"Unavailable"}
#print host
if len(hostName)==0:
print "HostID : %s\t HostName : %s\t Status :\033[32m%s\033[0m \t Available :\033[31m%s\033[0m"%(host['hostid'],host['name'],status[host['status']],available[host['available']])
else:
print "HostID : %s\t HostName : %s\t Status :\033[32m%s\033[0m \t Available :\033[31m%s\033[0m"%(host['hostid'],host['name'],status[host['status']],available[host['available']])
return host['hostid']
#图形查询
def graph_get(self,hostids,graphname=''):
data = json.dumps({
"jsonrpc": "2.0",
"method": "graph.get",
"params": {
"output": "extend",
"hostids": hostids,
"sortfield": "name"
},
"auth": self.user_login(),
"id":1
})
request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
if hasattr(e, 'reason'):
print 'We failed to reach a server.'
print 'Reason: ', e.reason
elif hasattr(e, 'code'):
print 'The server could not fulfill the request.'
print 'Error code: ', e.code
else:
response = json.loads(result.read())
result.close()
print "图形数量: \033[31m%s\033[0m"%(len(response['result']))
for graph in response['result']:
if len(graphname)==0:
print "graphid : %s\t graphname : %s\t width :\033[32m%s\033[0m \t height :\033[31m%s\033[0m"%(graph['graphid'],graph['name'],graph['width'],graph['height'])
else:
print "graphid : %s\t graphname : %s\t width :\033[32m%s\033[0m \t height :\033[31m%s\033[0m"%(graph['graphid'],graph['name'],graph['width'],graph['height'])
return graph['graphid']
#筛选图查询
def screen_get(self,ScreenName=''):
data = json.dumps({
"jsonrpc": "2.0",
"method": "screen.get",
"params": {
"output": "extend",
"selectScreenItems": "extend",
"filter": {
"name": ScreenName
}
},
"auth":self.user_login(),
"id":1
})

request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print 'Error as ', e
else:
response = json.loads(result.read())
result.close()
print "筛选图数量: \033[31m%s\033[0m"%(len(response['result']))
for screen in response['result']:
if len(ScreenName)==0:
print "ScreenID : %s\t ScreenName : %s\t Hsize :\033[32m%s\033[0m \t Vsize :\033[31m%s\033[0m"%(screen['screenid'],screen['name'],screen['hsize'],screen['vsize'])
else:
print "ScreenID : %s\t ScreenName : %s\t Hsize :\033[32m%s\033[0m \t Vsize :\033[31m%s\033[0m"%(screen['screenid'],screen['name'],screen['hsize'],screen['vsize'])
return screen['screenid']
#主机组查询
def hostgroup_get(self, hostgroupName=''):
data = json.dumps({
"jsonrpc":"2.0",
"method":"hostgroup.get",
"params": {
"output": "extend",
"filter": {
"name": hostgroupName
}
},
"auth":self.user_login(),
"id":1
})

request = urllib2.Request(self.url,data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
#print result.read()
response = json.loads(result.read())
result.close()
#print response()
for group in response['result']:
if len(hostgroupName)==0:
print "hostgroup: \033[31m%s\033[0m \tgroupid : %s" %(group['name'],group['groupid'])
else:
print "hostgroup: \033[31m%s\033[0m \tgroupid : %s" %(group['name'],group['groupid'])
self.hostgroupID = group['groupid']
return group['groupid']
#模版查询
def template_get(self,templateName=''):
data = json.dumps({
"jsonrpc": "2.0",
"method": "template.get",
"params": {
"output": "extend",
"filter": {
"name":templateName
}
},
"auth":self.user_login(),
"id":1
})

request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
#print response
for template in response['result']:
if len(templateName)==0:
print "template : \033[31m%s\033[0m\t id : %s" % (template['name'], template['templateid'])
else:
self.templateID = response['result'][0]['templateid']
print "Template Name : \033[31m%s\033[0m "%templateName
return response['result'][0]['templateid']
#主机组创建
def hostgroup_create(self,hostgroupName):
if self.hostgroup_get(hostgroupName):
print "hostgroup \033[42m%s\033[0m is exist !"%hostgroupName
sys.exit(1)
data = json.dumps({
"jsonrpc": "2.0",
"method": "hostgroup.create",
"params": {
"name": hostgroupName
},
"auth": self.user_login(),
"id": 1
})
request=urllib2.Request(self.url,data)

for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
print "\033[042m 添加主机组:%s\033[0m hostgroupID : %s"%(hostgroupName,response['result']['groupids'])
#筛选图添加
def screen_create(self,ScreenName,hsize,vsize):
if self.screen_get(ScreenName):
print "Screen \033[42m%s\033[0m is exist !"%ScreenName
sys.exit(1)
data = json.dumps({
"jsonrpc": "2.0",
"method": "screen.create",
"params": {
"name": ScreenName,
"hsize": hsize,
"vsize": vsize
},
"auth": self.user_login(),
"id": 1
})
request=urllib2.Request(self.url,data)

for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
print "\033[042m 添加筛选图:%s\033[0m ScreenName : %s"%(ScreenName,response['result']['screenids'])
#筛选图图形添加
def screen_item_create(self,screenid,resourceid,x,y):
if self.screen_item_create(resourceid):
print "resource \033[042m%s\033[0m is exist !"%resourceid
sys.exit(1)
screen_list=[]
for i in screenid.split(','):
var = {}
var['screenid'] = self.screen_get(i)
screen_list.append(var)
data = json.dumps({
"jsonrpc": "2.0",
"method": "screenitem.create",
"params": {
"screenid": screen_list,
"resourceid": resourceid,
"x": x,
"y": y
},
"auth": self.user_login(),
"id": 1
})
request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])
try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
print "\033[042m 添加筛选图形:%s\033[0m resourceid : %s"%(resourceid,response['result']['resourceids'])
#主机创建
def host_create(self, hostip, hostgroupName, templateName):
if self.host_get(hostip):
print "\033[041m该主机已经添加!\033[0m"
sys.exit(1)

group_list=[]
template_list=[]
for i in hostgroupName.split(','):
var = {}
var['groupid'] = self.hostgroup_get(i)
group_list.append(var)
for i in templateName.split(','):
var={}
var['templateid']=self.template_get(i)
template_list.append(var)

data = json.dumps({
"jsonrpc":"2.0",
"method":"host.create",
"params":{
"host": hostip,
"interfaces": [
{
"type": 1,
"main": 1,
"useip": 1,
"ip": hostip,
"dns": "",
"port": "10050"
}
],
"groups": group_list,
"templates": template_list,
},
"auth": self.user_login(),
"id":1
})
request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
print "添加主机 : \033[42m%s\031[0m \tid :\033[31m%s\033[0m" % (hostip, response['result']['hostids'])
#关闭主机
def host_disable(self,hostip):
data=json.dumps({
"jsonrpc": "2.0",
"method": "host.update",
"params": {
"hostid": self.host_get(hostip),
"status": 1
},
"auth": self.user_login(),
"id": 1
})
request = urllib2.Request(self.url,data)
for key in self.header:
request.add_header(key, self.header[key])
try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
print '----主机现在状态------------'
print self.host_get(hostip)
#删除主机
def host_delete(self,hostid):
hostid_list=[]
#print type(hostid)
for i in hostid.split(','):
var = {}
var['hostid'] = self.host_get(i)
hostid_list.append(var)
data=json.dumps({
"jsonrpc": "2.0",
"method": "host.delete",
"params": hostid_list,
"auth": self.user_login(),
"id": 1
})

request = urllib2.Request(self.url,data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except Exception,e:
print e
else:

result.close()
print "主机 \033[041m %s\033[0m 已经删除 !"%hostid
#删除筛选图
def screen_delete(self,screenid):
screenid_list=[]
for i in screenid.split(','):
var = {}
var['screenid'] = self.screen_get(i)
screenid_list.append(var)
data=json.dumps({
"jsonrpc": "2.0",
"method": "screen.delete",
"params": screenid_list,
"auth": self.user_login(),
"id": 1
})
request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])
try:
result = urllib2.urlopen(request)
except Exception,e:
print e
else:
result.close()
print "筛选图 \033[041m %s\033[0m 已经删除 !"%screenid


if __name__ == "__main__":
zabbix=zabbix_api()
parser=argparse.ArgumentParser(description='zabbix api ',usage='%(prog)s [options]')
parser.add_argument('-H','--host',nargs='?',dest='listhost',default='host',help='查询主机')
parser.add_argument('-Z','--graph',nargs='?',dest='listgraph',default='graph',help='查询图形')
parser.add_argument('-G','--group',nargs='?',dest='listgroup',default='group',help='查询主机组')
parser.add_argument('-T','--template',nargs='?',dest='listtemp',default='template',help='查询模板信息')
parser.add_argument('-S','--screen',nargs='?',dest='listscreen',default='screen',help='查询筛选图')
parser.add_argument('-A','--add-group',nargs=1,dest='addgroup',help='添加主机组')
parser.add_argument('-C','--add-host',dest='addhost',nargs=3,metavar=('192.168.2.1', 'test01,test02', 'Template01,Template02'),help='添加主机,多个主机组或模板使用分号')
parser.add_argument('-B','--create-screenitem',dest='addscreenitem',nargs=4,metavar=('38', '365', '0', '0'),help='添加筛选图图形')
parser.add_argument('-J','--add-screen',nargs=3,dest='addscreen',help='添加筛选图')
parser.add_argument('-d','--disable',dest='disablehost',nargs=1,metavar=('192.168.2.1'),help='禁用主机')
parser.add_argument('-D','--delete',dest='deletehost',nargs='+',metavar=('192.168.2.1'),help='删除主机,多个主机之间用分号')
parser.add_argument('-P','--delete-screen',dest='deletescreen',nargs='+',metavar=('38'),help='删除筛选图,多个筛选图之间用分号')
parser.add_argument('-v','--version', action='version', version='%(prog)s 1.0')
if len(sys.argv)==1:
print parser.print_help()
else:
args=parser.parse_args()

if args.listhost != 'host' :
if args.listhost:
zabbix.host_get(args.listhost)
else:
zabbix.host_get()
if args.listgraph != 'graph':
if args.listgraph:
zabbix.graph_get(args.listgraph)
else:
zabbix.graph_get()
if args.listgroup !='group':
if args.listgroup:
zabbix.hostgroup_get(args.listgroup)
else:
zabbix.hostgroup_get()
if args.listtemp != 'template':
if args.listtemp:
zabbix.template_get(args.listtemp)
else:
zabbix.template_get()
if args.listscreen != 'screen':
if args.listscreen:
zabbix.screen_get(args.listscreen)
else:
zabbix.screen_get()
if args.addgroup:
zabbix.hostgroup_create(args.addgroup[0])
if args.addhost:
zabbix.host_create(args.addhost[0], args.addhost[1], args.addhost[2])
if args.addscreen:
zabbix.screen_create(args.addscreen[0],args.addscreen[1],args.addscreen[2])
if args.addscreenitem:
zabbix.screen_item_create(args.addscreenitem[0],args.addscreenitem[1],args.addscreenitem[2],args.addscreenitem[3])
if args.disablehost:
zabbix.host_disable(args.disablehost)
if args.deletehost:
zabbix.host_delete(args.deletehost[0])
if args.deletescreen:
zabbix.screen_delete(args.deletescreen[0]) 查看全部
#!/usr/bin/python 
#coding:utf-8


import json
import urllib2
from urllib2 import URLError
import sys,argparse

class zabbix_api:
def __init__(self):
self.url = 'http://192.168.210.13:81/zabbix/api_jsonrpc.php' #修改URL
self.header = {"Content-Type":"application/json"}
#验证信息
def user_login(self):
data = json.dumps({
"jsonrpc": "2.0",
"method": "user.login",
"params": {
"user": "Admin", #修改用户名
"password": "zabbix" #修改密码
},
"id": 0
})

request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "\033[041m 用户认证失败,请检查 !\033[0m", e.code
else:
response = json.loads(result.read())
result.close()
#print response['result']
self.authID = response['result']
return self.authID
#主机查询
def host_get(self,hostName=''):
data = json.dumps({
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": "extend",
"filter":{
"host":hostName
}
},
"auth": self.user_login(),
"id": 1
})
request = urllib2.Request(self.url,data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
if hasattr(e, 'reason'):
print 'We failed to reach a server.'
print 'Reason: ', e.reason
elif hasattr(e, 'code'):
print 'The server could not fulfill the request.'
print 'Error code: ', e.code
else:
response = json.loads(result.read())
#print response
result.close()
print "主机数量: \033[31m%s\033[0m"%(len(response['result']))
for host in response['result']:
status={"0":"OK","1":"Disabled"}
available={"0":"Unknown","1":"available","2":"Unavailable"}
#print host
if len(hostName)==0:
print "HostID : %s\t HostName : %s\t Status :\033[32m%s\033[0m \t Available :\033[31m%s\033[0m"%(host['hostid'],host['name'],status[host['status']],available[host['available']])
else:
print "HostID : %s\t HostName : %s\t Status :\033[32m%s\033[0m \t Available :\033[31m%s\033[0m"%(host['hostid'],host['name'],status[host['status']],available[host['available']])
return host['hostid']
#图形查询
def graph_get(self,hostids,graphname=''):
data = json.dumps({
"jsonrpc": "2.0",
"method": "graph.get",
"params": {
"output": "extend",
"hostids": hostids,
"sortfield": "name"
},
"auth": self.user_login(),
"id":1
})
request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
if hasattr(e, 'reason'):
print 'We failed to reach a server.'
print 'Reason: ', e.reason
elif hasattr(e, 'code'):
print 'The server could not fulfill the request.'
print 'Error code: ', e.code
else:
response = json.loads(result.read())
result.close()
print "图形数量: \033[31m%s\033[0m"%(len(response['result']))
for graph in response['result']:
if len(graphname)==0:
print "graphid : %s\t graphname : %s\t width :\033[32m%s\033[0m \t height :\033[31m%s\033[0m"%(graph['graphid'],graph['name'],graph['width'],graph['height'])
else:
print "graphid : %s\t graphname : %s\t width :\033[32m%s\033[0m \t height :\033[31m%s\033[0m"%(graph['graphid'],graph['name'],graph['width'],graph['height'])
return graph['graphid']
#筛选图查询
def screen_get(self,ScreenName=''):
data = json.dumps({
"jsonrpc": "2.0",
"method": "screen.get",
"params": {
"output": "extend",
"selectScreenItems": "extend",
"filter": {
"name": ScreenName
}
},
"auth":self.user_login(),
"id":1
})

request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print 'Error as ', e
else:
response = json.loads(result.read())
result.close()
print "筛选图数量: \033[31m%s\033[0m"%(len(response['result']))
for screen in response['result']:
if len(ScreenName)==0:
print "ScreenID : %s\t ScreenName : %s\t Hsize :\033[32m%s\033[0m \t Vsize :\033[31m%s\033[0m"%(screen['screenid'],screen['name'],screen['hsize'],screen['vsize'])
else:
print "ScreenID : %s\t ScreenName : %s\t Hsize :\033[32m%s\033[0m \t Vsize :\033[31m%s\033[0m"%(screen['screenid'],screen['name'],screen['hsize'],screen['vsize'])
return screen['screenid']
#主机组查询
def hostgroup_get(self, hostgroupName=''):
data = json.dumps({
"jsonrpc":"2.0",
"method":"hostgroup.get",
"params": {
"output": "extend",
"filter": {
"name": hostgroupName
}
},
"auth":self.user_login(),
"id":1
})

request = urllib2.Request(self.url,data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
#print result.read()
response = json.loads(result.read())
result.close()
#print response()
for group in response['result']:
if len(hostgroupName)==0:
print "hostgroup: \033[31m%s\033[0m \tgroupid : %s" %(group['name'],group['groupid'])
else:
print "hostgroup: \033[31m%s\033[0m \tgroupid : %s" %(group['name'],group['groupid'])
self.hostgroupID = group['groupid']
return group['groupid']
#模版查询
def template_get(self,templateName=''):
data = json.dumps({
"jsonrpc": "2.0",
"method": "template.get",
"params": {
"output": "extend",
"filter": {
"name":templateName
}
},
"auth":self.user_login(),
"id":1
})

request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
#print response
for template in response['result']:
if len(templateName)==0:
print "template : \033[31m%s\033[0m\t id : %s" % (template['name'], template['templateid'])
else:
self.templateID = response['result'][0]['templateid']
print "Template Name : \033[31m%s\033[0m "%templateName
return response['result'][0]['templateid']
#主机组创建
def hostgroup_create(self,hostgroupName):
if self.hostgroup_get(hostgroupName):
print "hostgroup \033[42m%s\033[0m is exist !"%hostgroupName
sys.exit(1)
data = json.dumps({
"jsonrpc": "2.0",
"method": "hostgroup.create",
"params": {
"name": hostgroupName
},
"auth": self.user_login(),
"id": 1
})
request=urllib2.Request(self.url,data)

for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
print "\033[042m 添加主机组:%s\033[0m hostgroupID : %s"%(hostgroupName,response['result']['groupids'])
#筛选图添加
def screen_create(self,ScreenName,hsize,vsize):
if self.screen_get(ScreenName):
print "Screen \033[42m%s\033[0m is exist !"%ScreenName
sys.exit(1)
data = json.dumps({
"jsonrpc": "2.0",
"method": "screen.create",
"params": {
"name": ScreenName,
"hsize": hsize,
"vsize": vsize
},
"auth": self.user_login(),
"id": 1
})
request=urllib2.Request(self.url,data)

for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
print "\033[042m 添加筛选图:%s\033[0m ScreenName : %s"%(ScreenName,response['result']['screenids'])
#筛选图图形添加
def screen_item_create(self,screenid,resourceid,x,y):
if self.screen_item_create(resourceid):
print "resource \033[042m%s\033[0m is exist !"%resourceid
sys.exit(1)
screen_list=[]
for i in screenid.split(','):
var = {}
var['screenid'] = self.screen_get(i)
screen_list.append(var)
data = json.dumps({
"jsonrpc": "2.0",
"method": "screenitem.create",
"params": {
"screenid": screen_list,
"resourceid": resourceid,
"x": x,
"y": y
},
"auth": self.user_login(),
"id": 1
})
request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])
try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
print "\033[042m 添加筛选图形:%s\033[0m resourceid : %s"%(resourceid,response['result']['resourceids'])
#主机创建
def host_create(self, hostip, hostgroupName, templateName):
if self.host_get(hostip):
print "\033[041m该主机已经添加!\033[0m"
sys.exit(1)

group_list=[]
template_list=[]
for i in hostgroupName.split(','):
var = {}
var['groupid'] = self.hostgroup_get(i)
group_list.append(var)
for i in templateName.split(','):
var={}
var['templateid']=self.template_get(i)
template_list.append(var)

data = json.dumps({
"jsonrpc":"2.0",
"method":"host.create",
"params":{
"host": hostip,
"interfaces": [
{
"type": 1,
"main": 1,
"useip": 1,
"ip": hostip,
"dns": "",
"port": "10050"
}
],
"groups": group_list,
"templates": template_list,
},
"auth": self.user_login(),
"id":1
})
request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
print "添加主机 : \033[42m%s\031[0m \tid :\033[31m%s\033[0m" % (hostip, response['result']['hostids'])
#关闭主机
def host_disable(self,hostip):
data=json.dumps({
"jsonrpc": "2.0",
"method": "host.update",
"params": {
"hostid": self.host_get(hostip),
"status": 1
},
"auth": self.user_login(),
"id": 1
})
request = urllib2.Request(self.url,data)
for key in self.header:
request.add_header(key, self.header[key])
try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
print '----主机现在状态------------'
print self.host_get(hostip)
#删除主机
def host_delete(self,hostid):
hostid_list=[]
#print type(hostid)
for i in hostid.split(','):
var = {}
var['hostid'] = self.host_get(i)
hostid_list.append(var)
data=json.dumps({
"jsonrpc": "2.0",
"method": "host.delete",
"params": hostid_list,
"auth": self.user_login(),
"id": 1
})

request = urllib2.Request(self.url,data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except Exception,e:
print e
else:

result.close()
print "主机 \033[041m %s\033[0m 已经删除 !"%hostid
#删除筛选图
def screen_delete(self,screenid):
screenid_list=[]
for i in screenid.split(','):
var = {}
var['screenid'] = self.screen_get(i)
screenid_list.append(var)
data=json.dumps({
"jsonrpc": "2.0",
"method": "screen.delete",
"params": screenid_list,
"auth": self.user_login(),
"id": 1
})
request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])
try:
result = urllib2.urlopen(request)
except Exception,e:
print e
else:
result.close()
print "筛选图 \033[041m %s\033[0m 已经删除 !"%screenid


if __name__ == "__main__":
zabbix=zabbix_api()
parser=argparse.ArgumentParser(description='zabbix api ',usage='%(prog)s [options]')
parser.add_argument('-H','--host',nargs='?',dest='listhost',default='host',help='查询主机')
parser.add_argument('-Z','--graph',nargs='?',dest='listgraph',default='graph',help='查询图形')
parser.add_argument('-G','--group',nargs='?',dest='listgroup',default='group',help='查询主机组')
parser.add_argument('-T','--template',nargs='?',dest='listtemp',default='template',help='查询模板信息')
parser.add_argument('-S','--screen',nargs='?',dest='listscreen',default='screen',help='查询筛选图')
parser.add_argument('-A','--add-group',nargs=1,dest='addgroup',help='添加主机组')
parser.add_argument('-C','--add-host',dest='addhost',nargs=3,metavar=('192.168.2.1', 'test01,test02', 'Template01,Template02'),help='添加主机,多个主机组或模板使用分号')
parser.add_argument('-B','--create-screenitem',dest='addscreenitem',nargs=4,metavar=('38', '365', '0', '0'),help='添加筛选图图形')
parser.add_argument('-J','--add-screen',nargs=3,dest='addscreen',help='添加筛选图')
parser.add_argument('-d','--disable',dest='disablehost',nargs=1,metavar=('192.168.2.1'),help='禁用主机')
parser.add_argument('-D','--delete',dest='deletehost',nargs='+',metavar=('192.168.2.1'),help='删除主机,多个主机之间用分号')
parser.add_argument('-P','--delete-screen',dest='deletescreen',nargs='+',metavar=('38'),help='删除筛选图,多个筛选图之间用分号')
parser.add_argument('-v','--version', action='version', version='%(prog)s 1.0')
if len(sys.argv)==1:
print parser.print_help()
else:
args=parser.parse_args()

if args.listhost != 'host' :
if args.listhost:
zabbix.host_get(args.listhost)
else:
zabbix.host_get()
if args.listgraph != 'graph':
if args.listgraph:
zabbix.graph_get(args.listgraph)
else:
zabbix.graph_get()
if args.listgroup !='group':
if args.listgroup:
zabbix.hostgroup_get(args.listgroup)
else:
zabbix.hostgroup_get()
if args.listtemp != 'template':
if args.listtemp:
zabbix.template_get(args.listtemp)
else:
zabbix.template_get()
if args.listscreen != 'screen':
if args.listscreen:
zabbix.screen_get(args.listscreen)
else:
zabbix.screen_get()
if args.addgroup:
zabbix.hostgroup_create(args.addgroup[0])
if args.addhost:
zabbix.host_create(args.addhost[0], args.addhost[1], args.addhost[2])
if args.addscreen:
zabbix.screen_create(args.addscreen[0],args.addscreen[1],args.addscreen[2])
if args.addscreenitem:
zabbix.screen_item_create(args.addscreenitem[0],args.addscreenitem[1],args.addscreenitem[2],args.addscreenitem[3])
if args.disablehost:
zabbix.host_disable(args.disablehost)
if args.deletehost:
zabbix.host_delete(args.deletehost[0])
if args.deletescreen:
zabbix.screen_delete(args.deletescreen[0])

分享个基于sendclound的邮件群发软件 大家提点意见

回复

开源技术Nappywu 发起了问题 • 1 人关注 • 0 个回复 • 209 次浏览 • 2016-11-25 15:51 • 来自相关话题

Python的数据序列化「Json & Pickle」

大数据/云计算采菊篱下 发表了文章 • 0 个评论 • 316 次浏览 • 2016-10-20 00:06 • 来自相关话题

在介绍Python的数据序列化模块「Json & Pickle」之前,我们先来看看为什么需要数据序列化,什么是数据序列化。
 
为什么需要数据序列化,我认为有如下两种原因:
一个原因是将对象(一切皆对象)的状态保持在存储媒介(硬盘、网盘......)中,以便可以在以后重新创建精确的副本,相当于镜像的概念,比如我们平时利用VMware虚拟机中的挂起功能,这个挂起功能就是利用数据的序列化,把虚拟机当前的状态序列化保存在本地磁盘的文件中,然后恢复的时候只需反序列化,把状态恢复即可。
 
另一个原因是通过值将对象从一个应用程序域发送到另一个应用程序域中。例如,你利用Python监控采集程序采集到的数据想传送给Zabbix处理。当两个进程在进行远程通信时,彼此可以发送各种类型的数据。无论是何种类型的数据,都会以二进制序列的形式在网络上传送。发送方需要把这个对象转换为字节序列,才能在网络上传送;接收方则需要把字节序列再恢复为对象。
 
序列化和反序列化:
序列化: 将数据结构或对象转换成二进制串的过程。反序列化:将在序列化过程中所生成的二进制串转换成数据结构或者对象的过程。

序列化的目的就是为了跨进程传递格式化数据和保存某个时刻的状态。
 
什么是数据序列化:
数据序列化就是将对象或者数据结构转化成特定的格式,使其可在网络中传输,或者可存储在内存或者文件中。反序列化则是相反的操作,将对象从序列化数据中还原出来。而对象序列化后的数据格式可以是二进制,可以是XML,也可以是JSON等任何格式。对象/数据序列化的重点在于数据的交换和传输,例如在远程调用技术(如EJB,XML-RPC, Web Service),或者在GUI控件开发(JavaBean)等等。
 
清楚了数据格式化的必要和简单认识了什么是数据格式化之后,我们就来看看Python中两个数据格式化模块的使用。
 

Json Module

Json:用于字符串和 python数据类型间进行转换;
Json模块提供了四个功能:dumps、dump、loads、load
dumps把数据类型转换成字符串 dump把数据类型转换成字符串并存储在文件中 loads把字符串转换成数据类型  load把文件打开从字符串转换成数据类型
实例如下:
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

import json

info = {'1MinLoad': 5, 'MemUse': '5G', 'DiskUse': '80G'}

print('dumps 操作之前数据类型: %s' % type(info))
JsonInfo = json.dumps(info)
print(JsonInfo)
# dumps 将数据通过特殊的形式转换为所有程序语言都识别的字符串
print('dumps 操作之后数据类型: %s' % type(JsonInfo))

# loads 将字符串通过特殊的形式转为python是数据类型 (将字符串转为字典)
NewInfo = json.loads(JsonInfo)
print('loads 操作之后数据类型为: %s' % type(NewInfo))

print('分割线'.center(50, '-'))

# dump 将数据通过特殊的形式转换为所有语言都识别的字符串并写入文件
with open('SystemInfo.txt', 'w') as f:
json.dump(info, f)
print('dump file end!!')

# load 从文件读取字符串并转换为python的数据类型
with open('SystemInfo.txt', 'r') as f:
LoadInfo = json.load(f)
print('load file end, data type is %s' % type(LoadInfo), LoadInfo)结果如下:
dumps 操作之前数据类型: <class 'dict'>
{"MemUse": "5G", "DiskUse": "80G", "1MinLoad": 5}
dumps 操作之后数据类型: <class 'str'>
loads 操作之后数据类型为: <class 'dict'>
-----------------------分割线------------------------
dump file end!!
load file end, data type is <class 'dict'> {'MemUse': '5G', '1MinLoad': 5, 'DiskUse': '80G'}一个错误案例如下:
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

import json


def test():
print('Test Func')

info = {'Name': 'crh', 'age': 18, 'Func': test}

json.dumps(info)结果:
raise TypeError(repr(o) + " is not JSON serializable")
TypeError: <function test at 0x108e7a0d0> is not JSON serializable如上可知函数不能被json序列化。
 

Pickle Module

pickle,用于python特有的类型 和 python的数据类型间进行转换
Pickle模块同样提供了四个功能:dumps、dump、loads、load
dumps把数据类型转换成字符串 dump把数据类型转换成字符串并存储在文件中 loads把字符串转换成数据类型  load把文件打开从字符串转换成数据类型

Pickle可以序列化一些较复杂的数据,和json的区别在于pickle序列化的时候,存放的是二进制的文件,所以打开一个文件的时候,我们要以二进制的格式打开。
 实例如下:
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

import pickle


def test(name):
print('%s write Test Func' % name)

info = {'Name': 'crh', 'age': 18, 'Func': test}

print('dumps 之前数据的类型为: %s' % type(info))

# pickle.dumps 将数据通过特殊的形式转换为只有python语言认识bytes类型(Python2.*中是字符串类型)
NewInfo = pickle.dumps(info)
print('dumps result is %s, data type is %s' % (NewInfo, type(NewInfo)))

# pickle.loads 将bytes通过特殊的形式转为python是数据类型
LoadInfo = pickle.loads(NewInfo)
print('loads result is %s, data type is %s' % (LoadInfo, type(LoadInfo)))
LoadInfo['Func']('crh')

print('分割线'.center(50, '-'))

# pickle.dump 将数据通过特殊的形式转换为只有python语言认识的字符串,并写入文件
with open('pickle.rb', 'wb') as f:
pickle.dump(info, f)

# pickle.load 从文件读取只有python语言认识的字符串并转换为python的数据类型
with open('pickle.rb', 'rb') as f:
Info = pickle.load(f)

print(Info, 'type is %s' % type(Info))结果如下:
dumps 之前数据的类型为: <class 'dict'>
dumps result is b'\x80\x03}q\x00(X\x03\x00\x00\x00ageq\x01K\x12X\x04\x00\x00\x00Nameq\x02X\x03\x00\x00\x00crhq\x03X\x04\x00\x00\x00Funcq\x04c__main__\ntest\nq\x05u.', data type is <class 'bytes'>
loads result is {'age': 18, 'Name': 'crh', 'Func': <function test at 0x1032f10d0>}, data type is <class 'dict'>
crh write Test Func
-----------------------分割线------------------------
{'age': 18, 'Name': 'crh', 'Func': <function test at 0x1032f10d0>} type is <class 'dict'>
 

总结

很多情况下不同的程序之间传送数据我们一般通过文件的方式,但是这个方法是最原始的,而dumps可以直接让数据格式化传送给对方,但是不是所有的程序都是python的,所以只利用pickle是不现实的,比如一个python的程序需要发送一段数据给一个java程序开发的应用,这时候很多内存数据的交换,就得用json了。
 
并且josn能dump的结果更可读,那么有人就问了,那还用pickle做什么不直接用josn,是这样的josn只能把常用的数据类型序列化(列表、字典、列表、字符串、数字、),比如日期格式、类对象!josn就不行了。
 
为什么他不能序列化上面的东西呢?因为josn是跨语言的!注定了它只能规范出一些通用的数据类型的格式,统一标准。
  查看全部
jason.jpg
在介绍Python的数据序列化模块「Json & Pickle」之前,我们先来看看为什么需要数据序列化,什么是数据序列化。
 
为什么需要数据序列化,我认为有如下两种原因:
一个原因是将对象(一切皆对象)的状态保持在存储媒介(硬盘、网盘......)中,以便可以在以后重新创建精确的副本,相当于镜像的概念,比如我们平时利用VMware虚拟机中的挂起功能,这个挂起功能就是利用数据的序列化,把虚拟机当前的状态序列化保存在本地磁盘的文件中,然后恢复的时候只需反序列化,把状态恢复即可。
 
另一个原因是通过值将对象从一个应用程序域发送到另一个应用程序域中。例如,你利用Python监控采集程序采集到的数据想传送给Zabbix处理。当两个进程在进行远程通信时,彼此可以发送各种类型的数据。无论是何种类型的数据,都会以二进制序列的形式在网络上传送。发送方需要把这个对象转换为字节序列,才能在网络上传送;接收方则需要把字节序列再恢复为对象。
 
序列化和反序列化:
  • 序列化: 将数据结构或对象转换成二进制串的过程。
  • 反序列化:将在序列化过程中所生成的二进制串转换成数据结构或者对象的过程。


序列化的目的就是为了跨进程传递格式化数据和保存某个时刻的状态。
 
什么是数据序列化:
数据序列化就是将对象或者数据结构转化成特定的格式,使其可在网络中传输,或者可存储在内存或者文件中。反序列化则是相反的操作,将对象从序列化数据中还原出来。而对象序列化后的数据格式可以是二进制,可以是XML,也可以是JSON等任何格式。对象/数据序列化的重点在于数据的交换和传输,例如在远程调用技术(如EJB,XML-RPC, Web Service),或者在GUI控件开发(JavaBean)等等。
 
清楚了数据格式化的必要和简单认识了什么是数据格式化之后,我们就来看看Python中两个数据格式化模块的使用。
 


Json Module


Json:用于字符串和 python数据类型间进行转换;
Json模块提供了四个功能:dumps、dump、loads、load
  1. dumps把数据类型转换成字符串 
  2. dump把数据类型转换成字符串并存储在文件中 
  3. loads把字符串转换成数据类型  
  4. load把文件打开从字符串转换成数据类型

实例如下:
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

import json

info = {'1MinLoad': 5, 'MemUse': '5G', 'DiskUse': '80G'}

print('dumps 操作之前数据类型: %s' % type(info))
JsonInfo = json.dumps(info)
print(JsonInfo)
# dumps 将数据通过特殊的形式转换为所有程序语言都识别的字符串
print('dumps 操作之后数据类型: %s' % type(JsonInfo))

# loads 将字符串通过特殊的形式转为python是数据类型 (将字符串转为字典)
NewInfo = json.loads(JsonInfo)
print('loads 操作之后数据类型为: %s' % type(NewInfo))

print('分割线'.center(50, '-'))

# dump 将数据通过特殊的形式转换为所有语言都识别的字符串并写入文件
with open('SystemInfo.txt', 'w') as f:
json.dump(info, f)
print('dump file end!!')

# load 从文件读取字符串并转换为python的数据类型
with open('SystemInfo.txt', 'r') as f:
LoadInfo = json.load(f)
print('load file end, data type is %s' % type(LoadInfo), LoadInfo)
结果如下:
dumps 操作之前数据类型: <class 'dict'>
{"MemUse": "5G", "DiskUse": "80G", "1MinLoad": 5}
dumps 操作之后数据类型: <class 'str'>
loads 操作之后数据类型为: <class 'dict'>
-----------------------分割线------------------------
dump file end!!
load file end, data type is <class 'dict'> {'MemUse': '5G', '1MinLoad': 5, 'DiskUse': '80G'}
一个错误案例如下:
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

import json


def test():
print('Test Func')

info = {'Name': 'crh', 'age': 18, 'Func': test}

json.dumps(info)
结果:
 raise TypeError(repr(o) + " is not JSON serializable")
TypeError: <function test at 0x108e7a0d0> is not JSON serializable
如上可知函数不能被json序列化。
 


Pickle Module


pickle,用于python特有的类型 和 python的数据类型间进行转换
Pickle模块同样提供了四个功能:dumps、dump、loads、load
  1. dumps把数据类型转换成字符串 
  2. dump把数据类型转换成字符串并存储在文件中 
  3. loads把字符串转换成数据类型  
  4. load把文件打开从字符串转换成数据类型


Pickle可以序列化一些较复杂的数据,和json的区别在于pickle序列化的时候,存放的是二进制的文件,所以打开一个文件的时候,我们要以二进制的格式打开。
 实例如下:
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

import pickle


def test(name):
print('%s write Test Func' % name)

info = {'Name': 'crh', 'age': 18, 'Func': test}

print('dumps 之前数据的类型为: %s' % type(info))

# pickle.dumps 将数据通过特殊的形式转换为只有python语言认识bytes类型(Python2.*中是字符串类型)
NewInfo = pickle.dumps(info)
print('dumps result is %s, data type is %s' % (NewInfo, type(NewInfo)))

# pickle.loads 将bytes通过特殊的形式转为python是数据类型
LoadInfo = pickle.loads(NewInfo)
print('loads result is %s, data type is %s' % (LoadInfo, type(LoadInfo)))
LoadInfo['Func']('crh')

print('分割线'.center(50, '-'))

# pickle.dump 将数据通过特殊的形式转换为只有python语言认识的字符串,并写入文件
with open('pickle.rb', 'wb') as f:
pickle.dump(info, f)

# pickle.load 从文件读取只有python语言认识的字符串并转换为python的数据类型
with open('pickle.rb', 'rb') as f:
Info = pickle.load(f)

print(Info, 'type is %s' % type(Info))
结果如下:
dumps 之前数据的类型为: <class 'dict'>
dumps result is b'\x80\x03}q\x00(X\x03\x00\x00\x00ageq\x01K\x12X\x04\x00\x00\x00Nameq\x02X\x03\x00\x00\x00crhq\x03X\x04\x00\x00\x00Funcq\x04c__main__\ntest\nq\x05u.', data type is <class 'bytes'>
loads result is {'age': 18, 'Name': 'crh', 'Func': <function test at 0x1032f10d0>}, data type is <class 'dict'>
crh write Test Func
-----------------------分割线------------------------
{'age': 18, 'Name': 'crh', 'Func': <function test at 0x1032f10d0>} type is <class 'dict'>

 


总结


很多情况下不同的程序之间传送数据我们一般通过文件的方式,但是这个方法是最原始的,而dumps可以直接让数据格式化传送给对方,但是不是所有的程序都是python的,所以只利用pickle是不现实的,比如一个python的程序需要发送一段数据给一个java程序开发的应用,这时候很多内存数据的交换,就得用json了。
 
并且josn能dump的结果更可读,那么有人就问了,那还用pickle做什么不直接用josn,是这样的josn只能把常用的数据类型序列化(列表、字典、列表、字符串、数字、),比如日期格式、类对象!josn就不行了。
 
为什么他不能序列化上面的东西呢?因为josn是跨语言的!注定了它只能规范出一些通用的数据类型的格式,统一标准。
 

Python 备份Mysql

编程语言Not see︶ 发表了文章 • 0 个评论 • 294 次浏览 • 2016-09-23 19:26 • 来自相关话题

#!/usr/bin/env python
# Filename: mysql_backup.py
# author:kevin yang
# email:zhiwen.yang@showself.com
# date:2016-09-23
import os
import time
import sys
import datetime
from stat import *

# mysql user
User = 'root'

# mysql password
Passwd = '123456'

# mysqldump command
Mysqlcommand = 'mysqldump'

# gzip command
Gzipcommand = '/bin/gzip'

# you want backup mysql database
Mysqldata = ['PHPCMS', 'TeamToy']

# you want backup to dir
Tobackup = '/data/mysql_bak/'

for DB in Mysqldata:
# backup file name
Backfile = Tobackup + DB + '-' + time.strftime('%Y-%m-%d') + '.sql'
# gzip file name
Gzfile = Backfile +'.gz'
if os.path.isfile(Gzfile):
print Gzfile + " is already backup"
else:
# backup command
Back_command = Mysqlcommand + ' -u' + User + ' -p' + Passwd + ' -P3306 ' + DB + ' > ' + Backfile
if os.system(Back_command)==0:
print 'Successful backup to', DB + ' to ' + Backfile
else:
print 'Backup FAILED'
# gzip command
Gzip_command = Gzipcommand + ' ' + Backfile
if os.system(Gzip_command)==0:
print 'Successful Gzip to',Gzfile
else:
print 'Gzip FAILED'

# Delete back file
# show file list
filelist=[]
filelist=os.listdir(Tobackup)
# delete Gzfile 5 days ago
for i in range(len(filelist)):
ft=time.gmtime(os.stat(Tobackup+filelist[i])[ST_MTIME])
ftl=time.strftime('%Y-%m-%d',ft)
year,month,day=ftl.split('-')
ftll=datetime.datetime(int(year),int(month),int(day))
localt=time.gmtime()
localtl=time.strftime('%Y-%m-%d',localt)
year,month,day=localtl.split('-')
localtll=datetime.datetime(int(year),int(month),int(day))
days=(localtll-ftll).days
if days >5:
try:
os.remove(Tobackup+filelist[i])
print 'delete is ok'
except:
log=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')+" remove "+Tobackup+filelist[i]+" fail \n"
print log 查看全部
#!/usr/bin/env python
# Filename: mysql_backup.py
# author:kevin yang
# email:zhiwen.yang@showself.com
# date:2016-09-23
import os
import time
import sys
import datetime
from stat import *

# mysql user
User = 'root'

# mysql password
Passwd = '123456'

# mysqldump command
Mysqlcommand = 'mysqldump'

# gzip command
Gzipcommand = '/bin/gzip'

# you want backup mysql database
Mysqldata = ['PHPCMS', 'TeamToy']

# you want backup to dir
Tobackup = '/data/mysql_bak/'

for DB in Mysqldata:
# backup file name
Backfile = Tobackup + DB + '-' + time.strftime('%Y-%m-%d') + '.sql'
# gzip file name
Gzfile = Backfile +'.gz'
if os.path.isfile(Gzfile):
print Gzfile + " is already backup"
else:
# backup command
Back_command = Mysqlcommand + ' -u' + User + ' -p' + Passwd + ' -P3306 ' + DB + ' > ' + Backfile
if os.system(Back_command)==0:
print 'Successful backup to', DB + ' to ' + Backfile
else:
print 'Backup FAILED'
# gzip command
Gzip_command = Gzipcommand + ' ' + Backfile
if os.system(Gzip_command)==0:
print 'Successful Gzip to',Gzfile
else:
print 'Gzip FAILED'

# Delete back file
# show file list
filelist=[]
filelist=os.listdir(Tobackup)
# delete Gzfile 5 days ago
for i in range(len(filelist)):
ft=time.gmtime(os.stat(Tobackup+filelist[i])[ST_MTIME])
ftl=time.strftime('%Y-%m-%d',ft)
year,month,day=ftl.split('-')
ftll=datetime.datetime(int(year),int(month),int(day))
localt=time.gmtime()
localtl=time.strftime('%Y-%m-%d',localt)
year,month,day=localtl.split('-')
localtll=datetime.datetime(int(year),int(month),int(day))
days=(localtll-ftll).days
if days >5:
try:
os.remove(Tobackup+filelist[i])
print 'delete is ok'
except:
log=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')+" remove "+Tobackup+filelist[i]+" fail \n"
print log

Python程序软件目录规范化

编程语言采菊篱下 发表了文章 • 0 个评论 • 301 次浏览 • 2016-09-21 15:18 • 来自相关话题

为什么要设计好目录结构?

"设计项目目录结构",就和"代码编码风格"一样,属于个人风格问题。对于这种风格上的规范,一直都存在两种态度:
一类同学认为,这种个人风格问题"无关紧要"。理由是能让程序work就好,风格问题根本不是问题;另一类同学认为,规范化能更好的控制程序结构,让程序具有更高的可读性。
 
我是比较偏向于后者的,因为我是前一类同学思想行为下的直接受害者。我曾经维护过一个非常不好读的项目,其实现的逻辑并不复杂,但是却耗费了我非常长的时间去理解它想表达的意思。从此我个人对于提高项目可读性、可维护性的要求就很高了。"项目目录结构"其实也是属于"可读性和可维护性"的范畴,我们设计一个层次清晰的目录结构,就是为了达到以下两点:
可读性高: 不熟悉这个项目的代码的人,一眼就能看懂目录结构,知道程序启动脚本是哪个,测试目录在哪儿,配置文件在哪儿等等。从而非常快速的了解这个项目。可维护性高: 定义好组织规则后,维护者就能很明确地知道,新增的哪个文件和代码应该放在什么目录之下。这个好处是,随着时间的推移,代码/配置的规模增加,项目结构不会混乱,仍然能够组织良好。
 
所以,保持一个层次清晰的目录结构是有必要的。更何况组织一个良好的工程目录,其实是一件很简单的事儿。
 

目录组织方式

关于如何组织一个较好的Python工程目录结构,已经有一些得到了共识的目录结构。在Stackoverflow关于这个问题 ,可以看到很多赞同对Python目录结构规范的情况。

假设你的项目名为foo, 我比较建议的最方便快捷目录结构这样就足够了:Foo/
|-- bin/
| |-- foo
|
|-- foo/
| |-- tests/
| | |-- __init__.py
| | |-- test_main.py
| |
| |-- __init__.py
| |-- main.py
|
|-- docs/
| |-- conf.py
| |-- abc.rst
|
|-- setup.py
|-- requirements.txt
|-- README简要解释一下:
bin/: 存放项目的一些可执行文件,当然你可以起名script/之类的也行。foo/: 存放项目的所有源代码。(1) 源代码中的所有模块、包都应该放在此目录。不要置于顶层目录。(2) 其子目录tests/存放单元测试代码; (3) 程序的入口最好命名为main.py。docs/: 存放一些文档。setup.py: 安装、部署、打包的脚本。requirements.txt: 存放软件依赖的外部Python包列表。README: 项目说明文件。
 
除此之外,有一些方案给出了更加多的内容。比如LICENSE.txt,ChangeLog.txt文件等,我没有列在这里,因为这些东西主要是项目开源的时候需要用到。如果你想写一个开源软件,目录该如何组织,可以参考开源Python项目的正确方法 。

关于README的内容 

这个我觉得是每个项目都应该有的一个文件,目的是能简要描述该项目的信息,让读者快速了解这个项目。
 
它需要说明以下几个事项:
软件定位,软件的基本功能。运行代码的方法: 安装环境、启动命令等。简要的使用说明。代码目录结构说明,更详细点可以说明软件的基本原理。常见问题说明。
我觉得有以上几点是比较好的一个README。在软件开发初期,由于开发过程中以上内容可能不明确或者发生变化,并不是一定要在一开始就将所有信息都补全。但是在项目完结的时候,是需要撰写这样的一个文档的。
 
可以参考Redis源码中Readme的写法,这里面简洁清晰的描述了Redis功能和源码结构。

关于requirements.txt和setup.py

setup.py
 
一般来说,用setup.py来管理代码的打包、安装、部署问题。业界标准的写法是用Python流行的打包工具setuptools 来管理这些事情。这种方式普遍应用于开源项目中。不过这里的核心思想不是用标准化的工具来解决这些问题,而是说,一个项目一定要有一个安装部署工具,能快速便捷的在一台新机器上将环境装好、代码部署好和将程序运行起来。
 
我想大多数人是踩过坑的,刚开始接触Python写项目的时候,安装环境、部署代码、运行程序这个过程全是手动完成,遇到过以下问题:
安装环境时经常忘了最近又添加了一个新的Python包,结果一到线上运行,程序就出错了。Python包的版本依赖问题,有时候我们程序中使用的是一个版本的Python包,但是官方的已经是最新的包了,通过手动安装就可能装错了。如果依赖的包很多的话,一个一个安装这些依赖是很费时的事情。新同学开始写项目的时候,将程序跑起来非常麻烦,因为可能经常忘了要怎么安装各种依赖。
setup.py可以将这些事情自动化起来,提高效率、减少出错的概率。"复杂的东西自动化,能自动化的东西一定要自动化。"是一个非常好的习惯。

setuptools的文档比较庞大,刚接触的话,可能不太好找到切入点。学习技术的方式就是看他人是怎么用的,可以参考一下Python的一个Web框架,flask是如何写的:setup.py 。
 
当然,简单点自己写个安装脚本(deploy.sh)替代setup.py也未尝不可。

requirements.txt

这个文件存在的目的是:
方便开发者维护软件的包依赖。将开发过程中新增的包添加进这个列表中,避免在setup.py安装依赖时漏掉软件包。方便读者明确项目使用了哪些Python包。
这个文件的格式是每一行包含一个包依赖的说明,通常是flask>=0.10这种格式,要求是这个格式能被pip识别,这样就可以简单的通过 pip install -r requirements.txt来把所有Python包依赖都装好了。具体格式说明参考 。
 
关于配置文件的使用方法
注意,在上面的目录结构中,没有将conf.py放在源码目录下,而是放在docs/目录下。
 
很多项目对配置文件的使用做法是:
配置文件写在一个或多个python文件中,比如此处的conf.py。项目中哪个模块用到这个配置文件就直接通过import conf这种形式来在代码中使用配置。
 
这种做法我不太赞同:
这让单元测试变得困难(因为模块内部依赖了外部配置)另一方面配置文件作为用户控制程序的接口,应当可以由用户自由指定该文件的路径。程序组件可复用性太差,因为这种贯穿所有模块的代码硬编码方式,使得大部分模块都依赖conf.py这个文件。
 
所以,我认为配置的使用,更好的方式:
模块的配置都是可以灵活配置的,不受外部配置文件的影响。程序的配置也是可以灵活控制的。
 
能够佐证这个思想的是,用过nginx和mysql的同学都知道,nginx、mysql这些程序都可以自由的指定用户配置。

所以,不应当在代码中直接import conf来使用配置文件。上面目录结构中的conf.py,是给出的一个配置样例,不是在写死在程序中直接引用的配置文件。可以通过给main.py启动参数指定配置路径的方式来让程序读取配置内容。当然,这里的conf.py你可以换个类似的名字,比如settings.py。或者你也可以使用其他格式的内容来编写配置文件,比如settings.yaml之类的。 查看全部


为什么要设计好目录结构?


"设计项目目录结构",就和"代码编码风格"一样,属于个人风格问题。对于这种风格上的规范,一直都存在两种态度:
  1. 一类同学认为,这种个人风格问题"无关紧要"。理由是能让程序work就好,风格问题根本不是问题;
  2. 另一类同学认为,规范化能更好的控制程序结构,让程序具有更高的可读性。

 
我是比较偏向于后者的,因为我是前一类同学思想行为下的直接受害者。我曾经维护过一个非常不好读的项目,其实现的逻辑并不复杂,但是却耗费了我非常长的时间去理解它想表达的意思。从此我个人对于提高项目可读性、可维护性的要求就很高了。"项目目录结构"其实也是属于"可读性和可维护性"的范畴,我们设计一个层次清晰的目录结构,就是为了达到以下两点:
  1. 可读性高: 不熟悉这个项目的代码的人,一眼就能看懂目录结构,知道程序启动脚本是哪个,测试目录在哪儿,配置文件在哪儿等等。从而非常快速的了解这个项目。
  2. 可维护性高: 定义好组织规则后,维护者就能很明确地知道,新增的哪个文件和代码应该放在什么目录之下。这个好处是,随着时间的推移,代码/配置的规模增加,项目结构不会混乱,仍然能够组织良好。

 
所以,保持一个层次清晰的目录结构是有必要的。更何况组织一个良好的工程目录,其实是一件很简单的事儿。
 


目录组织方式


关于如何组织一个较好的Python工程目录结构,已经有一些得到了共识的目录结构。在Stackoverflow关于这个问题 ,可以看到很多赞同对Python目录结构规范的情况。

假设你的项目名为foo, 我比较建议的最方便快捷目录结构这样就足够了:
Foo/
|-- bin/
| |-- foo
|
|-- foo/
| |-- tests/
| | |-- __init__.py
| | |-- test_main.py
| |
| |-- __init__.py
| |-- main.py
|
|-- docs/
| |-- conf.py
| |-- abc.rst
|
|-- setup.py
|-- requirements.txt
|-- README
简要解释一下:
  1. bin/: 存放项目的一些可执行文件,当然你可以起名script/之类的也行。
  2. foo/: 存放项目的所有源代码。(1) 源代码中的所有模块、包都应该放在此目录。不要置于顶层目录。(2) 其子目录tests/存放单元测试代码; (3) 程序的入口最好命名为main.py。
  3. docs/: 存放一些文档。
  4. setup.py: 安装、部署、打包的脚本。
  5. requirements.txt: 存放软件依赖的外部Python包列表。
  6. README: 项目说明文件。

 
除此之外,有一些方案给出了更加多的内容。比如LICENSE.txt,ChangeLog.txt文件等,我没有列在这里,因为这些东西主要是项目开源的时候需要用到。如果你想写一个开源软件,目录该如何组织,可以参考开源Python项目的正确方法 。


关于README的内容 


这个我觉得是每个项目都应该有的一个文件,目的是能简要描述该项目的信息,让读者快速了解这个项目。
 
它需要说明以下几个事项:
  1. 软件定位,软件的基本功能。
  2. 运行代码的方法: 安装环境、启动命令等。
  3. 简要的使用说明。
  4. 代码目录结构说明,更详细点可以说明软件的基本原理。
  5. 常见问题说明。

我觉得有以上几点是比较好的一个README。在软件开发初期,由于开发过程中以上内容可能不明确或者发生变化,并不是一定要在一开始就将所有信息都补全。但是在项目完结的时候,是需要撰写这样的一个文档的。
 
可以参考Redis源码中Readme的写法,这里面简洁清晰的描述了Redis功能和源码结构。


关于requirements.txt和setup.py


setup.py
 
一般来说,用setup.py来管理代码的打包、安装、部署问题。业界标准的写法是用Python流行的打包工具setuptools 来管理这些事情。这种方式普遍应用于开源项目中。不过这里的核心思想不是用标准化的工具来解决这些问题,而是说,一个项目一定要有一个安装部署工具,能快速便捷的在一台新机器上将环境装好、代码部署好和将程序运行起来。
 
我想大多数人是踩过坑的,刚开始接触Python写项目的时候,安装环境、部署代码、运行程序这个过程全是手动完成,遇到过以下问题:
  1. 安装环境时经常忘了最近又添加了一个新的Python包,结果一到线上运行,程序就出错了。
  2. Python包的版本依赖问题,有时候我们程序中使用的是一个版本的Python包,但是官方的已经是最新的包了,通过手动安装就可能装错了。
  3. 如果依赖的包很多的话,一个一个安装这些依赖是很费时的事情。
  4. 新同学开始写项目的时候,将程序跑起来非常麻烦,因为可能经常忘了要怎么安装各种依赖。

setup.py可以将这些事情自动化起来,提高效率、减少出错的概率。"复杂的东西自动化,能自动化的东西一定要自动化。"是一个非常好的习惯。

setuptools的文档比较庞大,刚接触的话,可能不太好找到切入点。学习技术的方式就是看他人是怎么用的,可以参考一下Python的一个Web框架,flask是如何写的:setup.py 。
 
当然,简单点自己写个安装脚本(deploy.sh)替代setup.py也未尝不可。


requirements.txt


这个文件存在的目的是:
  1. 方便开发者维护软件的包依赖。将开发过程中新增的包添加进这个列表中,避免在setup.py安装依赖时漏掉软件包。
  2. 方便读者明确项目使用了哪些Python包。

这个文件的格式是每一行包含一个包依赖的说明,通常是flask>=0.10这种格式,要求是这个格式能被pip识别,这样就可以简单的通过 pip install -r requirements.txt来把所有Python包依赖都装好了。具体格式说明参考 。
 
关于配置文件的使用方法
注意,在上面的目录结构中,没有将conf.py放在源码目录下,而是放在docs/目录下。
 
很多项目对配置文件的使用做法是:
  1. 配置文件写在一个或多个python文件中,比如此处的conf.py。
  2. 项目中哪个模块用到这个配置文件就直接通过import conf这种形式来在代码中使用配置。

 
这种做法我不太赞同:
  1. 这让单元测试变得困难(因为模块内部依赖了外部配置)
  2. 另一方面配置文件作为用户控制程序的接口,应当可以由用户自由指定该文件的路径。
  3. 程序组件可复用性太差,因为这种贯穿所有模块的代码硬编码方式,使得大部分模块都依赖conf.py这个文件。

 
所以,我认为配置的使用,更好的方式:
  1. 模块的配置都是可以灵活配置的,不受外部配置文件的影响。
  2. 程序的配置也是可以灵活控制的。

 
能够佐证这个思想的是,用过nginx和mysql的同学都知道,nginx、mysql这些程序都可以自由的指定用户配置。

所以,不应当在代码中直接import conf来使用配置文件。上面目录结构中的conf.py,是给出的一个配置样例,不是在写死在程序中直接引用的配置文件。可以通过给main.py启动参数指定配置路径的方式来让程序读取配置内容。当然,这里的conf.py你可以换个类似的名字,比如settings.py。或者你也可以使用其他格式的内容来编写配置文件,比如settings.yaml之类的。

Memcached和Redis监控脚本分享

开源技术push 发表了文章 • 0 个评论 • 242 次浏览 • 2016-09-20 16:05 • 来自相关话题

Memcached:
#!/usr/bin/env python
#coding=utf8

import sys
import os

class GetMemStatus():
def __init__(self):
self.val = {}
def check(self):
try:
import memcache
self.mc = memcache.Client(['127.0.0.1:11211'], debug=0)
except:
raise Exception, 'Plugin needs the memcache module'

def extract(self, key):
stats = self.mc.get_stats()
try:
if key in stats[0][1]:
self.val[key] = stats[0][1][key]
return self.val[key]
except:
raise Exception, 'ERROR: key is not in stats!!!'

def main():
if len(sys.argv) == 1:
print "ERROR! Please enter a key"
elif len(sys.argv) == 2:
key = sys.argv[1]
a = GetMemStatus()
a.check()
print a.extract(key)

if __name__ == "__main__":
main()
Redis:
#!/usr/bin/env python
#coding=utf8

import sys
import os

class GetRedisStatus():
def __init__(self):
self.val = {}
def check(self):
try:
import redis
self.redis = redis.Redis('127.0.0.1', port=6379, password=None)
except:
raise Exception, 'Plugin needs the redis module'

def extract(self, key):
info = self.redis.info()
try:
if key in info:
self.val[key] = info[key]
return self.val[key]
except:
raise Exception, 'ERROR info not include this key!'

def main():
if len(sys.argv) == 1:
print "ERROR! Please enter a key"
elif len(sys.argv) == 2:
key = sys.argv[1]
a = GetRedisStatus()
a.check()
print a.extract(key)

if __name__ == "__main__":
main() 查看全部
Memcached:
#!/usr/bin/env python
#coding=utf8

import sys
import os

class GetMemStatus():
def __init__(self):
self.val = {}
def check(self):
try:
import memcache
self.mc = memcache.Client(['127.0.0.1:11211'], debug=0)
except:
raise Exception, 'Plugin needs the memcache module'

def extract(self, key):
stats = self.mc.get_stats()
try:
if key in stats[0][1]:
self.val[key] = stats[0][1][key]
return self.val[key]
except:
raise Exception, 'ERROR: key is not in stats!!!'

def main():
if len(sys.argv) == 1:
print "ERROR! Please enter a key"
elif len(sys.argv) == 2:
key = sys.argv[1]
a = GetMemStatus()
a.check()
print a.extract(key)

if __name__ == "__main__":
main()

Redis:
#!/usr/bin/env python
#coding=utf8

import sys
import os

class GetRedisStatus():
def __init__(self):
self.val = {}
def check(self):
try:
import redis
self.redis = redis.Redis('127.0.0.1', port=6379, password=None)
except:
raise Exception, 'Plugin needs the redis module'

def extract(self, key):
info = self.redis.info()
try:
if key in info:
self.val[key] = info[key]
return self.val[key]
except:
raise Exception, 'ERROR info not include this key!'

def main():
if len(sys.argv) == 1:
print "ERROR! Please enter a key"
elif len(sys.argv) == 2:
key = sys.argv[1]
a = GetRedisStatus()
a.check()
print a.extract(key)

if __name__ == "__main__":
main()

Python编码解析

编程语言采菊篱下 发表了文章 • 0 个评论 • 351 次浏览 • 2016-09-09 17:38 • 来自相关话题

一般我们在Python2.7的环境进行Python的编程的时候,一般头部会加#-*- coding:utf-8 -*- ​来声明编码类型为utf-8的编码,那为什么要声明,一定要声明吗?

针对如上问题我们先来讨论另外一个问题,为什么我们可以在显示器上能看到这些文字、数字、图片、字符、等等信息呢?大家都知道计算机本身只能识别 0  1 的组合,他们是怎么展示这些内容的呢?我们怎么和计算机去沟通呢?

如果我们使用0 1 的组合和计算机沟通你还能看到这些内容吗?还有一个问题就是01的组合我相信对于常人类都是没有办法看懂的。

那怎么办?如何让计算机理解我们的语言,并且我们能理解计算机的语言呢?

举个比较形象的例子,中英文词典对照表,这样我们就可以把中英文进行互相的翻译了呢?对不对!同理计算机也是这样的他需要一个标准的对照关系,那么这个标准最早叫什么呢?ASCII表




表格内容大致如下:
有特殊符号、大写字母、小写字母、数字(这里注意下0~9的数字是字符),在这些字符左边都有一个10进制的数字。但是对于10进制来说计算机他也是不能理解的,因为他只能理解0 1 ,但是10进制和2进制的转换就非常容易了!

举例来说:如果我在键盘上按一个A字母的时候那么实际是给计算机传输了一个数字65,通过这样的机制和计算机沟通,有了这个ASCII码表就可以和任何计算机进行沟通了。

这里在看个知识点:计算机中最小的单位是什么?bit   bit就咱们常说一位二进制,一位二进制要么是0 要么是 1

但是bit这个单位太小了,我们用字节(byte)来表示。他们是有换算的规则的(看下面的规则我想大家都不是很陌生对吧):8b = 1B #小b=bit ; 大B=byte
1024B = 1KB
1024KB = 1M
1024M = 1G
1024G = 1T 在存储英文的时候我们至少需要1个字节(一个字母),就是8位(bit),看下ASCII表中1个字节就可以表示所有的英文所需要的字符,是不非常高效!

为什么呢?早期的计算机的空间是非常宝贵的!

那你会发现1个字节8位,他能存储的最大数据是2的8次方-1 = 255,一个字节最多能表示255个字符 那西方国家他们使用了127个字符,那么剩下字符是做什么的呢?就是用来做扩展的,西方人考虑到还有其他国家。所以留下了扩展位。

但是呢有问题,计算机是西方人发明的,如果仅仅支持英文的话,这127个字符完全就可以表示所有英文中能用的的内容了。但是他没有考虑咱们大中国啊!ASCII到了中国之后发现:咱们中国最常用的中文都有6000多个完全不够用啊!

但是怎们办?中国人非常聪明:就在原有的扩展位中,扩展出自己的gbk、gb2312、gb2318字符编码。 

他是怎么扩展的呢?比如说在ASCII码中的128这个位置,这个位置又指定一张单独表,聪明吧! 其他国家也是这样设计的!

中国东亚大国是吧,我们国家比较NB,我要兼容其他国家的常用的编码!比如韩国日本,因为韩国和日本人家都有自己的编码,人家根本就不鸟你,举个例子来说,比如韩国的游戏,在中国下载安装之后会出现乱码的情况?什么鬼?

这种乱码的出现基本上就两种情况:
1、字符编码没有
2、字符编码冲突了,人家在写这个程序的时候指定的字符集和咱们使用的字符集的位置不对。 

你想想不光是亚洲国家这样,欧洲国家,非洲国家都会存在这个问题,基于这个乱象国际互联网组织就说你们各个国家都别搞了,我们给你们搞一个统一的,这个统一的是什么呢Unicode“万国编码”。

Unicode(统一码、万国码、单一码)是一种在计算机上使用的字符编码。Unicode 是为了解决传统的字符编码方案的局限而产生的,它为每种语言中的每个字符设定了统一并且唯一的二进制编码,规定虽有的字符和符号最少由 16 位来表示(2个字节),即:2 **16 = 65536, 注:此处说的的是最少2个字节,可能更多。

这里还有个问题:使用的字节增加了,那么造成的直接影响就是使用的空间就直接翻倍了!举例还说:同样是ABCD这些字符存储一篇相同的文章,使用ASCII码如果是1M的话,那么Unicode存储至少2M可能还会更多。

为了解决个问题就出现了:UTF-8编码

UTF-8编码:是对Unicode编码的压缩和优化,他不再使用最少使用2个字节,而是将所有的字符和符号进行分类:ascii码中的内容用1个字节保存、欧洲的字符用2个字节保存,东亚的字符用3个字节保存...

通过这种可扩展的方式来存储。

OK 上面了解了:
1、什么ASCII编码
2、什么Unicode编码
3、什么UTF-8编码

回顾下乱码的出现原因:1、没有字符集 2、字符集冲突

回过头来看下为什么需要在第二行加上指定编码呢?在2.x版本的Python中Pyton在解释.py文件的时候,默认是给他一个编码的就是ASCII码,so如果在2.7版本中如果你不指定编码并且在.py文件中写了一个ASCII码中没有的字符就会显示乱码 。

不过这个问题在Python3中就不存在了,因为在Python3中默认就是Unicode编码。

Python编码转换

有一个问题,既然有统一的Unicode编码了,为毛还需要编码转换?大家都统一一个编码不就可以了吗?

不要问我为什么,我问你们个问题,如果世界上出了一种世界语言,你会放弃中文吗?去使用这个世界通用语言吗?这就是个坑,是个遗留问题。

但是虽然以后可能世界语言会慢慢替代咱们常用的语言,大家以后沟通就使用世界语言就不会有沟通障碍了对吧。(就是举个例子)

还有一个情况是什么呢?韩国的游戏到中国来之后,是乱码?结合上一个回答咱们可以猜出:编写这个游戏的人在编写游戏的时候可能根本就没有考虑出口其他国家。那如果没有这个Unicode编码的话,到咱们这里来显示肯定是乱码是吧。

那就得需要通过转码把他们编码集,转换为Unicode(utf-8)编码集。这样他们就可以正常显示韩文了!(这里只是转编码集并不是翻译成中文不要弄混了~~!)

Python3中的编码转换
#在Python3中默认就是unicode编码#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

tim = '华仔'
#转为UTF-8编码
print(tim.encode('UTF-8'))

#转为GBK编码
print(tim.encode('GBK'))

#转为ASCII编码(报错为什么?因为ASCII码表中没有‘华仔’这个字符集~~)
print(tim.encode('ASCII'))



 
二、Python2.X中的编码转换
#因为在python2.X中默认是ASCII编码,你在文件中指定编码为UTF-8,但是UTF-8如果你想转GBK的话是不能直接转,需要Unicode做一个中间人转换角色。




#!/usr/bin/env python2
# _*_coding:utf-8_*_
# Author: Lucky.chen

import sys
print(sys.getdefaultencoding())


msg = "我爱北京天安门"
msg_gb2312 = msg.decode("utf-8").encode("gb2312")
gb2312_to_gbk = msg_gb2312.decode("gbk").encode("gbk")

print(msg)
print(msg_gb2312)
print(gb2312_to_gbk) 查看全部
一般我们在Python2.7的环境进行Python的编程的时候,一般头部会加#-*- coding:utf-8 -*- ​来声明编码类型为utf-8的编码,那为什么要声明,一定要声明吗?

针对如上问题我们先来讨论另外一个问题,为什么我们可以在显示器上能看到这些文字、数字、图片、字符、等等信息呢?大家都知道计算机本身只能识别 0  1 的组合,他们是怎么展示这些内容的呢?我们怎么和计算机去沟通呢?

如果我们使用0 1 的组合和计算机沟通你还能看到这些内容吗?还有一个问题就是01的组合我相信对于常人类都是没有办法看懂的。

那怎么办?如何让计算机理解我们的语言,并且我们能理解计算机的语言呢?

举个比较形象的例子,中英文词典对照表,这样我们就可以把中英文进行互相的翻译了呢?对不对!同理计算机也是这样的他需要一个标准的对照关系,那么这个标准最早叫什么呢?ASCII表
ascii.gif

表格内容大致如下:
有特殊符号、大写字母、小写字母、数字(这里注意下0~9的数字是字符),在这些字符左边都有一个10进制的数字。但是对于10进制来说计算机他也是不能理解的,因为他只能理解0 1 ,但是10进制和2进制的转换就非常容易了!

举例来说:如果我在键盘上按一个A字母的时候那么实际是给计算机传输了一个数字65,通过这样的机制和计算机沟通,有了这个ASCII码表就可以和任何计算机进行沟通了。

这里在看个知识点:计算机中最小的单位是什么?bit   bit就咱们常说一位二进制,一位二进制要么是0 要么是 1

但是bit这个单位太小了,我们用字节(byte)来表示。他们是有换算的规则的(看下面的规则我想大家都不是很陌生对吧):
8b = 1B  #小b=bit ; 大B=byte
1024B = 1KB
1024KB = 1M
1024M = 1G
1024G = 1T
在存储英文的时候我们至少需要1个字节(一个字母),就是8位(bit),看下ASCII表中1个字节就可以表示所有的英文所需要的字符,是不非常高效!

为什么呢?早期的计算机的空间是非常宝贵的!

那你会发现1个字节8位,他能存储的最大数据是2的8次方-1 = 255,一个字节最多能表示255个字符 那西方国家他们使用了127个字符,那么剩下字符是做什么的呢?就是用来做扩展的,西方人考虑到还有其他国家。所以留下了扩展位。

但是呢有问题,计算机是西方人发明的,如果仅仅支持英文的话,这127个字符完全就可以表示所有英文中能用的的内容了。但是他没有考虑咱们大中国啊!ASCII到了中国之后发现:咱们中国最常用的中文都有6000多个完全不够用啊!

但是怎们办?中国人非常聪明:就在原有的扩展位中,扩展出自己的gbk、gb2312、gb2318字符编码。 

他是怎么扩展的呢?比如说在ASCII码中的128这个位置,这个位置又指定一张单独表,聪明吧! 其他国家也是这样设计的!

中国东亚大国是吧,我们国家比较NB,我要兼容其他国家的常用的编码!比如韩国日本,因为韩国和日本人家都有自己的编码,人家根本就不鸟你,举个例子来说,比如韩国的游戏,在中国下载安装之后会出现乱码的情况?什么鬼?

这种乱码的出现基本上就两种情况:
1、字符编码没有
2、字符编码冲突了,人家在写这个程序的时候指定的字符集和咱们使用的字符集的位置不对。 

你想想不光是亚洲国家这样,欧洲国家,非洲国家都会存在这个问题,基于这个乱象国际互联网组织就说你们各个国家都别搞了,我们给你们搞一个统一的,这个统一的是什么呢Unicode“万国编码”

Unicode(统一码、万国码、单一码)是一种在计算机上使用的字符编码。Unicode 是为了解决传统的字符编码方案的局限而产生的,它为每种语言中的每个字符设定了统一并且唯一的二进制编码,规定虽有的字符和符号最少由 16 位来表示(2个字节),即:2 **16 = 65536, 注:此处说的的是最少2个字节,可能更多。

这里还有个问题:使用的字节增加了,那么造成的直接影响就是使用的空间就直接翻倍了!举例还说:同样是ABCD这些字符存储一篇相同的文章,使用ASCII码如果是1M的话,那么Unicode存储至少2M可能还会更多。

为了解决个问题就出现了:UTF-8编码

UTF-8编码:是对Unicode编码的压缩和优化,他不再使用最少使用2个字节,而是将所有的字符和符号进行分类:ascii码中的内容用1个字节保存、欧洲的字符用2个字节保存,东亚的字符用3个字节保存...

通过这种可扩展的方式来存储。

OK 上面了解了:
1、什么ASCII编码
2、什么Unicode编码
3、什么UTF-8编码

回顾下乱码的出现原因:1、没有字符集 2、字符集冲突

回过头来看下为什么需要在第二行加上指定编码呢?在2.x版本的Python中Pyton在解释.py文件的时候,默认是给他一个编码的就是ASCII码,so如果在2.7版本中如果你不指定编码并且在.py文件中写了一个ASCII码中没有的字符就会显示乱码 。

不过这个问题在Python3中就不存在了,因为在Python3中默认就是Unicode编码。


Python编码转换


有一个问题,既然有统一的Unicode编码了,为毛还需要编码转换?大家都统一一个编码不就可以了吗?

不要问我为什么,我问你们个问题,如果世界上出了一种世界语言,你会放弃中文吗?去使用这个世界通用语言吗?这就是个坑,是个遗留问题。

但是虽然以后可能世界语言会慢慢替代咱们常用的语言,大家以后沟通就使用世界语言就不会有沟通障碍了对吧。(就是举个例子)

还有一个情况是什么呢?韩国的游戏到中国来之后,是乱码?结合上一个回答咱们可以猜出:编写这个游戏的人在编写游戏的时候可能根本就没有考虑出口其他国家。那如果没有这个Unicode编码的话,到咱们这里来显示肯定是乱码是吧。

那就得需要通过转码把他们编码集,转换为Unicode(utf-8)编码集。这样他们就可以正常显示韩文了!(这里只是转编码集并不是翻译成中文不要弄混了~~!)

Python3中的编码转换
#在Python3中默认就是unicode编码
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

tim = '华仔'
#转为UTF-8编码
print(tim.encode('UTF-8'))

#转为GBK编码
print(tim.encode('GBK'))

#转为ASCII编码(报错为什么?因为ASCII码表中没有‘华仔’这个字符集~~)
print(tim.encode('ASCII'))
EncodeError.png

 
二、Python2.X中的编码转换
#因为在python2.X中默认是ASCII编码,你在文件中指定编码为UTF-8,但是UTF-8如果你想转GBK的话是不能直接转,需要Unicode做一个中间人转换角色。
decode.png

#!/usr/bin/env python2
# _*_coding:utf-8_*_
# Author: Lucky.chen

import sys
print(sys.getdefaultencoding())


msg = "我爱北京天安门"
msg_gb2312 = msg.decode("utf-8").encode("gb2312")
gb2312_to_gbk = msg_gb2312.decode("gbk").encode("gbk")

print(msg)
print(msg_gb2312)
print(gb2312_to_gbk)
条新动态, 点击查看
luotianshuai

luotianshuai 回答了问题 • 2015-12-14 12:59 • 3 个回复 不感兴趣

Python在生产环境都可以用来做什么?

赞同来自:

<Python能做什么Web程序

Python经常被用于Web开发。比如,通过mod_wsgi模块,Apache可以运行用Python编写的Web程序。使用Python语言 编写的Gunicorn作为Web服务器,也能够运行Python语言编写的Web... 显示全部 »
<Python能做什么Web程序

Python经常被用于Web开发。比如,通过mod_wsgi模块,Apache可以运行用Python编写的Web程序。使用Python语言 编写的Gunicorn作为Web服务器,也能够运行Python语言编写的Web程序。Python定义了WSGI标准应用接口来协调Http服务器与 基于Python的Web程序之间的沟通。一些Web框架,如Django、Pyramid、TurboGears、Tornado、web2py、 Zope、Flask等,可以让程序员轻松地开发和管理复杂的Web程序。

Python对于各种网络协议的支持很完善,因此经常被用于编写服务器软件、网络蠕虫。第三方库Twisted支持异步在线编写程序和多数标准的网 络协议(包含客户端和服务器),并且提供了多种工具,被广泛用于编写高性能的服务器软件。另有gevent这个流行的第三方库,同样能够支持高性能高并发 的网络开发。

GUI开发

Python本身包含的Tkinter库能够支持简单的GUI开发。但是越来越多的Python程序员选择wxPython或者PyQt等GUI包 来开发跨平台的桌面软件。使用它们开发的桌面软件运行速度快,与用户的桌面环境相契合。通过PyInstaller还能将程序发布为独立的安装程序包。

操作系统

在很多操作系统里,Python是标准的系统组件。大多数Linux发布版以及NetBSD、OpenBSD和Mac OS X都集成了Python,可以在终端机下直接运行Python。有一些Linux发布版的安装器使用Python语言编写,比如Ubuntu的 Ubiquity安装器、Red Hat Linux和Fedora的Anaconda安装器。Gentoo Linux使用Python来编写它的Portage包管理系统。Python标准库包含了多个调用作业系统功能的库。通过pywin32这个第三方软件 包,Python能够访问Windows的COM服务及其它Windows API。使用IronPython,Python程序能够直接调用.Net Framework。

其他

NumPy、SciPy、Matplotlib可以让Python程序员编写科学计算程序。有些公司会使用Scons代替make构建C 程序。

很多游戏使用C 编写图形显示等高性能模块,而使用Python或者Lua编写游戏的逻辑、服务器。相较于Python,Lua的功能更简单、体 积更小;而Python则支持更多的特性和数据类型。很多游戏,如EVE Online使用Python来处理游戏中繁多的逻辑。

YouTube、Google、Yahoo!、NASA都在内部大量地使用Python。OLPC的作业系统Sugar项目的大多数软件都是使用Python编写

 
所以他的应用范围大概分为:

数据分析
系统编程
组件集成
网络服务
图像处理
数值计算和科学计算>

以上是python能做的非常丰富!
采菊篱下

采菊篱下 回答了问题 • 2015-12-22 19:00 • 2 个回复 不感兴趣

Python的web框架有哪些

赞同来自:

Django 
Flask  
Pyramid
Tornado
Bottle
web.py
web2.py
更多信息查看:http://www.csdn.net/article/2013-08-08/2816494-6-pillars-of-python-as... 显示全部 »
Django 
Flask  
Pyramid
Tornado
Bottle
web.py
web2.py
更多信息查看:http://www.csdn.net/article/2013-08-08/2816494-6-pillars-of-python-assessment-of-best-python-web-frameworks
http://python.jobbole.com/72306/?replytocom=57112
 
fhand = urllib.request.urlopen('http://www.pythonlearn.com/code/mbox.txt').readlines()

for line in fhand:
# ...orfhand = urllib... 显示全部 »
fhand = urllib.request.urlopen('http://www.pythonlearn.com/code/mbox.txt').readlines()

for line in fhand:
# ...orfhand = urllib.request.urlopen('http://www.pythonlearn.com/code/mbox.txt').read().decode()

for line in fhand.split('\n'):
# ...
采菊篱下

采菊篱下 回答了问题 • 2016-12-27 11:38 • 2 个回复 不感兴趣

python FTP问题

赞同来自:

@Ansible 说的对,是你代码有问题,ftp这个对象不对。正常代码如下:
# 例:FTP编程
from ftplib import FTP

ftp = FTP()
timeout = 30
port = 21
ftp.c... 显示全部 »
@Ansible 说的对,是你代码有问题,ftp这个对象不对。正常代码如下:
# 例:FTP编程
from ftplib import FTP

ftp = FTP()
timeout = 30
port = 21
ftp.connect('192.168.1.188',port,timeout) # 连接FTP服务器
ftp.login('UserName','888888') # 登录
print ftp.getwelcome() # 获得欢迎信息
ftp.cwd('file/test') # 设置FTP路径
list = ftp.nlst() # 获得目录列表
for name in list:
print(name) # 打印文件名字
path = 'd:/data/' + name # 文件保存路径
f = open(path,'wb') # 打开要保存文件
filename = 'RETR ' + name # 保存FTP文件
ftp.retrbinary(filename,f.write) # 保存FTP上的文件
ftp.delete(name) # 删除FTP文件
ftp.storbinary('STOR '+filename, open(path, 'rb')) # 上传FTP文件
ftp.quit() # 退出FTP服务器 从上面代码你可以看出ftp.retrbinary()  这个方法ftp对象是------> ftp = FTP(),  而不是你代码里面的---->ftp = ftpconnect()
 
完整的参考模板:
#!/usr/bin/python
# -*- coding: utf-8 -*-
import ftplib
import os
import socket

HOST = 'ftp.mozilla.org'
DIRN = 'pub/mozilla.org/webtools'
FILE = 'bugzilla-3.6.7.tar.gz'
def main():
try:
f = ftplib.FTP(HOST)
except (socket.error, socket.gaierror):
print 'ERROR:cannot reach " %s"' % HOST
return
print '***Connected to host "%s"' % HOST

try:
f.login()
except ftplib.error_perm:
print 'ERROR: cannot login anonymously'
f.quit()
return
print '*** Logged in as "anonymously"'
try:
f.cwd(DIRN)
except ftplib.error_perm:
print 'ERRORL cannot CD to "%s"' % DIRN
f.quit()
return
print '*** Changed to "%s" folder' % DIRN
try:
#传一个回调函数给retrbinary() 它在每接收一个二进制数据时都会被调用
f.retrbinary('RETR %s' % FILE, open(FILE, 'wb').write)
except ftplib.error_perm:
print 'ERROR: cannot read file "%s"' % FILE
os.unlink(FILE)
else:
print '*** Downloaded "%s" to CWD' % FILE
f.quit()
return

if __name__ == '__main__':
main()

图解Python 集合

编程语言采菊篱下 发表了文章 • 2 个评论 • 382 次浏览 • 2016-08-10 23:41 • 来自相关话题

集合基本功能

集合是一个无序的,不重复的数据组合,用{}表示,它的主要作用如下:
去重,把一个列表变成集合,就会自动去重关系测试,测试两组数据之前的交集、差集、并集、子集等关系
 集合创建:
>>> set_job = set(['DEV', 'OPS', 'DBA', 'QA', 'Sales'])
>>> set_man = set(('lucky', 'jack', 'andy', 'tom', 'andy', 'jim'))
>>> print(set_job, type(set_job))
{'DEV', 'OPS', 'Sales', 'QA', 'DBA'} <class 'set'>
>>> print(set_man, type(set_man)) # 天生去重,只有一个andy了
{'andy', 'jack', 'lucky', 'tom', 'jim'} <class 'set'>
 
元素添加:
>>> set_job = set(['DEV', 'OPS', 'DBA', 'QA', 'Sales'])
>>> set_job.add('HR') # add方法只能添加一个
>>> print(set_job)
{'QA', 'HR', 'Sales', 'DEV', 'OPS', 'DBA'}
>>> set_job.update(['FD', 'MD', 'MD'])
>>> print(set_job)
{'QA', 'HR', 'Sales', 'DEV', 'MD', 'OPS', 'FD', 'DBA'}
>>> set_job.update(('AD', 'PD')) # update方法可以添加是列表或者元组,去重,如果添加的为一个单独字符串,则把字符串拆成字母添加到集合中
>>> print(set_job)
{'QA', 'HR', 'PD', 'Sales', 'DEV', 'MD', 'OPS', 'AD', 'FD', 'DBA'}
元素删除:
>>> set_job = {'QA', 'HR', 'PD', 'Sales', 'DEV', 'MD', 'OPS', 'AD', 'FD', 'DBA'}
>>> set_job.remove('PD') # 删除指定元素
>>> set_job.remove('xx') # 元素不存在则报错 KeyError
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'xx'
>>> print(set_job)
{'QA', 'HR', 'MD', 'DEV', 'Sales', 'OPS', 'AD', 'FD', 'DBA'}
>>> set_job.pop() # 随机删除一个元素
'QA'
>>> print(set_job)
{'HR', 'MD', 'DEV', 'Sales', 'OPS', 'AD', 'FD', 'DBA'}
>>> set_job.discard('OPS') # 指定删除
>>> set_job.discard('xxx') # 不存在返回None,不会报KeyError
>>> print(set_job)
{'HR', 'MD', 'DEV', 'Sales', 'AD', 'FD', 'DBA'}
其他:
>>> set_job = {'QA', 'HR', 'PD', 'Sales', 'DEV', 'MD', 'OPS', 'AD', 'FD', 'DBA'}
>>> len(set_job)  # 集合长度
10
>>> 'QA' in set_job  # 判断是否在集合中
True
>>> 'XXX' not in set_job # 不在集合中
True
>>> for i in set_job:   # 循环
...     print(i)

集合关系测试

交集:



>>> set_a = {5, 6, 7, 8, 9, 10}
>>> set_b = {1, 2, 3, 4, 5, 6}
>>> print(set_a.intersection(set_b)) # 常规方式
{5, 6}
>>> print(set_a & set_b) # 运算符(&)方式
{5, 6}
并集



>>> set_a = {5, 6, 7, 8, 9, 10}
>>> set_b = {1, 2, 3, 4, 5, 6}
>>> set_c = set_a.union(set_b)    # 关键字union做并集运算 先后顺序无关,谁并谁都可以
>>> print(set_c)
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
>>> 
>>> set_c = set_a | set_b     # 运算符关键符 | 做并集运算  先后顺序无关,谁并谁都可以
>>> print(set_c)
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

差集



>>> set_a = {5, 6, 7, 8, 9, 10}
>>> set_b = {1, 2, 3, 4, 5, 6}
>>> set_c = set_a - set_b # a集合跟b集合做差集 关键符 -
>>> print(set_c)
{8, 9, 10, 7}
>>> set_d = set_b - set_a # b集合跟a集合做差集 关键符 -
>>> print(set_d)
{1, 2, 3, 4}
>>> set_c = set_a.difference(set_b) # a集合跟b集合做差集 关键字difference
>>> print(set_c)
{8, 9, 10, 7}
>>> set_d = set_b.difference(set_a) # b集合跟a集合做差集 关键字difference
>>> print(set_d)
{1, 2, 3, 4}
 
子集父集




拿苹果来打比方就是,把苹果掰开,然后掰开的一小部分就是子集,然后整个苹果就是父集
>>> set_a = {5, 6, 7, 8, 9, 10}
>>> set_b = {1, 2, 3, 4, 5, 6}
>>> set_c = {7, 8, 9, 10}
>>> set_d = {1, 2, 3, 4}
>>> set_e = {5, 6}
>>> set_f = {11, 12, 13, 14, 15, 16}
>>> set_c.issubset(set_a) # 测试集合c是否是集合a的子集 放回布尔值 关键字issubset
True
>>> set_d.issubset(set_b) # 测试集合d是否是集合b的子集 返回布尔值 issubset
True
>>> set_e.issubset(set_a)
True
>>> set_e.issubset(set_b)
True
>>> set_e <= set_a # 测试集合e是否是集合a的子集 关键符 <=
True
>>> set_e <= set_b
True
>>> set_f.issuperset(set_a) # 测试f集合是否是a集合的父集
False
>>> set_a.issuperset(set_e) # 测试a集合是否是集合e的父集 关键字issuperset
True
>>> set_b >= set_e # 测试集合b是否是集合e的父集 关键符 >=
True
>>> set_b >= set_d
True
对称差集
对称差集就是两个集合去掉相同的部分,然后剩下的所有元素组成的集合



>>> set_a = {5, 6, 7, 8, 9, 10}
>>> set_b = {1, 2, 3, 4, 5, 6}
>>> set_c = set_a.symmetric_difference(set_b) # 集合a和集合b做对称差集 关键字symmetric_difference
>>> print(set_c)
{1, 2, 3, 4, 7, 8, 9, 10}
>>> set_c = set_a ^ set_b # 集合a和集合b做对称差集 关键符 ^
>>> print(set_c)
{1, 2, 3, 4, 7, 8, 9, 10}
>>> set_c = set_b ^ set_a
>>> print(set_c)
{1, 2, 3, 4, 7, 8, 9, 10}
所有方法:
class set(object):
"""
set() -> new empty set object
set(iterable) -> new set object

Build an unordered collection of unique elements.
"""
def add(self, *args, **kwargs): # real signature unknown
"""
Add an element to a set.

This has no effect if the element is already present.
"""
pass

def clear(self, *args, **kwargs): # real signature unknown
""" Remove all elements from this set. """
pass

def copy(self, *args, **kwargs): # real signature unknown
""" Return a shallow copy of a set. """
pass

def difference(self, *args, **kwargs): # real signature unknown
"""
Return the difference of two or more sets as a new set.

(i.e. all elements that are in this set but not the others.)
"""
pass

def difference_update(self, *args, **kwargs): # real signature unknown
""" Remove all elements of another set from this set. """
pass

def discard(self, *args, **kwargs): # real signature unknown
"""
Remove an element from a set if it is a member.

If the element is not a member, do nothing.
"""
pass

def intersection(self, *args, **kwargs): # real signature unknown
"""
Return the intersection of two sets as a new set.

(i.e. all elements that are in both sets.)
"""
pass

def intersection_update(self, *args, **kwargs): # real signature unknown
""" Update a set with the intersection of itself and another. """
pass

def isdisjoint(self, *args, **kwargs): # real signature unknown
""" Return True if two sets have a null intersection. """
pass

def issubset(self, *args, **kwargs): # real signature unknown
""" Report whether another set contains this set. """
pass

def issuperset(self, *args, **kwargs): # real signature unknown
""" Report whether this set contains another set. """
pass

def pop(self, *args, **kwargs): # real signature unknown
"""
Remove and return an arbitrary set element.
Raises KeyError if the set is empty.
"""
pass

def remove(self, *args, **kwargs): # real signature unknown
"""
Remove an element from a set; it must be a member.

If the element is not a member, raise a KeyError.
"""
pass

def symmetric_difference(self, *args, **kwargs): # real signature unknown
"""
Return the symmetric difference of two sets as a new set.

(i.e. all elements that are in exactly one of the sets.)
"""
pass

def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
""" Update a set with the symmetric difference of itself and another. """
pass

def union(self, *args, **kwargs): # real signature unknown
"""
Return the union of sets as a new set.

(i.e. all elements that are in either set.)
"""
pass

def update(self, *args, **kwargs): # real signature unknown
""" Update a set with the union of itself and others. """
pass 查看全部


集合基本功能


集合是一个无序的,不重复的数据组合,用{}表示,它的主要作用如下:
  1. 去重,把一个列表变成集合,就会自动去重
  2. 关系测试,测试两组数据之前的交集、差集、并集、子集等关系

 集合创建:
>>> set_job = set(['DEV', 'OPS', 'DBA', 'QA', 'Sales'])
>>> set_man = set(('lucky', 'jack', 'andy', 'tom', 'andy', 'jim'))
>>> print(set_job, type(set_job))
{'DEV', 'OPS', 'Sales', 'QA', 'DBA'} <class 'set'>
>>> print(set_man, type(set_man)) # 天生去重,只有一个andy了
{'andy', 'jack', 'lucky', 'tom', 'jim'} <class 'set'>

 
元素添加:
>>> set_job = set(['DEV', 'OPS', 'DBA', 'QA', 'Sales'])
>>> set_job.add('HR') # add方法只能添加一个
>>> print(set_job)
{'QA', 'HR', 'Sales', 'DEV', 'OPS', 'DBA'}
>>> set_job.update(['FD', 'MD', 'MD'])
>>> print(set_job)
{'QA', 'HR', 'Sales', 'DEV', 'MD', 'OPS', 'FD', 'DBA'}
>>> set_job.update(('AD', 'PD')) # update方法可以添加是列表或者元组,去重,如果添加的为一个单独字符串,则把字符串拆成字母添加到集合中
>>> print(set_job)
{'QA', 'HR', 'PD', 'Sales', 'DEV', 'MD', 'OPS', 'AD', 'FD', 'DBA'}

元素删除:
>>> set_job = {'QA', 'HR', 'PD', 'Sales', 'DEV', 'MD', 'OPS', 'AD', 'FD', 'DBA'}
>>> set_job.remove('PD') # 删除指定元素
>>> set_job.remove('xx') # 元素不存在则报错 KeyError
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'xx'
>>> print(set_job)
{'QA', 'HR', 'MD', 'DEV', 'Sales', 'OPS', 'AD', 'FD', 'DBA'}
>>> set_job.pop() # 随机删除一个元素
'QA'
>>> print(set_job)
{'HR', 'MD', 'DEV', 'Sales', 'OPS', 'AD', 'FD', 'DBA'}
>>> set_job.discard('OPS') # 指定删除
>>> set_job.discard('xxx') # 不存在返回None,不会报KeyError
>>> print(set_job)
{'HR', 'MD', 'DEV', 'Sales', 'AD', 'FD', 'DBA'}

其他:
>>> set_job = {'QA', 'HR', 'PD', 'Sales', 'DEV', 'MD', 'OPS', 'AD', 'FD', 'DBA'}
>>> len(set_job)  # 集合长度
10
>>> 'QA' in set_job  # 判断是否在集合中
True
>>> 'XXX' not in set_job # 不在集合中
True
>>> for i in set_job:   # 循环
...     print(i)


集合关系测试


交集:
intercaiton.png
>>> set_a = {5, 6, 7, 8, 9, 10}
>>> set_b = {1, 2, 3, 4, 5, 6}
>>> print(set_a.intersection(set_b)) # 常规方式
{5, 6}
>>> print(set_a & set_b) # 运算符(&)方式
{5, 6}

并集
bingji.png
>>> set_a = {5, 6, 7, 8, 9, 10}
>>> set_b = {1, 2, 3, 4, 5, 6}
>>> set_c = set_a.union(set_b)    # 关键字union做并集运算 先后顺序无关,谁并谁都可以
>>> print(set_c)
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
>>> 
>>> set_c = set_a | set_b     # 运算符关键符 | 做并集运算  先后顺序无关,谁并谁都可以
>>> print(set_c)
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

差集
chaji.png
>>> set_a = {5, 6, 7, 8, 9, 10}
>>> set_b = {1, 2, 3, 4, 5, 6}
>>> set_c = set_a - set_b # a集合跟b集合做差集 关键符 -
>>> print(set_c)
{8, 9, 10, 7}
>>> set_d = set_b - set_a # b集合跟a集合做差集 关键符 -
>>> print(set_d)
{1, 2, 3, 4}
>>> set_c = set_a.difference(set_b) # a集合跟b集合做差集 关键字difference
>>> print(set_c)
{8, 9, 10, 7}
>>> set_d = set_b.difference(set_a) # b集合跟a集合做差集 关键字difference
>>> print(set_d)
{1, 2, 3, 4}

 
子集父集
fuziji.png

拿苹果来打比方就是,把苹果掰开,然后掰开的一小部分就是子集,然后整个苹果就是父集
>>> set_a = {5, 6, 7, 8, 9, 10}
>>> set_b = {1, 2, 3, 4, 5, 6}
>>> set_c = {7, 8, 9, 10}
>>> set_d = {1, 2, 3, 4}
>>> set_e = {5, 6}
>>> set_f = {11, 12, 13, 14, 15, 16}
>>> set_c.issubset(set_a) # 测试集合c是否是集合a的子集 放回布尔值 关键字issubset
True
>>> set_d.issubset(set_b) # 测试集合d是否是集合b的子集 返回布尔值 issubset
True
>>> set_e.issubset(set_a)
True
>>> set_e.issubset(set_b)
True
>>> set_e <= set_a # 测试集合e是否是集合a的子集 关键符 <=
True
>>> set_e <= set_b
True
>>> set_f.issuperset(set_a) # 测试f集合是否是a集合的父集
False
>>> set_a.issuperset(set_e) # 测试a集合是否是集合e的父集 关键字issuperset
True
>>> set_b >= set_e # 测试集合b是否是集合e的父集 关键符 >=
True
>>> set_b >= set_d
True

对称差集
对称差集就是两个集合去掉相同的部分,然后剩下的所有元素组成的集合
duichengchaji.png
>>> set_a = {5, 6, 7, 8, 9, 10}
>>> set_b = {1, 2, 3, 4, 5, 6}
>>> set_c = set_a.symmetric_difference(set_b) # 集合a和集合b做对称差集 关键字symmetric_difference
>>> print(set_c)
{1, 2, 3, 4, 7, 8, 9, 10}
>>> set_c = set_a ^ set_b # 集合a和集合b做对称差集 关键符 ^
>>> print(set_c)
{1, 2, 3, 4, 7, 8, 9, 10}
>>> set_c = set_b ^ set_a
>>> print(set_c)
{1, 2, 3, 4, 7, 8, 9, 10}

所有方法:
class set(object):
"""
set() -> new empty set object
set(iterable) -> new set object

Build an unordered collection of unique elements.
"""
def add(self, *args, **kwargs): # real signature unknown
"""
Add an element to a set.

This has no effect if the element is already present.
"""
pass

def clear(self, *args, **kwargs): # real signature unknown
""" Remove all elements from this set. """
pass

def copy(self, *args, **kwargs): # real signature unknown
""" Return a shallow copy of a set. """
pass

def difference(self, *args, **kwargs): # real signature unknown
"""
Return the difference of two or more sets as a new set.

(i.e. all elements that are in this set but not the others.)
"""
pass

def difference_update(self, *args, **kwargs): # real signature unknown
""" Remove all elements of another set from this set. """
pass

def discard(self, *args, **kwargs): # real signature unknown
"""
Remove an element from a set if it is a member.

If the element is not a member, do nothing.
"""
pass

def intersection(self, *args, **kwargs): # real signature unknown
"""
Return the intersection of two sets as a new set.

(i.e. all elements that are in both sets.)
"""
pass

def intersection_update(self, *args, **kwargs): # real signature unknown
""" Update a set with the intersection of itself and another. """
pass

def isdisjoint(self, *args, **kwargs): # real signature unknown
""" Return True if two sets have a null intersection. """
pass

def issubset(self, *args, **kwargs): # real signature unknown
""" Report whether another set contains this set. """
pass

def issuperset(self, *args, **kwargs): # real signature unknown
""" Report whether this set contains another set. """
pass

def pop(self, *args, **kwargs): # real signature unknown
"""
Remove and return an arbitrary set element.
Raises KeyError if the set is empty.
"""
pass

def remove(self, *args, **kwargs): # real signature unknown
"""
Remove an element from a set; it must be a member.

If the element is not a member, raise a KeyError.
"""
pass

def symmetric_difference(self, *args, **kwargs): # real signature unknown
"""
Return the symmetric difference of two sets as a new set.

(i.e. all elements that are in exactly one of the sets.)
"""
pass

def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
""" Update a set with the symmetric difference of itself and another. """
pass

def union(self, *args, **kwargs): # real signature unknown
"""
Return the union of sets as a new set.

(i.e. all elements that are in either set.)
"""
pass

def update(self, *args, **kwargs): # real signature unknown
""" Update a set with the union of itself and others. """
pass

Python菜鸟之路基础篇(一)

编程语言采菊篱下 发表了文章 • 2 个评论 • 639 次浏览 • 2016-07-26 00:55 • 来自相关话题

Hello World

学习任何一门语言,我想大家写的以一句就是hello world吧,下面我们来看看Python的hello world
创建一个hello.py的文件:print ("Hello World")然后执行命令:python hello.py ,输出crh:Python crh$ python3 hello.py
Hello World
 
Python执行过程为: 把代码读到内存 ---->词法语法分析 ---->放到编译器 ----> 生成字节码 ---->执行字节码 ---->生成机器码---->CPU执行,图示如下:




指定解释器
在上面情况,我们指定Python3 来执行hello.py
如果想要类似于执行shell脚本一样执行python脚本,例: ./hello.py ,那么就需要在 hello.py 文件的头部指定解释器,如下:crh:Python crh$ cat hello.py
#!/usr/bin/env python3

print ("Hello World")像上面这样,然后给hello.py文件添加执行权限(chmod +x hello.py)就可以像执行shell脚本一样./hello.py 即可。
***像上面是利用Linux env命令通过环境变量去找到你想用的Python命令,如果你指定用某个Python版本的话一可以写绝对路径,比如:/usr/bin/python or /usr/local/bin/python3
 
在交互器中执行
除了把程序写在文件里,还可以直接调用python自带的交互器运行代码,进行调试和测试crh:Python crh$ python3
Python 3.5.1 (default, Dec 26 2015, 18:08:53)
[GCC 4.2.1 Compatible Apple LLVM 7.0.2 (clang-700.1.81)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
[quote]>> print ("Hello World")
Hello World
>>>  

变量

在一个计算机程序中引用变量是用来存储信息和操作的。他们还提供一种标签数据与一个描述性的名称,所以我们的程序可以被读者和我们自己更清楚地理解。它有助于认为变量保存信息的容器。他们的唯一目的是标签和数据存储在内存中。这些数据可以通过使用程序引用。
 
声明变量#_[i]_coding:utf-8_[/i]_

name = "Lucky chen"如上面所示声明了一个变量name,他的值是"Lucky chen"
 
我们再来看一组连续赋值的过程:>>> name = "crh"
>>> name1 = name
>>> print (name,name1)
crh crh
>>> name = "Lucky"
>>> print (name1,name)
crh Lucky如上所示,为什么name1 = name 当后续把name变量的值改变了,为什么name1的值没有随着改变呢,如下看看你就明白了:>>> name = "crh" #首先在内存中打开一块内存空间存储name变量值
>>> id(name) #查看变量name的内存地址
4412833952
>>> name1 = name #把我们把name赋值给name1变量
>>> id(name1) #然后查看name1变量的内存地址 (跟name变量的内存地址一样)
4412833952
>>> name = "lucky" #重新打开一个内存空间存储name的变量值
>>> id(name) #查看新的name变量值的内存地址
4412834176
>>> id(name1) #查看name1变量内存地址
4412833952如上所示,我们可以看出,nama1其实就是借助name变量做一个变量的赋值,通过name变量得到值所在内存中的内存地址后,从而变成了一个正常的赋值过程。而不换随着name变量的内存空间地址的改变而改变。示意图如下:





交互输入

用户输入就是程序和用户的交互,程序等待用户输入一个参数然后重新继续进行:#!/usr/bin/env python3
#Authe: Lucky.chen
#_[i]_coding:utf-8_[/i]_

name = input("Please enter your name:")
print ("[size=16]#",name,"[/size]#")



如上图所示,默认Python3下的input函数用户输入的所有东西都当做字符串处理,所以你输入的年龄希望它是整数类型,还需要int()一下。
 
在python2中input这个函数,用户默认输入的是什么格式的参数,Python就当作是什么类型处理,Python2中获取用户输入参数的函数还有一个叫做raw_input(),这个函数默认也是字符串处理。可以看出Python3为了简洁统一,在Python3中已经不存在了raw_input()函数,input()一个函数完全可以做到所有使用。
 
平常如果我们用针对密码、密码串之类的交互的话,一般用户的输入时隐藏或者*****的,输入密码时,在Python下如果你需要你输入的东西不可见,可以利用getpass 模块中的 getpass方法来处理:#!/usr/bin/env python3
#Authe: Lucky.chen
#_[i]_coding:utf-8_[/i]_[/quote]

#导入getpass模块
import getpass

# 将用户输入的内容赋值给 name 变量
pwd = getpass.getpass("请输入密码:")

# 打印输入的内容
print("Password is [size=16]",pwd,"***print end")[/size]

#比如我输入110119,执行过程和结果如下:
请输入密码:
Password is [size=16] 110119 ***print end[/size]

注释和拼接

注释:
单行注释:# 开头就好,跟shell一样
多行注释:成对的三个单引号 ''' 注释内容 ''' 或者 成对的三个双引号 """  注释内容  """>>> ''' My name is lucky '''
' My name is lucky '
[quote]>> """ My age is 23 """
' My age is 23 '
>>> # Good Idea
...
>>> msg = """ My info is :
... age: 23
... name: lucky
... job: IT"""
>>> print (msg)
My info is :
age: 23
name: lucky
job: IT
>>>
 
拼接:
1、难受的 "+" >>> name = "lucky"
>>> age = 23
>>> job = "IT"
>>>
>>> msg = """ Info of """ +name + """
... Name:""" +name + """
... Age:""" +age + """
... Job:""" +job
Traceback (most recent call last):
File "<stdin>", line 4, in <module>
TypeError: Can't convert 'int' object to str implicitly
>>>
>>> name = "lucky"
>>> age = "23"
>>> job = "IT"
>>> msg = """ Info of """ +name + """
... Name:""" +name + """
... Age:""" +age + """
... Job:""" +job
>>> print (msg)
Info of lucky
Name:lucky
Age:23
Job:IT
>>> 如上所示 "+"拼接只能是字符串,如果是整型、或者是浮点都会报错。
 
2、百分号(%)
 Code:#!/usr/bin/env python3.5
#auther: lucky.chen[/quote]

name = input("Please input your name: ")
age = input("Please input your age:")
job = input("Please input your job:")
salary = input("Please input your salary:")

msg = """------------ info of %s
Name: %s
Age: %s
Job: %s
Salary: %s
""" % (name,name,age,job,salary)

print (msg)Result:Please input your name: lucky
Please input your age:23
Please input your job:IT
Please input your salary:40000
------------ info of lucky
Name: lucky
Age: 23
Job: IT
Salary: 40000
 3、使用format函数
情况一:使用变量格式化
Code:#!/usr/bin/env python3.5
#auther: lucky.chen

name = input("Please input your name: ")
age = input("Please input your age:")
job = input("Please input your job:")
salary = input("Please input your salary:")

msg = """------------ info of {_Name}
Name: {_Name}
Age: {_Age}
Job: {_Job}
Salary: {_Salary}
""".format(_Name=name,_Age=age,_Job=job,_Salary=salary)

print (msg)Result:Please input your name: crh
Please input your age:23
Please input your job:IT
Please input your salary:45000
------------ info of crh
Name: crh
Age: 23
Job: IT
Salary: 45000情况二:使用下脚标#!/usr/bin/env python3.5
#auther: lucky.chen

name = input('please input your name:')
age = input('please input your age:')
job = input('please input your job:')
salary = input('please input your salary:')
msg = '''
------------info of {0}-----------
Name: {0}
Age: {1}
Job: {2}
Salary: {3}
'''.format(name,age,job,salary)
print (msg)Result:please input your name:chenronghua
please input your age:23
please input your job:OPS
please input your salary:50000

------------info of chenronghua-----------
Name: chenronghua
Age: 23
Job: OPS
Salary: 50000format是比较好的方式,有时候我们必须使用format方法,所以掌握了format就好。
 

流程控制

一、流程控制这里先介绍 if ...... else  and if ...... elif ..... else 
 
1、if ..... else(用户认证登录)
Code:#!/usr/bin/env python3.5
#auther: lucky.chen

name = input("Please input your name:")
passwd = input("Please input your password:")

if name == "crh" and passwd == "123456":
print (" \033[32mWelcome login OPS Management platform\033[0m ")
else:
print ("\033[31mYour UserName or Password Error\033[0m")Result:Please input your name:crh
Please input your password:34
Your UserName or Password Error
 2、if ..... elfi ...... else
Code:#!/usr/bin/env python3.5
#auther: lucky.chen

age = int(input("Pleast input your age:"))

if age < 18:
print (" \033[32m You're too young \033[0m ")
elif age > 18 and age < 30:
print ("\033[31m You still have many chance comes at a time when youth waiting for you \033[0m")
else:
print ("\033[33m Before you is too old to do \033[0m")Result:Pleast input your age:23
You still have many chance comes at a time when youth waiting for you
 二、for 循环遍历#!/usr/bin/env python3.5
#auther: lucky.chen

for num in range(5):
print ("loop is:",num)

# Result is:
loop is: 0
loop is: 1
loop is: 2
loop is: 3
loop is: 4range函数也可以设置步长值,比如我们要打印出1-10中的所有偶数(默认步长为1)#!/usr/bin/env python3.5
#auther: lucky.chen

for num in range(0,11,2):
print ("loop is:",num)

# Result
loop is: 0
loop is: 2
loop is: 4
loop is: 6
loop is: 8
loop is: 10除掉range函数我们还可以使用xrange函数,为什么要这里要介绍xrange呢,因为xrange相对于range来说性能比较优越,因为xrange不需要一上来就开辟一块很大的内存空间,具体可以参考我之前发布的文章:Python中xrange和range的异同 ,但是好像Python3.*中没有了xrange函数。
 
for...else...循环介绍,不止if中有else,在for循环中也是可以用else的,在for循环中的else就是当前面的循环正常执行完后,没有跳出,后面的else代码将被执行。crh:Python crh$ cat for.py
#!/usr/bin/env python3
#Auther: lucky.chen

for num in range(4):
print ("Loop is:",num)
else:
print ("normal")
crh:Python crh$ ./for.py
Loop is: 0
Loop is: 1
Loop is: 2
Loop is: 3
normal
crh:Python crh$ crh:Python crh$ cat for.py
#!/usr/bin/env python3
#Auther: lucky.chen

for num in range(4):
if num > 2:
break
print ("Loop is:",num)
else:
print ("normal")
crh:Python crh$ ./for.py
Loop is: 0
Loop is: 1
Loop is: 2
crh:Python crh$三、while循环遍历
 
while 循环它的原理是:当条件为真的时候运行,当条件为假的时候停止!没有一个规定次数,不设置条件就永远循环下去。#!/usr/bin/env python3.5
#auther: lucky.chen

import time
count = 0
while True:
count +=1
print ("loop",count)
time.sleep(3)
#这个循环3秒钟自+1后,无线循环只要这个条件为”真“,就无限循环下去#!/usr/bin/env python3.5
#auther: lucky.chen

import time
num = 0

while num < 3:
num +=1
print ("Num is:",num)
time.sleep(3)

#这个循环每3秒循环一次,当条件num < 3的时候为真(自己设置的条件),当num不小于3的时候为假(false)循环停止.While ...... else#!/usr/bin/env python3.5
#auther: lucky.chen

while 1:
if num == 4:
print ("I think stop")
break
print (num)
num += 1
else:
print ("stop")
 四、break和continue介绍break在循环中的作用是跳出所在的循环体,不在进行循环,而continue是跳出所在循环体中的本次循环,后续没有完的循环继续。Code:#!/usr/bin/env python3.5
#auther: lucky.chen

num = 1

print ("test break for loop start")
for n in range(5):
if n == num:
break
print (n)

print ("\n")

print ("test continue for loop start")
for n in range(5):
if n == num:
continue
print (n)Result:test break for loop start
0


test continue for loop start
0
2
3
4
猜数字游戏:#!/usr/bin/env python3.5
#auther: lucky.chen

#load module (random)
import random

TryNum = 0
RandNum = random.randrange(10)
print (RandNum)


while TryNum < 3:
GuessNum = int(input("请猜测从0到9之间的一个中奖数字:"))

if GuessNum >= 10:
print ("你输入的数字不在中奖号码范围内,请重新输入!")
continue

if GuessNum == RandNum:
print ("恭喜你猜对了,你将获得小米电视一台!")
break

elif GuessNum > RandNum:
print ("你猜的数字太大了可以再往小了猜")

else:
print ("你猜的数字太小了可以往大了猜")

TryNum += 1

else:
print ("不好意思你三次机会用完了,Game over!")

#先随机到0-9中筛选出以为数字,然后用户三次机会猜测一个中奖号码,如果用户输入的数字不在范围内,则让用户再次输入.Result:4
请猜测从0到9之间的一个中奖数字:11
你输入的数字不在中奖号码范围内,请重新输入!
请猜测从0到9之间的一个中奖数字:11
你输入的数字不在中奖号码范围内,请重新输入!
请猜测从0到9之间的一个中奖数字:11
你输入的数字不在中奖号码范围内,请重新输入!
请猜测从0到9之间的一个中奖数字:11
你输入的数字不在中奖号码范围内,请重新输入!
请猜测从0到9之间的一个中奖数字:2
你猜的数字太小了可以往大了猜
请猜测从0到9之间的一个中奖数字:5
你猜的数字太大了可以再往小了猜
请猜测从0到9之间的一个中奖数字:4
恭喜你猜对了,你将获得小米电视一台!

 
五、嵌套循环
While for:#!/usr/bin/env python3.5
#auther: lucky.chen

count = 1

while count < 4:
print("count var lt 4")

print ("#########################[size=16]#")[/size]

for n in range(3):
print ("for num is:",n)

print ("****************************")
count += 1Result:count var lt 4
#########################[size=16]#[/size]
for num is: 0
for num is: 1
for num is: 2
****************************
count var lt 4
#########################[size=16]#[/size]
for num is: 0
for num is: 1
for num is: 2
****************************
count var lt 4
#########################[size=16]#[/size]
for num is: 0
for num is: 1
for num is: 2
****************************
 死循环:#!/usr/bin/env python3.5
#auther: lucky.chen
import time

while True:
print ("One Loop")
time.sleep(1)

while True:
print ("Two Loop")
time.sleep(1)

while True:
print ("Three Loop")
time.sleep(1)
#这是一个死循环,第一次执行这段code的时候,依次往下执行,单到了第三个while的时候,就一直是true,所以一直在执行第三个while下的code.

#结果如下:
One Loop
Two Loop
Three Loop
Three Loop
Three Loop
Three Loop
..........
..........如上我们给出了一个死循环的例子,但是如果如果我们需要跳出循环应该怎么做,如果用break可以做到吗?
1、第一个while后加break分析




 
2、第二个while后加break分析




 
3、第三个while后加break分析




 
既然存在这种死循环的那我们有什么办法可以跳出呢?那就是打标志,标志位
Code:#!/usr/bin/env python3.5
#auther: lucky.chen

count = 0
while True:
print ("我是第一层")
jump_1_flag = False

while True:
print ("我是第二层")
jump_2_flag = False

while True:
count += 1
print ("我是第三层")

if count > 3:
jump_2_flag = True
break

if jump_2_flag:
print ("第三层跳到我这里来了,我也要跳到第一层")
jump_1_flag = True
break

if jump_1_flag:
print ("第二层和第三层跳到第一层了,我也要跳")
break分析和结果: 查看全部


Hello World


学习任何一门语言,我想大家写的以一句就是hello world吧,下面我们来看看Python的hello world
创建一个hello.py的文件:
print ("Hello World")
然后执行命令:python hello.py ,输出
crh:Python crh$ python3 hello.py 
Hello World

 
Python执行过程为: 把代码读到内存 ---->词法语法分析 ---->放到编译器 ----> 生成字节码 ---->执行字节码 ---->生成机器码---->CPU执行,图示如下:
workfollow.png

指定解释器
在上面情况,我们指定Python3 来执行hello.py
如果想要类似于执行shell脚本一样执行python脚本,例: ./hello.py ,那么就需要在 hello.py 文件的头部指定解释器,如下:
crh:Python crh$ cat hello.py 
#!/usr/bin/env python3

print ("Hello World")
像上面这样,然后给hello.py文件添加执行权限(chmod +x hello.py)就可以像执行shell脚本一样./hello.py 即可。
***像上面是利用Linux env命令通过环境变量去找到你想用的Python命令,如果你指定用某个Python版本的话一可以写绝对路径,比如:/usr/bin/python or /usr/local/bin/python3
 
在交互器中执行
除了把程序写在文件里,还可以直接调用python自带的交互器运行代码,进行调试和测试
crh:Python crh$ python3
Python 3.5.1 (default, Dec 26 2015, 18:08:53)
[GCC 4.2.1 Compatible Apple LLVM 7.0.2 (clang-700.1.81)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
[quote]>> print ("Hello World")
Hello World
>>>
 


变量


在一个计算机程序中引用变量是用来存储信息和操作的。他们还提供一种标签数据与一个描述性的名称,所以我们的程序可以被读者和我们自己更清楚地理解。它有助于认为变量保存信息的容器。他们的唯一目的是标签和数据存储在内存中。这些数据可以通过使用程序引用。
 
声明变量
#_[i]_coding:utf-8_[/i]_

name = "Lucky chen"
如上面所示声明了一个变量name,他的值是"Lucky chen"
 
我们再来看一组连续赋值的过程:
>>> name = "crh"
>>> name1 = name
>>> print (name,name1)
crh crh
>>> name = "Lucky"
>>> print (name1,name)
crh Lucky
如上所示,为什么name1 = name 当后续把name变量的值改变了,为什么name1的值没有随着改变呢,如下看看你就明白了:
>>> name = "crh"     #首先在内存中打开一块内存空间存储name变量值
>>> id(name) #查看变量name的内存地址
4412833952
>>> name1 = name #把我们把name赋值给name1变量
>>> id(name1) #然后查看name1变量的内存地址 (跟name变量的内存地址一样)
4412833952
>>> name = "lucky" #重新打开一个内存空间存储name的变量值
>>> id(name) #查看新的name变量值的内存地址
4412834176
>>> id(name1) #查看name1变量内存地址
4412833952
如上所示,我们可以看出,nama1其实就是借助name变量做一个变量的赋值,通过name变量得到值所在内存中的内存地址后,从而变成了一个正常的赋值过程。而不换随着name变量的内存空间地址的改变而改变。示意图如下:
var.png


交互输入


用户输入就是程序和用户的交互,程序等待用户输入一个参数然后重新继续进行:
#!/usr/bin/env python3
#Authe: Lucky.chen
#_[i]_coding:utf-8_[/i]_

name = input("Please enter your name:")
print ("[size=16]#",name,"[/size]#")
input.png

如上图所示,默认Python3下的input函数用户输入的所有东西都当做字符串处理,所以你输入的年龄希望它是整数类型,还需要int()一下。
 
在python2中input这个函数,用户默认输入的是什么格式的参数,Python就当作是什么类型处理,Python2中获取用户输入参数的函数还有一个叫做raw_input(),这个函数默认也是字符串处理。可以看出Python3为了简洁统一,在Python3中已经不存在了raw_input()函数,input()一个函数完全可以做到所有使用。
 
平常如果我们用针对密码、密码串之类的交互的话,一般用户的输入时隐藏或者*****的,输入密码时,在Python下如果你需要你输入的东西不可见,可以利用getpass 模块中的 getpass方法来处理:
#!/usr/bin/env python3
#Authe: Lucky.chen
#_[i]_coding:utf-8_[/i]_[/quote]

#导入getpass模块
import getpass

# 将用户输入的内容赋值给 name 变量
pwd = getpass.getpass("请输入密码:")

# 打印输入的内容
print("Password is [size=16]",pwd,"***print end")[/size]

#比如我输入110119,执行过程和结果如下:
请输入密码:
Password is [size=16] 110119 ***print end
[/size]


注释和拼接


注释:
单行注释:# 开头就好,跟shell一样
多行注释:成对的三个单引号 ''' 注释内容 ''' 或者 成对的三个双引号 """  注释内容  """
>>> ''' My name is lucky ''' 
' My name is lucky '
[quote]>> """ My age is 23 """
' My age is 23 '
>>> # Good Idea
...
>>> msg = """ My info is :
... age: 23
... name: lucky
... job: IT"""
>>> print (msg)
My info is :
age: 23
name: lucky
job: IT
>>>
 
拼接:
1、难受的 "+" 
>>> name = "lucky"
>>> age = 23
>>> job = "IT"
>>>
>>> msg = """ Info of """ +name + """
... Name:""" +name + """
... Age:""" +age + """
... Job:""" +job
Traceback (most recent call last):
File "<stdin>", line 4, in <module>
TypeError: Can't convert 'int' object to str implicitly
>>>
>>> name = "lucky"
>>> age = "23"
>>> job = "IT"
>>> msg = """ Info of """ +name + """
... Name:""" +name + """
... Age:""" +age + """
... Job:""" +job
>>> print (msg)
Info of lucky
Name:lucky
Age:23
Job:IT
>>>
如上所示 "+"拼接只能是字符串,如果是整型、或者是浮点都会报错。
 
2、百分号(%)
 Code:
#!/usr/bin/env python3.5
#auther: lucky.chen[/quote]

name = input("Please input your name: ")
age = input("Please input your age:")
job = input("Please input your job:")
salary = input("Please input your salary:")

msg = """------------ info of %s
Name: %s
Age: %s
Job: %s
Salary: %s
""" % (name,name,age,job,salary)

print (msg)
Result:
Please input your name: lucky
Please input your age:23
Please input your job:IT
Please input your salary:40000
------------ info of lucky
Name: lucky
Age: 23
Job: IT
Salary: 40000

 3、使用format函数
情况一:使用变量格式化
Code:
#!/usr/bin/env python3.5
#auther: lucky.chen

name = input("Please input your name: ")
age = input("Please input your age:")
job = input("Please input your job:")
salary = input("Please input your salary:")

msg = """------------ info of {_Name}
Name: {_Name}
Age: {_Age}
Job: {_Job}
Salary: {_Salary}
""".format(_Name=name,_Age=age,_Job=job,_Salary=salary)

print (msg)
Result:
Please input your name: crh
Please input your age:23
Please input your job:IT
Please input your salary:45000
------------ info of crh
Name: crh
Age: 23
Job: IT
Salary: 45000
情况二:使用下脚标
#!/usr/bin/env python3.5
#auther: lucky.chen

name = input('please input your name:')
age = input('please input your age:')
job = input('please input your job:')
salary = input('please input your salary:')
msg = '''
------------info of {0}-----------
Name: {0}
Age: {1}
Job: {2}
Salary: {3}
'''.format(name,age,job,salary)
print (msg)
Result:
please input your name:chenronghua
please input your age:23
please input your job:OPS
please input your salary:50000

------------info of chenronghua-----------
Name: chenronghua
Age: 23
Job: OPS
Salary: 50000
format是比较好的方式,有时候我们必须使用format方法,所以掌握了format就好。
 


流程控制


一、流程控制这里先介绍 if ...... else  and if ...... elif ..... else 
 
1、if ..... else(用户认证登录)
Code:
#!/usr/bin/env python3.5
#auther: lucky.chen

name = input("Please input your name:")
passwd = input("Please input your password:")

if name == "crh" and passwd == "123456":
print (" \033[32mWelcome login OPS Management platform\033[0m ")
else:
print ("\033[31mYour UserName or Password Error\033[0m")
Result:
Please input your name:crh
Please input your password:34
Your UserName or Password Error

 2、if ..... elfi ...... else
Code:
#!/usr/bin/env python3.5
#auther: lucky.chen

age = int(input("Pleast input your age:"))

if age < 18:
print (" \033[32m You're too young \033[0m ")
elif age > 18 and age < 30:
print ("\033[31m You still have many chance comes at a time when youth waiting for you \033[0m")
else:
print ("\033[33m Before you is too old to do \033[0m")
Result:
Pleast input your age:23
You still have many chance comes at a time when youth waiting for you

 二、for 循环遍历
#!/usr/bin/env python3.5
#auther: lucky.chen

for num in range(5):
print ("loop is:",num)

# Result is:
loop is: 0
loop is: 1
loop is: 2
loop is: 3
loop is: 4
range函数也可以设置步长值,比如我们要打印出1-10中的所有偶数(默认步长为1)
#!/usr/bin/env python3.5
#auther: lucky.chen

for num in range(0,11,2):
print ("loop is:",num)

# Result
loop is: 0
loop is: 2
loop is: 4
loop is: 6
loop is: 8
loop is: 10
除掉range函数我们还可以使用xrange函数,为什么要这里要介绍xrange呢,因为xrange相对于range来说性能比较优越,因为xrange不需要一上来就开辟一块很大的内存空间,具体可以参考我之前发布的文章:Python中xrange和range的异同 ,但是好像Python3.*中没有了xrange函数。
 
for...else...循环介绍,不止if中有else,在for循环中也是可以用else的,在for循环中的else就是当前面的循环正常执行完后,没有跳出,后面的else代码将被执行。
crh:Python crh$ cat for.py 
#!/usr/bin/env python3
#Auther: lucky.chen

for num in range(4):
print ("Loop is:",num)
else:
print ("normal")
crh:Python crh$ ./for.py
Loop is: 0
Loop is: 1
Loop is: 2
Loop is: 3
normal
crh:Python crh$
crh:Python crh$ cat for.py 
#!/usr/bin/env python3
#Auther: lucky.chen

for num in range(4):
if num > 2:
break
print ("Loop is:",num)
else:
print ("normal")
crh:Python crh$ ./for.py
Loop is: 0
Loop is: 1
Loop is: 2
crh:Python crh$
三、while循环遍历
 
while 循环它的原理是:当条件为真的时候运行,当条件为假的时候停止!没有一个规定次数,不设置条件就永远循环下去。
#!/usr/bin/env python3.5
#auther: lucky.chen

import time
count = 0
while True:
count +=1
print ("loop",count)
time.sleep(3)
#这个循环3秒钟自+1后,无线循环只要这个条件为”真“,就无限循环下去
#!/usr/bin/env python3.5
#auther: lucky.chen

import time
num = 0

while num < 3:
num +=1
print ("Num is:",num)
time.sleep(3)

#这个循环每3秒循环一次,当条件num < 3的时候为真(自己设置的条件),当num不小于3的时候为假(false)循环停止.
While ...... else
#!/usr/bin/env python3.5
#auther: lucky.chen

while 1:
if num == 4:
print ("I think stop")
break
print (num)
num += 1
else:
print ("stop")

 四、break和continue介绍
break在循环中的作用是跳出所在的循环体,不在进行循环,而continue是跳出所在循环体中的本次循环,后续没有完的循环继续。
Code:
#!/usr/bin/env python3.5
#auther: lucky.chen

num = 1

print ("test break for loop start")
for n in range(5):
if n == num:
break
print (n)

print ("\n")

print ("test continue for loop start")
for n in range(5):
if n == num:
continue
print (n)
Result:
test break for loop start
0


test continue for loop start
0
2
3
4

猜数字游戏:
#!/usr/bin/env python3.5
#auther: lucky.chen

#load module (random)
import random

TryNum = 0
RandNum = random.randrange(10)
print (RandNum)


while TryNum < 3:
GuessNum = int(input("请猜测从0到9之间的一个中奖数字:"))

if GuessNum >= 10:
print ("你输入的数字不在中奖号码范围内,请重新输入!")
continue

if GuessNum == RandNum:
print ("恭喜你猜对了,你将获得小米电视一台!")
break

elif GuessNum > RandNum:
print ("你猜的数字太大了可以再往小了猜")

else:
print ("你猜的数字太小了可以往大了猜")

TryNum += 1

else:
print ("不好意思你三次机会用完了,Game over!")

#先随机到0-9中筛选出以为数字,然后用户三次机会猜测一个中奖号码,如果用户输入的数字不在范围内,则让用户再次输入.
Result:
4
请猜测从0到9之间的一个中奖数字:11
你输入的数字不在中奖号码范围内,请重新输入!
请猜测从0到9之间的一个中奖数字:11
你输入的数字不在中奖号码范围内,请重新输入!
请猜测从0到9之间的一个中奖数字:11
你输入的数字不在中奖号码范围内,请重新输入!
请猜测从0到9之间的一个中奖数字:11
你输入的数字不在中奖号码范围内,请重新输入!
请猜测从0到9之间的一个中奖数字:2
你猜的数字太小了可以往大了猜
请猜测从0到9之间的一个中奖数字:5
你猜的数字太大了可以再往小了猜
请猜测从0到9之间的一个中奖数字:4
恭喜你猜对了,你将获得小米电视一台!

 
五、嵌套循环
While for:
#!/usr/bin/env python3.5
#auther: lucky.chen

count = 1

while count < 4:
print("count var lt 4")

print ("#########################[size=16]#")[/size]

for n in range(3):
print ("for num is:",n)

print ("****************************")
count += 1
Result:
count var lt 4
#########################[size=16]#[/size]
for num is: 0
for num is: 1
for num is: 2
****************************
count var lt 4
#########################[size=16]#[/size]
for num is: 0
for num is: 1
for num is: 2
****************************
count var lt 4
#########################[size=16]#[/size]
for num is: 0
for num is: 1
for num is: 2
****************************

 死循环:
#!/usr/bin/env python3.5
#auther: lucky.chen
import time

while True:
print ("One Loop")
time.sleep(1)

while True:
print ("Two Loop")
time.sleep(1)

while True:
print ("Three Loop")
time.sleep(1)
#这是一个死循环,第一次执行这段code的时候,依次往下执行,单到了第三个while的时候,就一直是true,所以一直在执行第三个while下的code.

#结果如下:
One Loop
Two Loop
Three Loop
Three Loop
Three Loop
Three Loop
..........
..........
如上我们给出了一个死循环的例子,但是如果如果我们需要跳出循环应该怎么做,如果用break可以做到吗?
1、第一个while后加break分析
loop1.png

 
2、第二个while后加break分析
loop2.png

 
3、第三个while后加break分析
loop3.png

 
既然存在这种死循环的那我们有什么办法可以跳出呢?那就是打标志,标志位
Code:
#!/usr/bin/env python3.5
#auther: lucky.chen

count = 0
while True:
print ("我是第一层")
jump_1_flag = False

while True:
print ("我是第二层")
jump_2_flag = False

while True:
count += 1
print ("我是第三层")

if count > 3:
jump_2_flag = True
break

if jump_2_flag:
print ("第三层跳到我这里来了,我也要跳到第一层")
jump_1_flag = True
break

if jump_1_flag:
print ("第二层和第三层跳到第一层了,我也要跳")
break
分析和结果:
tags.png

Python input和raw_input的区别

编程语言采菊篱下 发表了文章 • 1 个评论 • 729 次浏览 • 2015-12-14 23:18 • 来自相关话题

使用input和raw_input都可以读取控制台的输入,但是input和raw_input在处理数字时是有区别的

纯数字输入

当输入为纯数字时
[]input返回的是数值类型,如int,float[/][]raw_inpout返回的是字符串类型,string类型[/]





输入字符串为表达式

input会计算在字符串中的数字表达式,而raw_input不会。
如输入 "57 + 3":
input会得到整数60
raw_input会得到字符串"57 + 3"




输入字符串结果如下:




通过上面的实验我们知道input它会根据用户输入变换相应的类型,而且如果要输入字符和字符串的时候必须要用引号包起来,而raw_input则是不管用户输入什么类型的都会转变成字符型.

python input的实现

看python input的文档,你可以发现input其实是通过raw_input来实现的,原理很简单,就下面一行代码:def input(prompt):
return (eval(raw_input(prompt))) 查看全部
使用input和raw_input都可以读取控制台的输入,但是input和raw_input在处理数字时是有区别的


纯数字输入


当输入为纯数字时
    []input返回的是数值类型,如int,float[/][]raw_inpout返回的是字符串类型,string类型[/]

cb.png


输入字符串为表达式


input会计算在字符串中的数字表达式,而raw_input不会。
如输入 "57 + 3":
input会得到整数60
raw_input会得到字符串"57 + 3"
cb1.png

输入字符串结果如下:
cb3.png

通过上面的实验我们知道input它会根据用户输入变换相应的类型,而且如果要输入字符和字符串的时候必须要用引号包起来,而raw_input则是不管用户输入什么类型的都会转变成字符型.


python input的实现


python input的文档,你可以发现input其实是通过raw_input来实现的,原理很简单,就下面一行代码:
def input(prompt):
return (eval(raw_input(prompt)))

Python在生产环境都可以用来做什么?

编程语言koyo 回复了问题 • 2 人关注 • 3 个回复 • 1465 次浏览 • 2015-12-14 14:45 • 来自相关话题

为什么越来越多人喜欢全栈式开发语言 – Python

编程语言push 发表了文章 • 1 个评论 • 1657 次浏览 • 2015-11-29 20:12 • 来自相关话题

前段时间,ThoughtWorks在深圳举办一次社区活动上,有一个演讲主题叫做“Fullstack JavaScript”,是关于用JavaScript进行前端、服务器端,甚至数据库(MongoDB)开发,一个Web应用开发人员,只需要学会一门语言,就可以实现整个应用。
 
受此启发,我发现Python可以称为大数据全栈式开发语言。因为Python在云基础设施,DevOps,大数据处理等领域都是炙手可热的语言。




就像只要会JavaScript就可以写出完整的Web应用,只要会Python,就可以实现一个完整的大数据处理平台。

云基础设施

这年头,不支持云平台,不支持海量数据,不支持动态伸缩,根本不敢说自己是做大数据的,顶多也就敢跟人说是做商业智能(BI)。
 
云平台分为私有云和公有云。私有云平台如日中天的OpenStack,就是Python写的。曾经的追赶者CloudStack,在刚推出时大肆强调自己是Java写的,比Python有优势。结果,搬石砸脚,2015年初,CloudStack的发起人Citrix宣布加入OpenStack基金会,CloudStack眼看着就要寿终正寝。

如果嫌麻烦不想自己搭建私有云,用公有云,不论是AWS,GCE,Azure,还是阿里云,青云,在都提供了Python SDK,其中GCE只提供Python和JavaScript的SDK,而青云只提供Python SDK。可见各家云平台对Python的重视。

提到基础设施搭建,不得不提Hadoop,在今天,Hadoop因为其MapReduce数据处理速度不够快,已经不再作为大数据处理的首选,但是HDFS和Yarn——Hadoop的两个组件——倒是越来越受欢迎。Hadoop的开发语言是Java,没有官方提供Python支持,不过有很多第三方库封装了Hadoop的API接口(pydoop,hadoopy等等)。

Hadoop MapReduce的替代者,是号称快上100倍的Spark,其开发语言是Scala,但是提供了Scala,Java,Python的开发接口,想要讨好那么多用Python开发的数据科学家,不支持Python,真是说不过去。HDFS的替代品,比如GlusterFS,Ceph等,都是直接提供Python支持。Yarn的替代者,Mesos是C++实现,除C++外,提供了Java和Python的支持包。

DevOps

DevOps有个中文名字,叫做开发自运维。互联网时代,只有能够快速试验新想法,并在第一时间,安全、可靠的交付业务价值,才能保持竞争力。DevOps推崇的自动化构建/测试/部署,以及系统度量等技术实践,是互联网时代必不可少的。

自动化构建是因应用而易的,如果是Python应用,因为有setuptools, pip, virtualenv, tox, flake8等工具的存在,自动化构建非常简单。而且,因为几乎所有Linux系统都内置Python解释器,所以用Python做自动化,不需要系统预安装什么软件。

自动化测试方面,基于Python的Robot Framework企业级应用最喜欢的自动化测试框架,而且和语言无关。Cucumber也有很多支持者,Python对应的Lettuce可以做到完全一样的事情。Locust在自动化性能测试方面也开始受到越来越多的关注。

自动化配置管理工具,老牌的如Chef和Puppet,是Ruby开发,目前仍保持着强劲的势头。不过,新生代Ansible和SaltStack——均为Python开发——因为较前两者设计更为轻量化,受到越来越多开发这的欢迎,已经开始给前辈们制造了不少的压力。

在系统监控与度量方面,传统的Nagios逐渐没落,新贵如Sensu大受好评,云服务形式的New Relic已经成为创业公司的标配,这些都不是直接通过Python实现的,不过Python要接入这些工具,并不困难。

除了上述这些工具,基于Python,提供完整DevOps功能的PaaS平台,如Cloudify和Deis,虽未成气候,但已经得到大量关注。 

网络爬虫

大数据的数据从哪里来?除了部分企业有能力自己产生大量的数据,大部分时候,是需要靠爬虫来抓取互联网数据来做分析。

网络爬虫是Python的传统强势领域,最流行的爬虫框架Scrapy,HTTP工具包urlib2,HTML解析工具beautifulsoup,XML解析器lxml,等等,都是能够独当一面的类库。

不过,网络爬虫并不仅仅是打开网页,解析HTML这么简单。高效的爬虫要能够支持大量灵活的并发操作,常常要能够同时几千甚至上万个网页同时抓取,传统的线程池方式资源浪费比较大,线程数上千之后系统资源基本上就全浪费在线程调度上了。Python由于能够很好的支持协程(Coroutine)操作,基于此发展起来很多并发库,如Gevent,Eventlet,还有Celery之类的分布式任务框架。被认为是比AMQP更高效的ZeroMQ也是最早就提供了Python版本。有了对高并发的支持,网络爬虫才真正可以达到大数据规模。

抓取下来的数据,需要做分词处理,Python在这方面也不逊色,著名的自然语言处理程序包NLTK,还有专门做中文分词的Jieba,都是做分词的利器。

数据处理

万事俱备,只欠东风。这东风,就是数据处理算法。从统计理论,到数据挖掘,机器学习,再到最近几年提出来的深度学习理论,数据科学正处于百花齐放的时代。数据科学家们都用什么编程?

如果是在理论研究领域,R语言也许是最受数据科学家欢迎的,但是R语言的问题也很明显,因为是统计学家们创建了R语言,所以其语法略显怪异。而且R语言要想实现大规模分布式系统,还需要很长一段时间的工程之路要走。所以很多公司使用R语言做原型试验,算法确定之后,再翻译成工程语言。

Python也是数据科学家最喜欢的语言之一。和R语言不同,Python本身就是一门工程性语言,数据科学家用Python实现的算法,可以直接用在产品中,这对于大数据初创公司节省成本是非常有帮助的。正式因为数据科学家对Python和R的热爱,Spark为了讨好数据科学家,对这两种语言提供了非常好的支持。

Python的数据处理相关类库非常多。高性能的科学计算类库NumPy和SciPy,给其他高级算法打了非常好的基础,matploglib让Python画图变得像Matlab一样简单。Scikit-learn和Milk实现了很多机器学习算法,基于这两个库实现的Pylearn2,是深度学习领域的重要成员。Theano利用GPU加速,实现了高性能数学符号计算和多维矩阵计算。当然,还有Pandas,一个在工程领域已经广泛使用的大数据处理类库,其DataFrame的设计借鉴自R语言,后来又启发了Spark项目实现了类似机制。

对了,还有iPython,这个工具如此有用,以至于我差点把他当成标准库而忘了介绍。iPython是一个交互式Python运行环境,能够实时看到每一段Python代码的结果。默认情况下,iPython运行在命令行,可以执行ipython notebook在网页中运行。用matplotlib绘制的图可以直接嵌入式的显示在iPython Notebook中。
iPython Notebook的笔记本文件可以共享给其他人,这样其他人就可以在自己的环境中重现你的工作成果;如果对方没有运行环境,还可以直接转换成HTML或者PDF。




为什么是Python

正是因为应用开发工程师、运维工程师、数据科学家都喜欢Python,才使得Python成为大数据系统的全栈式开发语言。

对于开发工程师而言,Python的优雅和简洁无疑是最大的吸引力,在Python交互式环境中,执行import this,读一读Python之禅,你就明白Python为什么如此吸引人。Python社区一直非常有活力,和NodeJS社区软件包爆炸式增长不同,Python的软件包增长速度一直比较稳定,同时软件包的质量也相对较高。有很多人诟病Python对于空格的要求过于苛刻,但正是因为这个要求,才使得Python在做大型项目时比其他语言有优势。OpenStack项目总共超过200万行代码,证明了这一点。

对于运维工程师而言,Python的最大优势在于,几乎所有Linux发行版都内置了Python解释器。Shell虽然功能强大,但毕竟语法不够优雅,写比较复杂的任务会很痛苦。用Python替代Shell,做一些复杂的任务,对运维人员来说,是一次解放。

对于数据科学家而言,Python简单又不失强大。和C/C++相比,不用做很多的底层工作,可以快速进行模型验证;和Java相比,Python语法简洁,表达能力强,同样的工作只需要1/3代码;和Matlab,Octave相比,Python的工程成熟度更高。不止一个编程大牛表达过,Python是最适合作为大学计算机科学编程课程使用的语言——MIT的计算机入门课程就是使用的Python——因为Python能够让人学到编程最重要的东西——如何解决问题。

顺便提一句,微软参加2015年PyCon,高调宣布提高Python在Windows上的编程体验,包括Visual Studio支持Python,优化Python的C扩展在Windows上的编译等等。脑补下未来Python作为Windows默认组件的场景。

内容来源:ThoughtWorks洞见
分享阅读:http://insights.thoughtworkers.org/full-stack-python/ 查看全部
python_bigdata.png

前段时间,ThoughtWorks在深圳举办一次社区活动上,有一个演讲主题叫做“Fullstack JavaScript”,是关于用JavaScript进行前端、服务器端,甚至数据库(MongoDB)开发,一个Web应用开发人员,只需要学会一门语言,就可以实现整个应用。
 
受此启发,我发现Python可以称为大数据全栈式开发语言。因为Python在云基础设施,DevOps,大数据处理等领域都是炙手可热的语言。
bdlang.png

就像只要会JavaScript就可以写出完整的Web应用,只要会Python,就可以实现一个完整的大数据处理平台。


云基础设施


这年头,不支持云平台,不支持海量数据,不支持动态伸缩,根本不敢说自己是做大数据的,顶多也就敢跟人说是做商业智能(BI)。
 
云平台分为私有云和公有云。私有云平台如日中天的OpenStack,就是Python写的。曾经的追赶者CloudStack,在刚推出时大肆强调自己是Java写的,比Python有优势。结果,搬石砸脚,2015年初,CloudStack的发起人Citrix宣布加入OpenStack基金会,CloudStack眼看着就要寿终正寝。

如果嫌麻烦不想自己搭建私有云,用公有云,不论是AWS,GCE,Azure,还是阿里云,青云,在都提供了Python SDK,其中GCE只提供Python和JavaScript的SDK,而青云只提供Python SDK。可见各家云平台对Python的重视。

提到基础设施搭建,不得不提Hadoop,在今天,Hadoop因为其MapReduce数据处理速度不够快,已经不再作为大数据处理的首选,但是HDFS和Yarn——Hadoop的两个组件——倒是越来越受欢迎。Hadoop的开发语言是Java,没有官方提供Python支持,不过有很多第三方库封装了Hadoop的API接口(pydoop,hadoopy等等)。

Hadoop MapReduce的替代者,是号称快上100倍的Spark,其开发语言是Scala,但是提供了Scala,Java,Python的开发接口,想要讨好那么多用Python开发的数据科学家,不支持Python,真是说不过去。HDFS的替代品,比如GlusterFS,Ceph等,都是直接提供Python支持。Yarn的替代者,Mesos是C++实现,除C++外,提供了Java和Python的支持包。


DevOps


DevOps有个中文名字,叫做开发自运维。互联网时代,只有能够快速试验新想法,并在第一时间,安全、可靠的交付业务价值,才能保持竞争力。DevOps推崇的自动化构建/测试/部署,以及系统度量等技术实践,是互联网时代必不可少的。

自动化构建是因应用而易的,如果是Python应用,因为有setuptools, pip, virtualenv, tox, flake8等工具的存在,自动化构建非常简单。而且,因为几乎所有Linux系统都内置Python解释器,所以用Python做自动化,不需要系统预安装什么软件。

自动化测试方面,基于Python的Robot Framework企业级应用最喜欢的自动化测试框架,而且和语言无关。Cucumber也有很多支持者,Python对应的Lettuce可以做到完全一样的事情。Locust在自动化性能测试方面也开始受到越来越多的关注。

自动化配置管理工具,老牌的如Chef和Puppet,是Ruby开发,目前仍保持着强劲的势头。不过,新生代AnsibleSaltStack——均为Python开发——因为较前两者设计更为轻量化,受到越来越多开发这的欢迎,已经开始给前辈们制造了不少的压力。

在系统监控与度量方面,传统的Nagios逐渐没落,新贵如Sensu大受好评,云服务形式的New Relic已经成为创业公司的标配,这些都不是直接通过Python实现的,不过Python要接入这些工具,并不困难。

除了上述这些工具,基于Python,提供完整DevOps功能的PaaS平台,如CloudifyDeis,虽未成气候,但已经得到大量关注。 


网络爬虫


大数据的数据从哪里来?除了部分企业有能力自己产生大量的数据,大部分时候,是需要靠爬虫来抓取互联网数据来做分析。

网络爬虫是Python的传统强势领域,最流行的爬虫框架Scrapy,HTTP工具包urlib2,HTML解析工具beautifulsoup,XML解析器lxml,等等,都是能够独当一面的类库。

不过,网络爬虫并不仅仅是打开网页,解析HTML这么简单。高效的爬虫要能够支持大量灵活的并发操作,常常要能够同时几千甚至上万个网页同时抓取,传统的线程池方式资源浪费比较大,线程数上千之后系统资源基本上就全浪费在线程调度上了。Python由于能够很好的支持协程(Coroutine)操作,基于此发展起来很多并发库,如Gevent,Eventlet,还有Celery之类的分布式任务框架。被认为是比AMQP更高效的ZeroMQ也是最早就提供了Python版本。有了对高并发的支持,网络爬虫才真正可以达到大数据规模。

抓取下来的数据,需要做分词处理,Python在这方面也不逊色,著名的自然语言处理程序包NLTK,还有专门做中文分词的Jieba,都是做分词的利器。


数据处理


万事俱备,只欠东风。这东风,就是数据处理算法。从统计理论,到数据挖掘,机器学习,再到最近几年提出来的深度学习理论,数据科学正处于百花齐放的时代。数据科学家们都用什么编程?

如果是在理论研究领域,R语言也许是最受数据科学家欢迎的,但是R语言的问题也很明显,因为是统计学家们创建了R语言,所以其语法略显怪异。而且R语言要想实现大规模分布式系统,还需要很长一段时间的工程之路要走。所以很多公司使用R语言做原型试验,算法确定之后,再翻译成工程语言。

Python也是数据科学家最喜欢的语言之一。和R语言不同,Python本身就是一门工程性语言,数据科学家用Python实现的算法,可以直接用在产品中,这对于大数据初创公司节省成本是非常有帮助的。正式因为数据科学家对Python和R的热爱,Spark为了讨好数据科学家,对这两种语言提供了非常好的支持。

Python的数据处理相关类库非常多。高性能的科学计算类库NumPy和SciPy,给其他高级算法打了非常好的基础,matploglib让Python画图变得像Matlab一样简单。Scikit-learn和Milk实现了很多机器学习算法,基于这两个库实现的Pylearn2,是深度学习领域的重要成员。Theano利用GPU加速,实现了高性能数学符号计算和多维矩阵计算。当然,还有Pandas,一个在工程领域已经广泛使用的大数据处理类库,其DataFrame的设计借鉴自R语言,后来又启发了Spark项目实现了类似机制。

对了,还有iPython,这个工具如此有用,以至于我差点把他当成标准库而忘了介绍。iPython是一个交互式Python运行环境,能够实时看到每一段Python代码的结果。默认情况下,iPython运行在命令行,可以执行ipython notebook在网页中运行。用matplotlib绘制的图可以直接嵌入式的显示在iPython Notebook中。
iPython Notebook的笔记本文件可以共享给其他人,这样其他人就可以在自己的环境中重现你的工作成果;如果对方没有运行环境,还可以直接转换成HTML或者PDF。
ipython.png

为什么是Python

正是因为应用开发工程师、运维工程师、数据科学家都喜欢Python,才使得Python成为大数据系统的全栈式开发语言。

对于开发工程师而言,Python的优雅和简洁无疑是最大的吸引力,在Python交互式环境中,执行import this,读一读Python之禅,你就明白Python为什么如此吸引人。Python社区一直非常有活力,和NodeJS社区软件包爆炸式增长不同,Python的软件包增长速度一直比较稳定,同时软件包的质量也相对较高。有很多人诟病Python对于空格的要求过于苛刻,但正是因为这个要求,才使得Python在做大型项目时比其他语言有优势。OpenStack项目总共超过200万行代码,证明了这一点。

对于运维工程师而言,Python的最大优势在于,几乎所有Linux发行版都内置了Python解释器。Shell虽然功能强大,但毕竟语法不够优雅,写比较复杂的任务会很痛苦。用Python替代Shell,做一些复杂的任务,对运维人员来说,是一次解放。

对于数据科学家而言,Python简单又不失强大。和C/C++相比,不用做很多的底层工作,可以快速进行模型验证;和Java相比,Python语法简洁,表达能力强,同样的工作只需要1/3代码;和Matlab,Octave相比,Python的工程成熟度更高。不止一个编程大牛表达过,Python是最适合作为大学计算机科学编程课程使用的语言——MIT的计算机入门课程就是使用的Python——因为Python能够让人学到编程最重要的东西——如何解决问题。

顺便提一句,微软参加2015年PyCon,高调宣布提高Python在Windows上的编程体验,包括Visual Studio支持Python,优化Python的C扩展在Windows上的编译等等。脑补下未来Python作为Windows默认组件的场景。


内容来源:ThoughtWorks洞见
分享阅读:http://insights.thoughtworkers.org/full-stack-python/


老男孩Python开发2016最新14期前10周视频【限免】

回复

编程语言Target 回复了问题 • 5 人关注 • 4 个回复 • 1112 次浏览 • 2017-01-07 22:33 • 来自相关话题

python FTP问题

回复

编程语言采菊篱下 回复了问题 • 3 人关注 • 2 个回复 • 142 次浏览 • 2016-12-27 11:38 • 来自相关话题

分享个基于sendclound的邮件群发软件 大家提点意见

回复

开源技术Nappywu 发起了问题 • 1 人关注 • 0 个回复 • 209 次浏览 • 2016-11-25 15:51 • 来自相关话题

File "collect_info.py", line 109, in <module>

回复

编程语言Not see︶ 回复了问题 • 1 人关注 • 2 个回复 • 531 次浏览 • 2016-08-29 23:05 • 来自相关话题

Python中怎么去除字符串中间的空格?

回复

编程语言采菊篱下 回复了问题 • 2 人关注 • 1 个回复 • 714 次浏览 • 2016-08-13 14:56 • 来自相关话题

用Python从网页提取的文本,转换成str格式后,怎么逐行处理呢?

回复

编程语言采菊篱下 回复了问题 • 2 人关注 • 2 个回复 • 501 次浏览 • 2016-07-27 11:51 • 来自相关话题

Python的web框架有哪些

回复

编程语言采菊篱下 回复了问题 • 2 人关注 • 2 个回复 • 843 次浏览 • 2015-12-22 19:00 • 来自相关话题

Python在生产环境都可以用来做什么?

回复

编程语言koyo 回复了问题 • 2 人关注 • 3 个回复 • 1465 次浏览 • 2015-12-14 14:45 • 来自相关话题

AttributeError: 'module' object has no attribute 'error'

回复

编程语言采菊篱下 回复了问题 • 2 人关注 • 1 个回复 • 1261 次浏览 • 2015-08-23 08:24 • 来自相关话题

python科学计算的库有哪些

回复

编程语言Ansible 回复了问题 • 2 人关注 • 1 个回复 • 840 次浏览 • 2015-07-26 18:25 • 来自相关话题

Python最差实践变更

编程语言chris 发表了文章 • 0 个评论 • 104 次浏览 • 2016-12-20 17:28 • 来自相关话题

最近在看一些陈年老系统,其中有一些不好的代码习惯遗留下来的坑;加上最近自己也写了一段烂代码导致服务器负载飙升,所以就趁此机会总结下我看到过/写过的自认为不好的Python代码习惯,时刻提醒自己远离这些“最差实践”,避免挖坑。

下面所举的例子中,有一部分会造成性能问题,有一部分会导致隐藏bug,或日后维护、重构困难,还有一部分纯粹是我认为不够pythonic。所以大家自行甄别,取精去糟吧。
 

函数默认参数使用可变对象​

这个例子我想大家应该在各种技术文章中见过许多遍了,也足以证明这是一个大坑。
 
先看错误示范吧:
def use_mutable_default_param(idx=0, ids=[]):
ids.append(idx)
print(idx)
print(ids)

use_mutable_default_param(idx=1)
use_mutable_default_param(idx=2)输出:
1
[1]
2
[1, 2]理解这其中的原因,最重要的是有两点:
函数本身也是一个对象,默认参数绑定于这个函数对象上append这类方法会直接修改对象,所以下次调用此函数时,其绑定的默认参数已经不再是空list了
 
正确的做法如下:
def donot_use_mutable_default_param(idx=0, ids=None):
if ids is None:
ids = []
ids.append(idx)
print(idx)
print(ids)

try…except不具体指明异常类型

虽然在Python中使用try…except不会带来严重的性能问题,但是不加区分,直接捕获所有类型异常的做法,往往会掩盖掉其他的bug,造成难以追查的bug。

一般的,我觉得应该尽量少的使用try…except,这样可以在开发期尽早的发现问题。即使要使用try…except,也应该尽可能的指定出要捕获的具体异常,并在except语句中将异常信息记入log,或者处理完之后,再直接raise出来。
 

关于dict的冗余代码

我经常能够看到这样的代码:
d = {}
datas = [1, 2, 3, 4, 2, 3, 4, 1, 5]
for k in datas:
if k not in d:
d[k] = 0
d[k] += 1其实,完全可以使用collections.defaultdict这一数据结构更简单优雅的实现这样的功能:
default_d = defaultdict(lambda: 0)
datas = [1, 2, 3, 4, 2, 3, 4, 1, 5]
for k in datas:
default_d[k] += 1 同样的,这样的代码:
# d is a dict
if 'list' not in d:
d['list'] = []
d['list'].append(x)完全可以用这样一行代码替代:
# d is a dict
d.setdefault('list', []).append(x)同样的,下面这两种写法一看就是带有浓浓的C味儿:
# d is a dict
for k in d:
v = d[k]
# do something

# l is a list
for i in len(l):
v = l[i]
# do something应该用更pythonic的写法:
# d is a dict
for k, v in d.iteritems():
# do something
pass

# l is a list
for i, v in enumerate(l):
# do something
pass另外,enumerate其实还有个第二参数,表示序号从几开始。如果想要序号从1开始数起,可以使用enumerate(l, 1)。 
 

使用flag变量而不使用for…else语句

同样,这样的代码也很常见:
search_list = ['Jone', 'Aric', 'Luise', 'Frank', 'Wey']
found = False
for s in search_list:
if s.startswith('C'):
found = True
# do something when found
print('Found')
break

if not found:
# do something when not found
print('Not found') 其实,用for…else更优雅:
search_list = ['Jone', 'Aric', 'Luise', 'Frank', 'Wey']
for s in search_list:
if s.startswith('C'):
# do something when found
print('Found')
break
else:
# do something when not found
print('Not found')

 

过度使用tuple unpacking

在Python中,允许对tuple类型进行unpack操作,如下所示:
# human = ('James', 180, 32)
name,height,age = human这个特性用起来很爽,比写name=human[0]之类的不知道高到哪里去了。所以,这一特性往往被滥用,一个human在程序的各处通过上面的方式unpack。

然而如果后来需要在human中插入一个表示性别的数据sex,那么对于所有的这种unpack都需要进行修改,即使在有些逻辑中并不会使用到性别。
# human = ('James', 180, 32)
name,height,age, _ = human
# or
# name, height, age, sex = human有如下几种方式解决这一问题:
老老实实写name=human[0]这种代码,在需要使用性别信息处加上sex=human[3]使用dict来表示human使用namedtuple
 
# human = namedtuple('human', ['name', 'height', 'age', 'sex'])
h = human('James', 180, 32, 0)
# then you can use h.name, h.sex and so on everywhere.

到处都是import *

import *是一种懒惰的行为,它不仅会污染当前的命名空间,并且还会使得pyflakes等代码检查工具失效。在后续查看代码或者debug的过程中,往往也很难从一堆import *中找到一个第三方函数的来源。

可以说这种习惯是百害而无一利的。
 

文件操作

文件操作不要使用裸奔的f = open(‘filename’)了,使用with open(‘filename’) as f来让context manager帮你处理异常情况下的关闭文件等乱七八糟的事情多好。
 

野蛮使用class.name判断类型

我曾经遇见过一个bug:为了实现某特定功能,我新写了一个class B(A),在B中重写了A的若干函数。整个实现很简单,但是就是有一部分A的功能无法生效。最后追查到的原因,就是在一些逻辑代码中,硬性的判断了entity.__class__.__name__ == ‘A’。

除非你就是想限定死继承层级中的当前类型(也就是,屏蔽未来可能会出现的子类),否则,不要使用__class__.__name__,而改用isinstance这个内建函数。毕竟,Python把这两个变量的名字都刻意带上那么多下划线,本来就是不太想让你用嘛。
 

循环内部有多层函数调用

循环内部有多层函数调用,有如下两方面的隐患:
Python没有inline函数,所以函数调用本来就会导致一定的开销,尤其是本身逻辑简单的时候,这个开销所占的比例就会挺可观的。更严重的是,在之后维护这份代码时,会容易让人忽略掉函数是在循环中被调用的,所以容易在函数内部添加了一些开销较大却不必每次循环都调用的函数,比如time.localtime()。如果是直接一个平铺直叙的循环,我想大部分的程序员都应该知道把time.localtime()写到循环的外面,但是引入多层的函数调用之后,就不一定了哦。
 
所以我建议,在循环内部,如非特别复杂的逻辑,都应该直接写在循环里,不要进行函数调用。如果一定要包装一层函数调用,应该在函数的命名或注释中,提示后续的维护者,这个函数会在循环内部使用。
 

总结

Python是一门非常容易入门的语言,严格的缩进要求和丰富的内置数据类型,使得大部分Python代码都能做到比较好的规范。但是,不严格要求自己,也很容易就写出犯二的代码。上面列出的只是很小的一部分,唯有多读、多写、多想,才能培养敏锐的代码嗅觉,第一时间发现坏味道啊。
 

分享阅读:http://blog.guoyb.com/2016/12/03/bad-py-style/
作者:yubo 查看全部
python.png
最近在看一些陈年老系统,其中有一些不好的代码习惯遗留下来的坑;加上最近自己也写了一段烂代码导致服务器负载飙升,所以就趁此机会总结下我看到过/写过的自认为不好的Python代码习惯,时刻提醒自己远离这些“最差实践”,避免挖坑。

下面所举的例子中,有一部分会造成性能问题,有一部分会导致隐藏bug,或日后维护、重构困难,还有一部分纯粹是我认为不够pythonic。所以大家自行甄别,取精去糟吧。
 


函数默认参数使用可变对象​


这个例子我想大家应该在各种技术文章中见过许多遍了,也足以证明这是一个大坑。
 
先看错误示范吧:
def use_mutable_default_param(idx=0, ids=[]):
ids.append(idx)
print(idx)
print(ids)

use_mutable_default_param(idx=1)
use_mutable_default_param(idx=2)
输出:
1
[1]
2
[1, 2]
理解这其中的原因,最重要的是有两点:
  1. 函数本身也是一个对象,默认参数绑定于这个函数对象上
  2. append这类方法会直接修改对象,所以下次调用此函数时,其绑定的默认参数已经不再是空list了

 
正确的做法如下:
def donot_use_mutable_default_param(idx=0, ids=None):
if ids is None:
ids = []
ids.append(idx)
print(idx)
print(ids)


try…except不具体指明异常类型


虽然在Python中使用try…except不会带来严重的性能问题,但是不加区分,直接捕获所有类型异常的做法,往往会掩盖掉其他的bug,造成难以追查的bug。

一般的,我觉得应该尽量少的使用try…except,这样可以在开发期尽早的发现问题。即使要使用try…except,也应该尽可能的指定出要捕获的具体异常,并在except语句中将异常信息记入log,或者处理完之后,再直接raise出来。
 


关于dict的冗余代码


我经常能够看到这样的代码:
d = {}
datas = [1, 2, 3, 4, 2, 3, 4, 1, 5]
for k in datas:
if k not in d:
d[k] = 0
d[k] += 1
其实,完全可以使用collections.defaultdict这一数据结构更简单优雅的实现这样的功能:
default_d = defaultdict(lambda: 0)
datas = [1, 2, 3, 4, 2, 3, 4, 1, 5]
for k in datas:
default_d[k] += 1
同样的,这样的代码:
# d is a dict
if 'list' not in d:
d['list'] = []
d['list'].append(x)
完全可以用这样一行代码替代:
# d is a dict
d.setdefault('list', []).append(x)
同样的,下面这两种写法一看就是带有浓浓的C味儿:
# d is a dict
for k in d:
v = d[k]
# do something

# l is a list
for i in len(l):
v = l[i]
# do something
应该用更pythonic的写法:
# d is a dict
for k, v in d.iteritems():
# do something
pass

# l is a list
for i, v in enumerate(l):
# do something
pass
另外,enumerate其实还有个第二参数,表示序号从几开始。如果想要序号从1开始数起,可以使用enumerate(l, 1)。 
 


使用flag变量而不使用for…else语句


同样,这样的代码也很常见:
search_list = ['Jone', 'Aric', 'Luise', 'Frank', 'Wey']
found = False
for s in search_list:
if s.startswith('C'):
found = True
# do something when found
print('Found')
break

if not found:
# do something when not found
print('Not found')
其实,用for…else更优雅:
search_list = ['Jone', 'Aric', 'Luise', 'Frank', 'Wey']
for s in search_list:
if s.startswith('C'):
# do something when found
print('Found')
break
else:
# do something when not found
print('Not found')

 


过度使用tuple unpacking


在Python中,允许对tuple类型进行unpack操作,如下所示:
# human = ('James', 180, 32)
name,height,age = human
这个特性用起来很爽,比写name=human[0]之类的不知道高到哪里去了。所以,这一特性往往被滥用,一个human在程序的各处通过上面的方式unpack。

然而如果后来需要在human中插入一个表示性别的数据sex,那么对于所有的这种unpack都需要进行修改,即使在有些逻辑中并不会使用到性别。
# human = ('James', 180, 32)
name,height,age, _ = human
# or
# name, height, age, sex = human
有如下几种方式解决这一问题:
  1. 老老实实写name=human[0]这种代码,在需要使用性别信息处加上sex=human[3]
  2. 使用dict来表示human
  3. 使用namedtuple

 
# human = namedtuple('human', ['name', 'height', 'age', 'sex'])
h = human('James', 180, 32, 0)
# then you can use h.name, h.sex and so on everywhere.


到处都是import *


import *是一种懒惰的行为,它不仅会污染当前的命名空间,并且还会使得pyflakes等代码检查工具失效。在后续查看代码或者debug的过程中,往往也很难从一堆import *中找到一个第三方函数的来源。

可以说这种习惯是百害而无一利的。
 


文件操作


文件操作不要使用裸奔的f = open(‘filename’)了,使用with open(‘filename’) as f来让context manager帮你处理异常情况下的关闭文件等乱七八糟的事情多好。
 


野蛮使用class.name判断类型


我曾经遇见过一个bug:为了实现某特定功能,我新写了一个class B(A),在B中重写了A的若干函数。整个实现很简单,但是就是有一部分A的功能无法生效。最后追查到的原因,就是在一些逻辑代码中,硬性的判断了entity.__class__.__name__ == ‘A’。

除非你就是想限定死继承层级中的当前类型(也就是,屏蔽未来可能会出现的子类),否则,不要使用__class__.__name__,而改用isinstance这个内建函数。毕竟,Python把这两个变量的名字都刻意带上那么多下划线,本来就是不太想让你用嘛。
 


循环内部有多层函数调用


循环内部有多层函数调用,有如下两方面的隐患:
  1. Python没有inline函数,所以函数调用本来就会导致一定的开销,尤其是本身逻辑简单的时候,这个开销所占的比例就会挺可观的。
  2. 更严重的是,在之后维护这份代码时,会容易让人忽略掉函数是在循环中被调用的,所以容易在函数内部添加了一些开销较大却不必每次循环都调用的函数,比如time.localtime()。如果是直接一个平铺直叙的循环,我想大部分的程序员都应该知道把time.localtime()写到循环的外面,但是引入多层的函数调用之后,就不一定了哦。

 
所以我建议,在循环内部,如非特别复杂的逻辑,都应该直接写在循环里,不要进行函数调用。如果一定要包装一层函数调用,应该在函数的命名或注释中,提示后续的维护者,这个函数会在循环内部使用。
 


总结


Python是一门非常容易入门的语言,严格的缩进要求和丰富的内置数据类型,使得大部分Python代码都能做到比较好的规范。但是,不严格要求自己,也很容易就写出犯二的代码。上面列出的只是很小的一部分,唯有多读、多写、多想,才能培养敏锐的代码嗅觉,第一时间发现坏味道啊。
 


分享阅读:http://blog.guoyb.com/2016/12/03/bad-py-style/
作者:yubo


Python调用Zabbix API实例

开源技术Nock 发表了文章 • 0 个评论 • 137 次浏览 • 2016-12-06 19:59 • 来自相关话题

#!/usr/bin/python
#coding:utf-8


import json
import urllib2
from urllib2 import URLError
import sys,argparse

class zabbix_api:
def __init__(self):
self.url = 'http://192.168.210.13:81/zabbix/api_jsonrpc.php' #修改URL
self.header = {"Content-Type":"application/json"}
#验证信息
def user_login(self):
data = json.dumps({
"jsonrpc": "2.0",
"method": "user.login",
"params": {
"user": "Admin", #修改用户名
"password": "zabbix" #修改密码
},
"id": 0
})

request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "\033[041m 用户认证失败,请检查 !\033[0m", e.code
else:
response = json.loads(result.read())
result.close()
#print response['result']
self.authID = response['result']
return self.authID
#主机查询
def host_get(self,hostName=''):
data = json.dumps({
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": "extend",
"filter":{
"host":hostName
}
},
"auth": self.user_login(),
"id": 1
})
request = urllib2.Request(self.url,data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
if hasattr(e, 'reason'):
print 'We failed to reach a server.'
print 'Reason: ', e.reason
elif hasattr(e, 'code'):
print 'The server could not fulfill the request.'
print 'Error code: ', e.code
else:
response = json.loads(result.read())
#print response
result.close()
print "主机数量: \033[31m%s\033[0m"%(len(response['result']))
for host in response['result']:
status={"0":"OK","1":"Disabled"}
available={"0":"Unknown","1":"available","2":"Unavailable"}
#print host
if len(hostName)==0:
print "HostID : %s\t HostName : %s\t Status :\033[32m%s\033[0m \t Available :\033[31m%s\033[0m"%(host['hostid'],host['name'],status[host['status']],available[host['available']])
else:
print "HostID : %s\t HostName : %s\t Status :\033[32m%s\033[0m \t Available :\033[31m%s\033[0m"%(host['hostid'],host['name'],status[host['status']],available[host['available']])
return host['hostid']
#图形查询
def graph_get(self,hostids,graphname=''):
data = json.dumps({
"jsonrpc": "2.0",
"method": "graph.get",
"params": {
"output": "extend",
"hostids": hostids,
"sortfield": "name"
},
"auth": self.user_login(),
"id":1
})
request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
if hasattr(e, 'reason'):
print 'We failed to reach a server.'
print 'Reason: ', e.reason
elif hasattr(e, 'code'):
print 'The server could not fulfill the request.'
print 'Error code: ', e.code
else:
response = json.loads(result.read())
result.close()
print "图形数量: \033[31m%s\033[0m"%(len(response['result']))
for graph in response['result']:
if len(graphname)==0:
print "graphid : %s\t graphname : %s\t width :\033[32m%s\033[0m \t height :\033[31m%s\033[0m"%(graph['graphid'],graph['name'],graph['width'],graph['height'])
else:
print "graphid : %s\t graphname : %s\t width :\033[32m%s\033[0m \t height :\033[31m%s\033[0m"%(graph['graphid'],graph['name'],graph['width'],graph['height'])
return graph['graphid']
#筛选图查询
def screen_get(self,ScreenName=''):
data = json.dumps({
"jsonrpc": "2.0",
"method": "screen.get",
"params": {
"output": "extend",
"selectScreenItems": "extend",
"filter": {
"name": ScreenName
}
},
"auth":self.user_login(),
"id":1
})

request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print 'Error as ', e
else:
response = json.loads(result.read())
result.close()
print "筛选图数量: \033[31m%s\033[0m"%(len(response['result']))
for screen in response['result']:
if len(ScreenName)==0:
print "ScreenID : %s\t ScreenName : %s\t Hsize :\033[32m%s\033[0m \t Vsize :\033[31m%s\033[0m"%(screen['screenid'],screen['name'],screen['hsize'],screen['vsize'])
else:
print "ScreenID : %s\t ScreenName : %s\t Hsize :\033[32m%s\033[0m \t Vsize :\033[31m%s\033[0m"%(screen['screenid'],screen['name'],screen['hsize'],screen['vsize'])
return screen['screenid']
#主机组查询
def hostgroup_get(self, hostgroupName=''):
data = json.dumps({
"jsonrpc":"2.0",
"method":"hostgroup.get",
"params": {
"output": "extend",
"filter": {
"name": hostgroupName
}
},
"auth":self.user_login(),
"id":1
})

request = urllib2.Request(self.url,data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
#print result.read()
response = json.loads(result.read())
result.close()
#print response()
for group in response['result']:
if len(hostgroupName)==0:
print "hostgroup: \033[31m%s\033[0m \tgroupid : %s" %(group['name'],group['groupid'])
else:
print "hostgroup: \033[31m%s\033[0m \tgroupid : %s" %(group['name'],group['groupid'])
self.hostgroupID = group['groupid']
return group['groupid']
#模版查询
def template_get(self,templateName=''):
data = json.dumps({
"jsonrpc": "2.0",
"method": "template.get",
"params": {
"output": "extend",
"filter": {
"name":templateName
}
},
"auth":self.user_login(),
"id":1
})

request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
#print response
for template in response['result']:
if len(templateName)==0:
print "template : \033[31m%s\033[0m\t id : %s" % (template['name'], template['templateid'])
else:
self.templateID = response['result'][0]['templateid']
print "Template Name : \033[31m%s\033[0m "%templateName
return response['result'][0]['templateid']
#主机组创建
def hostgroup_create(self,hostgroupName):
if self.hostgroup_get(hostgroupName):
print "hostgroup \033[42m%s\033[0m is exist !"%hostgroupName
sys.exit(1)
data = json.dumps({
"jsonrpc": "2.0",
"method": "hostgroup.create",
"params": {
"name": hostgroupName
},
"auth": self.user_login(),
"id": 1
})
request=urllib2.Request(self.url,data)

for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
print "\033[042m 添加主机组:%s\033[0m hostgroupID : %s"%(hostgroupName,response['result']['groupids'])
#筛选图添加
def screen_create(self,ScreenName,hsize,vsize):
if self.screen_get(ScreenName):
print "Screen \033[42m%s\033[0m is exist !"%ScreenName
sys.exit(1)
data = json.dumps({
"jsonrpc": "2.0",
"method": "screen.create",
"params": {
"name": ScreenName,
"hsize": hsize,
"vsize": vsize
},
"auth": self.user_login(),
"id": 1
})
request=urllib2.Request(self.url,data)

for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
print "\033[042m 添加筛选图:%s\033[0m ScreenName : %s"%(ScreenName,response['result']['screenids'])
#筛选图图形添加
def screen_item_create(self,screenid,resourceid,x,y):
if self.screen_item_create(resourceid):
print "resource \033[042m%s\033[0m is exist !"%resourceid
sys.exit(1)
screen_list=[]
for i in screenid.split(','):
var = {}
var['screenid'] = self.screen_get(i)
screen_list.append(var)
data = json.dumps({
"jsonrpc": "2.0",
"method": "screenitem.create",
"params": {
"screenid": screen_list,
"resourceid": resourceid,
"x": x,
"y": y
},
"auth": self.user_login(),
"id": 1
})
request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])
try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
print "\033[042m 添加筛选图形:%s\033[0m resourceid : %s"%(resourceid,response['result']['resourceids'])
#主机创建
def host_create(self, hostip, hostgroupName, templateName):
if self.host_get(hostip):
print "\033[041m该主机已经添加!\033[0m"
sys.exit(1)

group_list=[]
template_list=[]
for i in hostgroupName.split(','):
var = {}
var['groupid'] = self.hostgroup_get(i)
group_list.append(var)
for i in templateName.split(','):
var={}
var['templateid']=self.template_get(i)
template_list.append(var)

data = json.dumps({
"jsonrpc":"2.0",
"method":"host.create",
"params":{
"host": hostip,
"interfaces": [
{
"type": 1,
"main": 1,
"useip": 1,
"ip": hostip,
"dns": "",
"port": "10050"
}
],
"groups": group_list,
"templates": template_list,
},
"auth": self.user_login(),
"id":1
})
request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
print "添加主机 : \033[42m%s\031[0m \tid :\033[31m%s\033[0m" % (hostip, response['result']['hostids'])
#关闭主机
def host_disable(self,hostip):
data=json.dumps({
"jsonrpc": "2.0",
"method": "host.update",
"params": {
"hostid": self.host_get(hostip),
"status": 1
},
"auth": self.user_login(),
"id": 1
})
request = urllib2.Request(self.url,data)
for key in self.header:
request.add_header(key, self.header[key])
try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
print '----主机现在状态------------'
print self.host_get(hostip)
#删除主机
def host_delete(self,hostid):
hostid_list=[]
#print type(hostid)
for i in hostid.split(','):
var = {}
var['hostid'] = self.host_get(i)
hostid_list.append(var)
data=json.dumps({
"jsonrpc": "2.0",
"method": "host.delete",
"params": hostid_list,
"auth": self.user_login(),
"id": 1
})

request = urllib2.Request(self.url,data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except Exception,e:
print e
else:

result.close()
print "主机 \033[041m %s\033[0m 已经删除 !"%hostid
#删除筛选图
def screen_delete(self,screenid):
screenid_list=[]
for i in screenid.split(','):
var = {}
var['screenid'] = self.screen_get(i)
screenid_list.append(var)
data=json.dumps({
"jsonrpc": "2.0",
"method": "screen.delete",
"params": screenid_list,
"auth": self.user_login(),
"id": 1
})
request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])
try:
result = urllib2.urlopen(request)
except Exception,e:
print e
else:
result.close()
print "筛选图 \033[041m %s\033[0m 已经删除 !"%screenid


if __name__ == "__main__":
zabbix=zabbix_api()
parser=argparse.ArgumentParser(description='zabbix api ',usage='%(prog)s [options]')
parser.add_argument('-H','--host',nargs='?',dest='listhost',default='host',help='查询主机')
parser.add_argument('-Z','--graph',nargs='?',dest='listgraph',default='graph',help='查询图形')
parser.add_argument('-G','--group',nargs='?',dest='listgroup',default='group',help='查询主机组')
parser.add_argument('-T','--template',nargs='?',dest='listtemp',default='template',help='查询模板信息')
parser.add_argument('-S','--screen',nargs='?',dest='listscreen',default='screen',help='查询筛选图')
parser.add_argument('-A','--add-group',nargs=1,dest='addgroup',help='添加主机组')
parser.add_argument('-C','--add-host',dest='addhost',nargs=3,metavar=('192.168.2.1', 'test01,test02', 'Template01,Template02'),help='添加主机,多个主机组或模板使用分号')
parser.add_argument('-B','--create-screenitem',dest='addscreenitem',nargs=4,metavar=('38', '365', '0', '0'),help='添加筛选图图形')
parser.add_argument('-J','--add-screen',nargs=3,dest='addscreen',help='添加筛选图')
parser.add_argument('-d','--disable',dest='disablehost',nargs=1,metavar=('192.168.2.1'),help='禁用主机')
parser.add_argument('-D','--delete',dest='deletehost',nargs='+',metavar=('192.168.2.1'),help='删除主机,多个主机之间用分号')
parser.add_argument('-P','--delete-screen',dest='deletescreen',nargs='+',metavar=('38'),help='删除筛选图,多个筛选图之间用分号')
parser.add_argument('-v','--version', action='version', version='%(prog)s 1.0')
if len(sys.argv)==1:
print parser.print_help()
else:
args=parser.parse_args()

if args.listhost != 'host' :
if args.listhost:
zabbix.host_get(args.listhost)
else:
zabbix.host_get()
if args.listgraph != 'graph':
if args.listgraph:
zabbix.graph_get(args.listgraph)
else:
zabbix.graph_get()
if args.listgroup !='group':
if args.listgroup:
zabbix.hostgroup_get(args.listgroup)
else:
zabbix.hostgroup_get()
if args.listtemp != 'template':
if args.listtemp:
zabbix.template_get(args.listtemp)
else:
zabbix.template_get()
if args.listscreen != 'screen':
if args.listscreen:
zabbix.screen_get(args.listscreen)
else:
zabbix.screen_get()
if args.addgroup:
zabbix.hostgroup_create(args.addgroup[0])
if args.addhost:
zabbix.host_create(args.addhost[0], args.addhost[1], args.addhost[2])
if args.addscreen:
zabbix.screen_create(args.addscreen[0],args.addscreen[1],args.addscreen[2])
if args.addscreenitem:
zabbix.screen_item_create(args.addscreenitem[0],args.addscreenitem[1],args.addscreenitem[2],args.addscreenitem[3])
if args.disablehost:
zabbix.host_disable(args.disablehost)
if args.deletehost:
zabbix.host_delete(args.deletehost[0])
if args.deletescreen:
zabbix.screen_delete(args.deletescreen[0]) 查看全部
#!/usr/bin/python 
#coding:utf-8


import json
import urllib2
from urllib2 import URLError
import sys,argparse

class zabbix_api:
def __init__(self):
self.url = 'http://192.168.210.13:81/zabbix/api_jsonrpc.php' #修改URL
self.header = {"Content-Type":"application/json"}
#验证信息
def user_login(self):
data = json.dumps({
"jsonrpc": "2.0",
"method": "user.login",
"params": {
"user": "Admin", #修改用户名
"password": "zabbix" #修改密码
},
"id": 0
})

request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "\033[041m 用户认证失败,请检查 !\033[0m", e.code
else:
response = json.loads(result.read())
result.close()
#print response['result']
self.authID = response['result']
return self.authID
#主机查询
def host_get(self,hostName=''):
data = json.dumps({
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": "extend",
"filter":{
"host":hostName
}
},
"auth": self.user_login(),
"id": 1
})
request = urllib2.Request(self.url,data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
if hasattr(e, 'reason'):
print 'We failed to reach a server.'
print 'Reason: ', e.reason
elif hasattr(e, 'code'):
print 'The server could not fulfill the request.'
print 'Error code: ', e.code
else:
response = json.loads(result.read())
#print response
result.close()
print "主机数量: \033[31m%s\033[0m"%(len(response['result']))
for host in response['result']:
status={"0":"OK","1":"Disabled"}
available={"0":"Unknown","1":"available","2":"Unavailable"}
#print host
if len(hostName)==0:
print "HostID : %s\t HostName : %s\t Status :\033[32m%s\033[0m \t Available :\033[31m%s\033[0m"%(host['hostid'],host['name'],status[host['status']],available[host['available']])
else:
print "HostID : %s\t HostName : %s\t Status :\033[32m%s\033[0m \t Available :\033[31m%s\033[0m"%(host['hostid'],host['name'],status[host['status']],available[host['available']])
return host['hostid']
#图形查询
def graph_get(self,hostids,graphname=''):
data = json.dumps({
"jsonrpc": "2.0",
"method": "graph.get",
"params": {
"output": "extend",
"hostids": hostids,
"sortfield": "name"
},
"auth": self.user_login(),
"id":1
})
request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
if hasattr(e, 'reason'):
print 'We failed to reach a server.'
print 'Reason: ', e.reason
elif hasattr(e, 'code'):
print 'The server could not fulfill the request.'
print 'Error code: ', e.code
else:
response = json.loads(result.read())
result.close()
print "图形数量: \033[31m%s\033[0m"%(len(response['result']))
for graph in response['result']:
if len(graphname)==0:
print "graphid : %s\t graphname : %s\t width :\033[32m%s\033[0m \t height :\033[31m%s\033[0m"%(graph['graphid'],graph['name'],graph['width'],graph['height'])
else:
print "graphid : %s\t graphname : %s\t width :\033[32m%s\033[0m \t height :\033[31m%s\033[0m"%(graph['graphid'],graph['name'],graph['width'],graph['height'])
return graph['graphid']
#筛选图查询
def screen_get(self,ScreenName=''):
data = json.dumps({
"jsonrpc": "2.0",
"method": "screen.get",
"params": {
"output": "extend",
"selectScreenItems": "extend",
"filter": {
"name": ScreenName
}
},
"auth":self.user_login(),
"id":1
})

request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print 'Error as ', e
else:
response = json.loads(result.read())
result.close()
print "筛选图数量: \033[31m%s\033[0m"%(len(response['result']))
for screen in response['result']:
if len(ScreenName)==0:
print "ScreenID : %s\t ScreenName : %s\t Hsize :\033[32m%s\033[0m \t Vsize :\033[31m%s\033[0m"%(screen['screenid'],screen['name'],screen['hsize'],screen['vsize'])
else:
print "ScreenID : %s\t ScreenName : %s\t Hsize :\033[32m%s\033[0m \t Vsize :\033[31m%s\033[0m"%(screen['screenid'],screen['name'],screen['hsize'],screen['vsize'])
return screen['screenid']
#主机组查询
def hostgroup_get(self, hostgroupName=''):
data = json.dumps({
"jsonrpc":"2.0",
"method":"hostgroup.get",
"params": {
"output": "extend",
"filter": {
"name": hostgroupName
}
},
"auth":self.user_login(),
"id":1
})

request = urllib2.Request(self.url,data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
#print result.read()
response = json.loads(result.read())
result.close()
#print response()
for group in response['result']:
if len(hostgroupName)==0:
print "hostgroup: \033[31m%s\033[0m \tgroupid : %s" %(group['name'],group['groupid'])
else:
print "hostgroup: \033[31m%s\033[0m \tgroupid : %s" %(group['name'],group['groupid'])
self.hostgroupID = group['groupid']
return group['groupid']
#模版查询
def template_get(self,templateName=''):
data = json.dumps({
"jsonrpc": "2.0",
"method": "template.get",
"params": {
"output": "extend",
"filter": {
"name":templateName
}
},
"auth":self.user_login(),
"id":1
})

request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
#print response
for template in response['result']:
if len(templateName)==0:
print "template : \033[31m%s\033[0m\t id : %s" % (template['name'], template['templateid'])
else:
self.templateID = response['result'][0]['templateid']
print "Template Name : \033[31m%s\033[0m "%templateName
return response['result'][0]['templateid']
#主机组创建
def hostgroup_create(self,hostgroupName):
if self.hostgroup_get(hostgroupName):
print "hostgroup \033[42m%s\033[0m is exist !"%hostgroupName
sys.exit(1)
data = json.dumps({
"jsonrpc": "2.0",
"method": "hostgroup.create",
"params": {
"name": hostgroupName
},
"auth": self.user_login(),
"id": 1
})
request=urllib2.Request(self.url,data)

for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
print "\033[042m 添加主机组:%s\033[0m hostgroupID : %s"%(hostgroupName,response['result']['groupids'])
#筛选图添加
def screen_create(self,ScreenName,hsize,vsize):
if self.screen_get(ScreenName):
print "Screen \033[42m%s\033[0m is exist !"%ScreenName
sys.exit(1)
data = json.dumps({
"jsonrpc": "2.0",
"method": "screen.create",
"params": {
"name": ScreenName,
"hsize": hsize,
"vsize": vsize
},
"auth": self.user_login(),
"id": 1
})
request=urllib2.Request(self.url,data)

for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
print "\033[042m 添加筛选图:%s\033[0m ScreenName : %s"%(ScreenName,response['result']['screenids'])
#筛选图图形添加
def screen_item_create(self,screenid,resourceid,x,y):
if self.screen_item_create(resourceid):
print "resource \033[042m%s\033[0m is exist !"%resourceid
sys.exit(1)
screen_list=[]
for i in screenid.split(','):
var = {}
var['screenid'] = self.screen_get(i)
screen_list.append(var)
data = json.dumps({
"jsonrpc": "2.0",
"method": "screenitem.create",
"params": {
"screenid": screen_list,
"resourceid": resourceid,
"x": x,
"y": y
},
"auth": self.user_login(),
"id": 1
})
request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])
try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
print "\033[042m 添加筛选图形:%s\033[0m resourceid : %s"%(resourceid,response['result']['resourceids'])
#主机创建
def host_create(self, hostip, hostgroupName, templateName):
if self.host_get(hostip):
print "\033[041m该主机已经添加!\033[0m"
sys.exit(1)

group_list=[]
template_list=[]
for i in hostgroupName.split(','):
var = {}
var['groupid'] = self.hostgroup_get(i)
group_list.append(var)
for i in templateName.split(','):
var={}
var['templateid']=self.template_get(i)
template_list.append(var)

data = json.dumps({
"jsonrpc":"2.0",
"method":"host.create",
"params":{
"host": hostip,
"interfaces": [
{
"type": 1,
"main": 1,
"useip": 1,
"ip": hostip,
"dns": "",
"port": "10050"
}
],
"groups": group_list,
"templates": template_list,
},
"auth": self.user_login(),
"id":1
})
request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
print "添加主机 : \033[42m%s\031[0m \tid :\033[31m%s\033[0m" % (hostip, response['result']['hostids'])
#关闭主机
def host_disable(self,hostip):
data=json.dumps({
"jsonrpc": "2.0",
"method": "host.update",
"params": {
"hostid": self.host_get(hostip),
"status": 1
},
"auth": self.user_login(),
"id": 1
})
request = urllib2.Request(self.url,data)
for key in self.header:
request.add_header(key, self.header[key])
try:
result = urllib2.urlopen(request)
except URLError as e:
print "Error as ", e
else:
response = json.loads(result.read())
result.close()
print '----主机现在状态------------'
print self.host_get(hostip)
#删除主机
def host_delete(self,hostid):
hostid_list=[]
#print type(hostid)
for i in hostid.split(','):
var = {}
var['hostid'] = self.host_get(i)
hostid_list.append(var)
data=json.dumps({
"jsonrpc": "2.0",
"method": "host.delete",
"params": hostid_list,
"auth": self.user_login(),
"id": 1
})

request = urllib2.Request(self.url,data)
for key in self.header:
request.add_header(key, self.header[key])

try:
result = urllib2.urlopen(request)
except Exception,e:
print e
else:

result.close()
print "主机 \033[041m %s\033[0m 已经删除 !"%hostid
#删除筛选图
def screen_delete(self,screenid):
screenid_list=[]
for i in screenid.split(','):
var = {}
var['screenid'] = self.screen_get(i)
screenid_list.append(var)
data=json.dumps({
"jsonrpc": "2.0",
"method": "screen.delete",
"params": screenid_list,
"auth": self.user_login(),
"id": 1
})
request = urllib2.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key])
try:
result = urllib2.urlopen(request)
except Exception,e:
print e
else:
result.close()
print "筛选图 \033[041m %s\033[0m 已经删除 !"%screenid


if __name__ == "__main__":
zabbix=zabbix_api()
parser=argparse.ArgumentParser(description='zabbix api ',usage='%(prog)s [options]')
parser.add_argument('-H','--host',nargs='?',dest='listhost',default='host',help='查询主机')
parser.add_argument('-Z','--graph',nargs='?',dest='listgraph',default='graph',help='查询图形')
parser.add_argument('-G','--group',nargs='?',dest='listgroup',default='group',help='查询主机组')
parser.add_argument('-T','--template',nargs='?',dest='listtemp',default='template',help='查询模板信息')
parser.add_argument('-S','--screen',nargs='?',dest='listscreen',default='screen',help='查询筛选图')
parser.add_argument('-A','--add-group',nargs=1,dest='addgroup',help='添加主机组')
parser.add_argument('-C','--add-host',dest='addhost',nargs=3,metavar=('192.168.2.1', 'test01,test02', 'Template01,Template02'),help='添加主机,多个主机组或模板使用分号')
parser.add_argument('-B','--create-screenitem',dest='addscreenitem',nargs=4,metavar=('38', '365', '0', '0'),help='添加筛选图图形')
parser.add_argument('-J','--add-screen',nargs=3,dest='addscreen',help='添加筛选图')
parser.add_argument('-d','--disable',dest='disablehost',nargs=1,metavar=('192.168.2.1'),help='禁用主机')
parser.add_argument('-D','--delete',dest='deletehost',nargs='+',metavar=('192.168.2.1'),help='删除主机,多个主机之间用分号')
parser.add_argument('-P','--delete-screen',dest='deletescreen',nargs='+',metavar=('38'),help='删除筛选图,多个筛选图之间用分号')
parser.add_argument('-v','--version', action='version', version='%(prog)s 1.0')
if len(sys.argv)==1:
print parser.print_help()
else:
args=parser.parse_args()

if args.listhost != 'host' :
if args.listhost:
zabbix.host_get(args.listhost)
else:
zabbix.host_get()
if args.listgraph != 'graph':
if args.listgraph:
zabbix.graph_get(args.listgraph)
else:
zabbix.graph_get()
if args.listgroup !='group':
if args.listgroup:
zabbix.hostgroup_get(args.listgroup)
else:
zabbix.hostgroup_get()
if args.listtemp != 'template':
if args.listtemp:
zabbix.template_get(args.listtemp)
else:
zabbix.template_get()
if args.listscreen != 'screen':
if args.listscreen:
zabbix.screen_get(args.listscreen)
else:
zabbix.screen_get()
if args.addgroup:
zabbix.hostgroup_create(args.addgroup[0])
if args.addhost:
zabbix.host_create(args.addhost[0], args.addhost[1], args.addhost[2])
if args.addscreen:
zabbix.screen_create(args.addscreen[0],args.addscreen[1],args.addscreen[2])
if args.addscreenitem:
zabbix.screen_item_create(args.addscreenitem[0],args.addscreenitem[1],args.addscreenitem[2],args.addscreenitem[3])
if args.disablehost:
zabbix.host_disable(args.disablehost)
if args.deletehost:
zabbix.host_delete(args.deletehost[0])
if args.deletescreen:
zabbix.screen_delete(args.deletescreen[0])

Python的数据序列化「Json & Pickle」

大数据/云计算采菊篱下 发表了文章 • 0 个评论 • 316 次浏览 • 2016-10-20 00:06 • 来自相关话题

在介绍Python的数据序列化模块「Json & Pickle」之前,我们先来看看为什么需要数据序列化,什么是数据序列化。
 
为什么需要数据序列化,我认为有如下两种原因:
一个原因是将对象(一切皆对象)的状态保持在存储媒介(硬盘、网盘......)中,以便可以在以后重新创建精确的副本,相当于镜像的概念,比如我们平时利用VMware虚拟机中的挂起功能,这个挂起功能就是利用数据的序列化,把虚拟机当前的状态序列化保存在本地磁盘的文件中,然后恢复的时候只需反序列化,把状态恢复即可。
 
另一个原因是通过值将对象从一个应用程序域发送到另一个应用程序域中。例如,你利用Python监控采集程序采集到的数据想传送给Zabbix处理。当两个进程在进行远程通信时,彼此可以发送各种类型的数据。无论是何种类型的数据,都会以二进制序列的形式在网络上传送。发送方需要把这个对象转换为字节序列,才能在网络上传送;接收方则需要把字节序列再恢复为对象。
 
序列化和反序列化:
序列化: 将数据结构或对象转换成二进制串的过程。反序列化:将在序列化过程中所生成的二进制串转换成数据结构或者对象的过程。

序列化的目的就是为了跨进程传递格式化数据和保存某个时刻的状态。
 
什么是数据序列化:
数据序列化就是将对象或者数据结构转化成特定的格式,使其可在网络中传输,或者可存储在内存或者文件中。反序列化则是相反的操作,将对象从序列化数据中还原出来。而对象序列化后的数据格式可以是二进制,可以是XML,也可以是JSON等任何格式。对象/数据序列化的重点在于数据的交换和传输,例如在远程调用技术(如EJB,XML-RPC, Web Service),或者在GUI控件开发(JavaBean)等等。
 
清楚了数据格式化的必要和简单认识了什么是数据格式化之后,我们就来看看Python中两个数据格式化模块的使用。
 

Json Module

Json:用于字符串和 python数据类型间进行转换;
Json模块提供了四个功能:dumps、dump、loads、load
dumps把数据类型转换成字符串 dump把数据类型转换成字符串并存储在文件中 loads把字符串转换成数据类型  load把文件打开从字符串转换成数据类型
实例如下:
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

import json

info = {'1MinLoad': 5, 'MemUse': '5G', 'DiskUse': '80G'}

print('dumps 操作之前数据类型: %s' % type(info))
JsonInfo = json.dumps(info)
print(JsonInfo)
# dumps 将数据通过特殊的形式转换为所有程序语言都识别的字符串
print('dumps 操作之后数据类型: %s' % type(JsonInfo))

# loads 将字符串通过特殊的形式转为python是数据类型 (将字符串转为字典)
NewInfo = json.loads(JsonInfo)
print('loads 操作之后数据类型为: %s' % type(NewInfo))

print('分割线'.center(50, '-'))

# dump 将数据通过特殊的形式转换为所有语言都识别的字符串并写入文件
with open('SystemInfo.txt', 'w') as f:
json.dump(info, f)
print('dump file end!!')

# load 从文件读取字符串并转换为python的数据类型
with open('SystemInfo.txt', 'r') as f:
LoadInfo = json.load(f)
print('load file end, data type is %s' % type(LoadInfo), LoadInfo)结果如下:
dumps 操作之前数据类型: <class 'dict'>
{"MemUse": "5G", "DiskUse": "80G", "1MinLoad": 5}
dumps 操作之后数据类型: <class 'str'>
loads 操作之后数据类型为: <class 'dict'>
-----------------------分割线------------------------
dump file end!!
load file end, data type is <class 'dict'> {'MemUse': '5G', '1MinLoad': 5, 'DiskUse': '80G'}一个错误案例如下:
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

import json


def test():
print('Test Func')

info = {'Name': 'crh', 'age': 18, 'Func': test}

json.dumps(info)结果:
raise TypeError(repr(o) + " is not JSON serializable")
TypeError: <function test at 0x108e7a0d0> is not JSON serializable如上可知函数不能被json序列化。
 

Pickle Module

pickle,用于python特有的类型 和 python的数据类型间进行转换
Pickle模块同样提供了四个功能:dumps、dump、loads、load
dumps把数据类型转换成字符串 dump把数据类型转换成字符串并存储在文件中 loads把字符串转换成数据类型  load把文件打开从字符串转换成数据类型

Pickle可以序列化一些较复杂的数据,和json的区别在于pickle序列化的时候,存放的是二进制的文件,所以打开一个文件的时候,我们要以二进制的格式打开。
 实例如下:
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

import pickle


def test(name):
print('%s write Test Func' % name)

info = {'Name': 'crh', 'age': 18, 'Func': test}

print('dumps 之前数据的类型为: %s' % type(info))

# pickle.dumps 将数据通过特殊的形式转换为只有python语言认识bytes类型(Python2.*中是字符串类型)
NewInfo = pickle.dumps(info)
print('dumps result is %s, data type is %s' % (NewInfo, type(NewInfo)))

# pickle.loads 将bytes通过特殊的形式转为python是数据类型
LoadInfo = pickle.loads(NewInfo)
print('loads result is %s, data type is %s' % (LoadInfo, type(LoadInfo)))
LoadInfo['Func']('crh')

print('分割线'.center(50, '-'))

# pickle.dump 将数据通过特殊的形式转换为只有python语言认识的字符串,并写入文件
with open('pickle.rb', 'wb') as f:
pickle.dump(info, f)

# pickle.load 从文件读取只有python语言认识的字符串并转换为python的数据类型
with open('pickle.rb', 'rb') as f:
Info = pickle.load(f)

print(Info, 'type is %s' % type(Info))结果如下:
dumps 之前数据的类型为: <class 'dict'>
dumps result is b'\x80\x03}q\x00(X\x03\x00\x00\x00ageq\x01K\x12X\x04\x00\x00\x00Nameq\x02X\x03\x00\x00\x00crhq\x03X\x04\x00\x00\x00Funcq\x04c__main__\ntest\nq\x05u.', data type is <class 'bytes'>
loads result is {'age': 18, 'Name': 'crh', 'Func': <function test at 0x1032f10d0>}, data type is <class 'dict'>
crh write Test Func
-----------------------分割线------------------------
{'age': 18, 'Name': 'crh', 'Func': <function test at 0x1032f10d0>} type is <class 'dict'>
 

总结

很多情况下不同的程序之间传送数据我们一般通过文件的方式,但是这个方法是最原始的,而dumps可以直接让数据格式化传送给对方,但是不是所有的程序都是python的,所以只利用pickle是不现实的,比如一个python的程序需要发送一段数据给一个java程序开发的应用,这时候很多内存数据的交换,就得用json了。
 
并且josn能dump的结果更可读,那么有人就问了,那还用pickle做什么不直接用josn,是这样的josn只能把常用的数据类型序列化(列表、字典、列表、字符串、数字、),比如日期格式、类对象!josn就不行了。
 
为什么他不能序列化上面的东西呢?因为josn是跨语言的!注定了它只能规范出一些通用的数据类型的格式,统一标准。
  查看全部
jason.jpg
在介绍Python的数据序列化模块「Json & Pickle」之前,我们先来看看为什么需要数据序列化,什么是数据序列化。
 
为什么需要数据序列化,我认为有如下两种原因:
一个原因是将对象(一切皆对象)的状态保持在存储媒介(硬盘、网盘......)中,以便可以在以后重新创建精确的副本,相当于镜像的概念,比如我们平时利用VMware虚拟机中的挂起功能,这个挂起功能就是利用数据的序列化,把虚拟机当前的状态序列化保存在本地磁盘的文件中,然后恢复的时候只需反序列化,把状态恢复即可。
 
另一个原因是通过值将对象从一个应用程序域发送到另一个应用程序域中。例如,你利用Python监控采集程序采集到的数据想传送给Zabbix处理。当两个进程在进行远程通信时,彼此可以发送各种类型的数据。无论是何种类型的数据,都会以二进制序列的形式在网络上传送。发送方需要把这个对象转换为字节序列,才能在网络上传送;接收方则需要把字节序列再恢复为对象。
 
序列化和反序列化:
  • 序列化: 将数据结构或对象转换成二进制串的过程。
  • 反序列化:将在序列化过程中所生成的二进制串转换成数据结构或者对象的过程。


序列化的目的就是为了跨进程传递格式化数据和保存某个时刻的状态。
 
什么是数据序列化:
数据序列化就是将对象或者数据结构转化成特定的格式,使其可在网络中传输,或者可存储在内存或者文件中。反序列化则是相反的操作,将对象从序列化数据中还原出来。而对象序列化后的数据格式可以是二进制,可以是XML,也可以是JSON等任何格式。对象/数据序列化的重点在于数据的交换和传输,例如在远程调用技术(如EJB,XML-RPC, Web Service),或者在GUI控件开发(JavaBean)等等。
 
清楚了数据格式化的必要和简单认识了什么是数据格式化之后,我们就来看看Python中两个数据格式化模块的使用。
 


Json Module


Json:用于字符串和 python数据类型间进行转换;
Json模块提供了四个功能:dumps、dump、loads、load
  1. dumps把数据类型转换成字符串 
  2. dump把数据类型转换成字符串并存储在文件中 
  3. loads把字符串转换成数据类型  
  4. load把文件打开从字符串转换成数据类型

实例如下:
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

import json

info = {'1MinLoad': 5, 'MemUse': '5G', 'DiskUse': '80G'}

print('dumps 操作之前数据类型: %s' % type(info))
JsonInfo = json.dumps(info)
print(JsonInfo)
# dumps 将数据通过特殊的形式转换为所有程序语言都识别的字符串
print('dumps 操作之后数据类型: %s' % type(JsonInfo))

# loads 将字符串通过特殊的形式转为python是数据类型 (将字符串转为字典)
NewInfo = json.loads(JsonInfo)
print('loads 操作之后数据类型为: %s' % type(NewInfo))

print('分割线'.center(50, '-'))

# dump 将数据通过特殊的形式转换为所有语言都识别的字符串并写入文件
with open('SystemInfo.txt', 'w') as f:
json.dump(info, f)
print('dump file end!!')

# load 从文件读取字符串并转换为python的数据类型
with open('SystemInfo.txt', 'r') as f:
LoadInfo = json.load(f)
print('load file end, data type is %s' % type(LoadInfo), LoadInfo)
结果如下:
dumps 操作之前数据类型: <class 'dict'>
{"MemUse": "5G", "DiskUse": "80G", "1MinLoad": 5}
dumps 操作之后数据类型: <class 'str'>
loads 操作之后数据类型为: <class 'dict'>
-----------------------分割线------------------------
dump file end!!
load file end, data type is <class 'dict'> {'MemUse': '5G', '1MinLoad': 5, 'DiskUse': '80G'}
一个错误案例如下:
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

import json


def test():
print('Test Func')

info = {'Name': 'crh', 'age': 18, 'Func': test}

json.dumps(info)
结果:
 raise TypeError(repr(o) + " is not JSON serializable")
TypeError: <function test at 0x108e7a0d0> is not JSON serializable
如上可知函数不能被json序列化。
 


Pickle Module


pickle,用于python特有的类型 和 python的数据类型间进行转换
Pickle模块同样提供了四个功能:dumps、dump、loads、load
  1. dumps把数据类型转换成字符串 
  2. dump把数据类型转换成字符串并存储在文件中 
  3. loads把字符串转换成数据类型  
  4. load把文件打开从字符串转换成数据类型


Pickle可以序列化一些较复杂的数据,和json的区别在于pickle序列化的时候,存放的是二进制的文件,所以打开一个文件的时候,我们要以二进制的格式打开。
 实例如下:
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

import pickle


def test(name):
print('%s write Test Func' % name)

info = {'Name': 'crh', 'age': 18, 'Func': test}

print('dumps 之前数据的类型为: %s' % type(info))

# pickle.dumps 将数据通过特殊的形式转换为只有python语言认识bytes类型(Python2.*中是字符串类型)
NewInfo = pickle.dumps(info)
print('dumps result is %s, data type is %s' % (NewInfo, type(NewInfo)))

# pickle.loads 将bytes通过特殊的形式转为python是数据类型
LoadInfo = pickle.loads(NewInfo)
print('loads result is %s, data type is %s' % (LoadInfo, type(LoadInfo)))
LoadInfo['Func']('crh')

print('分割线'.center(50, '-'))

# pickle.dump 将数据通过特殊的形式转换为只有python语言认识的字符串,并写入文件
with open('pickle.rb', 'wb') as f:
pickle.dump(info, f)

# pickle.load 从文件读取只有python语言认识的字符串并转换为python的数据类型
with open('pickle.rb', 'rb') as f:
Info = pickle.load(f)

print(Info, 'type is %s' % type(Info))
结果如下:
dumps 之前数据的类型为: <class 'dict'>
dumps result is b'\x80\x03}q\x00(X\x03\x00\x00\x00ageq\x01K\x12X\x04\x00\x00\x00Nameq\x02X\x03\x00\x00\x00crhq\x03X\x04\x00\x00\x00Funcq\x04c__main__\ntest\nq\x05u.', data type is <class 'bytes'>
loads result is {'age': 18, 'Name': 'crh', 'Func': <function test at 0x1032f10d0>}, data type is <class 'dict'>
crh write Test Func
-----------------------分割线------------------------
{'age': 18, 'Name': 'crh', 'Func': <function test at 0x1032f10d0>} type is <class 'dict'>

 


总结


很多情况下不同的程序之间传送数据我们一般通过文件的方式,但是这个方法是最原始的,而dumps可以直接让数据格式化传送给对方,但是不是所有的程序都是python的,所以只利用pickle是不现实的,比如一个python的程序需要发送一段数据给一个java程序开发的应用,这时候很多内存数据的交换,就得用json了。
 
并且josn能dump的结果更可读,那么有人就问了,那还用pickle做什么不直接用josn,是这样的josn只能把常用的数据类型序列化(列表、字典、列表、字符串、数字、),比如日期格式、类对象!josn就不行了。
 
为什么他不能序列化上面的东西呢?因为josn是跨语言的!注定了它只能规范出一些通用的数据类型的格式,统一标准。
 

Python 备份Mysql

编程语言Not see︶ 发表了文章 • 0 个评论 • 294 次浏览 • 2016-09-23 19:26 • 来自相关话题

#!/usr/bin/env python
# Filename: mysql_backup.py
# author:kevin yang
# email:zhiwen.yang@showself.com
# date:2016-09-23
import os
import time
import sys
import datetime
from stat import *

# mysql user
User = 'root'

# mysql password
Passwd = '123456'

# mysqldump command
Mysqlcommand = 'mysqldump'

# gzip command
Gzipcommand = '/bin/gzip'

# you want backup mysql database
Mysqldata = ['PHPCMS', 'TeamToy']

# you want backup to dir
Tobackup = '/data/mysql_bak/'

for DB in Mysqldata:
# backup file name
Backfile = Tobackup + DB + '-' + time.strftime('%Y-%m-%d') + '.sql'
# gzip file name
Gzfile = Backfile +'.gz'
if os.path.isfile(Gzfile):
print Gzfile + " is already backup"
else:
# backup command
Back_command = Mysqlcommand + ' -u' + User + ' -p' + Passwd + ' -P3306 ' + DB + ' > ' + Backfile
if os.system(Back_command)==0:
print 'Successful backup to', DB + ' to ' + Backfile
else:
print 'Backup FAILED'
# gzip command
Gzip_command = Gzipcommand + ' ' + Backfile
if os.system(Gzip_command)==0:
print 'Successful Gzip to',Gzfile
else:
print 'Gzip FAILED'

# Delete back file
# show file list
filelist=[]
filelist=os.listdir(Tobackup)
# delete Gzfile 5 days ago
for i in range(len(filelist)):
ft=time.gmtime(os.stat(Tobackup+filelist[i])[ST_MTIME])
ftl=time.strftime('%Y-%m-%d',ft)
year,month,day=ftl.split('-')
ftll=datetime.datetime(int(year),int(month),int(day))
localt=time.gmtime()
localtl=time.strftime('%Y-%m-%d',localt)
year,month,day=localtl.split('-')
localtll=datetime.datetime(int(year),int(month),int(day))
days=(localtll-ftll).days
if days >5:
try:
os.remove(Tobackup+filelist[i])
print 'delete is ok'
except:
log=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')+" remove "+Tobackup+filelist[i]+" fail \n"
print log 查看全部
#!/usr/bin/env python
# Filename: mysql_backup.py
# author:kevin yang
# email:zhiwen.yang@showself.com
# date:2016-09-23
import os
import time
import sys
import datetime
from stat import *

# mysql user
User = 'root'

# mysql password
Passwd = '123456'

# mysqldump command
Mysqlcommand = 'mysqldump'

# gzip command
Gzipcommand = '/bin/gzip'

# you want backup mysql database
Mysqldata = ['PHPCMS', 'TeamToy']

# you want backup to dir
Tobackup = '/data/mysql_bak/'

for DB in Mysqldata:
# backup file name
Backfile = Tobackup + DB + '-' + time.strftime('%Y-%m-%d') + '.sql'
# gzip file name
Gzfile = Backfile +'.gz'
if os.path.isfile(Gzfile):
print Gzfile + " is already backup"
else:
# backup command
Back_command = Mysqlcommand + ' -u' + User + ' -p' + Passwd + ' -P3306 ' + DB + ' > ' + Backfile
if os.system(Back_command)==0:
print 'Successful backup to', DB + ' to ' + Backfile
else:
print 'Backup FAILED'
# gzip command
Gzip_command = Gzipcommand + ' ' + Backfile
if os.system(Gzip_command)==0:
print 'Successful Gzip to',Gzfile
else:
print 'Gzip FAILED'

# Delete back file
# show file list
filelist=[]
filelist=os.listdir(Tobackup)
# delete Gzfile 5 days ago
for i in range(len(filelist)):
ft=time.gmtime(os.stat(Tobackup+filelist[i])[ST_MTIME])
ftl=time.strftime('%Y-%m-%d',ft)
year,month,day=ftl.split('-')
ftll=datetime.datetime(int(year),int(month),int(day))
localt=time.gmtime()
localtl=time.strftime('%Y-%m-%d',localt)
year,month,day=localtl.split('-')
localtll=datetime.datetime(int(year),int(month),int(day))
days=(localtll-ftll).days
if days >5:
try:
os.remove(Tobackup+filelist[i])
print 'delete is ok'
except:
log=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')+" remove "+Tobackup+filelist[i]+" fail \n"
print log

Python程序软件目录规范化

编程语言采菊篱下 发表了文章 • 0 个评论 • 301 次浏览 • 2016-09-21 15:18 • 来自相关话题

为什么要设计好目录结构?

"设计项目目录结构",就和"代码编码风格"一样,属于个人风格问题。对于这种风格上的规范,一直都存在两种态度:
一类同学认为,这种个人风格问题"无关紧要"。理由是能让程序work就好,风格问题根本不是问题;另一类同学认为,规范化能更好的控制程序结构,让程序具有更高的可读性。
 
我是比较偏向于后者的,因为我是前一类同学思想行为下的直接受害者。我曾经维护过一个非常不好读的项目,其实现的逻辑并不复杂,但是却耗费了我非常长的时间去理解它想表达的意思。从此我个人对于提高项目可读性、可维护性的要求就很高了。"项目目录结构"其实也是属于"可读性和可维护性"的范畴,我们设计一个层次清晰的目录结构,就是为了达到以下两点:
可读性高: 不熟悉这个项目的代码的人,一眼就能看懂目录结构,知道程序启动脚本是哪个,测试目录在哪儿,配置文件在哪儿等等。从而非常快速的了解这个项目。可维护性高: 定义好组织规则后,维护者就能很明确地知道,新增的哪个文件和代码应该放在什么目录之下。这个好处是,随着时间的推移,代码/配置的规模增加,项目结构不会混乱,仍然能够组织良好。
 
所以,保持一个层次清晰的目录结构是有必要的。更何况组织一个良好的工程目录,其实是一件很简单的事儿。
 

目录组织方式

关于如何组织一个较好的Python工程目录结构,已经有一些得到了共识的目录结构。在Stackoverflow关于这个问题 ,可以看到很多赞同对Python目录结构规范的情况。

假设你的项目名为foo, 我比较建议的最方便快捷目录结构这样就足够了:Foo/
|-- bin/
| |-- foo
|
|-- foo/
| |-- tests/
| | |-- __init__.py
| | |-- test_main.py
| |
| |-- __init__.py
| |-- main.py
|
|-- docs/
| |-- conf.py
| |-- abc.rst
|
|-- setup.py
|-- requirements.txt
|-- README简要解释一下:
bin/: 存放项目的一些可执行文件,当然你可以起名script/之类的也行。foo/: 存放项目的所有源代码。(1) 源代码中的所有模块、包都应该放在此目录。不要置于顶层目录。(2) 其子目录tests/存放单元测试代码; (3) 程序的入口最好命名为main.py。docs/: 存放一些文档。setup.py: 安装、部署、打包的脚本。requirements.txt: 存放软件依赖的外部Python包列表。README: 项目说明文件。
 
除此之外,有一些方案给出了更加多的内容。比如LICENSE.txt,ChangeLog.txt文件等,我没有列在这里,因为这些东西主要是项目开源的时候需要用到。如果你想写一个开源软件,目录该如何组织,可以参考开源Python项目的正确方法 。

关于README的内容 

这个我觉得是每个项目都应该有的一个文件,目的是能简要描述该项目的信息,让读者快速了解这个项目。
 
它需要说明以下几个事项:
软件定位,软件的基本功能。运行代码的方法: 安装环境、启动命令等。简要的使用说明。代码目录结构说明,更详细点可以说明软件的基本原理。常见问题说明。
我觉得有以上几点是比较好的一个README。在软件开发初期,由于开发过程中以上内容可能不明确或者发生变化,并不是一定要在一开始就将所有信息都补全。但是在项目完结的时候,是需要撰写这样的一个文档的。
 
可以参考Redis源码中Readme的写法,这里面简洁清晰的描述了Redis功能和源码结构。

关于requirements.txt和setup.py

setup.py
 
一般来说,用setup.py来管理代码的打包、安装、部署问题。业界标准的写法是用Python流行的打包工具setuptools 来管理这些事情。这种方式普遍应用于开源项目中。不过这里的核心思想不是用标准化的工具来解决这些问题,而是说,一个项目一定要有一个安装部署工具,能快速便捷的在一台新机器上将环境装好、代码部署好和将程序运行起来。
 
我想大多数人是踩过坑的,刚开始接触Python写项目的时候,安装环境、部署代码、运行程序这个过程全是手动完成,遇到过以下问题:
安装环境时经常忘了最近又添加了一个新的Python包,结果一到线上运行,程序就出错了。Python包的版本依赖问题,有时候我们程序中使用的是一个版本的Python包,但是官方的已经是最新的包了,通过手动安装就可能装错了。如果依赖的包很多的话,一个一个安装这些依赖是很费时的事情。新同学开始写项目的时候,将程序跑起来非常麻烦,因为可能经常忘了要怎么安装各种依赖。
setup.py可以将这些事情自动化起来,提高效率、减少出错的概率。"复杂的东西自动化,能自动化的东西一定要自动化。"是一个非常好的习惯。

setuptools的文档比较庞大,刚接触的话,可能不太好找到切入点。学习技术的方式就是看他人是怎么用的,可以参考一下Python的一个Web框架,flask是如何写的:setup.py 。
 
当然,简单点自己写个安装脚本(deploy.sh)替代setup.py也未尝不可。

requirements.txt

这个文件存在的目的是:
方便开发者维护软件的包依赖。将开发过程中新增的包添加进这个列表中,避免在setup.py安装依赖时漏掉软件包。方便读者明确项目使用了哪些Python包。
这个文件的格式是每一行包含一个包依赖的说明,通常是flask>=0.10这种格式,要求是这个格式能被pip识别,这样就可以简单的通过 pip install -r requirements.txt来把所有Python包依赖都装好了。具体格式说明参考 。
 
关于配置文件的使用方法
注意,在上面的目录结构中,没有将conf.py放在源码目录下,而是放在docs/目录下。
 
很多项目对配置文件的使用做法是:
配置文件写在一个或多个python文件中,比如此处的conf.py。项目中哪个模块用到这个配置文件就直接通过import conf这种形式来在代码中使用配置。
 
这种做法我不太赞同:
这让单元测试变得困难(因为模块内部依赖了外部配置)另一方面配置文件作为用户控制程序的接口,应当可以由用户自由指定该文件的路径。程序组件可复用性太差,因为这种贯穿所有模块的代码硬编码方式,使得大部分模块都依赖conf.py这个文件。
 
所以,我认为配置的使用,更好的方式:
模块的配置都是可以灵活配置的,不受外部配置文件的影响。程序的配置也是可以灵活控制的。
 
能够佐证这个思想的是,用过nginx和mysql的同学都知道,nginx、mysql这些程序都可以自由的指定用户配置。

所以,不应当在代码中直接import conf来使用配置文件。上面目录结构中的conf.py,是给出的一个配置样例,不是在写死在程序中直接引用的配置文件。可以通过给main.py启动参数指定配置路径的方式来让程序读取配置内容。当然,这里的conf.py你可以换个类似的名字,比如settings.py。或者你也可以使用其他格式的内容来编写配置文件,比如settings.yaml之类的。 查看全部


为什么要设计好目录结构?


"设计项目目录结构",就和"代码编码风格"一样,属于个人风格问题。对于这种风格上的规范,一直都存在两种态度:
  1. 一类同学认为,这种个人风格问题"无关紧要"。理由是能让程序work就好,风格问题根本不是问题;
  2. 另一类同学认为,规范化能更好的控制程序结构,让程序具有更高的可读性。

 
我是比较偏向于后者的,因为我是前一类同学思想行为下的直接受害者。我曾经维护过一个非常不好读的项目,其实现的逻辑并不复杂,但是却耗费了我非常长的时间去理解它想表达的意思。从此我个人对于提高项目可读性、可维护性的要求就很高了。"项目目录结构"其实也是属于"可读性和可维护性"的范畴,我们设计一个层次清晰的目录结构,就是为了达到以下两点:
  1. 可读性高: 不熟悉这个项目的代码的人,一眼就能看懂目录结构,知道程序启动脚本是哪个,测试目录在哪儿,配置文件在哪儿等等。从而非常快速的了解这个项目。
  2. 可维护性高: 定义好组织规则后,维护者就能很明确地知道,新增的哪个文件和代码应该放在什么目录之下。这个好处是,随着时间的推移,代码/配置的规模增加,项目结构不会混乱,仍然能够组织良好。

 
所以,保持一个层次清晰的目录结构是有必要的。更何况组织一个良好的工程目录,其实是一件很简单的事儿。
 


目录组织方式


关于如何组织一个较好的Python工程目录结构,已经有一些得到了共识的目录结构。在Stackoverflow关于这个问题 ,可以看到很多赞同对Python目录结构规范的情况。

假设你的项目名为foo, 我比较建议的最方便快捷目录结构这样就足够了:
Foo/
|-- bin/
| |-- foo
|
|-- foo/
| |-- tests/
| | |-- __init__.py
| | |-- test_main.py
| |
| |-- __init__.py
| |-- main.py
|
|-- docs/
| |-- conf.py
| |-- abc.rst
|
|-- setup.py
|-- requirements.txt
|-- README
简要解释一下:
  1. bin/: 存放项目的一些可执行文件,当然你可以起名script/之类的也行。
  2. foo/: 存放项目的所有源代码。(1) 源代码中的所有模块、包都应该放在此目录。不要置于顶层目录。(2) 其子目录tests/存放单元测试代码; (3) 程序的入口最好命名为main.py。
  3. docs/: 存放一些文档。
  4. setup.py: 安装、部署、打包的脚本。
  5. requirements.txt: 存放软件依赖的外部Python包列表。
  6. README: 项目说明文件。

 
除此之外,有一些方案给出了更加多的内容。比如LICENSE.txt,ChangeLog.txt文件等,我没有列在这里,因为这些东西主要是项目开源的时候需要用到。如果你想写一个开源软件,目录该如何组织,可以参考开源Python项目的正确方法 。


关于README的内容 


这个我觉得是每个项目都应该有的一个文件,目的是能简要描述该项目的信息,让读者快速了解这个项目。
 
它需要说明以下几个事项:
  1. 软件定位,软件的基本功能。
  2. 运行代码的方法: 安装环境、启动命令等。
  3. 简要的使用说明。
  4. 代码目录结构说明,更详细点可以说明软件的基本原理。
  5. 常见问题说明。

我觉得有以上几点是比较好的一个README。在软件开发初期,由于开发过程中以上内容可能不明确或者发生变化,并不是一定要在一开始就将所有信息都补全。但是在项目完结的时候,是需要撰写这样的一个文档的。
 
可以参考Redis源码中Readme的写法,这里面简洁清晰的描述了Redis功能和源码结构。


关于requirements.txt和setup.py


setup.py
 
一般来说,用setup.py来管理代码的打包、安装、部署问题。业界标准的写法是用Python流行的打包工具setuptools 来管理这些事情。这种方式普遍应用于开源项目中。不过这里的核心思想不是用标准化的工具来解决这些问题,而是说,一个项目一定要有一个安装部署工具,能快速便捷的在一台新机器上将环境装好、代码部署好和将程序运行起来。
 
我想大多数人是踩过坑的,刚开始接触Python写项目的时候,安装环境、部署代码、运行程序这个过程全是手动完成,遇到过以下问题:
  1. 安装环境时经常忘了最近又添加了一个新的Python包,结果一到线上运行,程序就出错了。
  2. Python包的版本依赖问题,有时候我们程序中使用的是一个版本的Python包,但是官方的已经是最新的包了,通过手动安装就可能装错了。
  3. 如果依赖的包很多的话,一个一个安装这些依赖是很费时的事情。
  4. 新同学开始写项目的时候,将程序跑起来非常麻烦,因为可能经常忘了要怎么安装各种依赖。

setup.py可以将这些事情自动化起来,提高效率、减少出错的概率。"复杂的东西自动化,能自动化的东西一定要自动化。"是一个非常好的习惯。

setuptools的文档比较庞大,刚接触的话,可能不太好找到切入点。学习技术的方式就是看他人是怎么用的,可以参考一下Python的一个Web框架,flask是如何写的:setup.py 。
 
当然,简单点自己写个安装脚本(deploy.sh)替代setup.py也未尝不可。


requirements.txt


这个文件存在的目的是:
  1. 方便开发者维护软件的包依赖。将开发过程中新增的包添加进这个列表中,避免在setup.py安装依赖时漏掉软件包。
  2. 方便读者明确项目使用了哪些Python包。

这个文件的格式是每一行包含一个包依赖的说明,通常是flask>=0.10这种格式,要求是这个格式能被pip识别,这样就可以简单的通过 pip install -r requirements.txt来把所有Python包依赖都装好了。具体格式说明参考 。
 
关于配置文件的使用方法
注意,在上面的目录结构中,没有将conf.py放在源码目录下,而是放在docs/目录下。
 
很多项目对配置文件的使用做法是:
  1. 配置文件写在一个或多个python文件中,比如此处的conf.py。
  2. 项目中哪个模块用到这个配置文件就直接通过import conf这种形式来在代码中使用配置。

 
这种做法我不太赞同:
  1. 这让单元测试变得困难(因为模块内部依赖了外部配置)
  2. 另一方面配置文件作为用户控制程序的接口,应当可以由用户自由指定该文件的路径。
  3. 程序组件可复用性太差,因为这种贯穿所有模块的代码硬编码方式,使得大部分模块都依赖conf.py这个文件。

 
所以,我认为配置的使用,更好的方式:
  1. 模块的配置都是可以灵活配置的,不受外部配置文件的影响。
  2. 程序的配置也是可以灵活控制的。

 
能够佐证这个思想的是,用过nginx和mysql的同学都知道,nginx、mysql这些程序都可以自由的指定用户配置。

所以,不应当在代码中直接import conf来使用配置文件。上面目录结构中的conf.py,是给出的一个配置样例,不是在写死在程序中直接引用的配置文件。可以通过给main.py启动参数指定配置路径的方式来让程序读取配置内容。当然,这里的conf.py你可以换个类似的名字,比如settings.py。或者你也可以使用其他格式的内容来编写配置文件,比如settings.yaml之类的。

Memcached和Redis监控脚本分享

开源技术push 发表了文章 • 0 个评论 • 242 次浏览 • 2016-09-20 16:05 • 来自相关话题

Memcached:
#!/usr/bin/env python
#coding=utf8

import sys
import os

class GetMemStatus():
def __init__(self):
self.val = {}
def check(self):
try:
import memcache
self.mc = memcache.Client(['127.0.0.1:11211'], debug=0)
except:
raise Exception, 'Plugin needs the memcache module'

def extract(self, key):
stats = self.mc.get_stats()
try:
if key in stats[0][1]:
self.val[key] = stats[0][1][key]
return self.val[key]
except:
raise Exception, 'ERROR: key is not in stats!!!'

def main():
if len(sys.argv) == 1:
print "ERROR! Please enter a key"
elif len(sys.argv) == 2:
key = sys.argv[1]
a = GetMemStatus()
a.check()
print a.extract(key)

if __name__ == "__main__":
main()
Redis:
#!/usr/bin/env python
#coding=utf8

import sys
import os

class GetRedisStatus():
def __init__(self):
self.val = {}
def check(self):
try:
import redis
self.redis = redis.Redis('127.0.0.1', port=6379, password=None)
except:
raise Exception, 'Plugin needs the redis module'

def extract(self, key):
info = self.redis.info()
try:
if key in info:
self.val[key] = info[key]
return self.val[key]
except:
raise Exception, 'ERROR info not include this key!'

def main():
if len(sys.argv) == 1:
print "ERROR! Please enter a key"
elif len(sys.argv) == 2:
key = sys.argv[1]
a = GetRedisStatus()
a.check()
print a.extract(key)

if __name__ == "__main__":
main() 查看全部
Memcached:
#!/usr/bin/env python
#coding=utf8

import sys
import os

class GetMemStatus():
def __init__(self):
self.val = {}
def check(self):
try:
import memcache
self.mc = memcache.Client(['127.0.0.1:11211'], debug=0)
except:
raise Exception, 'Plugin needs the memcache module'

def extract(self, key):
stats = self.mc.get_stats()
try:
if key in stats[0][1]:
self.val[key] = stats[0][1][key]
return self.val[key]
except:
raise Exception, 'ERROR: key is not in stats!!!'

def main():
if len(sys.argv) == 1:
print "ERROR! Please enter a key"
elif len(sys.argv) == 2:
key = sys.argv[1]
a = GetMemStatus()
a.check()
print a.extract(key)

if __name__ == "__main__":
main()

Redis:
#!/usr/bin/env python
#coding=utf8

import sys
import os

class GetRedisStatus():
def __init__(self):
self.val = {}
def check(self):
try:
import redis
self.redis = redis.Redis('127.0.0.1', port=6379, password=None)
except:
raise Exception, 'Plugin needs the redis module'

def extract(self, key):
info = self.redis.info()
try:
if key in info:
self.val[key] = info[key]
return self.val[key]
except:
raise Exception, 'ERROR info not include this key!'

def main():
if len(sys.argv) == 1:
print "ERROR! Please enter a key"
elif len(sys.argv) == 2:
key = sys.argv[1]
a = GetRedisStatus()
a.check()
print a.extract(key)

if __name__ == "__main__":
main()

Python编码解析

编程语言采菊篱下 发表了文章 • 0 个评论 • 351 次浏览 • 2016-09-09 17:38 • 来自相关话题

一般我们在Python2.7的环境进行Python的编程的时候,一般头部会加#-*- coding:utf-8 -*- ​来声明编码类型为utf-8的编码,那为什么要声明,一定要声明吗?

针对如上问题我们先来讨论另外一个问题,为什么我们可以在显示器上能看到这些文字、数字、图片、字符、等等信息呢?大家都知道计算机本身只能识别 0  1 的组合,他们是怎么展示这些内容的呢?我们怎么和计算机去沟通呢?

如果我们使用0 1 的组合和计算机沟通你还能看到这些内容吗?还有一个问题就是01的组合我相信对于常人类都是没有办法看懂的。

那怎么办?如何让计算机理解我们的语言,并且我们能理解计算机的语言呢?

举个比较形象的例子,中英文词典对照表,这样我们就可以把中英文进行互相的翻译了呢?对不对!同理计算机也是这样的他需要一个标准的对照关系,那么这个标准最早叫什么呢?ASCII表




表格内容大致如下:
有特殊符号、大写字母、小写字母、数字(这里注意下0~9的数字是字符),在这些字符左边都有一个10进制的数字。但是对于10进制来说计算机他也是不能理解的,因为他只能理解0 1 ,但是10进制和2进制的转换就非常容易了!

举例来说:如果我在键盘上按一个A字母的时候那么实际是给计算机传输了一个数字65,通过这样的机制和计算机沟通,有了这个ASCII码表就可以和任何计算机进行沟通了。

这里在看个知识点:计算机中最小的单位是什么?bit   bit就咱们常说一位二进制,一位二进制要么是0 要么是 1

但是bit这个单位太小了,我们用字节(byte)来表示。他们是有换算的规则的(看下面的规则我想大家都不是很陌生对吧):8b = 1B #小b=bit ; 大B=byte
1024B = 1KB
1024KB = 1M
1024M = 1G
1024G = 1T 在存储英文的时候我们至少需要1个字节(一个字母),就是8位(bit),看下ASCII表中1个字节就可以表示所有的英文所需要的字符,是不非常高效!

为什么呢?早期的计算机的空间是非常宝贵的!

那你会发现1个字节8位,他能存储的最大数据是2的8次方-1 = 255,一个字节最多能表示255个字符 那西方国家他们使用了127个字符,那么剩下字符是做什么的呢?就是用来做扩展的,西方人考虑到还有其他国家。所以留下了扩展位。

但是呢有问题,计算机是西方人发明的,如果仅仅支持英文的话,这127个字符完全就可以表示所有英文中能用的的内容了。但是他没有考虑咱们大中国啊!ASCII到了中国之后发现:咱们中国最常用的中文都有6000多个完全不够用啊!

但是怎们办?中国人非常聪明:就在原有的扩展位中,扩展出自己的gbk、gb2312、gb2318字符编码。 

他是怎么扩展的呢?比如说在ASCII码中的128这个位置,这个位置又指定一张单独表,聪明吧! 其他国家也是这样设计的!

中国东亚大国是吧,我们国家比较NB,我要兼容其他国家的常用的编码!比如韩国日本,因为韩国和日本人家都有自己的编码,人家根本就不鸟你,举个例子来说,比如韩国的游戏,在中国下载安装之后会出现乱码的情况?什么鬼?

这种乱码的出现基本上就两种情况:
1、字符编码没有
2、字符编码冲突了,人家在写这个程序的时候指定的字符集和咱们使用的字符集的位置不对。 

你想想不光是亚洲国家这样,欧洲国家,非洲国家都会存在这个问题,基于这个乱象国际互联网组织就说你们各个国家都别搞了,我们给你们搞一个统一的,这个统一的是什么呢Unicode“万国编码”。

Unicode(统一码、万国码、单一码)是一种在计算机上使用的字符编码。Unicode 是为了解决传统的字符编码方案的局限而产生的,它为每种语言中的每个字符设定了统一并且唯一的二进制编码,规定虽有的字符和符号最少由 16 位来表示(2个字节),即:2 **16 = 65536, 注:此处说的的是最少2个字节,可能更多。

这里还有个问题:使用的字节增加了,那么造成的直接影响就是使用的空间就直接翻倍了!举例还说:同样是ABCD这些字符存储一篇相同的文章,使用ASCII码如果是1M的话,那么Unicode存储至少2M可能还会更多。

为了解决个问题就出现了:UTF-8编码

UTF-8编码:是对Unicode编码的压缩和优化,他不再使用最少使用2个字节,而是将所有的字符和符号进行分类:ascii码中的内容用1个字节保存、欧洲的字符用2个字节保存,东亚的字符用3个字节保存...

通过这种可扩展的方式来存储。

OK 上面了解了:
1、什么ASCII编码
2、什么Unicode编码
3、什么UTF-8编码

回顾下乱码的出现原因:1、没有字符集 2、字符集冲突

回过头来看下为什么需要在第二行加上指定编码呢?在2.x版本的Python中Pyton在解释.py文件的时候,默认是给他一个编码的就是ASCII码,so如果在2.7版本中如果你不指定编码并且在.py文件中写了一个ASCII码中没有的字符就会显示乱码 。

不过这个问题在Python3中就不存在了,因为在Python3中默认就是Unicode编码。

Python编码转换

有一个问题,既然有统一的Unicode编码了,为毛还需要编码转换?大家都统一一个编码不就可以了吗?

不要问我为什么,我问你们个问题,如果世界上出了一种世界语言,你会放弃中文吗?去使用这个世界通用语言吗?这就是个坑,是个遗留问题。

但是虽然以后可能世界语言会慢慢替代咱们常用的语言,大家以后沟通就使用世界语言就不会有沟通障碍了对吧。(就是举个例子)

还有一个情况是什么呢?韩国的游戏到中国来之后,是乱码?结合上一个回答咱们可以猜出:编写这个游戏的人在编写游戏的时候可能根本就没有考虑出口其他国家。那如果没有这个Unicode编码的话,到咱们这里来显示肯定是乱码是吧。

那就得需要通过转码把他们编码集,转换为Unicode(utf-8)编码集。这样他们就可以正常显示韩文了!(这里只是转编码集并不是翻译成中文不要弄混了~~!)

Python3中的编码转换
#在Python3中默认就是unicode编码#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

tim = '华仔'
#转为UTF-8编码
print(tim.encode('UTF-8'))

#转为GBK编码
print(tim.encode('GBK'))

#转为ASCII编码(报错为什么?因为ASCII码表中没有‘华仔’这个字符集~~)
print(tim.encode('ASCII'))



 
二、Python2.X中的编码转换
#因为在python2.X中默认是ASCII编码,你在文件中指定编码为UTF-8,但是UTF-8如果你想转GBK的话是不能直接转,需要Unicode做一个中间人转换角色。




#!/usr/bin/env python2
# _*_coding:utf-8_*_
# Author: Lucky.chen

import sys
print(sys.getdefaultencoding())


msg = "我爱北京天安门"
msg_gb2312 = msg.decode("utf-8").encode("gb2312")
gb2312_to_gbk = msg_gb2312.decode("gbk").encode("gbk")

print(msg)
print(msg_gb2312)
print(gb2312_to_gbk) 查看全部
一般我们在Python2.7的环境进行Python的编程的时候,一般头部会加#-*- coding:utf-8 -*- ​来声明编码类型为utf-8的编码,那为什么要声明,一定要声明吗?

针对如上问题我们先来讨论另外一个问题,为什么我们可以在显示器上能看到这些文字、数字、图片、字符、等等信息呢?大家都知道计算机本身只能识别 0  1 的组合,他们是怎么展示这些内容的呢?我们怎么和计算机去沟通呢?

如果我们使用0 1 的组合和计算机沟通你还能看到这些内容吗?还有一个问题就是01的组合我相信对于常人类都是没有办法看懂的。

那怎么办?如何让计算机理解我们的语言,并且我们能理解计算机的语言呢?

举个比较形象的例子,中英文词典对照表,这样我们就可以把中英文进行互相的翻译了呢?对不对!同理计算机也是这样的他需要一个标准的对照关系,那么这个标准最早叫什么呢?ASCII表
ascii.gif

表格内容大致如下:
有特殊符号、大写字母、小写字母、数字(这里注意下0~9的数字是字符),在这些字符左边都有一个10进制的数字。但是对于10进制来说计算机他也是不能理解的,因为他只能理解0 1 ,但是10进制和2进制的转换就非常容易了!

举例来说:如果我在键盘上按一个A字母的时候那么实际是给计算机传输了一个数字65,通过这样的机制和计算机沟通,有了这个ASCII码表就可以和任何计算机进行沟通了。

这里在看个知识点:计算机中最小的单位是什么?bit   bit就咱们常说一位二进制,一位二进制要么是0 要么是 1

但是bit这个单位太小了,我们用字节(byte)来表示。他们是有换算的规则的(看下面的规则我想大家都不是很陌生对吧):
8b = 1B  #小b=bit ; 大B=byte
1024B = 1KB
1024KB = 1M
1024M = 1G
1024G = 1T
在存储英文的时候我们至少需要1个字节(一个字母),就是8位(bit),看下ASCII表中1个字节就可以表示所有的英文所需要的字符,是不非常高效!

为什么呢?早期的计算机的空间是非常宝贵的!

那你会发现1个字节8位,他能存储的最大数据是2的8次方-1 = 255,一个字节最多能表示255个字符 那西方国家他们使用了127个字符,那么剩下字符是做什么的呢?就是用来做扩展的,西方人考虑到还有其他国家。所以留下了扩展位。

但是呢有问题,计算机是西方人发明的,如果仅仅支持英文的话,这127个字符完全就可以表示所有英文中能用的的内容了。但是他没有考虑咱们大中国啊!ASCII到了中国之后发现:咱们中国最常用的中文都有6000多个完全不够用啊!

但是怎们办?中国人非常聪明:就在原有的扩展位中,扩展出自己的gbk、gb2312、gb2318字符编码。 

他是怎么扩展的呢?比如说在ASCII码中的128这个位置,这个位置又指定一张单独表,聪明吧! 其他国家也是这样设计的!

中国东亚大国是吧,我们国家比较NB,我要兼容其他国家的常用的编码!比如韩国日本,因为韩国和日本人家都有自己的编码,人家根本就不鸟你,举个例子来说,比如韩国的游戏,在中国下载安装之后会出现乱码的情况?什么鬼?

这种乱码的出现基本上就两种情况:
1、字符编码没有
2、字符编码冲突了,人家在写这个程序的时候指定的字符集和咱们使用的字符集的位置不对。 

你想想不光是亚洲国家这样,欧洲国家,非洲国家都会存在这个问题,基于这个乱象国际互联网组织就说你们各个国家都别搞了,我们给你们搞一个统一的,这个统一的是什么呢Unicode“万国编码”

Unicode(统一码、万国码、单一码)是一种在计算机上使用的字符编码。Unicode 是为了解决传统的字符编码方案的局限而产生的,它为每种语言中的每个字符设定了统一并且唯一的二进制编码,规定虽有的字符和符号最少由 16 位来表示(2个字节),即:2 **16 = 65536, 注:此处说的的是最少2个字节,可能更多。

这里还有个问题:使用的字节增加了,那么造成的直接影响就是使用的空间就直接翻倍了!举例还说:同样是ABCD这些字符存储一篇相同的文章,使用ASCII码如果是1M的话,那么Unicode存储至少2M可能还会更多。

为了解决个问题就出现了:UTF-8编码

UTF-8编码:是对Unicode编码的压缩和优化,他不再使用最少使用2个字节,而是将所有的字符和符号进行分类:ascii码中的内容用1个字节保存、欧洲的字符用2个字节保存,东亚的字符用3个字节保存...

通过这种可扩展的方式来存储。

OK 上面了解了:
1、什么ASCII编码
2、什么Unicode编码
3、什么UTF-8编码

回顾下乱码的出现原因:1、没有字符集 2、字符集冲突

回过头来看下为什么需要在第二行加上指定编码呢?在2.x版本的Python中Pyton在解释.py文件的时候,默认是给他一个编码的就是ASCII码,so如果在2.7版本中如果你不指定编码并且在.py文件中写了一个ASCII码中没有的字符就会显示乱码 。

不过这个问题在Python3中就不存在了,因为在Python3中默认就是Unicode编码。


Python编码转换


有一个问题,既然有统一的Unicode编码了,为毛还需要编码转换?大家都统一一个编码不就可以了吗?

不要问我为什么,我问你们个问题,如果世界上出了一种世界语言,你会放弃中文吗?去使用这个世界通用语言吗?这就是个坑,是个遗留问题。

但是虽然以后可能世界语言会慢慢替代咱们常用的语言,大家以后沟通就使用世界语言就不会有沟通障碍了对吧。(就是举个例子)

还有一个情况是什么呢?韩国的游戏到中国来之后,是乱码?结合上一个回答咱们可以猜出:编写这个游戏的人在编写游戏的时候可能根本就没有考虑出口其他国家。那如果没有这个Unicode编码的话,到咱们这里来显示肯定是乱码是吧。

那就得需要通过转码把他们编码集,转换为Unicode(utf-8)编码集。这样他们就可以正常显示韩文了!(这里只是转编码集并不是翻译成中文不要弄混了~~!)

Python3中的编码转换
#在Python3中默认就是unicode编码
#!/usr/bin/env python3
# _*_coding:utf-8_*_
# Author: Lucky.chen

tim = '华仔'
#转为UTF-8编码
print(tim.encode('UTF-8'))

#转为GBK编码
print(tim.encode('GBK'))

#转为ASCII编码(报错为什么?因为ASCII码表中没有‘华仔’这个字符集~~)
print(tim.encode('ASCII'))
EncodeError.png

 
二、Python2.X中的编码转换
#因为在python2.X中默认是ASCII编码,你在文件中指定编码为UTF-8,但是UTF-8如果你想转GBK的话是不能直接转,需要Unicode做一个中间人转换角色。
decode.png

#!/usr/bin/env python2
# _*_coding:utf-8_*_
# Author: Lucky.chen

import sys
print(sys.getdefaultencoding())


msg = "我爱北京天安门"
msg_gb2312 = msg.decode("utf-8").encode("gb2312")
gb2312_to_gbk = msg_gb2312.decode("gbk").encode("gbk")

print(msg)
print(msg_gb2312)
print(gb2312_to_gbk)

Python使用正则收集IP信息

编程语言Not see︶ 发表了文章 • 0 个评论 • 327 次浏览 • 2016-08-24 14:38 • 来自相关话题

#!/usr/bin/env python

import re
from subprocess import Popen, PIPE

def getIfconfig():
p = Popen(['ifconfig'], stdout=PIPE)
data = p.stdout.read().split('\n\n')
return [i for i in data if i and not i.startswith('lo')]

def parseIfconfig(data):
re_devname = re.compile(r'(br|eth|em|virbr|lo|bond)[\d:]+',re.M)
re_mac = re.compile(r'HWaddr ([0-9A-F:]{17})', re.M)
re_ip = re.compile('inet addr:([\d\.]{7,15})', re.M)
devname = re_devname.search(data)
if devname:
devname = devname.group()
else:
devname = ''
mac = re_mac.search(data)
if mac:
mac = mac.group(1)
else:
mac = ''
ip = re_ip.search(data)
if ip:
ip = ip.group(1)
else:
ip = ''
return {devname: [ip, mac]}

if __name__ == '__main__':
data = getIfconfig()
for i in data:
print parseIfconfig(i) 查看全部
#!/usr/bin/env python

import re
from subprocess import Popen, PIPE

def getIfconfig():
p = Popen(['ifconfig'], stdout=PIPE)
data = p.stdout.read().split('\n\n')
return [i for i in data if i and not i.startswith('lo')]

def parseIfconfig(data):
re_devname = re.compile(r'(br|eth|em|virbr|lo|bond)[\d:]+',re.M)
re_mac = re.compile(r'HWaddr ([0-9A-F:]{17})', re.M)
re_ip = re.compile('inet addr:([\d\.]{7,15})', re.M)
devname = re_devname.search(data)
if devname:
devname = devname.group()
else:
devname = ''
mac = re_mac.search(data)
if mac:
mac = mac.group(1)
else:
mac = ''
ip = re_ip.search(data)
if ip:
ip = ip.group(1)
else:
ip = ''
return {devname: [ip, mac]}

if __name__ == '__main__':
data = getIfconfig()
for i in data:
print parseIfconfig(i)

Python3中异常处理常用的三种方法

编程语言小白菜 发表了文章 • 0 个评论 • 340 次浏览 • 2016-08-22 23:13 • 来自相关话题

一般我们我们想捕获python的异常写入到log,做处理的话,一般用try语句来做处理,大概语法如下:try:
语句1
语句2
.
.
语句N
except ........ :
do something .......但是你并不知道"语句1至语句N"哪个会出现什么样的错误,但你还要做异常处理,且想把出现的异常打印出来,并不停止程序的运行,所以在"except ......"语句就起作用了。
 
方法一:捕获所有异常Python2如下:
try:
语句1
语句2
.....
语句N
except Exception,e:
print Exception,":",e

Python3如下:
try:
语句1
语句2
.....
语句N
except Exception as e:
print(Exception, ":", e)例子如下:try:
a = 1
b = a
c = w
except Exception as e:
print(Exception, ":", e)

结果为:
<class 'Exception'> : name 'w' is not defined
 方法二:采用sys模块回溯最后的异常
sys.exc_info() 会返回一个3值元表,其中包含调用该命令时捕获的异常。
这个元表的内容为 (type, value, traceback) ,其中:
type 从获取到的异常中得到类型名称,它是BaseException 的子类;value 是捕获到的异常实例;traceback 是一个 traceback 对象,下面会详述。
import sys
try:
w = abs(-1)
list.append(w)
except:
info = sys.exc_info()
print(info[0], ":", info[1])

# 结果如下:
<class 'TypeError'> : descriptor 'append' requires a 'list' object but received a 'int'sys.last_traceback 包含的内容与 sys.exc_info() 相同,但它主要用于调试,并不总是被定义。
 
三、采用traceback模块查看异常
trackback 模块用来精确模仿 python3 解析器的 stack trace 行为。在程序中应该尽量使用这个模块。
traceback.print_exc() 可以直接打印当前的异常。import traceback
try:
raise
except:
traceback.print_exc()traceback.print_tb() 用来打印上面提到的 trackback 对象。import sys,traceback
try:
raise
except:
t,v,tb = sys.exc_info()
traceback.print_tb(tb)traceback.print_exception() 可以直接打印 sys.exc_info()提供的元表。import sys,traceback
try:
raise
except:
traceback.print_exception(*sys.exc_info())其实,下面两句是等价的:
traceback.print_exc()traceback.print_exception(*sys.exc_info())
 
traceback 提供的参数可以将 print 的内容写入到文件中import traceback
try:
a=b
b=c
except:
f=open("log.txt",'a')
traceback.print_exc(file=f)
f.flush()
f.close()参考:
https://docs.python.org/3/library/traceback.html?highlight=print_tb#traceback.print_exc
https://docs.python.org/3/tutorial/errors.html 查看全部
一般我们我们想捕获python的异常写入到log,做处理的话,一般用try语句来做处理,大概语法如下:
try:
语句1
语句2
.
.
语句N
except ........ :
do something .......
但是你并不知道"语句1至语句N"哪个会出现什么样的错误,但你还要做异常处理,且想把出现的异常打印出来,并不停止程序的运行,所以在"except ......"语句就起作用了。
 
方法一:捕获所有异常
Python2如下:
try:
语句1
语句2
.....
语句N
except Exception,e:
print Exception,":",e

Python3如下:
try:
语句1
语句2
.....
语句N
except Exception as e:
print(Exception, ":", e)
例子如下:
try:
a = 1
b = a
c = w
except Exception as e:
print(Exception, ":", e)

结果为:
<class 'Exception'> : name 'w' is not defined

 方法二:采用sys模块回溯最后的异常
sys.exc_info() 会返回一个3值元表,其中包含调用该命令时捕获的异常。
这个元表的内容为 (type, value, traceback) ,其中:
  • type 从获取到的异常中得到类型名称,它是BaseException 的子类;
  • value 是捕获到的异常实例;
  • traceback 是一个 traceback 对象,下面会详述。

import sys
try:
w = abs(-1)
list.append(w)
except:
info = sys.exc_info()
print(info[0], ":", info[1])

# 结果如下:
<class 'TypeError'> : descriptor 'append' requires a 'list' object but received a 'int'
sys.last_traceback 包含的内容与 sys.exc_info() 相同,但它主要用于调试,并不总是被定义。
 
三、采用traceback模块查看异常
trackback 模块用来精确模仿 python3 解析器的 stack trace 行为。在程序中应该尽量使用这个模块。
traceback.print_exc() 可以直接打印当前的异常。
import traceback
try:
raise
except:
traceback.print_exc()
traceback.print_tb() 用来打印上面提到的 trackback 对象。
import sys,traceback
try:
raise
except:
t,v,tb = sys.exc_info()
traceback.print_tb(tb)
traceback.print_exception() 可以直接打印 sys.exc_info()提供的元表。
import sys,traceback
try:
raise
except:
traceback.print_exception(*sys.exc_info())
其实,下面两句是等价的:
  • traceback.print_exc()
  • traceback.print_exception(*sys.exc_info())

 
traceback 提供的参数可以将 print 的内容写入到文件中
import traceback
try:
a=b
b=c
except:
f=open("log.txt",'a')
traceback.print_exc(file=f)
f.flush()
f.close()
参考:
https://docs.python.org/3/library/traceback.html?highlight=print_tb#traceback.print_exc
https://docs.python.org/3/tutorial/errors.html

Python的生成器和迭代器

编程语言采菊篱下 发表了文章 • 0 个评论 • 288 次浏览 • 2016-08-19 18:39 • 来自相关话题

生成器

通过列表生成式,我们可以直接创建一个列表。但是,受到内存限制,列表容量肯定是有限的。而且,创建一个包含100万个元素的列表,不仅占用很大的存储空间,如果我们仅仅需要访问前面几个元素,那后面绝大多数元素占用的空间都白白浪费了。
 
 
所以,如果列表元素可以按照某种算法推算出来,那我们是否可以在循环的过程中不断推算出后续的元素呢?这样就不必创建完整的list,从而节省大量的空间。在Python中,这种一边循环一边计算的机制,称为生成器:generator。
 
 
要创建一个generator,有很多种方法。第一种方法很简单,只要把一个列表生成式的[]改成(),就创建了一个generator:>>> L = [x * x for x in range(5)]
>>> L
[0, 1, 4, 9, 16]
>>> g = (x * x for x in range(5))
>>> g
<generator object <genexpr> at 0x10fe179e8>创建L和g的区别仅在于最外层的[]和(),L是一个list,而g是一个generator。

我们可以直接打印出list的每一个元素,但我们怎么打印出generator的每一个元素呢?
>>> for i in g:
... print(i)
...
0
1
4
9
16
>>> for i in L:
... print(i)
...
0
1
4
9
16
如果要一个一个打印出来,可以通过next()函数获得generator的下一个返回值:
>>> g = (x * x for x in range(5))
>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration

# 取完之后就会报错,因为取完了,就没有,异常关键字:StopIterationgenerator保存的是算法,每次调用next(g),就计算出g的下一个元素的值,直到计算到最后一个元素,没有更多的元素时,抛出StopIteration的错误。

generator也是可迭代对象,所以,我们创建了一个generator后,基本上永远不会调用next(),而是通过for循环来迭代它,并且不需要关心StopIteration的错误。
 
generator非常强大。如果推算的算法比较复杂,用类似列表生成式的for循环无法实现的时候,还可以用函数来实现。

比如,著名的斐波拉契数列(Fibonacci),除第一个和第二个数外,任意一个数都可由前两个数相加得到:
1, 1, 2, 3, 5, 8, 13, 21, 34, ...
斐波拉契数列用列表生成式写不出来,但是,用函数把它打印出来却很容易:def fib(max):
n, a, b = 0, 0, 1
while n < max:
print(b)
a, b = b, a + b
n = n + 1
return 'done'注意,赋值语句:a, b = b, a + b相当于:
t = (b, a + b) # t是一个tuple
a = t[0]
b = t[1]但不必显式写出临时变量t就可以赋值。

上面的函数可以输出斐波那契数列的前N个数:
>>> fib(10)
1
1
2
3
5
8
13
21
34
55
done仔细观察,可以看出,fib函数实际上是定义了斐波拉契数列的推算规则,可以从第一个元素开始,推算出后续任意的元素,这种逻辑其实非常类似generator。

也就是说,上面的函数和generator仅一步之遥。要把fib函数变成generator,只需要把print(b)改为yield b就可以了:
def fib(max):
n,a,b = 0,0,1

while n < max:
#print(b)
yield b
a,b = b,a+b

n += 1

return 'done' 这就是定义generator的另一种方法。如果一个函数定义中包含yield关键字,那么这个函数就不再是一个普通函数,而是一个generator:
>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>这里,最难理解的就是generator和函数的执行流程不一样。函数是顺序执行,遇到return语句或者最后一行函数语句就返回。而变成generator的函数,在每次调用next()的时候执行,遇到yield语句返回,再次执行时从上次返回的yield语句处继续执行。
data = fib(10)
print(data)

print(data.__next__())
print(data.__next__())
print("干点别的事")
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())

#输出
<generator object fib at 0x101be02b0>
1
1
干点别的事
2
3
5
8
13在上面fib的例子,我们在循环过程中不断调用yield,就会不断中断。当然要给循环设置一个条件来退出循环,不然就会产生一个无限数列出来。

同样的,把函数改成generator后,我们基本上从来不会用next()来获取下一个返回值,而是直接使用for循环来迭代:
 
>>> for n in fib(6):
... print(n)
...
1
1
2
3
5
8但是用for循环调用generator时,发现拿不到generator的return语句的返回值。如果想要拿到返回值,必须捕获StopIteration错误,返回值包含在StopIteration的value中:
>>> g = fib(6)
>>> while True:
... try:
... x = next(g)
... print('g:', x)
... except StopIteration as e:
... print('Generator return value:', e.value)
... break
...
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done关于如何捕获错误,后面的错误处理还会详细讲解。

还可通过yield实现在单线程的情况下实现并发运算的效果
import time
def consumer(name):
print("%s 准备吃包子啦!" %name)
while True:
baozi = yield

print("包子[%s]来了,被[%s]吃了!" %(baozi,name))


def producer(name):
c = consumer('A')
c2 = consumer('B')
c.__next__()
c2.__next__()
print("开始准备做包子啦!")
for i in range(10):
time.sleep(1)
print("做了2个包子!")
c.send(i)
c2.send(i)

producer("lucky")

迭代器

我们已经知道,可以直接作用于for循环的数据类型有以下几种:
一类是集合数据类型,如list、tuple、dict、set、str等;一类是generator,包括生成器和带yield的generator function。这些可以直接作用于for循环的对象统称为可迭代对象:Iterable。

可以使用isinstance()判断一个对象是否是Iterable对象:
 
>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False而生成器不但可以作用于for循环,还可以被next()函数不断调用并返回下一个值,直到最后抛出StopIteration错误表示无法继续返回下一个值了。
 
*可以被next()函数调用并不断返回下一个值的对象称为迭代器:Iterator。
可以使用isinstance()判断一个对象是否是Iterator对象:
>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False生成器都是Iterator对象,但list、dict、str虽然是Iterable,却不是Iterator。

把list、dict、str等Iterable变成Iterator可以使用iter()函数:
>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True你可能会问,为什么list、dict、str等数据类型不是Iterator?

这是因为Python的Iterator对象表示的是一个数据流,Iterator对象可以被next()函数调用并不断返回下一个数据,直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列,但我们却不能提前知道序列的长度,只能不断通过next()函数实现按需计算下一个数据,所以Iterator的计算是惰性的,只有在需要返回下一个数据时它才会计算。

Iterator甚至可以表示一个无限大的数据流,例如全体自然数。而使用list是永远不可能存储全体自然数的。
 
小结
凡是可作用于for循环的对象都是Iterable类型;

凡是可作用于next()函数的对象都是Iterator类型,它们表示一个惰性计算的序列;

集合数据类型如list、dict、str等是Iterable但不是Iterator,不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的,例如:
for x in [1, 2, 3, 4, 5]:
pass实际上完全等价于:
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
try:
# 获得下一个值:
x = next(it)
except StopIteration:
# 遇到StopIteration就退出循环
break 查看全部


生成器


通过列表生成式,我们可以直接创建一个列表。但是,受到内存限制,列表容量肯定是有限的。而且,创建一个包含100万个元素的列表,不仅占用很大的存储空间,如果我们仅仅需要访问前面几个元素,那后面绝大多数元素占用的空间都白白浪费了。
 
 
所以,如果列表元素可以按照某种算法推算出来,那我们是否可以在循环的过程中不断推算出后续的元素呢?这样就不必创建完整的list,从而节省大量的空间。在Python中,这种一边循环一边计算的机制,称为生成器:generator。
 
 
要创建一个generator,有很多种方法。第一种方法很简单,只要把一个列表生成式的[]改成(),就创建了一个generator:
>>> L = [x * x for x in range(5)]
>>> L
[0, 1, 4, 9, 16]
>>> g = (x * x for x in range(5))
>>> g
<generator object <genexpr> at 0x10fe179e8>
创建L和g的区别仅在于最外层的[]和(),L是一个list,而g是一个generator。

我们可以直接打印出list的每一个元素,但我们怎么打印出generator的每一个元素呢?
>>> for i in g:
... print(i)
...
0
1
4
9
16
>>> for i in L:
... print(i)
...
0
1
4
9
16

如果要一个一个打印出来,可以通过next()函数获得generator的下一个返回值:
>>> g = (x * x for x in range(5))
>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration

# 取完之后就会报错,因为取完了,就没有,异常关键字:StopIteration
generator保存的是算法,每次调用next(g),就计算出g的下一个元素的值,直到计算到最后一个元素,没有更多的元素时,抛出StopIteration的错误。

generator也是可迭代对象,所以,我们创建了一个generator后,基本上永远不会调用next(),而是通过for循环来迭代它,并且不需要关心StopIteration的错误。
 
generator非常强大。如果推算的算法比较复杂,用类似列表生成式的for循环无法实现的时候,还可以用函数来实现。

比如,著名的斐波拉契数列(Fibonacci),除第一个和第二个数外,任意一个数都可由前两个数相加得到:
1, 1, 2, 3, 5, 8, 13, 21, 34, ...
斐波拉契数列用列表生成式写不出来,但是,用函数把它打印出来却很容易:
def fib(max):
n, a, b = 0, 0, 1
while n < max:
print(b)
a, b = b, a + b
n = n + 1
return 'done'
注意,赋值语句:
a, b = b, a + b
相当于:
t = (b, a + b) # t是一个tuple
a = t[0]
b = t[1]
但不必显式写出临时变量t就可以赋值。

上面的函数可以输出斐波那契数列的前N个数:
>>> fib(10)
1
1
2
3
5
8
13
21
34
55
done
仔细观察,可以看出,fib函数实际上是定义了斐波拉契数列的推算规则,可以从第一个元素开始,推算出后续任意的元素,这种逻辑其实非常类似generator。

也就是说,上面的函数和generator仅一步之遥。要把fib函数变成generator,只需要把print(b)改为yield b就可以了:
def fib(max):
n,a,b = 0,0,1

while n < max:
#print(b)
yield b
a,b = b,a+b

n += 1

return 'done'
这就是定义generator的另一种方法。如果一个函数定义中包含yield关键字,那么这个函数就不再是一个普通函数,而是一个generator:
>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>
这里,最难理解的就是generator和函数的执行流程不一样。函数是顺序执行,遇到return语句或者最后一行函数语句就返回。而变成generator的函数,在每次调用next()的时候执行,遇到yield语句返回,再次执行时从上次返回的yield语句处继续执行。
data = fib(10)
print(data)

print(data.__next__())
print(data.__next__())
print("干点别的事")
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())

#输出
<generator object fib at 0x101be02b0>
1
1
干点别的事
2
3
5
8
13
在上面fib的例子,我们在循环过程中不断调用yield,就会不断中断。当然要给循环设置一个条件来退出循环,不然就会产生一个无限数列出来。

同样的,把函数改成generator后,我们基本上从来不会用next()来获取下一个返回值,而是直接使用for循环来迭代:
 
>>> for n in fib(6):
... print(n)
...
1
1
2
3
5
8
但是用for循环调用generator时,发现拿不到generator的return语句的返回值。如果想要拿到返回值,必须捕获StopIteration错误,返回值包含在StopIteration的value中:
>>> g = fib(6)
>>> while True:
... try:
... x = next(g)
... print('g:', x)
... except StopIteration as e:
... print('Generator return value:', e.value)
... break
...
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done
关于如何捕获错误,后面的错误处理还会详细讲解。

还可通过yield实现在单线程的情况下实现并发运算的效果
import time
def consumer(name):
print("%s 准备吃包子啦!" %name)
while True:
baozi = yield

print("包子[%s]来了,被[%s]吃了!" %(baozi,name))


def producer(name):
c = consumer('A')
c2 = consumer('B')
c.__next__()
c2.__next__()
print("开始准备做包子啦!")
for i in range(10):
time.sleep(1)
print("做了2个包子!")
c.send(i)
c2.send(i)

producer("lucky")


迭代器


我们已经知道,可以直接作用于for循环的数据类型有以下几种:
  • 一类是集合数据类型,如list、tuple、dict、set、str等;
  • 一类是generator,包括生成器和带yield的generator function。
  • 这些可以直接作用于for循环的对象统称为可迭代对象:Iterable。


可以使用isinstance()判断一个对象是否是Iterable对象:
 
>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False
而生成器不但可以作用于for循环,还可以被next()函数不断调用并返回下一个值,直到最后抛出StopIteration错误表示无法继续返回下一个值了。
 
*可以被next()函数调用并不断返回下一个值的对象称为迭代器:Iterator。
可以使用isinstance()判断一个对象是否是Iterator对象:
>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False
生成器都是Iterator对象,但list、dict、str虽然是Iterable,却不是Iterator。

把list、dict、str等Iterable变成Iterator可以使用iter()函数:
>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True
你可能会问,为什么list、dict、str等数据类型不是Iterator?

这是因为Python的Iterator对象表示的是一个数据流,Iterator对象可以被next()函数调用并不断返回下一个数据,直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列,但我们却不能提前知道序列的长度,只能不断通过next()函数实现按需计算下一个数据,所以Iterator的计算是惰性的,只有在需要返回下一个数据时它才会计算。

Iterator甚至可以表示一个无限大的数据流,例如全体自然数。而使用list是永远不可能存储全体自然数的。
 
小结
凡是可作用于for循环的对象都是Iterable类型;

凡是可作用于next()函数的对象都是Iterator类型,它们表示一个惰性计算的序列;

集合数据类型如list、dict、str等是Iterable但不是Iterator,不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的,例如:
for x in [1, 2, 3, 4, 5]:
pass
实际上完全等价于:
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
try:
# 获得下一个值:
x = next(it)
except StopIteration:
# 遇到StopIteration就退出循环
break
Python(英语发音:/ˈpaɪθən/), 是一种面向对象、解释型计算机程序设计语言,由Guido van Rossum于1989年底发明,第一个公开发行版发行于1991年,Python 源代码同样遵循 GPL(GNU General Public License)协议 。Python语法简洁而清晰,具有丰富和强大的类库。它常被昵称为胶水语言,能够把用其他语言制作的各种模块(尤其是C/C++)很轻松地联结在一起。常见的一种应用情形是,使用Python快速生成程序的原型(有时甚至是程序的最终界面),然后对其中有特别要求的部分,用更合适的语言改写,比如3D游戏中的图形渲染模块,性能要求特别高,就可以用C/C++重写,而后封装为Python可以调用的扩展类库。需要注意的是在您使用扩展类库时可能需要考虑平台问题,某些可能不提供跨平台的实现。