一、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==y	x等于y
x<y	x小于y
x>y	x大于y
x>=y	x大于等于y
x<=y	x小于等于y
x!=y	x不等于y
x is y	x和y是同一个对象
x is not y	x和y是不同的对象
x in y	x是容器（如序列、字典）y的成员
x not in y	x不是容器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执行和求值字符串。