python的最最最最最基本语法（3）

模块：在Python中，一个.py文件就称之为一个模块（Module）。

为了避免模块名冲突，Python又引入了按目录来组织模块的方法，称为包（Package）。例如两个名不hello.py的模块分别在china的包和school里的包里，然后呢，现在它们的名字分别为：china.hello与school.hello， 这样就不冲突了吧。

每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录，而不是一个包。

自己写一个模块：（主要学习它的格式），创建一个hello.py的文件，内容如下：

1 #!/usr/bin/python
  2 # -*- coding: utf-8 -*-
  3
  4 'this is a hello module, i am coming '
  5 __author__='yinheyi'
  6
  7 import sys
  8
  9 def test():
 10         args = sys.argv
 11         if len(args) == 1:
 12                 print 'hello,world'
 13                 print '你好,世界!'
 14         elif len(args) == 2:
 15                 print 'hello,%s' % args[1]
 16         else:
 17                 print '你的参数个数不对啊,我的哥!'
 18 if __name__== '__main__':
 19         test()

第2行注释表示.py文件本身使用标准UTF-8编码；

第4行是一个字符串，表示模块的文档注释，任何模块代码的第一个字符串都被视为模块的文档注释；

第5行使用__author__变量把作者写进去，这样当你公开源代码后别人就可以瞻仰你的大名；

注意：

if __name__=='__main__':
    test()

当我们在命令行运行hello模块文件时，Python解释器把一个特殊变量__name__置为__main__，而如果在其他地方导入该hello模块时，则不会置为__main__, 所以我们可以直接运行这个模块哦，用于运行测试。

给模块起一个别名：

import 模块名 as 别名

模块内的变量与函数的作用域：

在一个模块中，我们可能会定义很多函数和变量，但有的函数和变量我们希望给别人使用，有的函数和变量我们希望仅仅在模块内部使用。在Python中，是通过_前缀来实现的。

正常的函数和变量名是公开的（public），可以被直接引用，比如：abc，x123，PI等；

类似__xxx__这样的变量是特殊变量，可以被直接引用，但是有特殊用途，比如上面的__author__，__name__就是特殊变量，hello模块定义的文档注释也可以用特殊变量__doc__访问，我们自己的变量一般不要用这种变量名；

类中，__xxx这样的函数或变量就是非公开的（private），即有__开头的名字；

模块的搜索路经：默认情况下，Python解释器会搜索当前目录、所有已安装的内置模块和第三方模块，搜索路径存放在sys模块的path变量中。

如果我们要添加搜索目录，有两种方法，

一是直接修改sys.path，这种方法在退出python后，会失效的。

>>> import sys
>>> sys.path.append('你自己的路经')

二是设置环境变量PYTHONPATH.可以在.bashrc里添加的，如，export PYTHONPATH = ‘目录‘：$PYTHONPATH

使用__future__模块：比如当我们是python2.7时，而我们想使用python3.4的python的功能时，怎么办呢？我们可以从

__future__模块里，导入我们想要用的功能。如除法：

#这是在python2.7中的
>>> 5/3
1
#导入新的；
>>> from __future__ import division
>>> 5/3
1.6666666666666667

面向对象的编程：它就是把一个对象作为基本单元，这个对象里有数据，也有对数据的操作方法啦。你看看C语言中，是不是以函数 为单元呢？？这就是差别。例如一个水杯，它的元素就是水，它可以的操作有加水，倒水等。

面向对象编程的过程很简单，首先创建一个类（其实，我认为就是一个数据类型啦，如int），然后再创建这个类的对象就可以啦。就好像你定义了一个汽车，然后，根据你的定义造出汽车的实例就可以啦。

类的定义，举个例子：

#这是从 最根类继承的，旧的方式定义Python类允许不从object类继承，但这种编程方式已经严重不推荐使用。任何时 候，如果没有合适的类可以继承，就继承自object类。 

