Python基础语法10 面向对象 时间与日历模块

时间内置模块:

1.时间戳：从1970年1月1日午夜到现在经历的时间使用秒为单位来进行表示
2.UTC格林尼治时间，时间标准时间，UTC+8
3.DST夏令时，人为规定的，夏季调快一个小时

tm_year: 年
tm_mon :月
t_mday : 日
tm_hour:时
tm_min :分
tm_sec:秒
tm_wday :星期码 0~6 0周一 6周日
tm_yday:一年中的第多少天
tm_isdst：是否为夏令时

import time

time.time():返回当前时间的时间戳
time.gmtime(t1) 返回格林尼治时间的时间元组
time.localtime(t1) 返回本地时间的时间元组

time.asctime(lt) 将时间元组转为时间字符串

time.strftime("%Y/%m/%d %X",lt) 将时间元组格式化为时间字符串

time.mktime(strp) :将时间元组转为时间戳
time.strptime(timestring,"%Y/%m/%d %X") 将时间字符串转为时间元组。

时间戳–》时间元组–》时间字符串
时间字符串–》时间元组 --》时间戳

time.sleep(sec) 休眠
time.clock() 计算cup的执行时间

t1 = time.time()
print(t1)

time.clock()
gt = time.gmtime(t1)
print(gt)

lt = time.localtime(t1)
print(lt)
timestr = time.asctime(lt)
print(timestr)

strt = time.strftime("%Y/%m/%d %X",lt)
strt3 = time.strftime("%Y/%m/%d %H:%M:%S",lt)
strt2 = time.strftime("%x %X",lt)
print(strt)
print(strt2)
print(strt3)

2019/05/08 11:55:51

timestring =“2019/05/08 11:55:51”
strp = time.strptime(timestring,"%Y/%m/%d %X")
print(strp)

t2 = time.mktime(strp)
print(t2)

格式化时间字符：
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12） 如 11:19:55 AM %I:%M:%S %p
%M 分钟数（00-59）
%S 秒（00-59）
%a 本地简化星期名称 如Mon
%A 本地完整星期名称 如Monday
%b 本地简化的月份名称 如Jan
%B 本地完整的月份名称 如January
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符 (上、下午，AM 或 PM),如 11:19:55 AM %I:%M:%S %p
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身
%f 毫秒

datetime模块:
from datetime import datetime

获取系统当前时间
datetime.now()
获取的是一个datetime对象
‘’’
dt = datetime.now()
print(dt)
print(type(dt))

获取指定的datetime时间

dt2 = datetime(2019,5,5)
print(dt2)

