九 Python面向对象

最新推荐文章于 2022-10-19 18:50:01 发布
最新推荐文章于 2022-10-19 18:50:01 发布
阅读量1.6k 收藏 39
点赞数 6
分类专栏： Python 文章标签： Python 面向对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45550881/article/details/103443760
版权

九 Python面向对象

1. 面向对象与面向过程

1-1. 介绍

面向对象编程：Object Oriented Programming，简称OOP，是一种程序设计方法。

1-2. 概念及术语

术语概念及介绍
类(Class)用来描述具有相同属性和方法的对象的集合。它定义了该集合中每个对 象所共有的属性和方法。其中的对象被称作类的实例。
实例也称对象。通过类定义的初始化方法，赋予具体的值，成为一个"有血有肉 的实体"。
实例化创建类的实例的过程或操作。
实例变量定义在实例中的变量，只作用于当前实例。
类变量类变量是所有实例公有的变量。类变量定义在类中，但在方法体之外。
数据成员类变量、实例变量、方法、类方法、静态方法和属性等的统称。
方法类中定义的函数
静态方法不需要实例化就可以由类执行的方法
类方法类方法是将类本身作为对象进行操作的方法。
方法重写如果从父类继承的方法不能满足子类的需求，可以对父类的方法 进行改写，这个过程也称override。
封装将内部实现包裹起来，对外透明，提供api接口进行调用的机制。
继承即一个派生类（derived class）继承父类（base class）的变量和方法。
多态根据对象类型的不同以不同的方式进行处理。

1-3. 区别

面向过程：根据业务逻辑从上到下写代码
面向对象：将数据与函数绑定到一起，进行封装。减少重复代码的重写过程

1-4. 示例参考

示例1：面向过程

def stu_info(name,age,gender):
    print(name,age,gender)

stu_info("oldli","18","male")
stu_info("ellen","18","male")
stu_info("bruin","18","male")

示例2：面向对象

class Students(object):
    def stu_info(self,name, age, gender):
        print(name, age, gender)

s = Students()
s.stu_info("oldli","18","male")
s.stu_info("ellen","18","male")
s.stu_info("bruin","18","male")

2. 面向对象之(类)

2-1. 介绍

类是抽象的模板，用来描述具有相同属性和方法的对象的集合，比如 Animal类。
类名通常采用驼峰式命名，尽量让字面意思体现出类的作用。

2-2. 结构

Python使用class关键字来定义类，结构如下：

class 类名(object): # object 可有可无
	def 方法名(self,参数): # 行为
		pass
name = 类名() # 定义一个实例对象
name.方法名(参数) # 调用

3. 面向对象之 (self)

3-1. 介绍

self 形参
self 是对象本身，也就是说，当创建的对象是谁时，self就是谁

3-2. 示例参考

class Student(object):
    def test(self):
        # print(self)
        pass

oldli = Student() # 实例化对象
print(oldli)
oldli.test()

Chy = Student() # 实例化对象
print(Chy)
Chy.test() # 调用类
# 输出结果
#<__main__.Student object at 0x03955190>
#<__main__.Student object at 0x039552C8>

class Student(object):
    def info(self):
        print(self.name,self.age)

marshal = Student()
marshal.name = "marshal"
marshal.age = "18"
# print(marshal)
marshal.info() # 输出结果 marshl 18

xiaoming = Student() # 实例化对象
xiaoming.name = "xiaoming"
xiaoming.age = "22"
# print(marshal)
xiaoming.info() # 输出结果 xiaoming 22
  1. 当只有一个变量，其它相同时，可以参考这个
class Students(object):
    def stu_info(self,name):
        print(name, self.age, self.gender)

s = Students() # 实例化对象
s.age = "18"
s.gender = "male"
s.stu_info("oldli")
s.stu_info("ellen")
s.stu_info("bruin")
'''
输出结果：
oldli 18 male
ellen 18 male
bruin 18 male
'''

