现在的位置: 首页 > 综合 > 正文

Python常用语法

2018年11月01日 ⁄ 综合 ⁄ 共 28619字 ⁄ 字号 小 中 大 ⁄ 评论关闭

python的入门语法和类型

Python的设计目标之一是让源代码具备高度的可读性。它设计时尽量使用其它语言经常使用的标点符号和英语单词，让源代码整体看起来很整洁美观。它不像静态语言如C、Pascal那样需要重复书写声明语句，也不像它们的语法那样经常有特殊情况和惊喜。

缩进

Python开发者有意让违反了缩进规则的程序不能通过编译，以此来强制程序员养成良好的编程习惯。并且在Python语言里，缩进而非花括号或者某种关键字，被用于表示语句块的开始和退出。增加缩进表示语句块的开始，而减少缩进则表示语句块的退出。缩进成为了语法的一部分。例如

if语句：

if age < 21:
print("你不能買酒。")
print("不過你能買口香糖。")
print("這句話處於if語句塊的外面。")

根据PEP的规定，必须使用4个空格来表示每级缩进。使用Tab字符和其它数目的空格虽然都可以编译通过，但不符合编码规范。支持Tab字符和其它数目的空格仅仅是为了兼容很旧的Python程序和某些有问题的编辑器。

语句和控制流

  • if语句，当条件成立时执行语句块。经常与else,elif(相当于else
    if    )配合使用。
  • for语句，遍历列表、字符串、字典、集合等迭代器，依次处理迭代器中的每个元素。
  • while语句，当条件为真时，循环执行语句块。
  • try语句。与except,finally配合使用处理在程序运行中出现的异常情况。
  • class语句。用于定义类型。
  • def语句。用于定义函数和类型的方法。
  • pass语句。表示此行为空，不执行任何操作。
  • assert语句。用于程序调试阶段时测试运行条件是否满足。
  • with语句。Python2.6以后定义的语法，在一个场景中运行语句块。比如，运行语句块前加锁，然后在语句块运行结束后释放它。
  • yield语句。在迭代器函数内使用，用于返回一个元素。自从Python 2.5版本以后。这个语句变成一个运算符。

表达式

Python的表达式写法与C/C++类似。只是在某些写法有所差别。

  • 主要的算术运算符与C/C++类似。+, -, *, /, //, **, ~, %分别表示加法或者取正、减法或者取负、乘法、除法、整除、乘方、取补、取模。>>, <<表示右移和左移。&,
    |, ^    表示二进制的AND, OR, XOR运算。>, <, ==, !=, <=, >=用于比较两个表达式的值，分别表示大于、小于、等于、不等于、小于等于、大于等于。在这些运算符里面，~, |, ^, &, <<, >>必须应用于整数。
  • Python使用and, or, not表示逻辑运算。
  • is, is not用于比较两个变量是否是同一个对象。in, not in用于判断一个对象是否属于另外一个对象。
  • Python支持"列表推导式"（list comprehension），比如计算0-9的平方和:
>>> sum(x * x for x in range(10))285

  • Python使用lambda表示匿名函数。匿名函数体只能是表达式。比如：
>>> add=lambda x, y : x + y>>> add(3,2)5

  • Python使用y if cond else x表示条件表达式。意思是当cond为真时，表达式的值为y，否则表达式的值为x。相当于C++和Java里的cond?y:x。
  • Python区分列表(list)和元组(tuple)两种类型。list的写法是[1,2,3]，而tuple的写法是(1,2,3)。可以改变list中的元素，而不能改变tuple。在某些情况下，tuple的括号可以省略。tuple对于赋值语句有特殊的处理。因此，可以同时赋值给多个变量，比如：
>>> x, y=1, 2 #同时给x,y赋值，最终结果：x=1, y=2

特别地，可以使用以下这种形式来交换两个变量的值：

>>> x, y=y, x #最终结果：y=1, x=2
  • Python使用'(单引号)和"(双引号)来表示字符串。与Perl、Unix Shell语言或者Ruby、Groovy等语言不一样，两种符号作用相同。一般地，如果字符串中出现了双引号，就使用单引号来表示字符串;反之则使用双引号。如果都没有出现，就依个人喜好选择。出现在字符串中的\(反斜杠)被解释为特殊字符，比如\n表示换行符。表达式前加r指示Python不解释字符串中出现的\。这种写法通常用于编写正则表达式或者Windows文件路径。
  • Python支持列表切割(list slices)，可以取得完整列表的一部分。支持切割操作的类型有str, bytes, list, tuple等。它的语法是...[left:right]或者...[left:right:stride]。假定nums变量的值是[1,
    3, 5, 7, 8, 13, 20]    ，那么下面几个语句为真：
  • nums[2:5] == [5, 7, 8] 从下标为2的元素切割到下标为5的元素，但不包含下标为2的元素。
  • nums[1:] == [3, 5, 7, 8, 13, 20] 切割到最后一个元素。
  • nums[:-3] == [1, 3, 5, 7] 从最开始的元素一直切割到倒数第3个元素。
  • nums[:] == [1, 3, 5, 7, 8, 13, 20] 返回所有元素。改变新的列表不会影响到nums。
  • nums[1:5:2] == [3, 7]

函数

Python的函数支持递归、默认参数值、可变参数，但不支持函数重载。为了增强代码的可读性，可以在函数后书写”文档字符串“(Documentation Strings，或者简称docstrings)，用于解释函数的作用、参数的类型与意义、返回值类型与取值范围等。可以使用内置函数help()打印出函数的使用帮助。比如：

复制代码
1 >>> def randint(a, b):
2 ...     "Return random integer in range [a, b], including both end points."
3 ...
4 >>> help(randint)
5 Help on function randint in module __main__:
6  
7 randint(a, b)
8     Return random integer in range [a, b], including both end points.
复制代码

对象的方法

对象的方法是指绑定到对象的函数。调用对象方法的语法是instance.method(arguments)。它等价于调用Class.method(instance,
arguments)。当定义对象方法时，必须显式地定义第一个参数为self，用于访问对象的内部数据。self相当于C++, Java里面的this变量。比如：

复制代码
class Fish:
def eat(self, food):
if food is not None:
            self.hungry=False

#构造Fish的实例：
f=Fish()
#以下两种调用形式是等价的：
Fish.eat(f, "earthworm")
f.eat("earthworm")
复制代码

Python认识一些以”__“开始并以"__"结束的特殊方法名，它们用于实现运算符重载和实现多种特殊功能。

类型

