day12_面对对象思想 属性及方法(用心去揣摩)

思维导图

一. 系统模块

UTC：国际标准时间, 格林尼治天文时间，UTC+8

时间戳：指定时间距离1970.1.1 00:00:00的秒数

time：时间

datetime:日期

calendar：万年历

os：系统，文件和文件夹

2.1time时间模块

时间的表示形式：

​ a. 时间戳： 如：1523158416.681

​ b. 元组格式

​ c. 字符串

tm_year: 年
tm_mon： 月（1~12）
tm_mday：天（1~31）
tm_hour：时（0~23）
tm_min：分（0~59）
tm_sec：秒（0~59）
tm_wday: 一周中的第几天（0~6，0表示星期一）
tm_yday：一年中的第几天（1~366）
tm_isdst：是否是夏令时

​ c.时间字符串：如：2019-09-08 11:11:11

%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00-59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%% %号本身

代码演示：

#导入
import time

#1。获取当前时间对应的时间戳，使用浮点型表示【掌握】
t1 = time.time()
print(t1)

#2。将时间戳转换为UTC
g = time.gmtime(t1)
print(g)  #time.struct_time(tm_year=2018, tm_mon=5, tm_mday=29, tm_hour=2, tm_min=29, tm_sec=1, tm_wday=1, tm_yday=149, tm_isdst=0)

#3.根据时间戳生成当地时间【掌握】
l = time.localtime(t1)
print(l)

#4.将具体时间转换为时间戳【掌握】
m = time.mktime(l)
print(m)

#5.将时间转换为字符串形式【掌握】
a = time.asctime(l)
print(a)  #Tue May 29 10:36:57 2018

#6.将时间戳转换为字符串形式
c = time.ctime(t1)
print(c)

#7.将时间进行格式化【指定字符串的格式】【掌握】
"""
%Y:年
%m:月
%d:日
%H:时【24小时制】
%h:时【12小时制】
%M:分
%S:秒
"""
s1 = time.strftime("%Y.%m.%d %H:%M:%S",l)   #string format
print(s1)

#8.休眠,参数的单位为秒【掌握】
print("4674747")
time.sleep(2)
print("hello")

#9.用浮点数【一般用科学计数法】计算的秒数返回当前cpu的时间，用于衡量不同程序的耗时
print(time.clock())  # 新版本Python已经不再支持

练习：

#需求;已知一个时间的字符串，然后输出三天之后的时间
"""
思路：
1.将已知的字符串转换为对应的时间戳
2.利用时间戳计算三天后的时间【加法运算 + 3 * 24 * 3600】
3.将时间戳转换为时间的字符串，并且将时间格式化
"""
import time

str = "2017-5-20"

#1.将已知的字符串转换为对应的时间戳
newStr = time.strptime(str,"%Y-%m-%d")
print(newStr)
time1 = time.mktime(newStr)
print(time1)
#2.利用时间戳计算三天后的时间【加法运算 + 3 * 24 * 3600】
time2 = time1 + 3 * 24 * 3600
#3.将时间戳转换为时间的字符串，并且将时间格式化
time3 = time.strftime("%Y-%m-%d",time.localtime(time2))
print(time3)   #2017-05-23

2.2datetime日期模块【掌握】

是对time模块的封装，比time模块更加全面

dt_now = datetime.datetime.now()
     获取当前的日期对象，包含时间的
dt_ziding = datetime.datetime()
     根据指定的日期、时间生成一个日期对象
     
dt.strftime()  将日期对象转化为指定的格式
dt.date()   获取日期对象中的日期
dt.time()   获取日期对象中的时间
dt.timestamp()  获取日期对象的时间戳
dt.hour\minute\second  获取小时、分钟、秒

datetime.datetime.fromtimestamp()
     根据一个时间戳，转化为指定的日期对象
datetime.timedelta()
     生成一个差值对象，可以和日期对象直接进行相加减
     参数有，days,hours,minutes,seconds

代码演示：

import  datetime

#1.获取当前时间
d1 = datetime.datetime.now()
print(d1)  #2018-05-29 11:20:51.432757

#2.获取指定的时间，通过元组形式
d2 = datetime.datetime(2015,10,1,10,23,23,1234)
print(d2)

#3.将时间格式化
d3 = d1.strftime("%Y.%m.%d")
print(d3)

