python

本文主要介绍了python中的两个函数raw_input和input函数的不同之处，该如何使用这两个函数？或者说在什么情况下用这两个函数：

这两个均是 python 的内建函数，通过读取控制台的输入与用户实现交互。但他们的功能不尽相同。举两个小例子。

>>> raw_input_A = raw_input("raw_input: ")
raw_input: abc
 >>> input_A = input("Input: ")
Input: abc
Traceback (most recent call last):
 File "<pyshell#1>", line 1, in <module>
  input_A = input("Input: ")
 File "<string>", line 1, in <module>
NameError: name 'abc' is not defined
 >>> input_A = input("Input: ")
Input: "abc"
 >>>
 

>>> raw_input_B = raw_input(“raw_input: “)
raw_input: 123
>>> type(raw_input_B)

>>> input_B = input(“input: “)
input: 123
>>> type(input_B)

>>>

例子 1 可以看到：这两个函数均能接收 字符串 ，但 raw_input() 直接读取控制台的输入（任何类型的输入它都可以接收）。而对于 input() ，它希望能够读取一个合法的 python 表达式，即你输入字符串的时候必须使用引号将它括起来，否则它会引发一个 SyntaxError 。

例子 2 可以看到：raw_input() 将所有输入作为字符串看待，返回字符串类型。而 input() 在对待纯数字输入时具有自己的特性，它返回所输入的数字的类型（ int, float ）；同时在例子 1 知道，input() 可接受合法的 python 表达式，举例：input( 1 + 3 ) 会返回 int 型的 4 。

查看 Built-in Functions ，得知：

input([prompt])
  Equivalent to eval(raw_input(prompt))
 

input() 本质上还是使用 raw_input() 来实现的，只是调用完 raw_input() 之后再调用 eval() 函数，所以，你甚至可以将表达式作为 input() 的参数，并且它会计算表达式的值并返回它。

不过在 Built-in Functions 里有一句话是这样写的：Consider using the raw_input() function for general input from users.

除非对 input() 有特别需要，否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。

——-

今天参加某公司的笔试的时候，俺使用了 raw_input() 接受整数（返回的是字符串）并再用一行语句返回整型数据。杯具，当时不大确定能用 input() 这个函数！特此记录。

pythonraw_input()和input()函数的不同用法就是这样，欢迎大家参考。。。。

本文主要介绍了python中通过对正则表达式的使用来编写爬虫，抓取百度百科页面的方法：

本文实例讲述了python采集百度百科的方法。分享给大家供大家参考。具体如下：

#!/usr/bin/python
# -*- coding: utf-8 -*-
#encoding=utf-8
#Filename:get_baike.py
import urllib2,re
import sys
def getHtml(url,time=10):
 response = urllib2.urlopen(url,timeout=time)
 html = response.read()
 response.close()
 return html
def clearBlank(html):
 if len(html) == 0 : return ''
 html = re.sub('r|n|t','',html)
 while html.find(" ")!=-1 or html.find(' ')!=-1 :
  html = html.replace(' ',' ').replace(' ',' ')
 return html
if __name__ == '__main__':
  html = getHtml('http://baike.baidu.com/view/4617031.htm',10)
  html = html.decode('gb2312','replace').encode('utf-8') #转码
  title_reg = r'<h1 class="title" id="&#91;d&#93;+">(.*&#63;)</h1>'
  content_reg = r'<div class="card-summary-content">(.*&#63;)</p>'
  title = re.compile(title_reg).findall(html)
  content = re.compile(content_reg).findall(html)
  title[0] = re.sub(r'<&#91;^>]*&#63;>', '', title[0])
  content[0] = re.sub(r'<&#91;^>]*&#63;>', '', content[0])
  print title[0]
  print '#######################'
  print content[0]
 

希望本文所述对大家的Python程序设计有所帮助。

python爬虫采集百度百科的方法就是这样，欢迎大家参考。。。。

本文主要介绍了python如何通过simpson发来实现积分的计算，并通过实例代码来演示如何来实现积分的计算：

本文实例讲述了python实现数值积分的Simpson方法。分享给大家供大家参考。具体如下：

#coding = utf-8
#simpson 法计算积分，数值积分，效果非常理想
from math import *
def func(x):
 """
 定义被积分函数
 """
 return x*sin(x)
def Get_N(a,b,width):
 # width为步长
 N=int((b-a)/width + 1)
 if N%2 == 0:
  N=N+1
 return N
def GenerateData(a,b,n,width):
 datas = []
 r=a
 for i in range(0,n):
  datas.append(func(r))
  r = r+width
 return datas
def simpson_integral(datas,width,n):
 sum = datas[0]+datas[n-1]
 for i in range(2,n):
  if i%2== 0:
   sum = sum +4*datas[i-1]
  else:
   sum = sum +2*datas[i-1]
 return sum*width/3.0
if __name__ == "__main__":
 a=1.0 #积分上限
 b=3.0 #积分下限
 width=0.0625 #步长
 N=Get_N(a,b,width)
 datas = GenerateData(a,b,N,width)
 print simpson_integral(datas,width,N)
 

希望本文所述对大家的Python程序设计有所帮助。

python中Python通过simpson法实现数值积分方法就是这样，欢迎大家参考。。。。

我们可以通过centos的virtualenv来搭建虚拟独立的python3开发环境，这样可以保持python的开发项目的独立性，如何来搭建呢？本文将会通过详细的步骤来介绍如何通过virtualenv来搭建python的开发环境：

问题描述

环境： CentOS6.5

想在此环境下使用python3进行开发，但CentOS6.5默认的python环境是2.6.6版本。

之前的做法是直接从源码安装python3，替换掉现有的开发环境，但在随后使用过程中发现系统很多脚本依赖python2.6，直接替换会导致很多软件不正常。

今天发现有朋友使用virtualenv搭建python3开发环境，这里记录下，也方便我以后查阅。

安装python3

安装脚本如下：

wget <a href="https://www.python.org/ftp/python/3.4.3/Python-3.4.3.tgz">https://www.python.org/ftp/python/3.4.3/Python-3.4.3.tgz</a>
tar zxvf Python-3.4.3.tgz
cd Python-3.4.3
./configure --prefix=/usr/local
make && make altinstall
 

运行以上命令后，你可以在目录/usr/local/bin/python3.4 看到新编译的环境。

注意： 这里我们使用的是make altinstall，如果使用make install，你将会看到在系统中有两个不同版本的Python在/usr/bin/目录中。这将会导致很多问题，而且不好处理。

搭建python3开发环境

1、安装virtualenv，可以通过pip进行安装，命令如下：

pip install virtualenv
 

如果没有安装pip，可以通过以下命令安装：

yum install python-pip
 

2、创建虚拟环境：

virtualenv -p /usr/local/bin/python3.4 py34env
 

执行上述命令后，会在当前目录创建py34env文件夹，该文件夹即为我们创建的虚拟环境。

3、激活虚拟环境：

source py34env/bin/activate
 

3.1、在虚拟环境中安装ipython

pip install ipython
 

3.2、在虚拟环境中启动ipython：

ipython
 

4、退出虚拟环境

deactivate
 

python中在centos系统的virtualenv上搭建开发环境的方法就是这样，欢迎大家参考。。。。

在python中如何来对字符串做判断呢，比如字符是数字，字母，特殊字符，是大写还是小写。以及python如何来实现字符串大小写互相转换呢？本文将会通过实际的例子来演示python判断字符串的方法以及大小写转换：

判断字符串

s.isalnum() #所有字符都是数字或者字母
s.isalpha() #所有字符都是字母
s.isdigit() #所有字符都是数字
s.islower() #所有字符都是小写
s.isupper() #所有字符都是大写
s.istitle() #所有单词都是首字母大写，像标题
s.isspace() #所有字符都是空白字符、t、n
 

大小写转换

s.upper() #把所有字符中的小写字母转换成大写字母
s.lower() #把所有字符中的大写字母转换成小写字母
s.capitalize() #把第一个字母转化为大写字母，其余小写
s.title() #把每个单词的第一个字母转化为大写，其余小写
 

python中字符串判断以及大小写转换的方法就是这样，欢迎大家参考。。。。

本文主要讲述python中的编码问题，不同的编码格式如何来转换，并通过实际的例子来演示文件编码格式是如何来转换的：

　　刚来这个公司，熟悉了环境，老大就开始让我做一个迁移、修改代码的工作，我想说的是，这种工作真没劲~~，看别人的代码、改别人的代码、这里改个变量、那里改个文件名······，都是些没技术含量、很繁琐的事情，不过通过迁移代码顺便熟悉下环境也好。扯了这么多，说说今天的主题吧——代码编码格式改变，由于某些原因，需要将代码从A机房迁移到B机房，这两个之间不能互相访问，但是历史原因导致A机房的代码全是utf8编码的，B机房要求是GBK编码，看看这个怎么解决。

编码问题

　　先说说为什么会有编码问题，就拿上面那个例子来说，B机房这边数据库全是GBK编码的，因此从数据库中取出来的数据都是GBK的，从数据库中取出来的数据是GBK编码的，要在展示的时候不乱码，在不对数据库取出的数据转换的情况下，就需要发送header的时候设置编码为GBK，输出的文件（html、tpl等）都必须是GBK的，看看下面这个图会更清楚点：

　　　　DB（GBK） => php等（编码格式不限但如果代码文件中有汉字，文件就要是gbk编码或者在汉字输出的时候转化为gbk） => header(GBK)  => html、tpl（GBK）

　　或者还有一种方式只在出库的时候在代码中将utf8转化为gbk，总的来说utf8还是更流行点，问题更少点

　　　　DB(GBK) => php等(utf8，并将从数据库取出的数据转化为utf8) => header(utf8) => html、tpl(utf8)

　　只要按照上面这两种规范编码格式，就不会出现乱码情况，起码我测试的第一种方式是没问题的，所以我猜第二种也ok，好了，现在就来写一个转换文件编码格式的小脚本：

#!/usr/bin/python
# -*- coding: utf-8 -*-
#Filename:changeEncode.py
import os
import sys
def ChangeEncode(file,fromEncode,toEncode):
  try:
    f=open(file)
    s=f.read()
    f.close()
    u=s.decode(fromEncode)
    s=u.encode(toEncode)
    f=open(file,"w");
    f.write(s)
    return 0;
  except:
    return -1;
def Do(dirname,fromEncode,toEncode):
  for root,dirs,files in os.walk(dirname):
    for _file in files:
      _file=os.path.join(root,_file)
      if(ChangeEncode(_file,fromEncode,toEncode)!=0):
        print "[转换失败:]"+_file
      else:
        print "[成功：]"+_file
