自定义模块+python面向对象+综合案例

一、模块

1.自定义模块

1.1import模块

代码演示：

moduleDemo01.py

def fun1():print("fun~~~~111")def fun2():print("fun~~~~222")def fun3():print("fun~~~~333")def fun4():print("fun~~~~444")num =10fun1()fun2()

moduleDemo02.py

def fun1():print("fun~~~~111")def fun2():print("fun~~~~222")

textDemo01.py

#2.如果需要导入的模块有多个，使用一个import，多个模块之间使用逗号隔开;也可以使用多个import，每个import相当于一条语句#import module01.moduleDemo01,module01.moduleDemo02import module01.moduleDemo01import module01.moduleDemo02#3.同一个模块如果被导入多次，只有第一次会加载源文件，其他的导入没有任何意义#【单例设计模式：只有当第一次import的时候，会去加载源文件，# 同时生成了一个.pyc文件，当第二次甚至第三次再import的时候，将不再加载源文件，直接去加载.pyc文件】#import module01.moduleDemo01#1.导入模块，调用其中的函数或者访问其中的变量#格式：包名.模块名.函数（） 或者 包名.模块名.变量module01.moduleDemo01.fun3()print(module01.moduleDemo01.num)#4.如果同时导入的多个模块中有重名的函数，调用函数的时候，可以通过函数所在的位置区分module01.moduleDemo01.fun1()module01.moduleDemo02.fun1()"""总结：1.模块的好处：提高代码的复用性，提高代码的可维护性2.通过import的方式导入，每次调用函数或者访问变量的时候都需要指明模块的路径，所以import多用来导入系统模块import os,random,math"""

1.2from-import 函数或者变量

1.3from-import *

代码演示：

moduleDemo01.py

def fun1():print("fun~~~~111")def fun2():print("fun~~~~222")def fun3():print("fun~~~~333")def fun4():print("fun~~~~444")num =10#fun1()#fun2()

moduleDemo02.py

def fun1():print("fun~~~~111~~~~")def fun2():print("fun~~~~222~~~~~")

moduleDemo03.py

def fun31():print("fun~~~~111")def fun32():print("fun~~~~222")def fun33():print("fun~~~~333")def fun34():print("fun~~~~444")

textDemo02.py

#from...import#语法：from 包名.模块名 import 函数名或者变量名或者类名#注意：从xxx导入xx#1.导入不同的函数或者变量或者类名，使用逗号隔开from module02.moduleDemo01 import fun1,fun2,numfrom module02.moduleDemo02 import fun1,fun2from module02.moduleDemo03 import *#2.通过from。。。import的方式导入模块之后，调用函数或者访问变量#格式：函数名()fun1()fun2()#3.如果没有指明哪个函数被导入，则相当于该函数未被定义#fun3()#3.通过form---import的方式导入模块，如果不同的模块中存在重名的函数，则后出现的会覆盖掉先出现的【就近原则】def fun1():print("hello")fun1()#4.如果一个模块中需要被导入的函数或者变量比较多的情况下，分别导入比较麻烦，可以使用from ... import *#select * from 表fun31()fun32()#5.要访问一个模块中的变量，也可以和函数一样使用【函数名就是一个变量名】num = 100print(num)"""导入自定义模块：import 包名.模块名.函数名(实参)from...import 函数名(实参)"""

2.name属性和dir函数

2.1name属性

__name__:如果指定的py文件作为模块的话，如果不想让其中的某些代码执行，则可以使用该属性进行屏蔽语法：if __name__ == "__main__":#不希望运行其他py文件时被执行的代码注意：每个模块都有一个__name__属性，代表了模块的名字，当他的值为__main__的时候，说明是当前模块在运行，反之，则表示是其他模块在运行，只是导入了当前模块

代码演示：

moduleDemo01.py

def fun1():print("fun~~~~111")def fun2():print("fun~~~~222")def fun3():print("fun~~~~333")num =10if __name__ == "__main__":def fun4():print("fun~~~~444")fun1()fun2()fun3()fun4()

textDemo03.py

from module03.moduleDemo01 import *fun1()fun2()#fun4()

2.2dir函数

代码演示：

import os,random#列出一个指定模块中的所有内容【函数，变量】，返回一个列表print(dir(os))

二、面向对象

1.面向对象的思想

1.1案例

万物皆对象

面向过程【process】和面向对象

举例说明：

案例一：我今天想吃大盘鸡

面向过程 面向对象

1.自己去买菜 1.委托一个人去帮忙买菜

