初学python之基础详解(二)

       上一篇博客讲解了Python的快速入门，这一篇博客来对python的基础详细的说一说，其中有：语句和语法，变量赋值，基本风格指南，内存管理。

1：python的语法和句法：

1：python中用井号字符（#）表示注释

[python] view plain copy

1. Python 2.7.12 (default, Nov 19 2016, 06:48:10)   
2. [GCC 5.4.0 20160609] on linux2  
3. Type "help", "copyright", "credits" or "license" for more information.  
4. >>> # print '这是一个注释'  
5. ...   
6. >>> #print 'hello python' #python 入门级语句  
7. ...   
8. >>>   
9. >>> print 'hello python' #python 入门级语句  
10. hello python  
11. >>>   

2：python中用(\n)表示换行，是一个标准的分隔符。（通常一个语句一行）

[python] view plain copy

1. Python 2.7.12 (default, Nov 19 2016, 06:48:10)   
2. [GCC 5.4.0 20160609] on linux2  
3. Type "help", "copyright", "credits" or "license" for more information.  
4. >>> print 'hello \n python' #语句中带有换号符号  
5. hello   
6.  python  
7. >>>   

3：python中用（\）表示继续上一行，一般用于一个语句比较长时，用\使语句移到下一行。

[python] view plain copy

1. 1 #coding:utf-8  
2. 2 #!/usr/bin/env python  
3. 3 age = 20  
4. 4 salary = 12000  
5. 5 job = 'IT'  
6. 6 if (age >= 20) and (salary > 10000 ) and \  
7. 7 (job == 'IT'):  
8. 8     print '你是一个有潜力的程序员'        

4：python用分号(;)将两个语句连接在一起。

[python] view plain copy

1. Python 2.7.12 (default, Nov 19 2016, 06:48:10)   
2. [GCC 5.4.0 20160609] on linux2  
3. Type "help", "copyright", "credits" or "license" for more information.  
4. >>> age = 20; print 'age:%d'%age  
5. age:20  

5：python用冒号（:）将代码块的头和体分开。

[python] view plain copy

1. Python 2.7.12 (default, Nov 19 2016, 06:48:10)   
2. [GCC 5.4.0 20160609] on linux2  
3. Type "help", "copyright", "credits" or "license" for more information.  
4. >>> age = 24  
5. >>> if (age > 18):  
6. ...     print '你年满18岁了'  
7. ...   
8. 你年满18岁了  
9. >>>  

6：python语句（代码块）用缩进块的方式体现，不同的缩进深度分割不同的代码块

[python] view plain copy

1. Python 2.7.12 (default, Nov 19 2016, 06:48:10)   
2. [GCC 5.4.0 20160609] on linux2  
3. Type "help", "copyright", "credits" or "license" for more information.  
4. >>> age = 24  
5. >>> if(age > 18):  
6. ...     print '你年满18岁了'  
7. ...     print '你应该遵守法律了'  
8. ...     print '你应该要有担当了'  
9. ...   
10. 你年满18岁了  
11. 你应该遵守法律了  
12. 你应该要有担当了  
13. >>>   

7：python文件以模块的形式组织。模块里的代码可以是一段直接执行的脚本也可以是一堆类似库函数的代码，从而可以被识别的模块导入调用；

[python] view plain copy

1. Python 2.7.12 (default, Nov 19 2016, 06:48:10)   
2. [GCC 5.4.0 20160609] on linux2  
3. Type "help", "copyright", "credits" or "license" for more information.  
4. >>> import numpy  
5. >>> import tensorflow  
6. >>>   

2：变量赋值

1：赋值操作符为等于号（=），等号左边为变量名右边为值。在python中赋值操作不是直接将一个值直接赋值给变量，而是通过对对象的引用将值赋值给变量。

[python] view plain copy

1. Python 2.7.12 (default, Nov 19 2016, 06:48:10)   
2. [GCC 5.4.0 20160609] on linux2  
3. Type "help", "copyright", "credits" or "license" for more information.  
4. >>> num1 = 10  
5. >>> myStr1 = 'a word'  
6. >>> myStr2 = 'hello' + ' ' + 'world'  
7. >>> myList = ['0', 1, 1.1]  
8. >>> myTuple = (1, 2, '3', 4.0)  
9. >>>   

2：增量赋值，首先在python中不支持++，--操作，取而代之的是x+=1，x-=1；增量赋值操作符为：+=，-=，*=， /=，%=，**=，<<=，>>=，&=，^=，|=；