def CheckParam(dirname,fromEncode,toEncode):
  encode=["UTF-8","GBK","gbk","utf-8"]
  if(not fromEncode in encode or not toEncode in encode):
    return 2
  if(fromEncode==toEncode):
    return 3
  if(not os.path.isdir(dirname)):
    return 1
  return 0
if __name__=="__main__":
  error={1:"第一个参数不是一个有效的文件夹",3:"源编码和目标编码相同",2:"您要转化的编码不再范围之内：UTF-8，GBK"}
  dirname=sys.argv[1]
  fromEncode=sys.argv[2]
  toEncode=sys.argv[3]
  ret=CheckParam(dirname,fromEncode,toEncode)
  if(ret!=0):
    print error[ret]
  else:
    Do(dirname,fromEncode,toEncode)
 

　　脚本很简单，使用也很简单

　　./changeEncode.py target_dir fromEncode toEncode
 

　　这里要注意下，几种常见编码的关系：

　　us-ascii编码是utf-8编码的一个子集，这个是从stackoverflow上得到的，原文如下ASCII is a subset of UTF-8, so all ASCII files are already UTF-8 encoded，

我试了下确实是的，在不加汉字的时候显示编码为us-ascii，加了汉字之后，变为utf-8。

　　还有就是ASNI编码格式，这代表是本地编码格式，比如说在简体中文操作系统下，ASNI编码就代表GBK编码，这点还需要注意

　　还有一点就是一个在linux下查看文件编码格式的命令是：

file -i *

　　可以看到文件的编码格式。

　　当然了，上面的可能有些文件中有特殊字符，处理的时候会失败，但一般程序文件是没有问题的。

以上所述就是本文的全部内容了，希望大家能够喜欢。

python中代码编码转换就是这样，欢迎大家参考。。。。

本文主要介绍了在python语言中逗号的三种不同的用法以及每种用法所代表的不同意思，并通过实例来讲述python中逗号的用法：

本文实例讲述了Python中逗号的三种作用。分享给大家供大家参考。具体分析如下：

最近研究python  遇到个逗号的问题 一直没弄明白 今天总算搞清楚了

1.逗号在参数传递中的使用：

这种情况不多说  没有什么不解的地方 就是形参或者实参传递的时候参数之间的逗号

例如def  abc(a,b)或者abc(1,2)

2.逗号在类型转化中的使用 主要是元组的转换

例如:

>>> a=11
>>> b=(a)
>>> b
11
>>> b=(a,)
>>> b
(11,)
>>> b=(a,22)
>>> b
(11, 22)
>>> b=(a,22,)
>>> b
(11, 22)
 

从中可以看出  只有当b元组中只有一个元素的时候  需要逗号来转换为元组类型

3.逗号在输出语句print中的妙用:

例子:

>>> for i in range(0,5):
...   print i
...
1
2
3
4
>>> for i in range(0,5):
...   print i,
...
0 1 2 3 4
 

很明显 print语句默认的会在后面加上 换行  加了逗号之后 换行 就变成了 空格

希望本文所述对大家的Python程序设计有所帮助。

python中逗号的用法就是这样，欢迎大家参考。。。。

本文主要介绍了python语言中的数组拷贝的实现，并通过实例来演示python中数组复制时值传递和地址传递两种方法的不同之处：

本文实例讲述了python数组复制拷贝的实现方法。分享给大家供大家参考。具体分析如下：

python中直接通过等号赋值实际上只是引用地址的传递
如：

a = [1,2,3,4,5]
b=a
 

当a的值改变时，b的值也会随之改变

如果希望b和a没有关系，可以通过下面的方法

a = [1,2,3,4,5]
b=a[:]
 

这样a和b就是两个完全独立的数组，互相不会影响

希望本文所述对大家的Python程序设计有所帮助。

python中关于数组拷贝的传递方法就是这样，欢迎大家参考。。。。

本文主要介绍了6个在python编程中可以使用的用来提高python运行效率的方法，比如：关键代码使用外部功能包，使用键来做排序，对循环做优化，使用最新的python版本，尝试多种编码方法，交叉编译python应用等：

不喜欢Python的人经常会吐嘈Python运行太慢。但是，事实并非如此。尝试以下六个窍门，来为你的Python应用提速。

窍门一：关键代码使用外部功能包

Python简化了许多编程任务，但是对于一些时间敏感的任务，它的表现经常不尽人意。使用C/C++或机器语言的外部功能包处理时间敏感任务，可以有效提高应用的运行效率。这些功能包往往依附于特定的平台，因此你要根据自己所用的平台选择合适的功能包。简而言之，这个窍门要你牺牲应用的可移植性以换取只有通过对底层主机的直接编程才能获得的运行效率。以下是一些你可以选择用来提升效率的功能包：

Cython
Pylnlne
PyPy
Pyrex

这些功能包的用处各有不同。比如说，使用C语言的数据类型，可以使涉及内存操作的任务更高效或者更直观。Pyrex就能帮助Python延展出这样的功能。Pylnline能使你在Python应用中直接使用C代码。内联代码是独立编译的，但是它把所有编译文件都保存在某处，并能充分利用C语言提供的高效率。

窍门二：在排序时使用键

Python含有许多古老的排序规则，这些规则在你创建定制的排序方法时会占用很多时间，而这些排序方法运行时也会拖延程序实际的运行速度。最佳的排序方法其实是尽可能多地使用键和内置的sort()方法。譬如，拿下面的代码来说：

 import operator
 somelist = [(1, 5, 8), (6, 2, 4), (9, 7, 5)]
 somelist.sort(key=operator.itemgetter(0))
 somelist
 #Output = [(1, 5, 8), (6, 2, 4), (9, 7, 5)]
 somelist.sort(key=operator.itemgetter(1))
 somelist
 #Output = [(6, 2, 4), (1, 5, 8), (9, 7, 5)]
 somelist.sort(key=operator.itemgetter(2))
 somelist
 #Output = [(6, 2, 4), (9, 7, 5), (1, 5, 8)],
 

在每段例子里，list都是根据你选择的用作关键参数的索引进行排序的。这个方法不仅对数值类型有效，还同样适用于字符串类型。

窍门三：针对循环的优化

每一种编程语言都强调最优化的循环方案。当使用Python时，你可以借助丰富的技巧让循环程序跑得更快。然而，开发者们经常遗忘的一个技巧是：尽量避免在循环中访问变量的属性。譬如，拿下面的代码来说：

 lowerlist = ['this', 'is', 'lowercase']
 upper = str.upper
 upperlist = []
 append = upperlist.append
 for word in lowerlist:
 append(upper(word))
 print(upperlist)
 #Output = ['THIS', 'IS', 'LOWERCASE']
 

每次你调用str.upper, Python都会计算这个式子的值。然而，如果你把这个求值赋值给一个变量，那么求值的结果就能提前知道，Python程序就能运行得更快。因此，关键就是尽可能减小Python在循环中的工作量。因为Python解释执行的特性，在上面的例子中会大大减慢它的速度。

（注意：优化循环的方法还有很多，这只是其中之一。比如，很多程序员会认为，列表推导式是提高循环速度的最佳方法。关键在于，优化循环方案是提高应用程序运行速度的上佳选择。）

窍门四：使用较新的Python版本

如果你在网上搜索Python，你会发现数不尽的信息都是关于如何升级Python版本。通常，每个版本的Python都会包含优化内容，使其运行速度优于之前的版本。但是，限制因素在于，你最喜欢的函数库有没有同步更新支持新的Python版本。与其争论函数库是否应该更新，关键在于新的Python版本是否足够高效来支持这一更新。

你要保证自己的代码在新版本里还能运行。你需要使用新的函数库才能体验新的Python版本，然后你需要在做出关键性的改动时检查自己的应用。只有当你完成必要的修正之后，你才能体会新版本的不同。

然而，如果你只是确保自己的应用在新版本中可以运行，你很可能会错过新版本提供的新特性。一旦你决定更新，请分析你的应用在新版本下的表现，并检查可能出问题的部分，然后优先针对这些部分应用新版本的特性。只有这样，用户才能在更新之初就觉察到应用性能的改观。

窍门五：尝试多种编码方法

每次创建应用时都使用同一种编码方法几乎无一例外会导致应用的运行效率不尽人意。可以在程序分析时尝试一些试验性的办法。譬如说，在处理字典中的数据项时，你既可以使用安全的方法，先确保数据项已经存在再进行更新，也可以直接对数据项进行更新，把不存在的数据项作为特例分开处理。请看下面第一段代码：

 n = 16
 myDict = {}
 for i in range(0, n):
 char = 'abcd'[i%4]
 if char not in myDict:
 myDict[char] = 0
 myDict[char] += 1
 print(myDict)
 

当一开始myDict为空时，这段代码会跑得比较快。然而，通常情况下，myDict填满了数据，至少填有大部分数据，这时换另一种方法会更有效率。

 n = 16
 myDict = {}
 for i in range(0, n):
 char = 'abcd'[i%4]
 try:
 myDict[char] += 1
 except KeyError:
 myDict[char] = 1
 print(myDict)
 

在两种方法中输出结果都是一样的。区别在于输出是如何获得的。跳出常规的思维模式，创建新的编程技巧能使你的应用更有效率。

窍门六：交叉编译你的应用

开发者有时会忘记计算机其实并不理解用来创建现代应用程序的编程语言。计算机理解的是机器语言。为了运行你的应用，你借助一个应用将你所编的人类可读的代码转换成机器可读的代码。有时，你用一种诸如Python这样的语言编写应用，再以C++这样的语言运行你的应用，这在运行的角度来说，是可行的。关键在于，你想你的应用完成什么事情，而你的主机系统能提供什么样的资源。

Nuitka是一款有趣的交叉编译器，能将你的Python代码转化成C++代码。这样，你就可以在native模式下执行自己的应用，而无需依赖于解释器程序。你会发现自己的应用运行效率有了较大的提高，但是这会因平台和任务的差异而有所不同。

（注意：Nuitka现在还处在测试阶段，所以在实际应用中请多加注意。实际上，当下最好还是把它用于实验。此外，关于交叉编译是否为提高运行效率的最佳方法还存在讨论的空间。开发者已经使用交叉编译多年，用来提高应用的速度。记住，每一种解决办法都有利有弊，在把它用于生产环境之前请仔细权衡。）

在使用交叉编译器时，记得确保它支持你所用的Python版本。Nuitka支持Python2.6, 2.7, 3.2和3.3。为了让解决方案生效，你需要一个Python解释器和一个C++编译器。Nuitka支持许多C++编译器，其中包括Microsoft Visual Studio, MinGW 和 Clang/LLVM。

交叉编译可能造成一些严重问题。比如，在使用Nuitka时，你会发现即便是一个小程序也会消耗巨大的驱动空间。因为Nuitka借助一系列的动态链接库（DDLs）来执行Python的功能。因此，如果你用的是一个资源很有限的系统，这种方法或许不太可行。

