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"