精华内容
下载资源
问答
  • 职称英语常用语法详解职称英语常用语法详解职称英语常用语法详解职称英语常用语法详解
  • 为了广大高考生理清英语语法头绪而传 希望大家喜欢
  • 最系统的语法归纳级词汇固定搭配 适合大学四六级备考学生短期突破语法常用搭配难关
  • 此文档对英语语法特别有帮助,是概要的讲解了语法的各各方面。
  • pytorch常用语法

    千次阅读 2019-02-23 19:42:28
    记录常用语法以备忘,方便遗忘时查阅… 本文从以下三个方面记录pytorch的常用语法,并会随着将来的使用不断更新: 张量操作 数据预处理 网络构建 1 张量操作 1.1 张量创建 x = torch.empty(5, 3 , dtype = torch....

    记录常用语法以备忘,记得不是很规范,主要方便自己遗忘时查阅…
    本文从以下三个方面记录pytorch的常用语法,并会随着将来的使用不断更新:

    • 张量操作
    • 数据预处理
    • 网络构建
    • 可视化

    1 张量操作

    1.1 张量创建
    • x = torch.empty(5, 3 , dtype = torch.uint8)
    • x = torch.ones(5, 3 , dtype = torch.float64)
    • x = torch.rand(5, 3 , dtype = torch.float32, requires_grad=True)
    • x = torch.view(3,-1) # reshape x to (3,5)
    • x = torch.randn(5, 3 , dtype = torch.long)
    • x_copy = x.new_ones(5, 3 ,dtype = torch.double)
    • x_same_size = torch.randn_like(x, dtype = torch.float)
    • torch.arange(start, end, step=1, dtype=torch.int32)
    • torch.full(size, fill_value)
    • torch.normal(mean, std, out=None) #正态分布
    • x = x.unsqueeze(0) # 增加一维
    1.2类型转换
    • b = a.long() # torch.int64
    • c = a.half() # torch.float16
    • d = a.int() # torch.int32
    • e = a.double() # torch.float64
    • f = a.float() # torch.float32
    • g = a.char() # torch.int8
    • h = a.byte() # torch.uint8
    • j = a.short() # torch.int16
    • c = a.type_as(c) # 转化 a 的数据格式与 c 相同
    1.3 张量信息查询
    • print(x.size()) # print(x.shape)
    • print(x.dtype) #tensor.uint8 tensor.float64 ....
    • print(type(x))
    • print(x[0][2].item())
    • print(x[0][2])
    1.4 张量操作
    • b = a.numpy() #numpy torch数据转换

    • a = torch.form_numpy(b)

    • ``

    • GPU设备中的运算

    if torch.cuda.is_available():
    	device = torch.device("cuda")
    	y = torch.ones_like(x,device= device)   #直接从 GPU 创建张量
    	x = x.to(device)                        #将 CPU 中变量移动到 GPU 中
    	z = y + x
    
    • 求导相关
    x = torch.rand(5, 5, requires_grad=True)
    y = torch.rand(5, 5, requires_grad=True)
    z=torch.sum(x+y)
    z.backward(torch.ones_like(z))
    print(z.grad_fn)
    print(x.grad, y.grad)
    
    with torch.no_grad():
    	............
    
    • 反向传播
    net.zero_grad()           # 反向传播前,将所有参数的梯度清零
    out.backward(torch.ones(1,10))
    
    import torch.optim
    out = net(input)       		# 直接调用 forward 函数
    criterion = nn.MSELoss()    # 损失函数 均方误差
    loss = criterion(out, y)	# 计算 out 于 y 的均方误差
    # 新建优化器
    optimizer = torch.optim.SGD(net.parameters(),lr = 0.01, momentum=0.9) 
    optimizer.zero_grad()     # equal to : net.zero_grad()
    loss.backward()           # 反向传播
    optimizer.step()		  # 更新参数
    

    2 数据预处理

    3 构建网络

    3.1 优化器

    常见的优化器:SGD, RMSProp,Adam,

    • import torch.optim # 优化器库
    3.2 网络层
    • 卷积层
    self.conv1 = torch.nn.Conv2d(in_channels, out_channels, kernel_size, 
    			stride=1, padding=0, dilation=1, groups=1, bias=True)
    x = self.conv1(x)
    # parameters:
    #		stride:(high,width)  
    #       padding:(high,width)  high 上下各补0的行数,width 左右各补零的列数
    #       groups: local convolution 局部卷积,然后拼起来,人脸识别常用到。  
    #				eg. group=4 每个channel分成4份,各自卷积。默认为1
    
    • BatchNormal层
    self.bn1 = torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, 
    			affine=True, track_running_stats=True)
    
    • 池化层
    • ReLU层
    • 存储,加载网络
    # 方法一,仅保持模型参数 (推荐)
    torch.save(the_model.state_dict(), PATH) # PATH, .pt or .pth
    # 加载
    the_model = TheModelClass(*args, **kwargs)
    the_model.load_state_dict(torch.load(PATH))
    
    # 方法二,保存整个模型
    torch.save(the_model,PATH)
    # 加载
    the_model = torch.load(PATH)
    

    4 参考资料

    展开全文
  • 程序员的英语pdf,包含最简单的语法常用句式,常用单词等,通过黑客、物联网、大数据等相关内容的文章进行解析。
  • 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 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



    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
    展开全文
  • 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
    英语语法是针对英语语言的语法进行的研究。英语的动词语法庞大复杂,与其他印欧语系语言具有相似的特性;某些历史因素使英语文法历经大幅的简化,总体而言比起其他印欧语系的语言是相对简单的。 目录 [隐藏]  ...
    英语语法是针对英语语言的语法进行的研究。英语的动词语法庞大复杂,与其他印欧语系语言具有相似的特性;某些历史因素使英语文法历经大幅的简化,总体而言比起其他印欧语系的语言是相对简单的。




    目录  [隐藏] 
    1 语序
    1.1 英语五大句型
    2 各词类
    2.1 名词
    2.1.1 名词复数形式的构成
    2.1.2 名词的限定和名词的数
    2.1.3 人称代词的格变化以及第三人称代词的性
    2.2 动词
    2.2.1 动词的人称
    2.2.2 动词的语态
    2.2.3 动词的语气
    2.2.4 动词的时和体
    2.2.4.1 虚位与类助动词
    2.2.4.2 其他
    2.2.5 不规则动词
    2.3 形容词与副词
    3 否定
    4 子句和句子结构
    4.1 疑问词
    4.2 关系子句
    5 参见
    语序
    英语语序如下:




    基本语序:主词─动词─受词─补语(SVO),但疑问句时助动词移至句首。
    介词多为前置词,即介词置于其所支配的名词前。
    数词、形容词和指示词等置于被修饰词前方,然关系子句置于其所修饰的名词之后。
    总体上来说英语是“中心语前置”的语言,也就是说一个短语的重心在其开头,但名词短语是主要的例外。语序变化一般用在疑问句(Did you go to the store?)、主动被动语态变化(The car was bought by John)及词语或语法上的强调(主题化)中。




    英语五大句型
    一说英语有五种主要的句形,它们分别如下:




    主词─动词
    主词─动词─主词补语
    主词─动词─受词
    主词─动词─间接受词─直接受词
    主词─动词─受词─受词补语
    加介系词的短语(如to the store、on Friday)等一般放在动词和受词之后,有时可移至句首。




    各词类
    名词
    英语中,名词一般描绘人物、地点、事物与抽象观点等。




    名词复数形式的构成
    以s、x、z、ch、sh 结尾的名词的复数形式:当单数可数名词的词尾是s、x、z、ch、sh 时,变为复数应加- es,例如:ass — asses , glass — glasses , inch -inches,brush — brushes,bench- benches,branch-branches,adz-adzes,quiz—quizzes。当ch 发音为[k]时,则变复数时仅加-s:monarch—monarchs,stomach-stomachs。
    以o 结尾的名词的复数形式:若单数名词的词尾为o,-o 前为元音字母时加-s,以-o 结尾的外来词加-s,有的加-s 或-es 均可,其中绝大部分直接加-s,这点与传统观点不同。
    加-es 的仅是有限的几个名词:antihero,bastinado,buffalo,dingo,echo,embargo,farrago,go,gusto,hero,jingo,lingo,Negro,potato,tomato,torpedo,veto。
    既可加-s,也可加-es 的名词:cargo,halo,commando,memento,mosquito,no,tornado,tobacco,volcano,zero。
    buffalo 变为复数时既可加-es,也可与单数同形。pimento 变为复数时既可加-s,也可与单数同形。
    有的以-o 结尾的单词变为复数时,既可以加-s,也可以把o变为i,这类词有:cello(celles,celli),concerto(concertos,concerti),dev - ertimento( devertimentos,devertimenti),fortissimo(fortissimos,fortissimi),glissando(glissandos,glissandi),intermezzo(intermezzos,inter- mezzi),libretto(librettos,libretti),maestro(maestros,maestri),obbligato(obbligatos,obbligati),pianissimo(pianissimos,pianissimi),pizzicato (pizzicatos,pizzicati),potto(pottos,potti),scherzo(scherzos,scherzi),sforzando(sforzandos,sforzandi),solo(solos,soli),tempo(tempos,tempi),virtuoso(virtuosos,virtuosi)。
    剩下的单词,均加-s:bamboo,solo,cuckoo,curio,embryo,two,disco,piano 等。
    以f、fe 结尾的名词的复数形式:大多数以f 或fe 结尾的名词变为复数时,直接加-s,但也有一部分须把f 或fe 改为-ves,总结如下:
    须把f 或fe 改为ves 的共有16 个:behalf,calf,elf,half,knife,bowie knife,life,loaf,leaf,midwife,self,sheaf,shelf,thief,wife,wolf。
    既可直接加-s,也可把f 或fe 改为ves 的共10 个,它们是beef,dwarf,hoof,handkerchief,oaf,kerchief,scarf,staff,turf,wharf。
    beef 表示“不平、牢骚、诉苦、告发”时,复数形式只用beefs;表示“养肥了的牛”时,beef 的复数形式用beeves;表示“牛肉”时,beef 一般是不可数名词。
    staff 表示“全体职员、路牌、五线谱”时,复数形式为staffs;表示“棍、柄、支柱”时,复数形式为staves。
    其余均直接加-s:belief,brief,cliff,disbelief,disproof,grief,gulf,golf,niff,proof,relief,riff,reef,strife,tariff,waif。
    以y 结尾的名词的复数形式:当单数可数名词的词尾为y 时,而y 前为辅音,须把y 改为i,再加-es:baby-babies,city—cities,fly-flies,lady—ladies;当y前为元音时,直接加-s:day-days,key-keys,boy-boys。假使词尾为quy,变复数时,须先把y 改为i,然后再加-es,因为 qu 的发音为[kw]:colloquy-colloquies,soliloquy-soliloquies。
    不规则变化:有些名词从单数变为复数时,并不按普通规则加-s:child-children,foot-feet,goose-geese,louse-lice,man-men,mouse-mice,ox-oxen,tooth-teeth,woman-women。还有一些外来语,必须依其原有规则变化:
    拉丁语:alumna-alumnae,alumnus—alumni,apparatus-apparatus or apparatuses,appendix-appendices or appendixes,axis- axes , bacterium - bacteria , curriculum-curricula or curriculums,datum—data,erratum—errata,focus-foci or focuses,formula—formulae or formulas,index(指数)-indices,index(索引)-indexes,memorandum—memoranda or memorandums,radius—radii or radiuses,series-series,species- species。
    希腊语:analysis—analyses,basis-bases,crisis-crises,criterion-criteria or criterions,hypothesis-hypotheses,phenomenon—phenomena,synopsis-synopses,thesis-theses。
    法语:beau-beaux or beaus,bureau—bureaux or bureaus,corp- s-corps。
    单复数同形的名词:
    表示鱼类及其他某些动物的名词。
    鱼类:fish,plaice(鲽),flounder(比目鱼),herring(鲱鱼),skate (鳐),sardine(沙丁鱼),salmon(大麻哈鱼),roach(斜齿鳊),dace (雅罗鱼),cod(鳕),mackerel(鲐鱼),halibut(大比目鱼),hake (狗鳕),haddock(黑线鳕),perch(河鲈),bass(鲈鱼),carp(鲤鱼),pike(狗鱼),trout(鳟鱼),crucian(鲫鱼)等等。
    fish 表示多种鱼时加-es。
    flounder,herring,skate,sardine 可用作复数,也可加-s 表示复数,用后者的情况更多一些。另外,packed like sardines 是习惯用语,不可把sardines 改为sardine。
    其他动物:sheep(羊),swine(猪),bison(野牛),deer(鹿),reindeer(驯鹿),elk(麋鹿),moose(驼鹿),grouse(松鸡),snipe (沙锥鸟),woodcock(山鹬),antelope(羚羊),buffalo(水牛),crab (蟹),duck(鸭子)等等。duck 指“家鸭”时,其复数形式为ducks,指“野鸭”时,复数形式仍用duck。
    某些表示人的名词。
    以-ese 结尾的表示民族的名词:Chinese,Japanese,Vietnamese,Lebanese,Portuguese,Maltese,Burmese,Ceylonese 等等。Swiss 也是单复数同形。
    其他某些表示人的名词:offspring(后代),counsel(律师),kin (家属),folk(人们),vermin(歹徒)等等。 offspring 的复数有时也用offsprings。
    某些表示单位的名词位于数词或其他表示数量的词之后,通常是单复数同形。常见的有:hundred,thousand,million,score,dozen,gross,stone,ton,brace,yoke,head 等等。
    hundred,thousand,million,billion,dozen 等表示不确切的数字或用于习语中,其复数形式均须加-s。
    score 表示“成绩或分数”,stone 表示“石头”,head 表示“脑袋”时,它们的复数均须加-s。dozen,hundred,thousand,mollion,billion 等词前有不定冠词、数词或 many,several 等词时,它们的词尾都不加s,后面也不用介词,直接修饰名词。但如后面跟的是代词,则在代词前应有of,如five thousand of them。前面没有数词、不定冠词等词时,一般即用复数形式表示“几”的意思,后面不能直接跟名词,而只能跟由介词of 组成的短语。
    表示单位的名词pound,foot 常有复数形式pounds 和feet,但有时可用单数形式代替复数形式,当它们后面有数词时,尤其如此:
    从汉语中音译过去的表示度量衡单位的名词都是单数和复数同形。常用的这类词有:yuan(元),jiao(角),fen(分),mu (亩),zhang(丈),chi(尺),cun(寸),li(里)等等。
    有些名词词尾有-s,即表示单数,也表示复数,如:headquarters,works,gallows,links,innings。
    数词加表示度量、数量、单位、时间等的名词作定语时,这些名词一律用单数形式。
    名词的限定和名词的数
    英语的名词总体上来说没有格变化,但有限定和数量差别。如:




    the(定冠词):the house指一幢明确具体的房子(例:“the house I was born in”)
    a/an(不定冠词):a house只是简单指一幢房子(例:“A house is a building for living in.”)
    单数:the house指一幢房子
    复数:the houses指一幢以上房子
    英语中,没有专门用来限定两个或三个的名词数字。还有一些名词是不可数名词,这类名词通常不是一个单独的固体,比如milk(牛奶)、water(水)都是不可数名词,固体切开后化学性质没有变化的一般也是不可数的名词,例如chocolate(巧克力)。0以及1以上的小数限定名词时名词一般也用复数。




    人称代词的格变化以及第三人称代词的性
    英语主要有两个情况需要格变化:所有格依附词(以前叫做撒克逊属格)和人称代词体系。在名词短语末尾附加依附词,用来指示所有格,如:




    The king's daughter's house fell.
    King后方的第一个<'s>显示这个女儿是国王的;第二个<'s>并不依附在daughter上(很多人对此是混淆的),而依附在The king's daughter整个名词短语后。




    另一方,英语在人称代词中保留了古日耳曼语的名词变格体系,参看下方表格。请注意,近代英语中第二人称单数thou1已经很少使用,在方言、宗教、诗歌或修辞等场合中才会出现。日常生活中普遍用you代替。












    人称: 第一单数 第二单数1 第三单数 第一复数 第三复数 第二复数 疑问词
    主格 I thou he, she, it we they you who
    宾格(或称受格) me thee him, her, it us them you whom (非正式:who)
    属格 mine2 thine2 his, hers, its ours theirs yours whose
    在第三人称代词上也残留下一些阴阳性变化。性用在生物上,一般是遵循生物学上的性变化;用在事物上,则根据社会历史传统变化(如“船”在英语中经常当作阴性看待)。He用来指代阳性名词;she用来指代阴性名词;it用来指代不确定性的名词和非生物。普遍认为用“it”来形容人类既不礼貌又不符合语法(形容婴儿时除外);一些英语使用者愿意用“they”来指代性别不明或与语境无关的人,另一些人愿意用稍稍复杂一些的“he or she”。这种场合很少会引起混淆,因为説话人想要表达的意思从语境中就能够体现出来;另外在英语当中,尚有人发明了一些性别中立的代词系统,如斯比瓦克代词、xe/xem、ve/ver、ze/mer等,详见英语性别中立代词表。




    总的来说,英语名词没有性和格的变化,只是人称代词有三个格(主格、宾格、所有格),只有第三人称单数才有阴阳性的差别,英语名词的形态比其他欧洲语言略单纯。




    动词
    主条目:英语动词
    英语中,动词一般描绘动作和状态等。与相对简单的名词相比,动词分为时态、情态、语态等,也根据人称变化。




    动词的人称
    英语中的动词人称变化较少。与其他欧洲语言不同,单从英语的动词变形很难看岀来主语是何人称(除动词be以外,现代英语仅有现在时的第三人称单数有动词人称变化)。结果就造成,英语中一般必须明确主语名词和代词,否则会造成混淆。大多数规则动词依照下方的格式随人称变化:




    词干:listen
    第一人称单数:I listen
    第二人称单数:You (Thou) listen (listenest)
    第三人称单数:He/She/It listens
    第一人称复数:We listen
    第二人称复数:You listen
    第三人称复数:They listen




    动词的语态
    英语动词有两种语态:主动和被动。基本形式是主动语态,遵循上方讨论过的SVO格式。被动语态的变化是,改变动词形态,将主语和直接宾语对调,然后在主语前附加“by”,如:




    主动:John heard the music.
    被动:The music had been heard by John.
    这种改变在语义上的效果是,这个动作会被“去人格化”,不会再受具体主语的限制。有的时候这种用法也用来强调句子中的直接宾语。




    动词的语气
    英语的动词有四种语气:陈述、祈使、条件和虚拟。陈述式是最简单的,也是最基本的形式。




    陈述语气简单说来就是围绕动词主动语态的叙述。
    祈使语气用在命令、请求中。要求使用动词原型,如“Listen!”、“Sit!”、“Eat!”等。祈使语气在英语中仅岀现在第二人称的情况。主语(你/你们)一般不说,因为句义中已经表达了出来。有时候也使用呼格,避免産生歧义,如“Sit, John.”
    条件语气用来表达假设性陈述,或回应虚拟的命题(见下方的虚拟语气)。表达方法是使用助动词could、would、should、may与might加动词原型,如:
    He goes to the store.
    He could go to the store.(他有能力去,[而且或已经承诺要去,或还没有承诺。])
    He should go to the store.(他应该去,但还没去。)
    He may go to the store.(他已经被允许去了,[而且或已经承诺要去,或还没有承诺。])
    He might go to the store.(并不确定他是否会去,而且暗示会受到条件变化的影响。)
    请注意,对大多数使用者来説,“may”和“might”已经没有分别,都用来表达上面说的“might”这个意思。
    虚拟语气用来表达反事实(附加条件)的叙述,经常出现在假设性陈述中。典型的用法是,用助动词“were”加上动词的现在分词<-ing>。
    I am eating, so I shall sit.(事实/陈述)
    Were I eating, I should sit.(反事实)
    If they were eating, they would sit.(附加条件的反事实/假设)
    Truth be told...(虚拟)
    If I were you...(虚拟)
    当这些语气用在时态中,情况会明显复杂。不过,日常用语中一般不会严格遵守虚拟语气的格式,而且也将条件式限制在简单现在和简单过去时中。




    动词的时和体
    英语有很多动词时态,全部这些都只是表明动作发生的时间;不过同大多数日耳曼语一样,这些时态最终可以划为四种:现在和过去的直陈与虚拟。使用“to be”和“to have”,再加上现在分词和过去分词,就可以创造岀各种复合时态。英语中有12个主要时态,都来自于三时(过去、现在、将来)和四体(一般、进行[或未完成]、完成、完成进行)的交叉组合。(在被动语态中,有一些组合会极少岀现,尤其是“将来完成进行时”。)下方是一些主要英语动词时态的例子。




    主动词根据人称变化的时态:




    一般现在时:“I listen.”对很多动词来讲,这个时态用来阐述习惯或能力。
    助动词根据人称变化的时态:




    现在进行时:“I am listening.”表达现在正在进行的动作。要表达这个意思,在英语中需要用到现在进行时,但在其他大多数语言中只用一般现在时就可以。请注意,这种形式在英语中也可以表达将来时,比如“We're going to the movies tonight”。
    过去进行时:“I was listening.”表达在过去某时刻持续进行的动作。
    现在完成时:“I have listened.”通常表达一个动作在过去某一时刻发生了,动作已结束。
    现在完成进行时:“I have been listening.”表达一个动作在过去某一时刻发生,并一直延续到现在。
    一般将来时:“I shall listen”或“I will listen.”表达一个动作会在将来发生,或説话人表示要完成某个行动。3
    将来进行时:“I shall be listening.”表达将来的某个持续进行的动作,此动作现在还没有开始。(使用will可以表达主观愿望。3)
    主动词和助动词都不根据人称变化的时态:




    不定式:“to listen”与其他动词连用,如“I was to listen to the story”。
    一般过去时:“I listened.”在英语中表达某个动作在过去发生,而不是现在(不同于其他一些语言中的不定过去时)。
    过去完成时:“I had listened.”表达某个过去的动作在过去某一时刻之前已经完成。
    过去完成进行时:“I had been listening.”表达一个动作在过去某一时刻发生,并一直延续到过去另一个时刻。
    将来完成时:“I shall have listened.”表达一个动作会在将来某一时刻之前完成。
    将来完成进行时:“I shall have been listening.”表达一个动作会在将来某一时刻开始,并一直延续到将来另一时刻。
    虚位与类助动词
    另外,“do”的各种形式也用在否定句、疑问句和对一般现在时与一般过去时的强调句中:




    "Do I go?" "I do not go." "I do go!"
    "Did I go?" "I did not go." "I did go!"
    进行形式“going to”也会用在将来时内:




    "I am going to go."
    "I was going to go."
    其他
    时态、体(又称“态”或“相”等)和语气/式之间的区别并不十分明确,也有很多别的分类意见。例如,许多分析人士不接受英语有12个时态的说法。那6个“进行”(又称连续)的形式经常统统放入一个大的“体”分类下讨论,而不被当作“时态”;同时这种观点也认为一般过去时和过去进行时属于同一个时态。另外,很多现代英语语法书都认为英语并没有将来时态(或将来完成时)。赞同这种观点的有近年来最大最复杂的两本语法书:




    Biber, D., S. Johansson, G. Leech, S. Conrad & E. Finegan. 1999. Longman grammar of spoken and written English. Harlow, Longman.
    Rodney Huddleston & Geoffrey Pullum. 2002. The Cambridge grammar of the English language. Cambridge, CUP.
    Huddleston和Pullum(页数209-10)的主要论点是英语没有将来时态,因为无论从语法上还是意义上来看,will都是一个情态动词。Biber等人走得更远,指岀英语仅有两个时态,过去和现在;他们将带有have的完成形式作为“体”来讨论。而Huddleston和Pullum则将带有have的完成形式作为“二等时态”来分析。




    不规则动词
    参见英语不规则动词
    英语中很多动词的变位遵循这一段开始说明的规则,但英语中还有很多不规则动词,分为两种:




    “外表不规则”
    实际不规则
    “外表不规则”是指虽然第一层看上去不规则,但实际上也遵循另外一种变位规律。这一组动词是古日耳曼语元音交替变位体系的遗留物。一般来说仅包括非典型的一般过去式。例如:




    I meet ~ I met ~ I had met
    I read ~ I read ~ I had read
    I lead ~ I led ~ I had led
    I swim ~ I swam ~ I had swum
    I sing ~ I sang ~ I had sung
    I steal ~ I stole ~ I had stolen
    而实际不规则的动词,不能根据元音交替的规律来判断如何变位。最常见的例子是be。下方是这个词的动词变位方式。其他时态的可以从这基本四个中推导岀来。另关于古日耳曼语言动词元音交替变位法的详细内容,可参见日耳曼语强变化动词。




    人称: 第一单数 第三单数 第一复数 第三复数 第二
    不定式
    to be
    一般现在时 I am He is, she is, it is We are They are You are
    一般过去时 I was He was, she was, it was We were They were You were
    现在进行时 I am being He/she/it is being We are being They are being You are being
    不规则动词包括“eat”、“sit”、“keep”等其他很多。有一些变化方式是根据废弃的词根而来,或者根据已经改变意思的词根而来。其他的方式从来自于古元音变音的规律,这些规律的音位结构已经变化,也受到了语法变化的歪曲影响(如keep变为kept)。有一些来源不详,可能会追溯到原始印欧语言的时代。




    形容词与副词
    形容词修饰名词,副词修饰动词(和形容词)。并不是所有语言都区分这两种词,但英语从语法上和构词上都将它们分得一清二楚。语法上来讲,形容词放在要修饰的名词前面,而副词放在要修饰的动词前后都可以。英语也有将形容词变为副词的方法:附加后缀“-ly”(并移到句子中合适的地方)。




    变换词性的方法还有很多。名词很容易就能换为动词:先移到句子中合适的地方,再根据动词变位规则进行变化。名词也可以转化为其他类名词(<-er>、<-ist>),表达状态的名词(<-ness>),或形容词(<-ish>)等。 动词可以变为形容词(<-ing>),副词(<-ly>),或名词(<-er>)。




    这些方式让英语选词可以更加灵活,可以扩展词汇量,还可以重新组和词汇以便附加各种微妙的含义。




    否定
    英语的一个否定词为not,not加在动词前、助动词之后,而否定句大多要加助动词,若一个句子其相对应的肯定句形式没有助动词,则其否定句形式要在not前面加助动词do或其词形变化的形式,像Kirino likes her brother(意即“桐乃喜欢她的哥哥”)这句的否定句形式要变为Kirino does not like her brother(意即“桐乃不喜欢她的哥哥”),而非*Kirino not likes her brother之类的;同时英语的not常与助动词缩略,像can not会缩略成cannot或can't、will not会缩略成won't、do not会缩略成don't、should not会缩略成shouldn't、is not会缩略成isn't等。




    助动词在动词不定形或分词形、动名词形等前面是不使用的,在不定形中,not要加在to之前,因此to go的否定形为not to go;而going的否定形则为not going。




    子句和句子结构
    疑问词
    英语的疑问词置句首,其中当疑问词不是主词时,助动词和be动词要移至疑问句后和主词间,没有助动词的句子要在疑问词与主词间补上do或其词形变化。




    是非疑问句中,助动词和be动词要移至句首,没有助动词的句子开头要补上do或其词形变化。




    关系子句
    主条目:英语关系从句
    在英语中,关系子句置于其所修饰的名词后,一般英语的关系子句借由置于子句开头的关系代名词来标明,而有时亦仅仅借由语序来标明。若关系代名词在子句中为动词受词,它出现在子句的开头,而非受词在主句中惯常出现的位置,因此要表“桐乃是黑猫昨天遇见的那个女孩子”之意,在英语中用Kirino is the girl who(m) Kuroneko met yesterday,而非Kirino is the girl Kuroneko met who(m) yesterday。




    英语关系代名词的选用,取决于其头词所指称的是人类或非人类、关系子句为限制性子句或限制性子句,以及头词在关系子句中扮演的角色(如主词、直接受词或补语等)等各种因素。




    若头词指称的对象是人类,通常用who、whom或that等关系代名词,如Kirino is the girl who met kuroneko yesterday(意即“桐乃是昨天遇见黑猫的那个女孩子”)、Kirino is the girl who(m) Kuroneko met yesterday(意即“桐乃是黑猫昨天遇见的那个女孩子”)和Kirino is the girl that Kuroneko met yesterday(意即“桐乃是黑猫昨天遇见的那个女孩子”)等句皆为其例;但当头词指称的不是人类时,则只用that或which。
    若头词指称的对象非人类,且子句为非限制子句(Non-restrictive clause),则使用which,如The tree, which has fallen, is over there(意即“那棵倒下的树在那里”)即为其例;若头词指称的对象非人类,且子句为限制子句(Restrictive clause),则that或which皆可使用(尽管有些规范语法要求限定子句的状况必须使用that),如The tree which has fallen is over there(意即“那棵倒下的树在那里”)或The tree that has fallen is over there(意即“那棵倒下的树在那里”)即为其例。
    在较正式的用法中,who用于头词在关系子句中的角色为主词时(像Kirino is the girl who met kuroneko yesterday(意即“桐乃是昨天遇见黑猫的那个女孩子”)这句就是其例子);而whom用于头词在关系子句中的角色为受词或前带介词的词时(像Kirino is the girl whom Kuroneko met yesterday(意即“桐乃是黑猫昨天遇见的那个女孩子”)和Kirino is the girl with whom Kuroneko frequently argues(意即“桐乃是黑猫常与之争论的那个女孩子”)这两句即为其例);但在非正式的用法中,whom常以who取代。
    在英语和法语等一些语言中,非限制关系子句由逗号分隔,但限制子句则否,限制关系子句缩减指称的范围,非限制的则否:




    We saw two puppies this morning: one that was born yesterday, and one that was born last week. The one that was born yesterday is tiny.(意即“我们早上看见两只小狗,其中一只昨天出生,另一只上星期出生,昨天出生的那只很小”,此句为限制关系子句,此处之that亦可改用which)
    We saw a puppy and a kitty this morning. The puppy, which was born yesterday, was tiny.(意即“我们早上见到一只小狗和一只小猫,那只小狗很小,它是昨天出生的。”,此句为非限制关系子句)
    并不是所有人都同意that做为关系代名词的状态的。传统语法将that视为一关系代名词,但并非所有的现代语法家都持同样的看法,像剑桥英语语法(Cambridge Grammar of the English Language)就将that给视为一从句词(subordinator)而非关系代名词(pp. 1056–7);而英国国家语料库(British National Corpus)则将that视为一子句连接词,即使在其做为关系子句开头时亦然。一个为that寻求不同解释的动机在于that和which之间有一定的差异性存在(人们可说in which但不能说in that,其他像这样的例子亦存在着)。
    展开全文
  • 高考英语语法

    2011-09-30 20:00:43
    高考英语语法常用知识点总结。这可是作者辛劳的结晶啊。
  • MarkDown常用语法 前言 ​ 工欲善其事必先利其器,我们在学习的过程中,做好笔记是很重要的,俗话说的好:好记性不如烂笔头,推荐使用一款简洁的Markdown编辑工具Typora点我下载 百度百科资料:Markdown是一种轻量...
  • 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 句型.....
  • mysql的增删改查常用语法

    千次阅读 2015-08-18 00:45:59
    MySQL 常用数据类型 java 中 String char ----- mysql 中字符串型 char varchar  * char是定长 varchar是变长  例如:char(8) 保存 lisi,因为lisi 只有四个字符,所有会补充四个空格,成为8个字符存入 char...
  • 英语语法记忆歌诀

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

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

    千次阅读 2019-02-28 11:19:32
    多个批量修改英语写作语法错误的工具:1Checker,ginger和Writefull,可以修改英文文章里的语法错误,修改效率极高,而且都是免费的。使用地址:1Checker http://www.1checker.com/Home/Index,ginger ...
  • 英语基本语法

    千次阅读 2018-06-18 19:40:00
    英语中的冠词有三种,一种是定冠词(the Definite Article),另一种是不定冠词(the Indefinite Article),还有一种是零冠词(Zero Article)。 不定冠词a (an)与数词one 同源,是"一个"的意思。a用于辅音音素前,...
  • 计算机编程 常用术语英语词汇大全 记忆

    万次阅读 多人点赞 2017-04-14 15:13:21
    第一部分、计算机算法常用术语中英对照 Data Structures 基本数据结构 Dictionaries 字典 Priority Queues 堆 Graph Data Structures 图 Set Data Structures 集合 Kd-Trees 线段树 ...
  • 英语语法顺口溜

    千次阅读 2011-12-21 10:06:04
    英语语法顺口溜 用顺口溜来学习英语,至少有三大好处:一是节省了时间。死记硬背效果差不说,还费时间,而利用顺口溜,效率又高又省时;二是培养了自己的概括思维能力。把一些词语编成顺口溜,看似容易,其实...
  • python常用英语单词(小白)

    千次阅读 多人点赞 2020-01-31 17:41:03
    本人英语不好,编程中遇到一些英文单词经常需要百度,太难受了,所以从网上收集到的一些python常用单词,对于英语不好的及一些初学者比较适用,对于学习基础python这些也足够了,仅供兴趣爱好学习使用,我们一起学习...
  • 语法顺口溜英语

    千次阅读 2005-06-27 13:35:00
    语法顺口溜英语zt (1)谓语be的用法我用am,你用are除此之外的单数包括他她还有它统统都是用is我们你们和他们只要复数都用are(2)一般疑问句和否定句的变化一般问句并不难,谓语调到主语前。大写小写有变化,句末要...
  • pocket英语语法入门

    千次阅读 2020-04-14 09:28:55
    this.these.that.those 不定代词:指代不确定的人或事物,常用:one,the other,some,any,something,nothing 第十三讲,形容词 形容词通常形容人或事物的状态,性质,大小等,通常用在名词前,be动词后, the+形容词=...
  • 英语语法-句法

    千次阅读 2020-02-12 15:30:05
    以下摘抄于《张道真英语语法大全-下》中的一些重点,以及总结,句法稍微比词法容易理解,实际上就基本的句型(5种),以及一些组合/衍生出来的句式,句法就是将词法元素组织成一个合法的句子,难点在于句子成分的识别...
  • 英语笔记】英语语法框架

    千次阅读 2020-06-27 21:52:56
    英语语法一、句法1.1三种句子结构1.2三大从句1.2.1定语从句1.2.2状语从句1.2.3名词性从句1.3四种句子类型1.4特殊句式1.4.1倒装1.4.2强调1.4.3省略1.4.4反义疑问1.5五种基本句1.6八种句子成分二、十大词类2.1名词2.2...

空空如也

空空如也

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

常用语法英语