一、模块
1.自定义模块
1.1import模块
代码演示:
def fun1(): print("fun~~~~111") def fun2(): print("fun~~~~222") def fun3(): print("fun~~~~333") def fun4(): print("fun~~~~444") num =10 fun1() fun2()
def fun1(): print("fun~~~~111") def fun2(): print("fun~~~~222")
#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 *
代码演示:
def fun1(): print("fun~~~~111") def fun2(): print("fun~~~~222") def fun3(): print("fun~~~~333") def fun4(): print("fun~~~~444") num =10 #fun1() #fun2()
def fun1(): print("fun~~~~111~~~~") def fun2(): print("fun~~~~222~~~~~")
def fun31(): print("fun~~~~111") def fun32(): print("fun~~~~222") def fun33(): print("fun~~~~333") def fun34(): print("fun~~~~444")
#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__的时候,说明是当前模块在运行,反之,则表示是其他模块在运行,只是导入了当前模块
代码演示:
def fun1(): print("fun~~~~111") def fun2(): print("fun~~~~222") def fun3(): print("fun~~~~333") num =10 if __name__ == "__main__": def fun4(): print("fun~~~~444") fun1() fun2() fun3() fun4()
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 = 0 height = 0.0 #3.事物的行为:成员方法/成员函数 """ 1.区别于普通方法,类中的成员方法,参数部分一定有self,而且存在于形参列表的第一个 2.调用成员函数,self不需要被手动传参 3.self不是Python的关键字,可以是任意的标识符,为了结合其他编程语言的使用,习惯上使用self 4.如果要给成员函数设置参数,则在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 = per1 per1.run()
4.动态绑定属性和限制绑定
代码演示:
#1.动态绑定属性 #对象可以任意访问一个类中没有被定义的属性 class MyClass1(): num1 = 10 num2 = 20 def 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'
综合案例一
代码演示:
#测试文件 """ 需求:开学了,王老师让小明,小花,小丽做自我介绍 需要介绍姓名,年龄,爱好,一段才艺展示 分析: 老师类 特征:姓名 行为:让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)
#实体文件 """ 老师类 特征:姓名 行为:让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 = xiaoming num1 = 10 num2 = num1 """
#实体文件 """ 学生类: 特征:姓名,年龄,爱好 行为:做自我介绍,一段才艺展示 """ class Student(): #特征:姓名,年龄,爱好 name = "" age = 0 hobby = "" #行为:做自我介绍,一段才艺展示 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 = 10 s1 = "" #成员方法 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 = 10 s1 = "" #成员方法 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 = 0 s1 = "" #成员方法 def func(self): print("func") #构造函数 #构造函数的形参列表:一般和成员变量有关 def __init__(self,n,s): #实例属性 num1 = n s1 = s c3 = Check3(10,"he") print(c3.num1,c3.s1) print("*********") #4.self的使用 class Check4(): #成员变量 #类属性:属于类 num1 = 0 s1 = "" #成员方法 def func(self): print("func") #构造函数 #构造函数的形参列表:一般和成员变量有关 def __init__(self,num1,s1): #实例属性:属于对象 #self的作用:通过self区分成员变量和局部变量 self.num1 = num1 self.s1 = s1 c4 = Check4(10,"he") print(c4.num1,c4.s1) #5.使用了self之后,则可以省略类属性 class Check5(): #构造函数 def __init__(self, num1, s1): #成员变量 self.num1 = num1 self.s1 = s1 #成员方法 def func(self): print("func") c5 = Check5(10,"abc") print(c5.num1,c5.s1) c5.num1 = 100 c5.s1 = "hello" #总结:一般情况下,在一个类中,包含构造函数和成员函数,在构造函数中,定义成员变量, # 并给成员变量赋值,通过有参的构造函数赋值
综合案例二
#测试文件 """ 需求:富二代王思聪开着豪车玛莎拉蒂,很自豪的向他的新女友炫耀起来 分析: 富二代类 特征;姓名 行为:开车,炫耀 汽车类: 特征:品牌,颜色 行为:行驶 女友类 特征:姓名 """ 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)
""" 富二代类 特征;姓名 行为:开车,炫耀 """ 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))
""" 女友类 特征:姓名 """ class GirlFriend(): def __init__(self,name): self.name = name
""" 汽车类: 特征:品牌,颜色 行为:行驶 """ class Car(): def __init__(self,brand,color): self.brand = brand self.color = color def run(self): print("running")