结论

前文所述的六个窍门都能帮助你创建运行更有效率的Python应用。但是银弹是不存在的。上述的这些窍门不一定每次都能奏效。在特定的Python的版本下，有的窍门或许比其他的表现更好，但这有时候甚至取决于平台的差异。你需要总结分析你的应用，找到它效率低下的部分，然后尝试这些窍门，找到解决问题的最佳方法。

python中提高运行效率的6个方法就介绍完了，如果还有其它提高python运行效率的方法，欢迎大家留言。。。。

本文主要介绍python语言中的对文件读写操作的用法，并通过实际的例子来演示如何在python语言里对文件的读和写文件操作：

本文实例总结了Python读写文件方法。分享给大家供大家参考。具体分析如下：

1.open

使用open打开文件后一定要记得调用文件对象的close()方法。比如可以用try/finally语句来确保最后能关闭文件。

file_object = open('thefile.txt')
try:
   all_the_text = file_object.read( )
finally:
   file_object.close( )
 

注：不能把open语句放在try块里，因为当打开文件出现异常时，文件对象file_object无法执行close()方法。

2.读文件

读文本文件

input = open('data', 'r')
#第二个参数默认为r
input = open('data')
 

读二进制文件

input = open('data', 'rb') 

读取所有内容

file_object = open('thefile.txt')
try:
   all_the_text = file_object.read( )
finally:
   file_object.close( )
 

读固定字节

file_object = open('abinfile', 'rb')
try:
  while True:
     chunk = file_object.read(100)
    if not chunk:
      break
     do_something_with(chunk)
finally:
   file_object.close( )
 

读每行

list_of_all_the_lines = file_object.readlines( ) 

如果文件是文本文件，还可以直接遍历文件对象获取每行：

for line in file_object:
   process line
 

3.写文件

写文本文件

output = open('data', 'w') 

写二进制文件

output = open('data', 'wb') 

追加写文件

output = open('data', 'w+') 

写数据

file_object = open('thefile.txt', 'w')
file_object.write(all_the_text)
file_object.close()
 

写入多行

file_object.writelines(list_of_text_strings) 

注意，调用writelines写入多行在性能上会比使用write一次性写入要高。

在处理日志文件的时候，常常会遇到这样的情况：日志文件巨大，不可能一次性把整个文件读入到内存中进行处理，例如需要在一台物理内存为 2GB 的机器上处理一个 2GB 的日志文件，我们可能希望每次只处理其中 200MB 的内容。
在 Python 中，内置的 File 对象直接提供了一个 readlines(sizehint) 函数来完成这样的事情。以下面的代码为例：

file = open(‘test.log’, ‘r’)
sizehint = 209715200 # 200M
position = 0
lines = file.readlines(sizehint)
while not file.tell() – position < 0: position = file.tell() lines = file.readlines(sizehint) [/code]

每次调用 readlines(sizehint) 函数，会返回大约 200MB 的数据，而且所返回的必然都是完整的行数据，大多数情况下，返回的数据的字节数会稍微比 sizehint 指定的值大一点（除最后一次调用 readlines(sizehint) 函数的时候）。通常情况下，Python 会自动将用户指定的 sizehint 的值调整成内部缓存大小的整数倍。

file在python是一个特殊的类型，它用于在python程序中对外部的文件进行操作。在python中一切都是对象，file也不例外，file有file的方法和属性。下面先来看如何创建一个file对象：

file(name[, mode[, buffering]])
file()函数用于创建一个file对象，它有一个别名叫open()，可能更形象一些，它们是内置函数。来看看它的参数。它参数都是以字符串的形式传递的。name是文件的名字。
mode是打开的模式，可选的值为r w a U，分别代表读（默认） 写 添加支持各种换行符的模式。用w或a模式打开文件的话，如果文件不存在，那么就自动创建。此外，用w模式打开一个已经存在的文件时，原有文件的内容会被清空，因为一开始文件的操作的标记是在文件的开头的，这时候进行写操作，无疑会把原有的内容给抹掉。由于历史的原因，换行符在不同的系统中有不同模式，比如在 unix中是一个/n，而在windows中是‘/r/n’，用U模式打开文件，就是支持所有的换行模式，也就说‘/r’ ‘/n’ ‘/r/n’都可表示换行，会有一个tuple用来存贮这个文件中用到过的换行符。不过，虽说换行有多种模式，读到python中统一用/n代替。在模式字符的后面，还可以加上+ b t这两种标识，分别表示可以对文件同时进行读写操作和用二进制模式、文本模式（默认）打开文件。
buffering如果为0表示不进行缓冲;如果为1表示进行“行缓冲“;如果是一个大于1的数表示缓冲区的大小，应该是以字节为单位的。

file对象有自己的属性和方法。先来看看file的属性。

closed #标记文件是否已经关闭，由close()改写
encoding #文件编码
mode #打开模式
name #文件名
newlines #文件中用到的换行模式，是一个tuple
softspace #boolean型，一般为0，据说用于print

file的读写方法：

F.read([size]) #size为读取的长度，以byte为单位
F.readline([size])
#读一行，如果定义了size，有可能返回的只是一行的一部分
F.readlines([size])
#把文件每一行作为一个list的一个成员，并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数，size是表示读取内容的总长，也就是说可能只读到文件的一部分。
F.write(str)
#把str写到文件中，write()并不会在str后加上一个换行符
F.writelines(seq)
#把seq的内容全部写到文件中。这个函数也只是忠实地写入，不会在每行后面加上任何东西。
file的其他方法：

F.close()
#关闭文件。python会在一个文件不用后自动关闭文件，不过这一功能没有保证，最好还是养成自己关闭的习惯。如果一个文件在关闭后还对其进行操作会产生ValueError
F.flush()
#把缓冲区的内容写入硬盘
F.fileno()
#返回一个长整型的”文件标签“
F.isatty()
#文件是否是一个终端设备文件（unix系统中的）
F.tell()
#返回文件操作标记的当前位置，以文件的开头为原点
F.next()
#返回下一行，并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时，就是调用next()函数来实现遍历的。
F.seek(offset[,whence])
#将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的，一般为正数。但如果提供了whence参数就不一定了，whence可以为0表示从头开始计算，1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意，如果文件以a或a+的模式打开，每次进行写操作时，文件操作标记会自动返回到文件末尾。
F.truncate([size])
#把文件裁成规定的大小，默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大，依据系统的不同可能是不改变文件，也可能是用0把文件补到相应的大小，也可能是以一些随机的内容加上去。

希望本文所述对大家的Python程序设计有所帮助。

python中读写文件的操作方法是这样，欢迎大家参考。。。。

本文实例讲述了Python实现数据库编程方法。分享给大家供大家参考。具体分析如下：
用PYTHON语言进行数据库编程, 至少有六种方法可供采用. 我在实际项目中采用,不但功能强大,而且方便快捷.以下是我在工作和学习中经验总结.
方法一:使用DAO (Data Access Objects)
这个第一种方法可能会比较过时啦.不过还是非常有用的. 假设你已经安装好了PYTHONWIN,现在开始跟我上路吧……
找到工具栏上ToolsàCOM MakePy utilities,你会看到弹出一个Select Library的对话框, 在列表中选择’Microsoft DAO 3.6 Object Library'(或者是你所有的版本).
现在实现对数据的访问:

import win32com.client
engine = win32com.client.Dispatch("DAO.DBEngine.35")
db = engine.OpenDatabase(r"c:/temp/mydb.mdb")
 

现在你有了数据库引擎的连接,也有了数据库对象的实例.现在就可以打开一个recordset了. 假设在数据库中已经有一个表叫做 ‘customers’. 为了打开这个表,对其中数据进行处理,我们使用下面的语法:

rs = db.OpenRecordset("customers")
rs = db.OpenRecordset("select * from customers where state = 'OH'")
 

你也可以采用DAO的execute方法. 比如这样:

db.Execute("delete * from customers where balancetype = 'overdue' and name = 'bill'")
 

EOF 等属性也是可以访问的, 因此你能写这样的语句:

while not rs.EOF:
 print rs.Fields("State").Value
 rs.MoveNext()
 

