Python编程基础（三）

打卡第三天啦！！！

面向对象基础（上）

面向对象介绍

1. OOP
2. 将数据与函数绑定在一起，进行封装
3. 面向过程和面向对象

类和对象

1. 类是模板，由类名、属性、方法构成
2. 对象是根据模板创建的实例

定义类和对象

# 类名用大驼峰命名法
class Person:
name='潘小雷'
age=20
def watch(self):
print('看韩剧')
pass
def run(self):
print('跑步')
pass
# 创建对象
rainy_universe=Person()
print(rainy_universe.name)
print(rainy_universe.age)
rainy_universe.watch()
rainy_universe.run()
# 潘小雷
# 20
# 看韩剧
# 跑步

实例方法与属性

1. 在类的内部，使用def关键字可以定义一个实例方法，与一般函数定义不同，类方法必须包含参数self，且为第一个参数（名字可以不是self，但是这个位置必须被占用）
2. 属性：类里面定义的变量（类属性）
3. 定义在方法里面使用self引用的属性称之为实例属性

# 类名用大驼峰命名法
class Person:
def watch(self):
print('看韩剧')
pass
def run(self):
print('跑步')
pass
def __init__(self):
self.name='潘小雷' # 实例属性
self.age=20
# 创建对象
rainy_universe=Person()
print(rainy_universe.name)
print(rainy_universe.age)
rainy_universe.watch()
rainy_universe.run()
# 潘小雷
# 20
# 看韩剧
# 跑步

__init__方法

1. python自带的内置函数，是魔术方法
2. 是一个初始化的方法，用来定义实例属性和初始化数据的，在创建对象的时候自动调用，不用手动去调用
3. 利用传参的机制可以让我们定义功能更强大并且方便的类

# 使用__init__方法前
class People:
def eat(self):
print('俺在吃饭')
pass
rainy_universe=People()
rainy_universe.eat()
rainy_universe.name='雨宙'
rainy_universe.age=19
print(rainy_universe.name,rainy_universe.age)
pan=People()
pan.name='潘小雷'
pan.age=20
print(pan.name,pan.age)
# 俺在吃饭
# 雨宙 19
# 潘小雷 20

# 使用__init__方法后
class People:
def __init__(self):
self.name='潘小雷'
self.age=20
pass
pan=People()
print(pan.name,pan.age)
# 潘小雷 20
rainy_universe=People()
rainy_universe.name='雨宙'
rainy_universe.age=19
print(rainy_universe.name,rainy_universe.age)
# 雨宙 19

# 改进
class People:
def __init__(self,name,age):
self.name=name
self.age=age
pass
def eat(self,food):
print(self.name+'在吃'+food)
pass
pan=People('潘小雷',20)
print(pan.name,pan.age)
pan.eat('面条')
# 潘小雷 20
# 潘小雷在吃面条

理解self

1. self和对象指向同一个内存地址，可以认为self就是对象的引用

class Person:
def eat(self):
print(self)
print('self={}'.format(id(self)))
pass
pass
pan=Person()
pan.eat()
print('pan={}'.format(id(pan)))
# <__main__.Person object at 0x000002449D31FFA0>
# self=2493718331296
# pan=2493718331296

2. 所谓的self，可以理解为对象自己。某个对象调用其方法时，python解释器会把这个对象作为第一个参数传递给self，所以开发者只需要传递后面的参数即可。
3. self只有在类中定义实例方法的时候才有意义，在调用的时候不必传入相应的参数，而是由解释器自动地去指向
4. self的名称可以更改，可以定义成其他的名字

魔术方法

1. __str__方法

class Person:
def __init__(self,name,age):
self.name=name
self.age=age
pass
def __str__(self):
return '姓名：{} 年龄：{}'.format(self.name,self.age)
def eat(self):
print('吃饭')
pass
pass
pan=Person('潘小雷',20)
print(pan)
# 姓名：潘小雷 年龄：20

2. __new__方法（至少有cls参数代表要实例化的类）
   （1）场景：可以控制创建对象的一些属性限定，经常用来做单例模式的时候来使用
   （2）__new__和__init__函数的区别：__new__类的实例化方法必须返回该实例，否则对象就创建不成功；__init__用来做数据属性的初始化工作，也可以认为是实例的构造方法，接收类的实例self并对其进行构造
   （3）__new__函数要早于__init__函数执行

class Person:
def __init__(self,name,age):
print('---------------init-------------')
self.name=name
self.age=age
pass
def __str__(self):
return '姓名：{} 年龄：{}'.format(self.name,self.age)
def __new__(cls,*args,**kwargs):
print('---------------new-------------')
return object.__new__(cls) #真正创建对象实例
pass
def eat(self):
print('吃饭')
pass
pass
pan=Person('潘小雷',20)
print(pan)
# ---------------new-------------
# ---------------init-------------
# 姓名：潘小雷 年龄：20