7 class Car（object):
  8 #定义一个含有的属性啦;
  9         color_ = ''
 10         weight_ = 0
 11         __wheel_ = 4  #可以通过__开头开定义私有的属性;
 12 #定义它的方法;
 13         def __init__(self, color, weight, wheel):
 14                 self.color_ = color
 15                 self.weight_ = weight
 16                 self.__wheel_ = wheel
 17         def get_color(self):
 18                 return self.color_
 19         def get_weight(self):
 20                 return self.weight_
 21         def get_wheel(self):
 22                 return self.__wheel_
 23
 24 baoma = Car('red',80,4)
 25 print baoma.get_color()
 26 print baoma.get_weight()
 27 print baoma.get_wheel()

输出为：

red
80
4

总结：

类的私有属性：
　　__private_attrs  两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs
类的方法
　　__private_method 两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用slef.__private_methods

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

双下划线开头的实例变量是不是一定不能从外部访问呢？其实也不是。不能直接访问__name是因为Python解释器对外把__name变量改成了_Student__name，所以，仍然可以通过_Student__name来访问__name变量，但是不同版本的Python解释器可能会把__name改成不同的变量名。
在类地内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self,且为第一个参数私有的类方法
类的专有方法：
__init__  构造函数，在生成对象时调用
__del__   析构函数，释放对象时使用
__repr__ 打印，转换
__setitem__按照索引赋值
__getitem__按照索引获取值
__len__获得长度
__cmp__比较运算
__call__函数调用
__add__加运算
__sub__减运算
__mul__乘运算
__div__除运算
__mod__求余运算
__pow__称方

类的继承与多态：我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类

定义一个基类：

class Animal(object):
    def run(self):
        print 'Animal is running...'

定义它的子类：

class Tiger(Animal):
    pass
class Dog(Animal):
    def run(self):
        print 'Dog is running...'

class Cat(Animal):
    def run(self):
        print 'Cat is running...'

运行：

tiger = Tiger()
tiger.run()
dog = Dog()
dog.run()
cat = Cat()
cat.run()

输出：

Animal is running...

Dog is running...
Cat is running...

多态：要理解多态，你要知道上面的dog与cat的实例同时属于Animal 与Dog 和Cat类型哦；

当我们定义一个函数时，如果传入的数据类型为Animal的话，我们可以把Animal的实例或着继承Anaimal的类的类型传入这个函数中。

看一个例子：定义一个函数：

def run_twice(animal):
    animal.run()
    animal.run()

然后呢，当我们传入Animal的实例时，run_twice()就打印出：

>>> run_twice(Animal())
Animal is running...
Animal is running...

当我们传入Dog的实例时，run_twice()就打印出：

>>> run_twice(Dog())
Dog is running...
Dog is running...

当我们传入Cat的实例时，run_twice()就打印出：

>>> run_twice(Cat())
Cat is running...
Cat is running...

可以看出：

对于Animal的子类，不必对run_twice()做任何修改，实际上，任何依赖Animal作为参数的函数或者方法都可以不加修改地正常运行，原因就在于多态。

多态的好处就是，当我们需要传入Dog、Cat、时，我们只需要接收Animal类型就可以了，因为Dog、Cat都是Animal类型，然后，按照Animal类型进行操作即可。由于Animal类型有run()方法，因此，传入的任意类型，只要是Animal类或者子类，就会自动调用实际类型的run()方法，这就是多态的意思：

对于一个变量，我们只需要知道它是Animal类型，无需确切地知道它的子类型，就可以放心地调用run()方法，而具体调用的run()方法是作用在Animal、Dog、Cat对象上，由运行时该对象的确切类型决定，这就是多态真正的威力：调用方只管调用，不管细节，而当我们新增一种Animal的子类时，只要确保run()方法编写正确，不用管原来的代码是如何调用的。

这就是著名的“开闭”原则：

对扩展开放：允许新增Animal子类；

对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。

获取对象有信息：

判断基本类型都可以用type()函数判断的，如：

>>> type(132)
<type 'int'>
>>> type('lol')
<type 'str'>>>> type([1,2,3])
<type 'list'>

另外，Python把每种type类型都定义好了常量，放在types模块里，使用之前，需要先导入，可以这这样子：

>>> import types
>>> type('lol')==types.StringType
True
>>> type([])==types.ListType
True
>>> type(str)==types.TypeType
True

对于类的话，可以使用isinstance():

>>> isinstance(dog, Dog)
True

