又开始的python-day09-20200814-继承-类方法-文件的打开和关闭

最新推荐文章于 2024-11-04 21:51:40 发布
最新推荐文章于 2024-11-04 21:51:40 发布
阅读量163 收藏
点赞数
分类专栏： Python 文章标签： python linux 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43862755/article/details/108952245
版权 
# 练习
# 定义一个类属性 记录通过这个类创建了多少对象

class Person(object):
	__count = 0 # 类属性
	def __init__(self,name,age):
		Person.__count += 1
		self.name = name
		self.age = age
	
	@classmethod  #
	def get_count(cls):
		return cls.__count


# 每次创建对象 都会调用__new__ __init__ f方法
p1 = Person('张三',18)
p2 = Person('李四',18)
p3 = Person('王五',18)
print(Person.get_count)



# 面向对象编程的三大特征：封装 继承 多态
# 封装：打包 函数是对语句的封装；类是对函数和变量的封装
# 继承：类和类之间可以手动的建立父子关系 父类的属性和方法 子类可以使用
# 多态：是一种技巧 提高代码的灵活度




# 继承的使用
class Animal(object):
	def __init__(self,name,age):
		self.name = name
		self.age = age
	def sleep(self):
		print(self.name + '在睡觉')

class Dog(object):
	def __init__(self,name,age):
		self.name = name
		self.age = age
	def sleep(self):
		print(self.name + '在睡觉')
	def bark(self):
		print(self.name + '正在叫')

class Student(object):
	def __init__(self,name,age):
		self.name = name
		self.age = age
	def sleep(self):
		print(self.name + '在睡觉')
	def study(self):
		print(self.name + '爱学习')
		
# 把 Animal当作父类(基类)
# Dog Student 为子类(派生类) 

class Animal(object):
	def __init__(self,name,age):
		self.name = name
		self.age = age
	def sleep(self):
		print(self.name + '在睡觉')

class Dog(Animal):
	def bark(self):
		print(self.name + '正在叫')

class Student(Animal):
	def study(self):
		print(self.name + '爱学习')

# Dog() 调用 __new__方法 在调用 __init__
# Dog() 里没有 __new__ 方法 会查看是否重写了 __new__ 方法
# 父类里也没有重写 __new__ 方法 会查找父类的父类 找到object

# 调用 __init__ 方法 Dog类没有实现 会自动找到Animal 父类
d1 = Dog('大黄',12)
print(d1.name)
d1.sleep()

s1 = Student('小帅',18)
s1.sleep()
s1.study()
# 子类可以使用父类下的方法
# 但Dog Student 两个之间的方法不能互相使用


# 继承的特点
class A(object):
	def demo_a(self):
		print('我是A类里的方法demo_a')
	def foo(self):
		print('我是A类里的方法foo_a')

class B(object):
	def demo_b(self):
		print('我是B类里的方法demo_b')
	def foo(self):
		print('我是B类里的方法foo_b')
	
# python 里允许多继承
class C(B,A): # 如果不写父类 python3 以后默认继承自object
	pass
c = C()
c.demo_a()
c.demo_b()
c.foo() # 如果同名 class C(B,A) 按继承的顺序 谁在前 调用谁
print(C.__mro__) # (<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)
# 如果有两个不同的父类有同名方法，有一个类属性可以查看方法的调用顺序

# __mro__ 属性
class A:
	pass
	
class B:
	def foo(self):
		print('我是B类里的方法foo_b')
		
class C(A):
	def foo(self):
		print('我是C类里的方法foo_c')

class D(B):
	pass

class E:
	pass

class X(D,C,E):
	pass

X().foo()
print(X.__mro__)
# 继承的传递


# 类方法和静态方法回顾
class Person:
	type = 'human'
	def __init__(self,name,age):
		self.name = name
		self.age = age
	# 需要打印name
	def demo(self):
		print('姓名是',self.name)
	# 需要访问到类属性
	@classmethod
	def bar(cls): # 不叫cls也行 self cls 都是临时指向
		print(cls is Person) # cls === Person
		print(cls.type)
	# 只需要打印hello world
	@staticmethod 
	def foo(): # 静态方法 什么都不用给
		print('hello world')
