May 13, 2019 - odoo-code-example

(一)数据模型

部分表名称

res_users 用户
res_groups 用户组(角色)
res_lang 语言
res_partner 供应商/客户/联系人
res_font 字体
res_company 公司
res_bank 银行
res_country 国家
res_country_state 州/省
res_currency 货币
res_currency_rate 汇率
ir_ui_menu 菜单 
ir_act_window 菜单动作
ir_act_window_view 菜单动作与视图的对应关系
ir_ui_view 视图
ir_cron 计划的动作
wkf 工作流
wkf_activity 活动
wkf_transition 迁移
sale_order 报价单/销售订单
sale_order_line 销售订单明细行
purchase_order 询价单/采购订单
purchase_order_line 采购订单明细行
product_category 产品分类
product_product 产品
product_template 产品信息
product_uom 计量单位
product_pricelist 价格表
product_pricelist_version 价格表版本
product_price_type 计价类型
stock_warehouse 仓库
stock_location 库位
stock_picking 分拣单(出库/入库/内部移动)
stock_move 库存移动(移库单)
stock_quant 库存分析
stock_inventory 库存盘点
stock_inventory_line 库存盘点明细
stock_production_lot 序列号(产品批次)
stock_warehouse_orderpoint 再订货规则
procurement_rule 补货规则(拉式流)
procurement_order 补货单
stock_location_route 路线
account_asset_category 固定资产类别
account_asset_asset 固定资产
account_account 会计科目
account_account_type 科目类型
account_tax 税
account_fiscalyear 会计年度
account_period 会计期间
account_invoice 发票
account_invoice_line 发票明细
account_move 会计凭证(会计分录)
account_move_line 会计凭证明细
account_voucher 记账凭证(收付款凭证)
account_voucher_line 记账明细
account_journal 凭证类型

创建数据模型 =========

  # -*- coding: utf-8 -*- 
  from odoo import models, fields 
  class TodoTask(models.Model): 
   _name = 'todo.task' 
   _description = 'To-do Task'
   name = fields.Char('Description', required=True) 
   is_done = fields.Boolean('Done?') 
   active = fields.Boolean('Active?', default=True) 

测试 =========

# -*- coding: utf-8 -*-
from odoo.tests.common import TransactionCase
class TestTodo(TransactionCase):
def test_create(self):
    "Create a simple Todo"
    Todo = self.env['todo.task']
    task = Todo.create({'name': 'Test Task'})
    self.assertEqual(task.is_done, False)

执行 $ ./odoo-bin -d todo -i todo_app –test-enable进行测试

下面动作的测试函数

   # def test_create(self):
        # ...
        # Test Toggle Done
        task.do_toggle_done()
        self.assertTrue(task.is_done)
        # Test Clear Done
        Todo.do_clear_done()
        self.assertFalse(task.active)

测试安全访问权限

  #class TestTodo(TransactionCase):
        def setUp(self,* args,** kwargs):
            result = super(TestTodo,self).setUp(* args,\
            ** kwargs)
            user_demo = self.env.ref('base.user_demo')
            self.env = self.env(user = user_demo)
            return result

向模型添加字段

类继承

# -*- coding: utf-8 -*-
  from odoo import models, fields, api
  class TodoTask(models.Model):
  _inherit = 'todo.task'
  user_id = fields.Many2one('res.users', 'Responsible')
  date_deadline = fields.Date('Deadline')

接下来在model文件夹里面还需要创建一个__init__.py文件,代码如下:

#-*- coding:utf-8 -*-
#!/usr/bin/env python
from . import todo_task

通过继承方式也可以对父类的字段进行属性修改,它是通过向子类添加和父类具有相同名称的字段来完成的,但是只能对字段进行属性的设置。 举例,如果我们要给当前例子的父类的name field添加一个帮助信息,我们可以在子类的todo_task.py文件里面类的成员添加如下代码: name = fields.Char(help="What needs to be done?") 注意:这个name是父类的属性

