Python面向对象

Python面向对象程序设计

面向对象程序设计可看做是一种在程序中包含各种独立而又相互调用的对象思想，与传统的程序设计思想不同（传统的程序一般就是一系列函数或指令的集合），面向对象的程序设计中的每一个对象都应该能够接受数据、处理数据、传递数据给其他对象。面向对象程序设计的灵活性与可维护性，使其在大型项目中被广泛使用

面向对象中的几个基本概念：

类（class）

*类是用来描述具有相同属性和方法的集合。*

实例化

*实例化，即创建一个类的实例（具体对象）。*

类变量

*类变量在整个实例化的过程是公用的。类变量定义在类中，但在函数体外，**_类变量通常不被实例变量使用_**

数据成员

*数据成员，即类变量或实例变量，是用于处理类及其实例对象的相关数据。*

方法

在类中定义的函数。

继承

即一个**派生类（derived class)继承基类（base class)** 的属性和方法。继承是相对的（即允许把一个派生类作为一个基类）

方法重写

若父类的方法不能满足子类的需求，可以对其进行改写，改写后的方法会覆盖父类中的原方法，这个过程叫做方法的重写。

对象

_即类的具体化，包括数据成员（类变量和实例变量）和方法。_

举例说明

class Student:#创建类
    age = 21        #定义类变量
    name = "周文静"
    school = "衡阳师范大学"
    def Say_hello (self):
        return "Hello everybody !"
a = Student()
print("age:", a.age)
print("name：", a.name)
print("school:", a.school)
print(a.Say_hello())
'''
运行效果
age: 21
name： 周文静
school: 衡阳师范大学
Hello everybody !

进程已结束,退出代码0

'''

类的构造方法

许多类都倾向于将对象创建为有初始态的，所以，类可能会定义一个__init_()的特殊方法（构造方法）如果定义了构造方法，那么类的实例化操作会自动调用构造方法。

实例

class Complex:
    def __init__(self, real, image):
        self.realpart = real
        self.imagpart = image
    def Add(self):
        print("x = %.1f + %.1fi"%(self.realpart,self.imagpart))
    def prt(self):
        print("self代表的是类的实例，代表当前对象的地址: ", (self),"\n self.class 指向类：",self.__class__)
x = Complex(3,4.8)
print(x.realpart,"\t", x.imagpart)
x.prt()
x.Add()

'''
运行结果
3 	 4.8
self代表的是类的实例，代表当前对象的地址:  <__main__.Complex object at 0x0000020B568A07F0> 
 self.class 指向类： <class '__main__.Complex'>
x = 3.0 + 4.8i

进程已结束,退出代码0

'''

类的继承

Python 同样支持继承，派生类的定义语法如下：

class DerivedClassName(BaseClassName1,BaseClassName2,···)：
        ···

实例

class People:
    name = ''
    age = 0
    __weight = 0.0  #双下划线开头，私有属性
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w
    def Introduce(self):
        print("My name is %s,I'm %d years old."%(self.name, self.age))
class Student:
   
 grade = ''#调用父类的构造函数
    def __init__(self, n, a, w, g):
        self.grade = g
        People.__init__(self, n , a, w)
    def Introduce(self):#重写父类的构造函数
        print("我叫%s，今年%d岁了，读%s"%(self.name, self.age, self.grade))
s_name = input("please enter your name:")
s_age = int(input("please enter your age:"))
s_weight = float(input("please enter yourn weight："))
s_grade = input("please enter your grade:")
stu = Student(s_name, s_age, s_weight, s_grade)
stu.Introduce()

注意：Python支持多继承，如果一个派生类在调用各基类中都有的方法时，默认调用的是在括号中排前面的父类的方法。

模块

模块是一个包含所有定义的函数和变量的文件，其后缀名是.py，模块可以被别的程序引用，以使用该模块中的函数等。

Ⅰ 、模块的分类：

1）自定义的模块：

自定义模块的过程与Python文件的创建是一样的，但一定要保存到Python的当前目录下才可以直接被调用

2）标准模块：

Python自带一些标准的模块库。如命令行参数 sys模块、操作系统接口os模块、、、

Ⅱ、模块的调用：

            若要调用Python中的某个模块（源文件），只需在另一个源文件里执行import 语句即可。

             import语句：

                            在Python中，使用import或from.....import来导入相应的模块。

                            1.将整个模块导入：mport 模块名

                            2.从某个模块中导入某个函数：from 模块名 import 函数名

                            3.从某个模块中导入多个函数：from 模块名 import 函数名1，函数名2，、、、、

                            4.将某个模块中的全部函数导入：from 模块名 import* 

        *注意：再导入模块时，import后只接模块名，不加后缀py

包

包是一种管理模块命名空间的形式，采用".(点)模块名称"。注意，目录中只有包含一个叫做——init——.py的文件才会被认作是一个包。

变量作用域和类型

变量作用域决定了程序在相应的位置可以访问到的特定的一些变量名称。Python中的作用域有4种，分别是局部作用域（Local）、闭包函数（内嵌函数）外的函数中的（Enclosing)、全局作用域（global）、内建作用域（Built-in）。在Python程序中，解释器由内到外查找变量（即Local>Enclosing>Global>Built-in)

global_x = 0#全局作用域
def out_fun():
    out_x = 2#闭包函数外的函数中
    def inner_fun():
        in_x=8#局部作用域

注意：在Python程序设计中，只有模块（module）、类（class）、以及函数（def、lambda）才会引入新的作用域，而其他代码块（if/elif/else、for/while)不会引入新的作用域（即这些语句内定义的变量，外部也可以引用）。

global与nonlocal关键字

当内部作用域想修改外部作用域的变量时，需要使用global和nonlocal关键字。

栗子说明：

欢迎各位大佬评论关注^ ^