#4.将时间字符串转换为datetime实体
d4 = datetime.datetime.strptime(d3,"%Y.%m.%d")
print(d4)

#5.直接进行加减运算
date1 = datetime.datetime(2015,10,1,10,23,23,0)
print(date1)

date2 = datetime.datetime(2015,10,4,10,23,23,0)
date3 = date2 - date1
print(date3)  #3 days, 0:00:00

print(date3.days)
print(date3.seconds)

2.3calendar日历模块（了解）

calendar(year,w=2,l=1,c=6)  
打印某一年的日历【c间隔距离; w每日宽度间隔; l是每星期行数 】
    
isleap(year)   判断是否是闰年

leapdays(y1, y2)  [y1, y2) 中间闰年的个数

month(year,month,w=2,l=1)  打印指定月份的日历

monthcalendar(year,month)  
返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。
Year年month月外的日期都设为0;范围内的日子都由该月第几日表示，从1开始。

monthrange(year,month)  
返回两个整数。第一个是该月的星期几的日期码，第二个是该月的日期码。
日从0（星期一）到6（星期日）;月从1到12。

代码演示：

import  calendar

#返回指定年份中指定月份的万年历表示
print(calendar.month(2018,5))

#返回指定年份的万年历表示
print(calendar.calendar(2018))

#返回一个列表【二维列表】
print(calendar.monthcalendar(2018,5))

#当前周起始的日期
print(calendar.firstweekday())

#判断某年是否为闰年
print(calendar.isleap(2010))

#统计两个年份之间闰年的总数
print(calendar.leapdays(2000,2020))

#获取的是星期，0【星期一】~6【星期天】   1~12
print(calendar.weekday(2018,5,29))

二、面向对象思想

1.面向对象思想设计

基于哲学观点：万物皆对象, 一切皆对象

举例说明：

案例一：我想吃大盘鸡

面向过程 面向对象

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

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

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

4.自己吃 4.自己吃

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

面向过程 面向对象

1.小明补充电脑知识 1.委托一个懂电脑的人买零件

2.小明去买零件 2.委托一个人组装

3.小明把零件运回来 3.小明打开玩游戏

4.小明组装

5.小明打开玩游戏

案例三：一辆红色的法拉利在京藏高速上奔驰

法拉利 京藏高速

2.面向过程和面向对象的区别

2.1面向过程

process：处理

在生活案例中：

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

在程序中：

​ 代码从上往下依次执行

​ 各个模块之间的关系尽可能的独立的，当import的时候，加载的顺序也是从上往下依次加载

​ 每个模块中的语句结构：顺序，分支，循环

2.2面向对象

在生活案例中：

​ 一种看待问题的思维方式，侧重于找到一个具有特殊功能的个体，然后委托这个个体帮忙完成某件事情，这个个体就被称为对象

​ 好处：可以将复杂的问题简单化，将程序员从执行者变成了指挥者

在程序中：

​ 根据不同的需求执行代码【代码执行顺序不一定】

​ 程序的流程完全由需求决定【对象】

​ 思想：如果对象存在，则直接使用；如果对象不存在，则创建对象

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

Python是一门面向对象的编程语言，类和对象是 面向对象的核心

示例： 小狗吃食（闻一闻smell、舔一舔lick、咬一咬bite）
	  分别采用面向过程和面向对象来分析

面向过程 :  先闻一闻, 然后再舔一舔, 最后再咬一咬 (注重过程) 
面向对象 :  小狗是一个对象, 它可以闻一闻食物, 可以舔一舔食物, 可以咬一咬食物.      (不注重过程, 注重对象)

三、类和对象【掌握】

1.类和对象的概念

类：多个具有特殊功能的个体的集合

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

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

思考问题：先有类还是先有对象？

【不好说，但是，在程序中使用的时候，一般是先定义类，然后创建对象】

举例：

​ 类 对象

​ 人 王麻子，李四. 赵四。。

​ 快递 韵达，中通，圆通。。

​ SupreHero 蝙蝠侠，蜘蛛侠，美国队。。

帮忙理解:类其实也是一种数据类型，只不过一般情况下是自定义的，所以可以将类认为是自定义的数据类型，用法和整型，string，list等基本是相同的【定义变量，传参】

2.类的定义

