python基础速成

标签：使用外部   import   show   icc   pipe   标准   swa   数据   打开文件   

一、基础模块

def prt(age,name):#函数定义

   print("%s is %d 年龄 old"%(name,age))

if __name__=="__main__":#程序入口

   print("Hello World")

   prt(45,"gaici")    

获取输入：使用input()函数

name=input("you name ？")   

python的文件类型主要分为3类，分别是源代码、字节代码和优化代码。

1、源代码：文件以“py”为扩展名，“pyw”是图形用户接口的源文件的扩展名。

2、字节代码：python源文件经过编译后生成扩展名为"pyc"的文件，此文件是与平台无关的,可通过脚本生成该类型的文件。

import py_compile

py_compile.compile("ps.py")

运行后即可得到ps.pyc文件

3、优化代码：经过优化的源文件生成扩展名为“pyo”,该类型的文件需要命令行工具生成。

在命令行中输入“python2.7 -O -m py_compile ps.py”生成文件为ps.pyo而

"python3.5 -O -m py_compile ps.py"生成的文件为ps.pyc

类的私有变量、私有方法以两个下划线作为前缀。

class Student:                 #类名首字母大写

   __name=""                  #私有实例变量前必须有2个下划线

   def __init__(self,name):   #构造函数

       self.__name=name       #self相当于Java中的this

   def getName(self):         #方法名首字母小写，其后每个单词的首字母用大写

       return self.__name

   def __del__(self):         #析构函数

       self.__name=None

if __name__=="__main__":

   student=Student("borphi")  #对象名用小写字母

   print(student.getName())

注：python对代码缩进的要求非常严格。如果程序中不采用代码缩进的编码风格，将抛出一个IndentationError异常。    

模块是类或函数的集合，用于实现某个功能。在Python中，如果需要在程序中调用标准库或其他第三方库的类时，需要先使用import或from ... import语句导入相关的模块。

1、import语句    如：import sys

2、from ... import ...:在当前程序的命名空间中创建导入模块的引用。  如：from sys import path

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。与缩进不同，空行并不是python语法的一部分。只是为增加程序可读性而已。

python以“#”作为注释，特殊的注释有：

1、中文注释     #-*-coding:UTF-8-*-

2、跨平台注释    #! /usr/bin/python

python也支持分号，但可以省略，python主要通过换行来识别语句的结束。python同样支持多行写一条语句，使用“\”作为换行符。

如：

sql="select id,name" \

   "from dept" \

   "where name=‘A"

局部变量是只能在函数或代码段内使用的变量。python并没有提供定义常量的保留字。

python中的字符串，可以用单引号、双引号和三引号来包括。其中三引号保持字符原样输出，不做任何处理。

python内置的几种数据结构：元组、列表、字典和序列。

1、元组(Tuple)：元组由不同的元素组成，每个元素可以存储不同类型的数据，元组是“写保护”的，即元组创建后不能再做任何修改操作，也不能添加或删除任何元素。元组通常代表一行数据，而元组中的元素代表不同的数据项。tuple_name=(元素1，元素2，...)元组的访问可以通过索引访问。

元组的遍历需要用到range()和len()这两个函数

tuple=(("apple","banana"),("grape","orange"),("watermelon",),("grapefruit",))

for i in range(len(tuple)):

   print("tuple[%d]:"%i,"")

   for j in range(len(tuple[i])):

       print(tuple[i][j], "")

2、列表(List):通常作为函数的返回类型，可以实现添加(append())、删除(remove())和查找(index())操作，元素的值可以被修改。list_name=[元素1，元素2，...]

list0=["apple","banana","grape","orange"]

list0.append("watermelon")

list0.insert(1,"grapefruit")

list0.remove("banana")      #如果列表中存在2个相同的元素，只删除位置靠前的。

print(list0.pop())

print(list0[-2])

print(list0[1:3])

print(list0[-3:-1])

print(list0.index("grape"))

print("orange" in list0)

list0.sort()

list0.reverse()

list1=[["apple","banana"],["grape","orange"],["watermelon"],["grapefruit"]]

for i in range(len(list1)):

   print("list[%d]:"%i,"")

   for j in range(len(list1[i])):

       print(list1[i][j])

list0.extend(list1)

list0=list0+list1

list3=["apple","banana"]*2

print(list3)

注：用列表可以实现堆栈（append()、pop()）和队列（append()、pop(0)）

3、字典(Dictionary):字典是由“键-值”对组成的集合，字典中的“值”通过“键”来引用。dictionary_name={key1:value1,key2:value2, ... }

注意：字典的书写顺序不是字典实际存储顺序，字典根据每个元素的Hashcode值进行排列。

dict={"a":"apple","b":"banana","g":"grape","o":"orange"}  #创建

dict["w"]="watermelon"   #添加

del(dict["a"])           #删除

dict["g"]="grapefruit"   #修改

print(dict.pop("b"))

dict.clear()

#字典的遍历

for k in dict:

   print("dict[%s]="%k,dict[k])

print(dict.items())#返回由元组组成的列表

for (k,v) in dict.items():

   print("dict[%s]="%k,v)

print(dict.keys())#输出key的列表

print(dict.values())#输出value的列表

4、序列：具有索引和切片能力的集合，元组、列表和字符串都属于序列。

包、模块、函数

python的程序由包(package)、模块(module)和函数组成。包是一系统模块组成的集合。模块是处理某一类问题的函数和类的集合。

