日历模块

1
2
3
4
5
6
import calendar

#calendar() 获取一年份的完整日历。
result = calendar.calendar(2017,w=5,l = 1)
# 2017 年份, w 表示显示日期数字的空格,  l 表示一周占用的行高,c 表示日历的月份的空格,m 表示显示的一行有几个月.
print(result)
1
2
3
#month() 获取一个月的日历
result = calendar.month(2017,10,w=3,l=2)
参数同上
1
2
3
#monthcalendar()获取一个月的矩阵列表
result = calendar.monthcalendar(2017,8)
#矩阵列表里存在0,表示不是本月的.有5条列表.
1
2
3
4
#isleap() 检测是否是润年

result = calendar.isleap(1900)
print(result)
1
2
3
4
#leapdays() 检测指定范围内有几个闰年

result = calendar.leapdays(2000,2017)
包括2000和2017年
1
2
3
4
5
#monthrange()

result = calendar.monthrange(2017,9)
print(result)
返回值:元组(周几,天数)
1
2
3
4
#weekday() 根据年月日计算周几

result = calendar.weekday(1997,7,1)
返回值:整型 0-6 表示周一到六
1
2
3
4
5
#timegm() 将时间元组转化为时间戳

timetuple = (1997,7,1,12,30,45,0,0,0)
result = calendar.timegm(timetuple)
print(result)

时间戳是从1970年1月1日0分0秒0毫秒开始到现在的秒数.在python里能够使用到2038年的某一天.

时间元组就是一个用于表示时间格式的元组数据而已,他是time模块操作时间的主要方式.

格式:(年,月,日,时,分,秒,周几,一年中的第几天,是否是夏令时)

1
2
3
4
5
6
7
8
9
10
索引    名称        内容           取值
0      tm_year      年           4位数年份如2017
1      tm_month     月            1-12
2      tm_day       日            1-31
3      tm_hour      时            0-23
4      tm_min       分            0-59
5      tm_sec       秒            0-61  60是闰秒,61是历史保留
6      tm_wday     周几           0-6
7      tm_yday   一年中的第几天    1-366
8    tm_isdst      夏令时         0是,其它不是

时间模块的值

1
2
3
4
timezone
获取当前时区与格林尼治所在时区的相差的秒数(推荐)
print(time.timezone)
-28800  相差8小时
1
2
3
4
altzone
获取当前时区与格林尼治所在时区的相差的秒数,在有夏令时的情况下.
print(time.altzone)
-32400  相差9小时
1
2
3
daylight
检测是否是夏令时的状态.
print(time.daylight)

时间相关函数

1
2
3
#asctime() 将时间元组转化为可读的时间字符串(英文!)
#获取当前时间字符串
result = time.asctime()
1
2
#获取指定时间字符串
result = time.asctime(1997,7,1,0,0,0,0,0,0,)
1
2
3
4
#localtime() 获取指定时间的时间元组格式

#获取当前时间的时间元组
result = time.localtime()
1
2
#获取当前时间戳的时间元组
result = time.localtime(0)
1
2
3
4
5
6
#gmtime() 获取指定时间的时间元组格式(UTC地区的)

#获取当前时间的时间元组
result = time.gmtime()
#获取当前时间戳的时间元组
result = time.gmtime(0)
1
2
3
4
5
6
7
#ctime() 获取本地时间的字符串格式
相当于asctime(localtime())

#获取当前时间的可读字符串格式(英文)
result = time.ctime()
#获取当前时间戳的可读字符串格式
result = time.ctime(0)
1
2
3
#mktime() 根据时间元组制作时间戳
ii = (1999,1,1,0,0,0,0,0,0)
result = time.mktime(ii)
1
2
3
4
5
# import time
#clock() 获取cpu执行时间

result = time.clock()
#sleep() 程序休眠时间

类成员的操作

获取类和对象中所属成员的信息

  • 创建类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Computer:
  #成员属性
  cpu = 'i7-7890'
  memory = '32G'
  disk = '1T'
  display = '120Hz'
  color = '黑色'

  #成员方法
  #播放电脑
  def play_movie(self):
      print('电脑播放电影中')
  #播放音乐
  def play_music(self):
      print('电脑播放音乐中')
  #玩游戏
  def play_game(self):
      print('正在使用电脑玩游戏')
1
2
3
4
5
6
类：类名.__dict__
对象:对象名.__dict__

#对于类的相关操作（很少使用）
#检测类中的成员
print(Computer.__dict__)
  • 成员属性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
成员属性:（和变量一样）
  访问  类名.成员属性名
  修改  类名.成员属性名 = 新值
  删除  del 类名.成员属性名
  添加  类名.成员属性名 = 值

#访问
print(Computer.cpu)
print(Computer.memory)
#修改
print(Computer.__dict__)
Computer.color = '灰色'#相当于变量重新赋值
print(Computer.__dict__)
#添加
print(Computer.__dict__)
Computer.keyboard = '机械键盘'
print(Computer.__dict__)
#删除
print(Computer.__dict__)
del Computer.cpu
print(Computer.__dict__)
  • 成员方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
成员方法
  访问  类名.方法名()
  修改  类名.方法名 = 新的函数
  删除  del 类名.方法名
  添加  类名.新方法名 = 函数（也可以是lambda表达式）

#访问
Computer.play_movie(None)
#添加(work)  不推荐使用
#定义一个函数
def work():
    print('使用电脑办公中')

Computer.work = work #也可以使用lambda表达式添加
print(Computer.__dict__)
#修改
Computer.play_movie(None)
Computer.play_movie = lambda : print('电影暂停中')
Computer.play_movie()
#删除
print(Computer.__dict__)
del Computer.play_movie #一定不要加括号。
print(Computer.__dict__)