Day 5

最新推荐文章于 2022-04-21 10:49:06 发布

努力！才能被爱慕~

最新推荐文章于 2022-04-21 10:49:06 发布

阅读量404

点赞数 1

分类专栏： Python学习

本文链接：https://blog.csdn.net/weixin_43604754/article/details/88319391

版权

Python学习专栏收录该内容

16 篇文章 0 订阅

订阅专栏

1.file

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

b.文件对象的操作方法

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

2.os模块

3.datetime模块

4.类和对象

5.正则表达式

6.re模块

7.http请求

==============================================================

1.file

open()方法
Python open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。

注意： 使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。
open()函数常用形式是接收两个参数：文件名(file)和模式(mode)。

语法：

open(file, mode='r')

完整的语法格式为：

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:

mode 参数有：

默认为文本模式，如果要以二进制模式打开，加上 b 。

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

1.读文件的模式打开一个文件对象，使用Python内置的open()函数，传入文件名和标示符；

2.标示符’r’表示读，如果文件不存在，open()函数就会抛出一个IOError的错误，并且给出错误码和详细的信息告诉你文件不存在；

3.文件打开成功，接下来，调用read()方法可以一次读取文件的全部内容，Python把内容读到内存，用一个str对象表示；

最后一步是调用close()方法关闭文件。文件使用完毕后必须关闭，因为文件对象会占用操作系统的资源，并且操作系统同一时间能打开的文件数量也是有限的；

注：由于文件读写时都有可能产生IOError，一旦出错，后面的f.close()就不会调用。所以，为了保证无论是否出错都能正确地关闭文件，使用try … finally来实现。
标准格式：

太过繁琐，Python引入了with语句来自动调用close()方法：

with open(r'/path/to/file', 'r') as f:      #/会被转义，加r
     print(f.read())

python文件对象提供了三个“读”方法： read()、readline() 和 readlines()。每种方法可以接受一个变量以限制每次读取的数据量。

read() 每次读取整个文件，它通常用于将文件内容放到一个字符串变量中。如果文件大于可用内存，为了保险起见，可以反复调用read(size)方法，每次最多读取size个字节的内容。

readlines()之间的差异是后者一次读取整个文件，象.read() 一样。.readlines() 自动将文件内容分析成一个行的列表，该列表可以由 Python 的 for … in … 结构进行处理。

readline()每次只读取一行，通常比readlines()慢得多。仅当没有足够内存可以一次读取整个文件时，才应该使用readline()。
注意：这三种方法是把每行末尾的’\n’也读进来了，它并不会默认的把’\n’去掉，需要我们手动去掉。

去掉‘\n ’

Python读写例题：

   两个文件，每个都有很多行ip地址，求两个文件中相同的ip地址：

要点：（1）用with （2）处理行末的’\n’ （3）使用二分查找提高算法效率。（4）使用set快速去重。

1.写文件： 写文件和读文件是一样的，唯一区别是调open()函数时，传入标识符’w’或者’wb’表示写文本文件或写二进制文件：

语法：

       f = open(filename, mode,buffering)  #buffering寄存，具体自行搜索

注：如果没有这个文件，就创建一个；如果有，那么就会先把原文件的内容清空再写入新的东西。

注：写完不能读出来

注：原内容后追加。

=========================
标准格式：可以反复调用write()来写入文件，但是务必要调用f.close()来关闭文件。当写文件时，操作系统往往不会立刻把数据写入磁盘，而是放到内存缓存起来，空闲的时候再慢慢写入。只有调用close()方法时，操作系统才保证把没有写入的数据全部写入磁盘。忘记调用close()的后果是数据可能只写了一部分到磁盘，剩下的丢失了。所以，还是用with语句来得保险：

===========================

等同于：

python文件对象提供了两个“写”方法： write() 和 writelines()。

write()方法和read()、readline()方法对应，是将字符串写入到文件中。

writelines()方法和readlines()方法对应，也是针对列表的操作。它接收一个字符串列表作为参数，将他们写入到文件中，换行符不会自动的加入，因此，需要显式的加入换行符。

b.文件对象的操作方法

file对象

file对象使用 open 函数来创建，下表列出了 file 对象常用的函数：

1.file.close()
关闭文件。关闭后文件不能再进行读写操作。
2 file.flush()
刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
3 file.fileno()
返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。

