Python基础任务5——file、os模块、datetime模块、类和对象、正则表达式、re模块

最新推荐文章于 2019-04-09 21:45:53 发布

YouYiLucifer

最新推荐文章于 2019-04-09 21:45:53 发布

阅读量258

点赞数

分类专栏： python

本文链接：https://blog.csdn.net/qq_42263613/article/details/89084956

版权

python 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1.file

a. 打开文件方式（读写两种方式）

http://www.runoob.com/python3/python3-file-methods.html
open() 方法
Python open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。

注意：使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。

完整的语法格式为：

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数说明:

file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener:

b. 文件对象的操作方法

文件对象的操作方法

c. 学习对excel及csv文件进行操作

参考1：https://www.cnblogs.com/cnkemi/p/8671493.html
参考2：https://www.cnblogs.com/zhangxinqi/p/9231801.html
参考3：https://www.cnblogs.com/imyalost/p/8893547.html

python读写excel文件
需要先用python pip命令安装xlrd , xlwt库。
xlrd官网：https://xlrd.readthedocs.io/en/latest/index.html

import xlrd, xlwt   #xlwt只能写入xls文件

# 写入xls文件
rows1 = [['Name', 'Age'],['fengju', '26'],['wuxia', '25']]
book1 = xlwt.Workbook()   # create new book1 excle
sheet1 = book1.add_sheet('user')   # create new sheet
for i in range(0, 3):    
	for j in range(0, len(rows1[i])):
		sheet1.write(i, j, rows1[i][j])
book1.save('testdata1.xls')   # sava as testdata1.xls

# 读取xlsx文件内容
rows = []   # create an empty list to store rows
book = xlrd.open_workbook('testdata.xls')  # open the Excel spreadsheet as workbook
sheet = book.sheet_by_index(0)    # get the first sheet
for user in range(1, sheet.nrows):  # iterate 1 to maxrows
	rows.append(list(sheet.row_values(user, 0, sheet.ncols)))  # iterate through the sheet and get data from rows in list
print(rows)

python读写csv文件
CSV，全称为Comma-Separated Values,它以逗号分隔值，其文件以纯文本形式存储表格数据，该文件是一个字符序列，可以由任意数目的记录组成，每条记录有字段组成，字段间分隔符是逗号或制表符，相当于结构化的纯文本形式，它比Excel文件更简洁，用来存储数据比较方便。

If csvfile is a file object, it should be opened with newline=’’. （来自python 中关于csv标准库的介绍）

csv.reader(csvfile, dialect = ‘excel’, **fmtparams)
遍历CSV文件对象并返回，csvfiel 可以是任何支持迭代器协议的对象
csv.writer(csvfile, dialect = ‘excel’, **fmtparams)
写入数据到csv文件中，csvfile可以是具有写入方法的任何对象，如果csvfiel是一个文件对象，
应该用newline = ''指定换行符（linux:\n windows:\r\n mac:\r）

import csv

iterable=[['1','zs',20,8998,20180627],['1','zs',20,8998,20180627],['1','zs',20,8998,20180627]]

with open('csvfile.csv','w',newline = '') as csvf:
    spanwriter = csv.writer(csvf,dialect = 'excel')   #创建writer对象
    spanwriter.writerow(['id','name','age','salary','date'])  #使用writer的方法writerow写入到文件
    spanwriter.writerows(iterable)  #迭代写入数据

with open('csvfile.csv','r',newline = '') as csvf:
    spamreader = csv.reader(csvf)  #创建reader对象
    for i in spamreader:
        print('\t'.join(i))   #指定分隔符，读取csv文件数据


'''
id    name    age    salary    date
1      zs     20     8998    20180627
1      zs     20     8998    20180627
1      zs     20     8998    20180627
'''

#从字典写入csv文件
dic = {'John':25, 'Mike':26}
csv_file = open('testdata1.csv', 'w', newline='')
writer = csv.writer(csv_file)
for key in dic:
	writer.writerow([key, dic[key]])
csv_file.close()   #close CSV file

csv_file1 = csv.reader(open('testdata1.csv','r'))
for user in csv_file1:
	print(user)



