Python 文件I/O
读取键盘输入
raw_input
inputraw_input函数
#!/usr/bin/python
# -*- coding: UTF-8 -*-
str = raw_input("请输入：");
print "你输入的内容是: ", str
请输入：Hello Python！
你输入的内容是: Hello Python！
- input函数
input 可以接收一个Python表达式作为输入，并将运算结果返回。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
str = input("请输入：");
print "你输入的内容是: ", str
请输入：[x*5 for x in range(2,10,2)]
你输入的内容是: [10, 20, 30, 40]
打开和关闭文件
open 函数
!/usr/bin/python
-- coding: UTF-8 --
打开一个文件
fo = open("foo.txt", "wb")
print "文件名: ", fo.name
print "是否已关闭 : ", fo.closed
print "访问模式 : ", fo.mode
print "末尾是否强制加空格 : ", fo.softspace
文件名: foo.txt
是否已关闭 : False
访问模式 : wb
末尾是否强制加空格 : 0
##### close()方法
##### write()方法
- write()方法可将任何字符串写入一个打开的文件。
- Write()方法不在字符串的结尾添加换行符('\n')：
语法：
fileObject.write(string);
##### read()方法
- read（）方法从一个打开的文件中读取一个字符串。
fileObject.read([count]);
该方法从文件的开头开始读入，如果没有传入count，它会尝试尽可能多地读取更多的内容，很可能是直到文件的末尾。
##### 文件定位
- tell()方法告诉你文件内的当前位置；换句话说，下一次的读写会发生在文件开头这么多字节之后。
- seek（offset [,from]）方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。
如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置。
!/usr/bin/python
-- coding: UTF-8 --
打开一个文件
fo = open("foo.txt", "r+")
str = fo.read(10);
print "读取的字符串是 : ", str
查找当前位置
position = fo.tell();
print "当前文件位置 : ", position
把指针再次重新定位到文件开头
position = fo.seek(0, 0);
str = fo.read(10);
print "重新读取字符串 : ", str
关闭打开的文件
fo.close()
读取的字符串是 : www.runoob
当前文件位置 : 10
重新读取字符串 : www.runoob
##### 重命名和删除文件
- Python的os模块提供了帮你执行文件处理操作的方法，比如重命名和删除文件。
- rename()方法：
rename()方法需要两个参数，当前的文件名和新文件名。
os.rename(current_file_name, new_file_name)
- remove()方法
你可以用remove()方法删除文件，需要提供要删除的文件名作为参数。
os.remove(file_name)
##### Python里的目录：
- os模块有许多方法能帮你创建，删除和更改目录。
- mkdir()方法
可以使用os模块的mkdir()方法在当前目录下创建新的目录们。
os.mkdir("newdir")
- chdir()方法
可以用chdir()方法来改变当前的目录。chdir()方法需要的一个参数是你想设成当前目录的目录名称。
os.chdir("newdir")
- getcwd()方法：getcwd()方法显示当前的工作目录。
os.getcwd()
- rmdir()方法
rmdir()方法删除目录，目录名称以参数传递。
在删除这个目录之前，它的所有内容应该先被清除。
os.rmdir('dirname')
***
## Python 异常处理
- 异常处理
捕捉异常可以使用try/except语句。
try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。
- 如果你不想在异常发生时结束你的程序，只需在try里捕获它。
以下为简单的*try....except...else*的语法：
try:
<语句> #运行别的代码
except <名字>：
<语句> #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句> #如果引发了'name'异常，获得附加的数据
else:
<语句> #如果没有异常发生
!/usr/bin/python
try:
fh = open("testfile", "w")
fh.write("This is my test file for exception handling!!")
except IOError:
print "Error: can't find file or read data"
else:
print "Written content in the file successfully"
fh.close()
以上程序输出结果：
Written content in the file successfully
##### 使用except而不带任何异常类型
- 这不是一个很好的方式，我们不能通过该程序识别出具体的异常信息。因为它捕获所有的异常。
##### 使用except而带多种异常类型
##### try-finally 语句
- try-finally 语句无论是否发生异常都将执行最后的代码。
try:
<语句>
finally:
<语句> #退出try时总会执行
raise
!/usr/bin/python
try:
fh = open("testfile", "w")
try:
fh.write("This is my test file for exception handling!!")
finally:
print "Going to close the file"
fh.close()
except IOError:
print "Error: can't find file or read data"
当在try块中抛出一个异常，立即执行finally块代码。
finally块中的所有语句执行后，异常被再次提出，并执行except块代码。
##### 异常的参数
以下为单个异常的实例：
!/usr/bin/python
Define a function here.
def temp_convert(var):
try:
return int(var)
except ValueError, Argument:
print "The argument does not contain numbers\n", Argument
Call above function here.
temp_convert("xyz");
以上程序执行结果如下：
The argument does not contain numbers
invalid literal for int() with base 10: 'xyz'
##### 用户自定义异常
- 异常应该是典型的继承自Exception类，通过直接或间接的方式。
- 以下为与RuntimeError相关的实例,实例中创建了一个类，基类为RuntimeError，用于在异常触发时输出更多的信息。
- 在try语句块中，用户自定义的异常后执行except块语句，变量 e 是用于创建Networkerror类的实例。
class Networkerror(RuntimeError):
def init(self, arg):
self.args = arg
在你定义以上类后，你可以触发该异常，如下所示：
try:
raise Networkerror("Bad hostname")
except Networkerror,e:
print e.args
***
## Python 面向对象
- 在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。类的每个对象维护它自己的一份实例变量的副本。
- 类变量也叫静态变量，也就是在变量前加了static 的变量；
- 实例变量也叫对象变量，即没加static 的变量；
- 区别在于：
类变量和实例变量的区别在于：类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；而实例变量则属对象私有，某一个对象将其值改变，不影响其他对象
##### 创建类
- 使用class语句来创建一个新类，class之后为类的名称并以冒号结尾，如下实例:
class ClassName:
'类的帮助信息' #类文档字符串
class_suite #类体
类的帮助信息可以通过ClassName.__doc__查看。
- 实例
!/usr/bin/python
-- coding: UTF-8 --
class Employee:
'所有员工的基类'
empCount = 0
def init(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self):
print "Total Employee %d" % Employee.empCount
def displayEmployee(self):
print "Name : ", self.name, ", Salary: ", self.salary
empCount变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用Employee.empCount访问。
第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
##### 创建实例对象
- 要创建一个类的实例，你可以使用类的名称，并通过__init__方法接受参数。
"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)
##### 访问属性
- 您可以使用点(.)来访问对象的属性。使用如下类的名称访问类变量:
emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount
hasattr(emp1, 'age') # 如果存在 'age' 属性返回 True。
getattr(emp1, 'age') # 返回 'age' 属性的值
setattr(emp1, 'age', 8) # 添加属性 'age' 值为 8
delattr(empl, 'age') # 删除属性 'age'
##### Python内置类属性
- __dict__ : 类的属性（包含一个字典，由类的数据属性组成）
- __doc__ :类的文档字符串
- __name__: 类名
- __module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
- __bases__ : 类的所有父类构成元素（包含了以个由所有父类组成的元组）
##### python对象销毁(垃圾回收)
- 同Java语言一样，Python使用了引用计数这一简单技术来追踪内存中的对象。
在Python内部记录着所有使用中的对象各有多少引用。
- 一个内部跟踪变量，称为一个引用计数器。
- 当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的引用计数变为0 时， 它被垃圾回收。但是回收不是"立即"的， 由解释器在适当的时机，将垃圾对象占用的内存空间回收。
- 垃圾回收机制不仅针对引用计数为0的对象，同样也可以处理循环引用的情况。循环引用指的是，两个对象相互引用，但是没有其他变量引用他们。这种情况下，仅使用引用计数是不够的。Python 的垃圾收集器实际上是一个引用计数器和一个循环垃圾收集器。作为引用计数的补充， 垃圾收集器也会留心被分配的总量很大（及未通过引用计数销毁的那些）的对象。 在这种情况下， 解释器会暂停下来， 试图清理所有未引用的循环。
- 析构函数 __del__ ，__del__在对象销毁的时候被调用，当对象不再被使用时，__del__方法运行：
!/usr/bin/python
-- coding: UTF-8 --
class Point:
def init( self, x=0, y=0):
self.x = x
self.y = y
def del(self):
class_name = self.class.name
print class_name, "销毁"
pt1 = Point()
pt2 = pt1
pt3 = pt1
print id(pt1), id(pt2), id(pt3) # 打印对象的id
del pt1
del pt2
del pt3
以上实例运行结果如下：
3083401324 3083401324 3083401324
Point 销毁
## 类的继承
面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。
在python中继承中的一些特点：
1. 在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。
2. 在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
3. Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。
!/usr/bin/python
-- coding: UTF-8 --
class Parent: # 定义父类
parentAttr = 100
def init(self):
print "调用父类构造函数"
def parentMethod(self):
print '调用父类方法'
def setAttr(self, attr):
Parent.parentAttr = attr
def getAttr(self):
print "父类属性 :", Parent.parentAttr
class Child(Parent): # 定义子类
def init(self):
print "调用子类构造方法"
def childMethod(self):
print '调用子类方法 child method'
c = Child() # 实例化子类
c.childMethod() # 调用子类的方法
c.parentMethod() # 调用父类方法
c.setAttr(200) # 再次调用父类的方法
c.getAttr() # 再次调用父类的方法
以上代码执行结果如下：
调用子类构造方法
调用子类方法 child method
调用父类方法
父类属性 : 200
issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类
issubclass(sub,sup)
isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象
或者是一个Class子类的实例对象则返回true。
##### 方法重写
- 如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法：
!/usr/bin/python
-- coding: UTF-8 --
class Parent: # 定义父类
def myMethod(self):
print '调用父类方法'
class Child(Parent): # 定义子类
def myMethod(self):
print '调用子类方法'
c = Child() # 子类实例
c.myMethod() # 子类调用重写方法
##### 运算符重载
!/usr/bin/python
class Vector:
def init(self, a, b):
self.a = a
self.b = b
def str(self):
return 'Vector (%d, %d)' % (self.a, self.b)
def add(self,other):
return Vector(self.a + other.a, self.b + other.b)
v1 = Vector(2,10)
v2 = Vector(5,-2)
print v1 + v2
以上代码执行结果如下所示:
Vector(7,8)
##### 类属性与方法
1. 类的私有属性
**__private_attrs**：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时**self.__private_attrs**。
2. 类的方法
在类地内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self,且为第一个参数
3. 类的私有方法
**__private_method**：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用 **self.__private_methods**
!/usr/bin/python
-- coding: UTF-8 --
class JustCounter:
__secretCount = 0 # 私有变量
publicCount = 0 # 公开变量
def count(self):
self.__secretCount += 1
self.publicCount += 1
print self.__secretCount
counter = JustCounter()
counter.count()
counter.count()
print counter.publicCount
print counter.__secretCount # 报错，实例不能访问私有变量
.........................
print counter._JustCounter__secretCount
***
## Python正则表达式
- re.match函数
re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。
re.match(pattern, string, flags=0)
!/usr/bin/python
-- coding: UTF-8 --
import re
print(re.match('www', 'www.runoob.com').span()) # 在起始位置匹配
print(re.match('com', 'www.runoob.com')) # 不在起始位置匹配
以上实例运行输出结果为：
(0, 3)
None
- 我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
- re.search方法
re.search 扫描整个字符串并返回第一个成功的匹配。
re.search(pattern, string, flags=0)
!/usr/bin/python
import re
line = "Cats are smarter than dogs";
searchObj = re.search( r'(.) are (.?) .*', line, re.M|re.I)
if searchObj:
print "searchObj.group() : ", searchObj.group()
print "searchObj.group(1) : ", searchObj.group(1)
print "searchObj.group(2) : ", searchObj.group(2)
else:
print "Nothing found!!"
searchObj.group() : Cats are smarter than dogs
searchObj.group(1) : Cats
searchObj.group(2) : smarter
flags定义包括：
- re.I：忽略大小写
- re.L：表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
- re.M：多行模式
- re.S：' . '并且包括换行符在内的任意字符（注意：' . '不包括换行符）
- re.U： 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
- r'(.*) are (.*?) .*'
首先，这是一个字符串，前面的一个r表示字符串为非转义的原始字符串，让编译器忽略反斜杠，也就是忽略转义字符。但是这个字符串里没有反斜杠，所以这个r可有可无。
1. (.**) 第一个匹配分组，.*代表匹配除换行符之外的所有字符.从第一个字符开始，到are的a结束。不错过一个空格。
2. (.**?)第二个匹配分组，.*?后面多个问号，代表非贪婪模式，也就是说只匹配符合条件的最少字符。非贪婪模式。从s开始，到空格结束。不匹配空格。下一个如果还是非贪婪模式。则依然什么都没有。因为下一个是空格。
- 后面的一个.* 没有括号包围，所以不是分组，匹配效果和第一个一样，但是不计入匹配结果中。
matchObj.group() 等同于 matchObj.group(0)，表示匹配到的完整文本字符
matchObj.group(1) 得到第一组匹配结果，也就是(.)匹配到的
matchObj.group(2) 得到第二组匹配结果，也就是(.?)匹配到的
因为只有匹配结果中只有两组，所以填3时会报错。
- 检索和替换
re.sub(pattern, repl, string, max=0)
返回的字符串是在字符串中用 RE 最左边不重复的匹配来替换。如果模式没有发现，字符将被没有改变地返回。
可选参数 count 是模式匹配后替换的最大次数；count 必须是非负整数。缺省值是 0 表示替换所有的匹配。
!/usr/bin/python
import rephone = "2004-959-559 # This is Phone Number"
Delete Python-style comments
num = re.sub(r'#.*$', "", phone)
print "Phone Num : ", num
Remove anything other than digits
num = re.sub(r'\D', "", phone) #匹配所有非数字
print "Phone Num : ", num
Phone Num : 2004-959-559
Phone Num : 2004959559
## Python CGI编程
- 什么是CGI
CGI 目前由NCSA维护，NCSA定义CGI如下：
CGI(Common Gateway Interface),通用网关接口,它是一段程序,运行在服务器上如：HTTP服务器，提供同客户端HTML页面的接口。
