精华内容
下载资源
问答
  • 职称英语常用语法详解职称英语常用语法详解职称英语常用语法详解职称英语常用语法详解
  • 常用英语语法小结

    2018-01-03 19:51:00
    虽然经过了小学,高中,大学甚至研究生的英语学习,但是对于语法的学习基本在高中达到了最高峰,之后在大学和研究生阶段就没有再怎么学习过了。现在还保留着高中时的英语语法笔记,看着纸质的笔记总结得很详实,真的...

    虽然经过了小学,高中,大学甚至研究生的英语学习,但是对于语法的学习基本在高中达到了最高峰,之后在大学和研究生阶段就没有再怎么学习过了。现在还保留着高中时的英语语法笔记,看着纸质的笔记总结得很详实,真的被当时的自己感动了呢。最近因为修改投稿论文中的语法错误,才重新温习了高中时记的英语语法。所以在博客里不会记得多么系统详尽,只会记录一下在科研论文写作中容易出错的语法知识。

    1 主谓一致[1]:
    科研论文中常常用到各种复杂的从句,从句中谓语动词的时态和语态就是常常出错的地方,所以有必要梳理一下。

    • 根据语法一致的原则:单数主语+单数谓语动词,复数主语+复数谓语动词
      eg. The teacher encourages the students to speak freely.
      eg. My family encourage me to study hard.
    • 概念一致的原则:即根据主语的概念判定主语是单数还是复数
      eg. My family are all early risers.
      His family has moved into the new house.
    • 临近词一致的原则:这个需要记住一些常见短语结构的临近关系。
      eg. Neither he nor they are wholly right.
    • 复合句中的主谓一致:顾名思义,复合句就是几个简单句的组合,所以在每个简单句中要遵守的主谓一致原则在复合句中也要遵守。只不过在复合句中主谓结构会出现好几个,这时只要各个小的主谓系统各自保持主谓一致即可,不用考虑自身的主谓结构之外的部分。
      eg. You tell him or else Tom tells.
      eg. Whether or not these books are satisfactory is uncertain.
      eg. My opinion is that he really doesn't understand you.
      复合句中的主谓一致问题,利用word之类软件的语法检查功能是查不出来的,这个必须依靠自己的语法知识来检查。

    2 近义词复用
    英语中比较忌讳的一点就是相同词的多次重复,所以要尽量避免同一个词的重复使用。解决的方法就是近义词复用,有时必须要重复使用这个词时,我们可以选择和它意义相近的词来代替。
    eg. Tom catched the ball and Lily also catched the ball. (bad, two "catch"es are used.)
    Correction: Tom catched the ball and Lily also got the ball. (replace the second "catch" with "get")

    3 冠词的使用
    不要小看定冠词 (the)和不定冠词 (a,an)。虽然只有三个词,但冠词在科研论文中的出现频率很高,如果频频出错的话,会让审稿人对文章的印象变得很差,甚至影响接收。所以对冠词的使用也要认真对待。

    4 so, therefore, then和hence的区别[2]

    参考:
    [1]外文出版社,无敌英语语法(全范围)
    [2]https://jakubmarian.com/so-thus-therefore-and-hence-in-english/

    转载于:https://www.cnblogs.com/docnan/p/8184589.html

    展开全文
  • 最系统的语法归纳级词汇固定搭配 适合大学四六级备考学生短期突破语法常用搭配难关
  • Java 与英语 干程序员这行实在是离不开英语 干程序员是一项很辛苦的工作 要成为一个高水平的程序 员尤为艰难 这是因为计算机软件技术更新的速度越来越快 而这些技术大多来源于英语国 家我们在引进这些技术时往往受到...
  • 对于初学英语的学员来说,是比较有用而且实用的资料。
  • markdwon常用语法

    2019-10-09 15:12:44
    markdwon常用语法什么是markdwon?Markdown 应用语法标题一级标题二级标题三级标题四级标题五级标题六级标题字体分割线列表有序列表无序列表列表嵌套文字引用超链接图片表格代码单行代码多行代码(代码块) 什么是...

    什么是markdwon?

    Markdown 是一种轻量级标记语言,它允许人们使用易读易写的纯文本格式编写文档。

    Markdown 语言在 2004 由约翰·格鲁伯(英语:John Gruber)创建。

    Markdown 编写的文档可以导出 HTML 、Word、图像、PDF、Epub 等多种格式的文档。

    Markdown 编写的文档后缀为 .md, .markdown。

    Markdown 应用

    Markdown 能被使用来撰写电子书,如:Gitbook。
    当前许多网站都广泛使用 Markdown 来撰写帮助文档或是用于论坛上发表消息。例如:GitHub、简书、reddit、Diaspora、Stack Exchange、OpenStreetMap 、SourceForge等。

    语法

    标题

    在想要设置为标题的文字前面加 #来表示
    标题和html的标题类似,一共有6个标题

    一级标题

    二级标题

    三级标题

    四级标题

    五级标题
    六级标题

    他们用markdwon的语法为:

    # 一级标题
    ## 二级标题
    ### 三级标题
    #### 四级标题
    ##### 五级标题
    ###### 六级标题
    

    字体

    • 加粗

    要加粗的文字左右分别用两个*号包起来

    • 斜体

    要倾斜的文字左右分别用一个*号包起来

    • 斜体加粗

    要倾斜和加粗的文字左右分别用三个*号包起来

    • 删除线

    要加删除线的文字左右分别用两个~~号包起来
    示例:

    **加粗的文字**
    *倾斜的文字*`
    ***斜体加粗的文字***
    ~~加删除线的文字~~
    

    效果:

    加粗的文字

    倾斜的文字`

    斜体加粗的文字

    加删除线的文字

    分割线

    用三个或者三个以上的 -或者 *

    示例:

    ---
    ----
    ***
    *****
    

    效果:





    列表

    有序列表

    语法: 用 - + *任何一种都可以,符号跟内容之间要有空格。
    示例:

    - 无序列表内容
    + 无序列表内容
    * 无序列表内容
    

    效果:

    • 无序列表内容
    • 无序列表内容
    • 无序列表内容

    无序列表

    语法: 数字加点 序号跟内容之间要有空格
    示例:

    1. 列表1的内容
    2. 列表2的内容
    3. 列表3的内容
    

    效果:

    1. 列表1的内容
    2. 列表2的内容
    3. 列表3的内容

    列表嵌套

    语法: 和html嵌套类似,这里 上一级和下一级之间三个空格即可

    文字引用

    语法:在引用的文字前加 >;引用也可以嵌套
    示例:

    >引用的内容
    >>引用的内容2
    >>>这是引用的内容3
    //这里的>可以有n个一直的嵌套下去
    

    效果:

    引用的内容

    引用的内容2

    这是引用的内容3

    超链接

    语法:

    [超链接名的名称](超链接的地址 "超链接的title")
    
    title就是鼠标移动到超链接上面的提示的内容,可加可不加
    

    示例:

    [程序思维](http://www.lucklnk.com "前端干货多多")
    
    [DataV](http://datav.jiaminghi.com/ "Vue炫酷大屏数据展示组件库")
    

    效果:

    程序思维

    DataV

    图片

    语法:

    ![图片的alt](图片的地址 "图片的title")
    
    //图片的alt:就是显示在图片下面的文字,对图片内容的进行解释。
    //图片的title:就是是图片的标题,当鼠移动到图片上时显示的内容,title可加可不加,和上面超链接的用法一样
    //
    

    示例:

    ![DataV组件库的Demo](http://yun.lkboy.top/manage-desk.jpg "Demo截图")
    

    效果:
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qc3gaJse-1570605102160)(http://yun.lkboy.top/manage-desk.jpg “Demo截图”)]

    表格

    语法:

    |表头|表头|表头|
    |---|:---:|---:|
    |内容|内容|内容|
    |内容|内容|内容|
    // 第二行用于分割表头和内容。
    // - 有一个即可,通常为了对齐,可以多加几个
    对齐方式:
    文字默认居左
    两边加`:`表示文字居中
    左边加`:`表示文字居右
    

    示例:

    |商品名称|商品数量|商品单价|
    |---|:---:|---:|
    |手机|1|1580元|
    |笔记本|3|5800元|
    

    效果:

    商品名称 商品数量 商品单价
    手机 1 1580元
    笔记本 3 5800元

    代码

    单行代码

    语法:
    代码之间分别用一个反引号包裹
    示例:

    `单行代码的内容`
    

    效果:
    单行代码的内容

    多行代码(代码块)

    语法:
    代码前后分别用三个反引号包起来,并且两边的反引号单独要占一行
    示例:

    [```]
      module.exports = function() {
        let hello = document.createElement('div');
        hello.innerHTML = "欢迎大家来到程序思维学习";
        return hello;
      };
    [```]
    
    注:上面的[]是为了转义加上去的,用于演示
    

    效果:

     module.exports = function() {
        let hello = document.createElement('div');
        hello.innerHTML = "欢迎大家来到程序思维学习";
        return hello;
      };
    
    展开全文
  • 程序员的英语pdf,包含最简单的语法常用句式,常用单词等,通过黑客、物联网、大数据等相关内容的文章进行解析。
  • 多年来,我国的英语教学一直采用语法翻译法,教法比较单一。...我们不妨从几种常用的教学法入手,来分析其中的语法语法教学是如何界定的。这些教学法如何界定和使用,已有很多的书籍和刊物介绍,这不是本...
    538958c023167d4e66161ea05ac7e7b3.png

    多年来,我国的英语教学一直采用语法翻译法,教法比较单一。上世纪八十年代初,随着国际交流的日益加强和教学改革的进一步深入,各种英语教学法,尤其是从国外推介的教学法都相继进入英语教学领域。尽管有一些教学法在中国已经显示水土不服,不符合当地的教情和学情,但仍然被鼓励使用。我们不妨从几种常用的教学法入手,来分析其中的语法和语法教学是如何界定的。这些教学法如何界定和使用,已有很多的书籍和刊物介绍,这不是本文的重点,所以这里只涉及到教学法的特征和它们对语法和语法教学的认识问题。

    在我国中小学使用的英语教学法,按照其使用的大致顺序有以下几种。这些教学法的特点和对语法的态度列于下表中:

    d50bde7b306118773cd2f0f51896596c.png

    表1 英语教学法中的语法认知

    以上这10种教学法的教学理念不同,所以对于语法和语法教学的观点迥异。从表1可以发现,它们是如何认知,如何诠释语法的。我总结如下:

    A). 对待语法从积极态度向消极态度转变。序号1-6持积极态度,认为有必要学习语法;7-10持消极态度,即排斥语法。

    B). 对目的语环境的依赖逐渐加强。1、3、6不强调目的语环境;序号2、4、5、7、8试图创造目的语场景;序号9、10强调真实场景。

    C). 越来越忽视母语。除序号1、3之外,序号2、4、5、7、8、9、10根据儿童母语学习的特点提出教学建议,但排斥母语。

    D). 越来越强调输出(output)。除序号1、3、6要求输入(input)为主之外,序号2、4、5、7、8、9、10强调输出。

    E). 越来越强调习得(acquisition)。除序号1、3要求学得(learning)为主之外,序号2、4、5、7、8、9、10强调习得。

    F). 教学重点从形式中心(form-focused)向意义中心(meaning-focused)倾斜。除序号1、3、6以语言形式为主之外,序号2、4、5、7、8、9、10则以语言意义为主。

    英语教学法林林总总,我们无法一一列出,所以这里涉及到的只是几种常用的英语教学法。英语教师使用的教学法还有:全身反应法(total physical response)、沉默法(the silent way)、暗示法(suggestopedia)、协作法(cooperative language learning)、自然法(the natural approach)、社团学习法(community language learning or counseling learning method)、整体法(whole language approach)、内容法(content-based instruction)、词汇法(the lexical approach)等等,都没有把语法作为教学重点。但是,有一些教学法并不是把语法绝对排除在外,例如暗示法就要求教师解释语法和词汇,只是不要详述这一部分。诚然,教学法之间并不是严格界定的,例如人文法包含暗示法和社团学习法;内容法和任务型教学法,还有参与式教学法(participatory approach)这三种方法都是以交际为中心。可以说,在我国的英语教学实践中,在强调语境,强调交际,进而强调语言使用的同时,语法在现今流行的教学法当中被严重忽视了。

    通过对以上列出的10种教学法的分析,笔者发现,除了个别教法以外,这些教学法一个共同的弱点是没有考虑到中国的英语教学环境,导致需要加强、巩固的语法内容被忽略了。中国是一个英语外语教学国家,英语教师不论采用哪一种教学法都要符合中国的教情和学情。英语在中国不是官方语言,没有英语语言社区,学生学习英语短期目标是完成学业考试,远期目标是国际交流,学习方式以课堂教学为主,课时有限,又是大班上课,所以,英语教师应正确认识这些引进的英语教学法,在借鉴的基础上加以改造,扬长避短,使之适应于中国的英语教学。

    我国学生学习英语还是以课堂学得为主,课堂上给学生提供机会使用或产出语言,使用了语法要点,并不等于用语言做事,去完成某项具体任务,充其量是“用语言做假事”或“假装用语言做某事”。教师关注的重点不应是学生做成了某件事,而是在这个语言输出过程中,关注学生是否正确使用了学习过的语法要点。英语教学应输入先于输出。换句话说,英语教学需要融入足够的语法内容。没有语法的教学等于没有完成教学任务。此外,这里强调正确使用语言,就包括语言的形式、意义和语用范畴。也就是说,即强调了语言的准确性(accuracy),同时兼顾到流利性(fluency),因为语言不流利,再准确还是要影响交流的。没有语言的准确性,即英语语法的支撑,再流利也是影响理解,进而影响交流的。因此,英语教师的一大挑战就是不被各种教学法所误导,结合学情和教情,在使用某种教学法的过程中,探索出语法教学的新路径。

    展开全文
  • 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
    展开全文
  • markdown常用语法介绍

    2020-08-31 15:34:07
    Markdown是一种轻量级标记语言,创始人为约翰·格鲁伯(英语:John Gruber)。 它允许人们使用易读易写的纯文本格式编写文档,然后转换成有效的XHTML(或者HTML)文档。 Markdown 是一种轻量级标记语言,让写作者...
  • Markdown 语言在 2004 由约翰·格鲁伯(英语:John Gruber)创建。Markdown 编写的文档可以导出 HTML 、Word、图像、PDF、Epub 等多种格式的文档。Markdown 编写的文档后缀为 .md, .markdown。Markdown 能被使用来...
  • 原标题:500个英语语法固定搭配as +adj./adv.+as 和…一样so … as 像…一样sb. be familiar with sth. 熟悉sth. be familiar to sb. 对…来说很熟悉prevent/defend …(sb) from doing 远离回复【语法400题】到平台...
  • 高考英语语法

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

    2012-09-26 15:18:01
    第一章 句子分类及基本句型(Sentence Type and Pattern) 一、句子分类 1.结构分类 英语的句子在结构上可分为简单句、并列句和复合句。...常用的并列连词有:and(和),or(或者,否则),but(但是),so(...
  • 介词在句子中表示名词或代词等与其他词之间的关系。...{ 介词用法详解 }语法专题详解介词,是表示两词之间的关系的词。我们在小学英语中学习的英语介词有:时间介词1.on( 1 ) 在------上面The book is on...
  • 万字英语语法总结

    2020-07-05 16:29:48
    英语语法概览 英语句子总体来说大体就分为三大种类:简单句、并列句、复合句 其中最常用的句子结构就是主+谓+宾 即主语(subject)【我】+ 谓语动词(verb)【爱】 + 宾语(object)【你 】 简单句: 主+谓+宾 ...
  • python作为一种编程语言对英语有一定的基础要求。本资源内涵python中常用的各种英文单词,帮助大家更好的学习。并包含python的基本语法,帮助大家快速学习和记忆,并且在编程中,如果遗忘也可快速查询
  • 几个常用时态的比较 1、一般现在时与现在进行时 (1)一般现在时用以说明客观事实,或用于强调动作的永久性、经常或反复性。而现在进行时强调动作正在进行,因此它表示动作含有暂时性(即动作的持续时间是有限的...
  • 小学英语阶段英语语法不多,但是有一些基本的常用语法也要牢记哦,今天小编给大家带来——名词语法口诀,大家在课后常读常背就能快速掌握啦!可数名词的复数变化规律口诀:名词复数有规律,一般词尾加s;辅音字母+y...
  • 英语语法的想法

    2013-04-06 20:52:00
    一直搞不懂英语语法,今天就通过百度的知识和自己的理解整理一下语法知识,以弥补自己在英语写作中的语法错误问题。 先复制,在做具体的总结。 句子的主要成分有:主语、谓语、宾语、定语、补语、状语、表语 ...
  • 编程常用英语词汇

    2019-06-05 19:58:37
    编程常用英语词汇 a block of pointers 一块指针 一组指针 abbreviation 缩略语 abstract 抽象的 abstract syntax tree, AST 抽象语法树 abstraction 抽象 abstraction barrier 抽象屏障 抽象阻碍 ...
  • 英语常用句型.ppt

    2020-08-27 15:24:52
    英语常用句型 初学英语的人常常感到在掌握一些英语单词和基本语法后,在英语说和写方面还是很难表达自己,笔者认为其中一个原因是没有掌握一些英语句型,只有掌握了一些句型才能比较正确、完整地表达型。
  • 本文主要内容是信息与通信工程专业英语,科技书籍的常用语法,本文主要叙述了以it作为形式主语从句,强调句型,动词不定式,分子及分子短语,分词独立结构,介词短语,虚拟语气,令定语从句在以英语为主要书写语言的...
  • #Print() 打印 ...#syntaxError 语法错误 #NameError 名字错误 #Invalid 无效的 #Character 字符 #Exit() 退出 #Directory 文件夹目录 #Help 帮助 #Function 函数 #Built-in(builtins) 内置 #Module 模块 ...
  • 可以进行英语文本的纠错(拼写、语法、格式)和简单的词汇润色,也有解释和词典功能辅助修改错误 gramerly:https://www.grammarly.com/affiliateNetwork=ho&affiliateID=19641 主要用于英语论文的拼写错误、...
  • 英语常用句型

    2012-05-07 11:35:25
    初学英语的人常常感到在掌握一些英语单词和基本语法后,在英语说和写方面还是很难表达自己,笔者认为其中一个原因是没有掌握一些英语句型,只有掌握了一些句型才能比较正确、完整地表达自己。下面是笔者收集的一些...
  • 最全高一英语语法知识点总结 英语的时态语法学习很重要哦,时态语法的正确运用能加分不少。下面就是给大家带来的高一英语语法总结,希望能帮助到大家! 高一英语语法1 表语从句 表语从句在复合句中作表语的名词性...
  • 高二的英语语法知识点归纳大全 关于高二英语语法,大家可能不知道语法知识点怎么归纳。下面为大家整理高二英语语法知识点归纳,提供大家进行提供参考和借鉴。 1. 常用前缀 anti-(antipollution) auto-(automobile...
  • [编程常用英语词汇]

    2020-05-09 09:49:29
    [编程常用英语词汇] A 英文 译法 1 译法 2 译法 3 a block of pointers 一块指针 一组指针 abbreviation 缩略语 abstract 抽象的 abstract syntax tree, AST 抽象语法树 abstraction 抽象 ...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 299
精华内容 119
关键字:

常用语法英语