Python采用动态类型系统。在编译的时候，Python不会检查对象是否拥有被调用的方法或者属性，而是直至运行时，才做出检查。所以操作对象时可能会抛出异常。不过，虽然Python采用动态类型系统，它同时也是强类型的。Python禁止没有明确定义的操作，比如数字加字符串。

与其它面向对象语言一样，Python允许程序员定义类型。构造一个对象只需要像函数一样调用类型即可，比如，对于前面定义的Fish类型，使用Fish()。类型本身也是特殊类型type的对象(type类型本身也是type对象)，这种特殊的设计允许对类型进行反射编程。

Python内置丰富的数据类型。与Java、C++相比，这些数据类型有效地减少代码的长度。下面这个列表简要地描述了Python内置数据类型(适用于Python 3.x)：

类型 描述 例子
str 一个由字符组成的不可更改的有串行。在Python 3.x里，字符串由Unicode字符组成。 'Wikipedia'

"Wikipedia"

"""Spanning

multiple

lines"""
bytes 一个由字节组成的不可更改的有串行。 b'Some ASCII'

b"Some ASCII"
list 可以包含多种类型的可改变的有串行 [4.0, 'string', True]
tuple 可以包含多种类型的不可改变的有串行 (4.0, 'string', True)
set, frozenset 与数学中集合的概念类似。无序的、每个元素唯一。 {4.0, 'string', True}

frozenset([4.0, 'string', True])
dict 一个可改变的由键值对组成的无串行。 {'key1': 1.0, 3: False}
int 精度不限的整数 42
float 浮点数。精度与系统相关。 3.1415927
complex 复数 3+2.7j
bool 逻辑值。只有两个值：真、假 True

False

除了各种数据类型，Python语言还用类型来表示函数、模块、类型本身、对象的方法、编译后的Python代码、运行时信息等等。因此，Python具备很强的动态性。

数学运算

Python使用与C、Java类似的运算符，支持整数与浮点数的数学运算。同时还支持复数运算与无穷位数（实际受限于计算机的能力）的整数运算。除了求绝对值函数abs()外，大多数数学函数处于math和cmath模块内。前者用于实数运算，而后者用于复数运算。使用时需要先导入它们，比如：

>>> import math
>>> print(math.sin(math.pi/2))
1.0

fractions模块用于支持分数运算；decimal模块用于支持高精度的浮点数运算。