4. 面向对象之 init 魔法方法

4-1. 介绍

# 构造方法（初始化方法）
def __init__(self):
	pass
# 特殊意义
	创建对象的同时，通过对象执行这样的一个方法，叫做构造方法

4-2. 示例参考

class students(object):
	def __init__(self,age,gender):
	#属性
	self.age = age
	self.gender = gender
	self.addr = "ChongQing"
	
	# 打印信息
	def stu_info(self,name):
		print(name,self.age,self.gender,self.addr)
s = students() # 实例化对象
s.stu_info("oldli")
s.stu_info("enlen")
s.stu_info("bruin")
# 输出结果:
# oldli 18 male ChangSha
# ellen 18 male ChangSha
# bruin 18 male ChangSha

5. 面向对象之 str 魔法方法

5-1. 介绍

tips： 使用了该函数，一定返回字符串；如果返回出错，可以
定义的 str

def __str__(self):
	pass 
# 1. return 关键字 将我们的信息直接返回对象
# 2. 只能时str 如果非字符串 str() 强转

5-2. 示例参考

class People(object):
	def __init__(self):
		self.age = 18
		self.name = "zero"
		self.hobby = "play game"
	
	def __str__(self):
		return str({"name":self.name,"age":self.age})
		# return 返回的多个值 元组
        # 一定返回字符串

zero = People() 
print(zero) # 输出结果： {'name':'zero',

6. 练习

‘’‘只有当年龄>0的时候才返回出来，否则默认为0岁’’’

class People(object):
	def __init__(self): # 初始化参数
		self.age = 0

	def set_age(self,new_age): # 判断
		if new_age >= 0 and new_age <=120:
			self.age = new_age
		elif new_age > 120:
			self.age = 0
		else:
			# abs()取绝对值的内置方法
			self.age = abs(new_age)
	def get_age(self):
		return self.age

xiaoming = People() # 实例化对象
xiaoming.set_age(10) # 调用函数
print(xiaoming.get_age())
# 输出结果为 10

7. 私有属性与方法

7-1. 介绍

在类中，不希望外部去访问我的属性。
格式：

# 私有属性 -->__属性名():

7-2. 私有属性示例参考

# 定义一个类
class People(object):
	def __init__(self): # 初始化参数
		self.__age = 18 # 私有属性，外部访问不了
		self.name = zero

	def get_age(self): # 可从内部调用私有属性
		print(self.__age)

	def set_age(self,age):
		self.__age = age

zero = People() # 实例化对象
print(zero.name) # 打印取出名字  输出结果 zero
print(zero.__age) # 会报错，no attribute 。 不能直接从外部调用私有的属性（__age）
zero.get_age() # 调用get_age 方法获取私有属性 输出结果18
zero.set_age(22) # 重新传入参数
zero.get_age() # 输出结果 22 
print(zero.__dir__()) # 查看对象的方法跟属性

7-3. 私有方法示例参考

定义私有方法