p = Person('小帅',18)
p.demo() # 实例对象调用 将实例对象传递给self
Person.demo(p)

# 类方法可以使用类对象和实例对象调用 
p.bar()
Person.bar()

# 要访问到实例对象的属性 实例方法
# 要访问到类对象的属性 类方法
# 什么都不访问 静态方法


# 私有属性的继承特点
class Animal:
	def __init__(self,name,age):
		self.name = name
		self.age = age
		self.__money = 1000
	def eat(self):
		print(self.name + '在吃东西')
	def __test(self):
		print('__test方法')

class Person(Animal):
	def __demo(self):
		print('__demo方法')
	
p = Person('小明',18)
print(p.name)
p.eat()
p._Person__demo()
# 自己类定义的私有方法 对象名._类名__私有方法名()
# p._Person__test() # 父类的私有方法 私有属性 子类没有继承
p._Animal__test() # 可以通过 对象名._父类名__私有方法名() 调用
print(p._Animal__money)

# 私有属性和方法 子类不会继承
# 子类没有 如果硬要调用 可以通过父类调用


# 新式类 和 经典类
# 手动指定Student类继承自object
class Student(object):
	pass

# 没有指定Dog的父类 python3 里默认继承自object	
class Dog:
	pass

# 新式类和经典类的概念：
# 新式类：继承自object的类 我们称之为新式类
# 经典类：不继承object的类


# python 2 3  的区别
# python3 里不存在 经典类 都是新式类
# 在python2里 如果不手动指定一个类的父类是object 这个类就是一个经典类
# python 2 里默认不支持中文 要加一行
# -*- coding:utf8 -*-
# python3 默认支持中文
# print '22' # python2 里print可以这样写
print('20200814') # python3 统一这样写 不再支持2的写法

# input 有区别
# 2 会把用户的输入当作代码 根据用户输入的内容来确定类型 raw_input 相当于3的input
# 3 直接接收用户的输入 所有的类型都是字符串类型 不再支持 raw_input

# 面向对象的相关的方法
class Animal(object):
	def __init__(self,name,age):
		self.name = name
		self.age = age

class X(object):
	pass
class Student(Animal,X):
	pass

p1 = Animal('张三',18)
p2 = Animal('张三',18)
s = Student('jack',18)
# 获取对象的内存地址 id(p1) id(p2)
print(p1 is p2) # is 运算符是用来比较是否是同一个对象
print(type(p1)) # 其实获取的就是类对象
print(type(p1) == Animal)
	#print('p1是Animal类创建的实例对象')

# s 这个实例对象是否是由Student类创建的
print(type(s) == Student)# True
print(type(s) == Animal) # False

# ininstance 用来判断一个对象是否由指定的类(或者父类)实例化来的
print(isinstance(s,(Student,X))) # True 可以判断多个
print(isinstance(s,Animal)) # True

# issubclass 用来判断一个类是否是另一个类的子类
print(issubclass(Student,Animal)) 


# 子类重写父类方法
# 

class Person:
	def __init__(self,name,age):
		self.name = name
		self.age = age
	def eat(self):
		print(self.name + '在吃东西')

class Student(Person):
	def __init__(self,name,age,school):
		# self.name = name
		# self.age = age
		# 子类在父类实现的基础上，又添加了自己的新的功能
		# 调用父类方法的两种方式：
		# 1.父类名.方法名(self,参数列表)
		# Person.__init__(self.name.age)
		# 2.使用super直接调用父类方法
		super(Student,self).__init__(name,age)
		# super().__init__(name,age)     # super()里面可以不写
		self.school = school
		
	def eat(self):
		print(self.name + '休息的时候在吃东西')
	def study(self):
		print(self.name + '在学习')
s = Student('小明',18,'清华小学')
s.eat()
s.study()

# 1. 子类的实现和父类的实现完全不一样 子类可以选择重写父类的方法
# 2. 子类在父类的基础上又有更多的实现


