class vecter3:
    def __init__(self,x=0,y=0,z=0):
        self.x = x
        self.y = y
        self.z = z
 
    def __add__(self,n):      # +  __add__意味着+号，系统自动识别 
        return vecter3(self.x+n.x, self.y+n.y, self.z+n.z)
 
    def __sub__(self,n):
        return vecter3(self.x-n.x, self.y-n.y, self.z-n.z)
 
    def __mul__(self,n):
        return vecter3(self.x*n, self.y*n, self.z*n)
 
    def __truediv__(self, n):
        return vecter3(self.x/n, self.y/n, self.z/n)
 
    def __str__(self):     ##供print打印的字符串
        return str(self.x)+\',\'+str(self.y)+\',\'+str(self.z)
 
        
if __name__ == "__main__":
    n = int (input("请输入一个变量n："))
    a,b,c = map(int,input("请输入第一个向量：").split())
    v1 = vecter3(a,b,c)
    a,b,c = map(int,input("请输入第二个向量：").split())
    v2 = vecter3(a,b,c)
    print("两向量的加法：",v1 + v2)
    print("两向量的减法：",v1 - v2)
    print("标量与向量的乘法：",v1 * n)
    print("标量与向量的除法：",v1 / n)

# -*- encoding:utf-8 -*-
\'\'\' 将一段英文中长度为x的单词输出，并去掉重复的单词 \'\'\'
import jieba
class proString:
    Str = ""
    Dict = {}  #花括号{}：代表dict字典数据类型，字典是Python中唯一内建的映射类型
    Ls = []   #中括号[]：代表list列表数据类型，列表是一种可变序列
    def __init__(self,string,length): #初始化长度固定
        self.string = string
        self.length = length
        
    def SignalWord(self):        #去除重复的单词
        self.words = jieba.lcut(self.string)   #jieba分词,精确模式返回一个列表 如：[\'I\', \' \', \'a\',  \'good\']
        #print(self.words)
        for i in self.words:                   #与词频算法相似
            self.Dict[i] = self.Dict.get(i,0) + 1  #字典的运用 .get(<key>.<default>)统计词频P167
            print(self.Dict)  #查看字典                  {\'I\': 2, \' \': 6, \'am\': 1, \'a\': 1, \'good\': 1, \'boy\': 1, \'!\': 1}
        del(self.Dict[\' \'])                 #删除空格项
        print(self.Dict)   #查看删除空格后的字典 {\'I\': 2, \'am\': 1, \'a\': 1, \'good\': 1, \'boy\': 1, \'!\': 1}
        self.Ls = list(self.Dict.keys())    #字典类型转化成列表类型
        print(self.Ls)   #查看列表   [\'I\', \'am\', \'a\', \'good\', \'boy\', \'!\']
 
    def StubbenWord(self):       #利用去除重复的单词，得到固定长度的单词
        for i in self.Ls:
            if len(i) == self.length:
                self.Str += i +\' \'   #加空格分隔
        return self.Str
            
if __name__ == "__main__":
    str1 = input("请输入字符串：")
    n = eval(input("请输入固定单词长度:"))
    Po = proString(str1,n)
    Po.SignalWord()
    print("处理后的字符串为：" + Po.StubbenWord())

import re
class proString:
    Dict = {}  #定义一个字典类型数据
    Ls = []     #列表  静态变量 全局可用
 
    def __init__(self,string,length):
        self.string = string
        self.length = length
 
    def Fixed_length_word(self):
        self.words = re.findall(r\'\b[a-z/A-Z]{%s}\b\'%self.length,self.string)
        #print(self.words)  #输出为 [\'Boy\', \'Boy\', \'boy\', \'BOY\'] 有重复
        for i in self.words: 
            self.Dict[i] = self.Dict.get(i,0) +1     #单词变为 字典类型数据
        self.Ls =  list(self.Dict.keys())   #提取字典中在keys位置的单词（相当于去重复）
        #print(self.Ls)    #输出为  [\'Boy\', \'boy\', \'BOY\']
        Str = ""  #定义一个字符串
        for i in self.Ls:    #把上面的列表转换为字符串
            Str += i + \' \'   #用空格分隔
        return Str
 
if __name__ == "__main__":       
    str = "I I  am a good Boy Boy boy BOY!"
    leng = eval(input("请输入固定单词长度："))
    Po = proString(str,leng)
    print("处理后的字符串为:"+Po.Fixed_length_word())

封装测试例子
class Foo:#定义一个类
    def __init__(self,name,age): #称为构造方法，根据类创建对象时自动执行
        self.name = name      #name和age是对象的 属性
        self.age = age
    def detail(self):
        print(self.name)
        print(self.age)
 
obj.Foo(\'wupeiqi\',18)
obj.detail() 
 
>>>>输出结果 wupeiqi 17

class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def detail(self):
        print(self.name)
        print(self.age)
 
class son(Foo):#子类继承父类，即拥有了父类的所有方法
    pass
obj = son(\'wupeiqi\',17)
obj.detail()
 
》》》输出结果wupeiqi 17

>>> class A:
    def __init__(hahaha, v):
        hahaha.value = v
    def show(hahaha):
        print(hahaha.value)
>>> a = A(3)
>>> a.show()
3

# -*- encoding:utf-8 -*-
\'\'\' 实例说明 —— 混入机制 \'\'\'
import types
class Stu:                  #定义类
    where = \'China\'       #定义类属性，属于静态字段，只保存于类中
    def __init__(self, c):
        self.name = c      #定义实例属性
 
stu = Stu("wupeiqi")             #实例化对象
print(stu.name, Stu.where)       #查看实例属性和类属性的值
Stu.where = \'Guangdong\'                    #修改类属性的值
Stu.age = 18                  #动态增加类属性，属于静态字段，只保存于类中
stu.name = "woshiname"                 #修改实例属性的值
print(Stu.where, Stu.age, stu.name)
 
def setGender(self, s):
    self.Gender = s
 
stu.setGender = types.MethodType(setGender, stu) #动态增加成员方法
stu.setGender(\'boy\')                                 #调用成员方法
print(stu.Gender)
 
#利用特殊的类属性查看类与对象的属性与行为 
print("Stu类的属性与行为如下：\n",Stu.__dict__)  #字典属性
print("\n")
print("stu对象的属性与行为如下：\n",stu.__dict__)
 
》》》输出如下
wupeiqi China
Guangdong 18 woshiname
boy
Stu类的属性与行为如下：
{\'__module__\': \'__main__\', \'where\': \'Guangdong\', \'__init__\': <function Stu.__init__ at 0x000002CDD020A9D8>, \'__dict__\': <attribute \'__dict__\' of \'Stu\' objects>, \'__weakref__\': <attribute \'__weakref__\' of \'Stu\' objects>, \'__doc__\': None, \'age\': 18}
 
stu对象的属性与行为如下：
{\'name\': \'woshiname\', \'setGender\': <bound method setGender of <__main__.Stu object at 0x000002CDD0224320>>, \'Gender\': \'boy\'}