自定义模块+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.moduleDemo02
import  module01.moduleDemo01
import  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,num
from module02.moduleDemo02 import  fun1,fun2
from 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 = 100
print(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 = 10
print(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 = 37
print(c1.num3)#注意：动态绑定属性，只是绑定给了指定的对象，并没有绑定给类
del c1.num3
print(c2.num3)#2.限制绑定
#__slots__
class MyClass2():name  = ""age = 0#限制属性：被限制绑定的属性通过字符串的名称保存在一个元组中__slots__ = ("num1","num2")m1 = MyClass2()
m1.num1 = 32
m1.num2 = 36
print(m1.num1,m1.num2)
m1.num3 = 66
print(m1.num3)  #AttributeError: 'MyClass2' object has no attribute 'num3'

综合案例一

代码演示：

practiceDemo01.py

#测试文件
"""
需求：开学了，王老师让小明，小花，小丽做自我介绍
需要介绍姓名，年龄，爱好，一段才艺展示分析：
老师类特征：姓名行为：让xx做自我介绍学生类：特征：姓名，年龄，爱好行为：一段才艺展示
"""
from  practice01.teacher import Teacher
from practice01.student import Student#1.创建一个老师的对象
wang = Teacher()
#给老师的对象的属性赋值
wang.name = "王老师"#2.创建学生的对象
xiaoming = Student()
#给学生对象的属性赋值
xiaoming.name = "小明"
xiaoming.age = 18
xiaoming.hobby = "吹牛逼"#3.让老师执行自己的行为
wang.letStuIntroduce(xiaoming)xiaohua = Student()
xiaohua.name = "小花"
xiaohua.age = 18
xiaohua.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 = 10
num2 = 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 = 100
c5.s1 = "hello"#总结：一般情况下，在一个类中，包含构造函数和成员函数，在构造函数中，定义成员变量，
# 并给成员变量赋值，通过有参的构造函数赋值

综合案例二

practiceDemo02.py

#测试文件
"""
需求：富二代王思聪开着豪车玛莎拉蒂，很自豪的向他的新女友炫耀起来分析：
富二代类特征;姓名行为：开车，炫耀
汽车类：特征：品牌，颜色行为：行驶女友类特征：姓名
"""
from practice02.richman import RichMan
from  practice02.car import Car
from 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面向对象+综合案例相关推荐

Python模块、包与面向对象综合案例
目录一.Python内置模块 1.什么是Python模块 2.模块的分类 3.模块的导入方式 4.使用import导入模块 5.使用from 模块名 import 功能名 ☆ from 模块名 im ...
Python面向对象封装案例——士兵突击
面向对象封装案例 II 目标士兵突击案例身份运算符封装封装是面向对象编程的一大特点面向对象编程的第一步 -- 将属性和方法封装到一个抽象的类中外界使用类创建对象, ...
Python面向对象编程案例：封装数据库增删改查操作
问题描述:编写一个类,封装对SQLite数据库的增删改查操作,使得数据库操作更加友好,类的使用者不需要了解SQL语句的语法规则,只需要了解类的接口即可. 思考下面的问题,尝试着写一写,然后到达文末查看 ...
整理了 70 个 Python 面向对象编程案例，怎能不收藏？
作者 | 周萝卜来源 | 萝卜大杂烩 Python 作为一门面向对象编程语言,常用的面向对象知识怎么能不清楚呢,今天就来分享一波文章很长,高低要忍一下,如果忍不了,那就收藏吧,总会用到的在 Py ...
Python(面向对象)--阶段案例——反恐精英CS
反恐精英CS案例游戏说明: 在全世界风靡起来的反恐精英是一种以团队合作为主的第一人称射击游戏,简称CS.根据面向对象的编程思维,模拟实现一个战士开枪射击敌人的场景. 游戏中主要包含两个角色:战士(玩 ...
Python面向对象实现案例——士兵突击
#一个对象的属性可以时另外一个类创建的对象 class Gun:def __init__(self,model):#1.枪的型号self.model=model#2.子弹的数量self.bullet_ ...
python数据分析--综合案例3
数据来源:泰坦尼克逃生数据知识点:特征处理和随机森林预测主要内容: 缺失值处理 1. 对Embarked字段直接用众数填充 2. 对船票Fare字段用均值填充 3. 建立预测模型,填充年龄Age字 ...
Java 面向对象综合案例
代码01 public class Movie {private int id;private String title;private String time;private double scor ...
[转载] python面向对象编程实例
参考链接: Python面向对象编程案例介绍本案例设计的是:为购置的新房添置家具,在本案例中,我们需要给出指定的房屋和面积,在为其添置家具的过程中,各家具的面积之和不能超过房屋面积的总和.房屋及家 ...

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

一、模块

1.自定义模块

1.1import模块

1.2from-import 函数或者变量

1.3from-import *

2.name属性和dir函数

2.1name属性

2.2dir函数

二、面向对象

1.面向对象的思想

1.1案例

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

2.类和对象

2.1类和对象的概念

2.2类和对象的使用

a.类的定义

b.类的设计

3.类中的方法和属性

3.1定义

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

3.3内存中的对象

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

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

综合案例一

6.构造函数和析构函数

综合案例二

自定义模块+python面向对象+综合案例相关推荐

最新文章

热门文章