python

Python统计英文单词数是如何来实现的呢？下面的内容将会通过具体的实例来演示Python统计英文单词数的实现方法及相关技巧：

字符串分割

str="a|and|hello|||ab"
alist = str.split('|')
print alist
 

结果

str="a hello{这里换成5个空格}world{这里换成3个空格}"
alist=str.split(' ')
print alist
 

统计英文单词的个数的python代码

# -*- coding: utf-8 -*-
import os,sys
info = os.getcwd() #获取当前文件名称
fin = open(u'c:/a.txt') 

info = fin.read()
alist = info.split(‘ ‘) # 将文章按照空格划分开

fout = open(u’c:/count.txt’, ‘w’)
fout.write(‘n’.join(alist)) # 可以通过文本文件的行号同样看到效果
##fout.write(‘%s’ % alist)
fout.close()

allen = len(alist) # 总的单词数
nulen = alist.count(”) # 空格的数量
print “words’ number is”,allen
print “null number is”,nulen
print “poor words number is”, allen-nulen # 实际的单词数目

fin.close()

Python统计英文单词数就是这样，欢迎大家参考。。。。

下面的内容主要介绍了Python中使用不同编码读写文件,欢迎大家参考：

import os
import codecs
filenames=os.listdir(os.getcwd()) 

out=file(“name.txt”,”w”)
for filename in filenames:
out.write(filename.decode(“gb2312”).encode(“utf-8”))
out.close()

Python中使用不同编码读写文件就是这样，欢迎大家参考。。。。

下面的内容主要介绍了Python中import与from…import用法的不同之处,欢迎大家参考：

在python用import或者from…import来导入相应的模块。模块其实就是一些函数和类的集合文件，它能实现一些相应的功能，当我们需要使用这些功能的时候，直接把相应的模块导入到我们的程序中，我们就可以使用了。这类似于C语言中的include头文件，Python中我们用import导入我们需要的模块。
eg:

import sys
print('================Python import mode==========================');
print ('The command line arguments are:')
for i in sys.argv:
    print (i)
print ('n The python path',sys.path)
from sys import argv,path  #  导入特定的成员
print('================python from import===================================')
print('path:',path) # 因为已经导入path成员，所以此处引用时不需要加sys.path
 

如果你要使用所有sys模块使用的名字，你可以这样：

from sys import *
print('path:',path)
从以上我们可以简单看出：
############################
#导入modules，import与from...import的不同之处在于，简单说：
# 如果你想在程序中用argv代表sys.argv，
# 则可使用：from sys import argv
# 一般说来，应该避免使用from..import而使用import语句，
# 因为这样可以使你的程序更加易读，也可以避免名称的冲突
###########################
 

Python中import与from…import用法的不同之处就是这样，欢迎大家参考。。。。

Python中发送邮件到邮箱是如何来实现的呢？下面的内容将会通过具体的实例来演示Python中发送邮件到邮箱的实现方法及相关技巧：

本文实例讲述了Python实现给qq邮箱发送邮件的方法。分享给大家供大家参考。具体实现方法如下：

#-*-coding:utf-8-*-
#==========================================
# 导入smtplib和MIMEText
#==========================================
from email.mime.text import MIMEText
import smtplib
#==========================================
# 要发给谁，这里发给2个人
#==========================================
mailto_list=["naughty610@qq.com","1034791200@qq.com"]
#==========================================
# 设置服务器，用户名、口令以及邮箱的后缀
#==========================================
mail_host="smtp.qq.com"
mail_user="naughty610"
mail_pass="here is your password"
mail_postfix="qq.com"
#==========================================
# 发送邮件
#==========================================
def send_mail(to_list,sub,content):
  '''''
  to_list:发给谁
  sub:主题
  content:内容
  send_mail("aaa@126.com","sub","content")
  '''
  me=mail_user+"<"+mail_user+"@"+mail_postfix+">"
  msg = MIMEText(content)
  msg['Subject'] = sub
  msg['From'] = me
  msg['To'] = ";".join(to_list)
  try:
    s = smtplib.SMTP()
    s.connect(mail_host)
    s.login(mail_user,mail_pass)
    s.sendmail(me, to_list, msg.as_string())
    s.close()
    return True
  except Exception, e:
    print str(e)
    return False
if __name__ == '__main__':
  if send_mail(mailto_list,"here is subject","here is content"):
    print "发送成功"
  else:
    print "发送失败"
 

Python中发送邮件到邮箱就是这样，欢迎大家参考。。。。

Python批量下载懒人图库网站中所有JavaScript特效是如何来实现的呢？下面的内容将会通过具体的实例来演示Python批量下载懒人图库网站中所有JavaScript特效的实现方法及相关技巧：

这是一个简单的Python脚本，主要从懒人图库下载JavaScript特效模板，在脚本中使用了gevent这个第三方库，使用的时候需要先安装。

#!/usr/bin/python
# -*- coding: utf-8 -*-
import urllib,os,sys
import gevent,re
from gevent import monkey
from bs4 import BeautifulSoup
gevent.monkey.patch_socket()
'''
Description：Python 爬虫抓取懒人图库的JS脚本模板
Author：admin
Create-Date：2015-05-25
Version：1.0
'''
HTTP_URL = 'http://www.lanrentuku.com%s'
DOWNLOAD_URL = HTTP_URL[:-2] + '/js/d%szip'
reg=r'd{1,}.+'
def encode(text):
  return text.encode("utf8")
def createDirectory(curPath):
  myPath = os.path.join(getSubDirectory(), u'JS代码模板')
  if not os.path.exists(myPath):
    os.mkdir(myPath)
  return os.path.join(myPath, curPath)
def getSubDirectory():
  return os.getcwd()
def schedule(a, b, c):
  per = 100.0 * a * b / c
  if per > 100 :
    per = 100
  sys.stdout.write('%.1f%%r' % per)
  sys.stdout.flush()
def geturllist(url):
  url_list = {}
  html = urllib.urlopen(url)
  content = html.read()
  html.close()
  # 用BeautifulSoup解析
  decodeHtml = BeautifulSoup(content)
  try:
    aTags = decodeHtml.find_all('div', {'class':'list-pngjs'})[0].find_all('a')
  except IndexError, e:
    print e
    aTags = None
  # 获取链接地址和标题
  if aTags is not None:
    for a_tag in aTags:
      url_list[HTTP_URL % a_tag.get('href')] = a_tag.get_text()
  return url_list
def download(down_url):
  try:
    m=re.search(reg,down_url[0])
    name = DOWNLOAD_URL % m.group(0)
    urllib.urlretrieve(name,createDirectory(down_url[1] + name[-4:]),schedule)
  except Exception, e:
    print e.message
def getpageurl(xUrl):
  # 进行列表页循环
  return [xUrl % page for page in xrange(1,49)]
if __name__ == '__main__':
  jobs = []
  pageurl = getpageurl('http://www.lanrentuku.com/js/p%s.html')
  # 爬取所有链接
  for i in pageurl:
    for k in geturllist(i).items():
      jobs.append(gevent.spawn(download, k))
  gevent.joinall(jobs)
 

Python批量下载懒人图库网站中所有JavaScript特效就是这样，欢迎大家参考。。。。

Python统计文件中单词出现的次数是如何来实现的呢？下面的内容将会通过具体的实例来演示Python统计文件中单词出现的次数的实现方法及相关技巧：

最近在看python脚本语言，脚本语言是一种解释性的语言，不需要编译，可以直接用，由解释器来负责解释。python语言很强大，而且写起来很简洁。下面的一个例子就是用python统计单词出现的个数。

import sys
import string
#import collections
if len(sys.argv) == 1 or sys.argv[1] in {"-h", "--help"}:
 print("usage: uniqueword filename_1 filename_2 ... filename_n")
 sys.exit()
else:
 words = {}
 # words = collections.defaultdict(int)
 strip = string.whitespace + string.punctuation + string.digits + ""'"
 for filename in sys.argv[1:]:
 for line in open(filename):
  for word in line.split():
  word = word.strip(strip)
  if len(word) >= 2:
   words[word] = words.get(word, 0) + 1
   # words[word] += 1
 for word in sorted(words):
 print("'{0}' occurs {1} times".format(word,words[word]))
 

假设文件名是 uniqueword.py，在命令行下输入： uniqueword.py filename_1 filename_2 … filename_n中单词出现的次数可以被统计出来。
第四行和第五行判断是否有输入参数，如果输入参数为空或者为-h， -help，则输出帮助信息。

从第七行到第14行是核心部分，逐一打开参数中指定的文件，并读取每一行，再用字符串的split方法把读取的行抽取出一个一个的单词，但单词长度大于2的时候，把此单词加入到字典words中。 其中words.get(word, 0)的意思是取出key等于word的value，如果key为空，则把value置为默认值0. 最后打印出结果。

Python统计文件中单词出现的次数就是这样，欢迎大家参考。。。。

Python使用Scrapy库爬取妹子图网站照片是如何来实现的呢？下面的内容将会通过具体的实例来演示Python使用Scrapy库爬取妹子图网站照片的实现方法及相关技巧：

函数是一组一起执行任务的语句。可以把代码放到独立的函数中。怎么划分代码功能之间的不同，但在逻辑上划分通常是让每个函数执行特定的任务。

Lua语言提供了程序可以调用大量的内置方法。例如，方法print()打印作为输入传参数在控制台中。

函数是已知的各种名称，如方法或子程序或程序等。
定义一个函数