继承也在业务逻辑级别起作用。添加新方法很简单:只需在继承类中声明新的函数。
要扩展或更改现有逻辑,可以通过声明具有完全相同名称的方法来覆盖相应的方法。新方法将替换前一个方法,它也可以只是扩展继承类的代码,使用Python的super()方法来调用父方法。然后,可以在调用super()方法之前和之后,在原有逻辑周围添加新逻辑。

 from odoo.exceptions import ValidationError  
 # ...
 # class TodoTask(models.Model):
 # ...
 @api.one
 def do_toggle_done(self):
   if self.user_id != self.env.user:
     raise Exception('Only the responsible can do this!')
   else:
     return super(TodoTask, self).do_toggle_done()

原型继承复制特征

from odoo import models 
class TodoTask(models.Model): 
_name = 'todo.task' 
_inherit = 'mail.thread'

使用委托继承嵌入模型

from odoo import models, fields 
class User(models.Model): 
_name = 'res.users' 
_inherits = {'res.partner': 'partner_id'} 
partner_id = fields.Many2one('res.partner')

请注意,使用委托继承,字段是继承的,但方法不是。

(一)视图

添加菜单

<?xml version="1.0"?> 
<odoo> 
 <act_window id="action_todo_task" 
   name="To-do Task" 
   res_model="todo.task" 
   view_mode="tree,form" /> 
 <menuitem id="menu_todo_task" 
   name="Todos" 
   action="action_todo_task" /> 
</odoo> 

修改菜单和操作记录

   < ! — — 修改菜单项-->
   <record id="todo_app.menu_todo_task" model="ir.ui.menu">
       <field name="name">My To-Do</field>
   </record>
   <record model="ir.actions.act_window"
    id="todo_app.action_todo_task">
       <field name="context">
          {'search_default_filter_my_tasks': True}
       </field>
   </record>   

(一)视图 =========

<?xml version="1.0"?> 
<odoo> 
 <record id="view_form_todo_task" model="ir.ui.view"> 
   <field name="name">To-do Task Form</field> 
   <field name="model">todo.task</field> 
   <field name="arch" type="xml"> 
   <form>
       <header>
           <button name="do_toggle_done" type="object" string="Toggle Done" class="oe_highlight" />
           <button name="do_clear_done" type="object" string="Clear All Done" />
       </header>
       <sheet>
           <group name="group_top">
               <group name="group_left">
                   <field name="name"/>
               </group>
               <group name="group_right">
                   <field name="is_done"/>
                   <field name="active" readonly="1" />
               </group>
           </group>
       </sheet>
   </form>
   </field> 
 </record> 
</odoo>

列表视图(tree)

<record id="view_tree_todo_task" model="ir.ui.view"> 
 <field name="name">To-do Task Tree</field> 
 <field name="model">todo.task</field> 
 <field name="arch" type="xml"> 
   <tree decoration-muted="is_done==True"> 
     <field name="name"/> 
     <field name="is_done"/> 
   </tree> 
 </field> 
</record>

搜索视图

<record id="view_filter_todo_task" model="ir.ui.view"> 
 <field name="name">To-do Task Filter</field> 
 <field name="model">todo.task</field> 
 <field name="arch" type="xml"> 
   <search> 
     <field name="name"/> 
     <filter string="Not Done" 
       domain="[('is_done','=',False)]"/> 
     <filter string="Done" 
       domain="[('is_done','!=',False)]"/> 
   </search> 
 </field> 
</record> 

扩展视图

   <record id="view_form_todo_task_inherited" model="ir.ui.view">
       <field name="name">Todo Task form - User extension</field>
       <field name="model">todo.task</field>
       <field name="inherit_id" ref="todo_app.view_form_todo_task"/>
       <field name="arch" type="xml">
           <field name="name" position="after">
               <field name="user_id" />
           </field>
           <field name="is_done" position="before">
               <field name="date_deadline" />
           </field>
           <field name="active" position="attributes">
               <attribute name="invisible">1</attribute>
           </field>
       </field>
    </record> 

下面是一个写在arch中的实现在is_done字段之前添加date_deadline字段的具体例子:

    <xpath expr="//field[@name='is_done']" position="before">
       <field name="date_deadline" />
   </xpath> 

快捷方式

    <field name="is_done" position="before">
      <field name="date_deadline" />
   </field> 