# Case 1: The file is read and written with newline=''.
csvfile=open('csvfile.csv','w',newline='')
writer=csv.writer(csvfile)
writer.writerow('a')
writer.writerow('b')
csvfile.close()
csvfile=open('csvfile.csv','r',newline='')
txtdata=csvfile.read()
csvfile.close()
# 最终，txtdata中的内容为'a\r\nb\r\n'。

# Case 2: The file is written with newline='', but read without it. 
csvfile=open('csvfile.csv','w',newline='')
writer=csv.writer(csvfile)
writer.writerow('a')
writer.writerow('b')
csvfile.close()
csvfile=open('csvfile.csv','r')
txtdata=csvfile.read()
csvfile.close()
#最终，txtdata中的内容为'a\nb\n'。


# Case 3: The file is written without newline='', but read with it. 
csvfile=open('csvfile.csv','w')
writer=csv.writer(csvfile)
writer.writerow('a')
writer.writerow('b')
csvfile.close()
csvfile=open('csvfile.csv','r',newline='')
txtdata=csvfile.read()
csvfile.close()
# 最终，txtdata中的内容为'a\r\r\nb\r\r\n'。


# Case 4: The file is read and written without newline=''.
csvfile=open('csvfile.csv','w')
writer=csv.writer(csvfile)
writer.writerow('a')
writer.writerow('b')
csvfile.close()
csvfile=open('csvfile.csv','r')
txtdata=csvfile.read()
csvfile.close()
# 最终，txtdata中的内容为'a\n\nb\n\n'。

csv标准库中的writerow在写入文件时会加入’\r\n’作为换行符，if newline is ‘’，换行符不会被转化而是直接输出，如case 1所示。
当写文件时newline=’’，程序写入’a\r\nb\r\n’；读取文件时newline=None，universal newlines mode工作，换行符’\r\n’被翻译为’\n’，如case 2所示。
当写文件时newline=None，csv先是将’a\r\nb\r\n’写入内存，再写入文件时，universal newlines mode工作，换行符’\n’被翻译为’\r\n’，最终结果如case 3所示。
当写文件时newline=None，csv先是将’a\r\nb\r\n’写入内存，再写入文件时，universal newlines mode工作，换行符’\n’被翻译为’\r\n’；读取文件时newline=None，universal newlines mode工作，换行符’\r’和’\r\n’被翻译为’\n’，显示为’a\n\nb\n\n’，如case 4所示。

2. os模块

参考1：https://www.cnblogs.com/sunyang945/p/7900957.html

a. 什么是os模块

os模块提供了多数操作系统的功能接口函数。当os模块被导入后，它会自适应于不同的操作系统平台，根据不同的平台进行相应的操作，在python编程时，经常和文件、目录打交道，所以离不了os模块。

b. 常用的os模块命令

http://www.runoob.com/python3/python3-os-file-methods.html

3. datetime模块

datatime模块重新封装了time模块，提供更多接口，提供的类有：date，time，datetime，timedelta，tzinfo。

a. date类

datetime.date(year, month, day)
静态方法和字段

date.max、date.min：date对象所能表示的最大、最小日期；
date.resolution：date对象表示日期的最小单位。这里是天。
date.today()：返回一个表示当前本地日期的date对象；
date.fromtimestamp(timestamp)：根据给定的时间戮，返回一个date对象；

from datetime import *

print('date.max:', date.max)
print('date.min:', date.min)
print('date.today():', date.today())
print('date.resolution：', date.resolution)
print('date.fromtimestamp():', date.fromtimestamp(time.time()))

# Output======================
# date.max: 9999-12-31
# date.min: 0001-01-01
# date.today(): 2019-04-08
# date.resolution： 1 day, 0:00:00
# date.fromtimestamp(): 2019-04-08

方法和属性

d1 = date(2019, 04, 08) #date对象
d1.year、date.month、date.day：年、月、日；
d1.replace(year, month, day)：生成一个新的日期对象，用参数指定的年，月，日代替原有对象中的属性。（原有对象仍保持不变）
d1.timetuple()：返回日期对应的time.struct_time对象；
d1.weekday()：返回weekday，如果是星期一，返回0；如果是星期2，返回1，以此类推；
d1.isoweekday()：返回weekday，如果是星期一，返回1；如果是星期2，返回2，以此类推；
d1.isocalendar()：返回格式如(year，month，day)的元组；
d1.isoformat()：返回格式如’YYYY-MM-DD’的字符串；
d1.strftime(fmt)：和time模块format相同。


