(4)Py控制流

内部指令、变量、程序流、模块、异常

Python是模块化设计成的，它由许多即插即用的模块组成。其中基础模块又叫内建模块，
被实现在解释器中。这包括高级数据结构，关键字，和内置命令组成。

程序开始：

#!/usr/bin/python
  -*- coding: UTF-8 -*-

语句和语法

     #     表示python中行注释，相当于C语言中的  //
     \n    表示python换行符号，和unix中的C语言相同
     \     表示python中上一行的继续，不添加换行符，相当于shell中的       ；    表示python中两条指令写到一行，这是一条指令的结束符，分号
     ：    表示python中的代码头与代码体区分，冒号

解释：

      #   可以从一行的任意一个位置开始，之后的会被认为是注释
       \   使用小括号，中括号，花括号,以及三个单引号时，可以不使用"\"换行
       ：  代码组，像if  while  class这些复合语句，冒号证明后面的子命令
       ；  代码链，将多条语句放到同一行，我们使用分号来表示他们属于同一逻辑

源代码结构布局

     # 起始行  UNIX 风格  #/usr/bin/env ptyhon
     # 模块文档，就是一些descripion comments
     # 模块导入，导入其他模块以便使用模块内的函数
     # 变量定义，定义一些全局变量和私有变量
     # 类定义，使用面向对象的编程思想，定义一些类
     # 函数定义，使用面向过程的编程思想，定义一些功能函数
     # 主程序，这里相当与C语言中的main()程序入口

Python原为C语言实现的，所以支持跨平台性。

1） 内置指令：包括标准输入输出I/O、数据类型生成、文件操作

• 标准输入输出——raw_input()/input()/print()
• 数据类型生成——int()/long()/bool()/float()/tuple()/list()/dict()
• 文件操作——open()
• 对象属性操作——help()/dir()/type()/glable()/locals()

2） 高级数据结构：包括python所支持的数据类型

• 数字对象——有符号整数、长整型、布尔型、浮点型、负数
• 字符串对象——str()+索引+切片+连接+重复
• 元组对象——tuple()+索引+切片+连接+重复
• 列表对象——list()+索引+切片+连接+重复
• 字典对象——dict()+索引+切片+连接+重复

3） 关键字：主要是控制程序执行流的结构语句

• 分支结构——if语句
• 循环结构——while语句

一、内置指令

执行python命令后进入解释器，即内嵌模块的运行中；
内嵌模块提供了三种基本指令，它们的执行不需要导入新的模块

使用：type(command) ==》:
表示内嵌模块提供的内嵌指令。查看提供的所有内嵌函数使用:

import sys
print dir(sys.modules[‘builtin‘])

a）打印对象内容 print()，内部实现为：sys.stdout.write()

参数：变量、单引号括起的字符串、或者%d
功能：常用来输出变量的值，输出最后自动添加换行符

例:print( "%s is number is %d" %(var1 , var2))
说明：输出数据与替换变量间不能有逗号隔开，使用‘%‘隔开

注意：1.V2.x版本中属于语句,V3.x版本中属于内嵌函数,函数必须加()

变量与变量之间使用逗号隔开，替换量与变量之间使用%隔开
单引号和双引号都是原样引用的意思，变量不能包括在内
%s 表示字符串， %d 表示整数， %f 表示浮点数，>> 表示重定向

b）格式化变量format()

格式：format(var , [format_geshi])
参数：第二个参数是字符串类型的格式,使用单引号括起

例：print( format (num, ‘4.2f‘))
说明：m.nf ，表示小数的后显示n位，总共显示m位

【n大于实际值，则使用0表示，小于实际值，则四舍五入】
【m大于实际值，则右对齐使用空格表示，小于实际值，左对齐不生效】m > n

c）终端读取raw_input()/input()

ret = raw_input(“str”) => V2版本

功能:输出提示字符串str,读取标准输入,返回字符串类型，赋值给变量