在Lua编程语言中的方法的定义一般形式如下：

optional_function_scope function function_name( argument1, argument2, argument3..., argumentn)
function_body
return result_params_comma_separated
end 

在 Lua 编程语言的方法定义包括方法头和方法体。这里是方法的所有部件

• 可选函数适用范围：可以使用关键字本地范围的限制功能或忽略的范围部分，这将使它成为一个全局函数。
• 函数名称：这是函数的实际名称。函数名和参数列表一起构成了函数签名。
• 参数：一个参数是像占位符。当调用一个函数，将值传递给参数。这个值被称为实际参数或参数。参数列表是指类型，顺序和数量的方法的参数。参数是可选的;也就是说，方法可能没有参数。
• 函数体：方法主体包含了定义方法做什么的语句的集合。
• 返回：在Lua中可以通过下面的逗号分隔的返回值，return关键字返回多个值。

例子：

下面是一个函数的源代码调用max()。这个函数有两个参数num1与num2并返回两者之间的最大值：

--[[ function returning the max between two numbers --]]
function max(num1, num2) 

if (num1 > num2) then
result = num1;
else
result = num2;
end

return result;
end

Python使用Scrapy库爬取妹子图网站照片就是这样，欢迎大家参考。。。。

Python基于smtplib实现异步发送邮件服务是如何来实现的呢？下面的内容将会通过具体的实例来演示Python基于smtplib实现异步发送邮件服务的实现方法及相关技巧：

基于smtplib包制作而成，但在实践中发现一个不知道算不算是smtplib留的一个坑，在网络断开的情况下发送邮件时会抛出一个socket.gaierror的异常，但是smtplib中并没有捕获这个异常，导致程序会因这个异常终止，因此代码中针对这部分的异常进行处理，确保不会异常终止。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = 'Zoa Chou'
# see http://www.mudoom.com/Article/show/id/29.html for detail
import logging
import smtplib
import mimetypes
import socket
from email import encoders
from email.header import Header
from email.mime.text import MIMEText, MIMENonMultipart
from email.mime.base import MIMEBase
from email.utils import parseaddr, formataddr
class Mailer(object):
  def __init__(self):
    pass
  def send_mail(self, smtp_server, from_address, to_address, subject, body, files=None):
    """
    发送邮件主程序
    :param smtp_server: dict 邮件服务器设置
      :keyword host: string smtp服务器地址
      :keyword port: int smtp服务器端口号
      :keyword user: string 用户名
      :keyword passwd: string 密码
      :keyword ssl: bool 是否启用ssl,默认False
      :keyword timeout: int 超时时间,默认10s
    :param from_address: 发件人邮箱
    :param to_address: 收件人邮箱
    :param subject: 邮件标题
    :param body: 邮件内容
    :param files: 附件
    :raise: NetworkError/MailerException
    """
    # 格式化邮件内容
    body = self._encode_utf8(body)
    # 邮件类型
    content_type = 'html' if body.startswith('<html>') else 'plain'
    msg = MIMENonMultipart() if files else MIMEText(body, content_type, 'utf-8')
    # 格式化邮件数据
    msg['From'] = self._format_address(from_address)
    msg['To'] = ', '.join(self._format_list(to_address))
    msg['subject'] = self._encode_utf8(subject)
    # 构造附件数据
    if files:
      msg.attach(MIMEText(body, content_type, 'utf-8'))
      cid = 0
      for file_name, payload in files:
        file_name = self._encode_utf8(file_name)
        main_type, sub_type = self._get_file_type(file_name)
        if hasattr(payload, 'read'):
          payload = payload.read()
        f_name = self._encode_header(file_name)
        mime = MIMEBase(main_type, sub_type, filename=f_name)
        mime.add_header('Content-Disposition', 'attachment', filename=f_name)
        mime.add_header('Content-ID', '<%s>' % cid)
        mime.add_header('X-Attachment-Id', '%s' % cid)
        mime.set_payload(payload)
        encoders.encode_base64(mime)
        msg.attach(mime)
        cid += 1
    host = smtp_server.get('host')
    port = smtp_server.get('port')
    user = smtp_server.get('user')
    passwd = smtp_server.get('passwd')
    ssl = smtp_server.get('ssl', False)
    time_out = smtp_server.get('timeout', 10)
    # 没有输入端口则使用默认端口
    if port is None or port == 0:
      if ssl:
        port = 465
      else:
        port = 25
    logging.debug('Send mail form %s to %s' % (msg['From'], msg['To']))
    try:
      if ssl:
        # 开启ssl连接模式
        server = smtplib.SMTP_SSL('%s:%d' % (host, port), timeout=time_out)
      else:
        server = smtplib.SMTP('%s:%d' % (host, port), timeout=time_out)
      # 开启调试模式
      # server.set_debuglevel(1)
      # 如果存在用户名密码则尝试登录
      if user and passwd:
        server.login(user, passwd)
      # 发送邮件
      server.sendmail(from_address, to_address, msg.as_string())
      logging.debug('Mail sent success.')
      # 关闭stmp连接
      server.quit()
    except socket.gaierror, e:
      """ 网络无法连接 """
      logging.exception(e)
      raise NetworkError(e)
    except smtplib.SMTPServerDisconnected, e:
      """ 网络连接异常 """
      logging.exception(e)
      raise NetworkError(e)
    except smtplib.SMTPException, e:
      """ 邮件发送异常 """
      logging.exception(e)
      raise MailerException(e)
  def _format_address(self, s):
    """
    格式化邮件地址
    :param s:string 邮件地址
    :return: string 格式化后的邮件地址
    """
    name, address = parseaddr(s)
    return formataddr((self._encode_header(name), self._encode_utf8(address)))
  def _encode_header(self, s):
    """
    格式化符合MIME的头部数据
    :param s: string 待格式化数据
    :return: 格式化后的数据
    """
    return Header(s, 'utf-8').encode()
  def _encode_utf8(self, s):
    """
    格式化成utf-8编码
    :param s: string 待格式化数据
    :return: string 格式化后的数据
    """
    if isinstance(s, unicode):
      return s.encode('utf-8')
    else:
      return s
  def _get_file_type(self, file_name):
    """
    获取附件类型
    :param file_name: 附件文件名
    :return: dict 附件MIME
    """
    s = file_name.lower()
    pos = s.rfind('.')
    if pos == -1:
      return 'application', 'octet-stream'
    ext = s[pos:]
    mime = mimetypes.types_map.get(ext, 'application/octet-stream')
    pos = mime.find('/')
    if pos == (-1):
      return mime, ''
    return mime[:pos], mime[pos+1:]
  def _format_list(self, address):
    """
    将收件人地址格式化成list
    :param address: string/list 收件人邮箱
    :return: list 收件人邮箱list
    """
    l = address
    if isinstance(l, basestring):
      l = [l]
    return [self._format_address(s) for s in l]
class MailerException(Exception):
  """ 邮件发送异常类 """
  pass
class NetworkError(MailerException):
  """ 网络异常类 """
  pass
# test for @qq.com
if __name__ == '__main__':
  import sys
  def prompt(prompt):
    """
    接收终端输入的数据
    """
    sys.stdout.write(prompt + ": ")
    return sys.stdin.readline().strip()
  from_address = prompt("From(Only @qq.com)")
  passwd = prompt("Password")
  to_address = prompt("To").split(',')
  subject = prompt("Subject")
  print "Enter message, end with ^D:"
  msg = ''
  while 1:
    line = sys.stdin.readline()
    if not line:
      break
    msg = msg + line
  print "Message length is %d" % len(msg)
  # QQ邮箱默认设置
  smtp_server = {'host': 'smtp.qq.com', 'port': None, 'user': from_address, 'passwd': passwd, 'ssl': True}
  mailer = Mailer()
  try:
    mailer.send_mail(smtp_server, from_address, to_address, subject, msg)
  except MailerException, e:
    print(e)
 

Python基于smtplib实现异步发送邮件服务就是这样，欢迎大家参考。。。。

Python中使用smallseg分词是如何来使用的呢？下面的内容将会通过具体的实例来演示Python中使用smallseg分词的使用方法及相关技巧：

本文实例讲述了Python smallseg分词用法。分享给大家供大家参考。具体分析如下：

#encoding=utf-8
#import psyco
#psyco.full()
words = [x.rstrip() for x in open("main.dic",mode='r',encoding='utf-8') ]
from smallseg import SEG
seg = SEG()
print('Load dict...')
seg.set(words)
print("Dict is OK.")
def cuttest(text):
  wlist = seg.cut(text)
  wlist.reverse()
  tmp = " ".join(wlist)
  print(tmp)
  print("================================")
if __name__=="__main__":
  cuttest("这是一个伸手不见五指的黑夜。我叫孙悟空，我爱北京，我爱Python和C++。")
  cuttest("我不喜欢日本和服。")
  cuttest("雷猴回归人间。")
  cuttest("工信处女干事每月经过下属科室都要亲口交代24口交换机等技术性器件的安装工作")
  cuttest("我需要廉租房")
  cuttest("永和服装饰品有限公司")
  cuttest("我爱北京天安门")
  cuttest("abc")
  cuttest("隐马尔可夫")
  cuttest("雷猴是个好网站")
  cuttest("“Microsoft”一词由“MICROcomputer（微型计算机）”和“SOFTware（软件）”两部分组成")
  cuttest("草泥马和欺实马是今年的流行词汇")
  cuttest("伊藤洋华堂总府店")
  cuttest("中国科学院计算技术研究所")
  cuttest("罗密欧与朱丽叶")
  cuttest("我购买了道具和服装")
 