# 多态的使用
# 多态是基于继承，通过子类重写父类的方法，达到不同的子类对象调用相同的父类方法，得到不同的结果
# 提高代码灵活度

class PoliceDog(object):
	def attack_enemy(self):
		print('警犬在攻击坏人')
		
class BlindDog(object):
	def lead_road(self):
		print('导盲犬在引路 ')
		
class DrugDog(object):
	def search_drug(self):
		print('缉毒犬在搜索')

class Person(object):
	def __init__(self,name,dog):
		self.name = name
		self.dog = dog
	def work_with_pd(self):
		print(self.name + '在工作')
		self.dog.attack_enemy()
	def work_with_bd(self):
		print(self.name + '在工作')
		self.dog.lead_road()	
		
pd = PoliceDog()
police = Person('张警官',pd)
police.dog = pd
police.work_with_pd()

bd = BlindDog()
police = Person('张警官',pd)
police.dog = bd
police.work_with_bd()


# 经过多态之后

class Dog(object):
	def work(self):
		print('在工作')

class PoliceDog(Dog):
	def work(self):
		print('警犬在攻击坏人')
		
class BlindDog(Dog):
	def work(self):
		print('导盲犬在引路 ')
		
class DrugDog(Dog):
	def work(self):
		print('缉毒犬在搜索')

class Person(object):
	def __init__(self,name):
		self.name = name
		self.dog = None
	def work_with_dog(self):
		if self.dog is not None and isinstance(self.dog,Dog):
		# 不为空 且 为狗的类型
			self.dog.work()
police = Person('张警官')		
pd = PoliceDog()
police.dog = pd
police.work_with_dog()

bd = BlindDog()
police.dog = bd
police.work_with_dog()

dd = DrugDog()
police.dog = dd
police.work_with_dog()

# 简化了



# 文件的打开和关闭
# open 内置函数 打开并操作一个文件
# open 函数
# file:用来指定打开的文件 (路径)
# mode:打开文件时的模式 默认r 只读
# encoding:打开文件时的编码方式

# xxx.txt 写入时 使用的是utf8编码模式
# 在windows操作系统里，默认使用gbk编码格式打开文件

file = open('Z:\\翟少帅\\整理\\浮躁\\Python\\Notepad++配置Python开发环境.txt','r',encoding='utf8')
print(file.read()) # 读取内容
file.close() # 操作完文件以后 关闭文件

# 路径：绝对路径 相对路径
# . 当前目录   ../ 上级目录
# \ python 转义字符 所以要用\\ 或者前面加 r
file = open(r'Z:\翟少帅\整理\浮躁\Python\Notepad++配置Python开发环境.txt','r',encoding='utf8')
print(file.read()) # 读取内容
file.close() # 操作完文件以后 关闭文件

# 非wind系统 / 表示文件夹之间分隔               win  \
import os
print(os.sep)
# 路径书写的三种方式 1.\\  2.r'\'  3.'/' 建议第三种

file = open('Z:/翟少帅/整理/浮躁/Python/Notepad++配置Python开发环境.txt','r',encoding='utf8')
print(file.read()) # 读取内容
file.close() # 操作完文件以后 关闭文件


# 文件的打开方式
# r 只读模式 默认 打开文件以后 只能读取 不能写入 如果文件不存在 报错
# w 写入模式 打开文件以后 只能写入 不能读取 如果文件存在 会覆盖文件 如果文件不存在 则会新建
# b 以二进制的形式打开文件  非文本的内容 比如图片
# rb 以二进制读取 读取结果是二进制 wb:以二进制的形式写入文件
# a 追加模式 会在最后追加内容 如果文件不存在 会创建文件
# r+ 可读写  如果文件不存在 报错
# w+ 可读写  如果文件存在 会覆盖文件 如果文件不存在 则会新建

# 一般要么读 要么写 单一操作 
import os
print(os.getcwd()) # 当前工作目录
file = open('./xxx.txt','w')
file.write('2020')
file.close()

file = open('./xxx.txt','wb')
file.write('2021'.encode('utf8'))
file.close()