4 file.isatty()
如果文件连接到一个终端设备返回 True，否则返回 False。

5 file.next()
返回文件下一行。

6 file.read([size])
从文件读取指定的字节数，如果未给定或为负则读取所有。

7 file.readline([size])
读取整行，包括 “\n” 字符。

8 file.readlines([sizeint])
读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。

9 file.seek(offset[, whence])
设置文件当前位置

10 file.tell()
返回文件当前位置。

11 file.truncate([size])
从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 Widnows 系统下的换行代表2个字符大小。

12file.write(str)
将字符串写入文件，返回的是写入的字符长度。

13 file.writelines(sequence)
向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

file_obj.seek(offset,whence=0)
file_obj.seek(offset,whence=0)方法用来在文件中移动文件指针。offset表示偏移多少。可选参数whence表示从哪里开始偏移，默认是0为文件开头，1为当前位置，2为文件尾部。

注意： 这个文件指针的改变只是作用于’r’,对’w’和’a’不会起作用，如果是’w’，那么write()永远都是从开头写（会覆盖后面对应位置的内容），是’a’的话write()就永远都是从最后开始追加。Whence不等于0的没法使用。

字符编码

要读取非UTF-8编码的文本文件，需要给open()函数传入encoding参数，例如，读取GBK编码的文件：

f =open('test.txt', 'r', encoding='gbk')

遇到有些编码不规范的文件，你可能会遇到UnicodeDecodeError，因为在文本文件中可能夹杂了一些非法编码的字符。遇到这种情况，open()函数还接收一个errors参数，表示如果遇到编码错误后如何处理。最简单的方式是直接忽略：

f =open('test.txt', 'r', encoding='gbk', errors='ignore')

pickle 模块

python的pickle模块实现了基本的数据序列和反序列化。

通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。

通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。

基本接口：

pickle.dump(obj, file, [,protocol])

JSON模块

   数据序列化

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

   读取csv

方法：

1.使用csv函数包，安装 pip install csv；
使用xlrd函数包，安装：pip install xlrd

======================================

import csv
def   fileload(filename = '待读取.csv'):
	 csvfile = open(filename, encoding ='utf-8')
	 data = csv.reader(csvfile)
	 dataset = []
	 for line in data:
    		dataset.append(line)
	 csvfile.close()
	 return dataset

=======================================

import xlrd

def fileload(filename = '待读取.xlsx'):

	dataset = []

 	workbook = xlrd.open_workbook(filename)

	table = workbook.sheets()[0]

 	for row in range(table.nrows):
    		dataset.append(table.row_values(row))
	 return dataset

=========================================

未成功

2.os模块

OS 模块提供了非常丰富的方法用来处理文件和目录

OS模块简单的来说它是一个Python的系统编程的操作模块，可以处理文件和目录这些我们日常手动需要做的操作。

可以查看OS模块的帮助文档：

import os  #导入os模块 

help(os)   #查看os模块帮助文档，里面详细的模块相关函数和使用方法

import os,sys
print(sys.path) #获取python的环境变量,以list形式返回
#输出：[‘E:\study\Automantic\jxz-code\Course4’]

print(os.listdir(’./’)) #获取指定目录下的文件及文件夹名称，以list形式返回

#输出：[‘access.log’, ‘b.txt’, ‘c.txt’, ‘course4作业.py’,
‘goods.txt’, ‘user_info.txt’, ‘、’, ‘函数.py’]

print(os.getcwd()) #获取当前目录

#输出：E:\study\Automantic\jxz-code\Course4

#print(os.chdir(‘E:\study\Automantic\jxz-code’)) #更换当前目录

print(os.rename(‘c.txt’,‘a.txt’))#修改文件名称

print(os.mkdir(‘新目录’))#创建文件夹

print(os.rmdir(‘新目录’))#删除文件夹（只能删除空文件夹）

print(os.makedirs(‘E:\xixi\haha’))#依次创建目录

print(os.removedirs(‘E:\xixi\haha’))#依次删除非空目录

print(os.sep)#获取当前操作系统的路径分隔符

#输出：**print(os.environ)**#获取当前操作系统的环境变量

#输出：environ({‘ALLUSERSPROFILE’: ‘C:\ProgramData’})

print(os.pathsep)#获取当前系统的环境变量中每个路径的分隔符，linux是:，windows是;

