（一）正则表达式

1、正则表达式

字符类

• [abc]：匹配 “a”、“b” 或 “c” 中的任意一个字符。
• abc：除了 “a”、“b” 和 “c” 以外的任何字符。
• [a-z]：匹配任何小写字母。
• [A-Z]：匹配任何大写字母。
• [0-9]：匹配任何数字。
• [a-zA-Z0-9]：匹配任何字母或数字。

限定符和重复次数

• ?：匹配前面的字符零次或一次。
• *：匹配前面的字符零次或多次。
• +：匹配前面的字符一次或多次。
• {n}：匹配前面的字符恰好 n 次。
• {n,}：匹配前面的字符至少 n 次。
• {n,m}：匹配前面的字符 n 到 m 次。

特殊字符

• \d：匹配任何数字字符，等价于 [0-9]。
• \D：匹配任何非数字字符。
• \s：匹配任何空白字符，
• 包括空格、制表符和换行符。
• \S：匹配任何非空白字符。
• \w：匹配任何字母或数字字符，等价于 [a-zA-Z0-9]。
• \W：匹配任何非词语字符。

分组和引用

• (expr)：匹配表达式并捕获匹配。可以在后续的表达式中使用 \g<id> 或 \g<name> 来引用这个捕获的匹配。
• (?:expr)：匹配表达式但不捕获匹配。 匹配位置 ^：匹配行的开头。 $：匹配行的结尾。 \b：匹配单词的边界。 \B：匹配非单词的边界。

2、re模块

查找

利用正则表达式查找，有三种方法

方法	match()	search()	findall
特点	从头匹配	仅返回第一个匹配	匹配所有字符串
返回类型	Object	Object	列表
匹配为空时	None	None	空列表
匹配次数	1	1	所有
使用频率	最不常使用	较常用	最常用

使用方法：

re.match(pattern, string, [flags])

re.search(pattern, string, [flags])

re.findall(pattern, string, [flags])

pattern：表示模式字符串，由要匹配的正则表达式转换而来

string：表示要匹配的字符串。，如

flags：可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写，如

 

利用group()来获取被匹配的子字符串

print(match.group()) # 返回所有分组的匹配结果 ​ print(match.group(1)) # 返回第1个分组的匹配结果 ​ print(match.group(2)) # 返回第2个分组的匹配结果 ​

分割

re.split(pattern, string, [maxsplit], [flags])

pattern：匹配的正则表达式
string：要匹配的字符串。
maxsplit：可选参数，表示最大的拆分次数。
flags：可选参数，表示标志位，用于控制匹配方式，如是否区分字母大小写

替换

re.sub(pattern, repl, string, count, flags)

pattern：正则表达式

repl：表示替换的字符串。

string：表示要被查找替换的原始字符串。

count：可选参数，表示模式匹配后替换的最大次数，默认值为0，表示替换所有的匹配

flags：可选参数，表示标志位，用于控制匹配方式

常见的正则表达式：

1. 匹配手机号码：^1[3-9]\d{9}$ 这个正则表达式可以精确地匹配中国大陆的手机号码，包括以 13、14、15、16、17、18、19 开头的 11 位数字串。

2. 匹配电子邮件地址：^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$ 这个正则表达式可以匹配标准的电子邮件地址格式，包括用户名和域名两个部分。其中，用户名部分可以包含大小写字母、数字、下划线和减号，域名部分则必须包含一个点号（例如 .com、.net、.edu）。

3. 匹配身份证号码：^[1-9]\d{5}(18|19|20)\d{2}(0[1-9]|1[012])(0[1-9]|[12]\d|3[01])\d{3}[0-9xX]$ 这个正则表达式可以匹配中国居民身份证号码，包括前六位地区代码、中间的年月日和最后一位的校验码。需要注意的是，该正则表达式不能验证身份证的真实性，只能验证格式是否正确。

4. 匹配日期：^(19|20)\d{2}-(0[1-9]|1[012])-(0[1-9]|[12]\d|3[01])$ 这个正则表达式可以匹配标准的日期格式，包括年份、月份和日份，其中年份范围为 1900 到 2099 年。

5. 匹配 IP 地址：^(25[0-5]|2[0-4]\d|[01]?\d\d?)\.(25[0-5]|2[0-4]\d|[01]?\d\d?)\.(25[0-5]|2[0-4]\d|[01]?\d\d?)\.(25[0-5]|2[0-4]\d|[01]?\d\d?)$ 这个正则表达式可以匹配标准 IPv4 地址格式，包括四个点分隔的数字段，每个数字段的取值范围是 0 到 255。

（二） 函数

1、定义

def 函数名(参数):
    函数体
    
#调用：
函数名(参数)

2、参数

普通参数：实参

默认值参数：

def 函数名(...，形参名=值)：
    函数体
    #形参名=值，要放在右边，位置必须与定义时一致
    
#查看当前默认参数值：
函数名.__defaults__

关键参数：调用函数时的参数传递方式与函数定义无关

可变长参数：

*parameter：存放元组

**parameter：多个关键字存放在字典中

3、作用域

局部变量：函数内部定义的变量

全局变量：在函数外定义，用global 定义全局变量

4、匿名函数（lambda表达式）