file = open('./xxx.txt','r')
print(file.read())
file.close()

file = open('yyy.txt','w+')
file.write('哈哈哈哈')
file.seek(0,0) # 写入之后 文件指针到最后 需要调用seek 将文件指针重置到开头
print(file.read())
file.close()

# P181
心无念
关注
专栏目录
实现一个类，计算程序中创建出了多少个类对象。(static成员)
enemyfloggers的博客
11-02 1400
一、直接上代码 #include <iostream> using namespace std; class A { public: A() { ++_scount; } A(const A& t) { ++_scount; } static int GetACount() { return _scount; } pr...
这篇博客记录廖雪峰python教程的习题(四)
柠檬黄先生的博客
02-09 2020
获取对象信息 主要是需要掌握 isinstance的用法，以及 hasattr(对象，属性) getattr(对象，属性) hasattr(对象，属性) 贴一段代码，解释其用法： class My_Object(object): def __init__(self): self.x=9 #就是这个类有一个属性x 并且把该属性的值设为9 之前都是可以用户输...
Python：31求通过定义类，所创建对象的个数
Yummy的博客
10-24 1150
问题回顾： 定义一个类属性，记录通过这个类创建了多少对象？ 代码献上： class Person(object): # __count = 0 #类属性 count = 0 def __new__(cls, *args, **kwargs): x = object.__new__(cls) #申请内存，创建一个对象，并设置类型：Person类 return x def __init__(self, name, age): Per
python中的多态
d_dxy的博客
08-04 252
python中的多态：不同的子类调用父类相同的方法，产生不同的执行结果，可以增加代码的外部灵活度。多态是以继承和重写父类方法为前提的，它是一种调用方法的技巧，不会影响到类的内部设计。 继承：这是设计类的技巧。父类与子类，主要体现在代码的重用，不需要大量的编写重复代码。子类通过继承父类，可以使用父类的方法，可以使代码变得简洁。 下面通过一个简单的例子，介绍下多态。 class Dog(object)...
python第十八天
Tdyang111的博客
10-22 101
class Student: def __init__(self, name, tel, study_id='0001', score=0): self.name = name self.tel = tel self.study_id = study_id self.score = score # 在打印一个对象的时候，系统会自动用这个对象去调用__repr__方法，并且获取这个方法的返回值。返回值是什么就打印什么（返回值必须
Java-day09-IO和序列化
so1125so的博客
08-05 268
一：IO流 io流（input/output） 作用：实现两个设备之间数据的通信 设备：磁盘（硬盘），内存，键盘，文件，网络，控制台 网络：当前主机之外的网上资源 分类： 根据操作的方式：输入流和输出流； 根据数据的类型：字节流和字符流 字节流：传输的是字节，可以操作任意类型的文件 ----音...
LLaMA的解读与其微调(含LLaMA 2)：Alpaca-LoRA/Vicuna/BELLE/中文LLaMA/姜子牙
热门推荐
结构之法 算法之道
03-22 7万+
还开始研究一系列开源模型(包括各自对应的模型架构、训练方法、训练数据、本地私有化部署、硬件配置要求、微调等细节)​该项目部分一开始是作为此文《》的第4部分，但但随着研究深入 为避免该文篇幅又过长，将把『第4部分 开源项目』抽取出来 独立成本文。
python-day14-面向对象
weixin_50336251的博客
09-21 58
面向对象：面向过程编程，逐一累积功能函数式编程，函数来定义面向对象编程，类&方法&对象完成想要的功能——>看底层源码和高阶项目并发编程：线程&进程&线程池&进程池&协程定义类和方法调用类中的方法实例化对象 类名()对象调用方法名。
Python魔法之旅-魔法方法(04)
ygb_1024的博客
05-30 2035
魔法方法(04)
华中农业大学pythonpython-Day31-35.rar
05-12
- **文件打开与关闭**: 学习了使用`open()`函数打开文件，`with`语句进行安全的文件操作，以及`close()`方法关闭文件。 - **读写模式**: 详述了读取（'r'）、写入（'w'）、追加（'a'）等模式，以及二进制文件的...
python-Day10.rar
04-08
在Day10的学习中，可能包括了如何打开、读取、写入和关闭文件，以及使用`with`语句确保资源的正确释放。此外，可能还会涉及更高级的文件操作，如追加模式、二进制文件或文件遍历。 模块（Module）和包（Package）...
python-Day17.rar
04-11
第17天可能讲解了如何打开、读取、写入和关闭文件，以及使用with语句来自动管理文件资源，避免资源泄露。此外，还可能涉及了更复杂的文件操作，如追加写入、读取大文件的分块处理，以及文件的复制和移动。 错误处理...
python入门python-Day24.rar
04-19
5. **文件操作**：学习如何打开、读取、写入和关闭文件，理解文件模式（如'r'、'w'、'a'等），以及处理异常如文件不存在或无法写入的情况。 6. **异常处理**：学习如何使用try/except块捕获和处理运行时错误，提高...
python-Day07.rar
04-07
- 打开和关闭文件：`open()`函数用于打开文件，`close()`方法用于关闭文件。 - 读写模式：如'r'（读）、'w'（写）、'a'（追加）等。 - 文件对象的方法：`read()`、`write()`、`readline()`、`readlines()`等。 7...
自助餐剩余食品识别图像分割系统：教学内容全覆盖
sgcsdn99的博客
11-04 925
数据集信息展示在本研究中，我们使用的数据集名为“9_5_Merged”，该数据集专门用于训练改进YOLOv8-seg的自助餐剩余食品识别图像分割系统。该数据集包含71个类别，涵盖了丰富多样的食品种类，旨在提高模型对不同类型剩余食品的识别和分割能力。通过对这些类别的细致划分，我们希望能够实现更高精度的图像分割，进而优化自助餐剩余食品的管理和利用。
Day21包和模块
weixin_50199478的博客
10-30 632
一个.py文件就是一个模块。模块是含有一系列数据、函数、类等的程序。包是将模块以文件夹的组织形式进行分组管理的方法，以便更好地组织和管理相关模块。包是一个包含一个特殊的__init__.py文件的目录。
Python 类和对象
最新发布
疯一样的码农
11-04 577
在 Python 中，类是一个对象创建的蓝图。它指定了对象（实例）将具有的属性和方法的集合。类通过封装数据和行为，促进了代码的组织、复用和模块化。使用类可以建模现实世界中的对象，定义其属性，并更有效地控制应用程序的复杂性。在 Python 中，一切都是对象，所有的数据类型和结构都是特定类的实例。对象是类的实例，具有用于修改数据的方法和存储数据的属性。理解对象对于掌握 Python 中的面向对象编程（OOP）范式至关重要。
探索 Python 的新天地：Helium 库揭秘
AIGC搞起
11-04 580
在自动化测试和网页交互的领域，Selenium 是一个强大的工具，但它的复杂性和陡峭的学习曲线让许多开发者望而却步。Helium库的出现，以其简洁的 API 和易用性，为 Python 开发者提供了一个新的选择。它不仅简化了 Selenium 的使用，还自带 WebDriver，减少了配置的复杂性。Helium 以其简洁的 API 和易用性，为 Python 开发者提供了一个强大的 Selenium 替代方案。它不仅减少了代码量，还简化了 WebDriver 的管理，使得自动化测试和网页交互变得更加容易。
01_IAR新建CC2530工程
nanxl1的博客
11-02 997
由于很多Zigbee商家提供的教程未有从零建立CC2530工程的讲解，可能会导致后面的开发中出现一些琐碎的问题。本文将以**LED流水灯**为例，从0到1用**IAR**建立CC2530工程。
Python编程基础教程-Day02完整解析
6. 文件操作：文件操作是编程中常用的功能，资源中将介绍如何在Python中打开、读取、写入和关闭文件，这些操作对于数据处理至关重要。 7. 异常处理：异常处理机制允许程序在遇到错误时不会立即崩溃，而是通过预定义...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值