python基础知识--条件，循环和其他语句

locale 是根据计算机用户所使用的语言，所在国家或者地区，以及当地的文化传统所定义的一个软件运行时的语言环境。

在Unix下可以通过命令 locale 来查看当前语言环境，可以使用locale-a查看系统支持locals值

1.print 和 import

1.1 print

可以打印多个表达式，用逗号隔开

>>> print 'Age:' , 42      Age : 42

print的参数不能构成元组

>>> 1, 2, 3      (1, 2, 3)           >>> print 1, 2, 3     1 2 3         >>> print (1, 2, 3)     (1, 2, 3)

同时输出本文和变量值，又不希望使用字符串格式化

>>> name = 'Gumby'    >>> salutation = 'Mr.'     >>> greeting = 'Hello,'     >>> print greeting, salutation, name       Hello, Mr.Gumby

如果greeting字符串中不带逗号，可以 print greeting + ',' ,salutation, name

如果在结尾处加上逗号，那么接下来的语句会与前一条语句在同一行打印　　　　　>>>print 'Hello,',    >>> print 'World!'     输出Hello, World!

1.2 import

import somemodule    from somemodule import somefunction              from somemodule import somefunction, anotherfunction    from somemodule import *

如果有两个模块都有open函数，可import somemodule,在使用时 module.open1(...)   module2.open(...)

还可以在语句末尾增加一个as子句，在该子句后给出名字，或为整个模块提供别名

>>> import math as foobar     >>> foobar.sqr(4)      2.0

函数别名  >>> from math import sqrt as foobar    >>> foobar(4)     2.0

或者from module1 import open as open1                from module2 import open as open2

2.赋值

2.1 序列解包

可选代解包，将多个值的序列解开，然后放到变量的序列中

>>> x,y, z = 1, 2, 3     >>> print x, y, z     1 2 3

>>> x, y = y, x             >>> print x, y, z      2 1 3

当函数或方法返回元组时，该方法尤其适用

>>> values = 1, 2, 3    >>> values     (1, 2, 3)      >>> x      1

需要获取（和删除）字典中任意键－值对，可使用popitem方法，将键值作为元组返回，

>>> scoundrel = {'name': 'Robin', 'girlfriend': 'Marion'}       >>> key.value = scoundrel. popitem()  

>>> key     'girlfriend'       >>> value    >>> 'Marion'

它允许函数返回一个以上的值并打包成元组，然后通过一个赋值语句进行访问，所解包的序列中的元素数量必须和放置在赋值符号左边的变量数量完全一致

****python3.0另一个解包特性，可以在参数列表中使用星号运算符，a,b,rest* = [1, 2, 3, 4]最终会在a和b被赋值之后将所有其他参数都收集到rest中，rest的结果[3, 4],星号也可放置第一个位置，这样它就总会包含一个列表，右边的赋值语句还可以是可迭代对象

2.2 链式赋值

将同一个值赋给多个变量的捷径

x = y = somefunction( )    等同于   y = somefunction( )    x = y

x = somefunction( )不同于 y = somefunction( )

2.3 增量赋值

>>> x = 2     >>> x += 1     >>> x *= 2       >>>x       6

>>> fnord = 'foo'     >>> fnord += 'bar'      >>> fnord *=2       >>> fnord         'foobarfoobar'

3. 语句块，缩排

语句块是在条件为真（条件语句）时执行或者执行多次（循环语句）的一组语句，在代码前放置空格来缩进语句即可创建语句块

使用tab字符可以缩进（８个空格），标准为空格，尤其在每个缩进需要４个空格时

python中使用冒号来标识语句块的开始，块中每个语句都是缩进的，当回退到和已经闭合的块一样的缩进量时，表示当前块结束

4.条件和条件语句

假值，False. None, 0, "", (), [], {} 即空的都为假值

if   else   elif  

5.嵌套

6.复杂条件

6.1 比较运算符

x is y x和y是一个对象(x is not y)       x in y x是y容器（例如序列）的成员, x not in y

6.2 相等运算符

= = 判断两个对象是否相等，is判定两者是否等同（同一个对象）

6.3 is 同一性运算符

>>> x = y = [1, 2, 3]      >>> z = [1, 2, 3]     >>> x == y   True   >>> x == z    True    >>> x is y    True     >>> x is z     False

避免将is运算符用于比较类似数值和字符串这类不可变值，因为python内部操作这些对象的方式的原因，结果不可测

6.4 in 成员资格运算符

6.5 字符串和序列比较

字符串可以按照字母序排列比较　>>>"alpha" < "beta"   True

序列 >>> [1, 2] < [2, 1]     True                      >>> [2, [1, 4]] < [2, [1, 5]]   True

