python中的语句：
赋值语句
if语句，当条件成立时运行语句块。经常与else, elif（相当于else if）配合使用。
for语句，遍列列表、字符串、字典、集合等迭代器，依次处理迭代器中的每个元素。
while语句，当条件为真时，循环运行语句块。
try语句。与except, finally, else配合使用处理在程序运行中出现的异常情况。
class语句。用于定义类型。
def语句。用于定义函数和类型的方法。
pass语句。表示此行为空，不运行任何操作。
assert语句。用于程序调适阶段时测试运行条件是否满足。
with语句。Python2.6以后定义的语法，在一个场景中运行语句块。比如，运行语句块前加锁，然后在语句块运行退出后释放锁。
yield语句。在迭代器函数内使用，用于返回一个元素。
raise语句。抛出一个异常。
import语句。导入一个模块或包。常用写法：from module import name, import module as name, from module import name as anothername
特别说明，以上划分也不是很严格，有的内容，有的朋友不认为属于语句。这没关系，反正就是那个东西，在编程中使用。不纠结于名词归类上。总之这些都是要掌握的，才能顺利编程呢。
赋值语句
实例:
>>> hiekay = 1
>>> python = 2
>>> x, y = hiekay, python #相当于x=hiekay,y=python
>>> x
1
>>> y
2
>>> x, y #输出的是tuple
(1, 2)
>>> [x, y] #这就是一个list
[1, 2]
>>> [a, b] = [hiekay, python]
>>> a
1
>>> b
2
>>> a, b
(1, 2)
>>> [a, b]
[1, 2]
换一种方式，以上两种赋值方法交叉组合一下：
>>> [c, d] = hiekay, python
>>> c
1
>>> d
2
>>> c, d
(1, 2)
>>> f, g = [hiekay, python]
>>> f
1
>>> g
2
>>> f, g
(1, 2)
居然也行。其实，赋值，就是对应着将左边的变量和右边的对象关联起来。
有这样一个有趣的问题，如果a=3,b=4，想把这两个变量的值调换一下，也就是a=4，b=3。在有的高级语言中，是要先引入另外一个变量c做为中间变量：
a = 3
b = 4
c = a #即c=3
a = b #a=4
b = c #b=3
python 更牛逼,不需要中间变量：
>>> hiekay = 100
>>> python = 200
>>> hiekay, python = python, hiekay
>>> hiekay
200
>>> python
100
神奇吧。
序列赋值
其实上面实验的赋值，本质上就是序列赋值。如果左边的变量是序列，右边的对象也是序列，两者将一一对应地进行赋值。
>>> [a, b, c] = (1, 2, 3) #左右序列一一对应，左边是变量，右边是对象
>>> a
1
>>> b
2
>>> c
3
>>> (a,b,c) = [1,2,3]
>>> a
1
>>> b
2
>>> c
3
>>> [a,b,c] = "kay" #不要忘记了，str也是序列类型的数据
>>> a
"k"
>>> b
"a"
>>> c
"y"
>>> (a,b,c) = "kay"
>>> a,c
("k", "y")
>>> a,b,c = "kay" #与前面等价
>>> a,b
("k", "a")
>>> a,b = "kay" #报错了，因为左边和右边不是一一对应
Traceback (most recent call last):
File "", line 1, in 
ValueError: too many values to unpack
>>> (a,b),c = "hi","kay" #注意观察，这样的像是是如何对应的
>>> a,b,c
("h", "i", "kay")
>>> string = "hiekay"
>>> a,b,c = string[0],string[1],string[2] #取切片也一样
>>> a,b,c
("h", "i", "e")
>>> (a,b),c = string[:2],string[2:]
>>> a,b,c
("h", "i", "ekay")
总结: 变量与值 一一对应 .

最基本的语句——赋值语句
 
【知识点】
 
赋值运算符；
复合的赋值运算符；
赋值表达式；
*赋值过程中的类型转换；
赋值表达式和赋值语句；
变量赋初值；
【内容】
 
在C程序中最常用的语句是：赋值语句和输入输出语句。
 
一、赋值运算符
 
赋值符号=就是赋值运算符，它的作用是将一个数据赋给一个变量。执行过程称为：赋值操作或赋值运算。
 
将一个常量赋给一个变量 
  
例如：int a = 23;//将常量23赋给变量a
将一个表达式的值赋给一个变量
 
二、复合的赋值运算符
 
在赋值符=前加上其他运算符，可以构成复合的运算符。有以下复合运算符：
 
+=
-=
*=
/=
%=
a += b;// a = a + b;
 
注意：若b是包含若干项的表达式，则相当于它有括号。(推荐：在b包含若干项表达式时，使用括号将b括起来)例如：
 
 
三、赋值表达式
 
定义：由赋值运算符将一个变量和一个表达式连接起来的式子称为“赋值表达式”。
 
形式：变量 赋值运算符(=) 表达式
 
作用：将一个表达式的值赋给一个变量。（计算、赋值功能）
 
概念：左值(left value,lvalue)、右值(right value,rvalue)
 
左值：
 
出现在赋值运算符的左侧；
其值可以改变；
注意：变量可以作为左值，算术表达式a+b不能作为左值，常量的值不能改变也不能作为左值。
 
右值：出现在赋值运算符的右侧。左值也可以出现在赋值运算符右侧，因此左值也可以作为右值。
 
*四、赋值过程中的类型转换
 
如果赋值运算符两侧的类型一致，则直接进行赋值。
 
如果赋值运算符两侧的类型不一致，但都是算术类型时，在赋值时要进行类型转换。类型转换是由系统自动进行的，转换的规则是：
 