包是一个完成特定任务的工具箱，python提供了许多有用的工具包，如字符串处理、图形用户接口、Web应用、图形图像处理等。

注意：包必须至少含有一个__init__.py文件，该文件内容可以为空。__init__.py用于标识当前文件夹是一个包。

1、模块把一组相关的函数或代码组织到一个文件中。一个Python文件即是一个模块。模块由代码、函数或类组成。

当python导入一个模块时，python首先查找当前路径，然后查找lib目录、site-package目录(python\lib\site-packages)和环境变量PYTHONPATH设置的目录。

模块导入

import 模块名

导入模块一次与多次的意义是一样的。

重新导入：hello=reload(hello)

如果不想在程序中使用前缀符，可以使用from ... import ...语句将模块导入。

from module_name import function_name

模块的属性

模块有一些内置属性，用于完成特定的任务，如__name__、__doc__。每个模块都有一个名称。例如，__name__用于判断当前模块是否是程序的入口，如果当前程序正在被使用，__name__的值为“__main__”。通常给每个模块都添加一个条件语句，用于单独测试该模块的功能。例如，创建一个模块myModule:

if __name__=="__main__":

   print("myModule作为主程序运行")

else:

   print("myModule被另一个模块调用")

__doc__可以输出文档字符串的内容。

模块内置函数：

1、apply():可以实现调用可变参数列表的函数，把函数的参数存放在一个元组或序列中。

   apply(func [,args [,kwargs]])

2、filter():可以对某个序列做过滤处理，对自定义函数的参数返回的结果是否为“真”来过滤，并一次性返回处理结果

   filter(func or None,sequence) -> list, tuple, or string

3、reduce():对序列中元素的连续操作可以通过循环来处理。

   reduce(func,sequence[,initial])->value

4、map()：多个序列的每个元素都执行相同的操作，并组成列表返回。

   map(func,sequence[,sequence, ...]) ->list

2、自定义包

包就是一个至少包含__init__.py文件的文件夹。例如，定义一个包parent，parent包中包含2个子包pack和pack2。pack包中包含myModule模块，pack2包中包含myModule2模块。

pack包的__init__.py

__all__=["myModule"]    #用于记录当前包所包含的模块，如果模块多于2个，用逗号分开。这样就可在调用时一次导入所有模块

if __name__=="__main__":

    print("作为主程序运行")

else:

    print("pack初始化")

pack包的myModule.py

def func():

    print("pack.myModule.func()")

if __name__=="__main__":

    print("myModule作为主程序运行")

else:

    print("myModule被另一个模块调用")

pack2包__init__.py

__all__=["myModule2"]   #用于记录当前包所包含的模块，如果模块多于2个，用逗号分开。这样就可在调用时一次导入所有模块

if __name__=="__main__":

print("作为主程序运行")

else:

print("pack2初始化")

包pack2的myModule2：

def func():

print("pack2.myModule.func2()")

if __name__=="__main__":

print("myModule2作为主程序运行")

else:

print("myModule2被另一个模块调用")

parent模块调用:

from pack import *

from pack2 import *

myModule.func()

myModule2.func2()

3、函数

定义：

def 函数名(参数1[＝默认值1],参数2[=默认值2] ...):

...

return 表达式

调用：

函数名(实参1, 实参2, ...)

注意：实参必须与形参一一对应，如果参数提供默认值，顺序可以不一致。

python中的任何变量都是对象，所以参数只支持引用传递的方式。即形参和实参指向内存的同一个存储空间。

python不仅支持函数体内的嵌套，还支持函数定义的嵌套。

函数嵌套的层数不宜过多，就控制在3层以内。

# 嵌套函数

def func():

   x=1

   y=2

   m=3

   n=4

   def sum(a,b):   # 内部函数

       return a+b

   def sub(c,d):   # 内部函数

       return c-d

   return sum(x,y)*sub(m,n)

print(func())

注意：尽量不要在函数内部定义函数。

lambda函数

lambda函数用于创建一个匿名函数。

func=lambda  变量1, 变量1, ... : 表示式

调用：func()

# lambda

def func():

   x=1

   y=2

   m=3

   n=4

   sum=lambda a,b:a+b

   sub=lambda c,d:c-d

   return sum(x,y) * sub(m,n)

print(func())

注意：lambda也称之为表达式，只能使用表达式，不能使用判断、循环等多重语句。

Generator函数

生成器（Generator）的作用是一次产生一个数据项，并把数据项输出。可以用在for循环中遍历。Generator函数所具有的每次返回一个数据项的功能，使得迭代器的性能更佳。定义如下：

def 函数名(参数列表):

   ...

   yield 表达式

Generator函数的定义与普通函数的定义没有什么区别，只要在函数体内使用yield生成数据项即可。

Generator函数可以被for循环遍历，而且可以通过next()方法获得yield生成的数据项。

# 定义Generator函数

def func(n):

    for i in range(n):

       yield i

    #在for循环中输出

    for i in func(3):

       print(i)

#使用next()输出

r=func(3)

print(r.__next__())

print(r.__next__())

print(r.__next__())

注意：yield保留字与return语句的返回值和执行原理并不相同。yield生成值并不会中止程序的执行，返回值继续往后执行。return返回值后，程序将中止执行。

字符串

1、字符串格式化

Python将若干值插入到带“%”标记的字符串中，语法如下