smallseg分词，在python3.3上运行稍微有些问题。py代码xrange在3.*中已经改名字为range了。另外，3.*中也没有decode函数了。

修改了上面的两个地方，代码就可移植性了。效果还可以。

Python中使用smallseg分词就是这样，欢迎大家参考。。。。

Python使用Supervisor来管理进程是如何来实现的呢？下面的内容将会通过具体的实例来演示Python使用Supervisor来管理进程的实现方法及相关技巧：

本文实例讲述了Python使用Supervisor来管理进程的方法。分享给大家供大家参考。具体分析如下：

Supervisor可以启动、停止、重启*nix系统中的程序。也可以重启崩溃的程序。

supervisord的一个守护进程，用于将指定的进程当做子进程来运行。

supervisorctl是一个客户端程序，可以查看日志并通过统一的会话来控制进程。

看例子：

我们写了一个py脚本，用于往log文件中记录一条当前的时间。

root@ubuntu:/home/zoer# cat daemon.py
#!/usr/bin/env python
import time
import os
time.sleep(1)
f=open("log",'a')
t=time.time()
f.write(str(t))
f.write("n")
f.close()
 

安装过程就不说了。

安装完毕supervisor之后【将配置文件放在/etc下】。修改配置文件，在最后增加如下内容：

[program:ddd] command=/home/zoer/daemon.py
autorestart=true

然后我们启动supervisor并启动daemon.py的执行。

root@ubuntu:/home/zoer# supervisord
/usr/local/lib/python2.7/dist-packages/supervisor-3.0b1-py2.7.egg/supervisor/options.py:286: UserWarning: Supervisord is running as root and it is searching for its configuration file in default locations (including its current working directory); you probably want to specify a "-c" argument specifying an absolute path to a configuration file for improved security.
 'Supervisord is running as root and it is searching '
root@ubuntu:/home/zoer# supervisorctl
ddd               STARTING
supervisor> start ddd
ddd: ERROR (already started)
supervisor> stop ddd
ddd: stopped
supervisor> start ddd
ddd: started
supervisor>
 

从上面的例子中，看到，可以通过start或者stop命令来启动或者停止ddd这个进程。ddd这里就是我们在配置文件中增加的内容（daemon.py这个脚本）。

也可以使用restart。如下：

supervisor> restart ddd
ddd: stopped
ddd: started

下面我们测试一下，假设说我们手动kill掉了ddd这个进程，那么ddd会自动恢复执行吗？

为了做实验，把代码修改如下：

root@ubuntu:/home/zoer# cat daemon.py
#!/usr/bin/env python
import time
import os
while True:
  time.sleep(1)
  f=open("log",'a')
  t=time.time()
  f.write(str(t))
  f.write("n")
  f.close()
 

通过ps可以找到这个进程的id：

root   9354 0.2 0.4 10924 4200 ?    S  23:16  0:00 python /home/zoer/daemon.py
root   9395 0.0 0.0  4392  832 pts/3  S+  23:17  0:00 grep --color=auto daemon
root@ubuntu:/home/zoer#
 

看下面的操作：

root@ubuntu:/home/zoer# rm log;touch log;kill 9354
root@ubuntu:/home/zoer# cat log
1364710712.51
root@ubuntu:/home/zoer# cat log
1364710712.51
1364710713.51
root@ubuntu:/home/zoer# cat log
1364710712.51
1364710713.51
root@ubuntu:/home/zoer# cat log
1364710712.51
1364710713.51
1364710714.52
root@ubuntu:/home/zoer# cat log
1364710712.51
1364710713.51
1364710714.52
1364710715.52
 

删除了log文件，并且重新创建。然后干掉了daemon.py的那个进程。会发现log内容又重新有新的内容了。再次ps查看进程号。

root   9429 0.1 0.4 10924 4200 ?    S  23:18  0:00 python /home/zoer/daemon.py
root   9440 0.0 0.0  4392  828 pts/3  S+  23:19  0:00 grep --color=auto daemon
root@ubuntu:/home/zoer#
 

会发现进程号已经变成9429了。说明supervisor已经重启了被干掉了的进程。

Python使用Supervisor来管理进程就是这样，欢迎大家参考。。。。

Python运算符重载是如何来使用的呢？下面的内容将会通过具体的实例来演示Python运算符重载的使用方法及相关技巧：

本文实例讲述了Python运算符重载用法。分享给大家供大家参考。具体分析如下：

python中，我们在定义类的时候，可以通过实现一些函数来实现重载运算符。

例子如下：

# -*- coding:utf-8 -*-
'''''
Created on 2013-3-21
@author: naughty
'''
class Test(object):
  def __init__(self, value):
    self.value = value
  def __add__(self, x):
    return self.value + x.value
a = Test(3)
b = Test(4)
print a + b
 

运行结果为：7

上面我们重载了加法。其他类似。

Python运算符重载就是这样，欢迎大家参考。。。。

python将文本转换成语音是如何来实现的呢？下面的内容将会通过具体的实例来演示python将文本转换成语音的实现方法及相关技巧：

本文实例讲述了python将文本转换成语音的方法。分享给大家供大家参考。具体实现方法如下：

# Text To Speech using SAPI (Windows) and Python module pyTTS by Peter Parente
# download installer file pyTTS-3.0.win32-py2.4.exe
# from: http://sourceforge.net/projects/uncassist
# also needs: http://www.cs.unc.edu/Research/assist/packages/SAPI5SpeechInstaller.msi
# and pywin32-204.win32-py2.4.exe at this date the latest version of win32com
# from: http://sourceforge.net/projects/pywin32/
# tested with Python24 on a Windows XP computer  vagaseat  15jun2005
import pyTTS
import time
tts = pyTTS.Create()
# set the speech rate, higher value = faster
# just for fun try values of -10 to 10
tts.Rate = 1
print "Speech rate =", tts.Rate
# set the speech volume percentage (0-100%)
tts.Volume = 90
print "Speech volume =", tts.Volume
# get a list of all the available voices
print "List of voices =", tts.GetVoiceNames()
# explicitly set a voice
tts.SetVoiceByName('MSMary')
print "Voice is set ot MSMary"
print
# announce the date and time, does a good job
timeStr = "The date and time is " + time.asctime()
print timeStr
tts.Speak(timeStr)
print
str1 = """
A young executive was leaving the office at 6 pm when he found
the CEO standing in front of a shredder with a piece of paper in hand.
"Listen," said the CEO, "this is important, and my secretary has left.
Can you make this thing work?"
"Certainly," said the young executive. He turned the machine on,
inserted the paper, and pressed the start button.
"Excellent, excellent!" said the CEO as his paper disappeared inside
the machine. "I just need one copy."
"""
print str1
tts.Speak(str1)
tts.Speak('Haah haa haah haa')
print
str2 = """
Finagle's fourth law:
 Once a job is fouled up, anything done to improve it only makes it worse.
"""
print str2
print
print "The spoken text above has been written to a wave file (.wav)"
tts.SpeakToWave('Finagle4.wav', str2)
print "The wave file is loaded back and spoken ..."
tts.SpeakFromWave('Finagle4.wav')
print
print "Substitute a hard to pronounce word like Ctrl key ..."
#create an instance of the pronunciation corrector
p = pyTTS.Pronounce()
# replace words that are hard to pronounce with something that
# is spelled out or misspelled, but at least sounds like it
p.AddMisspelled('Ctrl', 'Control')
str3 = p.Correct('Please press the Ctrl key!')
tts.Speak(str3)
print
print "2 * 3 = 6"
tts.Speak('2 * 3 = 6')
print
tts.Speak("sounds goofy, let's replace * with times")
print "Substitute * with times"
# ' * ' needs the spaces
p.AddMisspelled(' * ', 'times')
str4 = p.Correct('2 * 3 = 6')
tts.Speak(str4)
print
print "Say that real fast a few times!"
str5 = "The sinking steamer sunk!"
tts.Rate = 3
for k in range(7):
  print str5
  tts.Speak(str5)
  time.sleep(0.3)
tts.Rate = 0
tts.Speak("Wow, not one mispronounced word!")
 

python将文本转换成语音就是这样，欢迎大家参考。。。。

Python给文件添加内容并获取文件信息的方法是如何来实现的呢？下面的内容将会通过具体的实例来演示Python给文件添加内容并获取文件信息的方法的实现方法及相关技巧：

本文实例讲述了Python实现给文件添加内容及得到文件信息的方法。分享给大家供大家参考。具体分析如下：

经常会遇到给文件添加内容的时候，如果只是添加在文件的末尾，就比较简单了：

file = open(filename,'a')
file.write('hello')
file.close()
 

使用’a’模式打开文件后，指针默认指向文件末尾，即使你：

file.seek(0)
file.write('world')
 

字符串‘world’还是会加在文件的末尾，而不会是你想要的开始位置。

而我遇到的需求就是要在文件头添加东西啊，怎么办呢？不至于把里面东西全读出来，再写进去吧？

还好看到了’r+’这个模式(以前从来没有用过)

file = open(filename,'r+')
file.tell() #0L
file.write('begin')
file.close()
 

打开文件看看，是不是可以了呢;)

得到文件的修改时间：