ret = input(“str”) => V3版本

功能:输出提示字符串str,读取标准输入，返回字符串类型，赋值给变量

d）转化为整形int()，类的构造函数初始化整型对象

格式:int(var),返回转换后的变量值,赋值给新变量

e）转化浮点型float()，类的构造函数初始化浮点型对象

格式:float(var),返回转换后的变量值,赋值给新变量

f）转化布尔型bool()，类的构造函数初始化布尔型对象

格式:bool(var),返回ture或者false,赋值给新变量

g）生成元组tuple()，类的构造函数初始化元组对象

格式:tuple(var),返回转换后的变量值,赋值给新变量

h）生成列表list()，类的构造函数初始化列表对象

格式:list(var),返回转换后的变量值,赋值给新变量

i）生成字典dict()，类的构造函数初始化字典对象

格式:dict(var),返回转换后的变量值,赋值给新变量

j）查看对象类型type()

格式:type(var)，返回对象属于的类

k）查看对象内部id号id()

格式:id(var)，返回对象再内存中的ID

l）查看对象信息dir()

格式:dir(var)，返回该对象拥有的属性和提供的方法，比如变量、类和模块

m）打开文件open()

格式:open(path,mode),返回文件句柄

n）获取在线帮助help()

格式:help(raw_input) --- 将输出内建函数的使用方法

o）函数 globals（moudle)

可以返回全局命名空间里的名字

p）函数 locals（）

可以返回局部命名空间里的名字

q）函数 reload（module）

可以重新载入模块

s）函数 range（start, stop，step）

产生一个由开始到结束(stop-1)的列表,首参数及尾参数可以省略，step间隔数据

t）函数 len（obj）

返回对象中字符的个数或者元素的格式,数字不存在该属性

g) globals()和locals()函数 ：

根据调用地方的不同，globals()和locals()函数可被用来返回全局和局部命名空间里的名字。
如果在函数内部调用locals()，返回的是所有能在该函数里访问的命名。
如果在函数内部调用globals()，返回的是所有在该函数里能访问的全局名字。
两个函数的返回类型都是字典。所以名字们能用keys()函数摘取。

i) reload()函数 ： 当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。

因此，如果你想重新执行模块里顶层部分的代码，可以用reload()函数。
该函数会重新导入之前导入过的模块。语法如下：

    reload(module_name) 在这里，module_name要直接放模块的名字，
        而不是一个字符串形式。比如想重载hello模块，如下：
    reload(hello)

二、数据类型

Python里一切都是对象，包括它所支持的数据类型,属于内置高级数据结构。

1）python中数据类型

支持七种类型:数字、字符串、元组、列表、字典、集合、空对象

boolean 布尔类型，true or false
integer 整型类型
long    长整型类型
float   浮点类型
complex 复数类型
string  字符类型

list    列表类型，相当于C语言数组 ，使用中括号定义[]，也使用[]调用
tuple   元组类型，一次性初始化的不可变数组 ，使用小括号定义（），但使用[]调用
dict    字典类型，数据无序性(key=value)键值对，使用大括号定义 { }，仍然使用[]调用
Set     集合类型，数据无重复，无序
None    ‘’空对象，空字符，空列表

注意:单引号和双引号在字符串数据中的使用；
默认，python自带的命令行会把所有的字符串视为语句、函数、或者方法。

因此，所有字符串数据必须使用引号

• 外面使用单引号，内部直接使用双引号 ‘I Love "Itercast"’
• 外部使用双引号，内部需要转义单引号 "I Love \‘Itercast\’"

三个单引号可以达到到多行输入的功能，好比使用shell中“\”

2）Python中的变量

变量值都是由类初始化的对象，对象是通过引用传递的,而不是值；

变量赋值：变量名 = 变量值(使用"="等号进行变量的赋值操作)
变量类型：python中变量值是由类初始化的对象，而变量名只是一种名称连接，