"%s" % str1

"%s %s"% (str1,str2)

注意：如果要格式化多个值，元组中元素的顺序必须和格式化字符串中替代符的顺序一致。

Python格式化字符串的替代符及其含义

注意：如果要在字符串中输出“%”，则需要使用“%%”。

2、字符串的转义符

Python中转义字符的用法与Java相同，都是使用“\”作为转义字符。

Python的转义字符及其含义

注意：如果要在字符串中输出"\"，需要使用“\\”

3、字符串合并

Python使用“+”连接不同的字符串，如果两侧都是字符串，执行连接操作，如果两侧都是数字类型，则执行加法运算；如果两侧类型不同，则抛出异常：TypeError

4、字符串的截取

Python字符串内置了序列，可以通过“索引”、“切片”获取子串，也可以使用函数split来获取。

切片的语法格式如下所示：string[start:end:step]

5、字符串的比较

Python直接使用“==”、“！=”运算符比较两个字符串的内容。startswith()、endswith()

6、字符串反转

Python使用列表和字符串索引来实现字符串的反转，并通过range()进行循环。

# 循环输出反转的字符串

def reverse(s):

   out=""

   li=list(s)

   for i in range(len(li),0,-1):

      out+="".join(li[i-1])

   return out

利用序列的“切片”实现字符串反转最为简洁：

# 循环输出反转的字符串

def reverse(s):   

    return s[::-1]

7、字符串的查找和替换

查找：find()、rfind()

替换：replace()：不支持正则

8、字符串与日期转换

Python提供了time模块处理日期和时间

从时间到字符串的转换strftime(),格式：strftime(format[,tuple])->string

格式化日期常用标记

字符串到日期的转换：需要进行两次转换，使用time模块和datetime类。转换过程分为3个步骤。

（1）、调用函数strptime()把字符串转换为一个元组，进行第一次转换，格式如下

            strptime(string,format)->struct_time

（2）、把表示时间的元组赋值给表示年、月、日的3个变量

