一、比较操作

  对于python语言，所有的对象都支持比较操作，比较操作可用于测试相等性、相对大小等。如果是符合对象（如：元组、列表），python会检查其所有部分，包括自动遍历各级嵌套对象、直到可以得到最终结果。测试操作符只要有'=='与'is'。

  '=='操作符测试值的相等性

  'is'表达式测试对象的一致性

  组合条件测试： and与运算；or或运算；not非运算

In [1]: a= 123
In [2]: b=123
In [3]: a==b            #测试a与b的值是否相等
Out[3]: True
In [10]: type(a)is int  #测试a的类型是否为int
Out[10]: True

  在python中真与假的表示主要有以下几种方式：

二、选择与循环表达式

• if语句

if boolean_expression1:
  suite1
elif boolean_expression2:
...
else:
  else_suite
elif语句可选，当仅用于占位符，而不写相关语句时可以使用pass

• 三元表达式

A = X if Y else Z    等价于  expression1 if bool_expression else expression2
if Y:
  A=X
else:
  A=Z

• while循环

while bool_expression:
  while_suite
else:
  else_suite

• for循环

for expression1 in iterable:
  for_suite
else:
  else_suite

循环的控制方法：

a=[1,2,3,4,5,6,7]
for i in a:
    if i==3:
        continue    #跳出本次循环，直接往后执行遍历
    print(i)
else:                      #else语句在循环结束后得到执行
    print(a)
1
2
4
5
6
7
[1, 2, 3, 4, 5, 6, 7]

a=[1,2,3,4,5,6,7]
for i in a:
    if i==3:
        break              #break跳出循环，不再执行之后的遍历  
    print(i)
else:                      #else语句没有执行
    print(a)
1
2

三、迭代器和列表解析

• 迭代，使用iter()函数可以创建迭代器，使用__next__()函数可以对迭代器逐个取值。

  迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不能后退。另外，迭代器多的一个优点是不要求事先准备好整个迭代过程中的所有元素。迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素不存在或者销毁。

  列表解析：python迭代机制中的一种应用，它常用于实现创建新的列表，因此置于[]中。

语法：[expr for iter_var in iterable if cond_expr]
In [1]: range(22,101,2)    #22到101的偶数
In [5]: [ x for x in range(1,101) if x%2==0 and x>=20 ]   #与range(22,101,2)等价
In [6]: L = [ x**2 for x in range(9)]   #1到9 的平方值
In [7]: list(L)
Out[7]: [0, 1, 4, 9, 16, 25, 36, 49, 64]

range()与xrange()的对比：

  range()函数一次性返回连续的整数列表；xrange()函数一次性产生一个数据，相较于range更加节约空间。在python3.x中xrange()函数已经被移除。

>>> l = range(9)
>>> l
[0, 1, 2, 3, 4, 5, 6, 7, 8]
>>> L=xrange(9)
>>> L
xrange(9)   
>>> list(L)
[0, 1, 2, 3, 4, 5, 6, 7, 8]

• 生成器，在python中生成器主要有两种：生成器函数与生成器表达式。

def my_range(first=0,last=10,step=1):
    number =first
    while number <last:
        yield number     #yield生成器，当number<last时，生成number返回输出
        number +=step
ranger=my_range(1, 6)        #ranger为生成器对象
for x in ranger:
    print(x)                      #输出从yiled得到的值后，继续返回函数执行
1
2
3
4
5

In [14]: squ=(x**2 for x in range(4))
In [15]: squ
Out[15]: <generator object <genexpr> at 0x7fb403bc98e0>
In [16]: next(squ)
Out[16]: 0
In [17]: next(squ)
Out[17]: 1
In [18]: next(squ)
Out[18]: 4
In [19]: next(squ)
Out[19]: 9
In [26]: next(squ)
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-26-10dd268618a2> in <module>()
----> 1 next(squ)
StopIteration:

四、装饰器

  在写代码的时候，要遵循开放封闭的原则，虽然这个原则是用在面向对象开发，但是也适用于函数式编程，它规定已经实现的功能代码不允许被修改，但可以扩展。即：

  封闭：已实现的功能代码快

  开放：对外扩展开发

  所谓装饰器其本身是一个函数，用于装饰其他函数，功能是增强被装饰的功能。

#函数document_it()定义了一个装饰器，其功能为：
#打印输出函数的名字和参数的值
#打印含有参数的函数
#打印输出结果
#返回修改后的函数

def document_it(func):
    def new_function(*args,**kwargs):
        print('running function:',func.__name__)
        print('positionnal argument:',args)
        print('keyword arguments:',kwargs)
        result=func(*args,**kwargs)
        print('result:',result)
        return result
    return new_function
#无论document_it()的函数func是什么，装饰器都会返回一个新的函数。其中包括函数增加的额外语句。装饰器并不需要执行函数func中的代码，只是在结束前函数document_it()调用函数func的返回结果和附加的代码结果。

  对于装饰器的使用主要有两种方法：

def add_ints(a,b):      #定义函数，求两个数的和
    return a+b
c=add_ints(3,5)
print(c)

cooler_add_ints=document_it(add_ints)   #第一种方法：人工对装饰器赋值
c=cooler_add_ints(3,5)
print(c)
输出结果：
running function: add_ints
positionnal argument: (3, 5)
keyword arguments: {}
result: 8
8

@document_it                            #第二种方法：直接在要装饰的函数前面添加装饰器名字
def add_ints(a,b):
    return a+b
c=add_ints(3, 5)
print(c)
输出结果：
running function: add_ints
positionnal argument: (3, 5)
keyword arguments: {}
result: 8
8

五、枚举和递归

• 枚举

  range可以在非完备遍历中用于生成索引，而非偏移处的元素；如果同时需要便宜出的索引和元素时，可以使用enumerate()函数，此内置韩寒苏返回一个生成器对象。

In [3]: for i in range(5):     #只生成元素的值
   ...:     print(i)
   ...:     
0
1
2
3
4

In [4]: for index,i in enumerate(range(5)):   #同时生成索引和元素
   ...:     print(index,i)
   ...:     
0 0
1 1
2 2
3 3
4 4

In [7]: for index,i in enumerate(a):    #遍历列表时，生成索引和元素
   ...:     print(index,i)
   ...:     
0 1
1 2
2 5
3 67
4 3
5 54
6 756
7 8
8 9
9 35

• 递归：递归算法是一种直接或者间接调用自身算法的过程

 特点：递归算法就是在过程或者函数里调用自身。在使用递归策略时，必须要有一个明确的递归结束条件，称为递归出口；递归算法解题通常显得很简洁，但是其运行效率较低，在递归调用的过程中系统为每一层的返回点、局部变量开辟了栈来存储。递归次数过多容易造成栈溢出等。

#用递归算法求n!
def factorial(n):
    if n==1 or n==0:
        return 1
    else :
        return n*factorial(n-1)
a=factorial(8)
print(a)
输出结果：
40320