from datetime import *

now = date(2010, 4, 8)
tomorrow = now.replace(day = 27)
print('now:', now, ', tomorrow:', tomorrow)
print('timetuple():', now.timetuple())
print('weekday():', now.weekday())
print('isoweekday():', now.isoweekday())
print('isocalendar():', now.isocalendar())
print('isoformat():', now.isoformat())
print('strftime():', now.strftime("%Y-%m-%d"))

# Output========================
# now: 2019-04-08 , tomorrow: 2019-04-27
# timetuple(): time.struct_time(tm_year=2019, tm_mon=4, tm_mday=8, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=99, tm_isdst=-1)
# weekday(): 0
# isoweekday(): 1
# isocalendar(): (2019, 15, 1)
# isoformat(): 2019-04-08
# strftime(): 2019-04-08

b. time类

datetime.time(hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] )
静态方法和字段

time.min、time.max：time类所能表示的最小、最大时间。其中，time.min = time(0, 0, 0, 0)， time.max = time(23, 59, 59, 999999)；
time.resolution：时间的最小单位，这里是1微秒；

方法和属性

t1 = time(10,23,15)          # time对象
t1.hour、t1.minute、t1.second、t1.microsecond：时、分、秒、微秒；
t1.tzinfo：时区信息；
t1.replace([ hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )：创建一个新的时间对象，用参数指定的时、分、秒、微秒代替原有对象中的属性（原有对象仍保持不变）；
t1.isoformat()：返回型如"HH:MM:SS"格式的字符串表示；
t1.strftime(fmt)：同time模块中的format；

from  datetime import *

tm = time(23, 46, 10)
print('tm:', tm)
print('hour: %d, minute: %d, second: %d, microsecond: %d' % (tm.hour, tm.minute, tm.second, tm.microsecond))
tm1 = tm.replace(hour=20))
print('tm1:', tm1)
print('isoformat():', tm.isoformat())
print('strftime()', tm.strftime("%X"))

# Output==============================================
# tm: 23:46:10
# hour: 23, minute: 46, second: 10, microsecond: 0
# tm1: 20:46:10
# isoformat(): 23:46:10
# strftime() 23:46:10

c. datetime类

datetime相当于date和time结合起来。
datetime.datetime (year, month, day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )

静态方法和字段

datetime.today()：返回一个表示当前本地时间的datetime对象；
datetime.now([tz])：返回一个表示当前本地时间的datetime对象，如果提供了参数tz，则获取tz参数所指时区的本地时间；
datetime.utcnow()：返回一个当前utc时间的datetime对象； # 格林威治时间
datetime.fromtimestamp(timestamp[, tz])：根据时间戮创建一个datetime对象，参数tz指定时区信息；
datetime.utcfromtimestamp(timestamp)：根据时间戮创建一个datetime对象；
datetime.combine(date, time)：根据date和time，创建一个datetime对象；
datetime.strptime(date_string, format)：将格式字符串转换为datetime对象；

方法和属性

dt=datetime.now()#datetime对象
dt.year、month、day、hour、minute、second、microsecond、tzinfo：
dt.date()：获取date对象；
dt.time()：获取time对象；
dt. replace ([ year[ , month[ , day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] ] ] ])：
dt. timetuple ()
dt. utctimetuple ()
dt. toordinal ()
dt. weekday ()
dt. isocalendar ()
dt. isoformat ([ sep] )
dt. ctime ()：返回一个日期时间的C格式字符串，等效于time.ctime(time.mktime(dt.timetuple()))；
dt. strftime (format)


from  datetime import *
import time

print   'datetime.max:', datetime.max
print   'datetime.min:', datetime.min
print   'datetime.resolution:', datetime.resolution
print   'today():', datetime.today()
print   'now():', datetime.now()
print   'utcnow():', datetime.utcnow()
print   'fromtimestamp(tmstmp):', datetime.fromtimestamp(time.time())
print   'utcfromtimestamp(tmstmp):', datetime.utcfromtimestamp(time.time())

#output======================
# datetime.max: 9999-12-31 23:59:59.999999
# datetime.min: 0001-01-01 00:00:00
# datetime.resolution: 0:00:00.000001
# today(): 2016-10-26 23:12:51.307000
# now(): 2016-10-26 23:12:51.307000
# utcnow(): 2016-10-26 15:12:51.307000
# fromtimestamp(tmstmp): 2016-10-26 23:12:51.307000
# utcfromtimestamp(tmstmp): 2016-10-26 15:12:51.307000