（3）、把表示年、月、日的3个变量传递给函数datetime(),进行第2次转换，格式如下

            datetime(year,month,day[,hour[,minute[,second[,microsecond[,tzinfo]]]])

正则表达式

1、基础

正则表达式中的特殊字符

正则表达式中的常用限定符

限定符与“？”的组合

2、使用syt.re模块处理正则表达式

re模块的规则选项

pattern对象的属性和方法

match对象的方法和属性

类与对象

1、类

定义：

class Fruit:

   def grow(self):   #类的方法必须有1个self参数，但是方法调用时可以不传这个参数

      print("Fruit grow ...")

      if __name__=="__main__":

fruit=Fruit()

fruit.grow()

2、对象的创建

if __name__=="__main__":

    fruit=Fruit()

    fruit.grow()

属性和方法

1、python类的属性分为私有属性和公有属性，但python并没有提供公有属性和私有属性的修饰符。类的私有属性不能被该类之外的函数调用，类属性的作用范围完全取决于属性的名称。如果函数、方法或属性的名字以两个下划线开始，则表示私有类型；没有使用两个下划线开始则表示公有属性。

python的属性分为实例属性和静态属性。实例属性是以self作为前缀的属性。__init__方法即Python类的构造函数。如果__init__方法中定义的变量没有使用self作为前缀声明，则该变量只是普通的局部变量。在python中静态变量称之为静态属性。

class Fruit:

   price=0                  #类属性

   def __init__(self):

      self.color="red"     #实例属性

      zone="China"         #局部变量

if __name__=="__main__":

   print(Fruit.price)

   apple=Fruit()

   print(apple.color)

   Fruit.price=Fruit.price+10

   print("apple‘s price:"+str(apple.price))

   banana=Fruit()

   print("banana‘s price:" + str(banana.price))

注意：Python的类和对象都可以访问类属性。

python提供了直接访问私有属性的方式，可用于程序的测试和调试，访问的格式如下：

instance_classname_attribute     #instance表示对象；classname表示类名；attribute表示私有属性。

class Fruit:

    def __init__(self):

        self.__color="red"     #私有属性

if __name__=="__main__":

    apple=Fruit()

    print(apple._Fruit__color)

类提供了一些内置属性，用于管理类的内部关系。如，__dict__、__bases__、__doc__等

2、类的方法

类的方法也分为公有方法和私有方法。私有函数不能被该类之外的函数调用，私有方法也不能被外部的类或函数调用。Python使用函数staticmethod()或"@staticmethod"指令的方式把普通函数转换为静态方法。Python的静态方法并没有和类的实例进行名称绑定，Python的静态方法相当于全局函数。

class Fruit:

    price = 0

    def __init__(self):

        self.__color="red"     #私有属性

    def getColor(self):

        print(self.__color)

    @staticmethod

    def getPrice():

   print(Fruit.price)

    def __getPrice():

       Fruit.price=Fruit.price+10

       print(Fruit.price)

    count=staticmethod(__getPrice)

if __name__=="__main__":

    apple=Fruit()

    apple.getColor()

    Fruit.count()

    banana = Fruit()

    Fruit.count()

    Fruit.getPrice()

Python中还有一种方法称之为类方法。类方法的作用与静态方法相似，都可以被其它实例对象共享，不同的是类方法必须提供self参数。类方法可以使用函数classmethod()或“@classmethod”指令定义。

class Fruit:

   price = 0

   def __init__(self):

      self.__color="red"     #私有属性

   def getColor(self):

      print(self.__color)

   @classmethod

   def getPrice(self):

      print(self.price)

   def __getPrice(self):

      self.price=self.price+10

      print(self.price)

count=classmethod(__getPrice)

if __name__=="__main__":

   apple=Fruit()

   apple.getColor()

   Fruit.count()

   banana = Fruit()

   Fruit.count()

   Fruit.getPrice()

如果某个方法需要被其他实例共享，同时又需要使用当前实例的属性，则将其定义为类方法。

3、内部类的使用

内部类中的方法可以使用两种方法调用

第一种方法是直接使用外部类调用内部类，生成内部类的实例，再调用内部类的方法，调用格式如下所示：

object_name=outclass_name.inclass_name()

object_name.method()

第二种方法是先对外部类进行实例化，然后再实例化内部类，最后调用内部类

out_name=outclass_name()

in_name=out_name.inclass_name()

in_name.method()

内部类使用方法：

class Car:

class Door:               #内部类

       def open(self):          

print("open door")

class Wheel:              #内部类

       def run(self):

print("car run")

if __name__=="__main__":

car=Car()

backDoor=Car.Door()       #内部类的实例化方法一

frontDoor=car.Door()      #内部类的实例化方法二

backDoor.open()

frontDoor.open()

wheel=Car.Wheel()

wheel.run()

4、__init__方法

python的构造函数名为__init__。__init__方法除了用于定义实例变量外，还用于程序的初始化。__init__方法是可选的，如果不提供__init__方法，Python将会给出一个默认的__init__方法。

5、__del__方法

Python提供了析构函数__del__()。析构函数可以显式的释放对象占用的资源，析构函数也是可选的，如果程序不提供析构函数，Python会在后台提供默认的析构函数。

如果要显式的调用析构函数，可以使用del语句，在程序的末尾添加如下语句

del fruit     #执行析构函数

6、垃圾回收机制

Python也采用垃圾回收机制清除对象，Python提供了gc模块释放不再使用的对象。垃圾回收的机制有许多种算法，Python采用的是引用计算的方式。函数collect()可以一次性收集所有待处理的对象。

import gc

class Fruit:

    def __init__(self,name,color):     #初始化name,color属性

       self.__name=name

       self.__color=color

    def getColor(self):

       return self.__color

    def setColor(self,color):

       self.__color=color

    def getName(self):

       return self.__name

    def setName(self,name):

       self.__name=name

class FruitShop:                       #水果店类

    def __init__(self):

       self.fruits=[]

    def addFruit(self,fruit):          #添加水果

       fruit.parent=self              #把Fruit类关联到FruitShop类

       self.fruits.append(fruit)

if __name__=="__main__":

    shop=FruitShop()

    shop.addFruit(Fruit("apple","red"))

    shop.addFruit(Fruit("banana", "yellow"))

    print(gc.get_referents(shop))

    del shop

    print(gc.collect())                 #显式调用垃圾回收器

7、类的内置方法

__new__()

__new__()在__init__()之前调用，用于生成实例对象。利用这个方法和类属性的特性可以实现设计模式中的单例模式。

class Singleton(object):

   __instance=None           #定义实例

   def __init__(self):

      pass

   def __new__(cls, *args, **kwargs):    #在__init__之前调用

       if Singleton.__instance is None:  #生成唯一实例

           Singleton.__instance=object.__new__(cls,*args,**kwargs)

       return Singleton.__instance

8、方法的动态特性

Python作为动态脚本语言，编写的程序具有很强的动态性。可以动态添加类的方法，把某个已经定义的函数添加到类中。添加新方法的语法格式如下所示：

class_name.method_name=function_name

注意：function_name表示一个已经存在的函数

class Fruit:

    pass

def add(self):

    print("grow ...")

if __name__=="__main__":

    Fruit.grow=add()

    fruit=Fruit()

    fruit.grow()

继承

Python不提倡过度包装。继承可以重用已经存在的数据和行为，减少代码的重复编写。Python在类名后使用一对括号表示继承关系，括号中的类即为父类。如果父类定义了__init__方法，子类必须显式调用父类的__init__方法。如果子类需要扩展父类的行为，可以添加__init__方法的参数。

class Fruit():

   def __init__(self,color):

self.color=color

print("fruit‘s color:%s"%self.color)

   def grow(self):

print("grow ...")

class Apple(Fruit):

   def __init__(self,color):

Fruit.__init__(self,color)

print("apple‘s color:%s"%self.color)

class Banana(Fruit):

   def __init__(self,color):

Fruit.__init__(self,color)

print("banana‘s color:%s"%self.color)

   def grow(self):

print("banana grow ...")

if __name__=="__main__":

   apple=Apple("red")

   apple.grow()

   banana=Banana("yellow")

   banana.grow()

还可以使用super类的super()调用父类的__init__方法。super()可以绑定type类的父类。

super(type,obj)

class Fruit(object):

def __init__(self):

print("parent")

class Apple(Fruit):

def __init__(self):

super(Apple, self).__init__()

print("apple child")

if __name__=="__main__":

Apple()

注意：super类的实现代码继承了object，因此Fruit类必须继承object.如果不继承object，使用super()将出现错误。

python没有提供对接口的支持。

运算符的重载

Python把运算符和类的内置方法关联起来，每个运算符都对应1个函数。

class Fruit:

def __init__(self,price=0):

self.price=price

def __add__(self, other):             #重载加号运算符

       return self.price+other.price

def __gt__(self, other):              #重载大于运算符

       if self.price>other.price:

flag=True

       else:

flag=False

       return flag

class Apple(Fruit):

pass

class Banana(Fruit):

pass

python工厂方法模式

工厂方法类图

实现方法

class Factory:                         #工厂类

   def createFruit(self,fruit):       #工厂方法

       if fruit=="apple":

return Apple()

  elif fruit=="banana":

     return Banana()

class Fruit:

def __str__(self):

return "fruit"

class Apple(Fruit):

def __str__(self):

return "apple"

class Banana(Fruit):

def __str__(self):

return "banana"

if __name__=="__main__":

factory=Factory()

print(factory.createFruit("apple"))

print(factory.createFruit("banana"))

异常处理与程序调试

Python中的异常类定义在exceptions模块中，并继承自基类BaseException。BaseException类是属于new-style class，BaseException类下有3个子类，分别是Exception、KeyboardInterrupt、SystemExit。

Exception类是最常用的异常类，该类包括StandardError、StopIteration、GeneratorExit、Warning等异常类。

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration
      +-- StopAsyncIteration
      +-- ArithmeticError
      |    +-- FloatingPointError
      |    +-- OverflowError
      |    +-- ZeroDivisionError
      +-- AssertionError
      +-- AttributeError
      +-- BufferError
      +-- EOFError
      +-- ImportError
      +-- LookupError
      |    +-- IndexError
      |    +-- KeyError
      +-- MemoryError
      +-- NameError
      |    +-- UnboundLocalError
      +-- OSError
      |    +-- BlockingIOError
      |    +-- ChildProcessError
      |    +-- ConnectionError
      |    |    +-- BrokenPipeError
      |    |    +-- ConnectionAbortedError
      |    |    +-- ConnectionRefusedError
      |    |    +-- ConnectionResetError
      |    +-- FileExistsError
      |    +-- FileNotFoundError
      |    +-- InterruptedError
      |    +-- IsADirectoryError
      |    +-- NotADirectoryError
      |    +-- PermissionError
      |    +-- ProcessLookupError
      |    +-- TimeoutError
      +-- ReferenceError
      +-- RuntimeError
      |    +-- NotImplementedError
      |    +-- RecursionError
      +-- SyntaxError
      |    +-- IndentationError
      |         +-- TabError
      +-- SystemError
      +-- TypeError
      +-- ValueError
      |    +-- UnicodeError
      |         +-- UnicodeDecodeError
      |         +-- UnicodeEncodeError
      |         +-- UnicodeTranslateError
      +-- Warning
           +-- DeprecationWarning
           +-- PendingDeprecationWarning
           +-- RuntimeWarning
           +-- SyntaxWarning
           +-- UserWarning
           +-- FutureWarning
           +-- ImportWarning
           +-- UnicodeWarning
           +-- BytesWarning
           +-- ResourceWarning

StandardError类中常见的异常

Python使用try ... exception语句捕获异常，异常类型定义在try子句的后面。

注意：如果在except子句后将异常类型设置为"Exception"，异常处理程序将捕获除程序中断外的所有异常，因为Exception类是其他异常类的基类。

try ... exception用法：

try:

file("hello.txt",‘r‘)

print(‘读文件‘)

except IOError:

print("文件不存在")

except:

print("程序异常")

else:

print("结束")

try ... finally用法

try:

f=file("hello.txt",‘r‘)

print(‘读文件‘)

except IOError:

print("文件不存在")

finally:

f.close()

使用raise抛出异常

可以通过raise语句显式引发异常。一旦执行了raise语句，raise语句后的代码将不能被执行。

try:

   s=None

   if s is None:

       print("s 是空对象")

       raise NameError

   print(len(s))

except TypeError:

   print("空对象没有长度")    

自定义异常

自定义异常必须继承Exception类，自定义异常按照命名规范以"Error"结尾，使用raise引发，且只能通过手工方式触发

from __future__ import division

class DivisionException(Exception):

   def __init__(self,Exception):

       Exception.__init__(self,x,y)

       self.x=x

       self.y=y

if __name__=="__main__":

   try:

       x=3

       y=2

       if x%y>0:

           print(x/y)

           raise DivisionException(x,y)

   except DivisionException as div:

       print("DivisionException:x/y=%.2f"%(div.x/div.y))

assert语句的使用 

assert语句用于检测某个条件表达是否为真，又称断言语句  

t=("hello")

assert len(t)>=1

注意：python支持形如"m<=x<=n"的表达式。

Python中的traceback对象可记录异常信息和当前程序的状态。当异常发生时，traceback对象将输出异常信息。异常信息应从下往上阅读。

python的数据库编程

Python提供了连接数据库的专用模块，不同的数据库可以使用相应的专用模块访问数据库。

1、cx_Oracle模块

python的cx_Oracle模块可以访问Oracle数据库。

cx_Oracle模块的下载地址：http://cx-oracle.sourceforge.net/

代码示例：

import cx_Oracle

connection=cx_Oracle.Connection("scott","tiger,","ORCL") #连接oracle数据库

cursor=connection.cursor()   #获取cursor对象操作数据库

sql="";

cursor.execute(sql)

for x in cursor.fetvchall():

for value in x:

print(value)

cursor.close()

connection.close()

2、MySQLdb模块

MySQLdb模块是python操作MySQL数据库的。

代码示例

import os,sys

import MySQLdb

#连接数据库

try:

conn=MySQLdb.connect(host="localhost",user="root",passwd="",db="")

cursor=conn.cursor()

sql="insert into address(name,address) values (%s,%s)"

values=(("张三","北京海淀区"),("李四","北京海淀区"),("王五","北京海淀区"))

cursor.executemany(sql,values)   #插入多条数据

except Exception as e:

print(e)

sys.exit()

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

try:

sql=""

cursor.execute(sql)                   #查询数据

data=cursor.fetchall()

if data:

for x in data:

print(x[0],x[1])

cursor.close()                        #关闭游标

conn.close()                          #关闭数据库

except Exception as e:

print(e)

3、SQLite数据库

#-*-coding:utf-8-*-

import sqlite3

#连接数据库

conn=sqlite3.connect("./address.db")

#创建表

conn.execute("create table if not exists address(id integer primary key autoincrement,name VARCHAR(128),address VARCHAR (128))")

conn.execute("insert into address(name,address) VALUES (‘Tom‘,‘Beijing road‘)")

conn.execute("insert into address(name,address) VALUES (‘Jerry‘,‘Shanghai road‘)")

#手动提交数据

conn.commit()

#获取游标对象

cur=conn.cursor()

#使用游标查询数据

cur.execute("select * from address")

#获取所有结果

res=cur.fetchall()

print "address:",res

for line in res:

for f in line:

print f

#关闭连接

cur.close()

conn.close()

Python的持久化模块

python的标准库提供了几种持久化模块。这些模块可以模拟数据库的操作，会把数据保存在指定的文件中。例如dbhash、anydbm、shelve等模块。

1、dbhash模块读写数据

DBM是一种文件式数据库，采用哈希结构进行存储。是一种简单的数据库，并不具备管理能力，但是比普通文件更稳定、可靠，而且查询速度快。unix操作系统使用gdbm，而windows可以使用dbhash模块。

window环境下DBM数据库的读写操作

import  dbhash

db=dbhash.open(‘temp‘,‘c‘)    #创建并打开数据库

db["Tom"]="Beijing road"      #写数据

db["Jerry"]="Shanghai road"

for k,v in db.iteritems():    #遍历db对象

   print(k,v)

if db.has_key("Tom"):

   del db["Tom"]

print(db)

db.close()                     #关闭数据库

注意：dbhash模块返回字典的key、value值只支持字符串类型

为了统一不同操作系统对DBM数据库的要求，Python的anydbm模块提供了操作DBM数据库的一般性操作。其用法和dbhash模块类似。

2、shelve模块读写数据

shelve模块是Python的持久化对象模块，用法与anydbm模块的用法相似，但是shelve模块返回字典的value值支持基本的Python类型。

import  shelve

addresses=shelve.open(‘addresses‘)    #创建并打开数据库

addresses["1"]=["Tom","Beijing road","2018-01-03"]      #写数据

addresses["2"]=["Jerry","Shanghai road","2008-03-30"]

if addresses.has_key("2"):

    del addresses["2"]

print(addresses)

addresses.close()                     #关闭数据库

注意：shelve模块返回字典的key值只支持字符串类型

文件处理

文件通常用于存储数据或应用程序的参数。Python提供了os、os.path、shutil等模块用于处理文件。其中包括打开文件、读写文件、复制和删除文件等函数。

文件的处理一般分为以下3个步骤：

（1）创建并打开文件，使用file()函数返回一个file对象。

file(name[, mode[, buffering]])

文件打开的模式(mode)

注意：对于图片、视频等文件必须使用"b"的模式读写

（2）调用file对象的read()、write()等方法处理文件。

（3）调用close()关闭文件，释放file对象占用的资源。

示例：

#创建文件

context=‘‘‘helloworld

hellochina

‘‘‘

f=open(‘hello.txt‘,‘w‘)#打开文件

f.write(context)#把字符串写入文件

f.close()#关闭文件

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#按行读取方式：使用readline()读文件

f=open(‘hello.txt‘)

while True:

line=f.readline()

if line:

print(line)

else:

break

f.close()

#多行读取方式：使用readlins()读文件

f=open(‘hello.txt‘)

lines=f.readlines()

for line in lines:

print(line)

f.close()

#一次性读取方式：read()

f=open(‘hello.txt‘)

context=f.read()

print(context)

f.close()

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#使用writelines()写文件

f=open(‘hello.txt‘,‘w+‘)

li=[‘helloworld\n‘,‘hellochina\n‘]

f.writelines(li)

f.close()

#使用write()写文件：追加新的内容到文件

f=open(‘hello.txt‘,‘a+‘)

new_context="goodbye"

f.write(new_context)

f.close()

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

文件的删除需要使用os模块和os.path模块。os模块提供了对系统环境、文件、目录等操作的系统级的接口函数。

os模块常用的文件处理函数

os.path模块常用的函数

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#删除文件

importos

if os.path.exists(‘hello.txt‘):

os.remove(‘hello.txt‘)

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

file类没有提供直接复制文件的方法，但是可以使用read(),write()方法模拟实现文件复制功能。

#使用read()、write()实现拷贝

#创建文件hello.txt

src=open(‘hello.txt‘,‘w‘)

li=[‘helloworld\n‘,‘hellochina\n‘]

src.writelines(li)

src.close()

#把hello.txt拷贝到hello2.txt

src=open(‘hello.txt‘,‘r‘)

dst=open(‘hello2.txt‘,‘w‘)

dst.write(src.read())

src.close()

dst.close()

shutil模块是另一个文件、目录的管理接口，提供了一些用于复制文件、目录的函数。copyfile()函数可以实现文件的拷贝，copyfile()函数的声明如下：

copyfile(src,dst)

文件的剪切可以使用move()函数模拟，该函数声明如下：

move(src,dst)

#shutil模块实现文件的拷贝、移动

import shutil

shutil.copyfile(‘hello.txt‘,‘hello2.txt‘)

shutil.move(‘hello.txt‘,‘../‘)

shutil.move(‘hello2.txt‘,‘hello3.txt‘)

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

os模块的函数rename()可以对文件或目录进行重命名。

#修改文件名

import os

li=os.listdir(".")

print(li)

if "hello.txt" in li:

os.rename(‘hello.txt‘,‘hi.txt‘)

elif ‘hi.txt‘ in li:

os.rename(‘hi.txt‘,‘hello.txt‘)

#修改文件后缀（即扩展名）

import os

files=os.listdir(‘.‘)

for filename in files:

pos=filename.find(‘.‘)

if filename[pos+1:]==‘html‘:

newname=filename[:pos+1]+"htm"

os.rename(filename,newname)

#修改文件后缀（即扩展名）--简化版

import os

files=os.listdir(‘.‘)

for filename in files:

li=os.path.splitext(filename)

if li[1]==".html":

newname=li[0]+".htm"

os.rename(filename,newname)

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#文件的查找

import re

f1=open(‘hello.txt‘,‘r‘)

count=0

for s in f1.readlines():

li=re.findall(‘hello‘,s)

if len(li)>0:

count+=li.count("hello")

print("查找到"+str(count)+"个hello")

f1.close()

#文件内容的替换

f1=open(‘hello.txt‘,‘r‘)

f2=open(‘hello2.txt‘,‘w‘)

for s in f1.readlines():

f2.write(s.replace("hello",‘hi‘))

f1.close()

f2.close()

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

python提供了模块difflib用于实现对序列、文件的比较。如果要比较2个文件，列出2个文件的异同，可以使用difflib模块的SequenceMatcher类实现。其中get_opcodes()可以返回2个序列的比较结果。调用get_opcodes之前，需要先生成1个SequenceMatcher对象。

#文件比较

import difflib

f1=open(‘hello.txt‘,‘r‘)

f2=open(‘hi.txt‘,‘r‘)

src=f1.read()

dst=f2.read()

print(src)

print(dst)

s=difflib.SequenceMatcher(lambda x:x=="",src,dst)

for tag,i1,i2,j1,j2 in s.get_opcodes():

   print("%ssrc[%d:%d]=%sdst[%d:%d]=%s"%(tag,i1,i2,src[i1:i2],j1,j2,dst[j1:j2]))

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

python标准库ConfigParser模块用于解析配置文件。ConfigParser模块类可读取ini文件的内容

ODBC.ini

[ODBC 32 bit Data Sources]

MS Access Database=Microsoft Access Driver(*.mdb)(32)

Excel Files=Microsoft Excel Driver(*.xls)(32)

dBASE Files=Microsoft dBase Driver(*.dbf)(32)

[MSAccessDatabase]

Driver32=C:\WINDOWS\system32\odbcjt32.dll

[ExcelFiles]

Driver32=C:\WINDOWS\system32\odbcjt32.dll

[dBASEFiles]

Driver32=C:\WINDOWS\system32\odbcjt32.dll

#读取配置文件

import configparser

config=configparser.ConfigParser()

config.read("ODBC.ini")

sections=config.sections()#返回所有配置块的标题

print("配置块：",sections)

o=config.options("ODBC 32 bit Data Sources")#返回所有配置项的标题

print("配置项：",o)

v=config.items("ODBC 32 bit Data Sources")

print("内容：",v)

#根据配置块和配置项返回内容

access=config.get("ODBC 32 bit Data Sources","Ms Access Database")

print(access)

excel=config.get("ODBC 32 bit Data Sources","Excel Files")

print(excel)

dBASE=config.get("ODBC 32 bit Data Sources","dBASE Files")

2、配置文件写入

#写入配置文件

import configparser

config=configparser.ConfigParser()

config.add_section("ODBC Driver Count")#添加新配置块

config.set("ODBC Driver Count","count",2)#添加新的配置项

f=open("ODBC.ini",‘a+‘)

config.write(f)

f.close()

config.read("ODBC.ini")

3、修改配置文件

#修改配置文件

import configparser

config=configparser.ConfigParser()

config.read("ODBC.ini")

config.set("ODBC Driver Count","count",3)#修改配置项

f=open("ODBC.ini","r+")

config.write(f)

f.close()

4、删除配置块和配置项

#删除配置块和配置项

import configparser

config=configparser.ConfigParser()

config.read("ODBC.ini")

config.remove_option("ODBC Driver Count","count")#删除配置项

config.remove_section("ODBC Driver Count")#删除配置块

f=open("ODBC.ini","w+")

config.write(f)

f.close()

目录的基本操作

os模块提供了针对目录进行操作的函数

import os

os.mkdir("hello")

os.rmdir("hello")

os.makedirs("hello/world")

os.removedirs("hello/world")

目录的遍历有3种实现方法--递归函数、os.path.walk()、os.walk()

#1、递归遍历目录

import os

def visitDir(path):

li=os.listdir(path)

for p in li:

pathname=os.path.join(path,p)

if not os.path.isfile(pathname):

visitDir(pathname)

else:

print(pathname)

if__name__=="__main__":

path=r"/Users/liudebin/资料"

visitDir(path)

#2、os.path.walk()

import os,os.path

def visitDir(arg,dirname,names):

for filepath in names:

print(os.path.join(dirname,filepath))

if__name__=="__main__":

path=r"/Users/liudebin"

os.path.walk(path,visitDir,())

#3、os.walk

def visitDir(path):

for root,dirs,files in os.walk(path):

for filepath in files:

print(os.path.join(root,filepath))

if__name__=="__main__":

path=r"/Users/liudebin"

visitDir(path)

注意：os.path.walk()与os.walk()产生的文件名列表并不相同：

os.path.walk()产生目录树下的目录路径和文件路径，而os.walk()只产生文件路径

文件和流

python隐藏了流的机制，在python的模块中找不到类似Stream类，python把文件的处理和流关联在一起，流对象实现了File类的所有方法。sys模块提供了3种基本的流对象---stdin、stdout、stderr。流对象可以使用File类的属性和方法，流对象的处理和文件的处理方式相同。

1、stdin

importsys

sys.stdin=open(‘ODBC.ini‘,‘r‘)

forlineinsys.stdin.readlines():

print(line)

2、stdout

importsys

sys.stdout=open(r‘ODBC.ini‘,‘a‘)

print("goodbye")

sys.stdout.close()

3、stderr

importsys,time

sys.stderr=open(‘record.log‘,‘a‘)

f=open(r"./hello.txt","r")

t=time.strftime("%Y-%m-%d%X",time.localtime())

context=f.read()

ifcontext:

sys.stderr.write(t+""+context)

else:

raise Exception(t+"异常信息")

python模拟Java输入、输出流

#文件输入流

def fileInputStream(filename):

try:

f=open(filename)

for line in f:

for byte in line:

yield byte

exceptStopIteration:

f.close()

return

#文件输出流

def fileOutputStream(inputStream,filename):

try:

f=open(filename,‘w‘)

while True:

byte=inputStream.next()

f.write(byte)

except StopIteration:

f.close()

return

if__name__=="__main__":

fileOutputStream(fileInputStream(‘hello.txt‘),‘hello2.txt‘)

示例：

#文件属性浏览

def showFileProperties(path):

"""显示文件的属性，包括路径、大小、创建日期，最后修改时间，最后访问时间"""

import time,os

for root,dirs,files in os.walk(path,True):

print("位置："+root)

for filename in files:

stats=os.stat(os.path.join(root,filename))

info="文件名："+filename+""

info+="大小："+("%dM"%(stats[-4]/1024/1024))+""

t=time.strftime("%Y-%m-%d%X",time.localtime(stats[-1]))

info+="创建时间："+t+""

t=time.strftime("%Y-%m-%d%X",time.localtime(stats[-2]))

info+="最后修改时间："+t+""

t=time.strftime("%Y-%m-%d%X",time.localtime(stats[-3]))

info+="最后访问时间："+t+""

print(info)

if __name__=="__main__":

path=r"/Users/liudebin/Downloads/第一二期/第二期"

showFileProperties(path)

注意：os.stat()的参数必须是路径

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

URL的解析

Python中用来对URL字符串进行解析的模块是urlparse。该模块主要的方法有urlparse、urljoin、urlsplit和urlunsplit等

在Python语言中，urlparse对于URL的定义采用的六元组，如下所示：

scheme://netloc/path;parameters?query#fragment

urlparse方法返回对象的属性

可以使用PyChecker和PyLine检查源代码。

使用Distutils可以让开发者轻松地用Python编写安装脚本。

日志记录可以使用标准库中的logging模块，基本用法很简单：

import logging

logging.basicConfig(level=logging.INFO,filename=‘mylog.log‘)

logging.info("Starting program")

logging.info("Trying to divide 1 by 0")

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

测试

在Python中代码测试包含两种类型：unittest和doctest

unittest模块：用来写PyUnit的测试代码。支持对软件代码的自动化测试。

doctest模块：可以直接在代码的注释中写测试用例。此模块将测试用例内置在了函数的文档字符串，从而达到了文档和测试代码的统一。

TDD(测试驱动开发)：基本思想是测试先行，在开发具体的功能代码之前，需要先编写此功能的测试代码。只有通过了测试的代码，才能够加入到代码仓库中。

#encoding=utf-8

importunittest

importstring

classStringReplaceTestCase1(unittest.TestCase):

"""测试空字符串替换"""

defrunTest(self):

src="HELLO"

exp="HELLO"

result=string.replace(src,"","")

self.assertEqual(exp,result)

srtc=StringReplaceTestCase1()

srtc.runTest()

在python语言中，可以用内置的assert语句来实现测试用例运行时候的断言。

unittest模块中的测试方法

python基础速成

标签：使用外部   import   show   icc   pipe   标准   swa   数据   打开文件   

原文地址：http://www.cnblogs.com/netbloomy/p/6673522.html