Python初步学习（2）

1. Python的时间和日期

每个时间戳都是从1970.01.01算起的，Python内也有时间和日期的操作函数，最常见的有 time 库和 calendar 库；下面让我们看以下这两个库的使用；

import time；

basic_time = time.time(); # 获取距1970.01.01的时间以整型表示
localtime = time.localtime(time.time);#获取当前时间，其格式为年-月-日 时-分-秒
asctime = time.asctime(localtime);#获取格式化的时间，其格式为 星期 月 日  时：分：秒  年

print basic_time；

print localtime;

print asctime;

除了 time 获取基本的时间外，我们还可以通过 calendar 库，查看指定日期的日历信息，如下所示：

import calendar；

days = calendar.month(year,month); # 其中 year 和 month 是我们指定的参数；
print days；

以上只是 time 和 calendar 库的基本用法，想要了解更多的话，可以查阅其相应的函数手册：http://www.runoob.com/python/python-date-time.html

2. Python文件读写

和 C 语言一样，采用 open（）函数打开文件获得句柄，采用write（）函数写入文件，采用 close（）函数关闭文件句柄；其中涉及到的打开文件的方式和 C 语言也一样，这些不再多说，下面说一点其特有的函数 read（）、readLine（）、readall（）、seek（）和 tell（）等函数，这里的 read（n）会读出文件的前 n 个字节，如果遇到换行，则将换行符也读进去，和 C 中一行代表1024个字节不一样，另外其中的seek（offset，from）函数 offset 指的是偏移量向后，而
from 如果为 0 代表偏移的相对地址为文件的开头，如果为 1 ，则表示为当前位置；如果为 2 则表示文件的结尾。tell（）函数则返回当前文件的指针位置。例如：

opFileWrite = open('filename','ab+'); # 以二进制追加的方式向 filename 打开所指向的文件；
opFileWrite.write(text); #向文件内写入 text 所指向的数据
opFileWrite.close();# 关闭所打开的文件
opFileRead = open('filename','r');#以读的方式打开 filename 所指向的文件
print opFileRead.read(n);#读取文件的前 n 个字节
print opFileRead.tell();# 获取当前文件指针的位置
print opFileRead.seek(m,1);# 将文件指针从当前位置向前移动 m 个字节
print opFileRead.readLine();# 读取一行数据
opFileRead.close();#关闭文件

上面涉及到的文件操作主要是针对于文件内容的，我们还可以通过 rename（target，destion）将文件 target 重命名为 destion 或者通过 remove（）函数将文件删除。以上所涉及的都是对文件的操作，却没有谈及对目录的操作，在 Python 中还有几个对目录的操作函数。例如打印当前目录的 getcwd（）函数，创建目录的 mkdir（）函数，删除目录的rmdir（）函数，改变当前目录的 chdir（）函数等（这是需要引入 os 库）。例如：

import os；

os.rename(filename01,filename02); # 将文件filename01重命名为filename02
os.remove(filename02);#将filename02删除
os.mkdir(dir);#创建目录 dir
print os.getcwd();# 打印当前目录
os.chdir(dirs);#修改当前目录为 dirs
print os.getcwd();#打印当前目录
os.rmdir(dirs);#删除目录 dirs

3. Python正则表达式

Python中引入了 re 库，利用其 match（）方法、search（）方法、substring（）方法进行字符串的匹配、搜索和替换。至于正则表达式的单个字符的匹配、数字和字母的匹配等规则，不再多说，如下所示：

import re；

module = r'([0-9]*)@([a-z]*)/.([a-z]*)';#定义正则表达式的匹配模式
test = "1993138787@qq.com";#用于测试的字符串
matchObj = re.match(module,text);#match（）函数进行正则表达式的匹配
searchObj = re.serach("com",test,0);#search（）函数用于搜索指定字符串的第一个位置
subObj = re.sub("@","+",test);#对 test 字符串中指定的字符串进行替换
print matchObj.group(1);#每一个（）是一个元组，一次打印匹配的每一个元组
print matchObj.group(2);#
print matchObj.group(3);#
print searchObj;#
print subObj;#

4. Python面向对象

第一，面向对象的封装性、继承性和多态性不再多说。这里要说类的定义方法 class className (ParentName): 其中 class 是关键字，className 是创建的类的名称；而类的继承需要用（）对其父类进行包裹，若有多个父类，以逗号的形式在括号内隔离，ParentName即父类的名称。