我最开始采用这个方法,感觉不错.
方法二:使用Python DB API,Python ODBC modules(you can use ODBC API directly, but maybe it is difficult for most beginner.)
为了在Python里面也能有通用的数据库接口,DB-SIG为我们提供了Python数据库.(欲知详情,访问DB-SIG的网站,http://www.python.org/sigs/db-sig/). Mark
Hammond的win32扩展PythonWin里面包含了这些API的一个应用-odbc.pyd. 这个数据库API仅仅开放了一些有限的ODBC函数的功能(那不是它的目的),但是它使用起来很简单,而且在win32里面是免费的.
安装odbc.pyd的步骤如下:
1. 安装python软件包:
http://www.python.org/download/
2. 安装Mark Hammond的最新版本的python win32扩展 – PythonWin:
http://starship.python.net/crew/mhammond/
3. 安装必要的ODBC驱动程序,用ODBC管理器为你的数据库配置数据源等参数
你的应用程序将需要事先导入两个模块:
dbi.dll – 支持各种各样的SQL数据类型,例如:日期-dates
odbc.pyd – 编译产生的ODBC接口
下面有一个例子:

import dbi, odbc
import time
dbc = odbc.odbc(
    'sample/monty/spam'
    )
crsr = dbc.cursor()
crsr.execute(
    """
    SELECT country_id, name, insert_change_date
    FROM country
    ORDER BY name
    """
)
print 'Column descriptions:'
for col in crsr.description:
 print ' ', col
result = crsr.fetchall()
print '/nFirst result row:/n ', result[0]
print '/nDate conversions:'
date = result[0][-1]
fmt = '  %-25s%-20s'
print fmt % ('standard string:', str(date))
print fmt % ('seconds since epoch:', float(date))
timeTuple = time.localtime(date)
print fmt % ('time tuple:', timeTuple)
print fmt % ('user defined:', time.strftime('%d %B %Y', timeTuple))
 

下面是结果:
输出(output)

Column descriptions:
  ('country_id', 'NUMBER', 12, 10, 10, 0, 0)
  ('name', 'STRING', 45, 45, 0, 0, 0)
  ('insert_change_date', 'DATE', 19, 19, 0, 0, 1)
First result row:
  (24L, 'ARGENTINA',)
Date conversions:
  standard string:   Fri Dec 19 01:51:53 1997
  seconds since epoch:  882517913.0
  time tuple:    (1997, 12, 19, 1, 51, 53, 4, 353, 0)
  user defined:    19 December 1997
 

大家也可以去http://www.python.org/windows/win32/odbc.html看看,那儿有两个Hirendra Hindocha写的例子,还不错.
注意, 这个例子中,结果值被转化为Python对象了.时间被转化为一个dbiDate对象.这里会有一点限制,因为dbiDate只能表示UNIX时间(1 Jan 1970 00:00:00 GMT)之后的时间.如果你想获得一个更早的时间,可能会出现乱码甚至引起系统崩溃.*_*
方法三: 使用 calldll模块
(Using this module, you can use ODBC API directly. But now the python version is 2.1, and I don’t know if other version is compatible with it. 老巫:-)
Sam Rushing的calldll模块可以让Python调用任何动态连接库里面的任何函数,厉害吧?哈.其实,你能够通过直接调用odbc32.dll里面的函数操作ODBC.Sam提供了一个包装模块odbc.py,就是来做这个事情的.也有代码来管理数据源,安装ODBC,实现和维护数据库引擎 (Microsoft Access).在那些演示和例子代码中,还有一些让人侧目的好东东,比如cbdemo.py,有一个信息循环和窗口过程的Python函数!
[你可以到Sam’s Python Software去找到calldll的相关连接,那儿还有其他好多有趣的东西] 下面是安装CALLDLL包的步骤:
1. 安装PYTHON软件包(到现在为止最多支持2.1版本)
2. 下载calldll-2001-05-20.zip:
ftp://squirl.nightmare.com/pub/python/python-ext/calldll-2001-05-20.zip
3. 在LIB路径下面创建一个新路径比如说:
c:/Program Files/Python/lib/caldll/
4. 在原目录下解压calldll.zip
5. 移动calldll/lib/中所有的文件到上面一个父目录(calldll)里面,删除子目录(lib)
6. 在CALL目录里面生成一个file __init__.py文件,象这样:
# File to allow this directory to be treated as a python 1.5
package.
7. 编辑calldll/odbc.py:
在”get_info_word”和”get_info_long”里面,改变”calldll.membuf”为”windll.membuf”
下面是一个怎么使用calldll的例子:

from calldll import odbc
dbc = odbc.environment().connection() # create connection
dbc.connect('sample', 'monty', 'spam') # connect to db
# alternatively, use full connect string:
# dbc.driver_connect('DSN=sample;UID=monty;PWD=spam')
print 'DBMS: %s %s/n' % ( # show DB information
  dbc.get_info(odbc.SQL_DBMS_NAME),
  dbc.get_info(odbc.SQL_DBMS_VER)
  )
result = dbc.query( # execute query & return results
  """
  SELECT country_id, name, insert_change_date
  FROM country
  ORDER BY name
  """
  )
print 'Column descriptions:' # show column descriptions
for col in result[0]:
  print ' ', col
print '/nFirst result row:/n ', result[1] # show first result row
 

output(输出)

DBMS: Oracle 07.30.0000
Column descriptions:
  ('COUNTRY_ID', 3, 10, 0, 0)
  ('NAME', 12, 45, 0, 0)
  ('INSERT_CHANGE_DATE', 11, 19, 0, 1)
First result row:
  ['24', 'ARGENTINA', '1997-12-19 01:51:53']
 

方法四: 使用ActiveX Data Object(ADO)
现在给出一个通过Microsoft’s ActiveX Data Objects (ADO)来连接MS Access 2000数据库的实例.使用ADO有以下几个好处: 首先,与DAO相比,它能更快地连接数据库;其次,对于其他各种数据库(SQL Server, Oracle, MySQL, etc.)来说,ADO都是非常有效而方便的;再有,它能用于XML和文本文件和几乎其他所有数据,因此微软也将支持它比DAO久一些.
第一件事是运行makepy.尽管这不是必须的,但是它对于提高速度有帮助的.而且在PYTHONWIN里面运行它非常简单: 找到工具栏上ToolsàCOM MakePy utilities,你会看到弹出一个Select Library的对话框, 在列表中选择’Microsoft ActiveX Data Objects 2.5 Library ‘(或者是你所有的版本).
然后你需要一个数据源名Data Source Name [DSN] 和一个连接对象. [我比较喜欢使用DSN-Less 连接字符串 (与系统数据源名相比,它更能提高性能且优化代码)] 就MS Access来说,你只需要复制下面的DSN即可.对于其他数据库,或者象密码设置这些高级的功能来说,你需要去 [Control Panel控制面板 | 管理工具Administrative Tools | 数据源Data Sources (ODBC)]. 在那里,你可以设置一个系统数据源DSN. 你能够用它作为一个系统数据源名,或者复制它到一个字符串里面,来产生一个DSN-Less 的连接字符串. 你可以在网上搜索DSN-Less 连接字符串的相关资料. 好了,这里有一些不同数据库的DSN-Less连接字符串的例子:SQL Server, Access, FoxPro, Oracle , Oracle, Access, SQL Server, 最后是 MySQL.

>>>import win32com.client
>>> conn = win32com.client.Dispatch(r'ADODB.Connection')
>>> DSN = 'PROVIDER=Microsoft.Jet.OLEDB.4.0;DATA SOURCE=C:/MyDB.mdb;'
>>> conn.Open(DSN)
 

经过上面的设置之后,就可以直接连接数据库了:
首要的任务是打开一个数据集/数据表

>>> rs = win32com.client.Dispatch(r'ADODB.Recordset')
>>> rs_name = 'MyRecordset'
>>> rs.Open('[' + rs_name + ']', conn, 1, 3)
 

[1和3是常数.代表adOpenKeyset 和adLockOptimistic.我用它作为默认值,如果你的情况不同的话,或许你应该改变一下.进一步的话题请参考ADO相关材料.] 打开数据表后,你可以检查域名和字段名等等

>>> flds_dict = {}
>>> for x in range(rs.Fields.Count):
...  flds_dict[x] = rs.Fields.Item(x).Name
 

字段类型和长度被这样返回A :

>>> print rs.Fields.Item(1).Type
202 # 202 is a text field
>>> print rs.Fields.Item(1).DefinedSize
50 # 50 Characters
 

现在开始对数据集进行操作.可以使用SQL语句INSERT INTO或者AddNew() 和Update()

>>> rs.AddNew()
>>> rs.Fields.Item(1).Value = 'data'
>>> rs.Update()
 

这些值也能够被返回:

>>> x = rs.Fields.Item(1).Value
>>> print x
'data'
 

因此如果你想增加一条新的记录,不必查看数据库就知道什么number 和AutoNumber 字段已经产生了

>>> rs.AddNew()
>>> x = rs.Fields.Item('Auto_Number_Field_Name').Value
# x contains the AutoNumber
>>> rs.Fields.Item('Field_Name').Value = 'data'
>>> rs.Update()
 

使用ADO,你也能得到数据库里面所有表名的列表:

>>> oCat = win32com.client.Dispatch(r'ADOX.Catalog')
>>> oCat.ActiveConnection = conn
>>> oTab = oCat.Tables
>>> for x in oTab:
...  if x.Type == 'TABLE':
...   print x.Name
 

关闭连接. 注意这里C是大写,然而关闭文件连接是小写的c.

>>> conn.Close()
 

前面提到,可以使用SQL语句来插入或者更新数据,这时我们直接使用一个连接对象.

>>> conn = win32com.client.Dispatch(r'ADODB.Connection')
>>> DSN = 'PROVIDER=Microsoft.Jet.OLEDB.4.0;DATA SOURCE=C:/MyDB.mdb;'
>>> sql_statement = "INSERT INTO [Table_Name]
([Field_1], [Field_2]) VALUES ('data1', 'data2')"
>>> conn.Open(DSN)
>>> conn.Execute(sql_statement)
>>> conn.Close()
 

最后一个例子经常被看作是ADO的难点.一般说来,想要知道一个表的RecordCount 的话,必须象这样一个一个地计算他们 :

>>> # See example 3 above for the set-up to this
>>> rs.MoveFirst()
>>> count = 0
>>> while 1:
...  if rs.EOF:
...   break
...  else:
...   count = count + 1
...   rs.MoveNext()
 

如果你也象上面那样些程序的话,非常底效不说,如果数据集是空的话,移动第一个记录的操作会产生一个错误.ADO提供了一个方法来纠正它.在打开数据集之前,设置CursorLocation 为3. 打开数据集之后,就可以知道recordcount了.

>>> rs.Cursorlocation = 3 # don't use parenthesis here
>>> rs.Open('SELECT * FROM [Table_Name]', conn) # be sure conn is open
>>> rs.RecordCount # no parenthesis here either
186
 

[再:3是常数] 这些只用到ADO的皮毛功夫,但对于从PYTHON来连接数据库,它还是应该有帮助的.
想更进一步学习的话,建议深入对象模型.下面是一些连接:
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/ado270/htm/mdmscadoobjmod.asp
http://www.activeserverpages.ru/ADO/dadidx01_1.htm
(单步执行还可以，为何写为script就不行？老巫疑惑)
方法五:使用 mxODBC模块(在Windows和Unix下面都可以用,但是是商业化软件,要掏钱的.)下面是相关连接:
http://thor.prohosting.com/~pboddie/Python/mxODBC.html
http://www.egenix.com/files/python/mxODBC.html
方法六: 对具体的数据库使用特定的PYTHON模块
MySQL数据库à MySQLdb模块,下载地址为:
http://sourceforge.net/projects/mysql-python
PostgresSQL数据库àpsycopg模块
PostgresSQL的主页为: http://www.postgresql.org
Python/PostgresSQL模块下载地址: http://initd.org/software/psycopg
Oracle数据库àDCOracle模块下载地址: http://www.zope.org/Products/DCOracle
àcx_oracle模块下载地址: http://freshmeat.net/projects/cx_oracle/?topic_id=809%2C66

在实际的工作中，如何通过编写一段简单的python脚本来实现对整个网段的端口号进行扫描并查看端口号是否开放呢，下面我们会通过两个python脚本的例子来实现扫描IP网段，并查找出指定的端口号是否处于开放状态。

本文实例讲述了Python扫描IP段查看指定端口是否开放的方法。分享给大家供大家参考。具体实现方法如下：

#!/usr/local/bin/python
#-*- coding: UTF-8 -*-
####################################################################
##################################################
#BLOG:http://hi.baidu.com/alalmn
# Python 扫描IP段 指定端口是否开放
##################################################
import socket
import threading,time
socket.setdefaulttimeout(10) #设置了全局默认超时时间
#查看IP端口是否开放
class socket_port(threading.Thread):
  def __init__(self,cond, name):
    super(socket_port, self).__init__()
    self.cond = cond
    self.cond.set()#将标识位设为Ture
    self.HOST = name
  def run(self):
    #time.sleep(1) #确保先运行Seeker中的方法
    try:
      PORT=21
      s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
      s.connect((self.HOST,PORT))
      print""
      print self.HOST,u":",PORT,u"端口开放"
      #self.cond.wait()#堵塞线程，直到Event对象内部标识位被设为True或超时（如果提供了参数timeout）。
      self.cond.set()#将标识位设为Ture
      return 1
    except:
      print ".",
      #print self.HOST,u":",PORT,u"端口未开放"
      #self.cond.wait()#堵塞线程，直到Event对象内部标识位被设为True或超时（如果提供了参数timeout）。
      self.cond.set()#将标识位设为Ture
    return 0
##
#socket_port("192.168.2.1")
#if socket_port("192.168.2.100"):
#  print "开放"
#else:
#  print "未开放"
def ip2num(ip):
  ip = [int(x) for x in ip.split('.')]
  return ip[0]<<24 | ip&#91;1&#93;<<16 | ip&#91;2&#93;<<8 | ip&#91;3&#93;
def num2ip(num):
  #time.sleep(0.05) #50ms
  #time.sleep(0.1) #s
#  data='%s.%s.%s.%s' % ( (num & 0xff000000) >> 24,
#                 (num & 0x00ff0000) >> 16,
#                 (num & 0x0000ff00) >> 8,
#                 num & 0x000000ff )
#  #socket_port(data) #查看IP端口是否开放
  if num>=IPend:
    print u"IP导入数组完成"
  return '%s.%s.%s.%s' % ( (num & 0xff000000) >> 24,
               (num & 0x00ff0000) >> 16,
               (num & 0x0000ff00) >> 8,
               num & 0x000000ff )
def gen_ip(ip1,ip2): #返回数组
#  ip
#  global IPend
#  start, IPend = [ip2num(x) for x in ip.split('-')]
  global IPend
  IPend=ip2
  return [num2ip(num) for num in range(ip1,ip2+1) if num & 0xff]
import ini
if __name__=='__main__':
  ini.ini_get() #读取INI
  list_ip=gen_ip(ip2num(ini.IP1),ip2num(ini.IP2))
  I1 = 0 #得到list的第一个元素
  print u"开始扫描IP"
  ip=0
  while I1 < len(list_ip):
    #print list_ip&#91;I1&#93;
    time.sleep(0.3) #确保先运行Seeker中的方法
    cond = threading.Event()
    hider = socket_port(cond,list_ip&#91;I1&#93;)
    hider.start()
    if ip>=255:
      ini.ini_write(list_ip[I1],ini.IP2) #修改INI
      print ip
      ip=0
    ip=ip+1
    I1 = I1 + 1  #一层
 

ini.py：

#!/usr/local/bin/python
#-*- coding: UTF-8 -*-
##################################################
#qq:316118740
#BLOG:http://hi.baidu.com/alalmn
# Python 操作ini文件
# 刚学写的不好请大家见谅
##################################################
IP1="" #扫描IP
IP2=""  #当前已经扫到的IP
INITXT="IP.ini" #INI文件名字
import ConfigParser
def ini_get(): #读取INI
  try:
    global IP1
    global IP2
    global INITXT
    config = ConfigParser.ConfigParser()
    config.readfp(open(INITXT))
    IP1 = config.get("ipdata","ip1")
    IP2 = config.get("ipdata","ip2")
  except:
    print "读取INI错误"
    ini_add("","") #写入INI
def ini_add(ip1,ip2): #写入INI
  try:
    global INITXT
    config = ConfigParser.ConfigParser()
    config.add_section("ipdata")# 设置section段及对应的值
    config.set("ipdata","ip1",ip1)
    config.set("ipdata","ip2",ip2)
    config.write(open(INITXT, "w"))# 写入文件
  except:
    print "写入INI错误"
def ini_write(ip1,ip2): #修改INI
  try:
    global INITXT
    config = ConfigParser.ConfigParser()
    config.read(INITXT)
    if not config.has_section("ipdata"):#看是否存在该Section，不存在则创建
      temp = config.add_section("")
    config.set("ipdata","ip1",ip1)
    config.set("ipdata","ip2",ip2)
    config.write(open(INITXT, "r+"))
  except:
    print "修改INI错误"
    ini_add("","") #写入INI
#if __name__=='__main__':
##  ini_get() #读取INI
##  print IP1
##  print IP2
#
##  ini_add("222222222","3333333333333") #写入INI
##  ini_get() #读取INI
##  print IP1
##  print IP2
#
#  ini_write("999999999","0000000000") #修改INI
#  ini_get() #读取INI
#  print IP1
#  print IP2
 

运行：

python TCP21.py 

希望本文所述对大家的Python程序设计有所帮助。

python中扫描ip网段，查看端口号的方法就是这样，欢迎大家参考。。。。

本文主要讲述python如何来实现对过期时间的计算的方法，文章通过一个例子来讲述实现对过期时间计算的方法。

本文实例讲述了python简单实现计算过期时间的方法。分享给大家供大家参考。具体如下：

def time_passed(value):
now = datetime.now()
past = now – value
if past.days:
return u’%s天前’ % past.days
mins = past.seconds / 60
if mins < 60: return u'%s分钟前' % mins hours = mins / 60 return u'%s小时前' % hours [/code]

希望本文所述对大家的Python程序设计有所帮助。

python中计算过期时间的方法就是这样，欢迎大家参考。。。。

本文主要讲述了如何在python语言里使用全局变量，并讲述全局变量的用法，通过实例来分析如何使用全局变量，全局变量的使用的相关技巧。

本文实例分析了python中的全局变量用法。分享给大家供大家参考。具体分析如下：

Python是一种面向对象的开发语言，在函数中使用全局变量，一般应作全局变量说明，只有在函数内经过说明的全局变量才能使用，这里就来介绍下Python全局变量有关问题。

首先应该说明的是需要尽量避免使用Python全局变量。不同的模块都可以自由的访问全局变量，可能会导致全局变量的不可预知性。对全局变量，如果程序员甲修改了_a的值，这时可能导致程序中的错误。这种错误是很难发现和更正的。

全局变量降低了函数或模块之间的通用性，不同的函数或模块都要依赖于全局变量。同样，全局变量降低了代码的可读性，阅读者可能并不知道调用的某个变量是全局变量。 但是某些时候，Python全局变量能够解决局部变量所难以解决的问题。事物要一分为二。 python里面全局变量有两种灵活的用法：

gl.py：

gl_1 = 'hello'
gl_2 = 'world'
 

在其它模块中使用

a.py：

import gl
def hello_world()
  print gl.gl_1, gl.gl_2
 

b.py：

import gl
def fun1()
  gl.gl_1 = 'Hello'
  gl.gl_2 = 'World'
def modifyConstant() :
    global CONSTANT
    print CONSTANT
    CONSTANT += 1
    return
if __name__ == '__main__' :
    modifyConstant()
    print CONSTANT
 

1 声明法

在文件开头声明Python全局变量variable， 在具体函数中使用该变量时，需要事先声明 global variable，否则系统将该变量视为局部变量。 CONSTANT = 0  (将全局变量大写便于识别)

2模块法（推荐）

推荐！

gl.py：

gl_1 = 'hello'
gl_2 = 'world'
 

在其它模块中使用

a.py：

import gl
def hello_world()
  print gl.gl_1, gl.gl_2
 

b.py：

import gl
def fun1()
  gl.gl_1 = 'Hello'
  gl.gl_2 = 'World'
def modifyConstant() :
    global CONSTANT
    print CONSTANT
    CONSTANT += 1
    return
if __name__ == '__main__' :
    modifyConstant()
    print CONSTANT
 

希望本文所述对大家的Python程序设计有所帮助。

python中全局变量的使用方法就是这样，欢迎大家参考。。。。

本文将会讲述如何通过python语言来编写关于数独算法的程序，通过对实例的分析来更深入的讲解python数独算法的实现方法。

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

# -*- coding: utf-8 -*-
'''
Created on 2012-10-5
@author: Administrator
'''
from collections import defaultdict
import itertools
a = [
  [ 0, 7, 0, 0, 0, 0, 0, 0, 0], #0
  [ 5, 0, 3, 0, 0, 6, 0, 0, 0], #1
  [ 0, 6, 2, 0, 8, 0, 7, 0, 0], #2
  #
  [ 0, 0, 0, 3, 0, 2, 0, 5, 0], #3
  [ 0, 0, 4, 0, 1, 0, 3, 0, 0], #4
  [ 0, 2, 0, 9, 0, 5, 0, 0, 0], #5
  #
  [ 0, 0, 1, 0, 3, 0, 5, 9, 0], #6
  [ 0, 0, 0, 4, 0, 0, 6, 0, 3], #7
  [ 0, 0, 0, 0, 0, 0, 0, 2, 0], #8
#  0, 1, 2, 3,|4, 5, 6,|7, 8
  ]
#a = [
#  [0, 0, 0, 0, 0, 0, 0, 0, 0], #0
#  [0, 0, 0, 0, 0, 0, 0, 0, 0], #1
#  [0, 0, 0, 0, 0, 0, 0, 0, 0], #2
#  #
#  [0, 0, 0, 0, 0, 0, 0, 0, 0], #3
#  [0, 0, 0, 0, 0, 0, 0, 0, 0], #4
#  [0, 0, 0, 0, 0, 0, 0, 0, 0], #5
#  #
#  [0, 0, 0, 0, 0, 0, 0, 0, 0], #6
#  [0, 0, 0, 0, 0, 0, 0, 0, 0], #7
#  [0, 0, 0, 0, 0, 0, 0, 0, 0], #8
##  0, 1, 2, 3,|4, 5, 6,|7, 8
#  ]
exists_d = dict((((h_idx, y_idx), v) for h_idx, y in enumerate(a) for y_idx , v in enumerate(y) if v))
h_exist = defaultdict(dict)
v_exist = defaultdict(dict)
for k, v in exists_d.items():
 h_exist[k[ 0]][k[ 1]] = v
 v_exist[k[ 1]][k[ 0]] = v
aa = list(itertools.permutations(range(1, 10), 9))
h_d = {}
for hk, hv in h_exist.items():
 x = filter(lambda x:all((x[k] == v for k, v in hv.items())), aa)
 x = filter(lambda x:all((x[vk] != v for vk , vv in v_exist.items() for k, v in vv.items() if k != hk)), x)
# print x
 h_d[hk] = x
def test(x, y):
 return all([y[i] not in [x_[i] for x_ in x] for i in range(len(y)) ])
def test2(x):
 return len(set(x)) != 9
s = set(range(9))
sudokus = []
for l0 in h_d[0 ]:
 for l1 in h_d[ 1]:
  if not test((l0,), l1):
   continue
  for l2 in h_d[ 2]:
   if not test((l0, l1), l2):
    continue
   # 1,2,3行 进行验证
   if test2([l0[ 0], l0[ 1], l0[ 2]
      , l1[ 0], l1[ 1], l1[ 2]
      , l2[ 0], l2[ 1], l2[ 2]
      ]) : continue
   if test2([l0[ 3], l0[ 4], l0[ 5]
      , l1[ 3], l1[ 4], l1[ 5]
      , l2[ 3], l2[ 4], l2[ 5]
      ]) : continue
   if test2([l0[ 6], l0[ 7], l0[ 8]
      , l1[ 6], l1[ 7], l1[ 8]
      , l2[ 6], l2[ 7], l2[ 8]
      ]) : continue
   for l3 in h_d[ 3]:
    if not test((l0, l1, l2), l3):
     continue
    for l4 in h_d[ 4]:
     if not test((l0, l1, l2, l3), l4):
      continue
     for l5 in h_d[ 5]:
      if not test((l0, l1, l2, l3, l4), l5):
       continue
      # 4，5，6行 进行验证
      if test2([l3[ 0], l3[ 1], l3[ 2]
         , l4[ 0], l4[ 1], l4[ 2]
         , l5[ 0], l5[ 1], l5[ 2]
         ]) : continue
      if test2([l3[ 3], l3[ 4], l3[ 5]
         , l4[ 3], l4[ 4], l4[ 5]
         , l5[ 3], l5[ 4], l5[ 5]
         ]) : continue
      if test2([l3[ 6], l3[ 7], l3[ 8]
         , l4[ 6], l4[ 7], l4[ 8]
         , l5[ 6], l5[ 7], l5[ 8]
         ]) : continue
      for l6 in h_d[ 6]:
       if not test((l0, l1, l2, l3, l4, l5,), l6):
        continue
       for l7 in h_d[ 7]:
        if not test((l0, l1, l2, l3, l4, l5, l6), l7):
         continue
        for l8 in h_d[ 8]:
         if not test((l0, l1, l2, l3, l4, l5, l6, l7), l8):
          continue
         # 7，8，9行 进行验证
         if test2([l6[ 0], l6[ 1], l6[ 2]
            , l7[0 ], l7[1 ], l7[2 ]
            , l8[0 ], l8[1 ], l8[2 ]
            ]) : continue
         if test2([l6[ 3], l6[ 4], l6[ 5]
            , l7[3 ], l7[4 ], l7[5 ]
            , l8[3 ], l8[4 ], l8[5 ]
            ]) : continue
         if test2([l6[ 6], l6[ 7], l6[ 8]
            , l7[6 ], l7[7 ], l7[8 ]
            , l8[6 ], l8[7 ], l8[8 ]
            ]) : continue
         print l0
         print l1
         print l2
         print l3
         print l4
         print l5
         print l6
         print l7
         print l8
         sudokus.append((l0, l1, l2, l3, l4, l5, l6, l7, l8))
 

希望本文所述对大家的Python程序设计有所帮助。

python中实现数独算法的用法就是这样，欢迎大家参考。。。。

当我们在学些python的时候，如何来使用逗号这个特殊的符号呢？ 如何在赋值语句后使用逗号？在赋值语句后面使用给逗号的作用是什么呢？本文将会详细的讲述如何再赋值语句后使用逗号，并同时实例来讲述python中赋值语句后使用逗号的用法。

本文实例讲述了Python赋值语句后逗号的作用。分享给大家供大家参考。具体分析如下：

IDLE 2.6.2

>>> a = 1
>>> b = 2,
>>> print type(a)
<type 'int'>
>>> print type(b)
<type 'tuple'>
>>> c = []
>>> d = [],
>>> print type(c)
<type 'list'>
>>> print type(d)
<type 'tuple'>
 

赋值表达式的后面加了逗号后，会自动得到一个tuple的对象，在作一些与类型相关的工作或需要序列化时，是不能得到期望的结果的。工作中碰到类似灵异现象时，可以把这个放到自己的checklist中了。

>>> print c
[]
>>> print d
([],)
>>> print a
1
>>> print b
(2,)
 

希望本文所述对大家的Python程序设计有所帮助。

python中对赋值语句后使用逗号的用法就是这样，欢迎大家参考。。。。

在这篇博文中，将介绍django与数据库方面的交互的知识。首先在网上下载Python For MySQL，然后进行安装。安装成功之后，在setting.py文件中进行装载，如下：

 1  DATABASES = {
  2  ' default ' : {
  3  ' ENGINE ' : ' django.db.backends.mysql ' ,
  4  ' NAME ' : ' database ' , # 首先要在MySQL中建立一个数据库叫database
 5  ' USER ' :' root ' ,  # 你数据库的用户
 6  ' PASSWORD ' :' root ' ,  # 你数据库的密码
 7  ' HOST ' :' 127.0.0.1 ' ,
  8  ' PORT ' :' 3306 '
 9      }
 10  } 

配置好之后，如果没有错的话，进入项目所在目录，在命令行中运行python manage.py shell来进行测试。如果输入下面这段代码没有显示什么错误信息，就证明你的数据库配置正确了。之后就能进行增删改查操作。

1  from  django.db import  connection
 2  cursor = connection.cursor() 

下面假设你的数据库配置正确了。我们将演示如何进行增删改查操作。

首先在app应用中添加模型，我这里添加了3个，分别如下：

 1  # encoding=utf-8
 2  from  django.db import  models
  3
 4  # 建立模型,对应MySQL中的表
 5  #  Create your models here.
 6
 7  class  Publisher(models.Model):
  8      name = models.CharField(max_length = 30)    # 字段名以及类型指定
 9      address = models.CharField(max_length = 50)
 10      city = models.CharField(max_length = 50)
 11      state_province = models.CharField(max_length = 50)
 12      country = models.CharField(max_length = 50,blank=True)# blank=True表明字段可以为空
13      website = models.URLField(blank=True) # Python提供的特定URL形式
14
15  def  __unicode__ (self):  # 相当于Java中的toString()
16  return  u' id=%d,name=%s ' %(self.id,self.name)
 17
18  class  Meta: # 指定之后查出的结果集按照id的升序排列,使用ordering=['-id']则为降序.
19          ordering = [' id ' ]
 20
21  class  Author(models.Model):
 22      first_name = models.CharField(max_length = 50)
 23      last_name = models.CharField(max_length = 50)
 24      email = models.EmailField() # Python提供的特定Email格式x
25
26  def  __unicode__ (self):
 27  return  u' firstname=%s '  %self.first_name
 28
29  class  Meta:
 30          ordering = [' id ' ]
 31
32  class  Book(models.Model):
 33      title = models.CharField(max_length = 50)
 34      author = models.ManyToManyField(Author) # book和author为多对多
35      publisher = models.ForeignKey(Publisher)# 外键
36      publication_date = models.DateField()   # Python提供的特定日期格式
37
38  def  __unicode__ (self):
 39  return  self.title
 40
41  class  Meta:
 42          ordering = [' id ' ] 

上面的代码请参看其后注释，很容易理解。简历好模型之后(模型对应我们在数据库中表)，我们在setting.py中的INSTALLED_APPS元组里对我们的项目进行注册。然后使用python manage.py syncdb命令创建数据库中的表。创建成功之后，在tests.py里面对数据库进行操作（不是一定要在这个文件里）。

插入数据

先看下面这段代码：

 1  # encoding=utf-8
 2  # Create your tests here.
 3  from  Second.models import  Publisher
  4  # 插入对象
 5  p1 = Publisher(name=' zhouxy ' ,address=' nenu-software ' ,city=' 长春 ' ,state_province=' CA ' ,country=' China ' ,website=' www.cnblogs.com/zhouxuanyu ' )
  6  p1.save();
  7  p2 = Publisher(name=' zhouxuanyu ' ,address=' nenu-software ' ,city=' 长春 ' ,state_province=' CA ' ,country=' China ' ,website=' www.cnblogs.com/zxyyxzshine ' )
  8  p2.save();
  9  publisher_list = Publisher.objects.all();
 10  print  publisher_list 

在上面第5，7行创建两个对象p1，p2。然后我们分别调用它们的save()方法，将其插入数据库。9，10行打印出这两个对象的信息。打印的信息就是我们在model中定义Publisher的时候所定义的__unicode__函数返回的值。类似于Java中对象的toString()。下面是结果图：

我们可以使用python manage.py sqlall Second命令来显示MySQL语法。（版面原因，我只截部分图）

查询数据

1  # 查询对象
2  print  Publisher.objects.filter(name=' zhouxy ' ).order_by(' id ' ) # 等同于在sql中使用where关键字,也可以在model中添加class Meta:
3  print  Publisher.objects.filter(name=' zhouxy ' ,city=' 长春 ' ) # 等同于在sql中使用where和and关键字
4  print  Publisher.objects.filter(name__contains=' zhouxy ' )[0:2] # sql缺省=操作符是精确匹配,字段__contains相当于sql中的like,切片操作符等同于sql中的offset..limit..
5  print  Publisher.objects.get(name=' zxyyxzshine ' ,id=2) # 获取单个对象  

对照注释，很容易理解。filter()等同于sql中的where关键字。order_by()等同于sql中的order by语句。如果在filter中添加一个以上的条件，那么就相当于在sql中在条件语句中使用and关键字将条件结合起来。

更新数据

1  # 更新对象
2  print  Publisher.objects.filter(id=1).update(name=" zxyyxzshine >" ) # 返回更新成功的row数
3  print  Publisher.objects.filter(name=' zhouxuanyu ' ).update(name=' zxyyxzshine ' ) 

删除对象

1  # 删除对象
2  print  Publisher.objects.filter(id=1).delete()
 3  print  Publisher.objects.all().delete() 

原文:http://www.cnblogs.com/zhouxuanyu/p/4564162.html

Python是一种非常富有表现力的语言。它为我们提供了一个庞大的标准库和许多内置模块，帮助我们快速完成工作。然而，许多人可能会迷失在它提供的功能中，不能充分利用标准库，过度重视单行脚本，以及误解Python基本结构等。本文是一个关于Python新手可能会陷入的一些陷阱的不完全列表。

不知道Python版本

这是一个在StackOverflow上反复出现的问题。许多人能写出在某个版本上完美工作的代码，但在他们在自己的系统上安装有不同版本的Python。要确保你知道你正在使用的Python版本。

你可以通过下边的代码查看Python版本：

$ python --version
Python 2.7.9

不使用版本管理器

pyenv是一个极好的管理不同Python版本的工具，但很不幸，它只工作在*nix系统上。在Mac系统上，你可以简单地通过brew install pyenv安装它，在Linux上，也有一个 自动安装程序。

沉迷于一行程序

许多人热衷于一行程序带来的兴奋感。即使他们的一行解决方案比一个多行解决方案低效，他们也会吹嘘。

Python中的一行程序在本质上意味着具有多个表达式的复杂推导。例如：

l = [m for a, b in zip(this, that) if b.method(a) != b for m in b if not m.method(a, b) and reduce(lambda x, y: a + y.method(), (m, a, b))] 

老实讲，我编造了上面的例子。但我看到很多人都写类似的代码。这样的代码在一个星期后就会变得难以理解。如果你想做一些稍微复杂的事情，例如根据条件简单地在一个列表或集合中添加一个元素，你可能就会犯错误。

单行代码并不是什么成就，是的，他们可能看起来很灵活，但不是什么成就。想象一下，这就像是你在打扫房间时把所有的东西都塞进你的衣橱。好的代码应该是干净的，易于阅读的和高效的。

利用错误的方式初始化一个集合

这是一个更微妙的问题，可能让你措手不及。集合推导很像列表推导。

>>> { n for n in range(10) if n % 2 == 0 }
{0, 8, 2, 4, 6}
>>> type({ n for n in range(10) if n % 2 == 0 }) 

上面就是集合推导的一个例子。集合就像列表，也是一个容器。所不同的是，一个集合中不能有任何重复的值，而且是无序的。看到集合推导人们经常错误地认为{}能初始化一个空集合。但其实不然，它初始化一个空字典。

>>> {}
{}
>>> type({})

如果你想初始化一个空集合，可以简单地调用set()方法。

>>> set()
set()
>>> type(set())

注意一个空集合用set()表示，但是一个包含一些元素的集合就就要用花括号包围元素来表示。

>>> s = set()
>>> s
set()
>>> s.add(1)
>>> s
{1}
>>> s.add(2)
>>> s
{1, 2} 

这和直觉是相反的，因为你期望类似于set([1, 2])的一些东西。

误解GIL

GIL（全局解释器锁）意味着在Python程序中，任意一个时间点只能有一个线程在运行。这意味着当我们创建一个线程并希望它并行运行时，它并不会那样。Python解释器实际的工作是在不同的运行线程之间快速进行切换。但这只是对实际发生事情的一个非常简单的解释，实际情况要复杂的多。有很多种并行运行的实例，例如使用本质为C扩展的各种库。但运行Python代码时，大部分时间里它不会并行执行。换句话说，Python中的线程并不像Java或C++中的线程。

许多人会尝试为Python辩解，说这些都是真正的线程。这确实是真的，但并不能改变这样一个事实：Python处理线程的方式和你期望的方式是不同的。Ruby语言也有相同的情况（Ruby也有一个解释器锁）。

指定的解决方案是使用multiprocessing模块。multiprocessing模块提供Process类，它是一个对fork的很好的覆盖。然而，fork过程比一个线程的代价高得多，所以你可能不会每次都能看到性能上的提升，因为不同的process之间需要做大量的工作来进行相互协调。

然而，这个问题并不存在于每一个Python的实现版本中。例如，Python的一个实现PyPy-stm就试图摆脱GIL（仍未稳定）。建立在其他平台，如JVM（Jython）或CLR（IronPython），上的Python实现，也没有GIL的问题。

总之，使用Thread类时要多加小心，你得到的可能不是你想要的。

使用老式类

在Python 2中，有两种类型的类，分别为“老式”类和“新式”类。如果你使用Python 3，那么你默认使用“新式”类。为了确保在Python2中使用“新式”类，你需要让你新创建的每一个类都继承object类，且类不能已继承了内置类型，例如int或list。换句话说，你的基类、类如果不继承其他类，就总是需要继承object类。

class MyNewObject(object):
# stuff here

这些“新式”类解决一些老式类的根本缺陷，这一点我们不需要深入了解。然而，如果有人感兴趣，他们可以在相关文档中找到相关信息。

按错误的方式迭代

对于这门语言的新手来说，下边的代码是非常常见的：

for name_index in range(len(names)):
print(names[name_index])

在上边的例子中，没有必须调用len函数，因为列表迭代实际上要简单得多：

for name in names:
print(name)

此外，还有一大堆其他的工具帮助你简化迭代。例如，可以使用zip同时遍历两个列表：

for cat, dog in zip(cats, dogs):
print(cat, dog)

如果你想同时考虑列表变量的索引和值，可以使用enumerate：

for index, cat in enumerate(cats):
print(cat, index)

在itertools中也有很多有用的函数供你选择。然而请注意，使用itertools函数并不总是正确的选择。如果itertools中的一个函数为你试图解决的问题提供了一个非常方便的解决办法，例如铺平一个列表或根据给定的列表创建一个其内容的排列，那就用它吧。但是不要仅仅因为你想要它而去适应你代码的一部分。

滥用itertools引发的问题出现的过于频繁，以至于在StackOverflow上一个德高望重的Python贡献者已经贡献他们资料的重要组成部分来解决这些问题。

使用可变的默认参数

我多次见到过如下的代码：

def foo(a, b, c=[]):
# append to c
# do some more stuff

永远不要使用可变的默认参数，可以使用如下的代码代替：

def foo(a, b, c=None):
if c is None:
c = []
# append to c
# do some more stuff 

与其解释这个问题是什么，不如展示下使用可变默认参数的影响：

In[2]: def foo(a, b, c=[]):
... c.append(a)
... c.append(b)
... print(c)
...
In[3]: foo(1, 1)
[1, 1]
In[4]: foo(1, 1)
[1, 1, 1, 1]
In[5]: foo(1, 1)
[1, 1, 1, 1, 1, 1] 

同一个变量c在函数调用的每一次都被反复引用。这可能有一些意想不到的后果。

总结

这些只是相对来说刚接触Python的人可能会遇到的一些问题。然而请注意，可能会遇到的问题远非就这么些。然而另一些缺陷是人们像使用Java或C++一样使用Python，并且试图按他们熟悉的方式使用Python。所以作为本篇文章的一个延续，尝试深入一些东西，例如Python的super函数。看看类方法、静态方法和 __slots__等。

原文:http://python.jobbole.com/81564/

这些东西是我在慕课网，廖雪峰大神的python课中学到的。自己写成笔记的形式分享给大家。

先来看一段代码：

 1  def  f1(x):
  2  return  x*x
  3
 4  def  new_fn(f):
  5  def  fn(j):
  6  print  ' print ' +f.__name__
 7  return  f(j)
  8  return  fn
  9
10  g1 = new_fn(f1)
 11  print  g1(5)  

运行结果：

printf1
 25  

1.为什么会用到闭包？

在不修改f1函数的前提下，输出f1函数的名称

2.闭包是个什么鬼？

new_fn()函数传入一个参数f（f是一个函数），new_fn()中有一个fn()函数，这个就是增加参数功能的地方。

fn()函数可以使用new_fn()函数接收的参数f。

3.实例化的时候g1 其实就是函数fn()(不准确但是好理解)，传入的参数f1就是要增加功能的函数。

这里需要注意的是，g1是一个函数名，加上（）就能当作函数来用了。（因为fn返回的是一个函数对象）

总结：

a.闭包就是为了不动原函数里面的代码，还要给它增加‘性功能’的一种手段。

b.通过外面的一层层的函数传递的参数，让最内层的函数可以直接调用外层函数所有参数，从而实现不动原函数的代码，增加新功能的办法。

最后，在python中，修饰器就是最好的体现：

看一段代码：

实现输出传入参数运行了多长时间，并输出，时间单位是传入的参数。

import  time
 def  performance(unit):
	 def  performance_decorator(f):
		 def  p(x):
			t1  = time.time()
			r  = f(x)
			t2  = time.time()
			 print  ' call %s() in %f %s '  % (f.__name__ , t2 - t1, unit)
			 return  r
		 return  p
	 return   performance_decorator
@performance( ' ms ' )
 def  factorial(n):
	 return  reduce(lambda  x,y: x*y, range(1, n+1))
 print  factorial(10)
 

原文:http://www.cnblogs.com/xueweihan/p/4564088.html

python的set和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算.

下面来点简单的小例子说明把。
 >>> x = set(' spam ' )
 >>> y = set([' h ' ,' a ' ,' m ' ])
 >>> x, y
(set([ ' a ' , ' p ' , ' s ' , ' m ' ]), set([' a ' , ' h ' , ' m ' ]))
再来些小应用。
 >>> x & y #  交集
set([' a ' , ' m ' ])
 >>> x | y #  并集
set([' a ' , ' p ' , ' s ' , ' h ' , ' m ' ])
 >>> x - y #  差集
set([' p ' , ' s ' ])
 

a = t | s          #  t 和 s的并集
b  = t & s          #  t 和 s的交集
c  = t – s          #  求差集（项在t中，但不在s中）
d  = t ^ s          #  对称差集（项在t或s中，但不会同时出现在二者中）    

#Python中，使用相应的优化函数可以大大的提高系统的运行效率。比如下面的这个例子：
fromtime importtime
lista =[1,2, 3, 4,5, 6, 7 ,8, 9, 10, 25, 50, 36, 43, 52]
listb =[2, 4, 6, 9, 36]
def noset_test():
	t  = time()
	filter =[]
	 for  i in  range(100000):
		 for  a in  lista:
			 for  b in  listb:
				 if  a==b:
					filter.append(a)
	 print  ' no set total run time: '
print  time() -t
def set_test():
	t1  = time()
	 for  i in  range(100000):
		list(set(lista) &set(listb))
	 print  " set total run time: >"
print  time() - t1
noset_test();
set_test();
输出为：
no set total run time:
 0.365000009537
set total run time:
 0.15700006485
通过使用set,运行的时间明显的有缩减。
 

engineers = set([' John ' , ' Jane ' , ' Jack ' , ' Janice ' ])
programmers  = set([' Jack ' , ' Sam ' , ' Susan ' , ' Janice ' ])
managers  = set([' Jane ' , ' Jack ' , ' Susan ' , ' Zack ' ])
employees  = list(engineers | programmers | managers)           #  union
engineering_management = list(engineers & managers)            #  intersection
fulltime_management = list(managers - engineers - programmers) #  difference
print " employees >" , employees
 print " engineering_management >"  ,engineering_management
 print  " fulltime_management >" , fulltime_management
输出为：
employees [ ' Jack ' , ' Sam ' , ' Susan ' , ' Jane ' , ' Janice ' , ' John ' , ' Zack ' ]
engineering_management [ ' Jane ' , ' Jack ' ]
fulltime_management [ ' Zack ' ] 

原文:http://www.cnblogs.com/zhxhdean/p/4564075.html

本文主要讲述了如何在python脚本编写中使用MySQL数据库,如何通过python现有的类来对MySQL数据库进行操作，本文会讲述如何 来下载并安装MySQL数据库，python如何连接，写入，更新，删除，查询，关闭MySQL数据库。

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

下载安装MySQLdb

① linux版本

http://sourceforge.net/projects/mysql-python/ 下载，在安装是要先安装setuptools，然后在下载文件目录下，修改mysite.cfg,指定本地mysql的mysql-config文件的路径

② windows版本

网上搜索到一个http://www.technicalbard.com/files/MySQL-python-1.2.2.win32-py2.6.exe

安装后import MySQLdb会出现 DeprecationWarning: the sets module is deprecated 这样一个警告，baidu一下

原因是2.6不知sets这个模块，不过已经添加了set内置函数。找到MySQLdb文件夹的中__init__.py,注释掉from sets import ImmutableSet   class DBAPISet(ImmutableSet):添加class DBAPISet(frozenset):；找到converters.py注释掉from sets import BaseSet, Set。然后修改第45行和129行中的Set为set。

搞定。

下面开始操作的demo:

Python代码

# -*- coding: utf-8 -*-
#mysqldb
import time, MySQLdb
#连接
conn=MySQLdb.connect(host="localhost",user="root",passwd="",db="test",charset="utf8")
cursor = conn.cursor()
#写入
sql = "insert into user(name,created) values(%s,%s)"
param = ("aaa",int(time.time()))
n = cursor.execute(sql,param)
print n
#更新
sql = "update user set name=%s where id=3"
param = ("bbb")
n = cursor.execute(sql,param)
print n
#查询
n = cursor.execute("select * from user")
for row in cursor.fetchall():
  for r in row:
    print r
#删除
sql = "delete from user where name=%s"
param =("aaa")
n = cursor.execute(sql,param)
print n
cursor.close()
#关闭
conn.close()
 

基本的使用如上，还是很简单的，进一步使用还没操作，先从网上找点资料放上来，以备后续查看

1.引入MySQLdb库

import MySQLdb 

2.和数据库建立连接

conn=MySQLdb.connect(host="localhost",user="root",passwd="sa",db="mytable",charset="utf8") 

提供的connect方法用来和数据库建立连接,接收数个参数,返回连接对象.

比较常用的参数包括
host:数据库主机名.默认是用本地主机.
user:数据库登陆名.默认是当前用户.
passwd:数据库登陆的秘密.默认为空.
db:要使用的数据库名.没有默认值.
port:MySQL服务使用的TCP端口.默认是3306.
charset:数据库编码.

更多关于参数的信息可以查这里
http://mysql-python.sourceforge.net/MySQLdb.html

然后,这个连接对象也提供了对事务操作的支持,标准的方法
commit() 提交
rollback() 回滚

3.执行sql语句和接收返回值

cursor=conn.cursor()
n=cursor.execute(sql,param) 

首先,我们用使用连接对象获得一个cursor对象,接下来,我们会使用cursor提供的方法来进行工作.这些方法包括两大类:1.执行命令,2.接收返回值

cursor用来执行命令的方法:

callproc(self, procname, args):用来执行存储过程,接收的参数为存储过程名和参数列表,返回值为受影响的行数

execute(self, query, args):执行单条sql语句,接收的参数为sql语句本身和使用的参数列表,返回值为受影响的行数

executemany(self, query, args):执行单条sql语句,但是重复执行参数列表里的参数,返回值为受影响的行数

nextset(self):移动到下一个结果集

cursor用来接收返回值的方法:

fetchall(self):接收全部的返回结果行.
fetchmany(self, size=None):接收size条返回结果行.如果size的值大于返回的结果行的数量,则会返回cursor.arraysize条数据.
fetchone(self):返回一条结果行.
scroll(self, value, mode=’relative’):移动指针到某一行.如果mode=’relative’,则表示从当前所在行移动value条,如果mode=’absolute’,则表示从结果集的第一行移动value条.

下面的代码是一个完整的例子.

#使用sql语句,这里要接收的参数都用%s占位符.要注意的是,无论你要插入的数据是什么类型,占位符永远都要用%s
sql="insert into cdinfo values(%s,%s,%s,%s,%s)"
#param应该为tuple或者list
param=(title,singer,imgurl,url,alpha)
#执行,如果成功,n的值为1
n=cursor.execute(sql,param)
#再来执行一个查询的操作
cursor.execute("select * from cdinfo")
#我们使用了fetchall这个方法.这样,cds里保存的将会是查询返回的全部结果.
#每条结果都是一个tuple类型的数据,这些tuple组成了一个tuple
cds=cursor.fetchall()
#因为是tuple,所以可以这样使用结果集
print cds[0][3]
#或者直接显示出来,看看结果集的真实样子
print cds
#如果需要批量的插入数据,就这样做
sql="insert into cdinfo values(0,%s,%s,%s,%s,%s)"
#每个值的集合为一个tuple,整个参数集组成一个tuple,或者list
param=((title,singer,imgurl,url,alpha),(title2,singer2,imgurl2,url2,alpha2))
#使用executemany方法来批量的插入数据.这真是一个很酷的方法!
n=cursor.executemany(sql,param)
 

4.关闭数据库连接

需要分别的关闭指针对象和连接对象.他们有名字相同的方法
cursor.close()
conn.close()

四步完成,基本的数据库操作就是这样了.下面是两个有用的连接
MySQLdb用户指南: http://mysql-python.sourceforge.net/MySQLdb.html
MySQLdb文档: http://mysql-python.sourceforge.net/MySQLdb-1.2.2/public/MySQLdb-module.html

5 编码（防止乱码）

需要注意的点：

1 Python文件设置编码 utf-8 （文件前面加上 #encoding=utf-8)
2 MySQL数据库charset=utf-8
3 Python连接MySQL是加上参数 charset=utf8
4 设置Python的默认编码为 utf-8 (sys.setdefaultencoding(utf-8)

#encoding=utf-8
import sys
import MySQLdb
reload(sys)
sys.setdefaultencoding('utf-8')
db=MySQLdb.connect(user='root',charset='utf8')
 

注：MySQL的配置文件设置也必须配置成utf8

设置 MySQL 的 my.cnf 文件，在 [client]/[mysqld]部分都设置默认的字符集（通常在/etc/mysql/my.cnf)：

<!--&#91;endif&#93;-->
[client]
default-character-set = utf8
[mysqld]
default-character-set = utf8
<!--&#91;endif&#93;-->
 

希望本文所述对大家的Python程序设计有所帮助。

python中对MySQL数据库的操作用法就是这样，欢迎大家参考。。。。

本文主要讲述在编写python函数的时候如何来设定函数返回值，通过几个实例来讲解如何来使用python的函数返回值以及返回多个值得用法。

本文实例讲述了Python的函数返回值用法。分享给大家供大家参考。具体分析如下：

最近学一些Python的基本用法，看到定义函数，发现似乎只能返回一个返回值，想想matlab里返回多个返回值多方便啊，网上查了查，看到有返回多个值的方法。
 
python 函数返回值有两种形式：

1 返回一个值。
2 返回多个值。
 
现看看返回一个值的吧。

def firstvalue(a,b):
 c = a + b
 return c
print firstvalue(1,2) #结果:3
 

再看看返回多个值的： 那怎么可以返回多个值呢，其他的语言一般调用函数的话，只能返回一个值，可能我不太熟悉所有的语言，我知道的语言只能返回一个值，而python可以返回多个值，感觉非常方便,发代码看下：

def secondvalue(a,b):
 c = a + b
 return (a,b,c)
x,y,z = secondvalue(1,2)
print 'x:',x,'y:',y,'z:',z
 

希望本文所述对大家的Python程序设计有所帮助。

python中函数返回值的用法就这样，欢迎大家参考。。。。

最近倒腾python自带的开发工具idle，用的很不习惯，还是用Eclipse编写python项目方便（自动补齐，智能报错，调试方便），下面就说说怎么用Eclipse编写python代码吧~

1、安装jdk，安装eclipse，这些就不赘述啦~

2、安装PyDev插件，方法一：打开Eclipse->help->install new software->add添加插件名称和下载路径，然后按照提示操作，Elipse会自动安装，安装成功后重启Eclipse；方法二：下载PyDev2.2.0.zip压缩包，解压后会有features和plugins两个文件夹，分别将这两个文件夹中的内容拷贝到Eclipse对应的文件夹中，然后重启Eclipse；

3、打开Eclipse->window->preferences->PyDev->Interpreter-python,点击右侧的new添加安装的python路径，然后点击“apply”就ok啦，下面就可以创建Python项目啦~

4、new一个python project，然后再添加一个Python文件，输入：print(“Hello world!>”),右键选择run as ->Python run，控制台输出：Hello world!

好啦，Eclipse写Python项目就是这样滴方便，快点写点撒子吧~

原文:http://www.cnblogs.com/prudent/p/python_2.html

对于SQLite来说，目前查看还是比较麻烦，所以就像把SQLite中的数据直接转成Excel中能查看的数据，这样也好在Excel中做进一步分数据处理或分析，如上篇文章中介绍的 IP抓取的IP数据
。从网上找到了一个将SQLite转成CVS的方法，贴在博客里，供需要的朋友使用：

import sqlite3
import csv, codecs, cStringIO
class UnicodeWriter:
    ">""
    A CSV writer which will write rows to CSV file >"f",
    which is encoded in the given encoding.
    >"">" 

def __init__(self, f, dialect=csv.excel, encoding="utf-8>", **kwds):
        # Redirect output to a queue
        self.queue = cStringIO.StringIO()
        self.writer = csv.writer(self.queue, dialect=dialect, **kwds)
        self.stream = f
        self.encoder = codecs.getincrementalencoder(encoding)() 

def writerow(self, row):
        self.writer.writerow([unicode(s).encode("utf-8>") for s in row])
        # Fetch UTF-8 output from the queue ...
        data = self.queue.getvalue()
        data = data.decode("utf-8>")
        # ... and reencode it into the target encoding
        data = self.encoder.encode(data)
        # write to the target stream
        self.stream.write(data)
        # empty queue
        self.queue.truncate(0) 

def writerows(self, rows):
        for row in rows:
            self.writerow(row)

conn = sqlite3.connect('ipaddress.sqlite3.db')
c = conn.cursor()
c.execute('select * from ipdata')
writer = UnicodeWriter(open("export_data.csv>", "wb>"))
writer.writerows(c) 

原文:http://blogread.cn/it/article/4884?f=hot1

python中的命令行解析最简单最原始的方法是使用sys.argv来实现，更高级的可以使用argparse这个模块。argparse从python 2.7开始被加入到标准库中，所以如果你的python版本还在2.7以下，那么需要先手动安装。

基本使用

import argparse
parser=argparse.ArgumentParser()
parser.add_argument("echo>",help="echo the string>")
args=parser.parse_args()
print args.echo 

参数介绍

上面这个例子是最简单的一个使用例子，功能是把你的输入参数打印到屏幕 。不过对于基本的使用需求，这几行代码应该就已经够用，更加高级的用法可以参考官方文档。

下面介绍下例子代码。

1、导入argparse模块

2、创建解析器对象ArgumentParser，可以添加参数。

原文:http://www.sijitao.net/2000.html