一、面对对象思想
(1)大家肯定听过 Python 中”一切皆对象“的说法,但可能并不了解它的具体含义,只是在学习的时候听说 Python 是面向对象的编程语言,本节将向大家详细介绍 Python 面向对象的含义。
- 面向对象编程是在面向过程编程的基础上发展来的,它比面向过程编程具有更强的灵活性和扩展性。
- 面向对象编程(Object-oriented Programming,简称 OOP),是一种封装代码的方法。其实,在前面章节的学习中,我们已经接触了封装
- 代码封装,其实就是隐藏实现功能的具体代码,仅留给用户使用的接口,就好像使用计算机,用户只需要使用键盘、鼠标就可以实现一些功能,而根本不需要知道其内部是如何工作的。
- 面向对象编程,也是一种封装的思想,它可以更好地模拟真实世界里的事物(将其视为对象),并把描述特征的数据和代码块(函数)封装到一起。
(2)为什么说”一切皆对象“
a = 2
print(id(a))
print(type(a))
b = 3
print(id(b))
print(type(b))
b = 2
print(id(b) #输出结果如下
1441688672
<class 'int'>
1441688704
<class 'int'>
1441688672
- 如上述代码中,实际上整形数据2、3其实都是 integer class(整形类的一个实例对象),而 a、b只不过是这些对象的一个标签,可以简单理解为2、3是两个人,而a、b分别是他们的名字。就算把3的名字给了2这个人,那2这个人也是不会变的。这里的变指的是他们在内存中的地址,也就是上面例子中的 id() 。
二、类的理解
- 类:用来描述具有相同的属性和方法的对象的集合。可以理解是一个模板,通过它可以创建出无数个具体实例。
- 对象:类并不能直接使用,通过类创建出的实例(又称对象)才能使用。这有点像汽车图纸和汽车的关系,图纸本身(类)并不能为人们使用,通过图纸创建出的一辆辆车(对象)才能使用。
- 对象和类的关系:类和对象的关系就像模具和铸件的关系,类的实例化的结果就是对象,而对象的抽象体就是类。
- 属性:类中的所有变量称为属性。例如下面的 Student 类中的 self.name 和 self.score
- 方法:类中的所有函数通常称为方法。不过,和函数所有不同的是,类方法至少要包含一个 self 参数(后续会做详细介绍)。类方法无法单独使用,只能和类的对象一起使用。
类和实例
面向对象最重要的概念就是类(Class)和实例(Instance),必须牢记类是抽象的模板,比如 Student类,而实例是根据类创建出来的一个个具体的“对象”,每个对象都拥有相同的方法,但各自的数据可能不同。
仍以 Student 类为例,在 Python 中,定义类是通过 class 关键字:
class Student(object):
pass
class 后面紧接着是类名,即 Student,类名通常是大写开头的单词,紧接着是(object),表示该类是从哪个类继承下来的,继承的概念我们后面再讲,通常,如果没有合适的继承类,就使用 object类,这是所有类最终都会继承的类。
1.类定义:
- class定义类
- class 后面加 类名称 加 () 加 :
2.类名称定义规范:
- 不要以纯数字命名
- 不要以python中保留字符(关键字)来命名
- 不要以文件名命名
- 不能出现特殊字符
- 要简短且见名知义
- 当类名称中有多个单词时,应采用驼峰式(每个单词首字母大写) --> XinFangShuo()
定义好了 Student 类,就可以根据 Student 类创建出 Student 的实例,创建实例是通过类名+()实现的:
bart = Student()
可以看到,变量 bart 指向的就是一个 Student 的实例,而 Student 本身则是一个类。
由于类可以起到模板的作用,因此,可以在创建实例的时候,把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法,在创建实例的时候,就把 name,score 等属性绑上去:
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
注意:特殊方法“__init__”前后分别有两个下划线!!!
注意到__init__方法的第一个参数永远是 self,表示创建的实例本身,因此,在__init__方法内部,就可以把各种属性绑定到 self,因为 self 就指向创建的实例本身。
有了__init__方法,在创建实例的时候,就不能传入空的参数了,必须传入与__init__方法匹配的参数,但 self 不需要传,Python 解释器自己会把实例变量传进去:
bart = Student('Bart Simpson', 59)
和普通的函数相比,在类中定义的函数只有一点不同,就是第一个参数永远是实例变量 self,并且调用时,不用传递该参数。除此之外,类的方法和普通函数没有什么区别,所以,你仍然可以用默认
参数、可变参数、关键字参数和命名关键字参数。
class Four(): #类的定义
def sub(self,x,y):
return x + y """
class Dog():
def __init__(self,name,age):
self.name = name
self.age = age def sit(self):
print (self.name.title() + ' ' + "is now sitting") def roll_over(self):
print (self.name.title() + ' ' + "is now roll over") my_dog = Dog('willie',6) #参数实例化
# your_dog = Dog('lucy',3)
my_dog.sit()
my_dog.roll_over()
""" """
class Four_operations():
def __init__(self,a,b):
self.a = int(a)
self.b = int(b)
def add(self):
return self.a + self.b def reduce(self):
return self.a - self.b def ride(self):
return self.a * self.b def Except(self):
return self.a / self.b operation = Four_operations('12','4')
print (operation.add())
print (operation.reduce())
print (operation.ride())
print (operation.Except())
"""
class ReadWrite():
"""
txt文件读取类
""" def __init__(self,filepath):
self.filepath = filepath def read(self,index=0):
with open(self.filepath) as book:
return book.read().splitlines()[index] def write(self,body):
with open(self.filepath,"w") as book:
book.write(body) ReadWrite("d:\\test1.txt").write("大家好,我是郑迎!")
print (ReadWrite("d:\\test1.txt").read())
#coding=utf-8 mysql = {"zhangsan":"","lisi":"","wangwu":""} class LoginRegister():
"""
登录注册函数封装实现如下:
1.登录mysql中的账号密码成功
2.密码错误则重新输入密码
3.账号错误调用注册方法进行注册,注册成功后调用登录方法登录已注册的账号
"""
def login(self):
user = input("username:")
if user in mysql.keys():
for i in range(3):
pwd = input("password:")
if pwd == mysql.get(user):
print ("Login ok")
break
else:
print ("密码输错三次,将锁定账号!")
else:
print ("Please register first!")
LoginRegister().register() def register(self):
user = input("Input you username:")
while True:
pwd = input("Input you password:")
repwd = input("Input you password again:")
if repwd == pwd:
mysql.setdefault(user,pwd)
print ("Register ok,sign in now!")
LoginRegister().login()
break
else:
print ("两次密码不一致,请重新输入!") LoginRegister().login()
三、类的封装/调用
调用类下的方法,必需通过类的的实例/类名()进行调用
- 当类中初始化方法__init__中存在参数时,则在实例化时,需要往实例括号中传入参数
- 当类中无初始化方法或者__init__中不存在参数时,则在实例化时,不需要往实例括号中传入参数,而在调用方法时再进行传参
class Four():
def sub(self,x,y):
return x + y print Four().sub(2,3) class Four_operations():
def __init__(self,a,b):
self.a = int(a)
self.b = int(b)
def add(self):
return self.a + self.b def reduce(self):
return self.a - self.b def ride(self):
return self.a * self.b def Except(self):
return self.a / self.b operation = Four_operations('','') #实例化
print (operation.add())
print (operation.reduce())
print (operation.ride())
print (operation.Except())
四、面向对象和面向过程
- 面向过程:吃(狗,屎)
- 优点:流程化,分步骤实现,效率高,代码短小精悍
- 缺点:思考难道大,代码复用率低,扩展差,难维护
def eat(dog,food):
return "{} love to eat {}.".format(dog,food) print(eat("XiaoHei","shit")) #结果如下
XiaoHei love to eat shit.
- 面向对象:狗.吃(屎)
- 优点:结构化,模块化,易扩展,可继承,可覆盖,易维护
- 缺点:程序臃肿,性能低
class Dog(): def eat(self,food):
return "Dogs love to eat {}.".format(food) print(Dog().eat("shit")) #结果如下
Dogs love to eat shit.