2.自己择菜 2.委托一个人择菜

3.自己做菜 3.委托一个人做菜

4.自己吃 4.自己吃

案例二：小明是一个电脑小白，想要组装一台电脑

面向过程 面向对象

1.小明补习电脑知识 1.委托一个洞电脑知识的人去买零件

2.小明去买零件 2.委托一个动手能力强的人组装

3.小明组装 3.小明打游戏

4.小明打游戏

案例三：一辆白色的奥迪行驶在京藏高速上

1.2面向对象和面向过程的区别

面向过程

​ 在生活案例中：一种看待问题的思维方式，在思考问题的时候，侧重于问题是怎样一步一步解决的，然后亲力亲为的去解决问题

​ 在程序中：代码从上往下依次执行；程序流程在写程序的时候已经决定；顺序结构，分支结构，循环结构

面向对象：

​ 在生活案例中：一种看待问题的思维方式，在思考问题的时候，侧重于能够找到一个具有特殊功能的实体，然后委托该实体去帮忙完成某件事情

​ 在程序中：将多个具有特殊功能的实体集合到一起，形成一个类，其中某个具体的实体被称为对象；程序流程由需求决定

注意:面向对象的核心是类和对象

​ 使用面向对象进行开发，先要找到具有特殊功能的实体【对象】，如果有，则直接使用，如果没有，则可以创建

​ 面向对象只是一种编程思想，并不是一门编程语言

2.类和对象

2.1类和对象的概念

类：一个具有特殊功能的实体的集合【群体】

对象：在一个类中，一个具有特殊功能的实体，能够帮忙完成某件事情【对象也被称为实例】

两者之间的关系：类用于描述某一类对象的共同特征，而对象是类的具体的存在

问题：先有类，还是先有对象？

【在程序中，一般先定义类，然后再通过类创建对象】

举例：

​ 类 对象

​ 快递 圆通，中通，，，

​ 人

注意：类也是一种数据类型，只不过是自定义的，创建对象的过程其实就是定义类变量的过程

2.2类和对象的使用

a.类的定义

语法：

class 类名():

​ 类体

说明：

​ a.Python中通过关键字class定义类

​ b.类名:只要是一个合法的标识符即可，但是，尽量采用大驼峰命名

​ 举例：Iterator ValueError KeyError TypeError

​ c.():目前（）是空的，也可以省略

​ d。通过缩进来体现类体的存在

​ e.类体一般由两部分组成：类的特征和类的行为

代码演示：

#类的定义class MyClass():pass#注意：在同一个py文件中可以同时定义多个类，但是，一般情况下，采用包的方式使用，一个类一个模块class MyClass1():pass

b.类的设计

事物名称:【类名】，人【Person】

事物的特征:【变量】，身高【height】,年龄【age】 ------>名词

事物的行为：【函数】，吃，跑-------》动词

3.类中的方法和属性

3.1定义

类单独存在没有任何意义，所以，定义类其实就是定义类中的成员【成员变量，成员方法】

成员变量：类中定义的变量，也被称为属性

成员方法：类中定义的方法

注意：如果多个对象具有相同的特性和行为，则可以抽取出来一个类【相同的属性和方法】

代码演示：

#一、定义类#1.事物的名称：类名class Person():#2.事物的特征：成员变量/属性name = "hello"age = 0height = 0.0#3.事物的行为：成员方法/成员函数"""1.区别于普通方法，类中的成员方法，参数部分一定有self，而且存在于形参列表的第一个2.调用成员函数，self不需要被手动传参3.self不是Python的关键字，可以是任意的标识符，为了结合其他编程语言的使用，习惯上使用self4.如果要给成员函数设置参数，则在self后面进行添加，如果没有参数，self也不能省略5.self:自己，代表类的实例【对象】"""def eat(self,food):print(id(self))print("eating" + food)def run(self):print("running")

3.2对象的创建【对象的实例化】

语法:对象名 = 类名()

注意：对象的创建过程其实就是对象实例化的过程，创建对象其实相当于定义了一个类的变量

num = 10

代码演示：

#二、对象的创建#实例化一个对象，p1也被为变量，引用，对象，# 严格意义上来说，p1不是一个对象，只是一个指向一个对象的引用p1 = Person()print(type(p1)) #<class '__main__.Person'>num = 10print(type(num)) #<class "int">print(id(p1))p2 = Person()print(id(p2))

3.3内存中的对象

扩展：内存分类

​ a.寄存器：最快的存储区，由编译器根据需求进行内存分配，我们在程序中无法控制