案例

import time
class Person():
def __init__(self,name,blood):
self.name=name
self.blood=blood
def __str__(self):
return '玩家{}血量为{}'.format(self.name,self.blood)
def attack_methodA(self,enemy):
print('玩家{} 捅了 玩家{}一刀，玩家{}掉了10滴血'.format(self.name,enemy.name,enemy.name))
enemy.blood-=10
pass
def attack_methodB(self,enemy):
print('玩家{} 砍了 玩家{}一刀，玩家{}掉了15滴血'.format(self.name, enemy.name, enemy.name))
enemy.blood-=15
pass
def increase_blood(self):
print('玩家{} 吃药，恢复10滴血'.format(self.name))
self.blood+=10
pass
xm=Person('西门吹雪',100)
ygc=Person('叶孤城',100)
while True:
if(xm.blood<=0 or ygc.blood<=0):
break
pass
xm.attack_methodA(ygc)
print(xm)
print(ygc)
print('-------------------------------')
ygc.attack_methodB(xm)
print(xm)
print(ygc)
print('-------------------------------')
xm.increase_blood()
print(xm)
print(ygc)
print('-------------------------------')
time.sleep(1)
pass

面向对象基础（中）

析构方法

1. 当一个对象被删除或者被销毁时，Python解释器也会默认调用一个方法，这个方法为__del__()方法，也称为析构方法
2. 程序执行结束自动调用析构方法
3. 当对象被手动销毁时也会自动调用__del__方法
4. 析构函数一般用于资源回收

class Animal:
def __init__(self,name):
self.name=name
print('这是构造初始化方法')
pass
def __del__(self):
print('这是析构方法')
pass
cat=Animal('小猫')
# 这是构造初始化方法
# 这是析构方法

class Animal:
def __init__(self,name):
self.name=name
print('这是构造初始化方法')
pass
def __del__(self):
print('这是析构方法')
pass
cat=Animal('小猫')
del cat # 手动删除对象
input('程序等待中')
# 这是构造初始化方法
# 这是析构方法
# 程序等待中

继承

单继承

1. 对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一去实现

class Animal:
def eat(self):
print('吃')
pass
def drink(self):
print('喝')
pass
class Dog(Animal):
def wwj(self):
print('汪汪叫')
pass
pass
class Cat(Animal):
def mmj(self):
print('喵喵叫')
pass
pass
d1=Dog()
d1.eat()
c1=Cat()
c1.eat()
# 吃
# 吃

多继承

class shenxian:
def fly(self):
print('神仙都会飞')
pass
class Monkey:
def eat(self):
print('猴子喜欢吃桃')
pass
class SunWukong(shenxian,Monkey):
pass
sunWuKong=SunWukong()
sunWuKong.fly()
sunWuKong.eat()
# 神仙都会飞
# 猴子喜欢吃桃

class D(object):
def eat(self):
print('D.eat')
pass
class C(D):
def eat(self):
print('C.eat')
pass
class B(D):
pass
class A(B,C):
pass
a=A()
a.eat()
print(A.__mro__) # 可以显示类的依次继承关系
# 执行顺序：A-》B-》C（-》D）
# C.eat
# (<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class 'object'>)

重写父类方法

所谓重写，就是子类中，有一个和父亲相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法

调用父类方法

class Dog:
def __init__(self,name,color):
self.name=name
self.color=color
pass
class keji(Dog):
def __init__(self,name,color,height,weight):
Dog.__init__(self,name,color) # 调用父类方法
# super.__init__(name,color) # 另外一种方式 super自动找到父类进而调用方法
self.height=height
self.weight=weight
pass
def __str__(self):
return '名字：{} 颜色：{} 高度：{} 重量：{}'.format(self.name,self.color,self.height,self.weight)
kejiA=keji('柯基犬','红色',30,50)
print(kejiA)
# 名字：柯基犬 颜色：红色 高度：30 重量：50

多态

1. 所谓多态，定义时的类型和运行时的类型不一样，此时就成为多态（同一种行为，对于不同的子类有不同的有不同的行为表现）
2. 实现多态的前提：
   （1）多态必须发生在父类和子类之间
   （2）子类重写父类的方法

class Person:
def say_who(self):
print('我是一个人')
pass
class Student(Person): # 子类继承父类
def say_who(self):
print('我是一个学生') # 子类重写父类方法
pass
class Teacher(Person):
def say_who(self):
print('我是一个老师')
pass
def commonInvoke(obj):
obj.say_who()
listObj=[Student(),Teacher()]
for item in listObj:
commonInvoke(item)
# 我是一个学生
# 我是一个老师