class Demo(object): # 定义一个类
	def test1(self):
		print("test1:)
	
	def __test2(self):
		print("test2")

d = Demo() # 实例化对象
d.test1()	# 输出结果为 test1
d.__test2() # 报错，不能调用

8. 成员-方法与属性

8-1. 示例1 静态属性

class Province(object):
	country = "中国"  # 类属性， 静态属性  对象， 类来调用

	def __init__(self,name):
		self.name = name

	def print_info(self):
		print(Province.country,self.name) # 静态属性调用 类名.静态属性名

guangdong = Province("广东")
chongqing = Province("重庆")
guangdong.print_info() # 输出结果 中国广东
chongqing.print_info() # 输出结果 中国重庆
  1. 实例方法：对象需要保存的一些值，执行某功能时，需要使用对象中的值
    静态方法：跟我们在函数外部定义独立的方法没有什么区别，但是有的时方便维护。不需要创建对象 直接访问，不需要self参数。调用 通过类调用
    类方法： 保存在类中 由类直接调用 cls–>当前类
class Demo(object):
	def __init__(self):
		self.name = "zero"

	def test(self):
		print(self.name)

	@staticmethod # 静态方法，等同于上面的
	def test1(name):
		print(name)

	@classmethod
	def class_md(cls):
		print(cls)

d = Demo() # 实例化对象
d.test()  # 输出结果 zero
Demo.test1("王先生") # 输出结果 王先生 调用了静态属性@staticmethod
d.test1("小周") # 输出结果 小周

Demo.class_md() # <class '__main__.Demo'>

8-2. 在类中如何实现当前格式化时间

  1. 面向过程
import time
def show_time():
	print(time.strftime("%H:%M:%S",time.localtime()))

show_time() # 输出结果， 当前时间
  1. 面向对象
import time
class TimeTest(object):

	@staticmethod
	def show_time():
		print(time.strftime("%H:%M:%S",time.localtime()))

nowtime = Timetest()
TimeTest.showtime() # 输出结果， 当前时间

8-3. property

8-3-1. 介绍

可以将类的方法变为属性

8-3-2. 示例参考
class Demo(object):
	def __init__(self):
		self.name = "zero"

	@property  # 将方法变为属性
	def test(self):
		print(self.name)
		return "test"

	@test.setter   # d.test = "456"
	def test(self,nums):
		print(nums)

	@test.deleter
	def test(self):
		print(1111)

d = Demo() #　实例化对象
print(d.name)
res = d.test
print(res)

d.test = "456"  # 想要改变

del d.test
  1. 制作翻页效果
class Page(object):
	def __init__(self,current_page):
		try:
			p = int(current_page)
		except Exception as e: # 万能异常捕获
			p = 1
		self.page = p

	@property
	def start(self):
		start = (self.page-1)*10
		return start

	@property
	def end(self):
		end = self.page * 10
		return end

li = list(range(100))

while True:
	p = int(input("请输入要查看的页码："))
	page = page(p)  # 实例化对象
	print(li[page.start:page.end])

9. 函数的继承

9-1. 介绍

创建新类的方式，新类可以继承一个或者多个父类;
作用：避免重复造轮子
新式类 继承object
经典类 不继承object

tips:
如果调用的是继承的父类中的方法，可以在这个公有方法中访问父类中的私有属性和私有方法;
但是如果在子类中实现了一个公有方法，那么这个方法是不能够调用继承的父类中的私有方法和私有属性

class Father(object):
    def __init__(self):
        self.name = "amy"
        self.__age = 18

    def __test(self):
        print("__test")

    def test1(self):
        print(self.__age)


class Son(Father):
    # def __init__(self):
    #     print("Son")
    #     super().__init__()
    def test3(self):
        # print(self.__age)
        self.__test()

    def __test(self):
        print("__test")


s = Son()
print(s.name)  #	amy
# print(s.__age)  # 私有属性不会被继承
# s.__test()  #私有方法不会被继承
# s.test1()
s.test3() #	__test

9-2. 示例

class GrandFather(object):
	def sleep(self):
		print("睡10个小时")

class Father(GrandFather): # 父类 基类
	def run(self):
		print("我会跑")

	def eat(self):
		print("我会吃")

class Son(Father):
	def study_python(self):
		print("我学python")

s = Son()
# 子类没有， 就往父类中去找
s.run() # 输出结果 我会跑
s.study_python() # 输出结果 我学python
# 父类没有 就会往父类的父类中去找
s.sleep()	#	输出结果 睡10个小时

9-3. 多继承

示例:

class GrandFather(object):
	def sleep(self):
		print("GrangF睡觉")

class Father(GrandFather):
	def run(self):
		print("Father会跑")

class Father1(Father):
	def run(self):
		print("Father1会跑")

	def sleep(self):
		print("Father1睡觉")

class Son(Father,Father1):
	pass

s = Son()
s.run()
s.sleep()	# C3
# print(Son.__mro__) # 可以查看调用顺序

tips:

  1. 左边优先
  2. 当左边父类的父类，有该方法。右边父类有该方法。左边一条路走到底
  3. 他们有一个根，根最后执行

10. 函数重写

10-1. 示例

'''
重写的同时并且执行父类中的方法
'''
class GrandFather(object):
	def sleep(self):
		print("睡10个小时")

class Father(GrandFather):
	def run(self):
		print("我会跑")

	def eat(self):
		print("我会吃")

class Son(Father):
	def study_python(self):
		print("我学python")

	def sleep(self):
		print("我睡8个小时")
		#super(Son,self).sleep()	#	下面的完整版
		super().sleep()	#	效果同上
		#GrandFather.sleep(self)	#	效果同上

s = Son()
s.sleep() # 输出结果 我睡8个小时 睡10个小时

总结：

  1. 继承机制 深度优先 先从自己找 自己找不到 就往父类找
  2. 重写 防止执行父类的该方法
  3. self 都指当前实例化的对象
  4. 既想要继承父类当中方法 又想拓展新的东西
    4.1 super(cls,self).父类中的方法(para)
    4.2 父类名父类中的方法(self,para)

11. 多态

示例:

class Person(object):
	def print_info(self):
		print("我是个人")

class Girl(Person): # 继承
	def print_info(self):
		print("我是zero")

def info(travel): # 定义一个函数
	travel.print_info()

zero = Person() # 实例化对象
info(zero)  # 我是个人

zero1 = Girl() # 实例化对象
info(zero1)	# 我是zero

12. 面向对象之魔法方法

12-1. 魔法方法

  1. doc
    tips:
    当函数中有多个注释时，只会打印第一个注释
# str()
# print(str().__doc__)

class Demo(object):
	'''
我是Demo的注释
	'''
	'我有一个构造方法'
    "我....."
	def __init__(self):
		pass

d = Demo()
print(d.__doc__) #	输出结果：我是demo的注释
  1. del
    tips:
    只有等到对象全部释放，才会主动触发__del__
class Demo:
	def __del__(self):
		print("好惨，我被回收了")

d = Demo()
d1 = d
print("-"*20)
del d
del d1
print("-"*20)

'''
输出结果:
--------------------
好惨，我被回收了
--------------------
'''
  1. call
    tips:
    一个实例，也可以变成一个可调用的对象
class Demo(object):
	def __call__(self,*args,**kwargs):
		print("我可以调用了哟")

d = Demo()
d() # 'Demo' object is not callable # 输出结果: 我可以被调用了哟
# str()
  1. dict 查看类或者对象的成员 字典
    dict 更像__dir__的一个子集
class Demo(object):
	gender = "female"
	def __init__(self):
		self.name = "zero"
		self.__age = 18

	def test(self):
		print("test")

d = Demo()
d.test()
print(d.__dict__) # dict 查看对象中的实例属性
print(Demo.__dict__) #	查看类中的成员 -->类属性与行为
print(d.__dir__()) #	列表 查看对象的 -->成员
print(Demo.__dir__(d))
print(d._Demo__age)

12-2. new方法

12-2-1. 介绍

new 在类准备自身实例化时调用的
new 静态方法 创建对象
init 实例方法，对象自动调用的方法

12-2-2. 示例
class Demo(object):
	def __init__(self):
		print("__init__")

	# 如果我们这个类中没有new,会创建对象的时候，会自动执行父类中的new方法
	def __new__(cls,*args,**kwargs):
		return super().__new__(cls) # 传入别的类名时，不会调用__init__方法

d = Demo()
# 1.创建对象 __new__
# 2.调用__init__方法
# 3.返回对象引用

12-3. 单例模式

12-3-1. 介绍

永远只使用一份对象 （重点：记录日志在logger)
对象不存在时候 -->创建对象
对象存在 -->永远只返回当前创建对象

