Python

Python之模块

    包就是文件夹；包可以有多级；

  

模块就是 xxx.py文件；可以创建自己的模块，并且导入它们，模块的名字就和文件的名字相同；

Python使用import语句导入一个模块。

import math
print math.sqrt(16)  # => 4

只希望导入用到的math模块的某几个函数

from math import ceil, floor
print ceil(3.7)   # => 4.0
print floor(3.7)  # => 3.0

# 从模块中导入所有的定义
# 警告：不推荐使用
from math import *

使用 from...import 导入 函数，有时候会引起同名冲突。这时，可以给函数起个“别名”来避免冲突；

from math import log
from logging import log as logger   # logging的log现在变成了logger
print log(10)   # 调用的是math的log
logger(10, 'import from logging')   # 调用的是logging的log

# 也可以通过dir方法查看模块中有什么属性和方法
import math
dir(math)

dir()#当前模块的定义，但不会列出内置函数和变量名，他们在标准模块‘_builtin_’中定义
import __builtin__
print(dir(__builtin__))#如果一个模块被修改了，可以使用imp.reload重新加载模块的新定义import imp

imp.reload(math)

查找模块 

导入一个 xxx模块，解释器首先查找 xxx.py的文件，当找到该模块时，解释器将它编译成一个.pyc文件。当再次导入模块时，解释器可以加载编译好的模块，加速Python脚本的运行；如果导入的模块不存在，Python解释器会报 ImportError 错误：解释器查找模块搜索路径指定在sys模块的sys.path变量中的所有目录；

sys.path由环境变量PYTHONPATH初始化，如果没有设定PYTHONPATH，就由内置的默认值初始化，可以用标准的字符串操作修改它：

import sys

sys.path.append(r"C:Program Files")

安装第三方模块

 -easy_instal

-pip(推荐，已内置到 Python 2.7.9)

python -m pip install --upgrade pip  升级pip命令

第三方库都会在Python官方的pypi.python.org网站注册，要安装一个第三方库，必须先知道该库的名称；

进入window 命令符，键入 pip help

键入命令pip install numpy下载安装相关包（用于科学计算的NumPy库）；注意多版本共存的问题，使用哪个版本的pip 需要cd 到其 目录下：

python之__future__

Python的新版本会引入新的功能，但是，实际上这些功能在上一个老版本中就已经存在了。要“试用”某一新的特性，就可以通过导入__future__模块的某些功能来实现。

当新版本的一个特性与旧版本不兼容时，该特性将会在旧版本中添加到__future__中，以便旧的代码能在旧版本中测试新特性。

Python 2.7的整数除法运算结果仍是整数：Python 3.x已经改进了整数的除法运算，“/”除将得到浮点数，“//”除才仍是整数：要在Python 2.7中引入3.x的除法规则，导入__future__的division

from __future__ import division
print 10/3

python之类和对象

定义类是通过class关键字；定义一个Person类如下：

class Person(object):
    pass

按照 Python 的编程习惯，类名以大写字母开头，紧接着是(object)，表示该类是从哪个类继承下来的。通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类；
创建对象使用 类名+()，类似函数调用的形式创建：

xiaoming = Person() 
xiaohong = Person()

由于Python是动态语言，对每一个对象，都可以直接给他们的属性赋值，例如，给xiaoming这个对象加上name、gender和birth属性：

xiaoming.name = 'Xiao Ming'
xiaoming.gender = 'Male'
xiaoming.birth = '1990-1-1'

给xiaohong加上的属性不一定要和xiaoming相同：

xiaohong.name = 'Xiao Hong'
xiaohong.school = 'No. 1 High School'
xiaohong.grade = 2 

基本构造函数__init__()方法，当创建对象时，__init__()方法被自动调用，__init__() 方法的第一个参数必须是 self（也可以用别的名字，但建议使用习惯用法），后续参数则可以自由指定，和定义函数没有任何区别。相应地，创建对象时，就必须要提供除 self 以外的参数；