after:将内容添加到父元素之中,匹配的节点之后。
before:添加内容在匹配节点之前。
inside(默认值):匹配节点内的追加内容。
replace:替换匹配的节点。如果使用空内容,它将删除该匹配的元素。从Odoo 10开始,它还允许用其他标记包装一个元素,通过在内容中使用$0来表示被替换的元素。
attributes:修改匹配元素的XML属性。在元素内容使用<attribute name =“attr-name”>实现给属性name设置新属性值attr-name。

扩展树视图

   <record id="view_tree_todo_task_inherited" model="ir.ui.view">
       <field name="name">Todo Task tree - User extension</field>
       <field name="model">todo.task</field>
       <field name="inherit_id" ref="todo_app.view_tree_todo_task"/>
       <field name="arch" type="xml">
            <field name="name" position="after"> 
                <field name="user_id" />
            </field>
       </field>
    </record>

扩展搜索视图

   <record id="view_filter_todo_task_inherited" model="ir.ui.view">
       <field name="name">Todo Task tree - User extension</field>
       <field name="model">todo.task</field>
       <field name="inherit_id" ref="todo_app.view_filter_todo_task"/>
       <field name="arch" type="xml">
           <field name="name" position="after">
               <field name="user_id" />
               <filter name="filter_my_tasks" string="My Tasks" domain="[('user_id','in',[uid,False])]" />
               <filter name="filter_not_assigned" string="Not Assigned" domain="[('user_id','=',False)]" />
           </field> 
       </field>
    </record> 

(三)业务逻辑

from odoo import models, fields, api
@api.multi 
def do_toggle_done(self): 
   for task in self: 
       task.is_done = not task.is_done 
   return True

通常表单按钮只能对选定的记录起作用,但在这种情况下,我们希望它也对除当前记录之外的记录起作用,所以使用@api.model装饰符

from odoo import models, fields, api
@api.model 
def do_clear_done(self): 
   dones = self.search([('is_done', '=', True)]) 
   dones.write({'active': False}) 
   return True

写入方法同时对记录集的所有元素设置值。 要写入的值使用字典进行描述。 在这里使用write比遍历记录集更有效率,以便逐一为每个记录集赋值。

访问控制安全

security/ir.model.access.csv。添加以下内容︰

id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
acess_todo_task_group_user,todo.task.user,model_todo_task,base.group_user,1,1,1,1

Row-level访问规则

security/todo_access_rules.xml

<?xml version="1.0" encoding="utf-8"?>
<odoo>
    
        <record id="todo_task_user_rule" model="ir.rule">
            <field name="name">ToDo Tasks only for owner</field>
            <field name="model_id" ref="model_todo_task"/>
            <field name="domain_force">[('create_uid','=',user.id)]</field>
            <field name="groups" eval="[(4,ref('base.group_user'))]"/>
        </record>
    
</odoo>

小心noupdate =”1”属性。这意味着此数据在模块的升级时将不会更新。这就使它能够进行定制,因为后面模块的升级不会破坏用户进行的更改。但请注意,在开发的时候也会这样,所以在开发的时候你可以设置noupdate =”0” ,直到你对你的数据文件满意为止。
在groups字段,你还会发现一个特殊的表达式。它是一个一对多的关系字段,他们有特殊的操作语法。在这种情况下, (4,x) 元组指要追加 x 记录,这里 的x 是关联的员工组,用base.group_user标识的。
修改安全记录规则
覆盖todo_app.todo_task_user_rule以将domain_force字段修改为新值

 <?xml version =“1.0”encoding =“utf-8”?>
   <odoo>
    <data noupdate =“1”>
        <record id =“todo_app.todo_task_per_user_rule”model =“ir.rule”>
           <field name =“name”>所有者和关注者的ToDo任务</ field>
           <field name =“model_id”ref =“model_todo_task”/>
           <field name =“groups”eval =“[(4,ref('base.group_user'))]”/>
            <field name =“domain_force”>['|',('user_id','in',[user.id,False]),('message_follower_ids','in',[user.partner_id.id])]  </field>
        </ record>
    </ data>
  </ odoo>

  本人的更多原创文章请加入个人微信公众号。

Mar 12, 2019 - How To Use Smiley

