re模块+面向对象

re模块

re:其实就是带有特殊语法的字符串

语法：单个字符和多个字符

单个字符：

\d是匹配所有的数字

\D是匹配所有的非数字

\s是所有的换行符，制表符，空白等，回车符

\S是所有费换行符，空白和制表符等

\w字母数字下划线

\W所有非字母数字下划线

.匹配所有单个字符，（不包括换行符）

多个字符：

+==》{1，n}n是代表所取的个数，是贪婪匹配，能匹配多个就匹配多个

*==》{0，n}n是代表所取的个数，是贪婪匹配，能匹配多个就匹配多个

？==》{0，1}是贪婪匹配，也是能匹配多个就匹配多个

*****************************************************************************************************

+？结合在一起就是非贪婪匹配，是{1，n}但是能不匹配就不匹配，一般结合^$来使用，也是非单个字符匹配

*？结合在一起就是非贪婪匹配，是{0.1}，也是要结合^$在一起使用，非单个字符是没有意义的

.+:所有的匹配，除了换行符，贪婪匹配，最少匹配要看匹配前面的匹配对象

.*:所有的匹配，除了换行符，但是是从0开始，最少匹配是空格

.+?:是非贪婪匹配

.*?:也是非贪婪匹配，匹配多少还是要看匹配前面的匹配对象

####所谓的贪婪非贪婪指的是要匹配的字符，+？这个是前面的必须全部匹配，可以不取后面的  *？是可以将前面要匹配的少一个字符，可以不取后面的

多行：

re.S能让.也可以匹配到\n

re.M多行匹配，可以全部读取出来

re.I不区分大小写匹配

分组：

1.从左往右数左括号，对‘（’进行编号，自己的分组从1开始，group（0）代表匹配的目标整体。

2.（？：）取消所属分组，（）就是普通的（），可以将里面的信息作为整体包裹，但是不产生分组

替换sub

1.不参与匹配的原样带下

2.参与匹配的都会被替换成指定字符串

3.在指定字符串\num会拿到具体分组（注意转义）

4.其他字符都是原样字符串

切分split：将字符串切分成单个字符串列表

面向对象

1、面向过程编程
核心是"过程"二字，过程指的是解决问题的步骤，即先干什么再干什么
基于该思想编写程序就好比在编写一条流水线，是一种机械式的思维方式

如所写的函数等就是直接面向过程，解决问题，就是直接自己去解决问题，没有找中间

优点：复杂的问题流程化、进而简单化
缺点：可扩展性差

2、面向对象
核心"对象"二字，对象指的是特征与技能的结合体，
基于该思想编写程序就好比在创造一个世界，你就是这个世界的上帝，是一种
上帝式的思维方式

优点：可扩展性强
缺点：编程的复杂度高于面向过程
所写的东西就是直接面向对象，不在从过程考虑问题，只考虑找到怎么找到一个对象解决这个问题

相同点：两者都是最终都是要去解决问题

区别：面向过程：直接解决问题，将问题流程化，进而简单化。    面向对象：直接找到解决问题的对象，让这个对象去自己想办法解决

重点：面向对象的核心体现是将数据和处理数据的程序封装到对象中

其实就是将属性和方法都放到封装到对象里面，只管对象，对象自己管自己的里面的东西

*函数和方法的区别

函数：通过函数名直接调用

方法：通过附属者.语法调用

变量：通过变量名访问变量值

属性：通过附属者.语法来访问变量值

名称空间

函数可以产生自己的局部名称空间，文件可以产生自己的全局名称空间（我们平时所说的全局名称空间其实就是文件的全局名称空间）

名称空间就是存放名字和地址的一个字典，所以key对应的value就是名字：地址{‘name':地址}

但是如果是int和float，由于是不可变类型，所以直接显示值，其他的显示的是存放值的地址

查看re和函数的名称空间

import re
print(re.__dict__) #{'__name__':'re','__doc__':'地址'}
def fn():
    pass
print(fn.__dict__) #{}未定义就是一个空列表

_______________________________________________________________________________
可以添加内容

import test#文件只要被引用，里面的内容就会直接被打印，文件导入执行三步骤！

print(test.__dict__)#{'__name__':'test','__doc':'None'.....}文件也有自己的名称空间

import re
res=re.__dict__['name']='owen'
rea=re.__dict__['sys']='测试'
ren=re.__dict__
ren.update(name='egon')
print(re.sys)
print(re.__dict__)
#所以可以对名称空间进行字典的操作

————————————————————————————————————————————————————————————————————————————————
可以直接在名称空间里面添加一个匿名函数，引用

#value存的是地址，直接引用匿名函数，不加（）就是函数对象，结果就是对象地址
re.__dict__['action']=lambda x:x
print(re.__dict__['action'])#<function <lambda> at 0x000001C922D91EA0>

#在加上（）后就是函数运行后的结果，所以是100
print(re.__dict__['action'](100))#100

++++++++++++++++++++++++++++++++++++++++++++++

可以直接把一个函数方法封装在另一个名称空间里，通过.语法调用可以直接调用该方法

# def fn():
#     pass
# print(fn.__dict__)#{}
# fn.name='fn函数'
# # print(fn.name)#fn函数   可以直接通过.语法加key值
#
# def tst():
#     print('成为海贼王的男人')
# fn.action=tst#直接给fn封装一个tst函数方法
# fn.action()

                                      类与对象的概念
类：具有相同特征和行为个体集合的抽象
对象：有特征和行为的具体的个体。就是类的具体体现
区别：两个人同时思考一个名字，想到的是同一个物体，就一定是对象，反之，一定是类

语法
类的声明：
class：关键字
class 类名：
    pass
##对象的产生：对象的实例化
对象1=类名（）
对象2=类名（）
对象3=类名（）

类与对象都有自己独立的名称空间，每一个被实例化出来的对象，名称空间也是独立存在
所以类与对象都能额外添加属性（变量）和方法（函数）
重点：类随着文件的加载而加载（类一旦被加载），就会进入类的内部，执行类内部的代码（但是不进入到对象中）

属性：通过附属者.语法来访问的变量值

####对象查找属性顺序为：优先自身，自身没有的进入类

#对象查找属性的顺序
class People:
    identify='人类'
    def study(self):
        print('好好学习，天天向上')
p1=People()#产生对象p1
p2=People()#产生对象p2
p1.identify='新新人类'
print(p1.identify)#新新人类   访问的是自己的identify
print(p2.identify)#人类   未定义访问类中的identify
del p1.identify#删除自己的identify后
print(p1.identify)#人类  访问的是类中的identify
p2.identify='机器人'
print(p2.identify)#机器人
p2.__dict__.clear()
print(p2.identify)#人类
People.study((1,2,3))#好好学习，天天向上

————————————————————————————————————————————————————————————
类产生对象，类是由元类产生，元类？