知识点1：

Python标识符的命名规则（标识符包括变量，在Python中你自己可以定义的函数、类名、变量、对象（凡事你可以定义的）都统称为标识符），标识必须以下划线或者字母开头，不能以数字开头，标识符可以由下划线、字母和数字构成但是开头只能是下划线或者字母，标识符不能和关键字重名(python中只有33个关键字，而且这些关键字非常的好记，例如if,for,else,as 等等，想知道具体的请去找度娘！），另外，Python支持unicode编码格式，可以支持多国语言，用中文也可以做标识符，例如：身高=1.70（上面的规定变量的条件，只针对英文格式下，你如果用中文定义标识符例如：帅哥=‘我’，就不满足上面的规则了）

知识点2：

Python当中的两大循环（c语言是大三循环,不过目前我觉得两大循环就够了），for 和while，这里补充一个额外的知识点，for循环和while循环后面是可以跟else的,当循环结束就会执行else的代码，当循环中断就不会执行else的代码了

for i in [1,2,3,4]:print(i)
else:print('for循环执行完毕')

i=1
while i<10:print("循环进行中.....")i += 1
else:print("while循环结束")

 

知识点3：字符串的切片操作很重要！有时候需要用到切片操作，所以要知道

a = '我是个帅哥'
print(a[1:5])
print(a[0:5:1])
# a[start:end:step]
print(a[-1:-6:-1])
print(a[::-1])

知识点4：

zip函数的使用! zip函数用来打包非常的不错，所以可以记住这个函数，这个函数可以让两个列表的值相对应上，对于一些数据的归类对齐非常不错，比如你采集了一个学生的信息，学号要对应姓名，就可以使用zip函数了，非常方便。

student_name = ['帅哥','大帅哥','非常帅']
student_number = ['sg','big_sg','very_sg']
for i in zip(student_number,student_name):number,name = iprint(number+':::'+name)

知识点5：

Python当中的运算符，逻辑运算符，这些都比较简单，随便看看大概就记住了（*，/,+,-,%,//(地板除法），or,not,and,+= 就这些比较常用吧）

知识点6：Python常用的容器类型数据主要有三种，序列、集合、字典。

        那么就来分别说说这三种容器类型数据!(容器类型数据就是可以存储多个数据的类型） 首先来说序列，序列是有序的！序列主要包括列表（list）、元组（tuple)、字符串等。 其中列表是有序的，元组是不可变的！

        列表的创建及列表的使用

 name1 = []
name2 = ['张三','李四']
name3 = list('hello')
name4 = list(('帅哥','大帅哥'))
print(name1)
print(name2)
print(name3)
print(name4)
# 运行结果
[]
['张三', '李四']
['h', 'e', 'l', 'l', 'o']
['帅哥', '大帅哥']
列表常用的方法：
append() 方法 添加一个数据 append(x) x: 添加的值
extend() 方法 添加多个数据 extend(x) x：一个字典、列表、元祖
比较少用：
insert() 方法 插入一个数据 insert(i,x) i:插入的索引位置 x: 插入的数据
remove() 方法 删除一个数据 remove(x) x:删除的值，如果有多个删除第一个

元组的使用以及创建

num1 = ()
num2 = 20,30,40
num3 = tuple((20,30,80))
num4 = (20,50,80)
print(num1)
print(num2)
print(num3)
print(num4)
# 运行结果
()
(20, 30, 40)
(20, 30, 80)
(20, 50, 80)

元组的常用方法
 

 

元组和列表使用类型定义时（即使用list(),tuple()方法定义）需要注意，只能传入一个参数，如果要传入多个参数，要使用（）括起来！

字符串的常用方法

 

str = '我是一个帅哥，我相信我自己！'
str1 = str.split('，')
print(str1)
运行结果
['我是一个帅哥', '我相信我自己！']
split() 方法的介绍：将字符串按照要求进行分割，返回字符串列表对象
split('分割字符',maxcount)
maxcount: 最大分割次数

replace() 方法的介绍：将字符串当中的字符进行替换 replace('old','new',count)
old:需要替换字符 new： 替换成的新字符 count：替换次数

find() 方法的介绍: 对字符串进行查找 find('sub',start,end) sub:需要查找的内容 
start:开始索引
end: 结束索引 start和end可以省略不写
 

序列过来就是集合了！ 集合符号是一个大括号 {} ， 并且有一个特点里面的数据是无序的，里面的数据是无序的所以也就不能够进行索引, 特别注意集合里面的数据不能重复，每一个数据都是唯一的，所以集合在某些方面有非常大的作用。

# 创建集合的三种方式：
di1 = set('hello')
di2 = {}
di3 = {1,3,6}
#集合的常用方法：
# add() 添加元素
# remove() 删除元素
# clear() 清空集合
di1.add(50)
di1.remove('e')
print(di1)

说完序列就要说字典了。字典的使用在Python当中还是比较频繁的，字典和集合都是用{}，但是却完全不一样。字典由键和值组成翻译成英文就是由key和value组成，并且字典当中的数据形式都是以这样的方式存储的 ：{key1:value1,key2:value2,key3:value3}，每一个key必须要对应一个value，一一对应并且key值不能重复是唯一的。

字典的常用方法

 

字典1 = dict(zip((1,2),('帅哥','大帅哥')))
字典2 = dict() 通过dict()函数创建字典里面的参数就是一个字典dict({key:value})
字典3 = {}
字典4 = {'我':'帅哥','你':'小帅哥'}
print(字典1)
print(字典2)
print(字典3)
print(字典4)
# 运行结果
{1: '帅哥', 2: '大帅哥'}
{}
{}
{'我': '帅哥', '你': '小帅哥'}

# 添加值：
字典1['sg'] = '帅哥'
# 删除值：
字典1.pop(1) 利用 pop(key)的方法删除键值对
# 查看所有的键值对：
print(字典1.items())
# 查看所有的键（key）:
print(字典1.keys())
# 查看所有的值:
print(字典1.values())
print(list(字典1.values))  # 使用keys 方法后可以用list进行显示转换
# 字典也可以循环遍历：
for i in 字典1.keys():
    print(字典1[i])

以上就是三种容器类型的常用方法，在实际使用当中还有很多方法，所以我们要不断的积累和学习，在编程学习当中记笔记是一个非常好的习惯，当需要的时候翻笔记直接用！

知识点7：

转义字符，基本常见的转义字符有 \t,\n,\r,\\ 等等，当你要进行转义时可以加一个\（反斜杠），如果想要原生字符串，那么可以在字符串前面加上一个r 即 str = r'我是帅哥\n,我喜欢美女'

知识点8：

如何记住正斜杠和反斜杠，想象这个斜杠是一个人，如果这个人向前面倒，那么是正斜杠，如果向后面倒，那么就是反斜杠。

知识点9：

使用占位符，在Python当中使用占位符是非常常见的事情，一般可以使用format() 方法。用一个{}进行占位，我个人觉得是非常好用的。

for i in [1,3,8,10]:print('我的幸运数字是：{}'.format(i))print('我的幸运数字是：{} 你的幸运数字是：{}'.format(i,10))print('我的幸运数字是：{1} 你的幸运数字是：{1}'.format(i,10))print('我的幸运数字是：{0} 你的幸运数字是：{1}'.format(i,10)) 
占位符里可以设置序号，format函数里面的参数将按照序号对号入座，从0序号开始在占位符当中也可以设置数据的格式：print('我的幸运数字是：{0：float} 
你的幸运数字是：{0:d}'.format(i,10)){0：d} 0:参数序号 d:格式控制符

知识点10：

Python中的函数，函数在不同的位置有不同的叫法，作用于当前模块，我们称之为函数，在别的函数中定义我们称之为嵌套函数，在类中定义，我们称之为方法。

def 函数名（参数）：函数体return 返回值

其中def是关键字，声明这是一个函数，所以要定义一个函数就一定要用def标识。参数可以设置一个参数或者多个参数（*args 表示传入一个元组类型的参数，**args 表示传入一个字典类型的参数）。 一个函数可以用返回值也可以没有返回值，这个根据函数的功能来选择。

知识点11：全局变量和局部变量，如果要将局部变量声明为全局变量要加global

知识点12：函数可以也可以作为返回值，也可以作为另一个函数的参数使用，这个有的人容易忽略或者忘记！

def add(a,b):
    return a+b

def calc(opr):
    if opr=='+':
        return add
    else:
        print('不执行加法运算')

end = calc('+')
print(end(1,5))

过滤函数filter() : 用于对容器中的元素进行过滤处理。
list1 = [1,4, 8, 9,10, 24, 33, 88]
def man(i):
    return i>10

list2 = filter(man,list1)
print(list2)
print(list(list2)))

映射函数 map()
list1 = [1,4, 8, 9,10, 24, 33, 88]
def info(i):
    return i*10

list2 = map(info,list1)
print(list2)
print(list(list2))

关键来了 lambda() 函数 这个函数是匿名函数，就是没有名字，并且很简单
函数定义如下： lambda 参数列表：lambda体
注意： lambda体只能有一条语句不能有多条语句
 

 

注意：filter()函数和map()函数可以直接用列表推导式代替，用列表推导式也可以完成相同操作

！ 

知识点12：

Python当中非常高大上的方法：列表推导式！每个程序员的代码优美度有高有低，代码水平也各不相同，而有些代码的使用则会使代码瞬间打开一个新世界一样，令人感到非常的惊讶和舒适，并且看完以后还觉得非常精巧。列表推导式就是其中之一！

        下面就是代码，请仔细观察输出结果，作为一个程序员敏锐的观察力是一个必备条件！

# 列表推导式
list1 = [i for i in range(1,10)]
print(list1)
list1 = [i+10 for i in list1]
print(list1)
list2 = ['很自信','很强大','很帅','喜欢美女','不断在成长提高自己']
list2 = ['我'+i for i in list2]
print(list2)
# 运行结果
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[11, 12, 13, 14, 15, 16, 17, 18, 19]
['我很自信', '我很强大', '我很帅', '我喜欢美女', '我不断在成长提高自己']

上面就是列表推导式，一行代码就可以完成几行甚至十几行代码的工作！

除了列表推导式，还有字典推导式，集合推导式这些基本都是差不多的，举一个例子。

dic1 = ['帅哥','自信','勇敢','乐观']
dic2 = ['我是','我很','我非常','我超级']
dict3 = {i:j for i in dic2 for j in dic1 if dic1.index(j)==dic2.index(i)} 
print(dict3)
# 运行结果
{'我是': '帅哥', '我很': '自信', '我非常': '勇敢', '我超级': '乐观'}

上面这个字典列表式有点难度！（嘿嘿）

知识点13：

面向对象编程，即创建类（Class）。想必大家应该都听说过，Python是一门面向对象的编程语言，那么什么是对象呢？一个桌子是一个对象，一部手机是对象，世间万物都可以被称之为对象（详细专业术语解释请查阅专业书籍）。那么怎样来面对对象来进行开发呢？那么首先就要创建一个类，在Python当中类的使用非常的频繁，可以说是代码编程的核心了，通过类来创建对象，达到最终的目的。可能有人没懂，那我举个例子，类就是把对象的信息（形状、类型、特征等等）收集封装起来，如何实体化变成一个对象，就像飞机图纸和飞机的关系，飞机图纸有飞机的一切大小参数，如何实体化也就是制作出来就变成了一架飞机，就像王者荣耀的李白，在游戏里的模型就是类，把他变成手办就变成了一个对象，在或者，一个房子的图纸就是类，把房子做出来就变成了对象。（不懂自己去搞懂。。。吧，例子举了这么多）

        那么如何创建类呢？以及类又有哪些功能特点呢？

首先来说如何去创建一个类？

class ClassName(object):
    """docstring for ClassName"""
    def __init__(self, arg):
        super(ClassName, self).__init__()
        self.arg = arg
    def run():
        pass
# 上面是编译器自动补全的类，下面一般是自己建的类
class Candy():
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def run():
        pass
说明：name 和 age 是用户传入的参数即实例变量，run()方法是实例方法 

        创建一个类首先要给一个关键字：class , 关键字后面就是类名了（类的名字，开头字母要大写，遵循大驼峰命名法，就像骆驼的两个驼峰，单词首字母都要大写）

        接下来就是很重要的构造方法：

def __init__(self,name,age): self.name =nameself.age = age

构造方法是写在类当中的一个类方法，通过这个构造方法就是创建和初始化实例变量（实例变量就是用户自己要输入的变量也可以说是参数）。通过这个方法用户就可以把想要输入的参数传入到类当中，可能有些人会问函数是自己在后面括号里传参，为什么类不能，而要特意使用一个构造函数？因为类还有一个特征：继承性！（后面会讲）

构造方法的第一个参数必须是self，后面跟着要使用的参数，至于为什么要self.name = name (自己去寻找答案）

在类当中有五个名词：类变量、实例变量、类方法、实例方法和属性，如果想要彻底搞明白类，那么这五个词的意思必须清晰明确的知道，并且区分他们。（如果不知道，建议去弄懂）

接下来将类的三大特性：封装性、继承性、多态性（非常重要）

封装性：简单来说就是可以将代码封装起来，让外面的人看不到里面的详细结构（专业解释请参考有关书籍），举个例子：就像没有封装的时候就像一个玻璃瓶大家可以将玻璃瓶内部看的一清二楚，但是如果给玻璃瓶加一个杯套，那么玻璃瓶的内部我们就看不见了，封装也是这个意思。

        那么类也是如此，将类封装起来就可以让用户看到想要看到的内容，不想让用户看到的内容自然就看不见了。那么可能会有一个问题，类的代码就写在哪里?无论写了什么不都是都能一眼看见吗？类的封装是指让用户看不见，不是程序员看不见而且类并不是直接使用的而是要变成实例，实例后调用里面的内容，就一台电脑的主机，工人在安装的时候是一块块主板，一个个风扇，一个cup，一个内存条等等，工人是看的清清楚楚的，但是交到你（用户）手里那就是一台主机，你可以通过外壳一些间隙看见里面的东西，因为这是想让你看见的，不想让你看见的你自然就看不见了（除非你拆开他），类也是如此。

        通过类创建实例的过程如下：

class Is_class():def __init__(self,name):self.name = namedef run(self):print('我是一个{}类'.format(self.name))Pag = Is_class('猪')  # 这就创建了一个猪对象，也就是一个将类实例话
Pag.run() # 调用类当中的方法
print(Pag.name) # 查看自己的名字（调用类中的变量）

        创建对象的过程就像是给机器人加了灵魂，当灵魂加进去的时候，就可以调用类中的公有方法和属性。

        一般情况下使用对象来调用实例方法和查看实例变量，用类来调用类方法和类对象。（对象也可以直接调用类变量和类方法）

先来说私有变量和私有方法，他们都是通过在名字前面加两个下划线__来实现的。

class IsClass():
    def __init__(self,name,age):
        self.name = name
        self.__age = age
    
    def run(self):
        print('我是一个{}类'.format(self.name))
    def __sound(self):
        print('我的年龄是{}'.format(self.__age))

cat = IsClass('猫',10)
cat.__sound()
print(cat.__age)
运行结果:
AttributeError: 'IsClass' object has no attribute '__sound'
# Traceback 异常堆栈错误

 

上面运行的结果直接报错，并且提示属性错误，类对象没有__sound属性，但是事实是有，只是这是私有变量用户不能进行访问所以报错私有变量也是同样的不能访问，所以在类当中需要不让用户看到一些内容就添加私有属性和方法，这些私有属性和方法在类的内部可以自由使用。

        类变量和类方法，这个方法就是指类里面创建的属于类的方法，用户可以查看而且是所以用户都可以看见。就像QQ一样，大家都有一个共同的界面和布局，好友各不相同列表信息各不相同，相同的界面和布局就是类变量，自己的联系人就是实例变量。

        示例代码如下：

class Bank():profit = 0.0005 # 类变量def __init__(self,name,money):self.name = nameself.money = money@classmethoddef run(cls):print('每天利率为:{}'.format( cls.profit))my_bank = Bank('帅哥',10000)
my_bank.run()

类变量和类方法可以通过对象查看也可以通过类调用，书上说是用类调用（可以查看一下详细说明），其中要注意类方法的创建需要用到装饰器，@符合开头，并且类名括号里第一个参数是cls就是class的简写，也是通过cls.来调用类变量。

        还有一点，类变量和实例变量不能交叉使用，类方法里不能用实例变量，实例方法里不能用类变量，会报错！（怎么解决，请自己去网上寻找答案）

总结一下，类的封装性就是给类里面的添加一些私有属性，让对象不能够调用，从而实现封装的目的，也包括形成公共的类变量和类方法，和对象自定义的实例变量和实例方法等等。

类的第二大特征：继承性。 类可以继承父类的公有的成员变量和方法，私有的则不会继承。

就像只猫生了一个猫宝宝，猫宝宝会继承猫爸妈的特性，首先长的像只猫，看起来像只猫等等

类同样可以继承，比如当你写了一个动物类，然后又想建立一个猫类，那么就可以继承动物类，在继承动物类的基础上加上猫的独特特征变成猫类，继承可以大量的减少代码和方法的重用，非常方便。

        那么如何继承父类呢？ 代码如下

class Animal():
    def __init__(self, name):
        self.name = name

    def run_speak(self):
        print('我是动物，有叫声')
    
class Cat(Animal):
    def __init__(self,name,age):
        super().__init__(name) # 调用父类构造方法，初始化父类成员变量
        self.age = age
    def run(self):
        print('我是{},已经{}岁了'.format(self.name,self.age))

cat = Cat('小猫',10)
cat.run_speak()
cat.run()
# 运行结果
我是动物，有叫声
我是小猫,已经10岁了
 

 

上面代码中猫类继承了动物类，所以在可以调用父类的run_speak方法，并且还可以初始化父类的构造方法，调用父类的self.name 变量。（注意:super()方法的详细使用请查看相关文档，务必熟悉super()方法的使用）

那么一个子类可以继承多个父类吗？答案是可以，在Python当中支持一个类继承多个子类。

class Animal():
    def __init__(self, name):
        self.name = name

    def run_speak(self):
        print('我是动物，有叫声')
    
class Cat():
    def __init__(self,age):
        self.age = age
    def run(self):
        print('我是{},已经{}岁了'.format(self.name,self.age))
class Flower_cat(Animal,Cat):
    def __init__(self,name,name_cat):
        super().__init__(name)
        self.name_cat = name_cat
    def run_cat(self):
        print('我属于{}'.format(self.name_cat))

flower_cat = Flower_cat('小可爱','花猫')
flower_cat.run_cat()
flower_cat.run_speak()
# 运行结果：
我属于花猫
我是动物，有叫声
 

 

如果父类中有同名的类变量或者类方法，子类优先继承左边父类的类变量和类方法。如果子类的方法名与父类的方法名相同，那么会重写父类方法（也就是修改父类方法，输入子类方法的内容）。

类的多态性:在多个子类继承父类并且重写父类方法后，这些子类所创建的对象之间就是多态的。

举个例子：同一款手机买来的时候都是一样的，里面的应用也都是一样的，到了用户的手中每个人对手机进行个性化装饰（购买手机壳，保护套等等），对手机内部进行装饰（安装各种各样的APP，设置壁纸、个性化桌面等等），那么这个手机也就是多态的了，类也是如此，虽然继承父类但是经过对父类的重写，变成各种各样形态就是多态。

鸭子类型测试：如果看到一只鸟，游起来像鸭子、走起来像鸭子、叫起来也像鸭子，那么这只鸟可以被称为一只鸭子。

知识点14：

异常处理，异常处理在程序当中的作用很大，可以尽可能的避免程序出bug，也可以减少程序运行失败的可能性。

        异常处理的代码结构如下：

try:#可能发生异常的内容
except:# 发生异常后执行的代码
finally:# 不管有没有发生异常都执行的代码，并且释放资源

try-except 结构 : 将捕获所有的异常，不进行分类

try -except - except 结构：将对异常进行判断，由最后一个except捕获所有没有匹配的异常

try:# 可能发送异常的代码块
except ZeroDivisionError as e:# 捕获除零异常
except valueError as e:# 捕获值错误异常
except:# 捕获上面没有匹配的所有异常

try-except-finally 结构：在代码块的末尾加了finally代码块，作用是释放资源，有时在try-except语句当中会占用一些资源，为了确保资源被释放就可以使用finally代码块。

提示：多条except语句可以合并成一条语句。（如何合并请自己查阅资料进行学习）

提示：使用者也可以自定义异常类，继承父类，并进行部分代码重写。

知识点15：

Python中自带的模块的使用，math模块，datetime模块

import datetime# datetime 类
print(datetime.datetime.today())
# date 类
print(datetime.date.today())
# time 类
# 和其他两个类类似。。。。。。# 运行结果
2022-03-03 15:21:58.628014
2022-03-03

简述了一下datetime模块的使用，详细的使用方法请去看使用手册。

另外在加两个方法，将时间转换成字符串和将字符串时间转换成为时间，代码如下：

import datetimed = datetime.datetime.today()
b = d.strftime('%Y-%m-%d %H:%M:%S')
print(b)
a = '2022-03-03 15:27:33'
c = datetime.datetime.strptime(a,'%Y-%m-%d %H:%M:%S')
print(c)
# 运行结果
'2022-03-03 15:28:56' (b的实际结果是这个，但是打印后就是下面那个，加单引号是为了做区分)
2022-03-03 15:27:33

知识点16：

正则表达式！

相信大家对正则表达式应该都不陌生，因为在各大编程语言当中都出现过正则的身影，算是编程中通用的一种查找和筛选的方式。

        那么什么是正则表达式呢？就是通过一组规定，形成一个模板对数据进行筛查满足的就通过，没满足的就不通过，就相当于一个筛网，而通过正则就可以随意设计这个筛网，从而晒选出自己想要的数据。

学习正则基本语法之前，先来讲讲正则经常用的一些方法：match(parttern, text)、sub(pattern, repl, string, count)、search(parttern, text)、findall(parttern, text)、split(pattern,string,maxsplit)等等

        基本语法简单介绍：

1.匹配某个字符串
a = '我是帅哥'
b = re.match('我是',a)
print(b)
# 运行结果
<re.Match object; span=(0, 2), match='我是'> 
# 匹配成功则返回一个match对象，没有则返回none
2.点(.) 匹配任意字符
a = '我是帅哥'
b = re.match('..',a)
print(b)
# 运行结果
<re.Match object; span=(0, 2), match='我是'>
3.\d 匹配任意的数字（0-9）
a = '12345678'
b = re.match('\d\d\d',a)
print(b.group())
# 运行结果
123
4. \D 匹配任意的非数字
a = 'AbBVC'
b = re.match('\D\D\D',a)
print(b.group())
# 运行结果
AbB
5. \s 匹配空白字符（\n,\t,\r,空格)
a = 'AbB\t\nVC'
b = re.match('\D\D\D\s\s',a)
print(b.group())
# 运行结果
AbB 
其实实际上是这样的：AbB\t\n
6. \w 匹配的是a-z,A-Z,数字和下划线
a = 'AbB12930VC'
b = re.match('\w\w\w\w\w',a)
print(b.group())
# 运行结果
AbB12
7. \W 正好与\w相反
8.[]组合的方式，只要满足中括号中的字符就可以匹配
a = '130390390'
b = re.match('[1-9][1-9][0-9][1-9]',a)
print(b.group())
# 运行结果
1303
以上都是进行单个字符匹配，接下来是匹配多个字符，
匹配多个字符要在单个匹配的基础之上使用不能单个使用
9. * 匹配0个或者任意多个字符
a = '130390390'
b = re.match('\d*',a)
print(b.group())
# 运行结果
130390390
10. +：匹配一个或者多个字符
a = '130390390'
b = re.match('\d+',a)
print(b.group())
# 运行结果
130390390
11. ?: 匹配一个或者0个（要么没有，要么就只有一个）
a = '130390390'
b = re.match('\d?',a)
print(b.group())
# 运行结果
1
12. {m}:匹配m个字符
a = '130390390'
b = re.match('\d{3}',a)
print(b.group())
# 运行结果
130
13. {m,n}:匹配m-n个字符
a = '130390390'
b = re.match('\d{3,8}',a)
print(b.group())
# 运行结果
13039039
18.(^)脱子号：表示以。。。开始
a = '130390390'
b = re.match('^1',a)
print(b.group())
# 运行结果
1
19.$:表示以。。。结尾
a = '130390390.com'
b = re.match('\w+.com$',a)
print(b.group())
# 运行结果
130390390.com
20.|：匹配多个字符串或者表达式
a = 'http:130390390.com'
b = re.match('(http|ftp|https).+',a)
print(b.group())
# 运行结果
http:130390390.com
21.贪婪模式与非贪婪模式
text = '<h1>标签</h1>'
ret = re.match('<.+?>', text)
print(ret.group())
ret1 = re.match('<.+>',text)
print(ret1.group())
运行结果
<h1>
<h1>标签</h1>

以上就是正则表达式的基本语法，可能大家会觉得比较多，但是其实也就那几个\d,\D,\w,\W,.,\s,[]

其他的就是在以上基础的基础上使用的多匹配符合:+,?,{},*,另外加两个开头结尾：^,$ 就没有了（这个^在中括号中表示不是[^0-9]，意思是不是0-9的所有字符相当于\D），正则表达式就是通过以上进行自由组合，形成一个数据筛网，筛出想要的数据。

（记住技巧：\d :date(数字0-9），\D(don date)：不是数字的任意字符，\s(转义字符、空格)，\w:\w 匹配的是a-z,A-Z,数字和下划线 \W：与小w相反，. : 匹配任意一个字符，反正自己找方法记。。。。。。）

知识点17：

文件的操作，打开写入追加等等。

文件的打开方式有如下几种：t , b , w, r , a 

t : 以文本方式打开        b: 以二进制形式打开        w: 以写方式打开      r: 以只读方式打开

a : 以追加方式打开         +：以更新模式打开（需要配合w \ r \ a 使用）  

（具体详细的描述和介绍请查阅有关资料）

以 w+ 方式创建创建文件，并且写入hello Word

txt = 'ttt.txt'
b = open(txt,'w+')
b.write('hello word')

 以r+ 方式打开文件，查看文件内容

di = 'ttt.txt'
b = open(di,'r+')
a = b.read()
print(a)

 以a+方式打开并且追加数据

di = 'ttt.txt'
b = open(di,'a+')
a = b.write('我是帅哥？')
print(a)

复制文件：

1. 打开文件，读出文件内容

di = 'ttt.txt'
b = open(di,'r+')
a = b.readlines()

2.新建文件，写入读出的内容
d2 = 'ttt0.txt'
c = open(d2,'w+')
cc = c.writelines(a)

二进制文件的读写操作。二进制文件一般有excel,png图片等等

 1.以二进制打开图片，获取图片内容

a = open('士力架.jpg','rb+')
b = a.readlines()

2.以二进制写入图片
c = open('复制图片.jpg','wb+')
d = c.writelines(b)

在文件进行读写操作后都需要一步关闭文件的操作，即close(),一般可以读写文件的过程中经常会出错，所以close()操作一般写在finally()代码块后面，但是这样的操作太繁琐，我也不想写。

        所以为了避免代码繁琐，采用了一种新的打开方式即：with as , 代码写法如下：

with open(file,code,encoding,error) as f：

        f.write()

通过这样的写法就可以在完成写入或者查看操作后自动关闭文件，释放内存。示例如下:

with open('ttt.txt','r+') as f:
    content = f.read()
    print(content)

基本上使用是差不多的，就是加了一个 with as ，as 后面是赋值一个变量(如果学过数据库的朋友，那么应该知道 as 在数据库是起别名，在Python里也是一样，就可以理解是给打开后的文件对象起了个别名）。

        补充一点（差点忘了）：除了read() , write() 方法他们还各自有两个方法， readline() , readlines() , writeline() , writelines() （至于什么用法，自己去搞懂！）

        那么文件的读写操作就完了，读写操作就是通过 t , a , w , r , b 之间的自由组合 ，‘+’ 需要配合这些使用。

知识点18：

SQLlite数据库（SQLlite是为嵌入式设备设计的数据库（如智能手机等），与MySQL和oracle数据库不同的是，他与应用程序之间共用相同的进程空间），那么这个知识点就来简单的结束SQLlite数据的使用和与Python建立连接，用Python代码对数据库进行增删改查操作。

        SQLlite有很多第三方GUI管理界面，本人使用的是DB Browser for SQLlite。这款GUI管理界面非常的轻量级，而且是中文，个人觉得比较方便。

        在用户界面进行数据库的创建、设定约束条件等等，在此不讲（请自己自动去查阅相关资料）

        Python官方提供了sqlite3模块来访问SQL数据库。

首先来介绍一下sqlite3模块的几个常用的方法。

connect(database) 函数：用于链接数据库，database：是指数据库的路径

cursor(): 获得cursor游标（不懂游标肯定是基本不是很好，建议再去复习数据库基础（用于执行SQL命令））

close(): 关闭连接

commit() : 提交数据库事务   rollback() ： 回滚数据库事务    

游标对象的几个方法： cursor.execute(sql,[参数]) ：执行SQL语句，sql: 代指SQL语句

cursor.fetchone() \  cursor.fetchall() \ cursor.fetchmany(size) 代码中有解释

下面是用Python代码对数据库进行增删改查的代码操作

import sqlite3# 1.首先是要链接数据库
con = sqlite3.connect(r'F:\python\DB_Browser_for_SQLlite_database\DB Browser for SQLite\student.db')# 2.创建游标
cursor = con.cursor()
# 3. 写入SQL代码
try:sql = 'select * from class'# 4. 执行SQL代码cursor.execute(sql)# 5.获取数据# fetchone()获取一行date = cursor.fetchone()print(date)# fetchmany()指定获取几行date1 = cursor.fetchmany(2)print(date1)# fetchall()获取所有数据date2 = cursor.fetchall()print(date2)# 执行插入操作# 用户输入数据name1 = str(input('请输入姓名：'))sex1 = str(input('请输入性别：'))class_name1 = int(input('请输入班级号：'))sql = 'insert into class(name,sex,class_name) values(?,?,?)'cursor.execute(sql, [name1,sex1,class_name1])con.commit()# 打印一下数据库结果，看是否插入成功sql1 = 'select * from class'cursor.execute(sql1)result = cursor.fetchall()print(result)# 数据库的更新操作id = int(input('请输入要更改的id号：'))name1 = str(input('请输入更改后的姓名：'))sex1 = str(input('请输入更改后的性别：'))class_name1 = int(input('请输入更改后班级号：'))sql2 = 'update class set name= ? ,sex = ?, class_name= ? ' \'where id = ? ;'cursor.execute(sql2,[name1,sex1,class_name1,id])con.commit()# 打印一下更改结果sql22 = 'select * from class'cursor.execute(sql22)date = cursor.fetchall()print(date)# 数据库的删除操作# 先插入一个无关数据name1 = str(input('请输入姓名：'))sex1 = str(input('请输入性别：'))class_name1 = int(input('请输入班级号：'))sql = 'insert into class(name,sex,class_name) values(?,?,?)'cursor.execute(sql,(name1,sex1,class_name1))con.commit()# 打印一下插入的数据sql11 = 'select * from class'cursor.execute(sql11)date = cursor.fetchall()print(date)# 进行数据删除操作sql4 = 'delete from class where id=4'cursor.execute(sql4)con.commit()sql12 = 'select * from class'cursor.execute(sql12)date1 = cursor.fetchall()print(date1)# 运行结果如下，成功删除"""请输入姓名：宇宙无敌请输入性别：男请输入班级号：99[(1, '帅哥', '男', 1), (2, '无敌战神', '男', 3), (3, '李凌天', '男', 2), (4, '宇宙无敌', '男', 99)][(1, '帅哥', '男', 1), (2, '无敌战神', '男', 3), (3, '李凌天', '男', 2)]"""
except sqlite3.Error as e: print('数据查询发送错误：{}'.format(e))con.rollback()
finally:if cursor:cursor.close()if con:con.close()

以上代码段，都是经过运行调试后并且解除注释后所得到的代码，所以有些变量存在重名，若要运行代码，请一个操作一个操作的运行，其他操作代码块注释。

        提示：在SQL语句中 ? 是占位符，用来占位，在execute（）方法里面传参，也可以直接使用字符串拼接，不过用字符串拼接会被人利用，通过SQL注入获取信息，所以SQL语句在传参的时候尽力标准化传参，避免SQL注入。

        总结：SQLlite数据库还有很多的细节操作，这里不做详述。（请自己查阅相关操作，以补充自己不足的知识点！）

知识点20：

Python中多线程（threading模块）的使用。

        首先，在里面要说明一下什么是线程和进程，举个例子，进程就像一列火车，进程是整个火车，而线程就是火车的一节车厢，就是说进程包含线程，并且进程可以有多个线程。在举个例子，进入应用商店我们要下载一个软件，点击下载之后软件就开始下载了，这个时候用户依旧可以去浏览其他软件，也可以去下载其他软件，那么整个软件运行就相当于一个进程，而你整个下载操作是一个线程，然后你去浏览其他软件的操作又是一个线程，不然按照道理讲，用户不可能一边去浏览其他软件，一边下载软件，而如果使用了线程就完全可以了，因为多线程可以同时执行。

        线程的基本使用如下

import threading
import timeprint(threading.active_count()) # 查看当前活跃状态的线程个数
print(threading.main_thread()) # 查看主线程对象
print(threading.current_thread()) # 返回当前的Thread 对象# 创建子线程
# 1. 线程体的两种方式：自定义函数做线程体 、 自定义线程类做线程体
def run():t = threading.current_thread()for i in range(3):print('这是第{}个线程，名字叫{}'.format(i,t.name))time.sleep(2)
# 2.创建线程对象
t1 = threading.Thread(target=run,name='我是线程')
t2 = threading.Thread(target=run,name='我是帅哥线程')
# 启动线程
t1.start()
t2.start()# 使用自定义线程类做函数体
class ThreadBody(threading.Thread):def __init__(self, name):# super(ThreadBody, self).__init__()super().__init__()self.name = namedef run(self):t = threading.current_thread()for i in range(3):print('这是第{}个线程，名字叫{}'.format(i, t.name))time.sleep(2)
t1 = ThreadBody(name='我是帅哥线程')
t2 = ThreadBody(name='我是美女线程')
# t1 = ThreadBody('我是帅哥线程')
# t2 = ThreadBody('我是美女线程')
t1.start()
t2.start()# join(timeout=None) 方法的使用 timeout: 设置超时时间# 1. 定义一个函数体
values = []
def RunBody():print('开始执行线程')for i in range(3):print('线程执行第{}次'.format(i))values.append(i)time.sleep(2)print('线程执行完毕！')
t1 = threading.Thread(target=RunBody,name='帅哥线程')
t1.start()
# 主线程被被阻塞
t1.join()
# 开始执行主线程
print('value={}'.format(values))
# 主线程执行完毕
print('主线程执行完毕！')# 运行结果：
开始执行线程value=[]
主线程执行完毕！线程执行第0次
线程执行第1次
线程执行第2次
线程执行完毕！# 加t1.join()阻塞后的运行结果
开始执行线程
线程执行第0次
线程执行第1次
线程执行第2次
线程执行完毕！
value=[0, 1, 2]
主线程执行完毕！

以上就是线程的创建、两种线程体的创建方式、已经使用join()方法对线程进行阻塞，直到子线程完成后在完成主线程。

        注意：以上内容比较适合开始学习Python的朋友阅读，并不适合进阶，很多一些功能没有细讲，愿我们都是学习者，在学习的路上从不停止！