转载请注明出处：王亟亟的大牛之路
大多数的语言都提供了时间操作的相应类，诸如java的java.util.Date，java.util.Calendar等等，
Python中是time 和 calendar .
首先需要导包import time;
然后就可以使用了，mTime= time.time()那结果呢？
1448004021.1337154 （而且这个数字还继续在变）
WHY？
用ticks计时单位返回从12:00am, January 1, 1970(epoch) 开始的记录的当前操作系统时间，格林威治时间你懂的
在Java中也有类似实现，像下面：
Date date =new Date();
System.out.println(date.getTime());
结果： 1448004275140
- 1
- 2
- 3
- 4
那如何显示出我们平时的时分秒啊，日起之类的呢？
Java中的实现是：
Date date =new Date();
DateFormat df1 = DateFormat.getDateInstance(DateFormat.FULL, Locale.CHINA);
System.out.println(df1.format(date));
结果： 2015年11月20日 星期五
- 1
- 2
- 3
- 4
- 5
而Python中：
localtime = time.localtime(time.time())
print("第107行，本地时间 :", localtime)
#时间格式化
print("第109行，打印格式化后的本地时间",time.asctime(localtime))
结果： 第107行，本地时间 : time.struct_time(tm_year=2015, tm_mon=11, tm_mday=20, tm_hour=15, tm_min=20, tm_sec=21, tm_wday=4, tm_yday=324, tm_isdst=0)
第109行，打印格式化后的本地时间 Fri Nov 20 15:20:21 2015
- 1
- 2
- 3
- 4
- 5
- 6
- 7
Fri Nov 20 15:20:21 2015是不是看了就眼熟了？，那么107行打印的那一长串又是什么呢？
Python函数用一个元组装起来的9组数字处理时间，每个元素代表的意思依次为：
年，月，日，小时，分钟，秒一周第几天，一年第几天，是否夏令时然后调用
,time.asctime（）方法把这个元素格式化为我们所更能理解的格式。
跟事件相关的还有Calendar，Python对日历进行了很好的一层封装，诸如我要打出某一年某一月的所有日历，只需要一行代码calendar.month(2015,11)
结果：
November 2015
Mo Tu We Th Fr Sa Su
1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30
是不是瞬间高能？
还有诸如 返回在两年之间的闰年总数。
print(calendar.leapdays(2000,2009),"年")
结果： 3年
- 1
- 2
- 3
Python continue 语句
continue 语句跳出本次循环，而break跳出整个循环意义和Java中差不多都是直接终端这一步操作回到循环的起始点，看例子：
for x in "HelloWorldhaha":
if x=="r":
continue
print("now word:",x,end=" ")
if x=="a":
break
结果： now word: H now word: e now word: l now word: l now word: o now word: W now word: o now word: l now word: d now word: h now word: a NiHao 当前数字 0
第一个逻辑只是让r这一组打印没有执行，第二组逻辑的break是让整个循环结束了，所以二者的区别还是很大的没一个是单轮一个事全局哦。
再贴一个**pass**的例子
for x in range(10):
if x%3==0:
pass
print("NiHao",end=" ")
print("当前数字",x)
结果：
当前数字 1
当前数字 2
NiHao 当前数字 3
当前数字 4
当前数字 5
NiHao 当前数字 6
当前数字 7
当前数字 8
NiHao 当前数字 9
所以，pass就是 什么都没发生的意思。。
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
Python生成器
在Python中，这种一边循环一边计算的机制，称为生成器：generator。只要把一个列表生成式的[]改成()，就创建了一个generator。
print("第8行打印list",[x for x in range(10)])
结果： 第8行打印list [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
//创建一个generator
print("第11行打印generator",(x for x in range(10)))
结果： 第39行打印变形的fib 0x000000F008E43AF0>
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
generator是无法被直接打印出来的，我们可以用next()函数把他一个一个读出来（也不可以获取他的长度）
一样的道理，我们可以用for循环等一些迭代的方法，把他里面的内容读出来
g=(x for x in range(10))
#可迭代
for x in g:
print(x,end=" ")
结果： 0 1 2 3 4 5 6 7 8 9
或者用
next(g)
结果： 0
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
那么如果用next()读下去读不到东西了，就会抛异常，像这样
Traceback (most recent call last):
File “”, line 1, in
StopIteration
generator还提供了一个关键字yield，看上去 功能和return之类的差不多，但是运行到yield函数就会停止，并且记录位置，下一次调用会从 这个 位置 开始操作
def testYie():
print("第一次执行到这里")
yield 1
print('第二次执行到这里')
yield 3
print('第三次执行到这里')
yield 5
#需要先构造一个函数对象
newTestYie=testYie()
print(next(newTestYie))
print(next(newTestYie))
print(next(newTestYie))
yield必须在一个函数中，不可以出现在基类里。
结果：
第一次执行到这里
1
第二次执行到这里
3
第三次执行到这里
5
从正常理解结果看上去，函数只被调用了1次，其实并不是，被执行了3次才出现了这么个结果，每一次都是从关键字结束，第二次又从关键字的位置开始
如果再多调用一次，就会出现刚才的异常了
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
当一个函数 出现 yield 关键词的时候 这个 函数就是 generator函数了
迭代对象
迭代的概念以及如何在之前已经有讲过，今天要再强调的是Iterable对象以及Iterator对象
From Internet
一类是集合数据类型，如list、tuple、dict、set、str等；
一类是generator，包括生成器和带yield的generator function。
这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。
可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
我们可以用isinstance函数来判断对象的类型，如：
#判断是否是可迭代对象
print('第77行判断字符串是否是可迭代对象',isinstance("as",Iterable))
print('第78行判断list是否是可迭代对象',isinstance([],Iterable))
print('第79行判断字典是否是可迭代对象',isinstance({"aa":123,"cc":123},Iterable))
#判断是否迭代对象Iterator
print('第82行判断字典是否是迭代对象',isinstance({"aa":123,"cc":123},Iterator))
print('第83行判断list是否是迭代对象',isinstance([x for x in range(10)],Iterator))
print('第84行判断generator是否是迭代对象',isinstance((x for x in range(10)),Iterator))
结果：
第77行判断字符串是否是可迭代对象 True
第78行判断list是否是可迭代对象 True
第79行判断字典是否是可迭代对象 True
第82行判断字典是否是迭代对象 False
第83行判断list是否是迭代对象 False
第84行判断generator是否是迭代对象 True
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
两种类型还能互相转换:
#转换为Iterator对象
print('第87行Iterable转换为Iterator对象',isinstance(iter([x for x in range(10)]),Iterator))
第87行Iterable转换为Iterator对象 True
- 1
- 2
- 3
- 4
那么，有了Iterable为什么还需要Iterator呢？（好绕口，好难记）
这是因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。
Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。
例子里还有个99乘法表和帕斯卡数列，更多例子可以直接看源码：
https://github.com/ddwhan0123/PythonExample/blob/master/%E7%A4%BA%E4%BE%8B/l5demo.py
Thanks