3. 多态可以增加程序的灵活性，增加程序的扩展性
4. 鸭子类型：只要看起来像鸭子，就是鸭子

类属性和实例属性

1. 类属性：就是类对象所拥有的属性，可以被所有类对象的实例对象所共有，类对象和实例对象可以访问
2. 实例属性：实例对象所拥有的属性，只能通过实例对象访问
3. 类属性只能通过类对象修改

class Student:
name='潘小雷' # 属于类属性 就是student类对象所拥有的
def __init__(self,age):
self.age=age # 实例属性
pass
pass
rainy_universe=Student(19)
print('-----------通过实例对象访问类属性和实例属性------------')
print(rainy_universe.name)
print(rainy_universe.age)
print('-----------通过类对象访问类属性和实例属性--------------')
print(Student.name)
# print(Student.age) # error
# -----------通过实例对象访问类属性和实例属性------------
# 潘小雷
# 19
# -----------通过类对象访问类属性和实例属性--------------
# 潘小雷

class Student:
name='潘小雷' # 属于类属性 就是student类对象所拥有的
def __init__(self,age):
self.age=age # 实例属性
pass
pass
Student.name='雨宙' # 类属性只能通过类对象修改
rainy_universe=Student(19)
print('-----------通过实例对象访问类属性和实例属性------------')
print(rainy_universe.name)
print(rainy_universe.age)
print('-----------通过类对象访问类属性和实例属性--------------')
print(Student.name)
# print(Student.age) # error
# -----------通过实例对象访问类属性和实例属性------------
# 雨宙
# 19
# -----------通过类对象访问类属性和实例属性--------------
# 雨宙

类方法和静态方法

1. 类方法：类对象所拥有的方法，需要用装饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数，类方法可以通过类对象，实例对象调用

class People:
country='China'
# 类方法，用@classmethod进行修饰
@classmethod
def get_country(cls):
return cls.country
pass
@classmethod
def change_country(cls,data):
cls.country=data
pass
pass
# 通过类对象去引用
print(People.get_country()) # China
# 通过实例对象去引用
peopleA=People()
print(peopleA.get_country()) # China
People.change_country('英国')
print(People.get_country()) # 英国

2. 静态方法：类对象所拥有的方法，需要用@staticmethod来表示静态方法，静态方法不需要任何参数
3. 一般情况下，不会通过实例对象访问静态方法
4. 由于静态方法主要存放逻辑性的代码，本身和类以及实例对象没有交互，在静态方法中，不会涉及到类中方法和属性的操作

class People:
country='China'
@staticmethod
def getData():
return People.country # 通过类对象去引用
pass
p=People()
print(p.getData()) # China

import time
class TimeTest:
def __init__(self,hour,min,second):
self.hour=hour
self.min=min
self.second=second
@staticmethod
def showTime():
return time.strftime("%H:%M:%S",time.localtime())
pass
print(TimeTest.showTime()) # 11:23:26

5. 类方法第一个参数是类对象，简称cls，进而去引用类对象的属性和方法；实例方法的第一个参数必须是self，通过这个self可以去引用类属性或实例属性，若存在相同名称的实例属性和类属性的话，实例属性的优先级最高；静态方法不需要定义额外的参数，若是要引用属性的话，则可以通过类对象或实例对象去引用

面向对象基础（下）

私有化属性

1. 两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问
2. 私有化属性不能在外部直接访问，可以在类的内部随意使用
3. 子类不能继承父类的私有化属性，只能继承公共的属性和行为

class Person:
def __init__(self):
self.__name='潘小雷'
pass
def __str__(self):
return '姓名：{}'.format(self.__name)
class Student(Person):
pass
pan=Person()
# print(pan.__name) # error 私有属性不能在外部使用
print(pan.__str__()) # 姓名：潘小雷
stu=Student()
# print(stu.__name) # error 私有属性不能被继承

class Person:
def __init__(self):
self.__name='潘小雷'
pass
def change_name(self,data):
self.__name=data
pass
def __str__(self):
return '姓名：{}'.format(self.__name)
pass
pan=Person()
pan.change_name('雨宙')
print(pan.__str__())
# 姓名：雨宙

私有化方法

1. 私有化方法，在方法名前面加两个下划线

class Animal:
def eat(self):
print('吃东西')
pass
def __run(self):
print('飞快地跑')
pass
class Bird(Animal):
pass
b1=Bird()
b1.eat() # 吃东西
# b1.__run() # error

Property属性

两种实现方式

class Person:
def __init__(self,age):
self.__age=age
pass
def get_age(self):
return self.__age
def set_age(self,age):
if age<0:
print('年龄不能小于0')
pass
else:
self.__age=age
pass
age=property(get_age,set_age)
pass
p1=Person(20)
print(p1.age) # 20
p1.age=19
print(p1.age) # 19