它不占用内存，同时每个对象都有自己的属性和方法，因此对象是没有类型的
我们用C语言理解一下Python中的变量(对象)：

变量值==>程序堆中会分配一块内存，存储对象本身，它的内存地址不会被操作系统标记，但会被程序存储；
变量名==>程序堆中会另分配一块内存，它的内存地址会被操作系统标记，用以寻找此对象，但它将存储对象的内存地址；

变量分类：类变量和实例变量、动态变量和静态变量

1. 类变量 = 定义到函数之外，作用域为整个文件，定义形式为 value = key
2. 实例变量 = 定义到函数之内，作用域只在函数内，定义形式是self.value = key
3. 动态变量 = 动态变量包括(类变量和实例变量)，即动态变量可以被实例对象使用
4. 静态变量 = 静态变量需要使用指定的修饰符，表示该变量只能在类中使用，不能被对象使用

算数操作符 --- +，-，*，/，*，//
比较操作符 --- >，>=，<，<=，==，!=
逻辑操作符 --- and or not
增量操作符 --- +=，-=，=，/=，%=，**=，<
多重操作符 --- 将一个对象的多个引用赋值给多个变量 ：x = y = z = 1
多元操作符 --- x, y, z = 1, 2, ‘a string‘，多个变量赋不同的值

查看对象的类型 : 变量名.__class__
调用对象的方法 ：变量名.方法()
因此，python不需要变量声明，且变量无类型，统一存储为字符串
初始化格式:  变量名 = 变量值，我们认为变量就是对象

三、内置对象方法

对象的支持方法

变量是一种内建对象的引用，即变量名是内存数据对象的指向。

使用内建函数id(var)
==>可以查看对象存储的内存的逻辑地址。更改变量的值，实质是给重新创建了对象。

使用内建函数type(var)
==>可以查看对象的类型，常见的类型有str、int、float、tuple、list、dict等

使用 内建函数 help（func/key）
==>可以查看库函数在线帮助、可以查看类型对象的默认属性和方法，help（int）、help（str）， help（list）

• 元组（tuple）：一种只能被初始化而不能修改的一维数组对象，使用下标访问,元组名[下标号]，使用小括号初始化,使用逗号隔离元素
• 列表（list）：一种既能被初始化又能被修改的一维数组对象，使用下标访问,列表名[下标号]，使用中括号初始化,使用逗号隔离元素
• 字典（dict）：采用键值对的方式存储数据的 key = value 对象，使用下标访问 字典名[键名]，使用大括号和冒号初始化,使用逗号隔离键值对

实际上：字符串类型对象也是一种元组，支持索引和切片的操作方法。

常有操作：

1）索引访问：直接使用对象名和索引序列号来访问对象中的某个元素，对象名[下标序列号] ,此序列号由零开始
2）切片访问：直接使用冒号和索引始终序列号来访问对象中多个元素，对象名[下标起始序列号：下标终点序列号]

字符串操作：help（str）

str_name.upper()

将字符串转换成大写

str_name.lower()

将字符串转换成小写

str_name.count（sub， start，stop）

返回整个字符串中，指定的子串‘sub‘在指定的范围内，出现的次数

str_name.index（sub , start , stop）

返回字符串里，指定的子串‘sub‘在指定的范围内，首次出现时的下标序列号

str_name.find(sub, start, stop)

返回字符串里，指定的子串‘sub‘在指定的范围内，首次出现时的下标序列号

str_name.isalnum()

字符串对象中是否全部为数字或者字符串,返回布尔类型

str_name.ispha()

字符串对象中是否全部为字符串,返回布尔类型

str_name.isdigit()

字符串对象中是否全部为数字,返回布尔类型

str_name.islower()

字符串对象中是否全部为小写字符,返回布尔类型

str_name.isupper()

字符串对象中是否全部为大写字符,返回布尔类型

str_name.istitle()

