Python------date，continue，迭代对象,生成器

版权声明：本文为博主原创文章，允许转载，但请保留出处。 https://blog.csdn.net/ddwhan0123/article/details/49948559

转载请注明出处：王亟亟的大牛之路

大多数的语言都提供了时间操作的相应类，诸如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 <generator object fib at 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