d. timedelta类，时间加减

使用timedelta可以很方便的在日期上做天days，小时hour，分钟，秒，毫秒，微妙的时间计算，如果要计算月份则需要另外的办法。

from  datetime import *

dt = datetime.now()
# 日期减一天
dt1 = dt + timedelta(days=-1)        # 昨天
dt2 = dt - timedelta(days=1)         # 昨天
dt3 = dt + timedelta(days=1)         # 明天
delta_obj = dt3-dt
print type(delta_obj),delta_obj        # <type 'datetime.timedelta'> 1 day, 0:00:00
print delta_obj.days ,delta_obj.total_seconds()    # 1 86400.0

e. tzinfo时区类

from datetime import datetime, tzinfo, timedelta

"""
tzinfo是关于时区信息的类
tzinfo是一个抽象类，所以不能直接被实例化
"""
class UTC(tzinfo):
    """UTC"""
    def __init__(self,offset = 0):
        self._offset = offset

    def utcoffset(self, dt):
        return timedelta(hours=self._offset)

    def tzname(self, dt):
        return "UTC +%s" % self._offset

    def dst(self, dt):
        return timedelta(hours=self._offset)

#北京时间
beijing = datetime(2011,11,11,0,0,0,tzinfo = UTC(8))
print "beijing time:",beijing
#曼谷时间
bangkok = datetime(2011,11,11,0,0,0,tzinfo = UTC(7))
print "bangkok time",bangkok
#北京时间转成曼谷时间
print "beijing-time to bangkok-time:",beijing.astimezone(UTC(7))

#计算时间差时也会考虑时区的问题
timespan = beijing - bangkok
print "时差:",timespan

#Output==================
# beijing time: 2011-11-11 00:00:00+08:00
# bangkok time 2011-11-11 00:00:00+07:00
# beijing-time to bangkok-time: 2011-11-10 23:00:00+07:00
# 时差: -1 day, 23:00:00

4. 类和对象

原文：http://www.runoob.com/python3/python3-class.html

a. 面向对象技术简介

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
方法：类中定义的函数。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
局部变量：定义在方法中的变量，只作用于当前实例的类。
实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
实例化：创建一个类的实例，类的具体对象。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。

对象可以包含任意数量和类型的数据。

b. 类定义

类定义
类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。

c. 类对象

类对象支持两种操作：属性引用和实例化。
属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。
类对象创建后，类命名空间中所有的命名都是有效属性名。

class MyClass:
    """一个简单的类实例"""
    i = 12345
    def f(self):
        return 'hello world'
 
# 实例化类
x = MyClass()
 
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)             # MyClass 类的属性 i 为： 12345
print("MyClass 类的方法 f 输出为：", x.f())       # MyClass 类的方法 f 输出为： hello world



#类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用，像下面这样：
def __init__(self):
    self.data = []

x = MyClass()       # 实例化类 MyClass，对应的 __init__() 方法就会被调用。


# 当然， __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上。
class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 输出结果：3.0 -4.5


'''self代表类的实例，而非类'''
# 类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。
class Test:
    def prt(self):
        print(self)
        print(self.__class__)
 
t = Test()
t.prt()

# <__main__.Test instance at 0x100771878>
# __main__.Test

# 从执行结果可以很明显的看出，self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。
# self 不是 python 关键字，我们把他换成 其他任意字符串也是可以正常执行的。

d. 类方法

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
        
# 实例化类
p = people('python', 10, 30)
p.speak()

# python 说: 我 10 岁。

e. 继承

Python 同样支持类的继承，如果一种语言不支持继承，类就没有什么意义。

需要注意圆括号中基类的顺序，若是基类中有相同的方法名，而在子类使用时未指定，python从左至右搜索即方法在子类中未找到时，从左到右查找基类中是否包含方法。

BaseClassName（示例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用:

class DerivedClassName(modname.BaseClassName):

class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
s = student('ken',10,60,3)
s.speak()

# ken 说: 我 10 岁了，我在读 3 年级

f. 多继承

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索即方法在子类中未找到时，从左到右查找父类中是否包含方法。