12-3-2. 示例
class Demo(object):
	flag = None	#	标志

	# 创建对象 __new__
	def __new__(cls,*args,**kwargs):
		# return super().__new__(cls)
		if cls.fflag is None:
			cls.flag = super().__new__(cls):
			return cls.flag
		else:
			return cls.flag

d = Demo()
print(id(d))
d1 = Demo()
print(id(d1)) # 输出两个相同的ID地址

12-4. reflect 反射

12-4-1. 会用到的函数
  1. getattr 函数 获取属性值或者获取方法变量的地址
getattr(py文件名,输入的名字)

getattr(views,ipt)
  1. hasattr 函数 判断是否有此变量,返回bool 值
魔力军
关注
  • 6
    点赞
  • 踩
  • 39
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
python面向对象练习题.pdf
09-04
python面向对象练习题，资料，教育资料
Python中的 __init__函数，self参数
qq_40671063的博客
07-23 4023
Python中的 __init__函数，self参数
Python学习规划
hzp666的博客
07-27 1242
使用for循环编写程序实现以下功能计算1-1/3+1/5-1/7+...-1/99+......，结果保留2位小数。输入该表达式的项数n。（n-1）从后2个元素中找出具有最小值的元素，如果其不是第n-1个元素则将其与第n-1个元素交换。（i）从后n-i+1个元素中找出具有最小值的元素，如果其不是第i个元素则将其与第i个元素交换。（2）从后n-1个元素中找出具有最小值的元素，如果其不是第2个元素则将其与第2个元素交换。（1）从n个元素中找出具有最小值的元素，如果其不是第1个元素则将其与第1个元素交换。....
python面向对象基础
m0_53602804的博客
04-15 672
python面向对象基础面向对象与面向过程的区别（举例说明）对象类面向对象程序设计的三大特点封装继承多态类的定义和使用定义类创建类类属性类方法静态方法创建对象动态绑定属性和方法方法重写特殊属性与方法 面向对象与面向过程的区别（举例说明） 面向过程：吃饭的时候，必须严格按照步骤，第一步生火，第二步洗菜，第三步放油，第四步放菜，第五步炒菜，第六步端菜 面向对象：只需要点外卖打个电话，不需要知晓菜是谁买的，饭是谁做的，外卖是是谁送的，只要拿到饭了就可以 对象 对象是一个抽象的概念，表示任意存在的事物。通常将对象划
面向对象编程之类方法@classmethod
qq_46044325的博客
09-25 895
但是这个代码有个bug！当你不创建对象，直接对在外部调用num时也可以使数量+1。答：因为这里对num+1是针对的每个新创建的实例对象，而不是针对于整个大类而言。最终的代码如下：有小伙伴们找到bug可以和我交流一下!你会发现类方法中的self指向的是类本身，而不是实例对象。类方法只能访问类变量，不能访问实例变量。通过@classmethod装饰器实现。为什么类方法中不能够访问实例变量？答：将Self换成类本身即可！答：可以使用类方法避免这个问题！
Python基础学习day5-类和对象
最新发布
L_uca_s的博客
10-19 290
编程分为面向过程和面向对象，这两者是相辅相成的，python作为一门面向对象语言，类和对象的概念十分重要。
python面向对象
09-13
面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它基于“对象”的概念，将数据和...在视频课程“Python面向对象精彩讲解”中，会详细阐述这些概念，并通过实例演示如何在实际开发中应用它们。
Python面向对象进阶学习
09-19
在本文里我们整理了关于Python面向对象的进阶学习知识点以及学习路线等内容，有兴趣的朋友们学习下。
面向对象编程基础_python面向对象_python教程_
09-29
以上就是Python面向对象编程的基本概念和特性。掌握这些基础知识，能帮助你更好地理解和编写Python程序，尤其在处理复杂逻辑和大型项目时，面向对象编程的优势会更加明显。在实际应用中，不断实践和探索，才能真正...
python面向对象课件
11-12
面向对象编程（Object-Oriented Programming，简称OOP）是Python编程中的核心概念之一，它是一种编程范式，强调通过创建对象来组织代码，使得程序更易于理解和维护。本课件详细介绍了Python中的面向对象特性，包括类...
python自学笔记9 —— 面向对象编程
weixin_57518891的博客
04-24 349
python自学笔记9 —— 面向对象编程
python的基础语法（二）
FOKJECKT的博客
07-08 747
python的基础语法（二） python类方法的调用： 1、实例.实例方法名(调用传参) 2、类名.实例方法(实例，调用传参) class Human: age = 18 money=123 def eat(self,name,s): print("%s正在吃%s" % (name,s)) @classmethod def func(cls...
python 第四章面向对象
hello
08-04 457
python 第四章面向对象
面向对象——访问限制
z7sz的博客
06-23 308
python基础——面向对象之访问限制
Python基础语法篇（三）：类和对象
qq_42871783的博客
10-19 2834
文章目录一、类和对象介绍二、类的定义和创建实例三、类属性定义及其访问四、类中普通方法定义及调用五、私有属性六、构造方法七、析构方法八、常用内置方法九、继承十、类方法和静态方法 一、类和对象介绍 二、类的定义和创建实例 三、类属性定义及其访问 四、类中普通方法定义及调用 五、私有属性 六、构造方法 七、析构方法 八、常用内置方法 九、继承 十、类方法和静态方法 ......
Python基础详细版笔记四（类和对象详解）
weixin_43872169的博客
09-06 388
第一章 两大编程思想 1.编程思想 2.类和对象 字符串对象，字典对象… 3.类的创建 4.对象的创建 5.类属性 类方法 静态属性 类属性： 类方法和静态方法： 6.动态绑定属性和方法 这两种调用方法都可以，直接用对象.可以，也可以传入对象来 第二章 面向对象的三大特征 封装继承多态 1.封装的实现方法 .........
面向对象程序设计（Python）
qq_45705923的博客
05-23 1539
Python面向对象程序设计什么是面向对象程序设计面向过程VS面向对象面向对象程序设计的基本概念初识面向对象创建对象类变量类方法面向对象编程的三大特征1.封装私有属性私有方法2.继承什么是继承方法重写3.多态 此文为华理数学与智能科技协会（MITA）第三期护航计划面向对象预习资料 什么是面向对象程序设计 读者肯定听过 Python 中“一切皆对象”的说法，但可能并不了解它的具体含义，只是在学习的时候听说 Python 是面向对象的编程语言，本节将向大家详细介绍 Python 面向对象的含义。 面向过程VS面
Python基础五-类及对象
lucky_myj的博客
10-14 472
Python基础五-类及对象 一、面向对象编程 1、面向对象编程-Object Oriented Programming, 简称OOP，是一种程序设计思想。OOP将对象作为程序的基本单元，一个对象包含数据和操作数据的函数 面向过程的程序设计把计算机程序视为一系列的命令集合，即一组函数的顺序执行。为了简化程序设计，面向过程把函数继续切分为子函数，即把大块函数通过切割成小块函数来降低系统的复杂度。 面向对象的程序设计是将计算机程序视为一组对象的结合，每个对象都可以接受其他对象传递的消息，并处理消息，计算机程序的
16、python面对对象之类和继承
终极冥帝
01-31 172
前言：本文主要介绍python面对对象中的类和继承，包括类方法、静态方法、只读属性、继承等。 一、类方法传奇文学 https://m.xs86.com 1.类方法定义 　　使用装饰器@classmethod装饰，且第一个参数必须是当前类对象，该参数名一般约定为“cls"，通过它来传递类的属性和方法 （不能传递实例属性和实例方法），跟实例方法的self用法相似。 2.类方法的调用...
Python面向对象编程详解
Python程序设计语言深入探讨面向对象程序设计的概念，这一主题由张晓教授于2009年在西北工业大学计算机学院讲解。面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它将数据和操作数据的函数...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值