# 通过装饰器实现
class Person:
def __init__(self,age):
self.__age=age
pass
@property
def age(self):
return self.__age
@age.setter
def age(self,parms):
if parms<0:
print('年龄不能小于0')
pass
else:
self.__age=parms
pass
pass
p1=Person(20)
print(p1.age) # 20
p1.age=19
print(p1.age) # 19

__new__方法

1. 作用：创建并返回一个实例对象

class Animal:
def __init__(self):
self.color='黄色'
pass
# 默认结构
def __new__(cls, *args, **kwargs):
return super().__new__(cls,*args,**kwargs)
pass
cat=Animal()

单例模式

1. 是一种常用设计模式
2. 一个类只有一个实例存在

class DatabaseClass(object):
def __new__(cls, *args, **kwargs):
if not hasattr(cls,'_instance'):# hasattr不能处理私有变量，改成__instance会报错
cls._instance=super().__new__(cls, *args, **kwargs)
return cls._instance
pass
db1=DatabaseClass()
db2=DatabaseClass()
print(id(db1))
print(id(db2))
# 1835757881480
# 1835757881480

# 另一种方法
class DatabaseClass(object):
__instance=None
def __new__(cls, *args, **kwargs):
if not cls.__instance:
cls.__instance=super().__new__(cls, *args, **kwargs)
return cls.__instance
pass
db1=DatabaseClass()
db2=DatabaseClass()
print(id(db1))
print(id(db2))

错误与异常处理

1. 用一个块可以捕获多个不同类型的异常，使用Exception可以捕获到所有的异常

try:
print(b)
pass
except NameError as msg:
print(msg)
pass
print('错误处理完毕')
# name 'b' is not defined
# 错误处理完毕

2. 不需要在每个可能出错的地方去捕获，只要在合适的层次去捕获错误就可以了

def A(s):
return 10/s
def B(s):
return A(s)*2
def main():
try:
B(0)
pass
except Exception as msg:
print(msg)
pass
pass
main()
# division by zero

3. 异常抛出机制：如果在运行时发生异常，解释器会查找相应的异常捕获类型，如果在当前函数中没有找到的话，会将异常传递给上层调用函数，如果在最外层没有找到的话，解释器会退出程序
4. 语法格式：
   try:
     可能出现错误的代码块
   except:
     出错之后执行的代码块
   else:
     没有出错的代码块
   finally:
     不管有没有出错都执行的代码块

自定义异常

class ToolongException(Exception):
def __init__(self,len):
self.len=len
pass
def __str__(self):
return '输入长度为{}'.format(self.len)+'，超过长度'
pass
def name_test():
name=input('请输入姓名：')
try:
if len(name)>5:
raise ToolongException(len(name))
else:
print(name)
pass
pass
except ToolongException as msg:
print(msg)
pass
name_test()
# 请输入姓名：啦啦啦啦啦啦
# 输入长度为6，超过长度

动态绑定数据和方法

1. 绑定实例属性和方法

import types # 添加方法的库
def dynamicMethod(self):
print('姓名：{} 年龄：{} 体重：{}'.format(self.name,self.age,self.weight))
class Student:
def __init__(self,name,age):
self.name=name
self.age=age
pass
def __str__(self):
return '姓名：{} 年龄：{}'.format(self.name,self.age)
pan=Student('潘小雷',20)
pan.weight=68 # 动态绑定属性
pan.printInfo=types.MethodType(dynamicMethod,pan) # 动态绑定方法
pan.printInfo()
# 姓名：潘小雷 年龄：20 体重：68

2. 绑定类属性和方法

@classmethod
def classTest(cls):
print('这是一个绑定类方法')
pass
class Student:
def __init__(self,name,age):
self.name=name
self.age=age
pass
def __str__(self):
return '姓名：{} 年龄：{}'.format(self.name,self.age)
Student.weight=80
Student.testMethod=classTest
Student.testMethod()

__slots__属性

1. 限制要添加的实例属性
2. 子类未声明__slots__属性时，不会继承父类的__slots__属性，此时子类是可以随意属性赋值

class Student(object):
__slots__ = ('name','age')
def __str__(self):
return '姓名：{} 年龄：{}'.format(self.name,self.age)
pass
whale=Student()
whale.name='鲸鱼'
whale.age=20
# whale.score=100 # error
# print(whale.__dict__) # 所有的属性都存储在这里，定义slots变量后不能随意创建不在其中的属性
print(whale)

最后

以上就是专注方盒为你收集整理的Python编程基础（三）Python编程基础（三）的全部内容，希望文章能够帮你解决Python编程基础（三）Python编程基础（三）所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。