您现在的位置：首页 > 实用文 > 其他范文

Codeigniter的dom类用法实例

时间：2025-11-28 07:34:55 其他范文收藏本文下载本文

以下是小编整理的Codeigniter的dom类用法实例，本文共3篇，欢迎阅读分享，希望对大家有帮助。

篇1：Codeigniter的dom类用法实例

作者：疯狂的流浪字体：[增加减小] 类型：

这篇文章主要介绍了Codeigniter的dom类用法,实例分析了基于Codeigniter的dom操作技巧,需要的朋友可以参考下

本文实例讲述了Codeigniter的dom类用法，分享给大家供大家参考。具体分析如下：

利用simple_html_dom dom类为CI修改的一个类库,可以像JS一样对HTML元素进行分析,适合与抓取网页时,对网页数据进行的分析。

类库下载地址: sourceforge.net/projects/simplehtmldom/

修改：

把simple_html_dom批量替换为CI_Simple_html_dom，

放置在application\\libraries下：

function index { //$this->load->view(‘welcome_message‘); $this->load->library(‘Simple_html_dom‘); $html = file_get_html(‘localhost/test.htm‘); foreach($html->find(‘a‘) as $e) echo $e->href . ‘

‘; }

希望本文所述对大家基于Codeigniter的php程序设计有所帮助。

篇2：python抽象基类用法实例分析

作者：MaxOmnis 字体：[增加减小] 类型：转载

这篇文章主要介绍了python抽象基类用法,实例分析了Python抽象基类的使用方法与相关注意事项,需要的朋友可以参考下

本文实例讲述了python抽象基类用法，分享给大家供大家参考。具体如下：

定义抽象类，需要使用abc模块，该模块定义了一个元类(ABCMeata)，和装饰器 @abstractmethod， @abstractproperty

如果要实例化继承了Foo 的子类，子类必须实现了Foo所有的抽象方法（跟java一样),否则实例化报错。

抽象类不能直接实例化

#!coding=utf-8from abc import ABCMeta, abstractmethod, abstractpropertyclass Foo: __metaclass__ = ABCMeta. @abstractmethod #在python3.0中使用 class Foo(metaclass=ABCMeta)语法 def spam(self, a, b): pass @abstractproperty def name(self): passclass Bar(Foo): def spam(self, a, b): print a, b def name(): passb = Bar()b.spam(1,2)

抽象基类支持对已经存在的类进行注册，使其属于该基类，使用register()方法

向抽象基类注册某个类，对于注册类中的实例，涉及后续基类的类检测操作比如(isinstance, issubclass) 将返回True，向抽象基类注册某个类时，不会检查该类是否实现了任何抽象方法或特性，这种注册过程只会影响类型检查

class Crok(object): def spam(self, a, c): print “gork.span”Foo.register(Grok)

希望本文所述对大家的Python程序设计有所帮助，

篇3：Python中的对象，方法，类，实例，函数用法分析

Python是一个完全面向对象的语言。不仅实例是对象，类，函数，方法也都是对象。

代码如下:

class Foo(object):

static_attr = True

def method(self):

pass

foo = Foo()

这段代码实际上创造了两个对象，Foo和foo。而Foo同时又是一个类，foo是这个类的实例。

在C++里类型定义是在编译时完成的，被储存在静态内存里，不能轻易修改。在Python里类型本身是对象，和实例对象一样储存在堆中，对于解释器来说类对象和实例对象没有根本上的区别。

在Python中每一个对象都有自己的命名空间。空间内的变量被存储在对象的__dict__里。这样，Foo类有一个__dict__, foo实例也有一个__dict__，但这是两个不同的命名空间。

所谓“定义一个类”，实际上就是先生成一个类对象，然后执行一段代码，但把执行这段代码时的本地命名空间设置成类的__dict__. 所以你可以写这样的代码：

代码如下:

>>>class Foo(object):

... bar = 1 + 1

... qux = bar + 1

... print “bar: ”, bar

... print “qux: ”, qux

... print locals()

...

bar: 2

qux: 3

{‘qux‘: 3, ‘__module__‘: ‘__main__‘, ‘bar‘: 2}

>>>print Foo.bar, Foo.__dict__[‘bar‘]

2 2

>>>print Foo.qux, Foo.__dict__[‘qux‘]

3 3

所谓“定义一个函数”，实际上也就是生成一个函数对象。而“定义一个方法”就是生成一

个函数对象，并把这个对象放在一个类的__dict__中。下面两种定义方法的形式是等价的：

代码如下:

>>>class Foo(object):

... def bar(self):

... return 2

...

>>>def qux(self):

... return 3

...

>>>Foo.qux = qux

>>>print Foo.bar, Foo.__dict__[‘bar‘]

>>>print Foo.qux, Foo.__dict__[‘qux‘]

>>>foo = Foo()

>>>foo.bar()

>>>foo.qux()

而类继承就是简单地定义两个类对象，各自有不同的__dict__:

代码如下:

>>>class Cheese(object):

... smell = ‘good‘