第二，需要重写__init__(self)这个函数，即每一个类的构造函数；

第三，类中的每一个方法都需要添加 self 这个参数，其实就相当于 java 和 js 等语言中的 this 关键字；

第四，创建实例对象的时候不需要用 new 关键字，直接使用 className（arg1，args，...）就可以；

第五，可以通过 setattr（key，value）的方式设置类的属性，也可以通过 hasattr（key）的方式判断是否有某个属性，还可以通过getattr（key，value）对特定的属性进行赋值，最后还可以通过 delattr（key）删除类的属性；

第六，可以通过 __Name 也就是 __ 加变量名称的方式定义私有变量；

第七，私有变量只能在类内访问，实例化的类不能访问私有变量，但是可以通过 object._className__attrName 的方式访问属性；

第八，Python 内有私有一些内置类的属性，例如：“__name__” 表示类的名称；"__doc__" 指的是类的文档描述； ”__dict__“ 指的是类的属性；”__module__“ 表示的是类的模块；”__bases__“ 指的是类的父类；

class Parent:        # 定义父类
parentAttr = 100

__selfname = 1;
def __init__(self):
print "调用父类构造函数"
def parentMethod(self):
print '调用父类方法'
def setAttr(self, attr):
Parent.parentAttr = attr
def getAttr(self):
print "父类属性 :", Parent.parentAttr
class Child(Parent): # 定义子类
__selfNames = 2; 

def __init__(self):
print "调用子类构造方法"
def childMethod(self):
print '调用子类方法 child method'
c = Child()          # 实例化子类
c.childMethod()      # 调用子类的方法
c.parentMethod()     # 调用父类方法
c.setAttr(200)       # 再次调用父类的方法
c.getAttr()          # 再次调用父类的方法

print c._Parent__selfname;

5. Python多线程

多线程的好处在于内存共享、开销小、并发性；我们可以利用多线程来处理一些 IO 或者其他阻塞事件，也可以将那些占据长时间的程序放到后台去执行。

第一，在 Python 中主要通过 threading 库进行线程的设置。我们自定义一个线程的时候我们需要继承 thriding,Thread 类，在初始函数中加载 threading.Thread__init__(self)；另外我们往往重run（）方法，当一个类被加载的时候，会自动执行这个方法。

第二，我们需要调用实例化的 Thread 对象的 start（）方法，开启一个线程；

下面我们来看一个实例，如下所示：

import threading
import time

exitFlag = 0
class myThread (threading.Thread):   #继承父类threading.Thread
def __init__(self, threadID, name, counter):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter
def run(self):                   #把要执行的代码写到run函数里面 线程在创建后会直接运行run函数
print "Starting " + self.name
print_time(self.name, self.counter, 5)
print "Exiting " + self.name
def print_time(threadName, delay, counter):
while counter:
if exitFlag:
thread.exit()
time.sleep(delay)
print "%s: %s" % (threadName, time.ctime(time.time()))
counter -= 1
# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)
# 开启线程
thread1.start()
thread2.start()
print "Exiting Main Thread"

但是多线程也会带来一系列的问题，那就是内存共享的问题，这很可能引发死锁现象。因此我们常常需要让线程同步。

第一，我们需要获得 threading.Lock（）的引用实例，然后调用这个实例的 acquire（） 方法对共享区域进行锁定，通过 release（）方法对其进行释放。

第二，我们需要将阻塞的线程加入线程等待队列；

如下所示：

import threading
import time

class myThread (threading.Thread):
def __init__(self, threadID, name, counter):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter
def run(self):
print "Starting " + self.name
# 获得锁，成功获得锁定后返回True
# 可选的timeout参数不填时将一直阻塞直到获得锁定
# 否则超时后将返回False
threadLock.acquire()
print_time(self.name, self.counter, 3)
# 释放锁
threadLock.release()
def print_time(threadName, delay, counter):
while counter:
time.sleep(delay)
print "%s: %s" % (threadName, time.ctime(time.time()))
counter -= 1
threadLock = threading.Lock()
threads = []
# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)
# 开启新线程
thread1.start()
thread2.start()
# 添加线程到线程列表
threads.append(thread1)
threads.append(thread2)
# 等待所有线程完成
for t in threads:
t.join()
print "Exiting Main Thread"