class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
 
#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法。

g. 方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法。

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

# 调用子类方法
# 调用父类方法

h. 类属性与方法

__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法
在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。

self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定是用 self。

类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用，不能在类的外部调用。self.__private_methods。

'''类的私有属性'''
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)  # 报错，实例不能访问私有变量

# 1
# 2
# 2
# Traceback (most recent call last):
#   File "test.py", line 16, in <module>
#     print (counter.__secretCount)  # 报错，实例不能访问私有变量
# AttributeError: 'JustCounter' object has no attribute '__secretCount'


'''类的私有方法'''
class Site:
    def __init__(self, name, url):
        self.name = name       # public
        self.__url = url   # private
 
    def who(self):
        print('name  : ', self.name)
        print('url : ', self.__url)
 
    def __foo(self):          # 私有方法
        print('这是私有方法')
 
    def foo(self):            # 公共方法
        print('这是公共方法')
        self.__foo()
 
x = Site('菜鸟教程', 'www.runoob.com')
x.who()        # 正常输出
x.foo()        # 正常输出
x.__foo()      # 报错

类的私有方法

类的专有方法：

init : 构造函数，在生成对象时调用
del : 析构函数，释放对象时使用
repr : 打印，转换
setitem : 按照索引赋值
getitem: 按照索引获取值
len: 获得长度
cmp: 比较运算
call: 函数调用
add: 加运算
sub: 减运算
mul: 乘运算
truediv: 除运算
mod: 求余运算
pow: 乘方

i. 运算符重载

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)

5. 正则表达式

原文：http://www.runoob.com/regexp/regexp-tutorial.html

6. re模块

原文：https://www.cnblogs.com/tina-python/p/5508402.html

正则表达式本身是一种小型的、高度专业化的编程语言，而在python中，通过内嵌集成re模块，程序媛们可以直接调用来实现正则匹配。正则表达式模式被编译成一系列的字节码，然后由用C编写的匹配引擎执行。

re模块中常用功能函数

compile()
编译正则表达式模式，返回一个对象的模式。（可以把那些常用的正则表达式编译成正则表达式对象，这样可以提高一点效率。）

格式：

re.compile(pattern, flags=0)
pattern: 编译时用的表达式字符串。

flags 编译标志位，用于修改正则表达式的匹配方式，如：是否区分大小写，多行匹配等。常用的flags有：

标志	含义
re.S(DOTALL)	使.匹配包括换行在内的所有字符
re.I（IGNORECASE）	使匹配对大小写不敏感
re.L（LOCALE）	做本地化识别（locale-aware)匹配，法语等
re.M(MULTILINE)	多行匹配，影响^和$
re.X(VERBOSE)	该标志通过给予更灵活的格式以便将正则表达式写得更易于理解
re.U	根据Unicode字符集解析字符，这个标志影响\w,\W,\b,\B

match()
决定RE是否在字符串刚开始的位置匹配。//注：这个方法并不是完全匹配。当pattern结束时若string还有剩余字符，仍然视为成功。想要完全匹配，可以在表达式末尾加上边界匹配符’$’

格式：

re.match(pattern, string, flags=0)

search()
格式：

re.search(pattern, string, flags=0)

re.search函数会在字符串内查找模式匹配,只要找到第一个匹配然后返回，如果字符串没有匹配，则返回None。

注：match和search一旦匹配成功，就是一个match object对象，而match object对象有以下方法：

group() 返回被 RE 匹配的字符串
start() 返回匹配开始的位置
end() 返回匹配结束的位置
span() 返回一个元组包含匹配 (开始,结束) 的位置
group() 返回re整体匹配的字符串，可以一次输入多个组号，对应组号匹配的字符串。
a. group（）返回re整体匹配的字符串，
b. group (n,m) 返回组号为n，m所匹配的字符串，如果组号不存在，则返回indexError异常
c.groups（）groups() 方法返回一个包含正则表达式中所有小组字符串的元组，从 1 到所含的小组号，通常groups()不需要参数，返回一个元组，元组中的元就是正则表达式中定义的组。

findall()
re.findall遍历匹配，可以获取字符串中所有匹配的字符串，返回一个列表。
格式：

re.findall(pattern, string, flags=0)

finditer()
搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。找到 RE 匹配的所有子串，并把它们作为一个迭代器返回。
格式：

