python之编程风格

第一：语句和语法

• #   表示注释掉的内容
• \    续行

print("yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy\
yyyyyyyyyyyyyyyyyyyyyyy")

• ;    分号：同一行放置多个语句以分号作为分割符

print('cyy');print('zzl')

输出结果：
cyy
zzl

• 语句（代码块）用缩进方式体现不同的代码级别，建议用4个空格（不要用tab）
• python文件以模块的方式组织，编写一个.py结尾的文件实际上就是写了一个模块，模块的名称也是脚本的名称
• 首行以关键字开始，如if、while 等，以冒号结束
• Python使用缩进来分隔代码组，同一代码组的代码行必须严格左对齐，否则会造成语法错误
• 模块里的代码可以是一段直接执行的脚本，也可以是一些类似库函数的代码从而可由别的模块执行导入(import) 因为模块在被import的那一刻就会执行;所以模块中一般存放的都是一些可调用的代码段;

第二：标识符

标识符是计算机语言中允许作为名字的有效字符串集合

• 变量名只能是 字母、数字或下划线的任意组合
• 变量名的第一个字符不能是数字（是字母或下划线(_)）
• 大小写敏感
• 两种风格：conn_obj或ConnObj
• 不能使用关键字，不能使用内建

第三：专用下划线的标识符

• _xxx:不能用from module import *导入
• __xxx__:系统定义名字
• __xxx:类中私有变量

下划线对于解释器来说有特殊意义，而且是内建标识符所使用符号，不建议自定义变量以下划线开头

第四：变量的定义与赋值

变量定义方法很简单：

x=5
print(x,type(5))
print(x*5,type(x*5))

结果：
5 <class 'int'>
25 <class 'int'>

• 这个操作过程就是赋值，意思把整型数字5赋值给了变量x，用等号来连接变量名和值。之后就可以在表达式中使用这个新变量了。
• 5为内存变量存放于内存中，x为变量的引用，python为动态语言，变量及其类型均无需事先声明类型
• 与c的区别：a＝1无返回值

注意：在赋值时，值是什么数据类型，就决定了这个变量的类型，变量名引用了数值的同时也引用了它的类型。

变量命名规范

1、变量名可以包括字母、数字、下划线，但是数字不能做为开头。例如：name1是合法变量名，而1name就不可以。
2、系统关键字不能做变量名使用
3、除了下划线之个，其它符号不能做为变量名使用
4、Python的变量名是除分大小写的，例如：name和Name就是两个变量名，而非相同变量哦。

第五：python对象

python中使用对象模型来存储数据，用来生成数据类型的工厂函数本质上是类，新建数据的结果本质是实例化一个对象

对象有三种特性

• 身份：内存地址，可以用id()确认，id相同的就是同一个对象
• 类型：可以用type()查看，返回值的type也是对象
• 值

第六：python内存管理

内存管理：

变量无序指定类型

程序员无须关心内存管理

变量会自动回收

del能够直接释放内存对象（减少对象的引用计数）

解释：mem删除的则是引用，并不是100占用的这块内存地址，也不是100，删除引用以后，内存地址会自动回收

引用计数：

增加引用计数:

• 对象被创建并将其引用赋值给变量，引用计数加1（例a＝1）
• 同一个对象的引用又赋值给其它变量，引用计数加1（例b＝a）
• 对象作为参数被函数调用，引用计数加1（例int(a)
• 对象成为容器对象中的一个元素，引用计数加1（例list_test=['zzl','z',a]）

减少引用计数：

• a作为被函数调用的参数，在函数运行结束后，包括a在内的所有局部变量均会被销毁，引用计数减1
• 变量被赋值给另外一个对象，原对象引用计数减1（例b＝2，1这一内存对象的引用只剩a）
• 使用del删除对象的引用，引用计数减1（例del a）
• a作为容器list_test中的一个元素，被清除,引用计数减少（例list_test.remove(a)）
• 容器本身被销毁（例del list_test）

示例示图说明：

增加引用计数：
    name = ‘zzl’  ＃创建内存变量zzl，将变量zzl的引用传给name，此刻zzl的引用计数为1
    name1 = name  #name有赋值给name1，现在zzl的引用计数增加到2
    def foo(name):   #作为函数调用的时候，引用计数加1
        pass

减少引用计数
    name1＝‘cyy’ ＃创建新的内存变量cyy，将变量cyy的引用传给name1，原本指向zzl的name1，此刻给了2，所以1的引用计数减少了1

    del name ＃删除了内存对象zzl的引用name，此刻zzl再无引用，此刻它就成了python解释器回收的目标

　

用数据类型的可变/不可变与内存地址相互关联起来理解：

定义：基于一个内存地址的修改，是可变类型

数字：

数字更改元素，内存地址发生变化，所以数字是不可变的数据类型

字符串：

字符串更改元素，内存地址发生变化，所以字符串是不可变的数据类型

列表：

列表元素发生改变，内存地址不变，所以列表是可变类型

元组：

元祖本身就不能修改，所以元组是不可变的数据类型

字典：

字典元素发生改变，内存地址不变，所以字典是可变类型

补充知识：

一上两种情况，实际上应该开辟两块内存空间，为什么内存空间地址相同？

因为：如果变量占用的内存地址的长度比较短，所有python解释器会缓存起来

下面写一个长的内存地址进行对比：

第七: 编写模块基本风格

• 标题

  •  #_*_coding:utf-8_*_
     #!/usr/bin/env python

• 文档注释
  • 既不能缺少注释，也要避免过度注释
• 模块导入
  • import os
• 变量定义
  • name=‘cy’
• 类定义语句
  • class
• 函数定义语句
  • def
• 主程序
  • 无论当前模块是被别的模块导入还是作为脚本直接执行，都会执行这部分代码
  • if __name__ == '__main__'
• 测试代码
  • test()

eg:

#!/usr/bin/python # (1)起始行
#coding=utf-8                    #mod.__doc__ 引用类的文档
#"this is test module" (2)模块文档(文档字符串)
import sys #(3)模块导入
import os

debug = true
name = "Tom" #(4)全局变量

class FooClass(object): #(5)类定义(若有)
    "Foo class"
    pass

def test():
　　"test function"
　　foo = FooClass() #将类实例化
　　if debug:
　　　　print 'ran test()'

def main(name): #(6)函数定义(若有)
      '''
     test func
     :return:
      '''
    pass

if __name__ == '__main__'#(7)主程序
test()
main()