>>> t = os.path.getmtime(path)
>>> t
1190626843
>>> type(t)
<type 'int'>
>>> os.stat(path)[8]
1190626843
 

得到文件的大小：

>>> os.stat(path)[6]
2808L
>>> os.path.getsize(path)
2808L
 

Python给文件添加内容并获取文件信息的方法就是这样，欢迎大家参考。。。。

Python读写ini文件是如何来实现的呢？下面的内容将会通过具体的实例来演示Python读写ini文件的实现方法及相关技巧：

本文实例讲述了Python读写ini文件的方法。分享给大家供大家参考。具体如下：

比如有一个文件update.ini，里面有这些内容：

[ZIP]
EngineVersion=0
DATVersion=5127
FileName=dat-5127.zip
FilePath=/pub/antivirus/datfiles/4.x/
FileSize=13481555
Checksum=6037,021E
MD5=aaeb519d3f276b810d46642d782d8921
 

那就可以通过下面这些代码得到MD5的值，简单吧

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import ConfigParser
config = ConfigParser.ConfigParser()
config.readfp(open('update.ini'))
a = config.get("ZIP","MD5")
print a
 

写也很简单：

import ConfigParser
config = ConfigParser.ConfigParser()
# set a number of parameters
config.add_section("book")
config.set("book", "title", "the python standard library")
config.set("book", "author", "fredrik lundh")
config.add_section("ematter")
config.set("ematter", "pages", 250)
# write to file
config.write(open('1.ini', "w"))
 

修改也不难（添加内容）：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import ConfigParser
config = ConfigParser.ConfigParser()
config.read('1.ini')
a = config.add_section("md5")
config.set("md5", "value", "1234")
config.write(open('1.ini', "r+")) #可以把r+改成其他方式，看看结果:)
 

修改内容：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import ConfigParser
config = ConfigParser.ConfigParser()
config.read('1.ini')
config.set("md5", "value", "kingsoft") #这样md5就从1234变成kingsoft了
config.write(open('1.ini', "r+"))
 

删除部分就懒得写了，感兴趣的自己看文档：

remove_option( section, option)
Remove the specified option from the specified section. If the section does not exist, raise NoSectionError. If the option existed to be removed, return True; otherwise return False. New in version 1.6.
remove_section( section)
Remove the specified section from the configuration. If the section in fact existed, return True. Otherwise return False.

Python读写ini文件就是这样，欢迎大家参考。。。。

Python中super继承是如何来使用的呢？下面的内容将会通过具体的实例来演示Python中super继承的使用方法及相关技巧：

super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。总之前人留下的经验就是：保持一致性。要不全部用类名调用父类，要不就全部用 super，不要一半一半。

普通继承

class FooParent(object):
    def __init__(self):
        self.parent = 'I'm the parent.'
        print 'Parent'
    def bar(self,message):
        print message, 'from Parent'
class FooChild(FooParent):
    def __init__(self):
        FooParent.__init__(self)
        print 'Child'
    def bar(self,message):
        FooParent.bar(self,message)
        print 'Child bar function.'
        print self.parent
if __name__=='__main__':
    fooChild = FooChild()
    fooChild.bar('HelloWorld')
 

super继承

class FooParent(object):
    def __init__(self):
        self.parent = 'I'm the parent.'
        print 'Parent'
    def bar(self,message):
        print message,'from Parent'
class FooChild(FooParent):
    def __init__(self):
        super(FooChild,self).__init__()
        print 'Child'
    def bar(self,message):
        super(FooChild, self).bar(message)
        print 'Child bar fuction'
        print self.parent
if __name__ == '__main__':
    fooChild = FooChild()
    fooChild.bar('HelloWorld')
 

程序运行结果相同，为：

Parent
Child
HelloWorld from Parent
Child bar fuction
I'm the parent.
 

从运行结果上看，普通继承和super继承是一样的。但是其实它们的内部运行机制不一样，这一点在多重继承时体现得很明显。在super机制里可以保证公共父类仅被执行一次，至于执行的顺序，是按照mro进行的（E.__mro__）。
注意super继承只能用于新式类，用于经典类时就会报错。
新式类：必须有继承的类，如果没什么想继承的，那就继承object
经典类：没有父类，如果此时调用super就会出现错误：『super() argument 1 must be type, not classobj』

关于super用法的详细研究可参考「http://www.jb51.net/article/66912.htm」

Python中super继承就是这样，欢迎大家参考。。。。

Python中yield函数是如何来使用的呢？下面的内容将会通过具体的实例来演示Python中yield函数的使用方法及相关技巧：

初学 Python 的开发者经常会发现很多 Python 函数中用到了 yield 关键字，然而，带有 yield 的函数执行流程却和普通函数不一样，yield 到底用来做什么，为什么要设计 yield ？本文将由浅入深地讲解 yield 的概念和用法，帮助读者体会 Python 里 yield 简单而强大的功能。

您可能听说过，带有 yield 的函数在 Python 中被称之为 generator（生成器），何谓 generator ？
我们先抛开 generator，以一个常见的编程题目来展示 yield 的概念。
如何生成斐波那契數列
斐波那契（Fibonacci）數列是一个非常简单的递归数列，除第一个和第二个数外，任意一个数都可由前两个数相加得到。用计算机程序输出斐波那契數列的前 N 个数是一个非常简单的问题，许多初学者都可以轻易写出如下函数：
清单 1. 简单输出斐波那契數列前 N 个数

 def fab(max):
    n, a, b = 0, 0, 1
    while n < max:
        print b
        a, b = b, a + b
        n = n + 1
 &#91;/code&#93;
执行 fab(5)，我们可以得到如下输出：
&#91;code&#93;
 >>> fab(5)
 1
 1
 2
 3
 5
 

结果没有问题，但有经验的开发者会指出，直接在 fab 函数中用 print 打印数字会导致该函数可复用性较差，因为 fab 函数返回 None，其他函数无法获得该函数生成的数列。
要提高 fab 函数的可复用性，最好不要直接打印出数列，而是返回一个 List。以下是 fab 函数改写后的第二个版本：
清单 2. 输出斐波那契數列前 N 个数第二版

 def fab(max):
    n, a, b = 0, 0, 1
    L = []
    while n < max:
        L.append(b)
        a, b = b, a + b
        n = n + 1
    return L
 &#91;/code&#93;
可以使用如下方式打印出 fab 函数返回的 List：
&#91;code&#93;
 >>> for n in fab(5):
 ...     print n
 ...
 1
 1
 2
 3
 5
 

改写后的 fab 函数通过返回 List 能满足复用性的要求，但是更有经验的开发者会指出，该函数在运行中占用的内存会随着参数 max 的增大而增大，如果要控制内存占用，最好不要用 List
来保存中间结果，而是通过 iterable 对象来迭代。例如，在 Python2.x 中，代码：

清单 3. 通过 iterable 对象来迭代

 for i in range(1000): pass
 

会导致生成一个 1000 个元素的 List，而代码：

 for i in xrange(1000): pass
 

则不会生成一个 1000 个元素的 List，而是在每次迭代中返回下一个数值，内存空间占用很小。因为 xrange 不返回 List，而是返回一个 iterable 对象。
利用 iterable 我们可以把 fab 函数改写为一个支持 iterable 的 class，以下是第三个版本的 Fab：
清单 4. 第三个版本

 class Fab(object): 

def __init__(self, max):
self.max = max
self.n, self.a, self.b = 0, 0, 1

def __iter__(self):
return self

def next(self):
if self.n < self.max: r = self.b self.a, self.b = self.b, self.a + self.b self.n = self.n + 1 return r raise StopIteration()

Python中yield函数就是这样，欢迎大家参考。。。。

python中的逻辑运算符and和or是如何来使用的呢？下面的内容将会通过具体的实例来演示python中的逻辑运算符and和or的使用方法及相关技巧：

python 中的and从左到右计算表达式，若所有值均为真，则返回最后一个值，若存在假，返回第一个假值。

or也是从左到有计算表达式，返回第一个为真的值。

IDLE 1.2.4
>>>'a'and'b'
'b'
>>>''and'b'
''
>>>'a'or'b'
'a'
>>>''or'b'
'b'
 

类似三目表达式的用法：bool? a : b

>>> a ='first'
>>> b ='second'
>>>1and a or b   # 等价于 bool = true时的情况
'first'
>>>0and a or b   # 等价于 bool = false时的情况
'second'
>>> a =''
>>>1and a or b   # a为假时，则出现问题
'second'
>>>(1and[a]or[b])[0]# 安全用法，因为[a]不可能为假，至少有一个元素
''
>>>
 

python中的逻辑运算符and和or就是这样，欢迎大家参考。。。。

Python中的with…as句子结构是如何来使用的呢？下面的内容将会通过具体的实例来演示Python中的with…as句子结构的使用方法及相关技巧：

这个语法是用来代替传统的try…finally语法的。

with EXPRESSION [ as VARIABLE] WITH-BLOCK
 

基本思想是with所求值的对象必须有一个__enter__()方法，一个__exit__()方法。

紧跟with后面的语句被求值后，返回对象的__enter__()方法被调用，这个方法的返回值将被赋值给as后面的变量。当with后面的代码块全部被执行完之后，将调用前面返回对象的__exit__()方法。

file = open("/tmp/foo.txt")
try:
    data = file.read()
finally:
    file.close()
 

使用with…as…的方式替换，修改后的代码是：

with open("/tmp/foo.txt") as file:
    data = file.read()