Python定义求余运行a % b的值处于开区间[0, b)内，如果b是负数，开区间变为(b, 0]。这是一个很常见的定义方式。不过其实它依赖于整除的定义。为了让方程式：b
* (a // b) + a % b = a恒真，整除运行需要向负无穷小方向取值。比如7 // 3的结果是2，而(-7) // 3的结果却是-3。这个算法与其它很多编程语言不一样，需要注意，它们的整除运算会向0的方向取值。

Python允许像数学的常用写法那样连着写两个比较运行符。比如a < b < c与a < b and b < c等价。C++的结果与Python不一样，首先它会先计算a < b，根据两者的大小获得0或者1两个值之一，然后再与c进行比较。

转自：http://www.cnblogs.com/mcdou/archive/2011/08/02/2125016.html

python的C++扩展

      可扩展性是Python的一大特色，一方面，由于Python是解释执行的，这导致运行速度会比编译型语言慢，因此可以通过使用C/C++重写核心部分代码以解决性能上的瓶颈(程序90%的时间再运行10%的代码)；另一方面，可以通过扩展，达到添加整合一些额外的功能以及保持专有源代码的目的。在本文接下来的部分中我们将讨论如何编写C/C++扩展代码，并使用它们的功能。

    我们要建立的是一个可以在Python内运行的C/C++模块，因此需要解决如何使C代码和Python代码能够进行交互以及数据共享。扩展是通过为C代码编写包装函数(类似适配器)实现双向交互和数据共享的。

一．一般的包装模式

每一个包装函数主要做三件事：
1.把输入的Python对象转换为C/C++对象；
2.调用C/C++函数；
3.转换C/C++函数处理的输出结果为Python对象，并返回；

先用一个简单样例描述模块大体的过程：


//wrap.cpp

//1.C代码

#include "Python.h"
int add(int arg1, int arg2)
{

    return arg1 + arg2;
}
//2.add的包装函数：

static PyObject* wrap_add(PyObject *self, PyObject *args)
{

    //把输入的Python对象转换为C/C++能识别的数据

    int arg1, arg2;
    if(!PyArg_ParseTuple(args, "ii", &arg1, &arg2))

    return NULL;
    //调用C/C++函数，得到结果

    int result = add(arg1,arg2);
    //把得到的结果包装成Python对象，并返回

    return (PyObject*)Py_BuildValue("i", result);
}
//3.为模块添加PyMethodDef方法数组

static PyMethodDef wrap_methods[] ={

    {"add", wrap_add, METH_VARARGS},

    {NULL, NULL}
};
//4.增加模块初始化函数InitModule


PyMODINIT_FUNC initwrap (void)
{

    Py_InitModule("wrap ", wrap_methods);
}


   
   把上面的代码编译，生成wrap.pyd。
   Visual Studio 2005编译方法参考：
   http://blog.csdn.net/solo_lxy/archive/2007/07/20/1700515.aspx
   启动控制台切换到相应的工程目录，即可测试生成的模块：
    未命名.jpg 
   (PS:似乎只有Release模式生成的模块才能正常运行)

相关说明
    每个包装函数都有如下形式：
         PyObject
* wrap_function(PyObject *, PyObject * args)
    函数第一个参数，有特殊用途，通常选择忽略。第二个参数是一个PyTuple(PyObject的子类型，和Python中的Tuple对应)，是调用时Python传入的参数。
    函数PyArg_ParseTuple把Python对象转换为C的数据类型，其声明如下:
        int
PyArg_ParseTuple(PyObject* args, char* format, ...);
    参数args必须是一个tuple对象，包含传递过来的参数， format 参数必须是格式化字符串。剩余参数是各个变量的地址，类型要与格式化字符串对应。如：
        int
arg1, arg2;
        PyArg_ParseTuple(args, "ii", &arg1, &arg2);
    函数Py_BuildValue可以说是PyArg_ParseTuple的逆过程，它把C的数据类型包装为Python对象。
        return
(PyObject*)Py_BuildValue("i", result);
    把调用C函数的结果result包装为Python的int对象，并返回。
        static PyMethodDef wrap_methods[] ={
            {"add", wrap_add, METH_VARARGS},
            {NULL, NULL}
        };
    这个数组包含多个数组，其中的每个数组都包含了一个函数的信息，以便解释器能够导入并调用它们，最后一个NULL数组表示列表的结束。METH_VARARGS常量表示参数以元组形式传入。
        PyMODINIT_FUNC initwrap (void)
        {
            Py_InitModule("wrap ", wrap_methods);
        }
    模块初始化函数void initModuleName(),这部分代码在模块被导入的时候被解释器调用。这样所有的包装就已经完成了。

二．C++类的包装



// Example.cpp

class Numbers
{
public:

    Numbers(int first, double second) 

        : m_first( first), m_second(second){}

    double NumMemberMult(void){ return m_first*m_second;}
private:

    int m_first;

    double m_second;
};
static void PyDelNumbers(void *ptr)
{

    Numbers * oldnum = static_cast<Numbers *>(ptr);

    delete oldnum;

    return;
}

PyObject *Example_new_Numbers(PyObject *, PyObject* args)
{

    int arg1;

    double arg2;

    int ok = PyArg_ParseTuple(args,"id",&arg1,&arg2);

    if(!ok) return NULL;

   //动态创建一个新对象


    Numbers *newnum = new Numbers(arg1, arg2);

   //把指针newnum包装成PyCObject对象并返回给解释器


    return PyCObject_FromVoidPtr( newnum, PyDelNumbers);
}

PyObject * Example_Numbers_MemberMult(PyObject *, PyObject* args)
{

    PyObject *pynum = 0;

    int ok = PyArg_ParseTuple( args, "O", &pynum);

    if(!ok) return NULL;

   //把PyCObject转换为void指针


    void * temp = PyCObject_AsVoidPtr(pynum);

   //把void指针转换为一个Numbers对象指针


    Numbers * thisnum = static_cast<Numbers *>(temp);

    //调用函数


    double result = thisnum->NumMemberMult();

    //返回结果 


    return Py_BuildValue("d",result);
}

static PyMethodDef Example_methods[] = {

    {"Numbers", Example_new_Numbers, METH_VARARGS},

    {"NumMemberMult", Example_Numbers_MemberMult, METH_VARARGS},

    {NULL, NULL}
};

PyMODINIT_FUNC initExample (void)
{

    Py_InitModule("Example", Example_methods);
}


   C++类的包装和C函数的包装大同小异，因为对类的包装是对函数的包装，所以仍需要用Python代码对扩展模块进行包装，才可以像类一样的使用。


#example.py
from Example import *

class example(object):

    def __init__(self,arg1,arg2):

        self._base = Numbers(arg1,arg2)

    def MemberMult(self):

        return NumMemberMult(self._base)


    未命名2.jpg 
   这样C++类的包装也完成了。

三．C/C++中创建Python list


static PyObject* Windy_dict(PyObject *self, PyObject *args)
{
    //创建列表

    PyObject *newlist = PyList_New(0);

    PyList_Append(newlist, PyString_FromString("first"));

    PyList_Append(newlist, PyString_FromString("second"));

    PyList_Append(newlist, PyString_FromString("third"));
    //返回给解释器
    return newlist;
}


    创建其它Python对象也类似list的创建，返回给解释器的都是一个对象指针。C/C++对Python对象的解析差不多是创建时的逆过程。具体的对象模型及API可以查阅相关参考文档。


来源：http://bbs.chinaunix.net/thread-1593255-1-1.html


初识PyObject


PyObject是整个Python对象机制的核心

[html] view
plaincopy

  1. [object.h]  
  2. typedef struct _object {  
  3. PyObject_HEAD  
  4. } PyObject;  
[html] view
plaincopy

  1. [object.h]  
  2. #ifdef Py_TRACE_REFS  
  3. /* Define pointers to support a doubly-linked list of all live heap objects. */  
  4. #define _PyObject_HEAD_EXTRA            \  
  5.     struct _object *_ob_next;           \  
  6.     struct _object *_ob_prev;  
  7.   
  8. #define _PyObject_EXTRA_INIT 0, 0,  
  9.   
  10. #else  
  11. #define _PyObject_HEAD_EXTRA  
  12. #define _PyObject_EXTRA_INIT  
  13. #endif  
  14.   
  15. /* PyObject_HEAD defines the initial segment of every PyObject. */  
  16. #define PyObject_HEAD                   \  
  17.     _PyObject_HEAD_EXTRA                \  
  18.     Py_ssize_t ob_refcnt;               \  
  19.     struct _typeobject *ob_type;  

在实际发布的Python中PyObject的定义非常简单

[html] view
plaincopy

  1. [object.h]  
  2. typedef struct _object {  
  3.     int ob_refcnt;//引用计数  
  4.     struct _typeobject *ob_type;  
  5. } PyObject;  

这里的ob_refcnt是引用计数。ob_type？？？让我们看看这个_typeobject，它存储了大量的信息，里面的每一条信息，被称为一个元信息。

[html] view
plaincopy

  1. [object.h]  
  2. typedef struct _typeobject {  
  3.     PyObject_VAR_HEAD  
  4.     const char *tp_name; /* For printing, in format "<module>.<name>" */ 类型名  
  5.     Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */ 对象分配时内存空间大小  
  6.   
  7.     /* Methods to implement standard operations */ 函数指针  
  8.   
  9.     destructor tp_dealloc;  
  10.     printfunc tp_print;  
  11.     getattrfunc tp_getattr;  
  12.     setattrfunc tp_setattr;  
  13.     cmpfunc tp_compare;  
  14.     reprfunc tp_repr;  
  15.   
  16.     /* Method suites for standard classes */  //三组非常重要的操作族  
  17.   
  18.     PyNumberMethods *tp_as_number;  //PyNumberMethods类型定义了作为一个数值对象应该支持的操作  
  19.     PySequenceMethods *tp_as_sequence;  
  20.     PyMappingMethods *tp_as_mapping;  
  21.   
  22.     /* More standard operations (here for binary compatibility) */  
  23.   
  24.     hashfunc tp_hash;  
  25.     ternaryfunc tp_call;  
  26.     reprfunc tp_str;  
  27.     getattrofunc tp_getattro;  
  28.     setattrofunc tp_setattro;  
  29.   
  30.     /* Functions to access object as input/output buffer */  
  31.     PyBufferProcs *tp_as_buffer;  
  32.   
  33.     /* Flags to define presence of optional/expanded features */  
  34.     long tp_flags;  
  35.   
  36.     const char *tp_doc; /* Documentation string */  
  37.   
  38.     /* Assigned meaning in release 2.0 */  
  39.     /* call function for all accessible objects */  
  40.     traverseproc tp_traverse;  
  41.   
  42.     /* delete references to contained objects */  
  43.     inquiry tp_clear;  
  44.   
  45.     /* Assigned meaning in release 2.1 */  
  46.     /* rich comparisons */  
  47.     richcmpfunc tp_richcompare;  
  48.   
  49.     /* weak reference enabler */  
  50.     Py_ssize_t tp_weaklistoffset;  
  51.   
  52.     /* Added in release 2.2 */  
  53.     /* Iterators */  
  54.     getiterfunc tp_iter;  
  55.     iternextfunc tp_iternext;  
  56.   
  57.     /* Attribute descriptor and subclassing stuff */  
  58.     struct PyMethodDef *tp_methods;  
  59.     struct PyMemberDef *tp_members;  
  60.     struct PyGetSetDef *tp_getset;  
  61.     struct _typeobject *tp_base;  
  62.     PyObject *tp_dict;  
  63.     descrgetfunc tp_descr_get;  
  64.     descrsetfunc tp_descr_set;  
  65.     Py_ssize_t tp_dictoffset;  
  66.     initproc tp_init;  
  67.     allocfunc tp_alloc;  
  68.     newfunc tp_new;  
  69.     freefunc tp_free; /* Low-level free-memory routine */  
  70.     inquiry tp_is_gc; /* For PyObject_IS_GC */  
  71.     PyObject *tp_bases;  
  72.     PyObject *tp_mro; /* method resolution order */  
  73.     PyObject *tp_cache;  
  74.     PyObject *tp_subclasses;  
  75.     PyObject *tp_weaklist;  
  76.     destructor tp_del;  
  77.   
  78.     /* Type attribute cache version tag. Added in version 2.6 */  
  79.     unsigned int tp_version_tag;  
  80.   
  81. #ifdef COUNT_ALLOCS  
  82.     /* these must be last and never explicitly initialized */  
  83.     Py_ssize_t tp_allocs;  
  84.     Py_ssize_t tp_frees;  
  85.     Py_ssize_t tp_maxalloc;  
  86.     struct _typeobject *tp_prev;  
  87.     struct _typeobject *tp_next;  
  88. #endif  
  89. } PyTypeObject;</name></module>  

总结：PyObject里面有一个ob_refcnt(引用计数)，一个ob_type(一堆的信息，一堆的函数，一堆这个对象支持的操作)。

转自：http://blog.csdn.net/debugm/article/details/8241759


理解python的staticmethod与classmethod实现

本文源于一时好奇，想要弄清出python的staticmethod()这一builtin方法的实现，查了一些资料（主要是python官方手册了）汇集于此 

python在类中，有三种调用method的方法：普通method，staticmethod和classmethod 
前两个应该都好理解，classmethod就是在调用这个函数的时候，会把调用对象的class object对象隐式地传进去。咦？这个class object不是一个类型？No，在python里面，class object不像静态语言一样是个类型，它在虚拟机中，就是一个对象 
普通method调用需要把自己self作为参数传递，初学的时候怎么着也不能理解，不过看多了就自然熟悉了。比较奇怪的是staticmethod和classmethod不像静态语言一样，通过保留关键字定义，而是使用@staticmethod或者staticmethod()这种builtin函数进行定义。这个@staticmethod到底是个什么东东？ 

Python代码  收藏代码
  1. @staticmethod  
  2. def foo(x):  
  3.     print(x)  



之前用过java，所以第一反应这是个annotation……唔，确实感觉像个AOP的东西，python里把它称作decorator。如果我们要自己实现一个staticmethod，该怎么写呢？ 

研究了下官方的代码，我再改了改，感觉应该这样写： 

Python代码  收藏代码
  1. def foo(x):  
  2.     print(x)  
  3. class StaticMethod(object):  
  4.     def __init__(self, function):  
  5.         print("__init__() called")  
  6.         self.f = function  
  7.     def __get__(self, instance, owner):  
  8.         print("\t__get__() called")  
  9.         print("\tINFO: self = %s, instance =%s, owner = %s" % (self, instance, owner))  
  10.         return self.f  
  11.   
  12. class Class1(object):  
  13.     method = StaticMethod(foo)  
  14.       
  15. if __name__ == '__main__':  
  16.     ins = Class1()  
  17.     print("ins = %s, Class1 = %s" % (ins, Class1))  
  18.     print("ins.method = %s, Class1.method = %s" % (ins.method, Class1.method))  
  19.     ins.method('abc')  
  20.     Class1.method('xyz')  



输出结果是： 

Python代码  收藏代码
  1. __init__() called  
  2. ins = <__main__.Class1 object at 0xece2d0>, Class1 = <class '__main__.Class1'>  
  3.     __get__() called  
  4.     INFO: self = <__main__.StaticMethod object at 0xece5d0>, instance =<__main__.Class1 object at 0xece2d0>, owner = <class '__main__.Class1'>  
  5.     __get__() called  
  6.     INFO: self = <__main__.StaticMethod object at 0xece5d0>, instance =None, owner = <class '__main__.Class1'>  
  7. ins.method = <function foo at 0xeb6c00>, Class1.method = <function foo at 0xeb6c00>  
  8.     __get__() called  
  9.     INFO: self = <__main__.StaticMethod object at 0xece5d0>, instance =<__main__.Class1 object at 0xece2d0>, owner = <class '__main__.Class1'>  
  10. abc  
  11.     __get__() called  
  12.     INFO: self = <__main__.StaticMethod object at 0xece5d0>, instance =None, owner = <class '__main__.Class1'>  
  13. xyz  


嗯，看上去一切都挺顺利，Class1包含了一个变量method，不过这个method其实也是一个特殊处理过的StaticMethod类。这个类中有一个__get__函数，当类被“get”的时候，被访问的时候，会默认把访问者的instance和class信息都传进来。所以我们看到不管是否调用method()这个函数，只要碰着了method，这个函数就会触发，就会打印出当前instance和class信息。虽然ins和Class1的instance各有不同，但__get__函数中只是返回foo函数，所以这里调用method之时就没有区别，调用的都是同一个function对象。 

好的，那么classmethod又如何实现呢？ 

Python代码  收藏代码
  1. def foo2(cls, x):  
  2.     print("foo2's class = ", cls)  
  3.     print(x)  
  4.   
  5. class ClassMethod(object):  
  6.     def __init__(self, function):  
  7.         print("ClassMethod: __init__() called")  
  8.         self.f = function  
  9.     def __get__(self, instance, owner = None):  
  10.         print("\t__get__() called")  
  11.         print("\tINFO: self = %s, instance =%s, owner = %s" % (self, instance, owner))  
  12.         def tmpfunc(x):  
  13.             print("I'm tmpfunc")  
  14.             return self.f(owner, x)  
  15.         return tmpfunc  
  16.   
  17. class Class2(object):  
  18.     method = ClassMethod(foo2)  
  19.   
  20. class Class21(Class2):  
  21.     pass  
  22. if __name__ == '__main__':  
  23.     ins = Class2()  
  24.     print("ins.method = %s, Class2.method = %s, Class21.method = %s" % (ins.method, Class2.method, Class21.method))  
  25.     ins.method('abc')  
  26.     Class2.method('xyz')  
  27.     Class21.method('asdf')  



输出结果是： 

Python代码  收藏代码
  1. ClassMethod: __init__() called  
  2.     __get__() called  
  3.     INFO: self = <__main__.ClassMethod object at 0xdeb250>, instance =<__main__.Class2 object at 0xdeb350>, owner = <class '__main__.Class2'>  
  4.     __get__() called  
  5.     INFO: self = <__main__.ClassMethod object at 0xdeb250>, instance =None, owner = <class '__main__.Class2'>  
  6.     __get__() called  
  7.     INFO: self = <__main__.ClassMethod object at 0xdeb250>, instance =None, owner = <class '__main__.Class21'>  
  8. ins.method = <function tmpfunc at 0xdee050>, Class2.method = <function tmpfunc at 0xdee1e8>, Class21.method = <function tmpfunc at 0xdee270>  
  9.     __get__() called  
  10.     INFO: self = <__main__.ClassMethod object at 0xdeb250>, instance =<__main__.Class2 object at 0xdeb350>, owner = <class '__main__.Class2'>  
  11. I'm tmpfunc  
  12. foo2's class =  <class '__main__.Class2'>  
  13. abc  
  14.     __get__() called  
  15.     INFO: self = <__main__.ClassMethod object at 0xdeb250>, instance =None, owner = <class '__main__.Class2'>  
  16. I'm tmpfunc  
  17. foo2's class =  <class '__main__.Class2'>  
  18. xyz  
  19.     __get__() called  
  20.     INFO: self = <__main__.ClassMethod object at 0xdeb250>, instance =None, owner = <class '__main__.Class21'>  
  21. I'm tmpfunc  
  22. foo2's class =  <class '__main__.Class21'>  
  23. asdf  



可以看出，classmethod和staticmethod的实现方法是大同小异。staticmethod比较简单，直接返回self.f变量就好了，而classmethod不行，需要把调用时候的class类型信息传给foo2函数，这个函数根据接收的class信息来作不同的工作。（不过我现在也没有想到可以用来做些什么） 

有个地方值得注意，可能同志们刚才也已经想到了，我一定必须要定义一个tempfunc，再返回它才能完成工作吗？可不可以不要 

Java代码  收藏代码
  1. def tmpfunc(x):  
  2.             print("I'm tmpfunc")  
  3.             return self.f(owner, x)  
  4.         return tmpfunc  



而直接返回一个 

Java代码  收藏代码
  1. return self.f(owner, *args)  


？ 

我刚试了一把，直接传args默认参数是不行的，因为__get__被调用的时候，还没有把参数传进来。只有return tmpfunc之后，Class2.method('xyz')的参数才挂在tmpfunc之上。 

当然，如果有朋友成功做到了，请一定留言告诉我XD 

小结：看来staticmethod和classmethod实现不是很困难，多亏了__get__函数帮忙。前文也提到__get__被调用时会把instance和class信息都填进来，真是帮了很大忙。但是，这个__get__函数到底又是怎么一回事？为什么这么神奇？这里卖个关子，本文先不讲了，下篇博文再看看这个__get__函数吧 

转自：http://luozhaoyu.iteye.com/blog/1506376


import,reload,__import__在python中的区别

import
作用：
导入/引入一个python标准模块，其中包括.py文件、带有__init__.py文件的目录。
e.g：

[python] view
plaincopy

  1. import module_name[,module1,...]  
  2. from module import *|child[,child1,...]  

说明：
多次重复使用import语句时，不会重新加载被指定的模块，只是把对该模块的内存地址给引用到本地变量环境。
测试：

[python] view
plaincopy

  1. a.py  
  2. #!/usr/bin/env python    
  3. #encoding: utf-8  
  4. import os  
  5. print 'in a',id(os)  
  6.   
  7. m.py  
  8. #!/usr/bin/env python    
  9. #encoding: utf-8  
  10. import a   #第一次会打印a里面的语句  
  11. import os  #再次导入os后，其内存地址和a里面的是一样的，因此这里只是对os的本地引用  
  12. print 'in c',id(os)  
  13. import a  #第二次不会打印a里面的语句，因为没有重新加载  


reload
作用：
对已经加载的模块进行重新加载，一般用于原模块有变化等特殊情况，reload前该模块必须已经import过。
e.g：
import os
reload(os)
说明：
reload会重新加载已加载的模块，但原来已经使用的实例还是会使用旧的模块，而新生产的实例会使用新的模块；reload后还是用原来的内存地址；不能支持from。。import。。格式的模块进行重新加载。
测试：

[python] view
plaincopy

  1. a.py  
  2. #!/usr/bin/env python    
  3. #encoding: utf-8  
  4. import os  
  5. print 'in a',id(os)  
  6.   
  7. m.py  
  8. #!/usr/bin/env python    
  9. #encoding: utf-8  
  10. import a   #第一次import会打印a里面的语句  
  11. print id(a) #原来a的内存地址  
  12. reload(a)  #第二次reload还会打印a里面的语句，因为有重新加载  
  13. print id(a) #reload后a的内存地址，和原来一样  

扩展：
上面说了，在特殊情况的下才会使用reload函数；除了原来模块文件有修改外，还有哪些情况需要使用reload函数呢，这里举个例子。

[python] view
plaincopy

  1. #!/usr/bin/env python    
  2. #encoding: utf-8  
  3. import sys   #引用sys模块进来，并不是进行sys的第一次加载  
  4. reload(sys)  #重新加载sys  
  5. sys.setdefaultencoding('utf8')  ##调用setdefaultencoding函数  

上面的代码是正确的，再测试下面的代码

[python] view
plaincopy

  1. #!/usr/bin/env python    
  2. #encoding: utf-8  
  3. import sys     
  4. sys.setdefaultencoding('utf8')   

上面的测试会失败，那么为什么要在调用setdefaultencoding时必须要先reload一次sys模块呢？因为这里的import语句其实并不是sys的第一次导入语句，也就是说这里其实可能是第二、三次进行sys模块的import，这里只是一个对sys的引用，只能reload才能进行重新加载；那么为什么要重新加载，而直接引用过来则不能调用该函数呢？因为setdefaultencoding函数在被系统调用后被删除了，所以通过import引用进来时其实已经没有了，所以必须reload一次sys模块，这样setdefaultencoding才会为可用，才能在代码里修改解释器当前的字符编码。试试下面的代码，同样会报错：

[python] view
plaincopy

  1. #!/usr/bin/env python    
  2. #encoding: utf-8  
  3. import sys    
  4. reload(sys)   
  5. sys.setdefaultencoding('utf8')    
  6. del sys.setdefaultencoding   ##删除原来的setdefaultencoding函数     
  7. sys.setdefaultencoding('gb2312')  

那么到底是谁在之前就导入sys并且调用了setdefaultencoding函数呢？答案就在python安装目录的Lib文件夹下，有一个叫site.py的文件【python2.6】，在里面可以找到main() --> setencoding()-->sys.setdefaultencoding(encoding),因为这个site.py每次启动python解释器时会自动加载，所以main函数每次都会被执行，setdefaultencoding函数一出来就已经被删除了。

__import__
作用：
同import语句同样的功能，但__import__是一个函数，并且只接收字符串作为参数，所以它的作用就可想而知了。其实import语句就是调用这个函数进行导入工作的，import sys <==>sys = __import__('sys')
e.g：

__import__(module_name[, globals[, locals[, fromlist]]]) #可选参数默认为globals(),locals(),[]
__import__('os')    
__import__('os',globals(),locals(),['path','pip'])  #等价于from os import path, pip

说明：

通常在动态加载时可以使用到这个函数，比如你希望加载某个文件夹下的所用模块，但是其下的模块名称又会经常变化时，就可以使用这个函数动态加载所有模块了，最常见的场景就是插件功能的支持。

扩展：
既然可以通过字符串来动态导入模块，那么是否可以通过字符串动态重新加载模块吗？试试reload('os')直接报错，是不是没有其他方式呢?虽然不能直接reload但是可以先unimport一个模块，然后再__import__来重新加载模块。现在看看unimport操作如何实现，在python解释里可以通过globals(),locals(),vars(),dir()等函数查看到当前环境下加载的模块及其位置，但是这些都只能看不能删除，所以无法unimport；不过除此之外还有一个地方是专门存放模块的，这就是sys.modules，通过sys.modules可以查看所有的已加载并且成功的模块，而且比globals要多，说明默认会加载一些额外的模块，接下来就是unimport了。

[python] view
plaincopy

  1. #!/usr/bin/env python    
  2. #encoding: utf-8  
  3. import sys  
  4. __import__('a')      #第一次导入会打印消息  
  5. del sys.modules['a']   #unimport  
  6. __import__('a')    #再次导入还是会打印消息，因为已经unimport一次了  
  7. __import__('a')    #这次就不会打印消息了  

转自：http://blog.csdn.net/five3/article/details/7762870


Python的getattr(),setattr(),delattr(),hasattr()

getattr()函数是Python自省的核心函数，具体使用大体如下：

获取对象引用getattr
Getattr用于返回一个对象属性，或者方法

Python代码
  1. class A:
      
  2.     def __init__(self):
      
  3.         self.name
    =     'zhangjing'  
  4. 　　  #self.age='24'
  5.     def method(self):
      
  6.         print"method
    print"      
  7.   
  8. Instance = A()   
  9. print getattr(Instance , 'name, 'not
    find'    ) #如果Instance 对象中有属性name则打印self.name的值，否则打印'not
    find'
  10. print getattr(Instance , 'age', 'not
    find'    )   #如果Instance 对象中有属性age则打印self.age的值，否则打印'not
    find'
  11. print getattr(a, 'method', 'default')
      
  12. #如果有方法method，否则打印其地址，否则打印default   
  13. print getattr(a, 'method', 'default')()
      
  14. #如果有方法method，运行函数并打印None否则打印default  


注：使用getattr可以轻松实现工厂模式。 
例：一个模块支持html、text、xml等格式的打印，根据传入的formate参数的不同，调用不同的函数实现几种格式的输出

 

Python代码
    1. import statsout
        
    2. def output(data,
      format=      "text"):                             
        
    3.      output_function = getattr(statsout, "output_%s" %
      format)   
    4.     return output_function(data)  

 

setattr( object, name, value)

This is the counterpart of getattr(). The arguments
are an object, a string and an arbitrary value. The string may name an existing
attribute or a new attribute. The function assigns the value to the attribute,
provided the object allows it. For example, setattr(x,
'foobar', 123) is equivalent to
x.foobar = 123.

 这是相对应的getattr()。参数是一个对象,一个字符串和一个任意值。字符串可能会列出一个现有的属性或一个新的属性。这个函数将值赋给属性的。该对象允许它提供。例如,setattr(x,“foobar”,123)相当于x.foobar = 123。

delattr(       object, name)

This is a relative of setattr(). The arguments are
an object and a string. The string must be the name of one of the object’s
attributes. The function deletes the named attribute, provided the object allows
it. For example, delattr(x, 'foobar') is
equivalent to del x.foobar.

与setattr()相关的一组函数。参数是由一个对象(记住python中一切皆是对象)和一个字符串组成的。string参数必须是对象属性名之一。该函数删除该obj的一个由string指定的属性。delattr(x, 'foobar')=del x.foobar

 

 

  • hasattr用于确定一个对象是否具有某个属性。

    语法：
 hasattr(object, name) -> bool
判断object中是否有name属性，返回一个布尔值。

>>> li=["zhangjing","zhangwei"]

>>> getattr(li,"pop")
<built-in method pop of list object at 0x011DF6C0>
>>> li.pop
<built-in method pop of list object at 0x011DF6C0>

>>> li.pop()
'zhangwei'

>>> getattr(li,"pop")()
'zhangjing'

>>>getattr(li, "append")("Moe") 

转自：http://www.cnblogs.com/zhangjing0502/archive/2012/05/16/2503702.html

原文地址：Python中list、tuple、dict区别作者：张哲_____
  1. Dictionary 是 Python 的内置数据类型之一, 它定义了键和值之间一对一的关系。
  2.  每一个元素都是一个 key-value 对, 整个元素集合用大括号括起来
  3.  您可以通过 key 来引用其值, 但是不能通过值获取 key
  4.  在一个 dictionary 中不能有重复的 key。给一个存在的 key 赋值会覆盖原有的值。  在任何时候都可以加入新的 key-value 对。这种语法同修改存在的值是一样的。
  5.  当使用 dictionary 时, 您需要知道: dictionary 的 key 是大小写敏感的
  6.  Dictionary 不只是用于存储字符串。Dictionary 的值可以是任意数据类型, 包括字符串, 整数, 对象, 甚至其它的 dictionary。在单个 dictionary 里, dictionary 的值并不需要全都是同一数据类型, 可以根据需要混用和匹配。  Dictionary 的 key 要严格多了, 但是它们可以是字符串, 整数和几种其它的类型 (后面还会谈到这一点) 。也可以在一个 dictionary 中混用和配匹 key 的数据类型
  7.  del 允许您使用 key 从一个 dictionary 中删除独立的元素。
  8.  clear 从一个 dictionary 中清除所有元素。注意空的大括号集合表示一个没有元素的 dictionary。
 
  1.  list是一个使用方括号括起来的有序元素集合。
  2.  List 可以作为以 0 下标开始的数组。任何一个非空 list 的第一个元素总是 li[0]
  3.  负数索引从 list 的尾部开始向前计数来存取元素。任何一个非空的 list 最后一个元素总是 li[-1]。 如果负数索引使您感到糊涂, 可以这样理解: li[-n] == li[len(li) - n]。 所以在这个 list 里, li[-3] == li[5 - 3] == li[2]。
  4.  您可以通过指定 2 个索引得到 list 的子集, 叫做一个 “slice” 。返回值是一个新的 list, 它包含了 list 中按顺序从第一个 slice 索引 (这里为 li[1]) 开始, 直到但是不包括第二个 slice 索引 (这里为li[3]) 的所有元素。
  5.  如果将两个分片索引全部省略, 这将包括 list 的所有元素。但是与原始的名为 li 的 list 不同, 它是一个新 list, 恰好拥有与 li 一样的全部元素。li[:] 是生成一个 list 完全拷贝的一个简写。
  6.   append 向 list 的末尾追加单个元素。
  7.  insert 将单个元素插入到 list 中。数值参数是插入点的索引。请注意, list 中的元素不必唯一, 有有两个独立的元素具有 'new' 这个相同的值。
  8.   extend 用来连接 list。请注意不要使用多个参数来调用 extend, 要使用一个 list 参数进行调用。
  9.  Lists 的两个方法 extend 和 append 看起来类似, 但实际上完全不同。 extend 接受一个参数, 这个参数总是一个 list, 并且添加这个 list 中的每个元素到原 list 中
  10.  另一方面, append 接受一个参数, 这个参数可以是任何数据类型, 并且简单地追加到 list 的尾部。 在这里使用一个含有 3 个元素的 list 参数调用 append 方法。
  11.  index 在 list 中查找一个值的首次出现并返回索引值。
  12.  要测试一个值是否在 list 内, 使用 in, 如果值存在, 它返回 True, 否则返为 False 。
  13.  remove 从 list 中删除一个值的首次出现。
  14.  pop 是一个有趣的东西。它会做两件事: 删除 list 的最后一个元素, 然后返回删除元素的值。请注意, 这与 li[-1] 不同, 后者返回一个值但不改变 list 本身。也不同于 li.remove(value), 后者改变 list 但并不返回值。
  15.  Lists 也可以用 + 运算符连接起来。 list = list + otherlist 相当于 list.extend(otherlist)。 但 +运算符把一个新 (连接后) 的 list 作为值返回, 而 extend 只修改存在的 list。 也就是说, 对于大型 list 来说, extend 的执行速度要快一些。
  16.   Python 支持 += 运算符。 li += ['two'] 等同于 li.extend(['two'])。 += 运算符可用于 list, 字符串和整数, 并且它也可以被重载用于用户自定义的类中。
  17.  * 运算符可以作为一个重复器作用于 list。 li = [1, 2] * 3 等同于 li = [1, 2] + [1, 2] + [1, 2], 即将三个 list 连接成一个。
 
  1.  Tuple 是不可变 list。 一旦创建了一个 tuple 就不能以任何方式改变它。
  2.  定义 tuple 与定义 list 的方式相同, 除了整个元素集是用小括号包围的而不是方括号。
  3.   Tuple 的元素与 list 一样按定义的次序进行排序。 Tuples 的索引与 list 一样从 0 开始, 所以一个非空 tuple 的第一个元素总是 t[0]。
  4.   负数索引与 list 一样从 tuple 的尾部开始计数。
  5.   与 list 一样分片 (slice) 也可以使用。注意当分割一个 list 时, 会得到一个新的 list ；当分割一个tuple 时, 会得到一个新的 tuple。
  6.  Tuple 没有方法：没有 append 或 extend 方法、没有 remove 或 pop 方法、没有 index 方法、可以使用 in 来查看一个元素是否存在于 tuple 中。

python的list,dict,tuple比较和应用

python提供了好多的数据结构，主要是分list,dict,tuple（数组，字典，元组）

1.list（数组）

数组的方法运用，应该有写过程序的都知道啦

包括二维三维，下面我只说几个方法

 

x代表数组中的元素，i代表位置

a) append(x) 把元素x添加到数组的尾部

b) insert(i,x) 把元素x 插入到位置i

c) remove(x) 删除第一个元素x

