Python面向对象--笔记

一、类的创建

类的组成

类属性

实例方法

静态方法

类方法

class Student:
    #类属性
    native_place = '北京'    #直接写在类中的变量-->类属性

    #初始化方法
    def __init__(self,name,age):
        self.name = name    #self.name是实体属性，这里将局部变量name的值赋给实体属性
        self.age = age

    #实例方法（类之外定义的-->函数，类之内定义的-->方法）
    def eat(self):
        print('学生在吃饭...')

    #静态方法
    @staticmethod
    def method1():      #括号内不允许写self
        print("使用了staticmethod,这是一个静态方法")

    #类方法
    @classmethod
    def cm(cls):
        print("这是一个类方法！")

类方法、静态方法可以使用类名直接访问

动态绑定

可以在创建对象后动态绑定属性，方法

class Student:
    native_place = '北京'

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

    def eat(self):
        print(self.name + "在吃饭！")

stu1 = Student('张三',20)
stu2 = Student('李四',22)

动态绑定属性

stu1.gender = '女'
print(stu1.name,stu1.age,stu1.gender)

动态绑定方法

def show():
    print("这是一个定义在类外部的方法！")

stu1.show = show
stu1.show()

二、面向对象三大特征

封装

提高程序安全性

不希望某属性在类对象外部被访问，前边使用两个’_’

def __init__(self,name,age):
    self.__name = name	#不希望name在外部被访问
    self.age = age

print(stu._Student__name)	#但仍可以通过这种方式访问，但不建议访问

继承

提高代码的复用性

如果一个类没有继承任何类，则默认继承object类

python支持多继承

class A(object):
    pass
class B(object):
    pass
class C(A,B):   #同时继承A和B
    pass

定义子类时，必须在其构造函数中调用父类的构造函数

super().__init__(name,age)

方法重写

def info(self):
    super().info()		#通过super().xxx()调用父类中被重写的方法
    print(self.stu_no)

Object类（所有类的父类）

def __str__(self):			#重写__str__()方法
    return '我是{0}，今年{1}岁！'.format(self.name,self.age)	
    
stu = Student('张三',22)
print(stu)		#我是张三，今年22岁！  自动调用__str__()方法

内置函数dir()可以查看指定对象的所有属性

多态

提高程序的可扩展性和可维护性

静态语言(Java)和动态语言(Python)关于多态的区别

静态语言实现多态的必要条件：

	继承

	方法重写

	父类引用指向子类对象

动态语言：只关心行为（方法）

特殊方法和特殊属

特殊属性
__dict__        获得类对象或实例对象所绑定的所有属性和方法的字典
__class__		输出实例对象所属的类
__bases__		输出类对象的父类元素
__base__		输出最近的父类
__mro__			输出所继承的类的层次结构（最后是object）

特殊方法
__len__()       重写__len__()方法，让内置函数len()的参数可以是自定义类型
__add__()       重写__add__()方法，可使自定义对象具有“+”功能
__new__()       用于创建对象
__init__()      对创建的对象进行初始化 
__subclasses__()输出子类列表

三、类的浅拷贝和深拷贝

变量的赋值操作

cpu1 = CPU()
cpu2 = cpu1
print(cpu1)	#<__main__.CPU object at 0x000002E82B3E85E0>
print(cpu2)	#<__main__.CPU object at 0x000002E82B3E85E0>

浅拷贝

Python拷贝一般都是浅拷贝

实例对象(如下面的computer和computer2)不一致，但子对象一致(如下面的cpu和disk)

computer = Computer(cpu1,disk)
import copy
computer2 = copy.copy(computer)

#	<__main__.Computer object at 0x00000147C272F6D0> <__main__.CPU object at 0x00000147C27585E0> <__main__.Disk object at 0x00000147C2758C10>
print(computer,computer.cpu,computer.disk)

#	<__main__.Computer object at 0x00000147C276EBB0> <__main__.CPU object at 0x00000147C27585E0> <__main__.Disk object at 0x00000147C2758C10>

print(computer2,computer2.cpu,computer2.disk)

深拷贝

采用copy模块的deepcopy()函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象不同

computer3 = copy.deepcopy(computer)

#	<__main__.Computer object at 0x000002588018F6D0> <__main__.CPU object at 0x00000258801B85E0> <__main__.Disk object at 0x00000258801B8C10>

print(computer,computer.cpu,computer.disk)

#	<__main__.Computer object at 0x0000025880256430> <__main__.CPU object at 0x0000025880256370> <__main__.Disk object at 0x000002588028E4C0>

print(computer3,computer3.cpu,computer3.disk)

四、模块和包

模块的简单介绍

模块的英文：Modules

一个模块中可以包含：多个函数、多个类（类属性、类方法…）、多条语句

一个.py文件就是一个模块

自定义模块

"""
自定义模块：创建模块-->导入模块

①创建模块：
新建一个.py文件，名称尽量不要与Python自带的标准模块名称相同

②导入模块
import 模块 [as 别名]
from 模块 import 函数/变量/方法的名称
"""

eg:

calc.py文件：

def add(a,b):
    return a + b
def div(a,b):
    return a / b

另一个文件：

import calc
print(calc.add(2,3))

以主程序方式运行

calc2.py文件

def add(a,b):
    return a + b

#只有当点击运行calc2时，才会执行运算(将该.py文件导入其他文件中运行时，这一句不会运行)
if __name__ == '__main__':  
    print(add(10, 20))

Python中的包

包和目录的区别

包：包含__init__.py文件
目录：不包含__init__.py文件

导入包中的模块：import 包名.模块名

import  package1.module_A
print(package1.module_A.a)

或者可以用别名（更方便）

import  package1.module_A as a
print(a.a)

注意：