语法：

class 类名( ):

​ 类体

说明：

​ a.Python中使用class关键字定义类

​ b.类名只要是一个合法的标识符即可，但是要求：遵循大驼峰命名法则【首单词的首字母大写，不同单词之间首字母大写】

​ c.通过缩进区分类体

​ d.类体一般包含两部分内容：对类的特征的描述、对类的行为的描述

代码演示：

#类的定义
#类的声明
class MyClass():
 #类的实现
 #类体
 #print("hello")   #一般不会这么书写
 pass

#注意：在同一个py文件中可以同时定义多个类，但是，为了提高代码的可读性，结合模块的使用，最好是一个文件一个类
class MyClass1():
 pass

3.类的设计【类体的实现】

三要素：

​ 事物名称【类名】：举例：人

​ 事物的特征【变量】：名词，举例：姓名，年龄。。。。

​ 事物的行为【函数/方法】：动词，举例：吃，跑。。。。

三、类中的方法和变量【掌握】

1.类中的方法和变量的定义

类中的方法和变量是为了描述事物的行为和特征

类中定义的方法被称为成员方法

类中定义的变量被称为成员变量，也被称为属性 [os.name]

成员变量：类具有的特征

成员方法：类具有的行为

类存在的意义：拥有相同特征和行为的对象可以抽取出来一个类，类的存在是为了创建一个具体的对象

代码演示：

#定义类
#1.事物的名称：类名
class Person():
 #2.事物的特征：成员变量、属性
 name = ""
 age = 0
 height = 0.0

 #3.事物的行为：成员方法【函数】
 #注意：类中的成员方法区别于普通方法：参数部分一定包含self，而且最好self出现在参数列表的第一个
 #调用函数的时候，self不需要被传参
 #初次之外，成员方法的用法和普通方法的使用完全相同，也可以设置默认参数或者关键字参数，不定长参数

 #注意：self：自己，代表类的实例【对象】
 #此处的self可以是任意的标识符，只不过为了结合其他编程的使用，习惯上使用self
 def eat(self,food):
     print("eating",food)
 def run(self):
     print("running")

2.类中方法和属性的使用

2.1创建对象【实例化对象】

已知类，通过类创建对象

对象的创建过程被对象的实例化过程

语法：变量名 = 值

​ 对象名 = 类名()

代码演示：

#定义类
#1.事物的名称：类名
class Person():
 #2.事物的特征：成员变量、属性
 name = ""
 age = 0
 height = 0.0

 #3.事物的行为：成员方法【函数】
 #注意：类中的成员方法区别于普通方法：参数部分一定包含self，而且最好self出现在参数列表的第一个
 #调用函数的时候，self不需要被传参
 #初次之外，成员方法的用法和普通方法的使用完全相同，也可以设置默认参数或者关键字参数，不定长参数

 #注意：self：自己，代表类的实例【对象】
 #此处的self可以是任意的标识符，只不过为了结合其他编程的使用，习惯上使用self
 def eat(self,food):
     print("eating",food)
 def run(self):
     print("running")
     print("self的地址：", id(self))


#对象的创建
p1 = Person()
print(p1)

p2 = Person()
print(p2)

#p1和p2被称为对象，变量名，引用，指向了真正的对象
#p1和p2在栈空间中开辟了空间，真正的对象的被存储在堆空间中

#通过对象调用类中的成员方法和访问类中的成员变量
#1.访问属性
#语法：对象.属性名
#赋值：对象.属性 = 值
per = Person()
print(per.name)
per.name = "小姐姐"
print(per.name)
per.age = 18
print(per.age)
per.height = 1.70
print(per.height)

#2.调用方法
#语法：对象.函数名(参数列表)
#注意：self不需要被传参，传参的时候注意区分参数的类型【默认参数，不定长参数，关键字参数】
per.run()
print("per的地址：",id(per))
"""
self的地址： 2687721120880
per的地址： 2687721120880
"""
per.eat("apple")

person = Person()
person.name = "张三"
person.age = 20
print(person.name,person.age)
person.run()
person.eat("")

#结论：类中的成员变量和成员方法随着对象的出现而出现

总结：

​ 访问变量采用：对象名.属性名

​ 访问方法采用：对象名.方法名(参数列表)

3.内存中的对象

per = Person()

说明：