#!/usr/bin/env python
# with_example01.py
class Sample:
    def __enter__(self):
        print "In __enter__()"
        return "Foo"
    def __exit__(self, type, value, trace):
        print "In __exit__()"
def get_sample():
    return Sample()
with get_sample() as sample:
    print "sample:", sample
 

执行结果为

In __enter__()
sample: Foo
In __exit__()
 

1. __enter__()方法被执行
2. __enter__()方法返回的值 – 这个例子中是”Foo”，赋值给变量’sample’
3. 执行代码块，打印变量”sample”的值为 “Foo”
4. __exit__()方法被调用with真正强大之处是它可以处理异常。可能你已经注意到Sample类的__exit__方法有三个参数- val, type 和 trace。这些参数在异常处理中相当有用。我们来改一下代码，看看具体如何工作的。

Python中的with…as句子结构就是这样，欢迎大家参考。。。。

下面的内容主要介绍了Python中exit、return、sys.exit()的不同之处,欢迎大家参考：

有这样一道题目： 字符串标识符.修改例 6-1 的 idcheck.py 脚本,使之可以检测长度为一的标识符,并且可以识别 Python 关键字,对后一个要求,你可以使用 keyword 模块(特别是 keyword.kelist)来帮你.

我最初的代码是：

#!/usr/bin/env python 

import string
import keyword
import sys

#Get all keyword for python
#keyword.kwlist
#[‘and’, ‘as’, ‘assert’, ‘break’, …] keyWords = keyword.kwlist

#Get all character for identifier
#string.letters ==> ‘ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz’
#string.digits ==> ‘0123456789’
charForId = string.letters + “_”
numForId = string.digits

idInput = raw_input(“Input your words,please!”)

if idInput in keyWords:
print “%s is keyword fot Python!” % idInput
else:
lenNum = len(idInput)
if(1 == lenNum):
if(idInput in charForId and idInput != “_”):
print “%s is legal identifier for Python!” % idInput
else:
#It’s just “_”
print “%s isn’t legal identifier for Python!” % idInput

else:
if(idInput[0:1] in charForId):
legalstring = charForId + numForId
for item in idInput[1:]:
if (item not in legalstring):
print “%s isn’t legal identifier for Python!” % idInput
sys.exit(0)
print “%s is legal identifier for Python!2” % idInput
else:
print “%s isn’t legal identifier for Python!3” % idInput

Python中exit、return、sys.exit()的不同之处就是这样，欢迎大家参考。。。。

下面的内容主要介绍了Python中sys.argv的用法，如何来使用argv来获取参数，欢迎大家参考：

sys.argv变量是一个字符串的列表。特别地，sys.argv包含了命令行参数 的列表，即使用命令行传递给你的程序的参数。

这里，当我们执行python using_sys.py we are arguments的时候，我们使用python命令运行using_sys.py模块，后面跟着的内容被作为参数传递给程序。Python为我们把它存储在sys.argv变量中。记住，脚本的名称总是sys.argv列表的第一个参数。所以，在这里，’using_sys.py’是sys.argv[0]、’we’是sys.argv[1]、’are’是sys.argv[2]以及’arguments’是sys.argv[3]。注意，Python从0开始计数，而非从1开始。

sys.argv[]是用来获取命令行参数的，sys.argv[0]表示代码本身文件路径;比如在CMD命令行输入 “python test.py -help”，那么sys.argv[0]就代表“test.py”。

sys.startswith() 是用来判断一个对象是以什么开头的，比如在python命令行输入“’abc’.startswith(‘ab’)”就会返回True
以下实例参考:

#!/usr/local/bin/env python
import sys
def readfile(filename):
    '''Print a file to the standard output.'''
    f = file(filename)
    while True:
          line = f.readline()
          if len(line) == 0:
             break
          print line,
    f.close()
print "sys.argv[0]---------",sys.argv[0]
print "sys.argv[1]---------",sys.argv[1]
print "sys.argv[2]---------",sys.argv[2]
# Script starts from here
if len(sys.argv) < 2:
    print 'No action specified.'
    sys.exit()
if sys.argv&#91;1&#93;.startswith('--'):
   option = sys.argv&#91;1&#93;&#91;2:&#93;
   # fetch sys.argv&#91;1&#93; but without the first two characters
   if option == 'version':
      print 'Version 1.2'
   elif option == 'help':
      print '''"
           This program prints files to the standard output.
           Any number of files can be specified.
           Options include:
           --version : Prints the version number
           --help    : Display this help'''
   else:
       print 'Unknown option.'
       sys.exit()
else:
    for filename in sys.argv&#91;1:&#93;:
        readfile(filename)
 &#91;/code&#93;</p>
<p>执行结果:# python test.py --version help

sys.argv[0]--------- test.py
sys.argv[1]--------- --version
sys.argv[2]--------- help
Version 1.2
 

注意:sys.argv[1][2:]表示从第二个参数，从第三个字符开始截取到最后结尾，本例结果为:version

Python中sys.argv的用法就是这样，欢迎大家参考。。。。

Python fileinput模块是如何来使用的呢？下面的内容将会通过具体的实例来演示Python fileinput模块的使用方法及相关技巧：

fileinput模块可以遍历文本文件的所有行.它的工作方式和readlines很类似,不同点在于,它不是将全部的行读到列表中而是创建了一个xreadlines对象.

下面是fileinput模块中的常用函数
input() #它会返回能够用于for循环遍历的对象.
filename() #返回当前文件的名称
lineno() #返回当前(累计)的行数
filelineno() #返回当前文件的行数
isfirstline() #检查当前行是否是文件的第一行

#!/bin/env python
#coding=utf-8
import fileinput
import sys
import glob
import string
'''  处理一个文本文件  '''
for line in fileinput.input("tab.sh"):
    print line
'''处理多个文本文件 并输出行号'''
for line in fileinput.input(glob.glob("*.sh")):
    if fileinput.isfirstline():
       print "------ reading %s ------n" % fileinput.filename()
    print str(fileinput.lineno()) + " " + line
 

例子：

[root@rac1 admin]# python ftest.py
abc_permission_collection 

abc_user

abc_user_group_relationship

—— reading c.sh ——

1 c

2 cc

3 ccc

—— reading tab.sh ——

4 abc_permission_collection

5 abc_user

6 abc_user_group_relationship

[root@rac1 admin]#

Python fileinput模块就是这样，欢迎大家参考。。。。

python获取一组汉字拼音首字母是如何来实现的呢？下面的内容将会通过具体的实例来演示python获取一组汉字拼音首字母的实现方法及相关技巧：

本文实例讲述了python获取一组汉字拼音首字母的方法。分享给大家供大家参考。具体实现方法如下：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
def multi_get_letter(str_input):
if isinstance(str_input, unicode):
unicode_str = str_input
else:
try:
unicode_str = str_input.decode(‘utf8’)
except:
try:
unicode_str = str_input.decode(‘gbk’)
except:
print ‘unknown coding’
return
return_list = [] for one_unicode in unicode_str:
return_list.append(single_get_first(one_unicode))
return return_list
def single_get_first(unicode1):
str1 = unicode1.encode(‘gbk’)
try:
ord(str1)
return str1
except:
asc = ord(str1[0]) * 256 + ord(str1[1]) – 65536
if asc >= -20319 and asc <= -20284: return 'a' if asc >= -20283 and asc <= -19776: return 'b' if asc >= -19775 and asc <= -19219: return 'c' if asc >= -19218 and asc <= -18711: return 'd' if asc >= -18710 and asc <= -18527: return 'e' if asc >= -18526 and asc <= -18240: return 'f' if asc >= -18239 and asc <= -17923: return 'g' if asc >= -17922 and asc <= -17418: return 'h' if asc >= -17417 and asc <= -16475: return 'j' if asc >= -16474 and asc <= -16213: return 'k' if asc >= -16212 and asc <= -15641: return 'l' if asc >= -15640 and asc <= -15166: return 'm' if asc >= -15165 and asc <= -14923: return 'n' if asc >= -14922 and asc <= -14915: return 'o' if asc >= -14914 and asc <= -14631: return 'p' if asc >= -14630 and asc <= -14150: return 'q' if asc >= -14149 and asc <= -14091: return 'r' if asc >= -14090 and asc <= -13119: return 's' if asc >= -13118 and asc <= -12839: return 't' if asc >= -12838 and asc <= -12557: return 'w' if asc >= -12556 and asc <= -11848: return 'x' if asc >= -11847 and asc <= -11056: return 'y' if asc >= -11055 and asc <= -10247: return 'z' return '' def main(str_input): a = multi_get_letter(str_input) b = '' for i in a: b= b+i print b if __name__ == "__main__": str_input=u'欢迎你' main(str_input) [/code]
python获取一组汉字拼音首字母就是这样，欢迎大家参考。。。。

下面的内容主要介绍了python选择排序算法,，欢迎大家参考：

本文实例总结了python选择排序算法。分享给大家供大家参考。具体如下：

代码1：

def ssort(V):
#V is the list to be sorted
 j = 0
 #j is the "current" ordered position, starting with the first one in the list
 while j != len(V):
 #this is the replacing that ends when it reaches the end of the list
   for i in range(j, len(V)):
   #here it replaces the minor value that it finds with j position
     if V[i] < V&#91;j&#93;:
     #but it does it for every value minor than position j
       V&#91;j&#93;,V&#91;i&#93; = V&#91;i&#93;,V&#91;j&#93;
   j = j+1
   #and here's the addiction that limits the verification to only the next values
 return V
 &#91;/code&#93;