使用dir()函数获取类的对象的属性与方法。使用dir()函数，它返回一个包含字符串的list。

#看看字符串都有哪些属性与方法
>>> dir('lol')
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

如，如__len__方法返回长度。在Python中，如果你调用len()函数试图获取一个对象的长度，实际上，在len()函数内部，它自动去调用该对象的__len__()方法。

然后配合hasattr()，getattr()、setattr()我们可以直接操作一个对象的状态。

hasattr()：判断是否存在某个属性或方法；

getattr():得到是否存在某个属性或方法；

setattr():设置是否存在某个属性或方法；

python作为动态语言，有很多的灵活性。

我们可以动态的能已经定义的实例绑属性与方法哦，也可以给一个类绑定方法的。

#给一个实例绑定属性：
>>> class Car():
...     pass
...
>>> bmw = Car()
>>> bmw.clor = 'red'

#给一个实例邦定一个方法
>>> def get_color(self):
...     return self.color
...
>>> from types import MethodType
>>> bmw.color = MethodType(get_color, bmw, Car)
>>> bmw.color()
'red'

# 给一个类邦定方法
>>> def get_color(self):
...     return self.color
...
>>> from types import MethodType
>>> Car.color = MethodType(get_color, None, Car)

当我们想限制动态绑定的属性的名称时，怎么办呢？那就利用Class的__slots__变量。

为了达到限制的目的，Python允许在定义class的时候，定义一个特殊的__slots__变量，来限制该class能添加的属性：

>>> class Student(object):
...     __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称

#这样的话，我们的Student只能动态绑定 'name'与‘age'这两个动态变量了。

另外，

使用@property装饰器可以把定义的一个方法，变为通过属性来调用的。

还有，很有一些特殊的变量或方法来定制类，如__len__、__str__、__iter__、__getitem__等等等 ，具体可以用到的时候具体查一下的。

python中的错误处理机制：

错误处理机制：try …except…finally

Python的错误其实也是class，所有的错误类型都继承自BaseException。 在python程序中，一旦出现错误的话，它就要一级级的上报，直到某个函数能够处理这个错误，如果最后没有函数可以处理这个错误的话，最后就被python的解释器捕获，打印出错误信息，并退出程序了。

因为错误是一级一级的一报的，所以，不需要在每个可能出错的地方去捕获错误，只要在合适的层次去捕获错误就可以了。

1 #!/usr/bin/python
  2 # -*- coding: utf-8 -*-
  3
  4 try:
  5         r = 10 /0
  6 except ZeroDivisionError, sh:
  7         print '出现错误了,except:',sh
  8 finally:
  9         print 'finally,错误机制结束'
 10 print 'end,程序结束'

输出：

yinheyi@ubuntu:~/python$ ./2.py
出现错误了,except: integer division or modulo by zero
finally,错误机制结束
end,程序结束

我们也可以利用python中的log模块记录错误信息，然后分析错误原因。我们在except下面加入了一个记录错误的语句：

1 #!/usr/bin/python
  2 # -*- coding: utf-8 -*-
  3 import logging
  4 try:
  5         r = 10 /0
  6 except ZeroDivisionError, sh:
  7         print '出现错误了,except:',sh
  8         logging.exception(sh)
  9 finally:
 10         print 'finally,错误机制结束'
 11 print 'end,程序结束'

它的输出为：

yinheyi@ubuntu:~/python$ ./2.py
出现错误了,except: integer division or modulo by zero
ERROR:root:integer division or modulo by zero
Traceback (most recent call last):
  File "./2.py", line 5, in <module>
    r = 10 /0
ZeroDivisionError: integer division or modulo by zero
finally,错误机制结束
end,程序结束

可以用raise抛出错误的，错误也可以自己定义的哦，具体，等着我用到了，我再补冲哈

另外，还有和程序的调试，测试啦等待，现在暂时用不着，不写了就哈。（用于的时候学习代码是效率最高的）

最后，如果你觉得以上内容对你有帮助，作为回报，那就可以打赏一下我这个穷学生吧，以资助我买几本书。

钱也不用太多，您可以选择：2毛，5毛、1元。

如果对你没有帮助，那就算了。