layout: post title: “python调试工具Smiley使用手册” date: 2019-3-12 08:15:00 +0800 categories: jekyll update — python调试工具Smiley使用手册 === 原文:https://smiley.readthedocs.io/en/latest/ Smiley is a tool for spying on your Python programs and recording their activities. It can be used for post-mortem debugging, performance analysis, or simply understanding what parts of a complex program are actually used in different code paths. Smiley是一个工具,用于监视您的Python程序并记录它们的活动。它可以用于事后调试、性能分析,或者简单地理解复杂程序的实际执行的不同代码路径。

一、快速指南 1、安装 $ pip install smiley

2、使用 在一个终端下执行:(test.py是smiley软件包test_app目录下的示例) $ smiley monitor 在另一个终端下执行: smiley run ./test.py smiley run –remote ./test.py 监视器会话将显示应用程序的执行路径和局部变量。

3、将参数传递给跟踪程序 $ smiley run – ./test.py -e –将命令序列与运行选项分开

二、命令参考 run Run an application and trace its execution.

monitor Listen for trace data from an application running under the run command.

record Listen for trace data from an application running under the run command and write it to a database for later analysis.

list Show the runs previously recorded in the database.

delete Delete runs from the database.

replay Given a single run id, dump the data from that run in the same format as the monitor command.

server Run a web server for browsing the pre-recorded run data collected by the record command.

report Export a set of HTML files describing the pre-recorded run data collected by the record command.

stats show Show the profiling data from a run.

stats export Dump the profiling data from a run to a local file.

help Get help for the smiley command or a subcommand.

三、服务器模式 服务器命令在本地端口上启动Web服务器,为浏览记录和运行捕获的运行数据提供用户界面。它连接到同一个数据库,因此当捕获新的运行时,它们将出现在用户界面中。

1、Run List 服务器监听http://127.0.0.1:8080 默认情况下。在浏览器中访问该页面会使服务器以反向时间顺序返回数据库中的运行列表。对于每次运行,该列表显示其id、“Description”、开始和结束时间以及任何最终错误消息。单击最左边列中的“X”链接将永久删除从数据库中运行的链接。

2、运行详细信息 单击其中一个Run id值将打开为该运行记录的详细信息。详细信息页显示程序运行时的逐行状态,包括程序控件所在的位置(文件名、行号和源行)以及局部变量和函数的返回值。这是由监控器和重放,以一种更容易阅读的格式。

3、源文件 RunDetails视图中的每个文件名都链接到一个页面,该页面显示Python文件的完整来源,就像在程序执行时一样。

4、文件列表 对于具有多个源文件的应用程序,可以通过导航到文件列表视图并从列表中选择文件来检查源代码。

5、统计分析 stats视图显示运行的分析器输出,并按累积时间排序。与运行详细信息一样,每个文件名都链接到模块的完整源代码

6、调用图 调用图视图使用gprof2dot和图文生成一个树图,显示在程序的不同部分中使用了多少时间,以便更容易地将注意力集中在使用时间最多的区域上。

注 若要使此页面正常工作,dot命令必须已安装。安装smiley应该自动安装gprof2dot的。

Mar 1, 2019 - python内置对象说明

python内置对象说明

dir(builtins):打印所有内置对象,内置函数可以参考:[]!http://www.runoob.com/python/python-built-in-functions.html

  • build_class’, build_class 函数是创建类对象过程中的一个核心函数

  • debug’, 只读变量,参考:[]!https://blog.csdn.net/you_are_my_dream/article/details/53328293

  • doc’, 每个对象都会有一个__doc__属性,用于描述该对象的作用。在一个模块被import时,其文件中的某些特殊的字符串会被python解释器保存在相应对象的__doc__属性中。比如,一个模块有模块的__doc__,一个class或function也有其对应的__doc__属性。在python中,一个模块其实就是一个.py文件。在文件中特殊的地方书写的字符串就是所谓的docstrings,就是将被放到__doc__的内容。这个“特殊的地方”包括:

    1. 一个文件任何一条可执行的代码之前 #模块的__doc__
    2. 一个类,在类定义语句后,任何可执行代码前#类的__doc__
    3. 一个函数,在函数定义语句后,任何可执行代码前#函数的__doc__ ``` #use doc 属性 class MyClass: ‘string.’ def printSay(): ‘print say welcome to you.’ print ‘say welcome to you.’ print MyClass.doc print MyClass.printSay.doc

