Python的面向对象

1. 面向对象

面向对象程序设计（Object Oriented Programming，OOP）是一种计算机编程架构。OOP达到了软件工程的三个主要目标：重用性、灵活性和扩展性。OOP=对象+类+继承+多态+消息，其中核心概念是类和对象。

面向对象程序设计方法是尽可能模拟人类的思维方式，使得软件的开发方法与过程尽可能接近人类认识世界、解决现实问题的方法和过程，也即使得描述问题的问题空间与问题的解决方案空间在结构上尽可能一致，把客观世界中的实体抽象为问题域中的对象。

面向对象程序设计以对象为核心，该方法认为程序由一系列对象组成。类是对现实世界的抽象，包括表示静态属性的数据和对数据的操作，对象是类的实例化。对象间通过消息传递相互通信，来模拟现实世界中不同实体间的联系。在面向对象的程序设计中，对象是组成程序的基本模块。

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。

方法：类中定义的函数。

方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

局部变量：定义在方法中的变量，只作用于当前实例的类。

实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。

继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系。

实例化：创建一个类的实例，类的具体对象。

对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

2.类和对象

1.类(class):

就是对一类事物的描述，是抽象的，是概念上的定义

2.对象(object):

就是该类事物存在的个体(对象),也叫实例(instance)

3.定义类

class 类名:

类的属性

     方法

如：

class A:

    def f(self):

        print('hello')

4.创建对象

对象名 = 类名()

如：

a = A()

#调用方法

a.f()

#添加属性

a.j = 12

注:

所谓的self，可以理解为自己，就是对象自身的意思。

某个对象调用其方法时，python解释器会把这个对象作为第一个参数传递给self，所以开发者只需要传递后面的参数即可。

3.__init__()方法

    类中有一个名为 __init__() 的特殊方法（即构造方法），该方法在类实例化时会自动调用。可以用作初始化操作

def 类名:

        def __init__(self)::

         pass

4.__str__()方法

当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据

5.__del__()方法

创建对象后，python解释器默认调用__init__()方法；

当删除一个对象时，python解释器也会默认调用一个方法，这个方法为__del__()方法（析构方法）

import time

class Animal(object):



    # 初始化方法

    # 创建完对象后会自动被调用

    def __init__(self, name):

        print('__init__方法被调用')

        self.__name = name





    # 析构方法

    # 当对象被删除时，会自动被调用

    def __del__(self):

        print("__del__方法被调用")

        print("%s对象马上被干掉了..."%self.__name)



# 创建对象

dog = Animal("哈皮狗")

print("程序2秒钟后结束")

time.sleep(2)

# 删除对象

del dog

cat = Animal("波斯猫")

cat2 = cat

cat3 = cat



print("---马上 删除cat对象")

del cat

print("---马上 删除cat2对象")

del cat2

print("程序2秒钟后结束")

time.sleep(2)

print("---马上 删除cat3对象")

del cat3

1. 隐藏数据

我们不直接操作属性，而是把属性封装到方法里面，使用封装后的方法获取或复制属性。

如果有一个对象，当需要对其进行修改属性时，

对象名.属性名 = 数据---->直接修改

对象名.方法名() ---->间接修改

为了更好的保证属性安全，即不能随意修改，一般的处理方式为将属性定义为私有属性

添加一个可以调用的方法，供调用

如果在属性名前面加了2个下划线'__'，则表明该属性是私有属性，否则为公有属性（方法也是一样，方法名前面加了2个下划线的话表示该方法是私有的，否则为公有的）。

class A():

    def __init__(self):

        self.__age = 0

def setAge(self,age):

        self.__age = age

    def getAge(self):

        return self.__age

7.继承extends

在现实生活中，继承一般指的是子女继承父辈的财产，在程序中，继承描述的是事物之间的所属关系，例如猫和狗都属于动物，程序中便可以描述为猫和狗继承自动物

子类在继承的时候，在定义类时，小括号()中为父类的名字

父类的属性、方法，会被继承给子类

class Animal:

    def eat(self):

        print("-----吃----")

    def drink(self):

        print("-----喝----")

    def sleep(self):

        print("-----睡觉----")

    def run(self):

        print("-----跑----")



class Dog(Animal):

    def bark(self):

        print("----叫---")



class Cat(Animal):

    def catch(self):

        print("----抓老鼠----")



#a = Animal()

#a.eat()



wangcai = Dog()

wangcai.eat()



tom = Cat()

tom.eat()

python中是可以多继承的，所谓多继承，即子类有多个父类，并且具有它们的特征

# 定义一个父类

class A:

    def printA(self):

        print('----A----')



# 定义一个父类

class B:

    def printB(self):

        print('----B----')



# 定义一个子类，继承自A、B

class C(A,B):

    def printC(self):

        print('----C----')



obj_C = C()

obj_C.printA()