​ b.栈：存储对象的引用，但是对象本身不存储在栈中，存储在堆中

​ 特点：被执行完成之后，函数或者引用所占用的空间会立马被释放

​ c.堆：存储所有创建出来的对象

​ 特点：执行完不会立即被释放，当使用完成之后，会被标记上垃圾的标识，等待系统的垃圾回收机制回收【建议：当一个引用没有指向或者不确定该指向谁的时候，引用一般指向None】

​ d.方法区

​ 静态域：存放静态成员

​ 常量池：所有数据类型的常量

代码演示：

#三、内存中的对象num = 10 #num存储在栈中，10存储在堆中p3 = Person() #p3存储在栈中，Person（）真正的对象存储在堆中

3.4成员变量和成员方法的使用

代码演示：

四、访问类中的成员变量和调用类中的成员方法#1.访问属性#语法：对象.属性名#赋值：对象.属性名 = 新值per1 = Person()print(per1.name)print(per1.age)print(per1.height)#赋值per1.name = "zhangsan"print(per1.name)#2.调用函数#语法;对象.函数（实参）#self：self不需要被手动传参，系统会自动传参，传的是当前的对象【谁调用该函数，其中的self代表的就是谁】per1.eat("apple")print(id(per1))#per2 = per1 #self = per1per1.run()

4.动态绑定属性和限制绑定

代码演示：

#1.动态绑定属性#对象可以任意访问一个类中没有被定义的属性class MyClass1():num1 = 10num2 = 20def fun1(self):print("1111")def fun2(self):print("2222")#创建对象c1 = MyClass1()print(c1.num1)print(c1.num2)c1.fun1()c1.fun2()c2 = MyClass1()c2.num3 = 100#注意：动态绑定属性的时候，只是绑定给了指定的对象，其他的对象都没有该属性print(c2.num3)#print(c1.num3) #AttributeError: 'MyClass1' object has no attribute 'num3'c1.num3 = 37print(c1.num3)#注意：动态绑定属性，只是绑定给了指定的对象，并没有绑定给类del c1.num3print(c2.num3)#2.限制绑定#__slots__class MyClass2():name = ""age = 0#限制属性：被限制绑定的属性通过字符串的名称保存在一个元组中__slots__ = ("num1","num2")m1 = MyClass2()m1.num1 = 32m1.num2 = 36print(m1.num1,m1.num2)m1.num3 = 66print(m1.num3) #AttributeError: 'MyClass2' object has no attribute 'num3'

综合案例一

代码演示：

practiceDemo01.py

#测试文件"""需求：开学了，王老师让小明，小花，小丽做自我介绍需要介绍姓名，年龄，爱好，一段才艺展示分析：老师类特征：姓名行为：让xx做自我介绍学生类：特征：姓名，年龄，爱好行为：一段才艺展示"""from practice01.teacher import Teacherfrom practice01.student import Student#1.创建一个老师的对象wang = Teacher()#给老师的对象的属性赋值wang.name = "王老师"#2.创建学生的对象xiaoming = Student()#给学生对象的属性赋值xiaoming.name = "小明"xiaoming.age = 18xiaoming.hobby = "吹牛逼"#3.让老师执行自己的行为wang.letStuIntroduce(xiaoming)xiaohua = Student()xiaohua.name = "小花"xiaohua.age = 18xiaohua.hobby = "唱歌"wang.letStuIntroduce(xiaohua)

teacher.py

#实体文件"""老师类特征：姓名行为：让xx做自我介绍"""class Teacher():#特征：姓名name = ""#行为：让xx做自我介绍#stu；传值的时候，需要传的是一个学生的对象def letStuIntroduce(self,stu):print(self.name + "让" + stu.name + "做自我介绍")#学生开始做自我介绍stu.introduce()#做才艺展示:不同的学生有不同的才艺展示if stu.name == "小花":stu.sing()elif stu.name == "小丽":stu.dance()else:stu.lie()"""xiaoming = Student()stu = xiaomingnum1 = 10num2 = num1"""

student.py

#实体文件"""学生类：特征：姓名，年龄，爱好行为：做自我介绍，一段才艺展示"""class Student():#特征：姓名，年龄，爱好name = ""age = 0hobby = ""#行为：做自我介绍，一段才艺展示def introduce(self):print("大家好，我是%s,年龄：%d,爱好:%s" % (self.name,self.age,self.hobby))def sing(self):print("娘子~啊哈")def dance(self):print("广场舞")def lie(self):print("吹牛逼")

