re模块

1. 字符串匹配
2. 列表 = findall(正则表达式，待匹配的字符串) 找所有
   • 结果集 = search 找第一个，结果集.group()
   • 结果集 = match 从第一个字符开始匹配,结果集.group()
3. 编译结果 = compile(正则表达式) 编译 加快执行效率，节省时间
   • 编译结果.findall
   • 编译结果.finditer
   • 编译结果.search
4. 迭代器 = finditer(正则表达式，待匹配的字符串) 返回一个迭代器，节省空间for i in 迭代器：i是一个结果集，通过i.group才能取到结果
5. 替换后的字符串 = sub(正则,新的值,待匹配的字符串)（替换后的字符串,替换了多少次） =subn(正则,新的值,待匹配的字符串)
6. 列表 = split(正则,待切割的字符串)
   • 被切割的内容
     • 如果正则是带分组的，那么保留被切掉的内容
     • 如果正则是不带分组的，那么不保留被切掉的内容
7. 分组
   • findall 会优先显示分组中的内容
   • 取消分组优先 (?:正则)
   • ret = search()
     • ret.group(1) 获取第一组中的内容
   • 分组命名
     • (?P正则)
   • 引用分组
     • (?P=name)
     • \1 \2
8. 使用正则做匹配的时候，往往要匹配的东西很普通，容易和我们不需要的内容混在一起
9. 我们就通过把不需要的东西也匹配出来 来把想要的内容放在分组中方便获取

面向对象

1. 人
   • 名字，血量，攻击力，性别
2. 狗
   • 名字，血量，攻击力，品种

属性很有可能是不统一

def Person(name,hp,ad,sex):   # 模子
   dic = {'name':name,'blood':hp,'attack':ad,'sex':sex}

   def fight(dog):  # 攻击  属于人
       # 狗掉血，就是人的攻击力
       dog['blood'] -= dic['attack']
       print('%s打了%s，%s掉了%s血' % (dic['name'], dog['name'], dog['name'], dic['attack']))
   dic['fight'] = fight
   return dic

def Dog(name,hp,ad,kind):
   dic = {'name': name, 'blood': hp, 'attack': ad, 'kind': kind}

   def bite(person):  # 咬 属于狗
       person['blood'] -= dic['attack']
       print('%s咬了%s，%s掉了%s血' % (dic['name'], person['name'], person['name'], dic['attack']))

   dic['bite'] = bite
   return dic

互相打
alex = Person('alex',20,1,'不详')
print(alex)
hei = Dog('小黑',3000,10,'哈士奇')
print(hei)
alex['fight'](hei)
hei['bite'](alex)

通过两个模子 捏出两个具体的角色

抽象 ：只能知道有哪些属性

具体 ：可以描述他的属性的值的

1. 给两个特定的属于特定角色的方法 设置了他的使用范围
2. 让其他角色不能随意调用属于固定角色的方法
3. 先思考这个程序中有几个角色
4. 然后描述这个角色 属性和动作
5. 把这个属性和动作都装到一个角色中
6. 面向对象编程

面向对象语法

1. 对象 ：具有具体的属性值的实际存在的例子 # 实例
2. 类 ：具有相同方法和属性的一类事物

def 函数:
    pass

class Dog:
    pass

class Dog:
    变量 = 1000
    变量2 = 'abc'
    变量3 = [(1,2),(3,4)]
#查看类当中的变量，方法一
print(Dog.__dict__['变量'])
print(Dog.__dict__['变量2'])
print(Dog.__dict__['变量3'])
#查看方法二（常用）
print(Dog.变量)
print(Dog.变量2)
print(Dog.变量3)

#每一只狗都需要有自己的属性
class Dog:   # 狗模子  -- 类
    a = 1000  # 静态变量 这个类中的变量 是所有的对象共享的值
    def __init__(self,name,hp,ad,sex):
        print('执行我啦')
        self.__dict__['name'] = name
        self.__dict__['blood'] = hp
        self.__dict__['ad'] = ad
        self.__dict__['sex'] = sex
        print(self.__dict__)

alex = Dog('alex',20,10,'不详')  # 具体的狗 对象 实例化的过程
alex = Dog('alex',20,10,'不详')
print(alex.__dict__['name'])
print(alex.__dict__['blood'])