#输出结果 string. print say welcome to you.


* '__import__', 
import导入的是一个标准模块,而标准模块的概念是一个文件夹里面必须包含__init__.py文件。它的作用更像是一种声明,且import模块进来之后,万一原本的模块有什么变化,可以通过reload()进行重新加载。
__import__()作为一个函数,只能接受字符串参数,返回值可以直接用来操作,通常在动态加载的时候用到这个函数,最常见的情景就是插件功能的支持。

* '__loader__', 
[]!https://www.cnblogs.com/baishoujing/p/6358685.html 
'__loader__'是由加载器在导入的模块上设置的属性,访问它时将会返回加载器对象本身。

* '__name__', 
显示了当前模块执行过程中的名称,如果当前程序运行在这个模块中,__name__ 的名称就是__main__如果不是,则为这个模块的名称

* '__package__', 
获取导入文件的路径,多层目录以点分割,注意:对当前文件返回None

* '__spec__', TODO(找不到)

* 'abs', 
绝对值

* 'all', 
* 'any', 
all() # 全为真,输出Ture , 则输出Flase
any() # 只要有真,输出Ture,则输出Flase
0,None,"",[],(),{}  表示False

n1 = all([1,2,3,[],None]) print (n1)

False

n2 = any([1,0,””,[]]) print (n2)

True

n1 = all([1,2,3,[],None]) print (n1)

False

n2 = any([1,0,””,[]]) print (n2)

True


* 'ascii', 
自动执行对象的__repr__方法

* 'bin', 
将十进制转为二进制  0b 表示二进制

* 'bool',
布尔值
0,None,"",[],(),{}  表示False

* 'breakpoint', 
Python 3.7添加了breakpoint(),这个内置函数使得函数被调用时,让执行切换到调试器。相应的调试器不一定是Python自己的pdb,可以是之前被设为首选调试器的任何调试器。以前,调试器不得不手动设置,然后调用,因而使代码更冗长。而有了breakpoint(),只需一个命令即可调用调试器,并且让设置调试器和调用调试器泾渭分明。

* 'bytearray', 
根据传入的参数创建一个新的字节数组

bytearray(‘中文’,’utf-8’) bytearray(b’\xe4\xb8\xad\xe6\x96\x87’)

* 'bytes',
根据传入的参数创建一个新的不可变字节数组

bytes(‘中文’,’utf-8’) b’\xe4\xb8\xad\xe6\x96\x87’ ```

  • ‘callable’, 检测传递的值是否可以调用
    def f1():
      pass
    f1()
    f2 = 123
    print (callable(f1))
    # True
    print (callable(f2))
    # False
    
  • ‘chr’, 输出 ASCII的对应关系,chr()输出十进制位置的字符,ord()输出字符在ASCii表的位置
    print (chr(65))
    # A
    print (ord("A"))
    # 65
    
  • ‘classmethod’, classmethod 是一个装饰器函数,用来标示一个方法为类方法。类方法的第一个参数是类对象参数,在方法被调用的时候自动将类对象传入,参数名称约定为cls。如果一个方法被标示为类方法,则该方法可被类对象调用(如 C.f()),也可以被类的实例对象调用(如 C().f()) ```

    class C: @classmethod def f(cls,arg1): print(cls) print(arg1)

C.f(‘类对象调用类方法’)

<class ‘main.C’> 类对象调用类方法

c = C() c.f(‘类实例对象调用类方法’)

<class ‘main.C’> 类实例对象调用类方法


* 'compile', 
编译,将字符串编译成python代码,见exec

* 'complex', 
返回一个复数。有两个可选参数。当两个参数都不提供时,返回复数 0j。

* 'copyright', 
版权信息

* 'credits', 
感谢信息

* 'dict', 
用于创建一个字典

* 'dir', 
快速获取模块,对象提供的功能

* 'divmod',
得到商和余数

