一、模块
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")