#定义：
result=lambda 参数=函数体
#调用：
result(参数)

 （三）面对对象

1、类的定义

class 类名:
    属性1=值1 #类属性
    def __init__(self,变量1,变量2....):#实例方法（构造方法）
        #self.变量1=变量1 #成员属性
        方法体
​
    def 方法名(参数1....):#普通方法
        方法体
​
#调用类
对象名=类名()
对象名=类名（成员1，成员2....）

在实例方法中，python会自动绑定方法的第一个参数（通常建议该参数命名为self）第一个参数只想总是指向调用该方法的对象，

案例：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
​
person = Person("Tom", 28)
print(person.name)    # 输出 "Tom"
print(person.age)     # 输出 "28"
​

增加类属性：

对象.属性名=值

person.address="广州"

print(person.address)#结果：广州

2、类中的权限

在python中权限分三种：

• 保护protected：成员或方法前加上单下划线"_"
• 私有private：成员或方法前加上双下划线"__"
• 公共public：python默认的公共方法，什么都不加

此外注意：有一种特殊的方法定义:方法名前后都有双划线，例如实例方法__ _init__ _，这是系统定义的方法。

3、封装

封装指的是将数据和方法组合到一个单元中，并对外部隐藏这个单元的实现细节。

class Person:
   def __init__(self, name, age):
      self.name = name
      self.__age = age #私有属性
      
   def display(self):
      print("Name: ", self.name)
      print("Age: ", self.__age)
​
person = Person("Tom", 20)
person.display()

使用__来定义私有属性，这意味着该属性只能在类的内部访问，无法在类的外部访问。这样可以保证类的数据安全性和可维护性

4、继承

继承是面向对象编程中的另一个主要概念，它指的是一个类可以继承另一个类的属性和方法。被继承的类称为父类、超类或基类，而继承的类称为子类或派生类

class Person:
   def __init__(self, name, age):
      self.name = name
      self.__age = age #私有属性
      
   def display(self):
      print("Name: ", self.name)
      print("Age: ", self.__age)
​
person = Person("Tom", 20)
person.display()

创建了一个Animal类作为父类，又创建了一个Dog类作为子类，并使用super().__init__()方法来调用父类的构造函数进行初始化，使用super().display()方法来调用父类方法。

5、多态

多态指的是同一个方法或属性在不同的对象中表现出不同的行为。具体来说，多态体现在两个方面：方法重载和方法重写。方法重载指的是在同一个类中，根据传入的参数类型和数量的不同，实现具有不同行为的同名方法。方法重写指的是子类方法可以重写父类方法，从而实现不同的行为。

class Animal:
   def make_sound(self):
      print("Animal makes sound")
​
class Dog(Animal):
   def make_sound(self):
      print("Dog barks")
​
class Cat(Animal):
   def make_sound(self):
      print("Cat meows")
​
def animal_sound(animal):
   animal.make_sound()
​
animal_sound(Animal())
animal_sound(Dog())
animal_sound(Cat())

定义了一个基类Animal和两个子类Dog和Cat，并定义了make_sound()方法。我们使用animal_sound()方法在不同的对象中传入animal参数调用make_sound()方法，从而实现了多态的效果。

（四）异常处理

    try:
        try块
    except 错误类型：
        except块

可能存在异常。符合异常类型就执行

    try:
        try块
    except 错误类型：
        except块
    else:
        else块
    

不存在所列异常，就执行else模块

 try:
        try块
    except 错误类型：
        except块
    finally:
        finally块

不管异常情况如何，必执行finally块

 （五）文件操作

1、基本文件操作

打开文件对象：open

使用：

对象名=open(‘文件’，打开方式)

打开方式:

常见属性：

• closed：判断是否关闭
• mode:返回打开模式
• name:返回文件名称

关闭文件

• flush():内容写入文件，但不关闭文件
• close()：内容写入文件，同时关闭文件，释放资源

读文件

• read([size])：从文件中读取size字节，省略参数size表示一次性读取全部内容
• readline():读取一行
• readlines():读取一行的第一个字符

指针

• seek(offset[,whence]):指针移动，offset:偏移量，whence(0:从头开始，1：从当前位置开始，2：从尾部开始)
• tell():返回当前位置

删除

truncate([size]):删除当前指针位置到末尾内容，只留下前size字节，省略size表示：删除全部

写内容

• write(s):把内容写入文件中
• writeline(s)把列表s逐个写入文本文件

2、os模块

3、os.path模块

路径：

• abspath(‘路径’)：返回所给路径的绝对路径
• dirname('路径):返回路径的目录部分

判断问价是否存在：

• exits('文件')

时间

• getatime(路径)：最后访问时间
• getctime(路径)：文件创造时间
• getmtime(路径)：文件最后修改时间

文件大小：

• getsize(文件名)

判断：

• isiabs(路径)：判断是否是绝对路径
• isdir(路径)：判断是否是目录
• ifile(路径):判断是否是文件

连接：

• join(路径1，路径2):将多个路径组合成一个路径，便于跨平台使用

分割：

• split(路径)：分割路径为目录和文件名两部分，返回一个元组
• splitext(路径)：分割路径为文件名和扩展名两部分，返回一个元组
• splitdirive(路径)：从路径分割驱动器

4、目录操作

os模块

os.path模块