re.finditer(pattern, string, flags=0)

split()
按照能够匹配的子串将string分割后返回列表。
可以使用re.split来分割字符串，如：re.split(r’\s+’, text)；将字符串按空格分割成一个单词列表。
格式：

re.split(pattern, string[, maxsplit])
maxsplit用于指定最大分割次数，不指定将全部分割。

sub()
使用re替换string中每一个匹配的子串后返回替换后的字符串。
格式：

re.sub(pattern, repl, string, count)
re.sub还允许使用函数对匹配项的替换进行复杂的处理。
如：re.sub(r’\s’, lambda m: ‘[’ + m.group(0) + ‘]’, text, 0)；将字符串中的空格’ ‘替换为’[ ]’。

subn()
返回替换次数
格式：

subn(pattern, repl, string, count=0, flags=0)

7. http请求

http://www.runoob.com/http/http-tutorial.html

HTTP协议是Hyper Text Transfer Protocol（超文本传输协议）的缩写,是用于从万维网（WWW:World Wide Web ）服务器传输超文本到本地浏览器的传送协议。

HTTP是一个基于TCP/IP通信协议来传递数据（HTML 文件, 图片文件, 查询结果等）。

HTTP协议工作于客户端-服务端架构上。浏览器作为HTTP客户端通过URL向HTTP服务端即WEB服务器发送所有请求。

Web服务器有：Apache服务器，IIS服务器（Internet Information Services）等。

Web服务器根据接收到的请求后，向客户端发送响应信息。

HTTP默认端口号为80，但是你也可以改为8080或者其他端口。

HTTP三点注意事项：

HTTP是无连接：无连接的含义是限制每次连接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开连接。采用这种方式可以节省传输时间。
HTTP是媒体独立的：这意味着，只要客户端和服务器知道如何处理的数据内容，任何类型的数据都可以通过HTTP发送。客户端以及服务器指定使用适合的MIME-type内容类型。
HTTP是无状态：HTTP协议是无状态协议。无状态是指协议对于事务处理没有记忆能力。缺少状态意味着如果后续处理需要前面的信息，则它必须重传，这样可能导致每次连接传送的数据量增大。另一方面，在服务器不需要先前信息时它的应答就较快。

HTTP 消息结构
HTTP 方法
HTTP 协议的 8 种请求类型介绍
HTTP 协议中共定义了八种方法或者叫“动作”来表明对 Request-URI 指定的资源的不同操作方式，具体介绍如下：

OPTIONS：返回服务器针对特定资源所支持的HTTP请求方法。也可以利用向Web服务器发送’*'的请求来测试服务器的功能性。
HEAD：向服务器索要与GET请求相一致的响应，只不过响应体将不会被返回。这一方法可以在不必传输整个响应内容的情况下，就可以获取包含在响应消息头中的元信息。
GET：向特定的资源发出请求。
POST：向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中。POST请求可能会导致新的资源的创建和/或已有资源的修改。
PUT：向指定资源位置上传其最新内容。
DELETE：请求服务器删除 Request-URI 所标识的资源。
TRACE：回显服务器收到的请求，主要用于测试或诊断。
CONNECT：HTTP/1.1 协议中预留给能够将连接改为管道方式的代理服务器。

虽然 HTTP 的请求方式有 8 种，但是我们在实际应用中常用的也就是 get 和 post，其他请求方式也都可以通过这两种方式间接的来实现。

HTTP 响应头信息
HTTP请求头提供了关于请求，响应或者其他的发送实体的信息。
HTTP 状态码
当浏览者访问一个网页时，浏览者的浏览器会向网页所在服务器发出请求。当浏览器接收并显示网页前，此网页所在的服务器会返回一个包含HTTP状态码的信息头（server header）用以响应浏览器的请求。
HTTP状态码的英文为HTTP Status Code。
下面是常见的HTTP状态码：

详细内容：http://www.runoob.com/http/http-status-codes.html

YouYiLucifer

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python基础任务5——file、os模块、datetime模块、类和对象、正则表达式、re模块

1.filea.打开文件方式（读写两种方式）b.文件对象的操作方法c.学习对excel及csv文件进行操作2.os模块3.datetime模块4.类和对象5.正则表达式6.re模块7.http请求...
复制链接

扫一扫