#输出：;

print(os.path.abspath(file))#获取当前文件的绝对路径

#输出：E:\study\Automantic\jxz-code\Course4\函数.py

print(os.path.dirname(os.path.abspath(file)))#获取指定路径的父目录

#输出：E:\study\Automantic\jxz-code\Course4

print(os.path.isdir(os.path.abspath(file)))#判断指定路径是不是一个文件夹

#输出：False

print(os.path.isfile(os.path.abspath(file)))#判断指定路径是不是一个文件

#输出：True

print(os.path.join(‘一级’,‘二级’,‘三级’,‘haha.txt’))#将内容以当前操作系统的路径分隔符拼接成一个路径

#输出：一级\二级\三级\haha.txt

print(os.path.split(‘E:\study\Automantic\jxz-code\Course4\函数 .py’))#分割路径和文件名

#输出：(‘E:\study\Automantic\jxz-code\Course4’, ‘函数 .py’)

print(os.path.exists(‘E:\study\Automantic\jxz-code\Course4\函数 .py’))#判断目录或文件是否存在

#输出：True

os模块主要处理操作系统的相关的功能

os .name 获取操作系统平台

os.getcwd() 获取现在的工作目录

os.listdir() 获取某个目录下的所有文件名

os.system() 用来运行shell命令

os.remove() 删除某个文件

os.path.existe() 检验给出的路径是否真地存在

os.path.isfile() 判断是否为文件;若是，返回值为真

os.path.isdir() 判断是否为文件夹;若是，返回值为真

os.path.abspath(name) 获得绝对路径

os.path.splitext() 分离文件名与扩展名

os.path.split() 把一个路径拆分为目录+文件名的形式

os.path.join(path,name) 连接目录与文件名或目录

os.path.basename(path) 返回文件名

os.path.dirname(path) 返回文件路径

操作系统相关调用和操作：

os.environ 一个dictionary
包含环境变量的映射关系

os.environ[“HOME”] 可以得到环境变量HOME的值
os.chdir(dir) 改变当前目录
os.chdir(‘d:\outlook’) 注意windows下用到转义
os.getcwd() 得到当前目录
os.getegid() 得到有效组
id os.getgid() 得到组id
os.getuid() 得到用户id
os.geteuid() 得到有效用户id
os.setegid 设置id
os.getgruops() 得到用户组名称列表
os.getlogin() 得到用户登录名称
os.getenv 得到环境变量
os.putenv 设置环境变量
os.umask 设置umask
os.system(cmd) 利用系统调用，运行cmd命令

3.datetime模块

Python datetime模块比calendar，time，datetime。time模块等的接口则更直观、更容易调用。它提供的接口与C标准库time.h基本一致。
datetime模块定义了下面这几个类：

datetime.date：表示日期的类。常用的属性有year,month, day；
datetime.time：表示时间的类。常用的属性有hour,
minute, second, microsecond；datetime.datetime：表示日期时间。
datetime.timedelta：表示时间间隔，即两个时间点之间的长度。
datetime.tzinfo：与时区有关的相关信息。（参考python手册）
注：上面这些类型的对象都是不可变（immutable）的。

====================================================

1、date类

datetime.date(year,month, day)

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

方法和属性：

   1.d1 = date(2011,06,03)#date对象

2.d1.year、date.month、date.day：年、月、日；

3.d1.replace(year, month, day)：生成一个新的日期对象，用参数指定的年，月，日代替原有对象中的属性。（原有对象仍保持不变）

4.d1.timetuple()：返回日期对应的time.struct_time对象；

5.d1.weekday()：返回weekday，如果是星期一，返回0；如果是星期2，返回1，以此类推；

6.d1.isoweekday()：返回weekday，如果是星期一，返回1；如果是星期2，返回2，以此类推；

7.d1.isocalendar()：返回格式如(year，month，day)的元组；

8.d1.isoformat()：返回格式如'YYYY-MM-DD’的字符串；

9.d1.strftime(fmt)：和time模块format相同。

2、time类

datetime.time(hour[, minute[ , second[ , microsecond[ , tzinfo] ] ] ] )

静态方法和字段

   1.time.min、time.max：time类所能表示的最小、最大时间。其中，time.min = time(0, 0,0, 0)， time.max = time(23, 59, 59, 999999)；

  2.time.resolution：时间的最小单位，这里是1微秒；

