python (第十周）编玛规则、变量和常量、数据类型、运算符与表达式

2.2.3 模块导入的规范
1、import 语句

 import  sys              #sys模块是处理系统环境的函数的集合
 print  sys.path

2、from….import… 语句

from  sys  import  path
print path

两种语句的区别是前者在当前程序的命名空间中创建导入模块的引用，后者只导入模块的一部分内容，并在当前的命名空间创建导入对象的引用。

2.2.4 使用空行分隔代码
函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。空行与代码缩进不同，空行不是python语法的一部分。记住：空行也是程序代码的一部分。
2.2.5 正确的注释
C、C++、JAVA均采用“//”或”/“。python用”#“。通过注释还可以对代码进行调试检查。

  注释的用法                      作用    
  单行注释                    说明一行语句的作用
   块注释             说明一段代码的作用或整个程序文件的功能
 程序的跨平台                    #！/usr/bin/python
 中文注释的支持         # - * - coding:UTF - 8 - * -
  调试程序                  注释可以帮助程序员调试程序

2.2.6 语句的分隔
1、在C 、java中，分号用于一条语句的结束标识，python中用换行来标识语句的结束。
2、X=1 ; Y =1 ; Z=1 #一行中写多条语句帽用分号，但分号不是python推荐使用的符号。
3、python 使用”\”作为换行符。

     sql = "select id , name\
          from dept \ 
          where name = 'a'"
          print sql

   输出结果： sql = "select id , name from dept  where name = 'a'"

2.3 变量和常量
变量是内存中一块区域，值可以改变。常量不一块只读内存区域，不能修改。
2.3.1 变量的命名
变量的首字符必须用字母或下划线。 错误的变量命名：1_var = 3
2.3.2 变量的赋值
python 中变量的赋值操作即是变量的定义过程。

# 一次新的赋值操作，将创建一个新的变量。即使变量名相同，变量标识并不同。

x = 1
print id(x)
x = 2
print id(x)

输出结果：31031064
31031040

#给多个变量赋值

a = (1, 2, 3)
(x, y, z) = a
print "x =", x
print "y =", y
print "z =", z

2.3.3 局部变量
局部变量的作用范围只在局部变量被创建的函数内有效。

 def fun():
         local = 1
         print local
   local = local - 1     

#此时已超出local变量的作用范围，会提示错误： name ‘local’ is not defined

2.3.4 全局变量
全局变量是能够被不同的函数、类或文件共享的变量，在函数之外定义的变量都可以称为全局变量。
# 通常在文件的开头定义全局变量

_a = 1
_b = 2
def add():
    global _a       #这里使用了global保留字，用于引用全局变量。
    _a = 3          #对全局变量 _a 重新赋值。
    return "_a + _b =", _a + _b
def sub():
    global _b
    _b = 4
    return "_a - _b =", _a - _b
print add()
print sub()
输出：('_a + _b =', 5)
     ('_a - _b =', -1)
# 错误的使用全局变量
_a = 1 
_b = 2
def add():
    _a = 3      #函数 add() 的局部变量
    return "_a + _b =", _a + _b
def sub():
    _b = 4        #函数 sub() 的局部变量
    return "_a - _b =", _a - _b
print add()
print sub()    
输出：('_a + _b =', 5)
     ('_a - _b =', -3)

2.3.5 常量
C++用const Java 用 static和final 保留字指定常量，而python 不用，可以自己定义一个常量类来实现常量的功能。

2.4 数据类型
2.4.1 数字类型
python 不需要声明变量的类型，只需要采用赋值表达式即可。python 不能修改对象i的值。如果需要查看变量类型，可以使用 builtin模块的type类，该类能返回变量的类型。builtin模块是python的内联模块，不需要使用import语句。

 #整型
i = 1
print type（i）
输出：<type 'int'>
 #长整型
l = 999999 990
print type (l)
输出：<type 'long'>
 #浮点型
f = 1.2
print type (f)
输出：<type 'float'>
 #布尔型
b = Ture
print type（b）
输出：<type 'bool'>

 # 复数类型
c = 7 + 8j
print type（c）
输出：<type 'complex'>

【如果写成c = 7 + 8i ，python 不能识别其中的“i”.将提示语法错误。】

2.2.4 字符串类型
单引号与双引号的作用是相同的。

#三引号的第一种用法
str = '''he say ''hello world!'' '''
print str

三引号的别一种用法是制作文档字符串。python 的每个对象才都有一个属性 _doc_, 这个属性用于描述该对象的作用。

#三引号制作doc文档
class Hello       #定义一个名为Hello的类。
'''hello class''' #对Hello类的描述，该字符串将被存放在类的__doc__属性中。
def printHello():
'''print hello world'''
print ''hello world!''
print Hello.__doc__
print Hello.printHello.__doc__
输出：hello class
print hello world

1、输入特殊字符的字符串，需要用转义字符，其操作只要在特殊字符的前面加上“\” 即可。
2、使用双引号和三引号可以直接输出含有特殊字符的字符串。

2.5 运算符与表达式
2.5.1 算术运算符和算术表达式

print ''1/2='' , 1/2        #输出：0
print ''1/2 = '' , 1.0/2.0  #输出：0.5
print ''3%2 ='' , 3%2       #3除以2后的余数，输出：1

如果要使“2/1”进行浮点数计算，需要在文件的最前面导入division模块。

from__future__import division

python 的算术表达式具有结合性和优先性。

2.5.2 关系运算符和关系表达式

    print 2 ! = 2            
    print 1 < > 2
    print 1 = = 2
输出：False
     Ture
     False

<,<=,>,>=的优先级别大于==，！=的，关系运算符的优先级低于算术运算符。

2.5.3 逻辑运算符和逻辑表达式

逻辑运算符       逻辑表达式             说明
And             x and y       逻辑与，当x为Ture时，才计算y
Or              x or y        逻辑或，当x为False时，才计算y
Not              not x        逻辑非

# 逻辑运算符
print not True      
print False and True 
print True and False 
print True or False
输出：False
     False
     False
     Ture
# 逻辑表达式的优先级别
print "not 1 and 0 =>", not 1 and 0    
print "not (1 and 0) =>", not (1 and 0)
print "(1 <= 2) and False or True =>", (1 <= 2) and False or True
print "(1 <= 2) or 1 > 1 + 2 =>", 1 <= 2, "or", 1 > 2, "=>", (1 <= 2) or (1 < 2)
输出：False
     Ture
     Ture   #先执行1<=2,再执行and,最后执行or运算。
     Ture

#定义0为假，其他数为真

2.5.4 运算符的优先级

下表是从最低优先级到最高优先级，Python根据运算符的优先级从高到低进行计算，也就是先计算较下面的，然后再计算表上面的运算符。

通常为了使代码具有可读性，最好使用圆括号来分组表达式。