[python] view plain copy

1. Python 2.7.12 (default, Nov 19 2016, 06:48:10)   
2. [GCC 5.4.0 20160609] on linux2  
3. Type "help", "copyright", "credits" or "license" for more information.  
4. >>> x = 10  
5. >>> x+=1  
6. >>> x  
7. 11  
8. >>> x-=1  
9. >>> x  
10. 10  
11. >>> x*=2  
12. >>> x  
13. 20  
14. >>> x/=2  
15. >>> x  
16. 10  
17. >>> x%=3  
18. >>> x  
19. 1  
20. >>> x^=3  
21. >>> x  
22. 2  
23. >>> x**=2  
24. >>> x  
25. 4  
26. >>>   

3：多重赋值又称链式赋值，在多个变量拥有相同的值时可以选用多重赋值。即多个变量引用向通过的一个对象。

[python] view plain copy

1. Python 2.7.12 (default, Nov 19 2016, 06:48:10)   
2. [GCC 5.4.0 20160609] on linux2  
3. Type "help", "copyright", "credits" or "license" for more information.  
4. >>> var1 = var2 = var3 = 1  
5. >>> str1 = str2 = str3 = 'hello'  
6. >>> str1  
7. 'hello'  
8. >>> str3  
9. 'hello'  
10. >>> var1  
11. 1  
12. >>> var3  
13. 1  
14. >>> var2  
15. 1  
16. >>> str2  
17. 'hello'  
18. >>>   

4：“多元”赋值；在python中的多元赋值就是为多个变量同时赋值。在等号左边为多个变量名，等号右边为多个与之相对的值。等号两边的对象都是元组，即多元赋值利用了元组的特性。另外python中两个变量互相换值无需借助第三个临时变量。

[python] view plain copy

1. Python 2.7.12 (default, Nov 19 2016, 06:48:10)   
2. [GCC 5.4.0 20160609] on linux2  
3. Type "help", "copyright", "credits" or "license" for more information.  
4. >>> num1, num2, num3 = 1, 2, 3 #多元赋值  
5. >>> str1, str2, str3 = 'str_1', 'str_2', 'str_3' #多元赋值  
6. >>> (num1, num2, num3) = (1, 2, 3)  
7. >>> (x, y, z) = (1, 'word', [1, 2,3])  #多元赋值  
8. >>> x  
9. 1  
10. >>> z  
11. [1, 2, 3]  
12. >>> y  
13. 'word'  
14. >>> num1  
15. 1  
16. >>> num2  
17. 2  
18. >>> str1  
19. 'str_1'  
20. >>> num1, num2 = num2, num1  #值的交换  
21. >>> num1  
22. 2  
23. >>> num2  
24. 1  
25. >>>   

3：标识符

1：合法的标识符命名规则：

      python的标识符命名规则为：标识符的第一个字符必须是下划线或者字母，剩下的字符可以是字母或者数字或者下划线，python标识符大小写敏感。

2：python中的关键字：

[python] view plain copy

1. False      class      finally    is         return  
2. None       continue   for        lambda     try  
3. True       def        from       while      with  
4. and        del        global     not        yield  
5. as         elif       if         or           
6. assert     else       import     pass  
7. break      except     in         raise  

3：python的内建（built-in）：

       除了关键字之外，python还可以在任何一级代码使用“内建”的名字集合，这些名字可以由解释器设置或使用。虽然built-in不是关键字，但系统应该把它当做“系统保留字”，不做它用。python不支持重载标识符，所以任何时刻都只有一个名字绑定。built-in是__builtins__模块的成员，它由解释器自动导入。把它们看成适合用在任何一级python代码的全局变量。

4：专用下划线标识符；

       python用下划线作为变量前缀和后缀指定特殊变量。

       __xxx：不用‘from module import*’导入

       __xxx__：系统定义名字

       _xxx：类中的私有变量名

4：基本风格指南

1：注释；python语言编程虽然说简单易懂，但是适当的注释会更有助于新来的程序员快速读懂你的代码，或者在你长时间不看自己的代码时，能花更少的时间看懂你的代码。注释不能过少，但是注释也不能过多。

2：文档；python可以通过__doc__特别变量，动态获得文档字符串。在模块，类声明，或函数声明中第一个没有赋值的字符串可以用属性obj.__doc__来进行访问。

3：缩进；python因为没有大括号进行代码块的分割与封装，所以缩进的多少更应该掌握好，一般以四个空格比较好。