方法和属性

1.t1 = datetime.time(10,23,15)#time对象

2.t1.hour、t1.minute、t1.second、t1.microsecond：时、分、秒、微秒；

3.t1.tzinfo：时区信息；

4.t1.replace([ hour[ , minute[ , second[ ,microsecond[ , tzinfo] ] ] ] ] )：创建一个新的时间对象，用参数指定的时、分、秒、微秒代替原有对象中的属性（原有对象仍保持不变）；

5.t1.isoformat()：返回型如"HH:MM:SS"格式的字符串表示；

6.t1.strftime(fmt)：同time模块中的format；

3、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)

4.timedelta类，时间加减

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

#coding:utf-8

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()#186400.0

5、tzinfo时区类

#!/usr/bin/python
#coding=utf-8
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.类和对象

面向对象技术简介

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

方法： 类中定义的函数。

类变量： 类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

数据成员： 类变量或者实例变量用于处理类及其实例对象的相关的数据。

方法重写： 如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

局部变量： 定义在方法中的变量，只作用于当前实例的类。

实例变量： 在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。

继承： 即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。

实例化： 创建一个类的实例，类的具体对象。

对象： 通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。
Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。
对象可以包含任意数量和类型的数据

类定义

语法格式如下：

   class ClassName:

       <statement-1>

       .

       .

         .

        <statement-N>

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

类对象

类对象支持两种操作：属性引用和实例化。
属性引用使用和 Python 中所有的属性引用一样的标准语法：

       obj .name。

类对象创建后，类命名空间中所有的命名都是有效属性名。所以如果类定义是这样:

类有一个名为 init() 的特殊方法（构造方法），该方法在类实例化时会自动调用.

======================================

5.正则表达式

Python3 正则表达式
正则表达式(Regular Expression)是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。

正则表达式使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。

正则表达式是繁琐的，但它是强大的，学会之后的应用会让你除了提高效率外，会给你带来绝对的成就感。只要认真阅读本教程，加上应用的时候进行一定的参考，掌握正则表达式不是问题。

许多程序设计语言都支持利用正则表达式进行字符串操作。

? 通配符匹配文件名中的 0 个或 1 个字符，而 * 通配符匹配零个或多个字符。

1.data(\w)?.dat 这样的模式将查找下列文件：

          data.dat| data1.dat| data2.dat| datax.dat| dataN.dat

使用 * 字符代替 ? 字符扩大了找到的文件的数量。data.*.dat 匹配下列所有文件：
```
       data.dat| data1.dat| data2.dat| data12.dat| datax.dat| dataXYZ.dat
```

1.^为匹配输入字符串的开始位置；
2.[0-9]+匹配多个数字， [0-9] 匹配单个数字，+ 匹配一个或者多个；
3.abc $匹配字母 a b c 并以 a b c 结尾，$ 为匹配输入字符串的结束位置；

在写用户注册表单时，只允许用户名包含字符、数字、下划线和连接字符(-)，并设置用户名的长度，我们就可以使用以下正则表达式来设定。

以上的正则表达式可以匹配 runoob、runoob1、run-oob、run_oob，但不匹配 ru，因为它包含了小写的字母而且太短了，也不匹配 runoob$, 因为它包含特殊字符。

正则表达式的优点：

典型的搜索和替换操作要求提供与预期的搜索结果匹配的确切文本。这种技术对于对静态文本执行简单搜索和替换任务缺乏灵活性，若采用这种方法搜索动态文本，很困难。

通过使用正则表达式，可以：

   1.测试字符串内的模式。

例如，可以测试输入字符串，以查看字符串内是否出现电话号码模式或信用卡号码模式。这称为数据验证。

2.替换文本。

可以使用正则表达式来识别文档中的特定文本，完全删除该文本或者用其他文本替换它。

3.基于模式匹配从字符串中提取子字符串。

可以查找文档内或输入域内特定的文本。

注：搜索整个网站，删除过时的材料，替换某些 HTML 格式标记。在这种情况下，可以使用正则表达式来确定在每个文件中是否出现该材料或该HTML格式标记。此过程将受影响的文件列表缩小到包含需要删除或更改的材料的那些文件。然后可以使用正则表达式来删除过时的材料；也可以使用正则表达式来搜索和替换标记。

正则表达式 - 语法