字符串对象中是否为标题(仅仅首字符大写,其余小写)

str_name.lower()

字符串对象中将所有大写字符转换为小写字符

str_name.upper()

字符串对象中将所有小写字符转换为大写字符

str_name.title()

字符串对象转换为标题(仅仅首字符大写,其余消息)

str_name.isspace()

字符串对象中是否全部为空格字符,返回布尔类型

str_name.join(str)

字符串对象中将参数中每个字符添加到对象头尾

str_name.split(sep)

字符串对象中将以参数作为分割符,返回分割后的列表

元组操作：help（tuple）

tuple_name.count(element)

返回元组里，指定的元素‘elemnt‘出现了多少次

tuple_name.index(element, start, stop)

返回元组里，指定的元素‘element‘在指定的范围内，首次出现时的下标序列号

列表操作：help（list）

list_name.append(element)

追加一个新的元素到列表末尾

list_name.insert(index, object)

插入一个新的元素object 到列表的指定的 index 位置上

list_name.extent(list/tuple/dict)

扩展原来的列表，在尾部添加一个新的对象，组成新的列表

list_name.remove(element)

删除指定的元素‘element‘在列表中首次出现的元素

list_name.pop(index)

返回列表中指定索引index 的元素,并且在列表中删除它,默认从最后一位开始

list_name.count(element)

返回整个列表里，指定的元素‘element‘出现了多少次

list_name.index(element, start, stop)

返回列表里，指定的元素‘element‘在指定的范围内,首次出现时的下标序列号

字典操作：help（dict）

dict_name.clean()

清空一个字典的所有内容

dict_name.copy()

复制一个字典的所有内容并返回，可以使用变量存储下来

dict_name.keys()

列出一个字典的所有键名内容，不会列出键值数据

dict_name.values()

列出一个字典的所有键值数据，不会列出键名内容

dict_name.items()

列出一个字典的键名与键值的对应关系

dict_name.get(key1 , value2)

列出字典中，键名为key1的值，如果没有则将该键名的键值设为value2

dict_name.pop(key1, value2)

列出字典中，键名为key1的值，如果没有则返回内容为value2

其他说明：解释器中的下划线"_" 表示最后一个执行命令的表达式

"/" 表示传统的除法
"//" 表示浮点的除法
"**" 表示乘方

四、程序流程

变量名:第一个字符必须是字母或者下划线_，其余字符必须是数字、字母、下划线， 大小写敏感
标识符:理论上只要满足以上变量名定义规则,用户可自行设计程序中的变量名称,
但是python系统中仍然保留了关键词和函数方法的名称,
关键词作用:控制程序的执行流程,以及程序特殊的操作，为此我们建议尽量不要使用这些关键词作为变量名称。

常见的关键字包括:

     def    import     class     expect
     ----------------------------------------------
     and      or        not        exec
     ----------------------------------------------
     if      elif      else     while       break      contine
     -------------------------------------------------------------
     is      in        print       pass       with
     -------------------------------------------------------------  
     pass    raise     return      from       globle
     -------------------------------------------------------------

“人生道路虽然漫长，但紧要处常常只需要几步，特别是当人年轻的时候”--路遥
Python程序保持了C语言中的顺序、循环执行流

1)逻辑分支

/当判定条件为ture时，执行指令/

   if  条件判断语句：(不要忘记冒号)
       ......(4位缩进)
   elif  条件判断语句：(不要忘记冒号)
       ......(4位缩进)
   else：(不要忘记冒号)
       ......(4位缩进)

注意：python中不存在switch语句，同样没有三目运算符(food?eat=1:eat=0)

2)循环分支其一

/重复执行特定的语句/

   for  变量1,变量2  in  [列表]：(不要忘记冒号)
        ...... (4位缩进)

例如:

   for  i  in  range(1, 10, 2)
        print  i  -->  1, 3,  5,  7,  9  

3)循环分支其二

