Python学习基础笔记

1.numeric(10,2)长度为10，小数位为2的浮点数

2.bit字型，0或者1

1.编辑器：可以用自己带的编辑器python shell，也可以用网上的subline或者notepad++,不可以用带格式的文本（比如记事本或者word等带文本格式的编辑器）,在文本编辑的过程中，单引号双引号使用保持一致

 

2.Python是一种解释型,编译性、互动性、面向对象、动态数据类型的高级程序设计语言。

    使用缩进来写模块，不是用大括号{}来控制类，函数以及其他的逻辑判断

#coding=utf-8 默认编码是utf-8,所有的字符串都是unicode字符串，等号的两边不能有空格

#作者

#日期

 

3.keyword

print ('hello world');print('hello');

python>>>import keyword>>>keywordkwlist   ['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']

python中如果同一语句太长，换行通过在行位加反斜杠连接(\)，如果是在括号（）{}[]内的语句则不需要使用反斜杠

 

4.python中的数据类型：

number（数字）string（字符串）list(列表)tuple(元组)sets(集合)dictionary(字典)

    夫说可以用a+bj,或者complex(a,b)表示

python 中数的数据类型：整型int(1)、浮点数float(1.23,3E-2)和complex复数(2+3j)布尔值（bool）

可以用del语句删除一些对象引用。

del语法：del var1[,var2[,var3,[....,varN]]]

               eg: del var;del var_a,var_b

 

5.字符串

str = 'Runoob'

print 语句中可以使用运算符 eg:print(a+b)

Print type(变量)输出的是变量类型

print (str)          # 输出字符串

print (str[0:-1])   # 输出第一个个到最后一个的所有字符

print (str[0])      # 输出字符串第一个字符

print (str[2:5])    # 输出从第三个开始到第五个的字符

print (str[2:])     # 输出从第三个开始的后的所有字符

print (str * 2)     # 输出字符串两次

print (str +"TEST") # 连接字符串