... taste = ‘good‘

...

>>>class Stilton(Cheese):

... smell = ‘bad‘

...

>>>print Cheese.smell

good

>>>print Cheese.taste

good

>>>print Stilton.smell

bad

>>>print Stilton.taste

good

>>>print ‘taste‘ in Cheese.__dict__

True

>>>print ‘taste‘ in Stilton.__dict__

False

复杂的地方在`.`这个运算符上。对于类来说，Stilton.taste的意思是“在Stilton.__dict__中找‘taste‘. 如果没找到，到父类Cheese的__dict__里去找，然后到父类的父类，等等。如果一直到object仍没找到，那么扔一个AttributeError.”

实例同样有自己的__dict__：

代码如下:

>>>class Cheese(object):

... smell = ‘good‘

... taste = ‘good‘

... def __init__(self, weight):

... self.weight = weight

... def get_weight(self):

... return self.weight

...

>>>class Stilton(Cheese):

... smell = ‘bad‘

...

>>>stilton = Stilton(‘100g‘)

>>>print ‘weight‘ in Cheese.__dict__

False

>>>print ‘weight‘ in Stilton.__dict__

False

>>>print ‘weight‘ in stilton.__dict__

True

不管__init__()是在哪儿定义的， stilton.__dict__与类的__dict__都无关。

Cheese.weight和Stilton.weight都会出错，因为这两个都碰不到实例的命名空间。而

stilton.weight的查找顺序是stilton.__dict__ =>Stilton.__dict__ =>

Cheese.__dict__ =>object.__dict__. 这与Stilton.taste的查找顺序非常相似，仅仅是

在最前面多出了一步。

方法稍微复杂些。

代码如下:

>>>print Cheese.__dict__[‘get_weight‘]

>>>print Cheese.get_weight

>>>print stilton.get_weight

<__main__.Stilton object at 0x7ff820669190>>

我们可以看到点运算符把function变成了unbound method. 直接调用类命名空间的函数和点

运算返回的未绑定方法会得到不同的错误：

代码如下:

>>>Cheese.__dict__[‘get_weight‘]()

Traceback (most recent call last):

File “”, line 1, in

TypeError: get_weight() takes exactly 1 argument (0 given)

>>>Cheese.get_weight()

Traceback (most recent call last):

File “”, line 1, in

TypeError: unbound method get_weight() must be called with Cheese instance as

first argument (got nothing instead)

但这两个错误说的是一回事，实例方法需要一个实例，

所谓“绑定方法”就是简单地在调用方法时把一个实例对象作为第一个参数。下面这些调用方法是等价的：

代码如下:

>>>Cheese.__dict__[‘get_weight‘](stilton)

‘100g‘

>>>Cheese.get_weight(stilton)

‘100g‘

>>>Stilton.get_weight(stilton)

‘100g‘

>>>stilton.get_weight()

‘100g‘

最后一种也就是平常用的调用方式，stilton.get_weight()，是点运算符的另一种功能，将stilton.get_weight()翻译成stilton.get_weight(stilton).

这样，方法调用实际上有两个步骤。首先用属性查找的规则找到get_weight, 然后将这个属性作为函数调用，并把实例对象作为第一参数。这两个步骤间没有联系。比如说你可以这样试：

代码如下:

>>>stilton.weight()

Traceback (most recent call last):

File “”, line 1, in

TypeError: ‘str‘ object is not callable

先查找weight这个属性，然后将weight做为函数调用。但weight是字符串，所以出错。要注意在这里属性查找是从实例开始的：

代码如下:

>>>stilton.get_weight = lambda : ‘200g‘

>>>stilton.get_weight()

‘200g‘

但是

代码如下:

>>>Stilton.get_weight(stilton)

‘100g‘

Stilton.get_weight的查找跳过了实例对象stilton，所以查找到的是没有被覆盖的，在Cheese中定义的方法。

getattr(stilton, ‘weight‘)和stilton.weight是等价的。类对象和实例对象没有本质区别，getattr(Cheese, ‘smell‘)和Cheese.smell同样是等价的。getattr()与点运算符相比，好处是属性名用字符串指定，可以在运行时改变。

__getattribute__()是最底层的代码。如果你不重新定义这个方法，object.__getattribute__()和type.__getattribute__()就是getattr()的具体实现，前者用于实例，后者用以类。换句话说，stilton.weight就是object.__getattribute__(stilton, ‘weight‘). 覆盖这个方法是很容易出错的。比如说点运算符会导致无限递归：

代码如下:

def __getattribute__(self, name):

return self.__dict__[name]

__getattribute__()中还有其它的细节，比如说descriptor protocol的实现，如果重写很容易搞错。

__getattr__()是在__dict__查找没找到的情况下调用的方法。一般来说动态生成属性要用这个，因为__getattr__()不会干涉到其它地方定义的放到__dict__里的属性。

代码如下:

>>>class Cheese(object):

... smell = ‘good‘

... taste = ‘good‘

...

>>>class Stilton(Cheese):

... smell = ‘bad‘