/当判断条件为true时，循环执行代码块/

   while (判断条件) :  (不要忘记冒号)
        ......(4位缩进)

例如:

   while raw_input("Enter name:") != ‘admin‘:
       print (‘sorry,name error...‘)
       continue

   while raw_input("Enter pwd:") != ‘123456‘:
       print (‘sorry,passwd error...‘)
       continue

   print (‘Congratulation, welcome...‘)
   exit()

注意:子指令 continue 、 break解读

continue == 直接进入下一次循环
break == 退出整个循环

迭代器 range(var) #生成list对象
iterator = iter(obj) #生成迭代器

五、函数(方法)定义

函数的定义和调用
函数（方法）通过组合特定的代码，实现可重复执行的特定功能，
它通过参数接收数据，通过return返回结果

def 函数名(形参列表):
......(4位缩进) //可以用来注释代码段

对象名.方法名(实参列表) //通过对象调用方法

注意：

1)函数参数可以传递默认值,使用key=val的形式；
2)传递变长参数时，会被自动转换成以参数名命名的元组或字典，必须传递无默认值的参数赋值
3)函数返回多个对象时，总是以元组的形式返回。

元组

   def function(*var_name)：(不要忘记冒号)
       func_name(value1,value2)

字典

   def function(**var_name)
       func_name(key1=value1, key2=value2)

函数的返回值

return obj; //返回对象
return ; //返回None空对象，没有return则返回None空对象

注意：类变量和实例变量都是会定义内存的，但是类变量的改变会影响到全局；

因为return返回了整个对象，覆盖原对象

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。

调用函数时，所有在函数内声明的变量名称都将被加入到作用域中

1、定义在函数之外的属于全局变量，而在函数之内的使用，需要global声明，表示当前调用全局变量
2、函数内外可以定义相同名称的变量，但一个是全局的，一个是局部的。

因此，第一次调用函数时开销比较大．但是其后的每次调用都只会花费一条指令和一个间接的存储器引用

六、模块的使用

模块：以文件形式存储，一个文件就是一个模块，可以用import导入调用

1）模块：是包含执行代码、函数、类和变量的独立python文件

   import mod                         //不包括文件扩展名，调用通过"模块名.方法名"
        mod.function();               
   from mod import function
        function();                    //直接调用"方法名"

注意：from 后面可以跟目录名字，然后导入目录中的模块名（文件名）

常用系统模块

     import sys.path   //基础模块,又称伪系统模块
     import os import * //linux系统调用能力的体现点
     import socket, threading //网络模块和线程模块
     import time, random     //时间模块和随机模块
     import string, re       //字符串模块和正则模块

常用私有模块

 >#/home/itercast/modules/m.py
 path = ‘/home/itercast/modules/‘

使用私有模块

 >sys.path.append(path) //把私有模块路径添加进来
 form m import plus2  //导入私有模块==> import指令在sys.path中查找模块

 直接执行 plus2

七、错误和异常

异常处理方式：

     try:
          #正常的代码逻辑:
          code_break
     except ValumeError as e:                   //第一次调用捕获具体异常
          #如果上面的代码执行错误，则执行本块
          ....
     except Exception as e:                     //第二次调用抓所有异常
          #如果上面的代码执行错误，则执行本块
          ....
    else：
         #如果code_break没有出错，则继续执行这里的代码
    Finally:
         #最后执行，不管上面的代码有没有出错

Exception是捕获异常的总类，e是该类的对象；

常见的Python错误包括：

ValumeError、IndexError、FileNotFoundError、IOError、TypeError等，这些值替代Exception字符串

即：ValumeError、IndexError、FileNotFoundError、IOError、TypeError是Exception的子类

如何主动的抛出异常：

raise Exception("error ocured!")

断言： assert 条件 （如果条件成立，继续执行代码，如果代码异常，直接报错

(4)Py控制流

原文：https://blog.51cto.com/rulix9527/2848304