精华内容
下载资源
问答
  • 职称英语常用语法详解职称英语常用语法详解职称英语常用语法详解职称英语常用语法详解
  • 高中英语常用语法.doc

    2021-09-28 18:22:11
    高中英语常用语法.doc
  • 为了广大高考生理清英语语法头绪而传 希望大家喜欢
  • 英语四级常用语法归类大全.doc
  • 最系统的语法归纳级词汇固定搭配 适合大学四六级备考学生短期突破语法常用搭配难关
  • 此文档对英语语法特别有帮助,是概要的讲解了语法的各各方面。
  • 对于初学英语的学员来说,是比较有用而且实用的资料。
  • 小学英语常用句型与语法.doc
  • MarkDown常用语法

    2020-10-02 17:27:19
    MarkDown常用语法 前言 ​ 工欲善其事必先利其器,我们在学习的过程中,做好笔记是很重要的,俗话说的好:好记性不如烂笔头,推荐使用一款简洁的Markdown编辑工具Typora点我下载 百度百科资料:Markdown是一种轻量...

    MarkDown常用语法

    前言

    ​ 工欲善其事必先利其器,我们在学习的过程中,做好笔记是很重要的,俗话说的好:好记性不如烂笔头,推荐使用一款简洁的Markdown编辑工具Typora点我下载

    百度百科资料:Markdown是一种轻量级标记语言,创始人为约翰·格鲁伯(英语:John Gruber)。 它允许人们使用易读易写的纯文本格式编写文档,然后转换成有效的XHTML(或者HTML)文档。这种语言吸收了很多在电子邮件中已有的纯文本标记的特性。

    由于Markdown的轻量化、易读易写特性,并且对于图片,图表、数学式都有支持,目前许多网站都广泛使用Markdown来撰写帮助文档或是用于论坛上发表消息。 如GitHubRedditDiaspora、[Stack Exchange](https://baike.baidu.com/item/Stack Exchange/13777796)、OpenStreetMapSourceForge简书等,甚至还能被使用来撰写电子书


    常用的基本语法


    Markdown有序无序列表

    有序列表使用数字加上.号来表示,如:

    1. one
    2. two
    3. three

    无序列表使用星号(*)、加号(+)或是减号(-)作为列表标记,这些标记后面要添加一个空格,然后再填写内容,如:

    • one
    • two
    • three

    Markdown列表嵌套

    列表嵌套在子列表中的选项前面添加四个空格即可,也就是一个tab键,如:

    1. title
      • one
      • two
      • three

    Markdown标题

    井号(#)加空格,一个井号代表一级标题,两个代表二级标题,以此类推,最多六级标题。如:

    # 我是一级标题

    ## 我是二级标题

    ### 我是三级标题

    #### 我是四级标题

    ##### 我是五级标题

    ###### 我是六级标题

    Markdown字体

    • 斜体 ,文本前后使用一个星号(*)或者下划线(_
    • 粗体,文本前后使用两个星号(*)或者下划线(_
    • 粗斜体,文本前后使用三个星号(*)或者下划线(_

    如:

    *斜体*

    _斜体_

    **粗体**

    __粗体__

    ***斜粗体***

    ___斜粗体___

    Markdown分割线

    分割线使用三个或三个以上的星号(*)、减号(-)、底线(_)来建立一个分割线,其中行内不允许有其他东西,如:

    ***

    ---

    ___

    Markdown删除线

    删除线只需在文字两端加上两个波浪线(~~)即可,如:

    我是删除线

    Markdown下划线

    下划线使用HTML的 <u>标签来实现,如:

    <u>我是下划线</u>

    Markdown脚注

    脚注是对文本的补充说明,使用[^需要注明的文本],移动到脚注上面会出现自定义的文本信息,如:

    人生苦短,该当奋起直追,我若待明日,万事成蹉跎。[^老王]

    [^老王]: 一个不甘落后的95后小青年

    Markdown区块

    区块就是你输入的标签它占了以整行就是区块,这个只是一个简单的定义,现在可以这么来理解。使用大于号(>)加上空格,区块是可以嵌套的,一个 > 符号是最外层,两个 > 符号是第一层嵌套,以此类推如:

    > 我是第一层区块QAQ~~

    >> 我是第二层区块QAQ~~

    >>> 我是第二层区块QAQ~~

    Markdown链接

    链接创建使用<链接地址>或者[链接名称](链接地址),如:

    <www.baidu.com>

    [baidu](www.baidu.com)

    Markdown图片

    ![img](图片地址)

    alt python

    Markdown代码

    段落上的函数或片段的代码可以使用反引号(`)包起来转义,也可以使用 ``` 包裹一段代码,并指定一种语言(也可以不指定)

    Markdown表格

    制作表格使用 | 来分隔不同的单元格,使用 - 来分隔表头和其他行。

    |  表头   | 表头  |
    |  ----  | ----  |
    | 单元格  | 单元格 |
    | 单元格  | 单元格 |
    

    对齐方式:

    • -:设置内容和标题栏居右对齐。
    • :-设置内容和标题栏居左对齐。
    • :-:设置内容和标题栏居中对齐。
    | 左对齐 | 右对齐 | 居中对齐 |
    | :-----| ----: | :----: |
    | 单元格 | 单元格 | 单元格 |
    | 单元格 | 单元格 | 单元格 |
    

    在这里插入图片描述

    展开全文
  • 程序员的英语pdf,包含最简单的语法常用句式,常用单词等,通过黑客、物联网、大数据等相关内容的文章进行解析。
  • 英语四级常用词汇句型语法知识归纳.doc
  • Python常用语法

    千次阅读 2014-03-25 14:57:33
    它设计时尽量使用其它语言经常使用的标点符号和英语单词,让源代码整体看起来很整洁美观。它不像静态语言如C、Pascal那样需要重复书写声明语句,也不像它们的语法那样经常有特殊情况和惊喜。 缩进 Python...

    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使用andornot表示逻辑运算。
    • 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()外,大多数数学函数处于mathcmath模块内。前者用于实数运算,而后者用于复数运算。使用时需要先导入它们,比如:

    >>> 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 < ca < 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 plain copy
    1. [object.h]  
    2. typedef struct _object {  
    3. PyObject_HEAD  
    4. } PyObject;  
    [html]  view plain copy
    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 plain copy
    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 plain copy
    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 plain copy
    1. import module_name[,module1,...]  
    2. from module import *|child[,child1,...]  
    说明:
    多次重复使用import语句时,不会重新加载被指定的模块,只是把对该模块的内存地址给引用到本地变量环境。
    测试:
    [python]  view plain copy
    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 plain copy
    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 plain copy
    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 plain copy
    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 plain copy
    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 plain copy
    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



    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/marvin521/article/details/18958089
    展开全文
  • apt常用语法

    2017-02-10 14:50:08
    ap用法:apt-get [选项] 命令 apt-get [选项] install|remove pkg1 [pkg2 …]apt-get [选项] ... 最常用的命令是update(更新) 和install(安装)。命令: update - 重新获取软件包列表 upgrade - 进行更新 install -

    ap用法:

    apt-get [选项] 命令 apt-get [选项] install|remove pkg1 [pkg2 …]

    apt-get [选项] source pkg1 [pkg2 …]

    apt-get 是一个下载安装软件包的简单命令行接口。 最常用的命令是update(更新) 和install(安装)。

    命令:

    update - 重新获取软件包列表

    upgrade - 进行更新

    install - 安装新的软件包

    remove - 移除软件包

    autoremove - 自动移除全部不使用的软件包

    purge - 移除软件包和配置文件

    source - 下载源码档案

    build-dep - 为源码包配置编译依赖

    dist-upgrade - 发行版升级

    dselect-upgrade - 依照 dselect 的选择更新

    clean - 清除下载的归档文件

    autoclean - 清除旧的的已下载的归档文件

    check - 检验是否有损坏的依赖

    选项:

    -h 本帮助文件。

    -q 输出到日志 - 无进展指示

    -qq 不输出信息,错误除外

    -d 仅下载 - 不安装或解压归档文件

    -s 不实际安装。模拟执行命令

    -y 假定对所有的询问选是,不提示

    -f 尝试修正系统依赖损坏处

    -m 如果归档无法定位,尝试继续

    -u 同时显示更新软件包的列表

    -b 获取源码包后编译 -V 显示详细的版本号

    -c=? 阅读此配置文件

    -o=? 设置自定的配置选项,如 -o dir::cache=/tmp

    apt-get 常用实例:

    apt-cache search packagename 搜索包
    apt-cache show packagename 获取包的相关信息,如说明、大小、版本等
    apt-get install packagename 安装包
    apt-get install packagename –reinstall 重新安装包
    apt-get -f install 修复安装”-f = –fix-missing”
    apt-get remove packagename 删除包
    apt-get remove packagename –purge 删除包,包括删除配置文件等
    apt-get update 更新源
    apt-get upgrade 更新已安装的包
    apt-get dist-upgrade 升级系统
    apt-get dselect-upgrade 使用 dselect 升级
    apt-cache depends packagename 了解使用依赖
    apt-cache rdepends packagename 是查看该包被哪些包依赖
    apt-get build-dep packagename 安装相关的编译环境
    apt-get source packagename 下载该包的源代码
    apt-get clean 清理无用的包
    apt-get autoclean 清理无用的包
    apt-get check 检查是否有损坏的依赖

    展开全文
  • MYSQL常用语法

    千次阅读 2012-01-08 00:16:34
    2.常用命令 show databases; use databasename; show tables; desc tablename; 命令不是大小写敏感的,数据库对象名字是大小写敏感的 3.语法: 创建数据库 create database databasename; create datab
    1.登录 mysql -uuser -ppassword [-hhostip]
    
    2.常用命令
    show databases;
    use databasename;
    show tables;
    desc tablename;
    命令不是大小写敏感的,数据库对象名字是大小写敏感的
    3.语法:
    创建数据库
    create database databasename;
    create database databasename default character set utf8;
    常用字段类型:
    数值类类型:int  bigint decimal(4,2) 
    日期类型:date datatime  timestamp  time  year  其中datetime格式为yyyy-MM-dd HH:ss:mm  timestamp格式为yyyyMMddHHssmm
    文本类型:varchar(50) text(1000)/text


    数值函数:
    round(‘3.64’,0)--->4  四舍五入  第二个参数表示要留几位小数
    floor(3.64)--->3  取整


    日期常用函数:
    year(...)
    month(...)
    dayofmonth(...)
    curdate(); sysdate();
    last_day(date) 返回该月最后一天
    dayofweek(日期)
    to_days(日期)  距离0000-00-00多少天
    DATE_FORMAT(date,format)
    根据 format 字符串格式化 date 值。
    下列修饰符可以被用在 format
    字符串中: %M 月名字(January......December)
    %W 星期名字(Sunday......Saturday)
    %D 有英语前缀的月份的日期(1st, 2nd, 3rd, 等等。
    )
    %Y 年, 数字, 4 位
    %y 年, 数字, 2 位
    %a 缩写的星期名字(Sun......Sat)
    %d 月份中的天数, 数字(00......31)
    %e 月份中的天数, 数字(0......31)
    %m 月, 数字(01......12)
    %c 月, 数字(1......12)
    %b 缩写的月份名字(Jan......Dec)
    %j 一年中的天数(001......366)
    %H 小时(00......23)
    %k 小时(0......23)
    %h 小时(01......12)
    %I 小时(01......12)
    %l 小时(1......12)
    %i 分钟, 数字(00......59)
    %r 时间,12 小时(hh:mm:ss [AP]M)
    %T 时间,24 小时(hh:mm:ss)
    %S 秒(00......59)
    %s 秒(00......59)
    %p AM 或 PM
    %w 一个星期中的天数(0=Sunday ......6=Saturday )
    %U 星期(0......52), 这里星期天是星期的第一天
    %u 星期(0......52), 这里星期一是星期的第一天
    %% 一个文字“%”
    %a - 星期几的简写
    %A - 星期几的全写
    %b - 月份的简写
    %B - 月份的全写
    %c - 日期时间 06/12/05 11:15:10
    %C - 世纪时间
    %d - 一个月的第几号(从 01 到 31)
    %D - 同 %m/%d/%y
    %e - 一个月的第几号,号为单数则前面加一空格 (从 1 到 31)
    %g - 世纪
    %G - 世纪 [0000,9999]
    %h - 同%b
    %H - 24 小时形式的小时(从 00 到 23)
    %I - 12 小时形式的小时(从 01 到 12)
    %j - 一年中的第几天(从 001 到 366)
    %k - 24 小时形式的小时,单数字前面加空格. (从 0 到 23)
    %l - 12 小时形式的小时,单数字前面加空格.(range 1 to 12)
    %m - 月份 (range 01 to 12)
    %M - 分
    %n - 换行符
    %p - 显示早上还是下午`am' 或 `pm'
    %r - a.m. 或 p.m.形式的时间
    %R - 24 小时形式的时间
    %S - 秒
    %t - tab 符号
    %T - 同%H:%M:%S
    %u - 用 [1,7],表示星期几
    %U - 计算是该年的第几个星期,从该年的第一个星期天开始计算
    %V - 计算是该年的第几个星期, 从 01 到 53, 第一个星期必须
    至少有 4 天在这一年, 星期天作为这个星期的第一天
    %w - 用数字的形式表示是星期的第几天, 星期天 为 0
    %W - 用数字的形式是该年的第几个星期,从该年的第一个星期一开
    始计算
    %x - 显示日期:月/日/年
    %X - 显示时间:小时:分钟:秒
    %y - 不包括世纪的年份
    %Y - 包括世纪的年份
    %Z - 时区
    %% - 输出%


    创建表
    create table table_name(
    filed_name filed type,
    ...
    );
    create table table_name select ... from ...;


    插入数据:
    insert into tablename(columns...) values(....);
    load ...


    删除数据
    delete from table.... where  ....
    修改表
    update table_name
    set filed=value,...
    where ....


    删除表
    drop table tablename;




    查询数据
    select ....
    from ....
    where ....
    group by....
    having ....
    order by....   desc asc


    组函数
    count() sum( ) avg( ) max( ) min( )


    表连接
    内连接
    select .... a.xxx, b.xxx...
    from a inner join b
    on a.id=b.id;
    等价于
    select .... a.xxx, b.xxx...
    from a , b
    where a.id=b.id;


    外连接:
    select .... a.xxx, b.xxx...
    from a left|right outerjoin b
    on a.id=b.id;


    子查询
    select  aaa.xxxx
    from (select ...  from ... where ...) aaa;




    case [...]
    when ....  then ...
    when ...  then ...
    [else ...]
    end


    update EMP
    set SAL=
    (
    case
    when DEPTNO=10 and JOB='MANAGER' then SAL*1.1
    when DEPTNO=20 and JOB='CLERK' then SAL*1.2
    when DEPTNO=30  then SAL*1.1
    when DEPTNO=40  then SAL*1.2
    else SAL
    END
    );
    select ENAME, 
    case DEPTNO
    when 10 then '后勤部'
    when 20 then '财务部'
    when 30 then '内务部门'
    else '其他部门'
    end as dept
    from EMP;


    limit
    从index 0 开始,取5条记录
    select * from tablename limit 0,5
    从index 5开始,连续取10条记录
    select * from table limit 5,10




    字符串操作
    left('',2) right('',3)
    upper(..)
    lower(...)
    replace('asfdasdf','a','D')
    length(str)  str的长度
    CONCAT(str1,str2,str3,..)  拼接字符串
    like  _ %
    regexp 
     
    其他:
    null不是值   只能用is null  is not null


    约束:
    非空约束
    create table t10(
      id int default 0,
      name varchar(20) not null
    );
    insert into t10(name) values('aaa');
    insert into t10(id) values(1); //error
    ERROR 1364 (HY000): 
    Field 'name' doesn't have a default value


    主健约束&字段自增长
    create table t12(
      id int primary key auto_increment,
      name varchar(20) not null

    );

    相关表emp&dept和练习:

    http://download.csdn.net/detail/linchunhua/4007052

    展开全文
  • 英语语法

    千次阅读 2014-04-25 04:47:17
    英语语法是针对英语语言的语法进行的研究。英语的动词语法庞大复杂,与其他印欧语系语言具有相似的特性;某些历史因素使英语文法历经大幅的简化,总体而言比起其他印欧语系的语言是相对简单的。 目录 [隐藏]  ...
  • python作为一种编程语言对英语有一定的基础要求。本资源内涵python中常用的各种英文单词,帮助大家更好的学习。并包含python的基本语法,帮助大家快速学习和记忆,并且在编程中,如果遗忘也可快速查询
  • 高考英语语法

    2011-09-30 20:00:43
    高考英语语法常用知识点总结。这可是作者辛劳的结晶啊。
  • qlExpress实践手册-常用语法介绍

    万次阅读 2017-10-26 11:23:49
    QlExpress脚本语言解析工具诞生于2010年,是阿里巴巴 玄难 根据当时 涉及资金结算 的业务需要开始编写。 因为其良好的扩展性和过硬的稳定性,不断的被...2013年升级到3.0版本,内部重构了语法定义和匹配的算法,代码
  • 洪恩英语语法词典

    2008-07-03 16:04:58
    本书中有英语语法常用语句、口语学习等很好用
  • 英语基础语法

    千次阅读 多人点赞 2017-08-22 23:53:14
    英语的五种基本句式... 2 be 动词... 2 代词... 3 反身代词... 4 实意动词... 5 用疑问词提问和回答... 6 名词... 7 动词... 8 形容词... 9 助动词... 9 副词... 10 不定量表达法... 10 There be 句型.....
  • 本文主要内容是信息与通信工程专业英语,科技书籍的常用语法,本文主要叙述了以it作为形式主语从句,强调句型,动词不定式,分子及分子短语,分词独立结构,介词短语,虚拟语气,令定语从句在以英语为主要书写语言的...
  • 2022高考英语一轮复习第二部分语法专项突破第1板块构建基础词法专题1语法填空常用派生词对点训练含解析新人教版202104012126
  • mysql的增删改查常用语法

    千次阅读 2015-08-18 00:45:59
    MySQL 常用数据类型 java 中 String char ----- mysql 中字符串型 char varchar  * char是定长 varchar是变长  例如:char(8) 保存 lisi,因为lisi 只有四个字符,所有会补充四个空格,成为8个字符存入 char...
  • 2021版高考英语大一轮复习第2部分第1板块专题1语法填空常用派生词练习新人教版
  • 英语语法记忆歌诀

    2018-07-03 11:11:58
    英语语法记忆歌诀一般现在时一般现在时态中,动词一般用原形。表述事实讲真理,习惯动作常发生。动词词尾加-s(es),只表单数三人称。若变一般疑问句,得看句型是哪种。系表结构和there be, be放句首可完成;若遇实...
  • 英语语法总结

    千次阅读 2019-08-03 19:31:25
    英语语法总结 第一部分:基础概念 1、词性 2、句子成分 3、构词法 第二部分:基础篇 1、词性一 名词 - 名词的分类 - 名词所有格 - 主谓一致 2、词性二 代词 - 代词的分类 - 3、词性三 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,950
精华内容 12,380
关键字:

常用语法英语