Python 类和模块的使用

(一)类的使用

1.面向对象技术简介

1.类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
2.类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
3.数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
4.方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
5.实例变量：定义在方法中的变量，只作用于当前实例的类。
6.继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。
7.实例化：创建一个类的实例，类的具体对象。
8.方法：类中定义的函数。
9.对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

2.定义一个类，格式如下:

class 类名:
    方法列表
    
定义类时有2种：新式类和经典类，上面的Person为经典类，如果是Person(object)则为新式类。

3.创建对象的格式为:

对象名 = 类名()

4.类中特殊方法

创建对象后，python解释器默认调用__init__()方法，其他的__xxx()__方法python解释器也会默认调用__xxx()__方法。

例：定义一个Personr类

#1.定义一个Person类
class Person:
    #2.定义类变量
    name='张三'
    age=''
    __money=100
    #3.定义构造函数
    def __init__(self):
        print("无参构造方法")
    def __init__(self,name,age,money):
        print("含参构造方法")
        #4.定义实例变量
        self.name=name
        self.age=age
        self.__money=money
    #5.定义实例方法
    def  showName(self):
        print('1.实例方法可以访问实例变量！比如：self.name')
        print('2.实例方法可以访问类变量！比如：Person.name')
        print('3.实例方法可以访问类的私有变量!比如Person.__money')
        print('4.实例方法可以访问实例对象的私有变量!比如self.__money')
        print("姓名--"+self.name)
        print("姓名--" + Person.name)
        print("财产--"+str(Person.__money))
        print("财产--" + str(self.__money))
    def  showInfo(self,name,age,country='中国'):
        print("实例方法含有多个参数")
        print("姓名--"+self.name,"年龄--"+str(age),"国籍--"+country)
    #6.定义类方法
    @classmethod
    def classMethod(cls):
        print("1.类方法只能私有类属性，不能访问实例属性！比如:Person.name")
        print("2.类方法中可以有多个参数")
        print("姓名--"+Person.name)
        print("财产--"+str(Person.__money))
    #7.定义静态方法
    @staticmethod
    def staticmMthod():
        print("1.静态方法,只能访问类属性，无法访问实例属性！")
        print("姓名--" + Person.name)
        print("财产--" + str(Person.__money))

#8创建实例对象
p=Person('Kaina',22,888)
#9.调用实例方法 p.showName()
p.showName()
#10.调用类方法，类名+方法名或对象+方法名
Person.classMethod()
p.classMethod()
#11.调用静态方法,调用类方法，类名+方法名或对象+方法名
p.staticmMthod()
Person.staticmMthod()

结果演示：
含参构造方法
1.实例方法可以访问实例变量！比如：self.name
2.实例方法可以访问类变量！比如：Person.name
3.实例方法可以访问类的私有变量!比如Person.__money
4.实例方法可以访问实例对象的私有变量!比如self.__money
姓名--Kaina
姓名--张三
财产--100
财产--888
1.类方法只能私有类属性，不能访问实例属性！比如:Person.name
2.类方法中可以有多个参数
姓名--张三
财产--100
1.类方法只能私有类属性，不能访问实例属性！比如:Person.name
2.类方法中可以有多个参数
姓名--张三
财产--100
1.静态方法,只能访问类属性，无法访问实例属性！
姓名--张三
财产--100
1.静态方法,只能访问类属性，无法访问实例属性！
姓名--张三
财产--100

---

(二)类的继承

1.类的三大特征：封装、继承、多态

2.继承的作用：简化代码编写，提高编程效率(继承指的是继承父类的所有属性和方法，但私有方法无法继承)

3.单继承实例演示

#1.定义一个父类
class Person:
    name='张三'
    age=28
    #此属性无法被子类继承
    __money=100000
    count=0
    def __init__(self,name,age):
        self.name=name
        self.age=age
        #计算创建Person对象的个数
        self.count+=1
    def study(self):
        print("行为：-----学习-----")
    def __wife(self):
        print("老婆自己私有，儿子没法继承！")
    @classmethod
    def eat(cls):
        print("行为：-----吃饭-----")
    @staticmethod
    def sleep():
        print("行为：-----睡觉-----")

#2.定义一个子类并继承父类
class Student(Person):
    depart='IT'
    def __init__(self,name,age,country):
        #3.使用super()访问父类的构造方法中的属性
        super().__init__(name,age)
        self.country=country
        print("姓名--"+self.name,"年龄--"+str(self.age),"国家--"+country)
s=Student('Kaina',22,'中国')
#4.访问父类的study()方法
s.study()
#5.访问父类的eat()方法
Student.eat()
#6.访问父类的sleep()方法
s.sleep()

结果演示：
姓名--Kaina 年龄--22 国家--中国
行为01：-----学习-----
行为02：-----吃饭-----
行为03：-----睡觉-----

4.多继承实例演示

01.多继承的格式

class xxx(父类01,父类02...父类n)

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()

结果演示：
----A----
----B----

---

5.重写父类方法

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

# 1.定义一个父类
class Person(object):
    def height(self,height):
        pass
# 2.定义一个子类Children
class Children(Person):
    def height(self,height):
        print("小孩身高："+str(height)+"cm")
#3.定义一个子类Adult
class Adult(Person):
    def height(self,height):
        print("成年人身高："+str(height)+"cm")
print("不同实例对象调用相同的方法，产生的结果不同！")
c=Children()
c.height(150)
a=Adult()
a.height(170)

结果演示：
不同实例对象调用相同的方法，产生的结果不同！
小孩身高：150cm
成年人身高：170cm

---

(三)模块知识点

(01).模块的概念：在Python中模块就以.py结尾的文件，一个模块中可以写任意多个类和函数。

(02).从模块中导入类和函数的方式：

01.导入一个类：from 文件夹名.模块名 import 类名

02.导入多个类：from 文件夹名.模块名 import 类名01，类名02...类名n

03.导入所有类：from 文件夹名.模块名 import*

04.导入一个函数：from 文件夹名.模块名 import 函数名

05.导入多个函数：from 文件夹名.模块名 import 函数名01,函数名02...函数名n

06.导入所有函数：from 文件夹名.模块名 import*

07.导入类和函数：from 文件夹名.模块名 import 类名, 函数名

(03)实例演示

1.在ClassDemo文件夹下创建Person类

class Person:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def showInfo(self):
        print("姓名--"+self.name,"年龄--"+str(self.age))

2.在ClassDemo文件夹下创建Student类

from ClassDemo.Person import Person
class Student(Person):
    def __init__(self,name,age):
        super().__init__(name,age)
    def introduce(self):
        print("热爱编程，热爱Python")
s=Student('Kaina',22)
s.showInfo()
s.introduce()

结果演示：
姓名--Kaina 年龄--22
热爱编程，热爱Python