属性访问限制：在Python中，对象的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问；

以"__xxx__"定义的属性在Python的类中被称为特殊属性，有很多预定义的特殊属性可以使用，特殊变量是可以直接访问的，不是private变量，通常我们不要把普通属性用"__xxx__"定义。

以一个下划线开头的实例变量名，比如_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。

 类属性：在类上绑定一个属性，则所有实例都可以访问类的属性，并且，所有实例访问的类属性都是同一个，因为类属性是直接绑定在类上的；所以，访问类属性不需要创建实例，就可以直接访问，类属性也是可以动态添加和修改的；当实例属性和类属性重名时，实例属性优先级高，它将屏蔽掉对类属性的访问。

实例方法：就是在类中定义的函数，它的第一个参数永远是 self，指向调用该方法的实例本身，其他参数和一个普通函数是完全一样的;

方法也是一个属性，所以，它也可以动态地添加到实例上，只是需要用 types.MethodType() 把一个函数绑定到一个属性上；并不常见，直接在class中定义要更直观。

import types
def fn_get_grade(self):
    if self.score >= 80:
        return 'A'
    if self.score >= 60:
        return 'B'
    return 'C'

class Person(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score

p1 = Person('Bob', 90)
p1.get_grade = types.MethodType(fn_get_grade, p1, Person)
print p1.get_grade() # => A

 类方法：通过标记一个 @classmethod，该方法将绑定到类上，而非类的实例。类方法的第一个参数将传入类本身，通常将参数名命名为 cls；类方法无法获得任何实例变量，只能获得类的引用。

class Person(object):
    __count = 0
    @classmethod
    def how_many(cls):
        return cls.__count
    @classmethod
    def set_Count(cls,count):
        cls.__count=count
    def __init__(self,name):
        self.name=name
        Person.set_Count(Person.how_many()+1)
print Person.how_many()
p1 = Person('Bob')
print Person.how_many()

类的继承和多态：函数super(CurClass, self)将返回当前类(CurClass)继承的父类，然后调用__init__()方法，用于初始化父类；注意self参数已在super()中传入，在__init__()中将隐式传递，不需要写出（也不能写）;

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

class Teacher(Person):

    def __init__(self, name, gender, course):
        super(Teacher, self).__init__(name, gender)
        self.course=course

t = Teacher('Alice', 'Female', 'English')
print t.name
print t.course

 类型判断：函数isinstance()可以判断一个变量是否是某个类型；isinstance(a, list)

多重继承：Python允许从多个父类继承,一个子类就可以同时获得多个父类的所有功能。

class A(object):
    def __init__(self, a):
        print 'init A...'
        self.a = a

class B(A):
    def __init__(self, a):
        super(B, self).__init__(a)
        print 'init B...'

class C(A):
    def __init__(self, a):
        super(C, self).__init__(a)
        print 'init C...'

class D(B, C):
    def __init__(self, a):
        super(D, self).__init__(a)
        print 'init D...'

多重继承通过 super()调用__init__()方法时，A 虽然被继承了两次，但__init__()只调用一次；

解析类属性的规则：顺序是深度优先，从左到右；先在派生类（D）中查找某个属性,然后搜索 B,然后（递归的）搜索其基类，如果还没有找到，就搜索 C,以此类推；

获取对象信息：type() 函数获取变量的类型，它返回一个 Type 对象：

                    t = Teacher('Alice', 'Female', 'English')

                    type(t)  #=> <class '__main__.Teacher'>

                    dir() 函数获取变量的所有属性：对于实例变量，dir()返回所有实例属性，包括`__class__`这类有特殊意义的属性。

                    getattr() 和 setattr( )函数：获取或者设置对象的属性;

                    getattr(t, 'name') # 获取name属性

                    setattr(t, 'name', 'Adam') # 设置新的name属性

                    getattr(t, 'age') # 获取age属性，但是属性不存在，报错

                    getattr(t, 'age', 20) # 获取age属性，如果属性不存在，就返回默认值20

定制类：

python之异常