* 'enumerate',
多用于在for循环中得到计数,利用它可以同时获得索引和值,即需要index和value值的时候可以使用enumerate

#指定索引从1开始

lst = [1,2,3,4,5,6] for index,value in enumerate(lst,1): print (‘%s,%s’ % (index,value)) 1,1 2,2 3,3 4,4 5,5 6,6 ```

  • ‘eval’, 执行表达式,并且获取结果 eval有返回值,exec没返回值

  • ‘exec’, 执行python代码 eval有返回值,exec没返回值
    s = "print('hello,python~')"
    r = compile(s,"<string>","exec")
    exec (r)
    
  • ‘exit’, sys.exit(n) 退出程序引发SystemExit异常,可以捕获异常执行些清理工作。n默认值为0,表示正常退出,其他都是非正常退出。还可以sys.exit(“sorry, goodbye!”); 一般主程序中使用此退出。 os._exit(n), 直接退出, 不抛异常, 不执行相关清理工作。常用在子进程的退出。 exit()/quit(),跑出SystemExit异常。一般在交互式shell中退出时使用。

  • ‘filter’, 函数返回值为Ture,将元素添加结果中,filter 循环第二个参数,让每个循环元素执行函数,如果函数返回值为Ture,表示函数合法 ``` def f1(args): result = [] for item in args: if item > 22: result.append(item) return result li = [11,22,33,44,55,66,77,88] ret = f1(li) print (ret)

    [33, 44, 55, 66, 77, 88]

优化示例1

def f2(a): if a > 22: return True ls1 = [11,22,33,44,55,66,77] res1 = filter(f2,ls1) print(list(res1))

[33, 44, 55, 66, 77]

知识扩展,lambda 函数

res2 = filter(lambda x:x > 22,ls1) print (res2) # 返回一个filter object

<filter object at 0x000000E275771748>

print (list(res2))

[33, 44, 55, 66, 77]


* 'float', 
函数用于将整数和字符串转换成浮点数

* 'format', 
函数功能将一个数值进行格式化显示。如果参数format_spec未提供,则和调用str(value)效果相同,转换成字符串格式化。
参考:[]!https://www.cnblogs.com/sesshoumaru/p/6005368.html

#整形数值可以提供的参数有 ‘b’ ‘c’ ‘d’ ‘o’ ‘x’ ‘X’ ‘n’ None