<p>代码2：
</p>

def selection_sort(list):
  l=list[:]
  # create a copy of the list
  sorted=[]
  # this new list will hold the results
  while len(l):
  # while there are elements to sort...
    lowest=l[0]
    # create a variable to identify lowest
    for x in l:
    # and check every item in the list...
      if x<lowest:
      # to see if it might be lower.
        lowest=x
    sorted.append(lowest)
    # add the lowest one to the new list
    l.remove(lowest)
    # and delete it from the old one
  return sorted
 &#91;/code&#93;
<p>代码3</p>

a=input("Enter the length of the list :")
# too ask the user length of the list
l=[]
# take a emty list
for g in range (a):
# for append the values from user
  b=input("Enter the element :")
  # to ask the user to give list values
  l.append(b)
  # to append a values in a empty list l
print "The given eliments list is",l
for i in range (len(l)):
# to repeat the loop take length of l
  index=i
  # to store the values i in string index
  num=l[i]
  # to take first value in list and store in num
  for j in range(i+1,len(l)):
  # to find out the small value in a list read all values
    if num>l[j]:
    # to compare two values which store in num and list
      index=j
      # to store the small value of the loop j in index
      num=l[j]
      # to store small charecter are value in num
  tem=l[i]
  # to swap the list take the temparary list stor list vlaues
  l[i]=l[index]
  # to take first value as another
  l[index]=tem
print "After the swping the list by selection sort is",l
 

python选择排序算法就是这样，欢迎大家参考。。。。

python保存字符串到文件是如何来实现的呢？下面的内容将会通过具体的实例来演示python保存字符串到文件的实现方法及相关技巧：

本文实例讲述了python保存字符串到文件的方法。分享给大家供大家参考。具体实现方法如下：

def save(filename, contents):
  fh = open(filename, 'w')
  fh.write(contents)
  fh.close()
save('file.name', 'some stuff')
 

python保存字符串到文件就是这样，欢迎大家参考。。。。

下面的内容主要介绍了Python中marshal对象序列化,，欢迎大家参考：

有时候，要把内存中的一个对象持久化保存到磁盘上，或者序列化成二进制流通过网络发送到远程主机上。Python中有很多模块提供了序列化与反序列化的功能，如：marshal, pickle, cPickle等等。今天就讲讲marshal模块。

• 　　注意： marshal并不是一个通用的模块，在某些时候它是一个不被推荐使用的模块，因为使用marshal序列化的二进制数据格式还没有文档化，在不同版本的Python中，marshal的实现可能不一样。也就是说，用python2.5序列为一个对象，用python2.6的程序反序列化所得到的对象，可能与原来的对象是不一样的。但这个模块存在的意义，正如Python手册中所说：The marshal module exists mainly to support reading and writing the “pseudo-compiled” code for Python modules of .pyc files.

下面是marshal模块中定义的一些与序列化/反序列化有关的函数：
marshal.dump(value, file[, version])

将值写入到一个打开的输出流里。参数value表示待序列化的值。file表示打开的输出流。如:以”wb”模式打开的文件，sys.stdout或者os.popen。对于一些不支持序列类的类型，dump方法将抛出ValueError异常。要特别说明一下，并不是所有类型的对象都可以使用marshal模块来序列化/反序列化的。在python2.6中，支持的类型包括：None, integers, long integers, floating point numbers, strings, Unicode objects, tuple, list, set, dict, 和 code objects。对于tuple, list, set, dict等集合对象，其中的元素必须也是上述类型之一。
marshal.load(file)

执行与marshal.dump相反的操作，将二进制数据反序列为Python对象。下面是一个例子，演示这两个方法的使用：