正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。

Eg：

1.runoo+b，可以匹配 runoob、runooob、runoooooob 等，+ 号代表前面的字符必须至少出现一次（1次或多次）。 

2.runoo*b，可以匹配 runob、runoob、runoooooob 等，*号代表字符可以不出现，也可以出现一次或者多次（0次、或1次、或多次）。

3.colou?r 可以匹配 color 或者 colour，? 问号代表前面的字符最多只可以出现一次（0次、或1次）。

构造正则表达式的方法和创建数学表达式的方法一样。也就是用多种元字符与运算符可以将小的表达式结合在一起来创建更大的表达式。正则表达式的组件可以是单个的字符、字符集合、字符范围、字符间的选择或者所有这些组件的任意组合。
正则表达式是由普通字符（例如字符a 到 z）以及特殊字符（称为"元字符"）组成的文字模式。模式描述在搜索文本时要匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。

=============================================

普通字符

普通字符包括没有显式指定为元字符的所有可打印和不可打印字符。这包括所有大写和小写字母、所有数字、所有标点符号和一些其他符号。

非打印字符

非打印字符也可以是正则表达式的组成部分。下表列出了表示非打印字符的转义序列：

特殊字符

所谓特殊字符，就是一些有特殊含义的字符，如上面说的 runoo*b 中的 ，简单的说就是表示任何字符串的意思。如果要查找字符串中的 * 符号，则需要对 * 进行转义，即在其前加一个 : runo*ob 匹配 runoob。

许多元字符要求在试图匹配它们时特别对待。若要匹配这些特殊字符，必须首先使字符"转义"，即，将反斜杠字符\ 放在它们前面。下表列出了正则表达式中的特殊字符：

限定符

限定符用来指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。有 * 或 + 或 ? 或 {n} 或 {n,} 或 {n,m} 共6种。

正则表达式的限定符有：

由于章节编号在大的输入文档中会很可能超过九，所以需要一种方式来处理两位或三位章节编号。限定符的正则表达式匹配编号为任何位数的章节标题：

/Chapter[1-9][0-9]*/

请注意，限定符出现在范围表达式之后。因此，它应用于整个范围表达式，在本例中，只指定从 0 到 9 的数字（包括 0 和 9）。

这里不使用 + 限定符，因为在第二个位置或后面的位置不一定需要有一个数字。也不使用 ? 字符，因为使用 ? 会将章节编号限制到只有两位数。您需要至少匹配 Chapter 和空格字符后面的一个数字。

如果您知道章节编号被限制为只有 99 章，可以使用下面的表达式来至少指定一位但至多两位数字。

          /Chapter [0-9]{1,2}/

上面的表达式的缺点是，大于 99 的章节编号仍只匹配开头两位数字。另一个缺点是 Chapter 0 也将匹配。只匹配两位数字的更好的表达式如下：

          /Chapter [1-9][0-9]?/

或

          /Chapter[1-9][0-9]{0,1}/

*、+限定符都是贪婪的，因为它们会尽可能多的匹配文字，只有在它们的后面加上一个?就可以实现非贪婪或最小匹配。

例如，搜索 HTML 文档，以查找括在 H1 标记内的章节标题。该文本在您的文档中如下：

   <H1>Chapter 1 - 介绍正则表达式</H1>

贪婪：下面的表达式匹配从开始小于符号 (<) 到关闭 H1 标记的大于符号 (>) 之间的所有内容

          /<.*>/

非贪婪：如果您只需要匹配开始和结束 H1 标签，下面的非贪婪表达式只匹配

          /<.*?>/

如果只想匹配开始的 H1 标签，表达式则是：

          /<\w+?>/

通过在 *、+ 或 ? 限定符之后放置 ?，该表达式从"贪心"表达式转换为"非贪心"表达式或者最小匹配。

==============================

定位符

定位符使您能够将正则表达式固定到行首或行尾。它们还使您能够创建这样的正则表达式，这些正则表达式出现在一个单词内、在一个单词的开头或者一个单词的结尾。

定位符用来描述字符串或单词的边界，^ 和 $ 分别指字符串的开始与结束，\b描述单词的前或后边界，\B 表示非单词边界。

正则表达式的定位符有：

注意： 不能将限定符与定位符一起使用。由于在紧靠换行或者单词边界的前面或后面不能有一个以上位置，因此不允许诸如 ^* 之类的表达式。