6.构造函数和析构函数

6.1构造函数

构造函数也被称为构造器,当创建对象的时候第一个被自动调用的函数per = Person()语法：def __init__(self，arg1,arg2....):函数体说明：a.之前的写法中没有显式的定义一个构造函数，所以系统默认提供了一个无参的构造函数b.__init__是构造函数的函数名，是固定写法c.arg1,arg2....可以根据具体的需求自定义，但是，一般情况下，构造函数的形参和成员变量有关d.构造函数的作用：创建对象，给对象的成员变量赋值

代码演示：

#1.构造函数调用的时机class Check1():#成员变量num1 = 10s1 = ""#成员方法def func(self):print("func")#构造函数def __init__(self):print("hello")c1 = Check1()c1.func()c1.func()c1.func()"""【构造函数和成员函数之间的区别】1.成员函数的函数名可以自定义，但是，构造函数的函数名是固定的，就是__init__2.成员函数必须手动调用，但是。构造函数是在创建对象的过程中自动被调用的3.对于同一个对象而言，成员函数可以被调用多次，但是，构造函数只能被调用一次"""#2.给构造函数添加参数class Check2():#成员变量num1 = 10s1 = ""#成员方法def func(self):print("func")#构造函数"""def __init__(self,n,s):print("构造函数被指定了")def __init__(self):print("构造函数被指定了")"""#注意2：在Python中，一个类中的构造函数只能出现一个，为了满足不同的需求，可以使用不定长参数def __init__(self,*args):print("构造函数被执行了")#注意1：当在类中显式定义了构造函数，并且给构造函数设置了参数，则系统将不再提供无参的构造函数，# 所以创建对象的时候，类中的构造函数需要什么样的参数，则传相应的实参c2 = Check2(34,"abc")c21 = Check2()#3.构造函数的作用：给成员变量赋值class Check3():#成员变量num1 = 0s1 = ""#成员方法def func(self):print("func")#构造函数#构造函数的形参列表：一般和成员变量有关def __init__(self,n,s):#实例属性num1 = ns1 = sc3 = Check3(10,"he")print(c3.num1,c3.s1)print("*********")#4.self的使用class Check4():#成员变量#类属性：属于类num1 = 0s1 = ""#成员方法def func(self):print("func")#构造函数#构造函数的形参列表：一般和成员变量有关def __init__(self,num1,s1):#实例属性：属于对象#self的作用：通过self区分成员变量和局部变量self.num1 = num1self.s1 = s1c4 = Check4(10,"he")print(c4.num1,c4.s1)#5.使用了self之后，则可以省略类属性class Check5():#构造函数def __init__(self, num1, s1):#成员变量self.num1 = num1self.s1 = s1#成员方法def func(self):print("func")c5 = Check5(10,"abc")print(c5.num1,c5.s1)c5.num1 = 100c5.s1 = "hello"#总结：一般情况下，在一个类中，包含构造函数和成员函数，在构造函数中，定义成员变量，# 并给成员变量赋值，通过有参的构造函数赋值

综合案例二

practiceDemo02.py

#测试文件"""需求：富二代王思聪开着豪车玛莎拉蒂，很自豪的向他的新女友炫耀起来分析：富二代类特征;姓名行为：开车，炫耀汽车类：特征：品牌，颜色行为：行驶女友类特征：姓名"""from practice02.richman import RichManfrom practice02.car import Carfrom practice02.girlfriend import GirlFriend#1.创建富二代对象r = RichMan("王思聪")#2.创建女友对象g = GirlFriend("凤姐")#3.创建汽车的对象c = Car("五菱宏光","银白色")#4.让富二代执行自己的行为r.driveCar(c)r.show(g,c)

richman.py

"""富二代类特征;姓名行为：开车，炫耀"""class RichMan():def __init__(self,name):self.name = name#行为def driveCar(self,car):print("富二代%s开车他的豪车%s" % (self.name,car.brand))def show(self,gf,car):print("向%s炫耀豪车，你看，我这豪车%s,你瞅瞅这颜色%s" % (gf.name,car.brand,car.color))

girlfriend.py

"""女友类特征：姓名"""class GirlFriend():def __init__(self,name):self.name = name

car.py

"""汽车类：特征：品牌，颜色行为：行驶"""class Car():def __init__(self,brand,color):self.brand = brandself.color = colordef run(self):print("running")

如果觉得《自定义模块+python面向对象+综合案例》对你有帮助，请点赞、收藏，并留下你的观点哦！