obj_C.printB()

如果多个父类中，有一个同名的方法，那么通过子类去调用的该方法的时候，和类的对象搜索方法时的先后顺序有关, 小括号中从左到右

class A():

    def test(self):

        print('----A test----')



# 定义一个父类

class B():

    def test(self):

        print('----B test----')



# 定义一个子类，继承自A、B

class C(B,A):

    pass

obj_C = C()

obj_C.test()



print(C.__mro__) #可以查看C类的对象搜索方法时的先后顺序

8.方法重写 override

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

class Cat(object):

    def sayHello(self):

        print("halou-----1")





class Bosi(Cat):



    def sayHello(self):

        print("halou-----2")



bosi = Bosi()



bosi.sayHello()

调用父类的方法

语法格式:

父类类名.父类的方法(self)

super(子类的类名,self).方法名()

super().父类的方法名()

class Cat(object):

    def __init__(self,name):

        print(name)



class Bosi(Cat):



    def __init__(self,name):

        # 调用父类的__init__方法1

        #Cat.__init__(self,name)

        # 调用父类的__init__方法2

        #super(Bosi,self).__init__(name)

        # 调用父类的__init__方法3

        super().__init__(name)

Python的模块和包

1.模块

1.模块概述

模块是一个包含了定义的函数和变量等的文件。模块可以被程序引入，以使用该模块中的函数等功能。

说的通俗点：模块就好比是工具包，要想使用这个工具包中的工具(就好比函数)，就需要导入这个模块

2.import

在Python中用关键字import来引入某个模块,语法如下：

import module1[, module2[,... moduleN]

如：

import sys #引入 python 标准库中的sys模块

sys.argv #是一个包含命令行参数的列表。

sys.path #包含了一个 Python 解释器自动查找所需模块的路径的列表

import math  #引入 python 标准库中的math模块

math.sqrt(2) #取平方根

注：dir() 函数：内置的函数 dir() 可以找到模块内定义的名称。

3.from … import

Python 的 from … import 语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：

from modname import name1[, name2[, ... nameN]]

注：

把一个模块的所有内容全都导入到当前的命名空间，通过from modname import *

4.import...as 语句

给导入的模块起别名

5.模块制作

<1>定义自己的模块

在Python中，每个Python文件都可以作为一个模块，模块的名字就是文件的名字。

比如有这样一个文件test.py，在test.py中定义了函数add

def add(a,b):

    return a+b

<2>调用自己定义的模块

那么在其他文件中就可以先import test，然后通过test.add(a,b)来调用了，当然也可以通过from test import add来引入

import test

result = test.add(11,22)

print(result)

<3>__name__属性

在实际开中，当一个开发人员编写完一个模块后，为了让模块能够在项目中达到想要的效果，这个开发人员会自行在py文件中添加一些测试信息，

例如：

def add(a,b):

    return a+b

# 用来进行测试

ret = add(12,22)

print('int test.py file,,,,12+22=%d'%ret)

如果此时，在其他py文件中引入了此文件的话，测试的那段代码也会执行

至此，可发现test.py中的测试代码，应该是单独执行test.py文件时才应该执行的，不应该是其他的文件中引用而执行

如果想在模块被引入时，模块中的某一程序块不执行，可以用__name__属性来使该程序块仅在该模块自身运行时执行。

每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入。

2.包

包是一种管理 Python 模块命名空间的形式

包将有联系的模块组织在一起，即放到同一个文件夹下，并且在这个文件夹创建一个名字为__init__.py 文件，那么这个文件夹就称之为包

__init__.py 控制着包的导入行为，可以在__init__.py文件中编写内容，当导入时，这些语句就会被执行

如：

 

使用import的方式导入

import msg.sendmsg,msg.recvmsg

使用from .. import  的方式导入

from msg import *

注：在__init__.py文件中写入  __all__=['recvmsg','sendmsg']

3.模块发布

1.mymodule目录结构体如下：

 

 

2.编辑setup.py文件

py_modules需指明所需包含的py文件

from distutils.core import setup

setup(name="my", version="1.0", description="my module", author="tom", py_modules=['suba.aa', 'suba.bb', 'subb.cc', 'subb.dd'])

3.构建模块

python setup.py build

    

 

4.生成发布压缩包

python setup.py sdist

打包后,生成最终发布压缩包

 

4.模块安装、使用

1.安装的方式

找到模块的压缩包

解压

进入文件夹

执行命令python setup.py install

注意：

如果在install的时候，执行目录安装，可以使用python setup.py install --prefix=安装路径

1. 使用pip安装

animal1-1.0.tar.gz 为打包后的文件

--target 为本机python目录

pip3 install animal1-1.0.tar.gz --target=C:UsersEDYAppDataLocalProgramsPythonPython38Lib

1. 模块的引入

在程序中，使用from import 即可完成对安装的模块使用

from 模块名 import 模块名或者*

5.常用模块

os 模块提供用来处理文件和目录

random模块用于生成随机数。

random.random() 用于生成一个0到1的,随机浮点数：0<= n < 1.0

random.randint(a, b) 用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数n: a <= n <= b

math 模块提供了许多数学运算函数。

pi:数字常量，圆周率

ceil:取大于等于x的最小的整数值，如果x是一个整数，则返回x

floor:取小于等于x的最大的整数值，如果x是一个整数，则返回自身

pow:返回x的y次方，即x**y

sqrt:求x的平方根

time、datetime模块和 calendar 模块可以处理日期和时间

time模块

import time;  # 引入time模块

ticks = time.time()

print("当前时间戳为:", ticks) #时间戳单位最适于做日期运算。

1.获取当前时间，将时间戳传递给如localtime之类的函数。

localtime = time.localtime(time.time())

print ("本地时间为 :", localtime)

struct_time元组。这种结构具有如下属性:

 

2.获取格式化的时间

可以根据需求选取各种格式，但是最简单的获取可读的时间模式的函数是asctime():

import time

localtime = time.asctime( time.localtime(time.time()) )

print ("本地时间为 :", localtime)

3.格式化日期

可以使用 time 模块的 strftime 方法来格式化日期：

import time

# 格式化成2016-03-20 11:45:39形式

print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))

