一、比较操作

  对于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中真与假的表示主要有以下几种方式：

1、任何非0数字和非空对象都是为真

2、数字0、空对象和特殊对象None均为假

3、逻辑判断的返回值为True或者False

二、选择与循环表达式

  • 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

循环的控制方法：

break：跳出最内层循环

continue：跳出所处的最近层循环的开始处

else代码块：循环正常终止才会执行，若循环终止是由break跳出导致的，则else不会执行

 
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__()函数可以对迭代器逐个取值。

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

特点：

  访问者不需要关心迭代器内部的结构，仅需要通过next()方法不断取下一个内容

  不能随机访问集合中的某个值，只能从头到尾依次访问

  访问到一半时不能往后退

  便于循环比较大的数据集合，节省内存

wKiom1i6vvfhcTrxAAA9p84rJ4Y769.png-wh_50

  列表解析：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中生成器主要有两种：生成器函数与生成器表达式。

  生成器函数：一个函数调用时返回一个迭代器，那么这个函数就叫做生成器(generator)，如果这个函数中包含yield语法，那么这个函数就会变成生成器；yield的主要作用就是可以使函数中断并保存中断状态；中断后，代码可以继续往下执行，过一段时间后，还可以再重新调用这个函数，从上次yield的下一句开始执行。

def my_range(first=0,last=10,step=1):
    number =first
    while number 

  生成器表达式：类似于列表推导式，但生成器返回按需产生一个对象，不是一次构建一个结果列表。要创建一个生成器表达式很简单，只要把列表生成式的[]改成(),就可以创建一个生成器表达式，通过next()函数可以获得生成器表达式的下一个返回值。但是，当遍历到最后一个元素，没有元素时会抛出异常,因此一般用for循环迭代它。

In [14]: squ=(x**2 for x in range(4))
In [15]: squ
Out[15]:  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)
 in ()
----> 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