a.程序中定义的Person类型的变量per实际上是一个变量名，它被存放在栈内存中，他指向实际的Person对象，而真正的Person对象则存放于堆内存中

b.类中的成员变量随着对象的出现而出现，随着对象的消失而消失

c.每个对象的成员变量会在堆空间中开辟一份自己的空间，相互之间互不影响

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

__slots__变量的作用：限制一个类中的成员变量【程序在运行的过程中，就不能随意的动态绑定属性】
语法：__slots__ = (属性的名称)

代码演示：

#1.类的定义
class MyClass():
 #2.成员变量
 """
 num1 = 0
 num2 = 10
 """
 #限制属性
 #注意：被限制的属性的名称通过字符串的方式出现在元组的元素中
 __slots__ = ("num1","num2")

 #3.成员方法
 def fun1(self):
     print("fun1")
 def fun2(self,num):
     print(num)

#4.创建对象
my = MyClass()
#5.访问类中的成员变量
my.num1 = 11
my.num2 = 22
print(my.num1,my.num2)

#6.调用类中的成员方法
my.fun1()
my.fun2(30)

#成员变量随着对象的出现而出现的
#属性的动态绑定【Python是一门动态语言】
my.n = 100
print(my.n)

my1 = MyClass()
#print(my1.n)

5.综合案例一

代码演示：

practiceDemo01.py文件【测试模块】

"""
需求：使用面向对象的思想描述下面这个情景
开学了，王老师让小明，小花，小丽分别做自我介绍
需要介绍姓名，年龄，爱好，来一段才艺展示
"""
"""
分析：
老师类
 特性：姓名
 行为：让学生做自我介绍

学生类
 特征：姓名，年龄，爱好
 行为：一段才艺展示
"""
#导入
"""
import  practice01.teacher
import  practice01.student
"""
from practice01.teacher import  Teacher
from practice01.student import Student

#1.创建一个老师的对象
wang = Teacher()
wang.name = "王老师"

#2.创建一个学生的对象
xiaohua = Student()
xiaohua.name = "小花"
xiaohua.age = 18
xiaohua.hobby = "唱歌"

#3.让老师执行自己的行为
wang.letStudentIntroduce(wang.name,xiaohua)   #stu = xiaohua

xiaoli = Student()
xiaoli.name = "小丽"
xiaoli.age = 20
xiaoli.hobby = "跳舞"
wang.letStudentIntroduce(wang.name,xiaoli)

xiaoming = Student()
xiaoming.name = "小明"
xiaoming.age = 25
xiaoming.hobby = "吹牛逼"
wang.letStudentIntroduce(wang.name,xiaoming)

teacher.py文件【实体类】

#老师类
class Teacher():
 #特征：成员变量
 name = ""

 #行为：成员方法
 def letStudentIntroduce(self,name,stu):
     #老师发出指令
     print(name + "让" + stu.name + "做自我介绍")

     #执行指令
     stu.introduce(stu.name,stu.age,stu.hobby)

     #不同的学生展示不同的才艺
     if stu.name == "小花":
         stu.singSong()
     elif stu.name == "小丽":
         stu.dance()
     else:
         stu.lie()

student.py文件【实体类】

#学生类
class Student():
 #特征：成员变量
 name = ""
 age = 0
 hobby = ""

 #行为：成员方法
 def introduce(self,name,age,hobby):
     print("大家好，我是%s，今年%d,爱好%s"%(name,age,hobby))

 #唱歌
 def singSong(self):
     print("娘子~啊哈")

 #跳舞
 def dance(self):
     print("广场舞")

 #吹牛逼
 def lie(self):
     print("我家可穷了，就养了几百头牛")

四、构造函数和析构函数

1.构造函数【掌握】

采用上面的方式创建对象【直接给成员变量赋值】，很多的类一般倾向于创建成有初始状态的
__init__:构造函数【作用：创建对象，给对象的成员变量赋初始值】
构造函数：构造器
调用的时机：当一个对象被创建的时候，第一个被自动调用的函数
per = Person()

语法：
	def __init__(self,args1,args2....)
		函数体
说明：
	a.之前的写法中并没有显式的定义__init__函数，说明系统默认提供了一个无参的构造函数
	b.args1,args2...一般设置的形参列表和成员变量有关

代码演示：