• 对象 也是实例
• 创建一个对象也是创建实例
• 实例化的过程 ：
  1. 开辟了一块空间，创造了一个self变量来指向这块空间
  2. 调用init,自动传self参数，其他的参数都是按照顺序传进来的
  3. 执行init
  4. 将self自动返回给调用者

class Dog:
    def __init__(self,name,hp,ad,kind):  # 初始化方法
        self.name = name   # 实例变量   对象属性
        self.blood = hp
        self.ad = ad
        self.type = kind

class Person:
    a = 1000   # 静态变量
    def __init__(self,name,hp,ad,sex):  # 初始化方法
        self.name = name   # 实例变量   对象属性
        self.blood = hp
        self.ad = ad
        self.sex = sex

    def fight(self,dog):  # 动态变量  方法
        # 狗掉血，就是人的攻击力
        dog.blood -= self.ad
        print('%s攻击了%s，%s掉了%s点血'%(self.name,dog.name,dog.name,self.ad))
alex = Dog('alex',20,10,'不详')   # alex 对象 实例
太白 = Person('太白',300,20,'male')  # 太白 对象 实例
print(alex.blood)
太白.fight(alex)  # Person.fight(太白,alex)
print(alex.blood)

1. 类名可以调用所有定义在类中的名字
   • 变量
   • 函数名
2. 对象名 可以调用所有定义在对象中的属性
   • 在init函数中和self相关的
   • 调用函数的，且调用函数的时候，会把当前的对象当做第一个参数传递给self

清晰一下面向对象的例子

class Dog:
    def __init__(self,name,blood,ad,kind):
        self.name = name  # 向对象的内存空间中添加属性
        self.hp = blood   # 可以通过self在类的内部完成
        self.ad = ad
        self.kind = kind

hei = Dog('小黑',300,20,'哈士奇')
hua = Dog('小花',400,30,'萨摩耶')
print(hei.name)
print(hei.ad)
print(hei.kind)
hei.food = '单身狗粮'  # 也可以通过对象名在类的外部完成
hei.hp = 305  # 也可以在类的外部通过对象名来修改属性的值
print(hei.__dict__)
print(hei.hp)
del hei.hp            # 删除属性
print(hei.__dict__)

print(hua.name)
print(hua.ad)
print(hua.kind)

class Dog:
    def __init__(self,name,blood,ad,kind):
        self.name = name  # 向对象的内存空间中添加属性
        self.hp = blood   # 可以通过self在类的内部完成
        self.ad = ad
        self.kind = kind

    def bite(self,person):
        person.hp -= self.ad
        print('%s攻击了%s，%s掉了%s点血' % (self.name, person.name, person.name, self.ad))

class Person:
    def __init__(self,name,hp,ad,sex):
        self.name = name
        self.hp = hp
        self.ad = ad
        self.sex = sex

    def fight(self,dog):
        dog.hp -= self.ad
        print('%s攻击了%s，%s掉了%s点血'%(self.name,dog.name,dog.name,self.ad))

hei = Dog('小黑',300,20,'哈士奇')
alex = Person('alex',20,1,'不详')
alex.fight(hei)
print(hei.hp)
hei.bite(alex)
print(alex.hp)

面向对象用途

• 购物车
  • 商品
    • 名字 价格 库存数
  • 用户
    • 用户名 密码 钱 购物车 订单列表
    • 查看商品列表
    • 添加商品到购物车
    • 删除商品
    • 结算
    • 退出

一切皆对象

1. list 类
2. [1,2,3] 对象
3. int 类
4. a = 1
5. dict {'k':'v'}

数据类型 也是类

• 对象 就是具体的数字
• 所以有的列表都能够使用列表的方法
• 所以有的数字都能够使用列表的方法

圆形类

属性 ：半径
方法 ：计算周长(2pir) 计算面积(pir^2)
from math import pi
print(pi)
class Circle:
   def __init__(self,r):
       self.r = r
   def area(self):
       return pi * self.r**2
   def perimeter(self):
       return 2*self.r*pi
c1 = Circle(5)
c2 = Circle(15)
print(c1.area())
print(c1.perimeter())
print(c2.area())
print(c2.perimeter())