若要匹配一行文本开始处的文本，请在正则表达式的开始使用 ^ 字符。不要将 ^ 的这种用法与中括号表达式内的用法混淆。

若要匹配一行文本的结束处的文本，请在正则表达式的结束处使用 $ 字符。

若要在搜索章节标题时使用定位点，下面的正则表达式匹配一个章节标题，该标题只包含两个尾随数字，并且出现在行首：

          /^Chapter [1-9][0-9]{0,1}/

真正的章节标题不仅出现行的开始处，而且它还是该行中仅有的文本。它即出现在行首又出现在同一行的结尾。下面的表达式能确保指定的匹配只匹配章节而不匹配交叉引用。通过创建只匹配一行文本的开始和结尾的正则表达式，就可做到这一点。

/^Chapter[1-9][0-9]{0,1}$/

匹配单词边界稍有不同，但向正则表达式添加了很重要的能力。单词边界是单词和空格之间的位置。非单词边界是任何其他位置。下面的表达式匹配单词 Chapter 的开头三个字符，因为这三个字符出现在单词边界后面：

/\bCha/

\b 字符的位置是非常重要的。如果它位于要匹配的字符串的开始，它在单词的开始处查找匹配项。如果它位于字符串的结尾，它在单词的结尾处查找匹配项。例如，下面的表达式匹配单词 Chapter 中的字符串 ter，因为它出现在单词边界的前面：

/ter\b/

下面的表达式匹配 Chapter 中的字符串 apt，但不匹配 aptitude 中的字符串 apt：

/\Bapt/

字符串 apt 出现在单词 Chapter 中的非单词边界处，但出现在单词 aptitude 中的单词边界处。对于 \B 非单词边界运算符，位置并不重要，因为匹配不关心究竟是单词的开头还是结尾。

选择

用圆括号将所有选择项括起来，相邻的选择项之间用|分隔。但用圆括号会有一个副作用，使相关的匹配会被缓存，此时可用?:放在第一个选项前来消除这种副作用。

其中 ?: 是非捕获元之一，还有两个非捕获元是 ?= 和 ?!，这两个还有更多的含义，前者为正向预查，在任何开始匹配圆括号内的正则表达式模式的位置来匹配搜索字符串，后者为负向预查，在任何开始不匹配该正则表达式模式的位置来匹配搜索字符串。

反向引用

对一个正则表达式模式或部分模式两边添加圆括号将导致相关匹配存储到一个临时缓冲区中，所捕获的每个子匹配都按照在正则表达式模式中从左到右出现的顺序存储。缓冲区编号从 1 开始，最多可存储 99 个捕获的子表达式。每个缓冲区都可以使用 \n 访问，其中 n 为一个标识特定缓冲区的一位或两位十进制数。

可以使用非捕获元字符 ?:、?= 或 ?! 来重写捕获，忽略对相关匹配的保存。

反向引用的最简单的、最有用的应用之一，是提供查找文本中两个相同的相邻单词的匹配项的能力。以下面的句子为例：

Is is the cost of of gasoline going up up?

上面的句子很显然有多个重复的单词。如果能设计一种方法定位该句子，而不必查找每个单词的重复出现，那该有多好。下面的正则表达式使用单个子表达式来实现这一点：

=====================================

var str = "Is is the cost of of
gasoline going up up"
var patt1 = /\b([a-z]+) \1\b/ig;
document.write(str.match(patt1));

=======================================

捕获的表达式，正如 [a-z]+ 指定的，包括一个或多个字母。正则表达式的第二部分是对以前捕获的子匹配项的引用，即，单词的第二个匹配项正好由括号表达式匹配。\1 指定第一个子匹配项。

单词边界元字符确保只检测整个单词。否则，诸如 “is issued” 或 “this is” 之类的词组将不能正确地被此表达式识别。

正则表达式后面的全局标记 g 指定将该表达式应用到输入字符串中能够查找到的尽可能多的匹配。

表达式的结尾处的不区分大小写 i 标记指定不区分大小写。

多行标记指定换行符的两边可能出现潜在的匹配。

反向引用还可以将通用资源指示符 (URI) 分解为其组件。假定您想将下面的 URI 分解为协议（ftp、http 等等）、域地址和页/路径：

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

下面的正则表达式提供该功能：

