python语句--条件语句

linuxx

　　一、print语句、import语句、赋值语句。
　　1.1、print语句：输出
　　>>> print(2,3,4)    //python2.x
　　(2, 3, 4)
　　>>>
　　>>> print(1,2,3)    //python3.x
　　1 2 3
　　>>>
　　备注：print函数在输出时会在每个参数之间都插入一个空格符
　　在python2.x中，print的参数会构成一个元组，但是在python3.x中，print参数会构成一个元组。
　　如果不想在各参数之间留有空格，用连接字符“+”（加号）。如：
　　>>> print(1+2+3)    //按整数进行相加操作
　　6
　　>>> print('1'+'2'+'3')    //字符连接操作。
　　123
　　>>>
　　
　　1.2、import语句：把某件事作为另一件事导入。
　　从模块导入函数方法一：import somemodule
　　从模块导入函数方法二：from somemodule import somefunction
　　从模块导入函数方法三：from somemodule import somefunction,anotherfunction,yetanotherfunction
　　从模块导入函数方法四：from somemodule import *
　　从模块导入函数方法五：import math as foobar    //增加模块别名，关键字as 后为模块的别名
　　从模块导入函数方法六：from math import sqrt as foobar    //增加函数别名，关键字as后为函数别名
　　如：from module1 import open as open1
　　from module2 import open as open2
　　只有确定自己想要从给定的模块中导入所有功能时，才应该使用方法四。如果一个函数在两个模块中都有，如open函数，可以使用方法一导入，然后像下面这样使用函数：
　　module1.open(...)
　　module2.open(...)
　　1.3、赋值语句
　　a）、序列解包：多个赋值同时进行（两边的变量需数量一致）
　　如：
　　python3.x中
　　>>> x,y,z=1,2,3
　　>>> x
　　1
　　>>> y
　　2
　　>>> z
　　3
　　>>> print(x,y,z)
　　1 2 3
　　>>>
python2.x中　　>>> x,y,z=1,2,3
　　>>> x
　　1
　　>>> y
　　2
　　>>> z
　　3
　　>>>
　　>>> print(x,y,z)
　　(1, 2, 3)
　　>>> x,y,z=1,2,3
　　>>> print(x,y,z)
　　(1, 2, 3)
　　>>> x,y,z=z,x,y        //交换变量
　　>>> print(x,y,z)
　　(3, 1, 2)
　　>>>
　　备注：序列解包（或叫迭代解包）将多个值的序列解开，然后放到变量的序列中。更形象的表示方法如：
　　>>> values=1,2,3
　　>>> values
　　(1, 2, 3)
　　>>> x,y,z=values
　　>>> print(x,z,y)
　　(1, 3, 2)
　　>>>
　　取字典中的键-值对：
　　>>> d={'name':'zhangsan','age':'30'}
　　>>> d
　　{'age': '30', 'name': 'zhangsan'}
　　>>> key,value=d.popitem()    //用popitem方法（随机取字典中的键-值对删除）赋值给变量（key、value）。
　　>>> key
　　'age'
　　>>> value
　　'30'
　　>>> print(key,value)
　　('age', '30')
　　>>> d
　　{'name': 'zhangsan'}
　　>>>
　　b）、链式赋值：
　　链式赋值（chained assigment）是将同一个值赋给多个变量的捷径。
　　如：
>>> x=y=1　　>>> x
　　1
　　>>> y
　　1
　　>>>
　　等同于：
　　>>> y=1
　　>>> x=y
　　>>> x
　　1
　　>>>
　　c）、增量赋值（+=、-=、*=、\=、%=）
　　x+=1: 即x=x+1,其他增量类似。
　　注意：对于其他数据类型同样适用（只要二元运算符本身适用于这些数据类型即可）：
　　如：
　　>>> a='love'
　　>>> a+='u'
　　>>> a
　　'loveu'
　　>>> a*=3
　　>>> a
　　'loveuloveuloveu'
　　>>>
　　二、语句块
　　语句块是在条件为真（条件语句）时执行或者执行多次（循环语句）的一组语句。在代码前放置空格来缩进语句即可创建语句块。当然tab字符也可以缩进语句块，一个tab为8个空格，建议用空格缩进
　　很多编程语言使用特殊单词或者字符（比如begin或{ ）来表示一个语句块的开始，用另外的单词（end或者 }）来表示语句块的结束。在python中，冒号（：）用来标识语句块的开始，块中的每一个语句都是缩进的（缩进量相同）。当回退到和已经闭合的块一样的缩进量时，表示当前语句块结束。
　　三、条件和条件语句：
　　1、 布尔值：真(True)、假(False)。//注意字符的大小写
　　在python中被看作布尔值-假（flase）的值：False、None、0、" "、（ ）、[ ] 、{ }。
　　bool函数可以用来转换其他值为布尔值：
　　如：
　　>>> bool(12)
　　True
　　>>>
　　2、条件执行和if语句
　　a）、if语句：
　　格式：if 条件:语句     //如果if后面的条件为真，就执行后面的语句。
　　b）、else子句： else子句不能单独使用，必须作为if的子句执行，且只有在if条件不满足才执行。
　　格式：
　　if 条件:语句
　　else:语句
　　>>>name='123'
　　>>> if name=='1234':print("hello")
　　... else:    //else后面没有条件语句
　　...   print("hello world")
　　...
　　hello world
　　>>>
　　c）、elif子句 （如果有else子句，一般把else子句放在最后）
　　如果要检查多个条件，则使用elif，它是else if的缩写。它是具有条件的else子句。
　　如：
　　>>> name='123'
　　>>> if name=='1234':print("no true")
　　... elif name==123:print("it's right")        //注意elif后面有条件
　　... else:print("fo 123")
　　...
　　fo 123
　　>>>
　　d）、条件：
　　d1）、条件运算（比较运算符）
表达式描述x==yx等于yx<yx小于y　　x>y
x大于yx>=yx大于等于yx<=yx小于等于yx!=yx不等于yx is y　　x和y是同一个对象
x is not yx和y是不同的对象x in yx是容器（如序列、字典）y的成员x not in yx不是容器y的成员　　注意：x和y应该是相同（相近）类型的数据类型，否则比较无实际意义。同时：不建议使用x<>y表达式，虽然它的意思是x!=y。
　　在python中比较运算和赋值运算一样是可以连接的----几个运算符可以连在一起使用，比如： 0<age<100.
　　d2）、相等运算符（==）
　　之所以用两个==来表示两个值是否相等，是因为一个“=“表示赋值运算。
　　d3）、同一性运算符（is）
>>> x=y=[1,2,3]　　>>> z=[1,2,3]
　　>>> x is y
　　True
　　>>> x is z
　　False
　　>>>
　　解释：x、y、z是一样的列表，x is y的值是True，x is z的值是false
　　d4）、成员资格运算（in）
　　>>> name='12345678'
　　>>> if '4' in name: print("it's ok")
　　... else:print("it's worng")
　　...
　　it's ok
　　>>>
　　d5）、字符串和序列比较：(实际的顺序可能会因为使用不同的locale有所不同）
　　字符串可以按照字母顺序排列进行比较。
　　>>> "abc"<"abg"
　　True
　　>>>
　　d6）、布尔运算符（and、or、not）：布尔运算符可以结合使用。
　　布尔运算符可以连接两个或多个布尔值
　　如：
　　>>> x=3
　　>>> if x<10 and x>0 :print("hello world")
　　... else:print("no user num")
　　...
　　hello world
　　>>>
　　注意：布尔运算符也被叫做短路运算符。如表达式x and y，如果x为假，表达式就会立刻返回false，而不管y的值。同样在表达式x or y中，如果x为真，则会立刻返回x的值，而不管y的值；如果x的值为假，继续执行y的运算。
　　例子：当用户可以输入用户名也可以不输入：
>>> name=input("enter ur name:") or "<unknown>"　　enter ur name:
　　>>> name
　　'<unknown>'
　　>>>
解释：  python3.x中可以执行，在python2.x会报错。它表示如果输入名字的话，就不执行or后面的语句，并将值赋值给name，否则将<unkown>赋值给name.　　d7）、断言 （使用关键字assert）
　　作用：有时当程序在条件不满足时，会导致程序崩溃。当使用assert关键字时，可以检查出在条件不满足时直接让他崩溃，这样可以作为程序初期测试和调试过程中的辅助条件。
　　如：
　　>>> age=10
　　>>> assert 0<age<100
　　>>> assert 0<age<10
　　Traceback (most recent call last):
　　File "<stdin>", line 1, in <module>
　　AssertionError
　　>>>
　　>>> assert 0<age<10,'this age must be reallistic'    //使用assert条件时，可以添加字符串，
　　Traceback (most recent call last):
　　File "<stdin>", line 1, in <module>
　　AssertionError: this age must be reallistic
　　>>>
　　3、循环：
　　a）、while循环    （用来在任何条件为真的情况下重复执行一个代码块。）
　　//需要注意的是语句块的书写，否则python编辑器不知道怎么执行（哪里开始，哪里结束）
　　x=1
　　while x<=100:
　　print (x)
　　x+=1
　　name=''   //name被赋予空值（布尔值：假），注意：''两个单引号之间没有空格，有空格表示空格字符
　　while not name:
　　name=input("enter ur name:")
　　print("hello %s" % name)
　　执行结果：
　　admin@open:~> python3.4 while1.py     //在python2.x中执行一次，就会报错退出
　　enter ur name:
　　enter ur name:
　　enter ur name:zhangsan
　　hello zhangsan
　　admin@open:~>
　　如果空格作为名字，即name=‘  ‘，python会认为name为空格字符，不会判定为假。
　　修改的办法一：while not name or name.isspace()
　　修改的办法二：while not name.strip()。
　　b）、for循环 (能使用for循环，就尽量不要使用while循环）
　　>>> words=[1,2,3,4]
　　>>> for word in words : print (word)
　　...
　　1
　　2
　　3
　　4
　　>>>
　　>>> for num in range(1,10):print(num)    //range函数包括下限，但不包括上限。
　　...
　　1
　　2
　　3
　　4
　　5
　　6
　　7
　　8
　　9
　　>>>
　　>>> range(0,10)
　　range(0, 10)
　　>>>
　　b1）、循环遍历字典元素
　　for语句循环字典所有值：
　　反转和排序迭代（reversed，sorted）；sorted返回列表，而reversed返回一个对象（不能理解的对象）。
　　c）、跳出循环：提前结束循环，即使执行条件满足为真。
　　c1）、break
　　>>> for n in range(99,0,-1):
　　...     root=sqrt(n)
　　...     if root==int(root):        //如果root和取整的root一样 则输出n。
　　...         print(n)
　　...         break
　　...
　　81
　　>>>
　　c2）、continue ：结束当前剩余循环体语句，但是不结束循环，跳到下一循环体并开始执行。
　　for x in seq:
　　if condition1:continue
　　if condition2:continue
　　if condition3:continue
　　do_something()
　　do_something_else()
　　do_another_thing()
　　etc()
　　很多时候，只要使用if语句就可以：
　　for x in seq：
　　if not (condition1 or condition2 or condition3):
　　do_something()
　　do_something_else()
　　do_another_thing()
　　etc()
　　c3）、while True/break习语：
　　while True:        //循环条件一直为真
　　word=str(input('enter a word:'))
　　if not word:break        //循环体语句，如果不满足if条件则跳出循环，否则执行下一个语句。
　　print('the word is:'+word)
　　c4）、循环中的else子句：
　　from math import sqrt
　　for n in range(99,80,-1):
　　root=sqrt(n)
　　if root==int(root):
　　print(n)
　　break
　　else:
　　print("didn't find it!")
　　d）、列表推导式（轻量级循环）：
　　列表推导式（list comprehension）是利用其他列表创建新列表的一种方法，类似for循环。
　　如：
　　>>> [x*x for x in range(10)]
　　[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
　　>>>
　　>>> [pow(2,x) for x in range(16)]
　　[1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768]
　　>>> [(x,y) for x in range(3) for y in range(3)]        //增多的for语句部分，注意range（）不包括右上限
　　[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
　　>>> [pow(x,y) for x in range(3) for y in range(3)]
　　[1, 0, 0, 1, 1, 1, 1, 2, 4]
　　>>>
　　>>> result=[]
　　>>> for x in range(3):
　　...  for y in range(3):
　　...   result.append((x,y))
　　...
　　>>> result
　　[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
　　>>>
　　e）、pass ：什么都不做，一般用来作程序的站位语句。
　　f）、del：删除，删除不再使用的对象（如：列表、字典）。
　　g）、exec和eval执行和求值字符串。