d) pop(i) 删除第i个元素，并返回这个元素。若调用pop()则删除最后一个元素

e) index(x) 返回数组中第一个值为x的位置。如果没有匹配的元素会抛出一个错误

f) count(x) 返回x在数组中出现的次数

g) sort() 对数组中的元素进行排序

h) reverse() 对数组中的元素用倒序排序

2.dict（字典）

这一个有必要说多一些东西，因为比较好用，而且在别的语言里也较少

字典（Dictionary）是一种映射结构的数据类型，由无序的“键－值对”组成。字典的键必须是不可改变的类型，如：字符串，数字，tuple；值可以为任何python数据类型。

1)、新建字典
>>> dict1={}      #建立一个空字典
>>> type(dict1)
<type ‘dict’>

2)、增加字典元素：两种方法
>>> dict1['a']=1    #第一种
>>> dict1
{’a': 1}
#第二种：setdefault方法
>>> dict1.setdefault(’b',2)
2
>>> dict1
{’a': 1, ‘b’: 2}

3)、删除字典
#删除指定键－值对
>>> dict1
{’a': 1, ‘b’: 2}
>>> del dict1['a']      #也可以用pop方法，dict1.pop(’a')
>>> dict1
{’b': 2}
#清空字典
>>> dict1.clear()
>>> dict1         #字典变为空了
{}
#删除字典对象
>>> del dict1

4)、字典的方法
1)get(key,default=None) 
返回键值key对应的值；如果key没有在字典里，则返回default参数的值，默认为None

>>> dict1         #空的字典
{}
>>> dict1.get(’a')   #键‘a’在dict1中不存在，返回none
>>> dict1.get(’d1′,’no1′)   #default参数给出值’no1′，所以返回’no1′
‘no1′
>>> dict1['a']=’no1′      #插入一个新元素
>>> dict1
{’a': ‘1111′}
>>> dict1.get(’a')      #现在键’a'存在，返回其值
‘1111′

(2)clear
清空字典

(3)has_key(key)
如果key出现在dict里则返回True；否则返回False
>>> dict1
{’a': ‘1111′}
>>> dict1.has_key(’b')
False
>>> dict1.has_key(’a')
True

(4)items
返回dict的（键，值）tuple对的一个列表
>>> dict1
{’a': ‘no1′, ‘b’: ‘2222′}
>>> dict1.items()
[('a', 'no1'), ('b', '2222')]

(5)keys   返回dict的键列表
(6)values 返回dict的值列表
>>> dict1
{’a': ‘no1′, ‘b’: ‘2222′}
>>> dict1.keys()
['a', 'b']
>>> dict1.values()
['no1', '2222']

(7)setdefault(key,default=None)
如果dict中有key，则返回key值，如果没有找到key，则在dict中加上该key，值由default参数给出，默认None

(8)update(dict2)
把dict2的元素加入到dict中去，键字重复时会覆盖dict中的键值
>>> dict2
{’c': ‘3333′, ‘b’: ‘no2′}
>>> dict1                  #dict2和dict1的键‘b’重复
{’a': ‘no1′, ‘b’: ‘2222′}
>>> dict1.update(dict2)     #调用update后，dict1的键’b'值被覆盖了
>>> dict1
{’a': ‘no1′, ‘c’: ‘3333′, ‘b’: ‘no2′}

(9)popitem
删除任意键－值对，并返回该键－值对，如字典为空，则产生异常
>>> dict1
{’b': ‘no2′}
>>> dict1.popitem()
(’b', ‘no2′)
>>> dict1
{}
>>> dict1.popitem()
Traceback (most recent call last):
File “<interactive input>”, line 1, in <module>
KeyError: ‘popitem(): dictionary is empty’

(10)pop(key,[d])
删除指定键字的键－值对，并返回该键对应的值   ＃第二个参数不知道怎么用
>>> dict1
{’a': ‘no1′, ‘c’: ‘3333′, ‘b’: ‘no2′}
>>> dict1.pop(’a')
‘no1′
>>> dict1
{’c': ‘3333′, ‘b’: ‘no2′}

(11)copy
返回字典的一个浅拷贝

#以下方法目前还不知道怎么用
(12)fromkeys
(13)iteritems
(14)iterkeys
(15)itervalues

3.tuple(元组)

tuple是python中一个相对简单的类型，它的特点是：有顺序的、不可变的。因此，很显然地tuple有像list 和string一样的 indexing和slicing（分片）的功能，可以通过标号对成员进行访问。同时由于tuple是不可变的，因此试图改变tuple成员的是非法的。 不过由于tuple中的成员可以是list，而list是可变的，因此改变tuple成员的成员是可行的。这怎么理解呢？tuple中保存的中是各个成员 的指针，所说的tuple不可变，也就是说指向各个成员的地址是不可变的。更改作为tuple成员的list里的成员，并不需要变更在tuple中指向这
个list的指针，因此tuple并没有改变。

内置函数tuple([seq])用于把seq转换成tuple。此外，与list和string不同，tuple没有专属的函数。

tuple的表示形式如下：

  • （成员1, 成员2…）

考虑只有一个成员的例子，(成员1)，由于小括号也用于表达式的分组，这就会产生一个问题，当你写下了：

  • T=(23)

这一行代码的时候，python怎么知道你是要把23这个整数赋予T呢，还是要把只有一个成员的tuple给T呢。所以，python规定，这种形式表示把T赋为整数23。而只有一个成员的tuple应该用如下的方式表示：

  • T=（23,）

即在唯一的成员后面加上一个逗号。

4.总结一下：

list是顺序的，可变的。
dictrionary是无顺序的，可变的
tuple是顺序的，不可变的。

三者最好是结合起来用，个有个的优点，例如：

a=((1,”abc”),(2,”efg”),(3,”ghi”))
如果我选择1的话，如何返回abc

a=((1,"abc"),(2,"efg"),(3,"ghi"))
>>> dict(a)[1]
'abc'
 

python getopt使用



python中 getopt 模块，
该模块是专门用来处理命令行参数的


函数getopt(args, shortopts, longopts = [])

参数args一般是sys.argv[1:]
shortopts  短格式 (-) 

longopts 长格式(--) 



命令行中输入：
python test.py -i 127.0.0.1 -p 80 55 66


python test.py --ip=127.0.0.1 --port=80 55 66


下面的代码：


try:
options,args = getopt.getopt(sys.argv[1:],"hp:i:",["help","ip=","port="])
except getopt.GetoptError:
sys.exit()


for name,value in options:
if name in ("-h","--help"):
usage()
if name in ("-i","--ip"):
print 'ip is----',value
if name in ("-p","--port")

print 'port is----',value




options,args = getopt.getopt(sys.argv[1:],"hp:i:",["help","ip=","port="])


“hp:i:”
短格式 --- h 后面没有冒号：表示后面不带参数，p：和 i：后面有冒号表示后面需要参数


["help","ip=","port="]


长格式 --- help后面没有等号=，表示后面不带参数，其他三个有=，表示后面需要参数


返回值 options 是个包含元祖的列表，每个元祖是分析出来的格式信息，比如 [('-i','127.0.0.1'),('-p','80')] ;
 args 是个列表，包含那些没有‘-’或‘--’的参数，比如：['55','66']


注意：定义命令行参数时，要先定义带'-'选项的参数，再定义没有‘-’的参数






转自：http://blog.csdn.net/tianzhu123/article/details/7655499
返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