类和正则表达

1、面对对象的总结

•面向对象是一种编程方式，此编程方式的实现是基

于对 类 和 对象 的使用

•类 是一个模板，模板中包装了多个“函数”供使用（可以讲多函数中

公用的变量封装到对象中）

•对象，根据模板创建的实例（即：对象），实例用于调用被包装在

类中的函数

•属性：类中所定义的变量

• 方法：类中所定义的函数

•实例化：通过类创建对象的过程

 总结：对象的抽象是类，类的具体化就是对象；也可以说类的实例化是对象，对象是类的实例。

2、特征

1. 封装

(1) 概念：封装是将对象运行时所需的资源封装在程序对象中。简单来说，就是将内容封装起来，以后再去调用被封装的内容。

(2) 调用封装的内容有2种方法：

——通过对象直接调用

——通过self间接调用

•经典代码

# -*- encoding:utf-8 -*-
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def detail(self): 
        print(self.name)
        print(self.age)

obj1 = Student('Jack',15) 
print(obj1.name) 
print(obj1.age)

obj2 = Student('Sahra',13)
obj2.detail()

2. 继承

(1) 概念：继承可以使得子类别具有父类别的各种属性和方法，而不需要再次编写相同的代码。在令子类别继承父类别的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类别的原有属性和方法，使其获得与父类别不同的功能。

(2) 多继承

注：Python的类可以继承多个类，而Java和C#中则只能继承一个类

Python的类如果继承了多个类，那么其寻找方法的方式有2种：

 

• 当类为经典类时会按照深度优先方式查找

• 当类为新式类时会按照广度优先方式查找

 

•经典代码

# -*- encoding:utf-8 -*-


class Person(object):   
    def talk(self):       
        print("Person can talk.")
class Chinese(Person):  
    def talkC(Person):    
        print("Chinese can talk Mandarin.")
class Characters(Chinese):  
    def people(self):        
        print("Chinese are clever and diligent.")
class American(Person):   
    def talkA(self):       
        print("American can talk English.")

C = Characters() 
A = American()  
C.talk()        
A.talkA()        
C.people()

3. 多态

概念：多态指同一个实体同时具有多种形式，在赋值之后，不同的子类对象调用相同的父类方法，产生的执行结果不同。

•经典代码

# -*- encoding:utf-8 -*-
  import abc
   
  class Animal(metaclass=abc.ABCMeta):
   
      @abc.abstractmethod
      def talk(self):
          pass
  
 class People(Animal):
     def talk(self):
         print('say hello')
  
 class Dog(Animal):   
     def talk(self):
         print('say wangwang')
  
 class Pig(Animal):  
     def talk(self):
         print('say aoao')
  
  
 peo = People()
 dog = Dog()  
 pig = Pig()  
 peo.talk()    
 dog.talk()
 pig.talk()

三、三维向量类

(1) 简述：实现向量的加减法、向量与标量的乘除法。

(2) 代码实现：

#  --coding: gb2312--
''' 三维向量 '''

class vector3:
    def __init__(self, x_ = 0, y_ = 0, z_ = 0): #构造函数
        self.x = x_
        self.y = y_
        self.z = z_

    def __add__(self, obj):      #重载+作为加号
        return vector3(self.x+obj.x, self.y+obj.y, self.z+obj.z)

    def __sub__(self, obj):      #重载-作为减号
        return vector3(self.x-obj.x, self.y-obj.y, self.z-obj.z)

    def __mul__(self,n):         #重载*作为点乘
        return vector3(self.x*n, self.y*n, self.z*n)

    def __truediv__(self, obj):  #重载/作为除法
        return vector3(self.x/n, self.y/n, self.z/n)

    def __str__(self):
        return str(self.x)+','+str(self.y)+','+str(self.z)

if __name__ == "__main__":
    n = int(input("请输入一个标量："))
    a,b,c = map(int,input("请输入第一个向量：").split())
    v1 = vector3(a,b,c)
    a,b,c = map(int,input("请输入第二个向量：").split())
    v2 = vector3(a,b,c)
    print("两向量的加法：",v1 + v2)
    print("两向量的减法：",v1 - v2)
    print("标量与向量的乘法：",v1 * n)
    print("标量与向量的除法：",v1 / n)

2. 英文字符串处理

 (1) 简述：用户输入一段英文，得到这段英文中所以长度为3的单词，并去除重复的单词。

 (2) 代码实现：

方法一： 使用 jieba 库

# -*- encoding:utf-8 -*-
''' 将一段英文中长度为3的单词输出，并去掉重复的单词 '''

import jieba
class ProString:
    Str = ""
    Dict = {}
    Ls = []
    def __init__(self,string,length = 3): #初始化
        self.string = string
        self.length = length
        
    def SignalWord(self):        #去除重复的单词
        self.words = jieba.lcut(self.string)   #jieba分词
        for _ in self.words:                   #与词频算法相似
            self.Dict[_] = self.Dict.get(_,0) + 1
        del(self.Dict[' '])                 #删除空格项
        self.Ls = list(self.Dict.keys())    #字典类型转化成列表类型
        self.StubbenWord(self.Ls)

    def StubbenWord(self,Ls):       #利用去除重复的单词，得到固定长度的单词
        for _ in Ls:
            if len(_) == self.length:
                self.Str += _ + ' '
        self.printf(self.Str)
        
    def printf(self,Str):
        print("处理后的字符串为：",Str)
            
if __name__ == "__main__":
    str = input("请输入字符串：")
    process = ProString(str,3)
    process.SignalWord()

方法二： 使用 re库 (正则表达式)

# -*- encoding:utf-8 -*-
''' 将一段英文中长度为3的单词输出，并去掉重复的单词 '''

import re
class ProStr:
    a = []
    def __init__(self, words, length = 3):
        self.words = words
        self.length = length

    def process(self):
        word_list = re.split('[. ]+',self.words)
        for _ in word_list:
            if len(_) == self.length:
                if _ not in self.a:
                    self.a.append(_)
            else:
                continue
        self.printf()

    def printf(self):
        print("处理后的字符串为：", end = '')
        for _ in range(len(self.a)):
            print(self.a[_],end=' ')

if __name__ == "__main__":
    words = input("请输入字符串：")
    process = ProStr(words, 3)
    process.process()