Python 资源篇----参考《从Python开始学编程》

以下目前分为：文件篇、上下文管理器、pickle包、time时间篇、正则表达式篇、网络篇
文件篇
1.打开文件

f = open("hello.txt","r")#r表示读取已经存在的文件；w表示新建文件，并写入；a表示如果文件存在，那么写入到文件的结尾，如果文件不存在，则新建文件并写入。

2.读取文件内容
f文件从上次操作后的位置继续执行。例如如果一行字超过10个字节，第一次f.read(10)只读取10个字节，则下次操作f.read(10)将会紧接上一次的位置继续读取10个字节

f = open("f:/Control.txt","r")
content = f.read(10) #读取10个字节的数据
content = f.readline() #读取一行 
content = f.readlines()#读取所有行

3.写入文件

f = open("f:/Control.txt","w")
f.write("I like apple\r\n")#在Windows中，换行符“\r\n”,Unix,则为“\n”

4.关闭文件

f = open("f:/Control.txt","r")
f.close()#关闭文件

上下文管理器
上下文管理器具有自动关闭不需要文件的功能，使用with…as…结构。当语句不再缩进时，上下文管理器将会自动关闭文件。

上下文管理器基于f对象的exit()特殊方法。使用上下文管理器的语法时，Python 会在进入程序块之前调用文件对象的enter()方法，在程序块的结尾调用文件对象的exit()方法。在该方法中有self.close()语句。因此，使用上下文管理器时，就可以不用编写关闭文件语句。

#使用上下文管理器
with open("f:\Control.txt","w") as f:
     f.write("Hello World!")

print(f.closed)#若为True，则为文件处于关闭状态。

自制适用于上下文管理器的with…as…结构的类，如下：

class Vow(object):
   def __init__(self,text):
      self.text = text
   def __enter__(self):
      self.text = "I say" + self.text
      return self
   def __exit__(self,exc_type,exc_value,traceback):
      self.text = self.text + "!"

with Vow("I'm fine") as myWow:
    print(mVow.text)

print(myVow.text)

输出结果为：

I say: I’m fine
I say: I’m fine!

进一步解释该类的exit和enter方法

enter()返回一个对象，上下文管理器会使用该对象作为as 所指的变量。
exit()有四个参数。当程序块出现异常时。exc_type、exc_value、 traceback用于描述异常。如果运行正常，则三个参数都为None。

pickle包重点内容

import pickle

class Bird(object):
    have_feather = True
    reproduction_method = "egg"


summer = Bird()
pickle_string = pickle.dumps(summer)  #序列化对象

print(pickle_string)

with open("summer.pkl","wb") as f:
    f.write(pickle_string)



import pickle

class Bird(object):
    have_feather = True
    reproduction_method = "egg"

summer = Bird()
with open("summer.pkl","wb") as f:
    pickle.dump(summer,f) #序列化并保存对象

import pickle

class Bird(object):
    have_feather = True
    reproduction_method = "egg"

with open("summer.pkl","rb") as f:
    summer =  pickle.load(f) #序列化并保存对象

print(summer.have_feather)  

time时间篇

import time
print(time.time())  #挂钟时间，Unix一般从1970年1月1日0点0分0秒

#测量程序运行时间
start = time.clock()
for i in range(100000):
    j=i**2

end  = time.clock()
print(end - start) #Windows 返回的是挂钟时间，UNIX返回的是CPU时间。

print("start")
time.sleep(1) #休眠1秒
print("wake up")

st = time.gmtime()  #返回struct_time格式的UTC时间

print(st)
st = time.localtime() #返回当地时间，当地时区根据系统环境决定
print(st)
s = time.mktime(st) #将struct_time格式转换成挂钟时间
print(s)


import datetime

t = datetime.datetime(2012,9,3,21,30)
print(t)

#t对象有如下属性：hour,minute,second,millisecond,microsecond,year,month,day,weekday
#借助datetime包，进行时间间隔的运算。timedelta对象

t = datetime.datetime(2012,9,3,21,30)
t_next = datetime.datetime(2012,9,5,23,30)
delta1 = datetime.timedelta(seconds = 600)#除了seconds,weeks，还可以传递days,hours,milliseconds,microseconds
delta2 = datetime.timedelta(weeks = 3)
print(t + delta1)  #打印 2012-09-03 21:40:00
print(t + delta2)  #打印 2012-09-24 21:30:00
print(t_next - t) #打印2 days，2:00:00

print(t>t_next) #打印False

#将包含有时间信息的字符串，借助datetime包，转换成datetime类的对象。
from datetime import datetime