print("*“50)
timestr = dt.strftime("%Y-%m-%d %X")
print(timestr)
print(type(timestr))
print("”*50)

dt.strftime("%Y-%m-%d %X")
将datetime类型的对象转为指定格式的时间字符串

注意：两个datetime对象相减的时候，会返回一个timedelta对象，
从这个对象身上我们可以获取两个对象的间隔天数以及除间隔天数之外的秒数。
dlt = datetime1 -datetime2
dlt.days 获取间隔天数
dlt.seconds 获取除间隔天数之外的秒数

dtt = dt - dt2
print(dtt)
print(type(dtt))
print(dtt.days)
print(dtt.seconds)

calendar模块:
import calendar

‘’’
calendar.calendar(year)
返回指定年份的日历

‘’’

cal = calendar.calendar(2019)

print(cal)

print(type(cal))

‘’’
calendar.month(year,month)
返回指定的年月的日历
‘’’
cm = calendar.month(2019,5)
print(cm)
‘’’

calendar.isleap(year)

判断指定的年份是否为闰年

‘’’
print(calendar.isleap(2019))
print(calendar.isleap(2020))
print(calendar.isleap(2200))
‘’’
calendar.leapdays(year1,year2)
返回[year1,year2)之间闰年的个数
‘’’
print(calendar.leapdays(2008,2020))
‘’’
calendar.monthrange(year,month)
返回指定年月的第一天的星期码与该月的天数。
‘’’
print(calendar.monthrange(2019,4))
‘’’
将每周的日期以列表的方式返回，若不存在该日期则使用0来代替
‘’’
print(calendar.monthcalendar(2019,5))
‘’’
calendar.weekday(year,month,day)
功能：返回指定日期的星期码 星期码[0,6] 0:星期一 6：星期日
‘’’
print(calendar.weekday(2019,5,8))

面向对象:

面向过程：
生活中：自己事情自己做，着眼于事情的细节，亲力亲为。
程序中：
代码从上往下执行，代码执行的顺序是写代码的时候就已经定义好的了。
面向对象：
生活中：你办事我放心，着眼于找到一个能够帮你解决问题的特殊的对象。
程序中：
将数据以及对数据操作的方法进行封装。
程序执行的流程在用户使用的过程中决定的。

python中使用的是面向对象的思想，类与对象是面对对象的核心。

类：一个具有特殊功能实体的集合我们称之为类
对象：在类中，能够帮忙解决问题的实体，对象我们通常也称之为实例。
类： 学生
对象： 张三
快递 --》 类
顺丰 --》 对象
类与对象的关系：
1.类是对象的抽象，而对象是类的具体体现
2.类本身也是一种数据类型，只不过这种数据类型是我们自己定义的，
类本身不占用空间，但是对象是占用空间的。

类的定义：
class 类名():
类体
class：标识类的开始
类名：遵循标识符命名，驼峰式命名，见名知意
() :可以省略
冒号：不能省略
‘’’

class Person:

pass

‘’’
类的设计：
关心3样东西：
1.事物的名称【类名】： 人类（Person）
2.特征【属性】：姓名 性别 年龄 身高 体重
3.行为【方法】：吃饭 睡觉 敲代码

class Person:
name = “lili”
sex = “girl”
age = 18
height = 160
weight = 100

def eat(self,food):
    print(self)
    print("吃%s。。。"%food)

def sleep(self):
    print("睡觉。。。")

def code(self):
    print("敲代码。。。")

类中的方法以及属性的使用：
1.实例化对象/创建对象【对象也称之为实例】
对象名 = 类名()

#main + enter
if name == ‘main’:
per1 = Person()
print(“per1”,per1)
per1.eat(“面条”)
per1.code()
per1.sleep()
print(per1.name)
print(per1.age)

per2 = Person()
per2.name = "小明"
print(per2.name)

per3 = Person()
print(per3.name)

创建一个学生对象，来一个自我介绍
属性：姓名 性别 年龄 学科 班级
方法：自我介绍

class Student:
name = “”
sex = “”
age = None
subject = None
classname = “”
def ins(self):
print(“大家好，我叫%s,我是一个%s,我今年%d岁,我的学科是%s，我的班级是%s”%(self.name,self.sex,self.age,self.subject,self.classname))

调用对象的方法以及属性：
对象名.方法名(参数列表)
注意:self不需要传递
对象名.属性

注意:每次实例化对象的时候，我们实例化出来的都是不同的对象。

if name == ‘main’:
stu = Student()
stu.name = “小明”
stu.sex = “boy”
stu.age = 20
stu.subject = “python”
stu.classname = “python1904”
stu.ins()
stu2 = Student()
stu3 = Student()
stu4 = stu3
print(id(stu2))
print(id(stu3))
print(id(stu4))

构造函数：
def init(self):
pass
特点：不需要自己手动调用，会自动执行，当实例化对象的时候会自动执行。
__init__这个是系统函数，它的主要作用就是初始化对象的。

class Student:
# name = “”
# sex = “”
# age = None
# subject = None
# classname = “”

def __init__(self,name,sex,age,subject,classname):
    # print("init被执行啦！！！")
    self.name = name
    self.sex = sex
    self.age = age
    self.subject = subject
    self.classname = classname

def ins(self):
    print("大家好，我叫%s,我是一个%s,我今年%d岁,我的学科是%s，我的班级是%s"%(self.name,self.sex,self.age,self.subject,self.classname))

if name == ‘main’:
stu = Student(“lili”,“girl”,18,“python”,“python1903”)
stu.ins()

析构函数：
def del(self):
pass
析构函数调用：对象销毁的时候调用，也是自动调用的，不需要我们手动调用。
‘’’
class Student:

def __init__(self,name,sex,age,subject,classname):
    # print("init被执行啦！！！")
    self.name = name
    self.sex = sex
    self.age = age
    self.subject = subject
    self.classname = classname

def ins(self):
    print("大家好，我叫%s,我是一个%s,我今年%d岁,我的学科是%s，我的班级是%s"%(self.name,self.sex,self.age,self.subject,self.classname))

def __del__(self):
    print("析构函数被调用啦！！！")

if name == ‘main’:
stu = Student(“lili”,“girl”,18,“html5”,“h51905”)
stu.ins()
# while True:pass
# del stu
# while True:pass

练习:
‘’’
同桌买了一部 华为meteBook X pro ，跟你炫耀。
分析：
同桌
特征：有钱，有电脑
行为：炫耀
电脑
特征：品牌，价格，全面屏
行为：碰传，续航

class Computer:
def init(self,pinpai,price,fullScreen):
self.pinpai = pinpai
self.price = price
self.fullScreen = fullScreen

def pengchuan(self):
    print("碰一碰就能传递文件哦。。。")

def xuhang(self):
    print("有超长续航哦。。。")

class DeskMate:

def __init__(self,money,computer):
    self.money = money
    self.computer = computer

def xuanyao(self):
    print(self.computer.fullScreen)
    self.computer.pengchuan()
    self.computer.xuhang()

if name == ‘main’:
com = Computer(“华为”,8999,“全面屏”)
mate = DeskMate(1000000000,com)
mate.xuanyao()