================================================

   var str ="http://www.runoob.com:80/html/html-tutorial.html";
   var patt1 = /(\w+):\/\/([^/:]+)(:\d*)?([^# ]*)/;
   arr = str.match(patt1);

  for (var i = 0; i < arr.length ; i++) {

       document.write(arr[i]);

       document.write("<br>");
}

==================================================

第三行代码 str.match(patt1) 返回一个数组，实例中的数组包含 5 个元素，索引 0 对应的是整个字符串，索引 1 对应第一个匹配符（括号内），以此类推。

第一个括号子表达式捕获 Web 地址的协议部分。该子表达式匹配在冒号和两个正斜杠前面的任何单词。

第二个括号子表达式捕获地址的域地址部分。子表达式匹配 : 和
/ 之后的一个或多个字符。

第三个括号子表达式捕获端口号（如果指定了的话）。该子表达式匹配冒号后面的零个或多个数字。只能重复一次该子表达式。

最后，第四个括号子表达式捕获 Web 地址指定的路径和 / 或页信息。该子表达式能匹配不包括 # 或空格字符的任何字符序列。

将正则表达式应用到上面的 URI，各子匹配项包含下面的内容：

第一个括号子表达式包含 http

第二个括号子表达式包含 www .runoob.com

第三个括号子表达式包含 :80

第四个括号子表达式包含
/html/html-tutorial.html

6.re模块

正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。

Python 自1.5版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。

re 模块使 Python 语言拥有全部的正则表达式功能。

compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。

re 模块也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数。

re.match函数*

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

函数语法：

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

函数参数说明：

re.search方法

re.search 扫描整个字符串并返回第一个成功的匹配。

函数语法：

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

7.http请求

http请求获取url的几种方法：Python3发送http请求（GET请求）获取url内容的几种方法，可以使用urllib，requests，可以带cookie或则不带cookie或者自动处理set-cookie

使用urllib.request

1.第一种是不带cookie，不带自定义请求头，直接获取url，使用如图所示的：

urllib.request.urlopen方法。url此时只需要是一个链接字符串即可。
要获取响应文本，先使用响应的read()，接着使用decode()解码得到字符串。

2.第二种是带有cookie，可以填写自定义请求头的url获取。

将自定义请求头写成字典（如图是my_headers）。
接着，使用urllib.request.Request(url,headers=my_headers)创建一个http请求对象。
然后使用urllib.request.urlOpen(Request对象)发送http请求。后续步骤相同。

3.第三种方法是使用具有一定自动Cookie设置功能的HTTPCookieProcessor。
需要使用urllib.request.build_opener创建一个opener对象。
接着使用opener发送HTTP请求。

使用requests

1.要使用requests，需要先安装这个模块。如果是PyCharm，在开头写import requests会自动提醒安装这个模块。

使用requests.session创建一个会话对象。

这个对象的好用之处在，它会根据http响应头自动设置下次的请求头数据。当然了，一开始需要的请求头数据还是要自行添加。

不带任何自定义请求头，访问同一个url两次，第二次已经带上了第一次响应的设定。

2.在这个requests模块内，get方法实际上是request()方法的包装。

关于参数的提示要参考request()函数的参数（第一个参数method除外）

3. 如果要带有自定义的请求头，需要定义一个字典对象（如图是myheaders），然后每个get写为：

session对象.get(url, headers=自定义http请求头字典)

自定义的请求头会覆盖默认值。

4. 如果要带上自定义cookie，最好单独一个字典对象，设置get的cookies参数。

如果希望cookie覆盖掉默认设置的所有cookie项，那就把Cookie加在请求头字典对象里。

参阅原文链接：

https://blog.csdn.net/qq_33363973/article/details/78783481

https://www.cnblogs.com/yunlong-study/p/9592926.html

https://blog.csdn.net/chenmozhe22/article/details/81434549#With_open_6

https://www.cnblogs.com/hello-wei/p/9729745.html

https://www.jianshu.com/p/ce197a6a14ea

https://www.cnblogs.com/tkqasn/p/6001134.html

https://jingyan.baidu.com/article/ed2a5d1f9f7d7309f6be178d.html

http://www.runoob.com/python/python-reg-expressions.html

http://www.runoob.com/regexp/regexp-example.html

努力！才能被爱慕~

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Day 5

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

扫一扫