str = "output-1997-12-23-030000.txt"
format = "output-%Y-%m-%d-%H%M%S.txt"#如果想使用符号%，则需要写"%%"来表示
t = datetime.strptime(str,format)
print(t) #打印1997-12-23 03:00:00

#可以将datetime对象转换为特定格式的字符串，使用strftime方法
format = "%Y-%m-%d %H:%M"#除了%H（24小时制的小时）%M（分钟）%S（秒）%Y(年份)%m（月份）%d（日）
#之外，还有%A（星期几，如Sunday,Monday，%a，简写的星期几，如Sun,Mon，%I 表示小时，12小时制，%p 表示上午或下午即AM或PM，%f表示毫秒，如2、0014）
t = datetime(2012,9,5,23,30)
print(t.strftime(format))#打印 2012-09-05 23:30

下面为上述代码的运行结果：

1515573133.8462498
0.042953753706752945
start
wake up
time.struct_time(tm_year=2018, tm_mon=1, tm_mday=10, tm_hour=8, tm_min=32, tm_sec=14, tm_wday=2, tm_yday=10, tm_isdst=0)
time.struct_time(tm_year=2018, tm_mon=1, tm_mday=10, tm_hour=16, tm_min=32, tm_sec=15, tm_wday=2, tm_yday=10, tm_isdst=0)
1515573135.0
2012-09-03 21:30:00
2012-09-03 21:40:00
2012-09-24 21:30:00
2 days, 2:00:00
False
1997-12-23 03:00:00
2012-09-05 23:30

正则表达式篇
正则表达式主要是根据自己编写的模式，对字符串进行搜索或者进行其他处理。类似模糊匹配。Python的正则表达式包为：re包。

1.下面首先介绍简单的方法

#Python 使用 re包来处理正则表达式
#search 在一个字符串中搜索一个符合正则式的子串
#match方法必须从第一个字符开始检查，不符合None
#sub方法利用正则pattern在字符串string中进行搜索，并用另一个字符replacement进行替换。
#re.sub(pattern.replacement,string)
#split方法：根据正则表达式分割字符串，将分割后的所有子字符串放进一个list中返回

import re

m = re.search("[0-9]","abcd4ef56")
print(m.group(0))
print(m.group())

m = re.match("[0-9]","abcd4ef56")
#print(m.group(0)) 没有该对象，报错

str = re.sub("[0-9]","love","abcd4ef56")
print(str)

spstr = re.split("[0-9]","abcd4ef56")
print(spstr)

strall = re.findall("[0-9]","abcd4ef56")
print(strall)
"""
.            任意的一个字符
a|b          字符a或者b
[afg]        a或者f或者g的一个字符
[0-4]        0-4范围内的一个字符
[a-f]        a-f范围内的一个字符
[^m]         不是m的一个字符
\s           一个空格
\S           一个非空格
\d           一个数字，相当于[0-9] 
\D           一个非数字，相当于[^0-9]
\w           数字或字母，相当于[0-9a-zA-Z]
\W           非数字非字母，相当于[^0-9a-zA-Z]

正则表达式中还有一部分符号代表其前面的字符的重复频数
*            重复超过0次或更多次
+            重复1次或超过1次
？           重复0次或1次
{m}          重复m次。比如a{4}相当于aaaa,再比如[1-3]{2}相当于[1-3][1-3]
{m,n}        重复m到n次。比如a{2,5}表示a重复2到5次。小于2次或大于5次都不符合条件



最后有一部分关于位置的符号

^            字符串的起始位置
$            字符串的结尾位置


进一步提取，需要正则表达式的目标外面带上圆括号
用括号（）圈起来的正则表达式的一部分，成为群（group）。一个正则表达式中可以有很多群。
注意group(0)是整个正则表达的搜索结果。group(1)是第一个群，以此类推。
还可以将群命名
（？P...）为group命名

"""

m = re.search("output_(\d{4})","output_1994.txt")
print(m.group(1)) #打印1994
print(m.group(0)) #打印output_1994

m = re.search("output_(?P\d{4})","output_1994.txt")#为第一个群，命名为year
print(m.group("year")) #打印1994

运行后的结果为：

4
4
abcdloveeflovelove
[‘abcd’, ‘ef’, ”, ”]
[‘4’, ‘5’, ‘6’]
1994
output_1994
1994

网络篇

import http.client

conn = http.client.HTTPConnection("www.example.com")
conn.request("GET",'/')
response = conn.getresponse()

print(response.status,response.reason)
#status等于200表示正常，404表示无法找到，302表示重定向，reason 表示状态描述，如200的状态描述为“OK”，Content-type:分为text/plain:普通文本 text/html：HTML文本 image/jpeg:jpeg图片，image/gif:gif图片
content = response.read()
print(content)