语句和语法

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

1 print("yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy2 yyyyyyyyyyyyyyyyyyyyyyy")

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

1 print(‘cyy‘);print(‘zzl‘)
2  
3 输出结果：
4 cyy
5 zzl

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

标识符

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

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

专用下划线的标识符

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

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

变量的定义与赋值

变量定义方法很简单：

1 x=5
2 print(x,type(5))
3 print(x*5,type(x*5))
4  
5 结果：
6 5 <class ‘int‘>
7 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）

示例说明：

 1 增加引用计数：
 2     name = ‘yyp’  ＃创建内存变量yyp，将变量yyp的引用传给name，此刻yyp的引用计数为1
 3     name1 = name  #name有赋值给name1，现在yyp的引用计数增加到2
 4     def foo(name):   #作为函数调用的时候，引用计数加1
 5         pass
 6  
 7 减少引用计数 
 8     name1＝‘sy’ ＃创建新的内存变量sy，将变量sy的引用传给name1，原本指向yyp的name1，此刻给了2，所以1的引用计数减少了1
 9  
10     del name ＃删除了内存对象yyp的引用name，此刻yyp再无引用，此刻它就成了python解释器回收的目标

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

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

数字：

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

字符串：

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

列表：

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

元组：

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

字典：

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

补充知识：

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

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

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

编写模块基本风格

• 标题

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

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

eg:

 1 #!/usr/bin/python # (1)起始行
 2 #coding=utf-8                    #mod.__doc__ 引用类的文档
 3 #"this is test module" (2)模块文档(文档字符串)
 4 import sys #(3)模块导入
 5 import os
 6  
 7 debug = true
 8 name = "Tom" #(4)全局变量
 9  
10 class FooClass(object): #(5)类定义(若有)
11     "Foo class"
12     pass
13  
14 def test():
15 　　"test function"
16 　　foo = FooClass() #将类实例化 
17 　　if debug:
18 　　　　print ‘ran test()‘
19  
20 def main(name): #(6)函数定义(若有)
21       ‘‘‘
22      test func
23      :return:
24       ‘‘‘
25     pass
26  
27  
28  
29 if __name__ == ‘__main__‘#(7)主程序
30 test()
31 main()

View Code

Python学习之路3?编程风格