Python 条件 and 循环

本文引用至: 条件 循环

python中的条件语句格式没有什么太多要说的内容. 就是if...elif...else 这3个语句结构.
就比如这样的:

num = float(input("Enter a number: "))
if num > 0:
    print("Positive number")
elif num == 0:
    print("Zero")
else:
    print("Negative number")

在python中, 也会出现像js一样的隐式转换. 比如:
None , 0 , "" , (), [] , {}
都会被转为False进行判断. 但是== 运算时, 就不会各自进行隐式类型转换了.

if 0:
    print(True)
else:
    print(False)

另外,就是比较复杂一点的elif 结构.
基本结构差不多就是:

if test expression:
    Body of if
elif test expression:
    Body of elif
else: 
    Body of else

python中的operators

平常我们常用的到的operators 大概就有: >,<,=,>= 等等. 这些都是编程语言里面经常用到的.
所以，就不过多赘述了. 这里就挑一些python里面比较特殊的吧.
is 和 is not.

• is: 和==不一样, is是用来判断他们的内存地址是否一样, 而== 是用来判断他们的值是否一样.

A = [1,2,3]
B = [1,2,3]
print(A is B)
print(A == B)
//得到
False
True

• is not: 同理, 也是用来判断他们的内存地址是否不一样. 特别是当两个值相同的时,显示出他的不同了.

A = [1,2,3]
B = [1,2,3]
print(A is not B)
print(A == B)
// 得到
True
True

还有一对是成员判断符号: in 和 not in. 主要用在数据结构上面,比如list, tupe, set, dict

• in: 用来判断一个元素是否在集合中

• not in: 用来判断一个元素不在集合中

x = 'Hello world'
y = {1:'a',2:'b'}
print('H' in x)
print('hello' not in x)
print(1 in y)

另外, python还有一个3元运算符.
基本格式为:

var = B if Boolean else B

如果Boolean为True则会返回A, 如果为False则会返回B

name = 'a' if False else 'b'
print(name)
# 得到 b

循环内容

在Py中常见的循环就有 for 和 while.
但实际上,我们更长使用for, 因为他比较简单而且获取的内容也多.

for

py提供了for...in...循环. 来帮助我们对序列结构(list,tupel,string)进行遍历. 或者其他可以迭代的对象.
比如,这里我们可以模仿一下,list的累加(sum方法)

def sum(list):
    total = 0
    for x in list:
        total +=x
    return total

另外, 还有一个比较特殊的结构

for ... else ...

他的作用就是当for正常执行完毕后执行. 但如果你是使用break,return 这类强制中断的方法外, 是不会执行的.
比如, 我们可以来构造一个in方法, 来检查成员

def exist(seq,ele):
    for x in seq:
        if(x == ele)
            return True
    else:
        return False

如果你使用break或者return 语句的话,就不会执行了.

print(exist((1,2,3),1))
# 返回 True

但,有时候我们还想要使用序列中的index. 那应该怎么做呢?
没错,这时候,就可以使用enumerate()方法,来帮我们实现这个功能.

• enumerate(seq):该是用来将,序列变为可迭代的iterable对象. 比如,可以将seq转变为

>>> enumberate(seq)
(0, seq[0]), (1, seq[1]), (2, seq[2])...

所以, 我们就可以使用它,在我们的循环当中.从而获取到他的key值

a_list = [1,2,3,4]
for key,value in enumerate(a_list):
    print('''
        the key is {0}
        the value is {1}
        '''.format(key,value))

while

while循环和for最大的不同就在于他比较简单. 常常用来做单纯的循环. 他和for一样,也有: while...else的结构.
直接看demo:

flag = 4
while flag--:
    print('ok')
else:
    print('finish')

上面两个是一般的串行迭代,那我们应该怎么实现并行迭代呢?

并行迭代

python在全局中提供了一个zip方法,来帮我们实现并行迭代.基本格式为:

zip(iter1 [,iter2 [...]])

实际上zip完成的事情其实就是序列的打包,将多个迭代对象,变为 [(a,b),(a,b)...]的形式

>>> zip([1,2],[3,4])
# 我们遍历看看
>>> for value,key in a_zip:
...     print(value,key)

循环trick

首先, break和continue应该算是大众语言必备. 在py中,比较特殊的应该算pass语句了. 因为, 在python中,body为空是不被允许的.比如:

if True:
else:
    print("Ok")

这样就会报错, 所以,python提出了pass语句,来帮我们完成这个空缺。
所以格式应该为:

if True:
    pass
else:
    print("Ok")

这样就没有什么问题了

另外,我们还可以利用for循环实现巧妙的列表推导. 相当于快速生成序列或者hash表.

//生成 list
a_list = [x for x in range(10)]
// 并且后面还可以加上条件判断
>>> a_list = [x for x in range(10) if x%2==0]

你还可以生成一个元组序列

>>> a_tup = [(x,y) for x in range(3) for y in range(3)]

那字典应该怎么生成呢?
如下:

>>> a_dict = {x:x for x in range(10)}
# 不过这样的意义并不是很大

itertools 迭代模块

itertools 实际上是为了让python更加灵活而创建的. 他的作用就是提供更多的遍历方法,来帮我们实现真正的人工解放.
首先,我们需要引进itertools.

from itertools import *

具体方法,我们选几个常用的,其余的可以查阅一下官方文档

chain 合并

chain在这里的作用就是合并多个iterator, 并且返回itertools的对象.
基本格式为:

itertools.chain(*iterables)

实际上,我们使用python代码模拟一下 就是这个效果:

def chain(*iterables):
    for it in iterables:
        for element in it:
            yield element

看个实例吧:
合并两个list

>>> a_chain = chain([1,2],[3,4])
# 返回itertools对象

然后,我们也可以使用for ... in 来遍历该对象

>>> for ele in a_chain:
...     print(ele)

zip_longest 组合元组

zip_longest 容易让我们想起python中的zip全局方法. 他们两者最大的不同是, zip是依据最短的iterator进行的, 而zip_longest 是依据最长的iterator.
他的格式为:

itertools.zip_longest(*iterables, fillvalue=None)

当一部分序列短了, 空缺的位置,默认会使用None填补,当然, 你也可以自定义 fillvalue

>>> for key,value in zip_longest([1,2,3],[2,3]):
...     print(key,value)
... 
1 2
2 3
3 None

islice 截取

从iterator集合中截取指定长度的元素,并生成一个集合. 不过,对于list而言,没什么卵用. 对于其他数据结构,比如, Set,Tuple. 还是很方便的. 但有的同学可能会相当, set不是无序的么？ 他截取的依据是什么呢？
eh... 就是依据初始化时, 你定义的顺序. 这时候, 我们需要把Set当成一个列表来看待.
对于dict 就是获取他的key.
基本结构为:

itertools.islice(iterable, stop)

itertools.islice(iterable, start, stop[, step])

当为一个参数时, 就是指截取的长度. 当有多个参数就是按下面那种方式来, 截取适当的范围 [start,stop)

>>> for x in islice({1,2,3},3):
...     print(x)
... 
1
2
3

指定范围:

>>> for x in islice({1,2,3},1,2):
...     print(x)
... 
2

tee 一次性

当你想,想要一个数据集合是,用了一次里面的内容就没有了的. 那么就可以使用tee 来完成. 并且,可以返回多个一次性迭代对象, 具体的数目, 由第二个参数决定(default for 2).
他的格式为:

itertools.tee(iterable, n=2)¶

比如:

>>> a,b = tee([1,2,3],2)
# 使用一次
>>> for x in a:
...     print(x)
... 
1
2
3
# 如果再遍历的话, 里面的内容就为空了
>>> for x in a:
...     print(x)
... 
# 同理, b也是这样

starmap 推导式

startmap方法,和map方法很相近, 将iterable 中的值, 使用函数处理后返回,并组成新的迭代器. 唯一不同的是, starmap是处理一个序列, 而map可以处理多个序列. 如果你想要处理多个序列的话, 可以使用 zip/zip_longest方法将序列合为:[(a,b),(a,b)...]的形式
基本格式为:

itertools.starmap(function, iterable)

demo:

from itertools import *
a_list = [1,2,3,4]
b_list = [1,2,3]
c = starmap(lambda a,b:a*b,zip_longest(a_list,b_list,fillvalue=2))
for x in c:
    print(x)

count 序列值

count() 实际上使用来生成, 指定步长值的序列. 比如, 你可以给一个tuple 打上 数字tag.
他的基本格式为:

itertools.count(start=0, step=1)

这里,我们尝试一下,给tuple打上tag

from itertools import *
tup = ('a','b','c','d','e')

tag_tup = tuple(zip(count(0, 2),tup))
print(tag_tup)

# 得到: ((0, 'a'), (2, 'b'), (4, 'c'), (6, 'd'), (8, 'e'))

基本格式就到这里了. 最后我们来总结一下吧