print'''

line1

line2

line3            #打印多行字符串使用三个引号，等同于print'line1\nline2\nline3\n'

 

6.pycharm设置编码(注册之后更新，可以与svn同步更新，subversion.)：

        第一步：file>Settings,输入框搜索encoding

        第二步：Editor>File encoding

        第三步：将IDE Encoding 和 Project Encoding 设置为utf-8,

 

7.python变量命名： 使用下划线，字母或者数字组成标识符，但是不能以数字开头，以下划线开头的有特殊意义，缩进和空格要严格一致不然报错，标识符对大小写敏感，如果是多个字符，使用_作为连接

#  单行注释

'''多行注释,三个单引号'''

字符串十一单引号或者双引号括起来的任意文本，转义字符在引号中也编译，如果不想让反斜杠发生转义，可以在字符前面添加一个r，表示原始字符，python字符串不能被改变，向索引位置赋值， 会导致错误

>>> print('Ru\noob')

Ru

oob

>>> print r'Ru\noob'

Ru\noob

>>> 

python允许处理unicode字符串，加前缀u或者U表示这个字符串是不可变的，同一行多条语句用';'隔开

 

8.python的运算符

布尔值，布尔值和布尔函数的表示完全一致，一个布尔值只有True和False，注意首字母大写；布尔值可以用and,or和not运算，布尔值常用于条件判断中，控制，用    None表示

变量，用来存储数据的最小单位，脚本过程中其值是可变的，常量就是不能变得变量，常量通常全用大写书写，变量不需要生命，每个变量使用前都必须赋值，变量赋值以后该变量才会创建

python允许给多个变量同时赋值 a=c=b=1    ;多个对象指定多个变量啊a,b,c =1,2,'runoob'

算数运算符：取模% 取余数部分 ； 取整除 // ; 取整数部分 ； 幂 **  ;同意类型的数值运算之后类型不变；

比较运算符（返回true或者false）：==相等 ;  != 不等于 ； <>不等于        在计算机如果返回1则表示真，返回0则表示假

if ( a == b ):

   print "1 - a 等于 b"

else:

   print "1 - a 不等于 b"

赋值运算符： = ； += ； -= ； *= ； /= ; 幂值运算符**=; 

逻辑运算符：and     x and y布尔‘与’如果x为False，x and y返回False,否则它返回y的计算值

                    or     x or y 布尔‘或’如果x为假则返回x的值，苟泽返回y的计算值。

                   not     not x 布尔    布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

 

9.python编码规范;

不适用分号，每行不超过80字符，如果一个文本字符串在一行放不下, 可以使用圆括号来实现隐式行连接:情况除外：1）. 长的导入模块语句 2）.注释里的URL

eg：x= ('这是一个非常长非常长非常长非常长

     非常长非常长非常长非常长非常长非常长的字符串')

使用4个空格来缩进代码，绝对不要用tab或者，使用tab和空格混用

对齐方式：：与起始变量对齐，字典中与起始值对齐，4个空格缩进第一行不需要，字典中四个空格缩进

空行： 顶级定义之间空两行（比如函数定义或者类定义），方法定义之间空一行（方法定义或者类定义和第一个方法之间），空行是程序代码的一部分，如果没有空行，也不会报错

空格：不要在逗号分号，冒号前面加空格，但是应该在他们的后面加空格，行尾不用加；括号内不能有空格；

            参数列表，索引或者前篇的做括号前不加空格（Yes: spam(1)，Yes: dict['key'] = list[index]）；

            在二元操作符两边都加上一个空格, 比如赋值(=), 比较(==, <, >, !=, <>, <=,>=, in, not in, is, is not), 布尔(and, or, not).

            当'='用于指示关键字参数或默认参数值时, 不要在其两侧使用空格.

 

10.类：如果一个类不继承自其的自类，就显示额是从object集成，嵌套类也是一样

classOuterClass(object):classInnerClass(object):pass

 

11.字符串：

     x = a + b

 x ='%s, %s!'%(imperative, expletive) x ='{}, {}!'.format(imperative, expletive) x ='name: %s;score: %d'%(name, n) x ='name: {};score: {}'.format(name, n)

 要是有两个一定要用括号，分开是输出不了的

为了避免使用过程中的空间使用浪费，使用子串加入列表，再循环后使用.join

 

 items =['

']for last_name, first_name in employee_list: items.append(''%(last_name, first_name)) items.append('

%s,%s

') employee_table =''.join(items)

print var1.lower()  # 变成小写

print var1.upper()  # 大写

print var1.capitalize()  # 首字母大写，其余小写

print var1.find('hello')        # 返回字符第一次出现的索引值

print var1.count('h')           # 返回字符串中字符'h'的数量

print (var1[5:7])          # 给定字符串的切片

var1.lstrip()# 截掉字符串左边的空格

var1.isspance() #字符串全是空格则返回真，否则假

 var1.expandtabs(tabsize=8) #tab转换成空格

 

Python的汉字占用3个字符，用于切片

 

12.文件和sockets

    使用with语句管理文件：

        with open('hello.txt') ashello_file:

            for line inhello_file:

                   print line

    不支持使用'with'语句的类似文件的对象，使用contextlib.closing():

    import comtextlib

    withcontextlib.closing(urllib.urlopen('http://www.python.org/'))as front_page:

            for line infont_page:

               print line

ToDo注释： #ToDo(dubinglin) Change this to use relations.

 

13.导入格式：每个导入应该独占一行

    import os

    import sys00

导入应该按照从最通用到最不让通用的顺序分组：

1.标准库导入    2.第三方库导入    3.应用程序导入

每个模块的完整包路径按照字典序排序，忽略大小写

 

14.访问控制:

 在python中一些琐碎和不太重要的访问函数，你应该直接使用共有变量来取代他们，这样可以避免额外的函数调用开销，当添加更多功能的时候，你可以用属性（property）来保持语法的一致性。

 

15.命名：

应该避免的名称：

1).单字符名称, 除了计数器和迭代器.

   2).包/模块名中的连字符(-)

   3).双下划线开头并结尾的名称(Python保留, 例如__init__)

命名约定：

1).所谓"内部(Internal)"表示仅模块内可用, 或者, 在类内是保护或私有的.

  2).用单下划线(_)开头表示模块变量或函数是protected的(使用import* from时不会包含).

  3).用双下划线(__)开头的实例变量或方法表示类内私有. 

  4).将相关的类和顶级函数放在同一个模块里. 不像Java, 没必要限制一个类一个模块. 

  5).对类名使用大写字母开头的单词(如CapWords,即Pascal风格), 但是模块名应该用小写加下划线的方式(如lower_with_under.py).尽管已经有很多现存的模块使用类似于CapWords.py这样的命名, 但现在已经不鼓励这样做, 因为如果模块名碰巧和类名一致, 这会让人困扰.

 

16.main:Main 

即使是一个打算被用作脚本的文件, 也应该是可导入的. 并且简单的导入不应该导致这个脚本的主功能(main functionality)被执行, 这是一种副作用. 主功能应该放在一个main()函数中.

在Python中, pydoc以及单元测试要求模块必须是可导入的. 你的代码应该在执行主程序前总是检查

if __name__ == '__main__' , 这样当模块被导入时主程序就不会被执行.

def main():

      ...

if __name__ == '__main__':

    main()

所有的顶级代码在模块导入时都会被执行. 要小心不要去调用函数, 创建对象, 或者执行那些不应该在使用pydoc时执行的操作.

 

17.list:是使用最频繁的数据类型，支持数字，字符串和嵌套列表，索引值从0未开始值，-1为从末尾的开始位置。使用变量给列表赋值，列表保持赋值时候的变量数值

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]       一定要加中括号，不加括号或者加上小括号不然变成元组tuple了

tinylist = [123, 'runoob']

print (list)           # 输出完整列表

print (list[0])         # 输出列表第一个元素

print (list[1:3])       # 从第二个开始输出到第三个元素

print (list[2:])        # 输出从第三个元素开始的所有元素

print (tinylist * 2)    # 输出两次列表

print (list + tinylist) # 连接列表，只能列表列表之间才能连接，不能列表与元素一起连接

print (list1 + list2)

print '元素1是否在列表list中：%s'% (1 in list1)

%s表示用字符串替换 ，%d 表示用整数替换，%f  表示用浮点数替换

列表元素的添加：

  在列表的尾部追加元素：.append()       list1.append('小明')添加'小明'元素

 删除列表中的元素：.remove()           list1.remove('小明')删除第一个重复的'小明'元素

删除列表的指定元素，移除列表中的一个元素，默认是最后一个元素,并且返回这个值的元素，索引值

：list.pop(obj=list[-1])    list1.pop()       print list1.pop(0) 永久改变

删除列表 dellist1()               删除列表1

在指定位置中插入元素：.insert(位置,元素)    list1.insert(2,'小明')插在第三个位置，单独语句，不能再print中写入list2.insert(i,i+ 1)  这是插入，如果只是修改列表，使用赋值

 list1['索引值'] = values 

连接两个字符串：.extend（）           list1.extend(list2)将另一个表插在一个表的末尾，后面的可以直接写成

列表长度    len(list)           len(list1)读取元素的长度 ，可以用可变参数求参数个数

最大值max()最小值min()

每n个中取一个list1[开始值:结束值:间隔值]           print list1[::n] 会从第一个索引值开始提取，不包含结束值，如果取到最后则可以第二个值空着，第三个值不为0，

元组转换成列表：list1=list(tuple1)

返回不是边界的整数range()函数，range(2,5)       #返回从2到5之间的不包含右边界的整数，生成一个数列（列表），

                       list1 = rang(1,101)

包括左边界不包括右边界

对原列表进行排序list.sort([func])                       #,,,,,,,,,,,正序排列,,,,,,,,,,,

比较两个列表的元素    cmp(list1,list2)               # ASC2码 如果第一个较大返回 1，相等返回 0 ，第二个较大返回-1

反向列表中的元素list.reverse()                          #,,,,,,,,倒序排列,,,,,,,,,,

获取端口输入的数据： 

  input('能够输出端口的文字')返回的是数值：int或者float，input会计算数值中的数字表达式  

  raw_input('要输出在端口的文字')返回的是字符串类型，string类型

  从列表中找出某个值第一个匹配项的索引位置：list.index(obj)

字符串中额元素是可以修改的,添加中文后会变成16进制代码

>>> a[2:5] = [13, 14, 15]

>>> a[2:5] = []   # 删除

 

18.tuple元组：与列表类似，不同之处在于元组的元素不能修改，元组中的元素可以进行调用但是不能计算

 

19.特殊字符： 

1）输出中既有单引号又有双引号： print ('bob said \"I\' am ok\"')    使用反斜杠来控输出的单引号双引号

2）打印单引号”’’”用双引号括起来，如果打印双引号则用单引号括起来，打印换行符’\n’ 打印tab‘\t’ 打印反斜杠 ‘\\’，输出%只用在里面打两个%%，

 

20.语句输出，

使用语句的时候循环变量一定要放到语句的外面定义，不然每定义一遍就赋初始值一遍

if...else...语句：

因为Python不支持switch语句所以多个条件判断的时候只能用elif来实现

   if 条件1：

               结果1

   elif 条件2：

               结果2

   else:

       结果3

if (dep == '数学系' and banji = 2) or (dep == '计算机系' and banji= ‘3’):

    print('请在下周五去12教学习Python')

else:

    print('不用去学习')

遍历，迭代for语句： 

for x in [1,2,3]:

      print x            输出结果为1,2,3

for j in list1:
    i += 1 print j/i

while语句（Python中没有do，while语句，提供while循环和for的循环，可以在while循环中嵌套for循环）

while x

        print x

        x += 1

如果不是真的话就跳出循环

        当有两个while循环的时候，定义内循环变量的时候一定要注意，变量放在外循环中，不然只能循环一次，下例99乘法表中的如果放在外面只能输出一列，

j = 9 while j > 0:  i = 1            #一定要放在内循环中 while i < 10: print (10-j),'x',i,'=',(10-j)*i
          i += 1 j -= 1

 

break语句： 跳出if条件所在的那个循环循环。if 条件：break语句中。一定要注意if中的语句不是能死循环，break后面的语句和循环直接跳出，不执行

i = 0 while i < 20:
    sum = 0 sum += 2**i
    i +=1 if i > 19: print sum break

 

continue就跳出当前循环，continue后面的语句不执行，但是循环仍然进行

 

21．Dictionary

是除列表意外，Python之中最灵活的内置数据结构，列表是有序对象结合。字典是无序的对象集合

两者之间的区别在于，字典当中的元素是通过键来存取的而不是通过偏移存取，用{}标识，由key（是不可变的，元组可以，但是列表不可以，列表是可变的）和value组成

pass循环控制语句： pass是空语句，是为了保持程序结构的完整性

dict = {}

dict['one'] =    ，；

听见没感情5  "This is one"
                #赋值

dict[2]= "This is two"                   # 赋值使用，中括号

tinydict = {'name':'john','code':6734, 'dept': 'sales'}

print dict['one']             # 输出键为'one' 的值       This is one

print dict[2]                     # 输出键为 2 的值     This is two

print tinydict                     # 输出完整的字典

print tinydict.keys()             # 输出所有键

print tinydict.values()             # 输出所有值

deldict['name']  #删除自字典中'name'的条目

dict.clear()#清空字典所有条目

dict1.fromkeys(sep.val) #以序列sep中的元素做字典的键，val为字典所有键对应的初始值

del dict  #删除字典

cmp(dict1,dict2)  #比较两个字典中的元素

len(dict)  #计算字典元素个数，即键的总数

str(dict)  #输出字典可打印的字符串表示

print type(dict)                        #返回数据类型

radiansdict.get(key,default=none) #返回指定键的值，如果值不在字典中返回default值

radiansdict.setdefault(key,default=none) #如果不存在于字典中，则会自动添加键并将值设为default

radiansdict.has_key() #如果键在字典dict里返回true,否则返回false

radiansdict.items() #以列表返回字典中的值

radiansdict.keys() #以列表返回字典中所有的键

radiansdict.values() #返回字典中所有的值

radiansdict.update(dict2) #把字典dict2中的键和值更新到dict中去

radiansdict.pop(key) #删除字典中的元素 dict1 = {9:4, 5:8, 7:6} dict1.pop(9)    可以删除键为9的条目       字典中不能使用remove            AttributeError: 'dict' object hasno attribute 'remove'

for i in tinydict:这个后面一定不能有()  或者      for key in tingdict():   或者for in tinydict.keys()               # 打印出key。

for value ind.values():                    #打印出value值

for value,key intingdict.items():                #打印出key和value值,items不能少，不然会报错key和value不加

for value in dict1.values(): print 'value', value                        #固定写法，是用value,输出value的值，固定变量

从界面获取  字符串获取raw_input('要说的话')        或者 整形获取input('要说的话')

D.clear()                             #移除D中的所有项 

D.copy()                              #返回D的副本 

D.fromkeys(seq[,val])                 #返回从seq中获得的键和被设置为val的值的字典。可做类方法调用 

D.get(key[,default])                  #如果D[key]存在，将其返回；否则返回给定的默认值None 

D.has_key(key)                        #检查D是否有给定键key 

D.items()                             #返回表示D项的(键，值)对列表 

D.iteritems()                         #从D.items()返回的(键，值)对中返回一个可迭代的对象 

D.iterkeys()                          #从D的键中返回一个可迭代对象 

D.itervalues()                        #从D的值中返回一个可迭代对象 

D.keys()                              #返回D键的列表 

D.pop(key[,d])                        #移除并且返回对应给定键key或给定的默认值D的值 

D.popitem()                           #从D中移除任意一项，并将其作为(键，值)对返回 

D.setdefault(key[,default])           #如果D[key]存在则将其返回；否则返回默认值None 

D.update(other)                       #将other中的每一项加入到D中。 

D.values()                            #返回D中值的列表 

 

defaddWord(theIndex,word,pagenumber):

  theIndex.setdefault(word,[ ]).append(pagenumber)#存在就在基础上加入列表，不存在就新建个字典key  

d= {"hello":[3]}

#d= {}

addWord(d,"hello",3)

addWord(d,"hello",56)

addWord(d,"nihao",24)

printd

 

程序运行结果如下：

1	{'nihao': [24], 'hello': [3, 3, 56]}

 

 

import random # 引用所需的类库

a = random.random()         #   生成一个0-1的随机浮点数0.415748914

a = random.uniform(a,b)        #   生成一个指定范围内的随机浮点数

a = random.randint(a,B)        #    生成一个指定范围内的整数

 

21，函数：使用def定义函数，定义函数的时候涉及到出书

def def1(i, j): print i, '+', j, '=', i+j
def1(1, 2)

也可以定义没有参数的函数：

def def1()：

    print '这是一个没有参数的函数'

    调用的的时候直接写def1，默认参数只能定义在必须参数的前面

有关参数的报错：参数个数不对，参数类型不对

默认参数：简化调用，你只需把必须参数传进去就行；但是需要的时候你又可以传入额外的参数来覆盖默认参数，默认参数要放在不是默认参数的后面

形参：函数定义的时候的参数

实参 : 函数调用的时候传的两个参数

可变参数：可变参数的名字前面有个*号，我们可以传入0个，1个或者多个参数给可变参数，可变参数可以看成一个元组，可以进行遍历调用，可变参数只能将参数放在函数小括号里面，虽然运行过程相当于元组，但是不能直接把元组或者列表传给虚参，可以用len()函数计算元素的个数，也可以传字符串等

def average(*a): if len(a) == 0:  print aelse:  return sum(a)/len(a) print average(1, 2, 3, 9)

return语句：

       函数缺少相等的return语句，这种情况下返回值就是None,再有返回值的函数中，一定要保证每个可能的流程都对应着return语句，return语句可以返回一个或者多个值，也是以元组的形式传回

 

22.常用例子

冒泡排序法：

    重复走访要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们调换，走访数列的工作是重复进行指导没有再需要交换，也就是说这个数列已经排序排序完成

特殊语句：

 冒泡排序法交换序列：1=1+2；2=1-2；1=1-2；

 注意：两层循环，内层循环条件每次减一，如果使用函数的话，注意让函数return，else可以使用pass让程序完整。不能使用变量代换进行调换，虽然可以把列表的值赋值给变量，但是不能用

 x被i整除：x%i == 0 或者not(x%i)     不被整除则只用表达式就可以x%i

 99乘法表：while语句，控制列输出10-j;    控制行输出i；或者用for语句inrange(1,10)

  注意的是，如果在一个循环中输出末尾加“,”，那么所有的输出都会在同一行

 素数：只能被1和本身整除

i = 2 while i<100:
    j = 2 while j<=(i/j): if not(i%j):break j += 1 if j >(i/j): print ii += 1

使用递归函数的优点是逻辑简单清晰，缺点是过深的调用会导致栈溢出。

针对尾递归优化的语言可以通过尾递归防止栈溢出。尾递归事实上和循环是等价的，没有循环语句的编程语言Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。

 

23高级特性

   切片  L[0:3] 表示从索引0开始取，只到索引3为止，但不包括索引3，即索引0，1，2，正好3个元素；支持倒数，倒数第一个元素的索引是-1

L[:10:2]表示从索引0开始取，直到索引9为止，每两个取一个

 L[::5]表示所有的数，每五个取一个。

 除了list可以做切片，tuple和字符串也可以用切片操作。对于字符串就相当于截取函数

①pythonpath变量

    set PYTHONPATH=c:\pathon27\lib;

    set PYTHONPATH=/usr/local/lib/python

②dir()函数，模块中包含的函数

    import math

    print dir(math)

③reload()函数，重启模块

④__int__.py（python自我保留）

·        Phone目录下Isdn_1.py 含有函数Isdn()

·        Phone目录下G3_1.py 含有函数G3()

·        Phone目录下的pots_1.py含有Pots()文件

 可以在__int__.py文件夹下，使用显式的导入语句，然后在其他文件中导入phone包的时候就可以使用上述三类例子函数

from Pots_1 import Potsfrom Isdn_1 import Isdnfrom G3_1 import G3

#!/usr/bin/python # -*- coding: UTF-8 -*-  # 导入 Phone 包 import Phone   Phone.Pots() Phone.Isdn() Phone.G3()

⑤raw_input从屏幕端读取原始字符串

    input从屏幕端读取运算结果

⑥file文件操作，open打开文件，读写文件

file_1 = open("wenben.txt","r+") 打开文件，文件名字，打开模式，关闭文件

print file_1.name,file_1.mode

# file_1.close()

  write可以对文件写入字符，包括二进制字符，但是不能够默认在文字末尾添加“/n”

  file_1.write("woaini")#都可以写入

  file_1.writelines("今天天气非常好") #都可以写入但是不能够自动换行，而且会直接覆盖原有内容

  read[10]读取10个字符file_1.read

  tellfile_1.tell() 查找当前位置，返回索引值

  rename os.rename("wenben.txt","shuaiqi.txt")

  os.mkdir("happy")在所运行的文件下建立目录

  os.rmdir("happy")在所运行的文件下建立目录

  os.chdir("/home") 改变所运行的目录

  os.getcwd()给出当前目录

    

24.try....except.....else异常处理语句

try: <语句>#运行别的代码

except <名字>： <语句> #如果在try部份引发了'name'异常

except <名字>，<数据>: <语句> #如果引发了'name'异常，获得附加的数据

else: <语句>#如果没有异常发生

 

用例：

try:

    fh = open("testfile", "w")

    fh.write("这是一个测试文件，用于测试异常!!")

    fh.write("这是一个测试文件，用于测试异常!!")

    fh.write("这是一个测试文件，用于测试异常!!")

except IOError:

    print "Error: 没有找到文件或读取文件失败"

else:

    print "内容写入文件成功"

    fh.close()

try-finally 语句

try-finally 语句无论是否发生异常都将执行最后的代码。

try: <语句> finally:<语句>    #退出try时总会执行 raise

    

raise 可以创造异常，但是触发异常后就不会执行后面的语句

#!/usr/bin/python # -*- coding: UTF-8 -*-# 定义函数 def mye( level ):     if level < 1:        raise Exception("Invalid level!", level)        # 触发异常后，后面的代码就不会再执行 try:     mye(0)                // 触发异常 except "Invalid level!":     print 1 #因为前面触发异常，所以这里不会执行 else:    print 2

用户自定义异常

    class Networkerror(RuntimeError):

    def __init__(self, arg):

        self.args = arg

try:

    raise Networkerror("Bad hostname")

except Networkerror,e:  #在try语句块中，用户自定义的异常后执行except块语句，变量 e 是用于创建Networkerror类的实例。

    print e.args

    

python在字符串中插入变量

    1. 使用连接符： +

    world = "World"

    print "Hello " + world + " ! "

    2. 使用占位符来内插

    world = "World"

    print "Hello %s !" % world

    3. 使用函数

    li = ['my','name','is','bob']

    mystr = ' '.join(li)

    print mystr

python修改字符串中的文字

param=param.replace("旧的","新的")

exec(param) 将字符串变成代码来执行

有分号的时候可以当成语句，也可以把读取的字符串当成变量名

字典也可以把读取的字符串当成变量名

 

25页面操作

brow.quit() # 关闭浏览器

brow.maxmize_window() # 浏览器最大化

brow.set_window_size(480,800) # 设置浏览器的宽和高

brow.get(url) # 访问页面

brow.back() # 当前页面后退

brow.forward() # 前进页面

XPATH

相对路径，绝对路径

find_element_by_xpath("/html/body/div[2]/form/span/input")

相对路径定位:

find_element_by_xpath("//input[@id=’input’]") #通过自身的id 属性定位

find_element_by_xpath("//span[@id=’input-container’]/input") #通过上一级目录的id 属性定位

find_element_by_xpath("//div[@id=’hd’]/form/span/input") #通过上三级目录的id 属性定位

find_element_by_xpath("//div[@name=’q’]/form/span/input")#通过上三级目录的name 属性定位

XPath 可以做布尔逻辑运算，例如：//div[@id=’hd’ or @name=’q’]