6.6 布尔运算符

and, or, not

6.7 断言 assert

需要确保某个条件为真程序才能正常工作，assert可在程序中置入检查点

>>> age = -1     >>> assert 0 < age < 100 　　报错

5.循环

5.1 while

name = ' '

while not name:

     name = raw_input("please enter your name:")

print 'hello, %s!' % name

考虑空格，改为while not name or name.isspace（）或者while not name.strip()

5.2 for循环

words = ['this', 'is', 'an', 'ex', parrot']

for word in words:

     print word

numbers = [0, 1, 2, 3, 4, 5]

for number in numbers:

     print number

迭代（循环的另一种说法），内建的范围函数 range

>>> range(0, 6)      [0, 1, 2, 3, 4, 5]  包含下限，不包含上限

for number in range(0,6) :

    print number

xrange 函数类似 range，区别在于range函数一次创建整个序列，而xrange一次只创建一个数，当需要迭代巨大的序列时更高效

5.3 循环遍历字典元素

d = {'x': 1, 'y': 2, 'z': 3} 

for key in d;

    print key, 'corresponds to', d[key]

如果只需要值，可以使用d.values代替d.keys， d.items方法会将键值对作为元组返回，for循环的一大好处就是可以循环中使用序列解包

for key.value in d.items():

      print key, 'corresponds to' , value

字典元素的顺序通常是没有定义的，迭代的时候，字典中的键和值都能被处理，但处理顺序不确定，如果顺序很重要的话，可以将键值保存在单独的列表中，例如在迭代前进行排序

5.4一些迭代工具

5.4.1 并行迭代

同时执行两个序列

names = ['anne', 'beth', 'george', 'damon']

ages = [12, 45, 32, 102]

打印名字和对应年龄，

for i in range(len(names)):

     print name[i], 'is', ages[i], 'years old'

内建的zip函数可以用来进行并行迭代，可以把两个序列‘压缩’在一起，然后返回一个元组列表

>>> zip(names, ages)

[('anne', 12), ('beth', 45), ('george', 32), ('damon', 102)]

在循环中解包元组

for name, age in zip(names, ages):

     print name. 'is', age, 'years old'

zip函数也可以作用于任意多的序列，可以应付不等长序列，短的用完即停止

>>> zip(range(5), xrange(1000000))

[(0, 0), (1, 1), (2, 2),(3, 3), (4, 4)]     使用xrange只计算前５个数字

5.4.2 编号迭代

迭代序列中的对象，同时获取当前对象的索引

例如，在一个字符串列表中替换所有包含‘XXX'的子字符串

index = 0                                                                                   

for string in strings:

   if 'XXX' in string;

   strings[index[ = '[censored]'

index += 1

另一种使用内建的enumerate函数

for index, string in enumerate(strings):

    if 'xxx' in string:

        strings[index] = '[censored]'

5.4.3 翻转和排序迭代

reverse和sort

5.5 跳出循环

break 结束循环

continue 结束当前循环，跳到下一轮循环

while True/break

while True:

     word = raw_input('Please enter a word:')

     if not word: break

     print 'The word was' + word

5.6 循环中的else子句

from math import sqrt

for n in range(99, 81, -1）:

     root = sqrt (n)

     if root == int(root):

         print n

         break

else:

     print "Didn't find it!"

6 列表推导式－－轻量级循环

是利用其他列表创建新列表的一种方法，工作类似for

>>> [x*x for x in range(10)]          [0,1,4,9,16,25,36,49,64,81]

>>> [x*x for x in range(10) if x% 3 == 0]     [0,9,36,81]

>>> [(x, y) for x in range(3) for y in range(3)]            [(0,0),(0,1),(0,2),(1,0),(1,1),(1,2),(2,0),(2,1),(2,2)]

男孩女孩姓名

>>> girls = ['alice', 'bernice', clarice']

>>> boys = ['chiris', 'arnold'. 'bob']

>>> [b+'+'+g for b in boys for g in girls if b[0] == g[0]]

['chris+clarice'. 'arnold+alice', 'bob+bernice']

更优方案

 girls = ['alice', 'bernice', clarice']

 boys = ['chiris', 'arnold'. 'bob']

 letterGirls = { }

 for girl in girls :

       letterGirls.setdefault(girl[0], [ ] ).append(girl)

 print [b+'+'+g for b in boys for g in letterGrils[b[0]]]

7. 三人行

pass,什么都没发生，占位，比如if语句下面占位使程序运行

del，移除对象的引用和名字，但不回移除后定义的（x=y,移除x,但是y还在而且非空）

exec和eval执行和求值字符串