4：标识符名称；标识符名称一般要简短意赅，一般类名用名词比如：class Student()，方法名用动词+名词;def del_student()，def delStudent()

5：模块结构和布局：

（1）：起始行（一般在unix中）  #有起始行就能够仅输入脚本名字来执行脚本，无需直接调用解释器

（2）：模块文档    #简要介绍模块的功能和重要的全局变量的含义，模块外可以通过module.__doc__访问这些内容

（3）：模块导入   #导入当前模块所需要别的所有模块（每个模块仅需导入一次，和Java，c++类似），函数内部的模块导入代码不会被执行，除非该函数正在执行。

（4）：变量定义   #这里的变量定义为全局变量，这个模块中所有的函数都可以使用，但是在局部边变量有相同的名字时，这个局部就会被局部变量遮蔽，一般建议少用全局变量

（5）：类定义   #当模块被导入时class语句会被执行，类也就被定义。类文档变量是class.__doc__

（6）：函数定义   #函数可以通过：类名.函数名；被外部访问到，当模块被导入是def语句会被执行，函数也就都会被定义好。函数文档变量是：函数.__doc__

（7）：主程序  #无论这个模块是被别的模块导入还是作为脚本执行，都会执行这部分代码。这里通常不会有太多功能性代码，而是根据执行的模式调用不同的函数。

     __name__指示模块应该如何被加载：

    a：如果模块是被导入，__name__的值为模块名字;

    b：如果模块是被直接执行，__name__的值为'__main__'；

6：在主程序中书写测试代码；

      在主程序中放置测试代码是测试模块的简单快捷的手段。python标准库中还提供了unittest模块，有时候它称为PyUnit，是一个测试框架。

5：内存管理

     在python中变量无需事先声明，变量也无需指定类型，内存的管理也不需要关心，del 语句能够直接释放资源。

    1：变量的定义。

     C语言变量的声明必须位于代码块最开始，且在任何其他语句之前。C++，Java允许“随时随地”声明变量。python无需显示变量声明语句，变量在第一次被赋值是自动声明。和其他大多数变量一样，变量只有创建和赋值后才能被使用。变量一旦被赋值，你就可以通过变量名来访问它。

     2：动态类型。

     在python语言中，对象的类型和内存占用都是在运行时确定的。尽管代码被编译成字节码，python仍然是一种解释性语言。在创建即赋值时，解释器会根据语法和右侧的操作数来决定新对象的类型。在对象创建后，一个该对象的应用就会被赋值给左侧的变量。

     3：内存分配。

     为变量分配内存时，是在借用系统资源，在用完之后，应该释放借用的系统资源。python的解释器承担了内存管理的复杂任务，简化了程序的编写。

     4：引用计数。

      python中使用引用计数来追踪内存中的对象。一个内部跟踪变量，称为一个引用计数器。每个对象各有多少引用，简称引用计数。当对象被创建时，就创建了引用计数，当这个对象不再需要时，也就说，这个引用计数变为0，非严格的说法它被垃圾回收。

      当创建一个变量并被赋值时，x = 1，对象1有一次引用，y = x，y通过x也指向了对象1，对象1引用了两次。

     引用增加的情况：当对象引用增加时，引用计数会增加。

      a：对象被创建   #  x = 1

      b：另外的别名被创建   # y = x

      c：或被作为参数传递给函数（新的本地引用）  #count(x)

      d：或称为容器对象的一个元素   #myList = [123, x, 'xyz']

      引用减少的情况：当对象的引用被销毁时，引用计数会减小。

      a：一个本地引用离开了其作用范围  #函数count(x)，运行结束

      b：对象的别名被显示销毁   #  del  y

      c：对象从一个窗口对象被移除  #myList.remove(x)

      d：对象串口被销毁   #del  myList

      del语句，del语句会删除一个对象的引用。

6：垃圾回收 

      不再使用的内存会被一种称为垃圾收集的机制释放。解释器负责跟踪对象的引用计数，可是垃圾收集器负责释放内存。垃圾收集器是一块独立的代码，它用来引用计数为0的对象。它也负责检查那些虽然计数大于0但也应该被销毁的对象。（一个循环引用发生在当你至少有两个对象相互引用时，也就是说所有的引用都消失时，这些引用仍然存在，这说明只靠引用计数是不够的）垃圾收集器实际上是一个引用计数器和一个循环垃圾收集器。