# 格式化成Sat Mar 28 22:24:24 2016形式

print(time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()))

# 将格式字符串转换为时间戳

a = "Sat Mar 28 22:24:24 2016"

print(time.mktime(time.strptime(a, "%a %b %d %H:%M:%S %Y")))

 注：

 python中时间日期格式化符号：

%y 两位数的年份表示（00-99）

%Y 四位数的年份表示（0000-9999）

%m 月份（01-12）

%d 月内中的一天（0-31）

%H 24小时制小时数（0-23）

%I 12小时制小时数（01-12）

%M 分钟数（00=59）

%S 秒（00-59）

%a 本地简化星期名称

%A 本地完整星期名称

%b 本地简化的月份名称

%B 本地完整的月份名称

%c 本地相应的日期表示和时间表示

%j 年内的一天（001-366）

%p 本地A.M.或P.M.的等价符

%U 一年中的星期数（00-53）星期天为星期的开始

%w 星期（0-6），星期天为星期的开始

%W 一年中的星期数（00-53）星期一为星期的开始

%x 本地相应的日期表示

%X 本地相应的时间表示

%Z 当前时区的名称

%% %号本身

datetime模块

1.获取当前日期和时间

from datetime import datetime

now = datetime.now()

print(now)    # 2017-09-01 10:28:47.663625

print(type(now))  # <class 'datetime.datetime'>

注：

datetime是模块，datetime模块还包含一个datetime类，通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime，则必须引用全名datetime.datetime。

datetime.now()返回当前日期和时间，其类型是datetime。

2.获取指定日期和时间

要指定某个日期和时间，我们直接用参数构造一个datetime：

from datetime import datetime

dt = datetime(2017,9,1,12,40,12)

print(dt)  #2017-09-01 12:40:12

print(type(dt)) #<class 'datetime.datetime'>

把一个datetime类型转换为timestamp只需要简单调用timestamp()方法：

from datetime import datetime

dt = datetime(2017,9,1,12,40,12)

print(dt.timestamp())  #1504240812.0

要把timestamp转换为datetime，使用datetime提供的fromtimestamp()方法：

from datetime import datetime

t = 1504240812.0

print(datetime.fromtimestamp(t)) #2017-09-01 12:40:12

datetime与str的转换

now = datetime.now()

print(now.strftime("%Y-%m-%d %H:%M:%S"))

calendar模块

import calendar

#打印2019年的日历

print(calendar.calendar(2019))

#打印2019年8月的日历

print(calendar.month(2019, 8))

#判断是否是闰年

print(calendar.isleap(2000))

#返回元组,两个整数。第一个是该月的第一天是星期几（星期几是从0（星期一） 到 6（星期日）），第二个是该月的总天数

print(calendar.monthrange(2020,3))

#返回星期几(0（星期一）到6（星期日）)

print(calendar.weekday(2020,3,18))

最后

以上就是端庄狗为你收集整理的Python的面向对象、模块和包Python的面向对象2.类和对象3.__init__()方法4.__str__()方法5.__del__()方法7.继承extends8.方法重写 overridePython的模块和包1.模块2.包3.模块发布4.模块安装、使用5.常用模块的全部内容，希望文章能够帮你解决Python的面向对象、模块和包Python的面向对象2.类和对象3.__init__()方法4.__str__()方法5.__del__()方法7.继承extends8.方法重写 overridePython的模块和包1.模块2.包3.模块发布4.模块安装、使用5.常用模块所遇到的程序开发问题。

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