①使用import 只能导入包名或模块名

②使用from…import 可以导入包、模块名、函数名、变量名

Python中常用的内置模块

sys 与python解释器及其环境操作相关的标准库

time 提供与时间相关的各种函数的标准库

os 提供了访问操作系统功能的标准库

calendar 提供与日期相关的各种函数的标准库

urllib 用于读取来自网上（服务器）的数据标准库

json 用于使用JSON序列和反序列化对象

re 用于在字符串中执行正则表达式匹配和替换

math 提供标准算数运算函数的标准库

decimal 用于进行精确控制运算精度、有效数位和四舍五入操作的十进制运算

logging 提供了灵活的记录事件、错误、警告和调试信息等日志信息的功能

第三方模块的安装

在线安装方式，可以在Pycharm的Terminal中安装

pip install 模块名

eg： pip install schedule

第三方模块的使用

import 模块名

五、编码格式

默认编码格式为UTF-8

可以修改编码格式

#encoding=gbk
print('你好，中国！')

不同编码格式占用的磁盘空间大小不一样

六、文件读写原理

文件读写俗称“IO操作”（队列）

内置函数open()

使用内置函数open()创建文件对象

被创建的对象file = open(要创建或打开的文件名称filename,[,mode,encoding])

常用的文件打开模式

文本文件：记事本打开

二进制文件：专门的软件，如，mp3音频文件、jpg图片文件、doc文档

打开模式

r：只读，打开时指针放在文件开头

w：只写，不存在则创建，存在则覆盖原有内容，指针在文件开头

a：追加，不存在则创建，指针在开头，存在则在末尾追加，指针在原文末尾

b：以二进制形式打开文件，不能单独使用，需与其他模式一起使用，如rb,wb

+：以读写方式打开，不可单独使用，需与 其他模式一起使用，如a+

文件对象常用方法

read([size])：从文件中读size个字节或字符的内容返回，若省略size，则读取到文件末尾

readline()：从文本中读取一行

readlines()：把每一行作为独立地字符串对象，并将这些对象放入列表返回

write(str)：把字符串str写入文件

writelines(s_list)：把字符串列表s_list写入文件，不添加换行符

seek(offset[,whence])：

把文件指针移到新地方，offset为相对于whence的位置

offset：

	为正：往结束方向移动

	为负：往开始方向移动

whence：

	0：从文件头开始计算（默认）

	1：从当前位置开始计算

	2：从文件尾开始计算

tell()：返回文件指针当前位置

flush()：把缓冲区的内容写进文件，但不关闭文件

close()：把缓冲区的内容写入文件，同时关闭文件，释放文件对象相关资源

七、with语句（上下文管理器）

with语句可以自动管理上下文资源，不论什么原因跳出with块，都能确保文件正确关闭，以此达到释放资源的目的。

上下文管理器：实现了–enter–()方法和–exit–()方法，自动调用–enter–()方法，将返回值赋给as后面的file

八、os模块

os模块与os.path模块用于对目录或文件进行操作

例如，使用os打开可执行文件（打开QQ）：

import os
os.startfile('C:\Program Files (x86)\Tencent\QQ\Bin\qq.exe')

os模块常用函数

getcwd()：返回当前的工作目录

import os
print(os.getcwd())	#E:newStudypython_workspacechap15

listdir(path)：返回指定路径下的文件和目录信息

import os
print(os.getcwd())				#E:newStudypython_workspacechap15
lst = os.listdir('../chap15')	 # ../指退一级目录，因为改文件本身就在chap15文件夹下
print(lst)					   #得到chap15文件夹下的所有文件的列表

mkdir(path[,mode])：创建目录

os.mkdir('newdir')  #在该路径(chap15)下创建文件夹newdir

makedirs(path1/path2,…[,mode])：创建多级目录

os.makedirs('A/B/C')    #在该路径(chap15)下创建文件夹A，A中含B，B中含C

rmdir(path)：删除目录

os.rmdir('newdir')

removedirs(path1/path2…)：删除多级目录

os.removedirs('A/B/C')  #将A，A中的B，B中的C都删除

chdir(path)：将path设置为当前工作目录

os.chdir('E:\newStudy\python_workspace\chap14')
print(os.getcwd())	#E:newStudypython_workspacechap14

os.path模块操作目录相关函数

abspath(path)：获取文件或目录的绝对路径

import os.path
print(os.path.abspath('demo11.py'))	#E:newStudypython_workspacechap15demo11.py

exists(path)：判断文件或目录是否存在，存在返回True，否则False

print(os.path.exists('demo11.py'))	#True

join(path,name)：将目录与目录或者文件名拼接起来

print(os.path.join('E:\newStudy\python_workspace\chap1','demo12.py'))
#	E:newStudypython_workspacechap1demo12.py

split()：分离路径和文件名

print(os.path.split('E:\newStudy\python_workspace\chap15\demo11.py'))
#	('E:\newStudy\python_workspace\chap15', 'demo11.py')

splitext()：分离文件名和扩展名

print(os.path.splitext('E:\newStudy\python_workspace\chap15\demo11.py'))
#	('E:\newStudy\python_workspace\chap15\demo11', '.py')

basename(path)：从一个目录中提取文件名

print(os.path.basename('E:\newStudy\python_workspace\chap15\demo11.py'))
#	demo11.py

dirname(path)：从一个路径中提取文件路径，不包括文件名

print(os.path.dirname('E:\newStudy\python_workspace\chap15\demo11.py'))
#	E:newStudypython_workspacechap15

isdir(path)：用于判断是否为路径

print(os.path.isdir('E:\newStudy\python_workspace\chap15\demo11.py'))	#False 是文件
print(os.path.isdir('E:\newStudy\python_workspace\chap15'))				#True 是目录