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)
2）if __name__ == '__main__' 如何正确理解
详细介绍链接：http://blog.konghy.cn/2017/04/24/python-entry-program/
Second.字符串处理
（1）简述：用户输入一段英文，得到这段英文中所以长度为x(用户输入)的单词，并去除重复的单词。
代码如下（分词法）：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
# -*- 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())
|
（2）正则表达式法：
代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
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())
|
一.面向对象总结：
（1）三要素：封装，继承，多态 详细介绍链接：https://www.jianshu.com/p/68ab35298a59
one.封装：所谓封装，也就是把 客观事物 封装成 抽象的 类，并且 类 可以把自己的数据和方法只让可信的类或者对象操作。 简而言之就是将内容封装到某个地方，以后再去调用被封装在某处的内容
测试代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
封装测试例子
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
|
two.继承：将多个类共有方法提取到父类，子类仅需继承父类而不必一一实现每个方法 注：除了子类和父类的称谓，你可能看到过 派生类 和 基类 ，他们与子类和父类只是叫法不同而已。
测试代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
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
|
需要说明的是：python可以继承多个类，如果python继承了多个类那么它有两种方式寻找，分别是 深度优先和广度优先。以后再作详细介绍
three.多态：所谓多态就是指一个类实例的 相同方法 在不同情形有不同 表现形式
（2）类成员的修饰符：下划线
xxx ：公有成员，在任何地方都能访问
__xxx or ...__xxx：私有成员，只有类对象自己能访问，子类对象不能直接访问，但在对象外部可以通过“对象名._类名__xxx”这样的特殊方式来访问。
_xxx：受保护成员，不能用'from module import *'导入
__xxx__：系统定义的特殊成员
注：Python中不存在严格意义上的私有成员
（3）名词解析
1. 类：类就是一个模板，模板里可以包含多个函数，每个函数都能实现一些功能。
2. 对象：根据模板(类)创建的实例，通过这个实例(对象)可以执行类中的函数。
3. 属性：类中所定义的变量
4. 方法：类中所定义的函数
5. 实例化：通过类创建对象的过程
总结：对象的抽象是类，类的具体化就是对象；也可以说类的实例化是对象，对象是类的实例，例如 奥斑马和梅西可以抽象为人（类），人的实例化是奥斑马和梅西，此外，类也可以作为 其父类的实例化，例如：人和猫可以抽象为动物，动物的实例化是人和猫。
（4）类的成员：字段，方法，属性
注：类和对象在内存中如何保存？
答：类以及类中的方法在内存中只占一份内存，而根据类创建的每一个对象在内存中都需要一份内存。如下图：
（5）类的特殊成员
(1) __init__：构造方法，通过类创建对象时，自动触发执行。
(2) __del__：析构方法，当对象在内存中被释放时，自动触发执行，此方法一般无需定义。
(3) 类的属性
dir(类名)：查出的是一个名字列表
类名.__dict__：查出的是一个字典，key为属性名，value为属性值
(4) 特殊的类属性
类名.__name__：类的名字(字符串)
类名.__doc__：类的文档字符串
类名.__base__：类的第一个父类(在讲继承时会讲)
类名.__bases__：类所有父类构成的元组(在讲继承时会讲)
类名.__dict__：类的字典属性
类名.__module__：类定义所在的模块
类名.__class__：实例对应的类(仅新式类中)
（6）self
在Python中，在类中定义实例方法时将第一个参数定义为“self”只是一个习惯，而实际上类的实例方法中第一个参数的名字是可以变化的，而不必须使用“self”这个名字，尽管如此，建议编写代码时仍以self作为方法的第一个参数名字。
|
1
2
3
4
5
6
7
8
|
>>>
class
A:
def __init__(hahaha, v):
hahaha.value = v
def show(hahaha):
print(hahaha.value)
>>> a = A(3)
>>> a.show()
3
|
7）混入机制
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
# -*- 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'
}
|