将浮点型数据(包括单、双精度)赋给整型变量时，先对浮点数取整，即舍弃小数部分，然后赋予整型变量。
将整型数据赋给单、双精度变量时，数值不变，但以浮点数形式存储到变量中。
将一个double型数据赋给float变量时，先将双精度数转换为单精度，即只取6-7位有效数字，存储到float变量的4个字节中。注意：双精度数值的大小不能超出float型变量的数值范围。
将一个float型数据赋给double变量时，数值不变，在内存中以8个字节存储，有效位数扩展到15位。
字符型数据赋给整型变量时，将字符的ASCII码值赋给整型变量。
*将一个占字节多的整型数据赋给一个占字节少的整型变量或字符变量时，只将其低字节原封不动地送到被赋值的变量。例如：
 
本质：
 
整型数据之间的赋值，是按存储单元中的存储形式直接传送。
实型数据之间以及整型与实型之间的赋值，是先转换(类型)后赋值。
总结：
 
赋值运算符两侧类型不一致，系统先转换后赋值；
算术运算符两侧类型不一致，系统先转换后运算；
五、赋值表达式和赋值语句
 
六、变量赋初值
 
注意：如果对几个变量赋予同一个初值，应写成：
 
int a = 3, b = 3, c = 3;
 
不能写成：
 
int a = b = c = 3;
 
一般变量初始化不是在编译阶段完成的(只有在静态存储变量和外部变量的初始化是在编译阶段完成的)，而是在程序运行时执行本函数时赋予初值的，相当于执行一个赋值语句。
 

python中的语句：
 
赋值语句
if语句，当条件成立时运行语句块。经常与else, elif（相当于else if）配合使用。
for语句，遍列列表、字符串、字典、集合等迭代器，依次处理迭代器中的每个元素。
while语句，当条件为真时，循环运行语句块。
try语句。与except, finally, else配合使用处理在程序运行中出现的异常情况。
class语句。用于定义类型。
def语句。用于定义函数和类型的方法。
pass语句。表示此行为空，不运行任何操作。
assert语句。用于程序调适阶段时测试运行条件是否满足。
with语句。Python2.6以后定义的语法，在一个场景中运行语句块。比如，运行语句块前加锁，然后在语句块运行退出后释放锁。
yield语句。在迭代器函数内使用，用于返回一个元素。
raise语句。抛出一个异常。
import语句。导入一个模块或包。常用写法：from module import name, import module as name, from module import name as anothername
 
特别说明，以上划分也不是很严格，有的内容，有的朋友不认为属于语句。这没关系，反正就是那个东西，在编程中使用。不纠结于名词归类上。总之这些都是要掌握的，才能顺利编程呢。
 
赋值语句
 
实例:
 
>>> hiekay = 1
>>> python = 2
>>> x, y = hiekay, python   #相当于x=hiekay,y=python
>>> x
1
>>> y
2
>>> x, y                    #输出的是tuple
(1, 2)
>>> [x, y]                  #这就是一个list
[1, 2]

>>> [a, b] = [hiekay, python]
>>> a
1
>>> b
2
>>> a, b
(1, 2)
>>> [a, b]
[1, 2]

 
换一种方式，以上两种赋值方法交叉组合一下：
 
>>> [c, d] = hiekay, python
>>> c
1
>>> d
2
>>> c, d
(1, 2)
>>> f, g = [hiekay, python]
>>> f
1
>>> g
2
>>> f, g
(1, 2)

 
居然也行。其实，赋值，就是对应着将左边的变量和右边的对象关联起来。
 
有这样一个有趣的问题，如果a=3,b=4，想把这两个变量的值调换一下，也就是a=4，b=3。在有的高级语言中，是要先引入另外一个变量c做为中间变量：
 
a = 3
b = 4
c = a   #即c=3
a = b   #a=4
b = c   #b=3

 
python 更牛逼,不需要中间变量：
 
>>> hiekay = 100
>>> python = 200
>>> hiekay, python = python, hiekay
>>> hiekay
200
>>> python
100

 
神奇吧。
 
序列赋值
 
其实上面实验的赋值，本质上就是序列赋值。如果左边的变量是序列，右边的对象也是序列，两者将一一对应地进行赋值。
 
>>> [a, b, c] = (1, 2, 3)   #左右序列一一对应，左边是变量，右边是对象
>>> a
1
>>> b
2
>>> c
3
>>> (a,b,c) = [1,2,3]
>>> a
1
>>> b
2
>>> c
3
>>> [a,b,c] = "kay"     #不要忘记了，str也是序列类型的数据
>>> a
'k'
>>> b
'a'
>>> c
'y'
>>> (a,b,c) = "kay"
>>> a,c
('k', 'y')
>>> a,b,c = 'kay'       #与前面等价
>>> a,b
('k', 'a')
>>> a,b = 'kay'         #报错了，因为左边和右边不是一一对应
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack

>>> (a,b),c = "hi","kay"    #注意观察，这样的像是是如何对应的
>>> a,b,c
('h', 'i', 'kay')
>>> string = "hiekay"
>>> a,b,c = string[0],string[1],string[2]   #取切片也一样
>>> a,b,c
('h', 'i', 'e')
>>> (a,b),c = string[:2],string[2:]
>>> a,b,c
('h', 'i', 'ekay')

 
总结: 变量与值 一一对应 .

1.print语句
 
①括号括起来（自python3），逗号隔开
 
②输出时，隔开的各个字符串前会自动加空格
 
③需要输出的符号可包含在字符串中，也可单独输出，使用+号则不增加空格
 
④同行打印的几种方法
 
2.import语句
 
①轻量化：导入某模块的某函数
 
②大块导入：导入某模块的所有函数
 
③导入加改函数名
 
3.赋值语句
 
①序列赋值
 
②交换变量
 
③链式&增量赋值
 
未完待续……
 
如有疑问或补充，请留言！