#1.构造函数被调用的时机
class Check():
 num1 = 0
 str1 = ""

 #构造函数
 def __init__(self):
     print("jfahj")

 def show(self):
     print("show")
#注意：当创建对象的时候，默认调用了系统提供的无参的构造函数
c = Check()
c.show()

#2.给构造函数添加参数
class Check1():
 name = ""
 age = 0
 """
 def __init__(self,n,a):
     print("fajkgak")
 """
 #注意2：当使用构造函数的时候，可以使用无参的，也可以使用有参的，在Python中的解决办法：设置不定长参数
 #注意3：Python中，一个类中只能有一个构造函数
 def __init__(self, *n):
     print("fajkgak")


#注意1：当手动头添加了有参的构造函数之后，系统将不再提供无参的构造函数
c1 = Check1()
c11 = Check1("fsiugh")

#3.有参构造函数的使用
class Check2():
 name = ""
 age = 0

 #构造函数的形参列表：和成员变量有关
 def __init__(self,n,a):
    print(n,a)
    name = n
    age = a

#注意1：当手动头添加了有参的构造函数之后，系统将不再提供无参的构造函数
c2 = Check2("zhangsan",10)
print(c2.name,c2.age)   #0


#4.self的使用
class Check3():
 name = ""
 age = 0

 #构造函数的形参列表：和成员变量有关
 def __init__(self,n,a):
    print(n,a)
    #self的使用：通过self来区分成员变量和局部变量,所以self.name代表name是一个全局变量【成员变量】
    self.name = n
    self.age = a

c3 = Check3("zhangsan",10)
print(c3.name,c3.age)  #10

#5.使用self之后，可以省略成员变量的定义【掌握】
#self只是一个标识符，可以替换成任意的标识符
class Check4():

 #构造函数的形参列表：和成员变量有关
 def __init__(self,name,age):
    print(name,age)
    #self的使用：通过self来区分成员变量和局部变量,所以self.name代表name是一个全局变量【成员变量】
    self.name = name
    self.age = age

 def show(self):
     print("showing")

c4 = Check4("lisi",20)
print(c4.name,c4.age)
c4.show()

2.析构函数

与构造函数正好相反，当对象被销毁的时候自动调用的函数，被称为析构函数
__del__:

删除变量：   del  变量名，此时可以触发析构函数的调用

使用情景：清理工作，比如关闭数据库，关闭文件等

代码演示：

import  time

class Pig():
 def __init__(self,name,age):
     self.name  = name
     self.age = age
     print("构造函数被执行")


 def show(self):
     print("show")

 #析构函数
 def __del__(self):
     print("~析构函数被调用")


#析构函数被调用的时机：1：当程序运行完成的时候    2：使用del删除变量
p = Pig("abc",10)

del p

#注意：对象释放以后就不能再访问了【相当于根本未创建过这个对象】
#print(p.age)

time.sleep(5)

#在函数里定义的对象，会在函数结束时自动释放，这样可以用来减少内存空间的浪费
#其实就是作用域的问题
def func():
 per2 = Person("aa", 1, 1, 1)

func()

3.综合案例二

practiceDemo02.py文件【测试模块】

"""
需求：富二代王思聪开着豪车，很自豪的向他的新女友炫耀

富二代类
特征：姓名
行为：开车，炫耀

汽车类
特征：品牌，颜色
行为：奔驰
"""
#测试模块
from  practice02.car import Car
from practice02.richMan import RichMan

#1.创建一个富二代的对象
wang = RichMan("王思聪")

#2.创建一个汽车的对象
c = Car("玛莎拉蒂","闷骚红")
c.run()

#3.让富二代执行自己的行为
wang.driveCar(c)
wang.showCar(c)

richMan.py文件【实体类】

class RichMan():
 #构造函数
 def __init__(self,name):
     self.name = name

 #成员函数
 def driveCar(self,car):
     print("富二代%s开着他的豪车%s"%(self.name,car.brand))
 def showCar(self,car):
     print(car.brand,car.color)

car.py文件【实体类】

class Car():
 #构造函数
 def __init__(self,brand,color):
     self.brand = brand
     self.color = color

 #成员函数
 def run(self):
     print("%s在马路上奔驰"%(self.brand))

每天进步一点点,日后成就不近一点!!!