format(3,’b’) #转换成二进制 ‘11’ format(97,’c’) #转换unicode成字符 ‘a’ format(11,’d’) #转换成10进制 ‘11’ format(11,’o’) #转换成8进制 ‘13’ format(11,’x’) #转换成16进制 小写字母表示 ‘b’ format(11,’X’) #转换成16进制 大写字母表示 ‘B’ format(11,’n’) #和d一样 ‘11’ format(11) #默认和d一样 ‘11’ ```

  • ‘frozenset’, 传入一个可迭代对象,生成一个新的不可变集合。
    >>> a = frozenset(range(10))
    >>> a
    frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
    
  • ‘globals’, 所有的全局变量

  • ‘hasattr’, 函数功能用来检测对象object中是否含有名为name的属性,如果有则返回True,如果没有返回False

  • ‘hash’, 生成一个hash值(字符串)

  • ‘help’, 快速获取模块,对象提供的功能

  • ‘hex’, 将十进制转为十六进制 0x 表示十六进制

  • ‘id’, 函数用于获取对象的内存地址

  • ‘input’, 如果提供了promat参数,首先将参数值输出到标准的输出,并且不换行。函数读取用户输入的值,将其转换成字符串。
    >>> s = input('please input your name:')
    please input your name:Ain
    >>> s
    'Ain'
    
  • ‘int’, 把其他类型转换为整数

  • ‘isinstance’, isinstance(object, classinfo) 函数功能用于判断对象是否是类型对象的实例,object参数表示需要检查的对象,calssinfo参数表示类型对象。如果object参数是classinfo类型对象(或者classinfo类对象的直接、间接、虚拟子类)的实例,返回True。

  • ‘issubclass’, issubclass(class, classinfo) 函数功能用于判断一个类型对象是否是另一个类型对象的子类,class参数表示需要检查的类型对象,calssinfo参数表示需要对比类型对象。如果class参数是classinfo类型对象(或者classinfo类对象的直接、间接、虚拟子类)的实例,返回True

  • ‘iter’, 函数功能返回一个迭代器对象。当第二个参数不提供时,第一个参数必须是一个支持可迭代协议(即实现了__iter__()方法)的集合(字典、集合、不可变集合),或者支持序列协议(即实现了__getitem__()方法,方法接收一个从0开始的整数参数)的序列(元组、列表、字符串),否则将报错。
     l = [1, 2, 3]
    for i in iter(l):
        print(i)
    

    如果传递了第二个参数,则object必须是一个可调用的对象(如,函数)。此时,iter创建了一个迭代器对象,每次调用这个迭代器对象的__next__()方法时,都会调用object。 如果__next__的返回值等于sentinel,则抛出StopIteration异常,否则返回下一个值

      class TestIter(object):
     
          def __init__(self):
              self.l=[1,2,3,4,5]
              self.i=iter(self.l)
          def __call__(self):  #定义了__call__方法的类的实例是可调用的
              item = next(self.i)
              print ("__call__ is called,which would return",item)
              return item
          def __iter__(self): #支持迭代协议(即定义有__iter__()函数)
              print ("__iter__ is called!!")
              return iter(self.l)
     
      t = TestIter()  # t是可调用的
      t1 = iter(t, 3)  # t必须是callable的,否则无法返回callable_iterator
      print(callable(t))
      for i in t1:
          print(i)
    # 它每次在调用的时候,都会调用__call__函数,并且最后输出3就停止了。
    
  • ‘len’, 输出对象的长度

  • ‘license’, 打印license

  • ‘list’, 列表,可将元组,字符串等转换为列表。

  • ‘locals’, 所有的局部变量

  • ‘map’, 将函数返回值添加结果中,(函数,可迭代的对象(可以for循环)) ``` def f1(args): result = [] for i in args: result.append(i + 100) return result lst1 = [11,22,33,44,55,66] rest = f1(lst1) print (list(rest))

    [111, 122, 133, 144, 155, 166]

优化示例2,,,map函数

def f2(a): return a + 100 lst2 = [11,22,33,44,55,66] result1 = map(f2,lst2) print (list(result1))

[111, 122, 133, 144, 155, 166]

优化示例2,map函数+lambda函数

lst3 = [11,22,33,44,55,66] result2 = map(lambda a:a+100,lst3) print (list(result2))

[111, 122, 133, 144, 155, 166]


* 'max', 
最大值

lit = [11,22,33,44,55] print (max(lit)) print (min(lit)) print (sum(lit))


* 'memoryview', 
该函数会创建一个引用自 obj 的内存视图(memoryview)对象。内存视图对象允许 Python 代码访问支持缓冲区协议(buffer protocol)的对象的内部数据,且无需拷贝。
obj 必须支持缓冲区协议(buffer protocol)。支持缓冲区协议的内置对象有 bytes 和 bytearray。bytes 和 bytearray 由 memoryview 提供支持,内存视图使用缓冲区协议(buffer protocol)访问来访问其它二进制对象的内存,且无需拷贝。
示例 - 使用内存视图对象修改一个短整型有符号整数数组的数据

from array import array

numbers = array(‘h’, [-2, -1, 0, 1, 2]) # ‘h’表示signed short memv = memoryview(numbers) len(memv) #> 5

转换成列表形式

memv.tolist() #> [-2, -1, 0, 1, 2]

转换成无符号字符类型

memv_oct = memv.cast(‘B’)
memv_oct.tolist() #> [254, 255, 255, 255, 0, 0, 1, 0, 2, 0]

修改第3个元素的高位字段

memv_oct[5] = 4
numbers #> array(‘h’, [-2, -1, 1024, 1, 2])


* 'min', 
最小值

* 'next', 
 函数必须接收一个可迭代对象参数,每次调用的时候,返回可迭代对象的下一个元素。如果所有元素均已经返回过,则抛出StopIteration 异常

* 'object', 
Object类是Python中所有类的基类,如果定义一个类时没有指定继承那个类,则默认继承object类

* 'oct', 
将十进制转为八进制  0o 表示八进制

* 'open',
open函数,该函数用于处理文件,参考[]!https://www.cnblogs.com/sesshoumaru/p/6047046.html

* 'ord',
见'chr'

* 'pow', 
求指数

print(pow(2,10))


* 'print', 
用于打印输出,最常见的一个函数
参考:[]!http://www.runoob.com/python/python-func-print.html

* 'property',
* 'setattr', 
* 'getattr', 
* 'delattr', 
property()函数中的三个函数分别对应的是获取属性的方法、设置属性的方法以及删除属性的方法,这样一来,外部的对象就可以通过访问x的方式,来达到获取、设置或删除属性的目的。

class Shuxing(): def init(self, size = 10): self.size = size def getSize(self): return self.size def setSize(self, value): self.size = value def delSize(self): del self.size x = property(getSize, setSize, delSize)

sx = Shuxing(100) sx.x 100 sx.x= 106 sx.x 106 del sx.x sx.x Traceback (most recent call last): File “<pyshell#60>”, line 1, in sx.x File "<pyshell#54>", line 5, in getSize return self.size AttributeError: 'Shuxing' object has no attribute 'size' ```

  • ‘quit’, 同exit()

  • ‘range’, 可创建一个整数列表,一般用在 for 循环中 语法:range(start, stop[, step]) start: 计数从 start 开始。默认是从 0 开始。例如range(5)等价于range(0, 5); stop: 计数到 stop 结束,但不包括 stop。例如:range(0, 5) 是[0, 1, 2, 3, 4]没有5 step:步长,默认为1。例如:range(0, 5) 等价于 range(0, 5, 1)
    >>>range(10)        # 从 0 开始到 10
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    
  • ‘repr’, 函数功能返回一个对象的字符串表现形式。其功能和str函数比较类似,但是两者也有差异:函数str() 用于将值转化为适于人阅读的形式,而repr() 转化为供解释器读取的形式。
    >>> a = 'some text'
    >>> str(a)
    'some text'
    >>> repr(a)
    "'some text'"
    
  • ‘reversed’, 反转
    lit1 = [11,22,33,44,55,66]
    print (list(reversed(lit1)))
    # [66, 55, 44, 33, 22, 11]
    

    ‘round’, 四舍五入求值

  • ‘set’, 函数创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等

  • ‘slice’, slice() 函数实现切片对象,主要用在切片操作函数里的参数传递。

  • ‘sorted’, 排序 等同于列表的sort

  • ‘staticmethod’,
  • ‘str’, 字节转化为字符串 ```

    将字符串转换为字节类型,系统中的表现形式为16进制

    bytes(字符串,编码格式)

    s = “中国” n3 = bytes(s,encoding=”utf-8”) print (n3)

    b’\xe4\xb8\xad\xe5\x9b\xbd’

    n4 = bytes(s,encoding=”gbk”) print (n4)

    b’\xd6\xd0\xb9\xfa’

n5 = str(b’\xd6\xd0\xb9\xfa’,encoding=”gbk”) print (n5)

中国

n6 = str(b’\xe4\xb8\xad\xe5\x9b\xbd’,encoding=”utf-8”) print (n6)

中国

'sum', 
求和

* 'super', 
函数是用于调用父类(超类)的一个方法
Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx

* 'tuple', 
将列表转换为元组

* 'type', 
type() 函数如果你只有第一个参数则返回对象的类型,三个参数返回新的类型对象。 
isinstance() 与 type() 区别:
type() 不会认为子类是一种父类类型,不考虑继承关系。
isinstance() 会认为子类是一种父类类型,考虑继承关系。 
如果要判断两个类型是否相同推荐使用 isinstance()。

* 'vars', 
返回对象object的属性和属性值的字典对象

* 'zip',
函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表

l1 = [“hello”,11,22,33] l2 = [“world”,44,55,66] l3 = [“python”,77,88,99] l4 = zip(l1,l2,l3)

print (list(l4))

# [(‘hello’, ‘world’, ‘python’), (11, 44, 77), (22, 55, 88), (33, 66, 99)]

temp1 = list(l4)[0] print (temp1[0]) ret1 = “ “.join(temp1) print (ret1)

hello world python

```