# coding=gbk
import  marshal ,  sys ,  os
lst  =  [ 1 ,  ( 2 ,  " string " ) ,  { " key " :  " Value " } ]
# 序列化到文件中
fle  =  open ( os . path . join ( os . getcwd ( ) ,  ' fle . txt ' ) ,  ' wb ' )
marshal . dump ( lst  

Python中marshal对象序列化就是这样，欢迎大家参考。。。。

python实现的简单FTP上传下载文件是如何来实现的呢？下面的内容将会通过具体的实例来演示python实现的简单FTP上传下载文件的实现方法及相关技巧：

本文实例讲述了python实现的简单FTP上传下载文件的方法。分享给大家供大家参考。具体如下：

python本身自带一个FTP模块，可以实现上传下载的函数功能。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from ftplib import FTP
def ftp_up(filename = "20120904.rar"):
  ftp=FTP()
  ftp.set_debuglevel(2)
  #打开调试级别2，显示详细信息;0为关闭调试信息
  ftp.connect('192.168.0.1','21')
  #连接
  ftp.login('admin','admin')
  #登录，如果匿名登录则用空串代替即可
  #print ftp.getwelcome()
  #显示ftp服务器欢迎信息
  #ftp.cwd('xxx/xxx/')
  #选择操作目录
  bufsize = 1024
  #设置缓冲块大小
  file_handler = open(filename,'rb')
  #以读模式在本地打开文件
  ftp.storbinary('STOR %s' % os.path.basename(filename),file_handler,bufsize)
  #上传文件
  ftp.set_debuglevel(0)
  file_handler.close()
  ftp.quit()
  print "ftp up OK"
def ftp_down(filename = "20120904.rar"):
  ftp=FTP()
  ftp.set_debuglevel(2)
  ftp.connect('192.168.0.1','21')
  ftp.login('admin','admin')
  #print ftp.getwelcome()
  #显示ftp服务器欢迎信息
  #ftp.cwd('xxx/xxx/')
  #选择操作目录
  bufsize = 1024
  filename = "20120904.rar"
  file_handler = open(filename,'wb').write
  #以写模式在本地打开文件
  ftp.retrbinary('RETR %s' % os.path.basename(filename),file_handler,bufsize)
  #接收服务器上文件并写入本地文件
  ftp.set_debuglevel(0)
  file_handler.close()
  ftp.quit()
  print "ftp down OK"
 

python实现的简单FTP上传下载文件就是这样，欢迎大家参考。。。。

python线程池是如何来实现的呢？下面的内容将会通过具体的实例来演示python线程池的实现方法及相关技巧：

本文实例讲述了python实现线程池的方法。分享给大家供大家参考。具体如下：

原理：建立一个任务队列，然多个线程都从这个任务队列中取出任务然后执行，当然任务队列要加锁，详细请看代码

文件名：thrd_pool.py 系统环境：ubuntu linux & python2.6

import threading
import time
import signal
import os
class task_info(object):
  def __init__(self):
    self.func = None
    self.parm0 = None
    self.parm1 = None
    self.parm2 = None
class task_list(object):
  def __init__(self):
    self.tl = []
    self.mutex = threading.Lock()
    self.sem = threading.Semaphore(0)
  def append(self, ti):
    self.mutex.acquire()
    self.tl.append(ti)
    self.mutex.release()
    self.sem.release()
  def fetch(self):
    self.sem.acquire()
    self.mutex.acquire()
    ti = self.tl.pop(0)
    self.mutex.release()
    return ti
class thrd(threading.Thread):
  def __init__(self, tl):
    threading.Thread.__init__(self)
    self.tl = tl
  def run(self):
    while True:
      tsk = self.tl.fetch()
      tsk.func(tsk.parm0, tsk.parm1, tsk.parm2)
class thrd_pool(object):
  def __init__(self, thd_count, tl):
    self.thds = []
    for i in range(thd_count):
      self.thds.append(thrd(tl))
  def run(self):
    for thd in self.thds:
      thd.start()
def func(parm0=None, parm1=None, parm2=None):
  print 'count:%s, thrd_name:%s'%(str(parm0), threading.currentThread().getName())
def cleanup(signo, stkframe):
  print ('Oops! Got signal %s', signo)
  os._exit(0)
if __name__ == '__main__':
  signal.signal(signal.SIGINT, cleanup)
  signal.signal(signal.SIGQUIT, cleanup)
  signal.signal(signal.SIGTERM, cleanup)
  tl = task_list()
  tp = thrd_pool(6, tl)
  tp.run()
  count = 0
  while True:
    ti = task_info()
    ti.parm0 = count
    ti.func = func
    tl.append(ti)
    count += 1
    time.sleep(2)
  pass
 

执行方式：python thrd_pool.py

执行结果：

count:0, thrd_name:Thread-1
count:1, thrd_name:Thread-2
count:2, thrd_name:Thread-3
count:3, thrd_name:Thread-4
count:4, thrd_name:Thread-5
count:5, thrd_name:Thread-1
count:6, thrd_name:Thread-6
count:7, thrd_name:Thread-2
count:8, thrd_name:Thread-3
count:9, thrd_name:Thread-4
count:10, thrd_name:Thread-5
count:11, thrd_name:Thread-1
count:12, thrd_name:Thread-6
count:13, thrd_name:Thread-2
count:14, thrd_name:Thread-3
('Oops! Got signal %s', 15)
 

python线程池就是这样，欢迎大家参考。。。。

python在windows服务中新建进程是如何来实现的呢？下面的内容将会通过具体的实例来演示python在windows服务中新建进程的实现方法及相关技巧：

本文实例讲述了python实现在windows服务中新建进程的方法。分享给大家供大家参考。具体实现方法如下：

需要安装的软件：python和pywin32，我这里装的分别是python-2.6.amd64、pywin32-217.win-amd64-py2.6

文件名：dma_ws.py

#!python
import win32serviceutil
import win32service
import win32event
import os
from subprocess import Popen, PIPE
import json
import signal
run_proc = None
class DMA_WS(win32serviceutil.ServiceFramework):
 _svc_name_ = "DMA_WS"
 _svc_display_name_ = "DMA_WS"
 def __init__(self, args):
  win32serviceutil.ServiceFramework.__init__(self, args)
  self.hWaitStop = win32event.CreateEvent(None, 0, 0, None)
 def SvcStop(self):
  self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
  win32event.SetEvent(self.hWaitStop)
 def SvcDoRun(self):
  f = file('C:/DXMonitorSystem/dma.conf')
  host = json.load(f)
  f.close()
  dxsrv = os.path.join(host['app_path'], 'DXHttpServer.py')
  run_proc = Popen([host['ironpython'], dxsrv],
      stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=False,
      cwd=host['app_path'])
      #这里新建进程，注意cwd参数必不可少且要是绝对路径
  #res, err = run_proc.communicate()
  #这个函数内的上面部分都是逻辑处理的部分，可以根据自己的需求订制，但下面这行代码任何服务都需要
  win32event.WaitForSingleObject(self.hWaitStop, win32event.INFINITE)
  run_proc.kill() # 用于关闭服务所创建的子进程
  #os.kill(run_proc.pid, signal.SIGTERM)
if __name__=='__main__':
 win32serviceutil.HandleCommandLine(DMA_WS)
 

使用方法：

创建服务：Python dma_ws.py install

开始服务：python dma_ws.py start

停止服务：python dma_ws.py stop

python在windows服务中新建进程就是这样，欢迎大家参考。。。。

python实现的系统实用log类是如何来实现的呢？下面的内容将会通过具体的实例来演示python实现的系统实用log类的实现方法及相关技巧：

本文实例讲述了python实现的系统实用log类。分享给大家供大家参考。具体如下：

每个系统都必不可少会需要一个log类，方便了解系统的运行状况和排错，python本身已经提供了一个logger了，很强大，只要稍微封装一下就可以放到自己的系统了，下面是我自己的log类

文件名：logger.py

"""This module takes care of the logging
logger helps in creating a logging system for the application
Logging is initialised by function LoggerInit.
"""
import logging
import os
import sys
class logger(object):
  """Class provides methods to perform logging."""
  m_logger = None
  def __init__(self, opts, logfile):
    """Set the default logging path."""
    self.opts = opts
    self.myname = 'dxscs'
    self.logdir = '.'
    self.logfile = logfile
    self.filename = os.path.join(self.logdir, self.logfile)
  def loginit(self):
    """Calls function LoggerInit to start initialising the logging system."""
    logdir = os.path.normpath(os.path.expanduser(self.logdir))
    self.logfilename = os.path.normpath(os.path.expanduser(self.filename))
    if not os.path.isdir(logdir):
      try:
        os.mkdir(logdir)
      except OSError, e:
        msg = ('(%s)'%e)
        print msg
        sys.exit(1)
    self.logger_init(self.myname)
  def logger_init(self, loggername):
    """Initialise the logging system.
    This includes logging to console and a file. By default, console prints
    messages of level WARN and above and file prints level INFO and above.
    In DEBUG mode (-D command line option) prints messages of level DEBUG
    and above to both console and file.
    Args:
     loggername: String - Name of the application printed along with the log
     message.
    """
    fileformat = '[%(asctime)s] %(name)s: [%(filename)s: %(lineno)d]: %(levelname)-8s: %(message)s'
    logger.m_logger = logging.getLogger(loggername)
    logger.m_logger.setLevel(logging.INFO)
    self.console = logging.StreamHandler()
    self.console.setLevel(logging.CRITICAL)
    consformat = logging.Formatter(fileformat)
    self.console.setFormatter(consformat)
    self.filelog = logging.FileHandler(filename=self.logfilename, mode='w+')
    self.filelog.setLevel(logging.INFO)
    self.filelog.setFormatter(consformat)
    logger.m_logger.addHandler(self.filelog)
    logger.m_logger.addHandler(self.console)
    if self.opts['debug'] == True:
      self.console.setLevel(logging.DEBUG)
      self.filelog.setLevel(logging.DEBUG)
      logger.m_logger.setLevel(logging.DEBUG)
    if not self.opts['nofork']:
      self.console.setLevel(logging.WARN)
  def logstop(self):
    """Shutdown logging process."""
    logging.shutdown()
#test
if __name__ == '__main__':
  #debug mode & not in daemon
  opts = {'debug':True,'nofork':True}
  log = logger(opts, 'dxscs_source.log')
  log.loginit()
  log.m_logger.info('hello,world')
 

执行结果：

终端和文件中都显示有：[2012-09-06 16:56:01,498] dxscs: [logger.py: 88]: INFO : hello,world

如果只需要显示在文件中可以将debug和nofork选项都置为false

python实现的系统实用log类就是这样，欢迎大家参考。。。。

python实现DES加密解密方法是如何来实现的呢？下面的内容将会通过具体的实例来演示python实现DES加密解密方法的实现方法及相关技巧：

本文实例讲述了python实现DES加密解密方法。分享给大家供大家参考。具体分析如下：

实现功能：加密中文等字符串
密钥与明文可以不等长
这里只贴代码，加密过程可以自己百度，此处python代码没有优化

1. desstruct.py DES加密中要使用的结构体

ip= (58, 50, 42, 34, 26, 18, 10, 2,
   60, 52, 44, 36, 28, 20, 12, 4,
   62, 54, 46, 38, 30, 22, 14, 6,
   64, 56, 48, 40, 32, 24, 16, 8,
   57, 49, 41, 33, 25, 17, 9 , 1,
   59, 51, 43, 35, 27, 19, 11, 3,
   61, 53, 45, 37, 29, 21, 13, 5,
   63, 55, 47, 39, 31, 23, 15, 7)
ip_1=(40, 8, 48, 16, 56, 24, 64, 32,
   39, 7, 47, 15, 55, 23, 63, 31,
   38, 6, 46, 14, 54, 22, 62, 30,
   37, 5, 45, 13, 53, 21, 61, 29,
   36, 4, 44, 12, 52, 20, 60, 28,
   35, 3, 43, 11, 51, 19, 59, 27,
   34, 2, 42, 10, 50, 18, 58, 26,
   33, 1, 41, 9, 49, 17, 57, 25)
e =(32, 1, 2, 3, 4, 5, 4, 5,
    6, 7, 8, 9, 8, 9, 10, 11,
   12,13, 12, 13, 14, 15, 16, 17,
   16,17, 18, 19, 20, 21, 20, 21,
   22, 23, 24, 25,24, 25, 26, 27,
   28, 29,28, 29, 30, 31, 32, 1)
p=(16, 7, 20, 21, 29, 12, 28, 17,
   1, 15, 23, 26, 5, 18, 31, 10,
   2, 8, 24, 14, 32, 27, 3, 9,
   19, 13, 30, 6, 22, 11, 4, 25)
s=[ [[14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7],
   [0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8],
   [4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0],
   [15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13]],
   [[15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10],
   [3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5],
   [0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15],
   [13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9]],
   [[10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8],
   [13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1],
   [13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7],
   [1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12]],
  [[7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15],
   [13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14,9],
   [10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4],
   [3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14]],
  [[2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9],
   [14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6],
   [4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14],
   [11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3]],
  [[12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11],
   [10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8],
   [9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6],
   [4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13]],
  [[4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1],
   [13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6],
   [1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2],
   [6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12]],
  [[13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7],
   [1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2],
   [7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8],
   [2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11]]]
pc1=(57, 49, 41, 33, 25, 17, 9,
    1, 58, 50, 42, 34, 26, 18,
   10, 2, 59, 51, 43, 35, 27,
   19, 11, 3, 60, 52, 44, 36,
   63, 55, 47, 39, 31, 33, 15,
    7, 62, 54, 46, 38, 30, 22,
   14, 6, 61, 53, 45, 37, 29,
   21, 13, 5, 28, 20, 12, 4);
pc2= (14, 17, 11, 24, 1, 5, 3, 28,
   15, 6, 21, 10, 23, 19, 12, 4,
   26, 8, 16, 7, 27, 20, 13, 2,
   41, 52, 31, 37, 47, 55, 30, 40,
   51, 45, 33, 48, 44, 49, 39, 56,
   34, 53, 46, 42, 50, 36, 29, 32)
d = ( 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1)
 

2. des.py 加密文件

#_*_ coding:utf-8 _*_
#!/usr/bin/env python
#Filename:des.py
from desstruct import *
import re
__all__=[‘desencode’] class DES():
”’des 加密”’
def __init__(self):
pass
#加密
def code(self,from_code,key,code_len,key_len):
output=””
trun_len=0
#将密文和密钥转换为二进制
code_string=self._functionCharToA(from_code,code_len)
code_key=self._functionCharToA(key,key_len)
#如果密钥长度不是16的整数倍则以增加0的方式变为16的整数倍
if code_len%16!=0:
real_len=(code_len/16)*16+16
else:
real_len=code_len
if key_len%16!=0:
key_len=(key_len/16)*16+16
key_len*=4
#每个16进制占4位
trun_len=4*real_len
#对每64位进行一次加密
for i in range(0,trun_len,64):
run_code=code_string[i:i+64] l=i%key_len
run_key=code_key[l:l+64] #64位明文、密钥初始置换
run_code= self._codefirstchange(run_code)
run_key= self._keyfirstchange(run_key)
#16次迭代
for j in range(16):
#取出明文左右32位
code_r=run_code[32:64] code_l=run_code[0:32] #64左右交换
run_code=code_r
#右边32位扩展置换
code_r= self._functionE(code_r)
#获取本轮子密钥
key_l=run_key[0:28] key_r=run_key[28:56] key_l=key_l[d[j]:28]+key_l[0:d[j]] key_r=key_r[d[j]:28]+key_r[0:d[j]] run_key=key_l+key_r
key_y= self._functionKeySecondChange(run_key)
#异或
code_r= self._codeyihuo(code_r,key_y)
#S盒代替/选择
code_r= self._functionS(code_r)
#P转换
code_r= self._functionP(code_r)
#异或
code_r= self._codeyihuo(code_l,code_r)
run_code+=code_r
#32互换
code_r=run_code[32:64] code_l=run_code[0:32] run_code=code_r+code_l
#将二进制转换为16进制、逆初始置换
output+=self._functionCodeChange(run_code)
return output
#异或
def _codeyihuo(self,code,key):
code_len=len(key)
return_list=”
for i in range(code_len):
if code[i]==key[i]:
return_list+=’0′
else:
return_list+=’1′
return return_list
#密文或明文初始置换
def _codefirstchange(self,code):
changed_code=”
for i in range(64):
changed_code+=code[ip[i]-1] return changed_code
#密钥初始置换
def _keyfirstchange (self,key):
changed_key=”
for i in range(56):
changed_key+=key[pc1[i]-1] return changed_key
#逆初始置换
def _functionCodeChange(self, code):
lens=len(code)/4
return_list=”
for i in range(lens):
list=”
for j in range(4):
list+=code[ip_1[i*4+j]-1] return_list+=”%x” %int(list,2)
return return_list
#扩展置换
def _functionE(self,code):
return_list=”
for i in range(48):
return_list+=code[e[i]-1] return return_list
#置换P
def _functionP(self,code):
return_list=”
for i in range(32):
return_list+=code[p[i]-1] return return_list
#S盒代替选择置换
def _functionS(self, key):
return_list=”
for i in range(8):
row=int( str(key[i*6])+str(key[i*6+5]),2)
raw=int(str( key[i*6+1])+str(key[i*6+2])+str(key[i*6+3])+str(key[i*6+4]),2)
return_list+=self._functionTos(s[i][row][raw],4)
return return_list
#密钥置换选择2
def _functionKeySecondChange(self,key):
return_list=”
for i in range(48):
return_list+=key[pc2[i]-1] return return_list
#将十六进制转换为二进制字符串
def _functionCharToA(self,code,lens):
return_code=”
lens=lens%16
for key in code:
code_ord=int(key,16)
return_code+=self._functionTos(code_ord,4)
if lens!=0:
return_code+=’0’*(16-lens)*4
return return_code
#二进制转换
def _functionTos(self,o,lens):
return_code=”
for i in range(lens):
return_code=str(o>>i &1)+return_code
return return_code
#将unicode字符转换为16进制
def tohex(string):
return_string=”
for i in string:
return_string+=”%02x”%ord(i)
return return_string
def tounicode(string):
return_string=”
string_len=len(string)
for i in range(0,string_len,2):
return_string+=chr(int(string[i:i+2],16))
return return_string
#入口函数
def desencode(from_code,key):
#转换为16进制
from_code=tohex(from_code)
key=tohex(key)
des=DES()
key_len=len(key)
string_len=len(from_code)
if string_len<1 or key_len<1: print 'error input' return False key_code= des.code(from_code,key,string_len,key_len) return key_code #测试 if __name__ == '__main__': print desencode('我是12345678刘就是我abcdwfd','0f1571c947刘') #返回密文为: 84148584371a6a1fe99e1da0ce1e34649b88ed15098e8aa4b8eb0bf24885c658 [/code]

3. 解密文件

#_*_coding:utf-8_*_
#!/usr/bin/env python
#Filename:des.py
from desstruct import *
import re
__all__=[‘desdecode’] class DES():
”’解密函数，DES加密与解密的方法相差不大
只是在解密的时候所用的子密钥与加密的子密钥相反
”’
def __init__(self):
pass
def decode(self,string,key,key_len,string_len):
output=””
trun_len=0
num=0
#将密文转换为二进制
code_string=self._functionCharToA(string,string_len)
#获取字密钥
code_key=self._getkey(key,key_len)
#如果密钥长度不是16的整数倍则以增加0的方式变为16的整数倍
real_len=(key_len/16)+1 if key_len%16!=0 else key_len/16
trun_len=string_len*4
#对每64位进行一次加密
for i in range(0,trun_len,64):
run_code=code_string[i:i+64] run_key=code_key[num%real_len] #64位明文初始置换
run_code= self._codefirstchange(run_code)
#16次迭代
for j in range(16):
code_r=run_code[32:64] code_l=run_code[0:32] #64左右交换
run_code=code_r
#右边32位扩展置换
code_r= self._functionE(code_r)
#获取本轮子密钥
key_y=run_key[15-j] #异或
code_r= self._codeyihuo(code_r,key_y)
#S盒代替/选择
code_r= self._functionS(code_r)
#P转换
code_r= self._functionP(code_r)
#异或
code_r= self._codeyihuo(code_l,code_r)
run_code+=code_r
num+=1
#32互换
code_r=run_code[32:64] code_l=run_code[0:32] run_code=code_r+code_l
#将二进制转换为16进制、逆初始置换
output+=self._functionCodeChange(run_code)
return output
#获取子密钥
def _getkey(self,key,key_len):
#将密钥转换为二进制
code_key=self._functionCharToA(key,key_len)
a=[”]*16
real_len=(key_len/16)*16+16 if key_len%16!=0 else key_len
b=[”]*(real_len/16)
for i in range(real_len/16):
b[i]=a[:] num=0
trun_len=4*key_len
for i in range(0,trun_len,64):
run_key=code_key[i:i+64] run_key= self._keyfirstchange(run_key)
for j in range(16):
key_l=run_key[0:28] key_r=run_key[28:56] key_l=key_l[d[j]:28]+key_l[0:d[j]] key_r=key_r[d[j]:28]+key_r[0:d[j]] run_key=key_l+key_r
key_y= self._functionKeySecondChange(run_key)
b[num][j]=key_y[:] num+=1
return b
#异或
def _codeyihuo(self,code,key):
code_len=len(key)
return_list=”
for i in range(code_len):
if code[i]==key[i]:
return_list+=’0′
else:
return_list+=’1′
return return_list
#密文或明文初始置换
def _codefirstchange(self,code):
changed_code=”
for i in range(64):
changed_code+=code[ip[i]-1] return changed_code
#密钥初始置换
def _keyfirstchange (self,key):
changed_key=”
for i in range(56):
changed_key+=key[pc1[i]-1] return changed_key
#逆初始置换
def _functionCodeChange(self, code):
return_list=”
for i in range(16):
list=”
for j in range(4):
list+=code[ip_1[i*4+j]-1] return_list+=”%x” %int(list,2)
return return_list
#扩展置换
def _functionE(self,code):
return_list=”
for i in range(48):
return_list+=code[e[i]-1] return return_list
#置换P
def _functionP(self,code):
return_list=”
for i in range(32):
return_list+=code[p[i]-1] return return_list
#S盒代替选择置换
def _functionS(self, key):
return_list=”
for i in range(8):
row=int( str(key[i*6])+str(key[i*6+5]),2)
raw=int(str( key[i*6+1])+str(key[i*6+2])+str(key[i*6+3])+str(key[i*6+4]),2)
return_list+=self._functionTos(s[i][row][raw],4)
return return_list
#密钥置换选择2
def _functionKeySecondChange(self,key):
return_list=”
for i in range(48):
return_list+=key[pc2[i]-1] return return_list
#将十六进制转换为二进制字符串
def _functionCharToA(self,code,lens):
return_code=”
lens=lens%16
for key in code:
code_ord=int(key,16)
return_code+=self._functionTos(code_ord,4)
if lens!=0:
return_code+=’0’*(16-lens)*4
return return_code
#二进制转换
def _functionTos(self,o,lens):
return_code=”
for i in range(lens):
return_code=str(o>>i &1)+return_code
return return_code
#将unicode字符转换为16进制
def tohex(string):
return_string=”
for i in string:
return_string+=”%02x”%ord(i)
return return_string
def tounicode(string):
return_string=”
string_len=len(string)
for i in range(0,string_len,2):
return_string+=chr(int(string[i:i+2],16))
return return_string
#入口函数
def desdecode(from_code,key):
key=tohex(key)
des=DES()
key_len=len(key)
string_len=len(from_code)
if string_len%16!=0:
return False
if string_len<1 or key_len<1: return False key_code= des.decode(from_code,key,key_len,string_len) return tounicode(key_code) #测试 if __name__ == '__main__': print desdecode('84148584371a6a1fe99e1da0ce1e34649b88ed15098e8aa4b8eb0bf24885c658','0f1571c947刘' [/code]

解密后为: 我是12345678刘就是我abcdwfd

python实现DES加密解密方法就是这样，欢迎大家参考。。。。