python中class是什么意思（python里面class spider什么意思）

本文目录

• python里面class spider什么意思
• python代码 allinstances = classes是什么意思
• 关于python里定义class的问题
• python关于class问题 小白求解答
• python中 A=ClassA() ClassB(A) 这是什么意思

python里面class spider什么意思

class 是定义类的方法，即定义一个

spider

类

python代码 allinstances = classes是什么意思

　　Python中的类(classes)
　　Python的类机制使用尽可能少的新语法和语义将类引入语言。Python的类提供了面向对象程序设计语言所有的 标准特性：类继承机制允许有多个基类，一个派生类可以覆盖基类中的任何方法，一个方法可以使用相同的名字调用 基类中的方法。
　　Table of Contents
　　1 名字和对象
　　2 Python的域(scopes)和名称空间(namespaces)
　　3 初识类
　　3.1 定义类
　　3.2 类对象
　　3.3 实例化对象
　　3.4 方法对象
　　4 漫谈
　　5 派生
　　6 多重继承
　　7 私有变量和类局部引用
　　8 结构体
　　9 异常(Exceptions)也是类
　　10 迭代器
　　11 生成器(Generators)
　　1 名字和对象
　　对象有其特性，同一个对象可以有多个名字，这与其它语言中的别名很相似。别名有时候像指针，例如将对象当做 函数参数传递的时候非常高效，因为只传递了指针，这避免了pascal中的两套参数传递机制。
　　2 Python的域(scopes)和名称空间(namespaces)
　　在引入类之前，我们讲Python的域规则。类的定义巧妙地运用了名称空间，所以你需要知道域和名称空间如何工作才能理解发生了什么。
　　首先从定义开始。 名称空间是名字和对象之间的映射。多数名称空间使用Python的字典来实现，但除非出于性能考虑,我们通常不关心具体如何实现。名称空间的例子有，内置的名称例如abs(),内置的异常名，模块的全局名称，函数调用时的局部名称。在某种程度上，对象的属性也构成名称空间。
　　关于名称空间最重要的一点是：不同名称空间中的名称没有关系。例如 两个不同模块中都可以包含名为maximize的函数，这不会造成混肴，因为使用这些模块时必须加上模块名作为前缀。 另外，我把任何点后的名称叫做属性。例如，在表达式z.real中，real是对象z的属性。严格来说，引用模块中的名称是对属性的引用，在表达式modname.funcname中，modname是一个模块，funcname是它的一个属性。这个例子中模块属性和模块 内定义的全局名称有着直接的映射，它们有着相同的名称空间。 属性可能是只读的或者可写的，上面的例子中，属性就是可写的，例如：modname.the_ answer = 42.可写的属性可以被删除， 例如 del modname.the_ answer 会删除模块 modname中的 the_ answer属性。
　　名称空间在不同的时刻创建，有着不同的生命周期。包含内置名称的名称空间在Python解释器启动时被创建，且不会被删除。 模块的全局名称空间在模块被导入时被创建，正常情况下，模块的名称空间会持续到解释器退出。来自脚本文件或者交互式环境 被解释器最顶层调用执行的语句，被认为是 __ main __ 模块的一部分，所以他们有着自己的全局名称空间。 函数的局部名称空间当函数被调用时被创建，函数返回时或者出现异常而函数又没有提供处理方式时被删除。当然，在递归调用 中每一次调用都有他们自己的局部名称空间。 域(scpoe)是Python程序的一个名称空间可以直接访问的一个文本范围，“直接访问”在这里的意思时当对一个名字的访问没有 前缀时，会尝试在名称空间内查找这个名字。 在执行的任意时刻，至少有三个嵌套域，它们有名称空间可以直接访问。
　　最内层的域，它会首先被搜索，包含局部名称
　　任何封装函数的域，从最近的封装域开始搜索，包含非局部，非全局的名称
　　倒数第二个域，包含当前模块的全局名称
　　最外层的域，最后被搜索，包含内置名字的名称空间
　　如果一个名字被声名为全局的，那么所有的引用和赋值都是针对中间层的域，这一层域包含模块的全局名称。 意识到域是由文本决定是非常重要的，定义在模块中的一个函数的全局域就是这个模块的名称空间，无论这个函数在哪儿， 通过哪个别名被调用。
　　3 初识类
　　3.1 定义类
　　class ClassName:
　　《statement-1》
　　.
　　.
　　.
　　《statement-N》
　　类定义，像函数定义一样，在执行时才会起作用。你可以把类定义放在任何地方比如if语句的分支，或者在函数内部。 在实际应用时，定义在类中的语句通常都是函数定义，但是其它语句也是允许出现的，并且有的时候非常有用。 当进入一个类定义时，一个新的名称空间被创建，并且被当作局部域来使用。
　　3.2 类对象
　　类对象提供两种操作，属性引用和实例化。 属性引用使用标准句法：obj.name. 有效的属性名是类对象创建时类的名称空间内的所有名字。 例如下面的类定义中,MyClass.i和MyClass.f都是有效的属性名。
　　》》》 class MyClass:
　　... “““A simple example class“““
　　... i = 123
　　... def f(self):
　　... return ’hello world’
　　...
　　》》》 MyClass.i
　　123
　　》》》 MyClass.i = 10
　　类的实例化使用函数记号，例如：
　　》》》 x = MyClass()
　　》》》 x.i
　　10
　　这个实例化操作创建了一个空对象，许多类在实例化时定义了一些初始化操作。例如：
　　》》》 class MyClass():
　　... def __init__(self):
　　... self.data =
　　当一个类定义了__ init __ 方法后，类实例化时会自动调用 __ init __ ().
　　__ init __ 函数还可以有其它参数,例如:
　　》》》 class Complex:
　　... def __init__(self, realpart, imagpart):
　　... self.r = realpart
　　... self.i = imagpart
　　...
　　》》》 x = Complex(3.0, -4.5)
　　》》》 x.r, x.i
　　(3.0, -4.5)
　　3.3 实例化对象
　　现在我们可以用实例化的对象做些什么呢？它唯一可以进行的操作是属性引用。有两类有效的属性名，数据属性和方法。 数据属性(data attributes)对应c++中的数据成员，数据属性无需声明，第一次给它赋值时就表明了它的存在。 另一种实例化的属性引用叫做方法(Method).方法是对象内的一个函数。
　　3.4 方法对象
　　通常我们调用一个方法的方式是：
　　x.f()
　　但是，由于x.f是一个方法对象，所以它可以存储起来，以便以后调用
　　》》》 class MyClass:
　　... “““A simple example class“““
　　... i = 12345
　　... def f(self):
　　... return ’hello world’
　　...
　　》》》 x = MyClass()
　　》》》 x.f()
　　’hello world’
　　》》》 xf = x.f
　　》》》 xf()
　　’hello world’
　　你可能已经发现，f名名有一个参数，但是调用时为什么没有使用呢。其实，原因在于 x.f() 与 MyClass.f(x) 是等价的。
　　》》》 MyClass.f(x)
　　’hello world’
　　4 漫谈
　　数据属性如果和方法属性名称相同，前者会覆盖后者。所以为了避免名称冲突，最好养成一些习惯，比如方法名称大写，数据属性 名称前加一个短小，唯一的前缀。或者数据属性用名词，方法属性用动词。 数据属性可以被方法引用，也可以被对象的使用者引用。换句话说，类不能实现为纯抽象数据类型。 通常，方法的第一个参数是self.虽然这只是一个习惯用法，但是遵循一些习惯用法会让你的程序可读性更强。 函数定义没有必要非在类里面，例如：
　　# Function defined outside the class
　　def f1(self, x, y):
　　return min(x, x+y)
　　class C:
　　f = f1
　　def g(self):
　　return ’hello world’
　　h = g
　　一个方法可以通过self参数调用其它方法，
　　》》》 class Bag:
　　... def __init__(self):
　　... self.data =
　　... def add(self, x):
　　... self.data.append(x)
　　... def addtwice(self, x):
　　... self.add(x)
　　... self.add(x)
　　...
　　》》》 b = Bag()
　　》》》 b.data
　　
　　》》》 b.add(’1’)
　　》》》 b.data
　　
　　》》》 b.addtwice(’x’)
　　》》》 b.data
　　
　　5 派生
　　派生类的形式如下：
　　class DerivedClassName(BaseClassName):
　　《statement-1》
　　.
　　.
　　.
　　《statement-N》
　　BaseClassName必须在包含派生类的域内定义，BaseClassName可以是一个表达式，例如：
　　class DerivedClassName(modname.BaseClassName):
　　当派生类的对象引用了一个属性时，会先在派生类内查找这个属性名，如果找不到，再到基类中查找。 派生类可以覆盖基类中的方法，即使基类中的方法被覆盖了，也可以使用下面的方法来调用
　　BaseClassName.methodname(self, arguments)
　　6 多重继承
　　Python 支持有限的多重继承：
　　class DerivedClassName(Base1, Base2, Base3):
　　《statement-1》
　　.
　　.
　　.
　　《statement-N》
　　在旧风格的类中，唯一的规则是深度优先，从左到右。以上述类定义为例，如果一个属性没有在 DerivedClassName中被 找到，那么会继续搜索Base1,Base2等等 在新风格的类中，对方法的解析次序是动态改变的，这是因为类的继承关系会呈现出一个或多个菱形。例如新风格的类都由 object类派生出，这样就会就多条路径通向object。为了避免基类被多次搜索，使用了线性化算法将所有基类排列成从左 到右的顺序
　　7 私有变量和类局部引用
　　实例的私有变量只能在对象内部使用，python中常常使用例如 _ spam 的形式来代表API的非公有部分，无论是函数，方法还是 数据成员。类私有成员的特性的一种有效的用法是可以避免与子类中定义的名字冲突，这种机制叫做 mangling:
　　class Mapping:
　　def __init__(self, iterable):
　　self.items_list =
　　self.__update(iterable)
　　def update(self, iterable):
　　for item in iterable:
　　self.items_list.append(item)
　　__update = update # private copy of original update() method
　　class MappingSubclass(Mapping):
　　def update(self, keys, values):
　　# provides new signature for update()
　　# but does not break __init__()
　　for item in zip(keys, values):
　　self.items_list.append(item)
　　注意上述代码中 __ update 的使用，避免了子类中对update的覆盖影响到基类 __ init__ 中的 update.
　　8 结构体
　　有时候我们可能需要像C中的struct那样的数据类型，把少量的数据项放在一起。Python中可以使用定义一个空类来实现这一点：
　　# filename:p.py
　　class Employee:
　　pass
　　john = Employee() # Create an empty employee record
　　# Fill the fields of the record
　　john.name = ’John Doe’
　　john.dept = ’computer lab’
　　john.salary = 1000
　　》》》 import p
　　》》》 p.john
　　《p.Employee instance at 0xb71f50ac》
　　》》》 p.john.name
　　’John Doe’
　　》》》 p.john.dept
　　’computer lab’
　　》》》 p.john.salary
　　1000
　　9 异常(Exceptions)也是类
　　用户定义的异常也可以用类来表示，使用这种机制可以创建出可扩展，层次化的异常。 raise 语句有两种新的形式
　　raise Class, instance
　　raise instance
　　第一种形式中，instance必须是Class的一个实例，或者是由它派生出的类。 第二种形式是下面这种形式的缩写
　　raise instance.__class__, instance
　　下面这个例子会依次打印出B,C,D
　　class B:
　　pass
　　class C(B):
　　pass
　　class D(C):
　　pass
　　for c in :
　　try:
　　raise c()
　　except D:
　　print “D“
　　except C:
　　print “C“
　　except B:
　　print “B“
　　》》》 import f
　　B
　　C
　　D
　　注意如果 B写在最前面，会打印出BBB,这是因为raise C和raise D时，执行到except B是都会 print “B“. 因为B是C,D的基类.
　　10 迭代器
　　现在你可能已经注意到了多数容器对象都可以使用for语句来循环
　　》》》 for elem in :
　　... print elem
　　...
　　1
　　2
　　3
　　》》》 for elem in (1,2,3):
　　... print elem
　　...
　　1
　　2
　　3
　　这一风格清晰，简捷，方便。迭代器的使用在Python中非常普便。for语句的背后，其实是对容器对象调用 iter(). 这个函数返回一个迭代器对象，它定义了next()函数，每次访问容器中的一个元素。当没有元素的时候，next()返回一个 StopIteration异常，告诉for语句循环结束了。
　　》》》 s = ’asdf’
　　》》》 it = iter(s)
　　》》》 it
　　《iterator object at 0xb71f590c》
　　》》》 it.next()
　　’a’
　　》》》 it.next()
　　’s’
　　》》》 it.next()
　　’d’
　　》》》 it.next()
　　’f’
　　》》》 it.next()
　　Traceback (most recent call last):
　　File “《stdin》“, line 1, in 《module》
　　StopIteration
　　理解了迭代机制，就可以很容易地把迭代器加入你的类中，定义__ iter__ ()方法，返回一个有next()方法的对象。 如果一个类定义了next()函数，__ iter__ () 可以仅返回 self:
　　# q.py
　　class Reverse:
　　def __init__(self, data):
　　self.data = data
　　self.index = len(data)
　　def __iter__(self):
　　return self
　　def next(self):
　　if self.index == 0:
　　raise StopIteration
　　self.index = self.index -1
　　return self.data
　　》》》 import q
　　》》》 rev = q.Reverse(’spam’)
　　》》》 iter(rev)
　　《q.Reverse instance at 0xb71f588c》
　　》》》 for char in rev:
　　... print char
　　...
　　m
　　a
　　p
　　s
　　11 生成器(Generators)
　　生成器是创建迭代器的一个简单而强大的工具。它们像正常函数一样，只是需要返回数据时使用 yield语句。
　　# d.py
　　def reverse(data):
　　for index in range(len(data)-1, -1, -1):
　　yield data
　　》》》 import d
　　》》》 for char in d.reverse(’golf’):
　　... print char
　　...
　　f
　　l
　　o
　　g
　　任何可以使用生成器做的事，都可以使用前一版本的reverse实现，生成器之所以实现紧凑是因为自动创建了 __ iter() 和 next() 方法。
-python中class是什么意思

关于python里定义class的问题

对象构造后第一个调用的函数，在python里面实例的属性是可以动态构建的，在类里面定义的属性是类属性，不是实例属性，定义实例自己的属性的最好地方是__init__函数里面。
比如
class TEST():
class_attr #类属性，通过TEST.class_attr调用，如果用instance.class_attr调用实际上是声明类另一个实例属性，与之前的TEST.class_attr不是一个东西了
def __init__(self,other):
self.class_attr #实例属性，与之前的那个属性处于不同的名字空间了，不是一个东西。
self.other=other
总之，__init__可以用来声明实例属性，以及进行必要的初始化。
-python中class是什么意思

python关于class问题 小白求解答

Python编程中类的概念可以比作是某种类型集合的描述，如“人类”可以被看作一个类，然后用人类这个类定义出每个具体的人——你、我、他等作为其对象。类还拥有属性和功能，属性即类本身的一些特性，如人类有名字、身高和体重等属性，而具体值则会根据每个人的不同；功能则是类所能实现的行为，如人类拥有吃饭、走路和睡觉等功能。具体的形式如下：-python中class是什么意思

Python中定义和使用类的形式为：class 类名，类名为这个类的名称，而父类名为可选，但定义父类名后，子类则拥有父类的相应属性和方法。在用类定义成对象时，会先调用__init__构造函数，以初始化对象的各属性，类的各属性（成员变量）均可以在构造函数中定义，定义时只要加上对象指针就好了。而在对象销毁时，则会调用__del__析构函数，定义类的成员函数时，必须默认一个变量（类似于C++中的this指针）代表类定义的对象本身，这个变量的名称可自行定义，下面例子将使用  self变量表示类对象变量  。-python中class是什么意思

python中 A=ClassA() ClassB(A) 这是什么意思

A=ClassA()是把类ClassA的实例赋值给变量A
ClassB(A)意思是类ClassB继承类ClassA的方法和属性。就是类的继承。实例A是类ClassA的实例。而类ClassB继承了类ClassA的属性和方法。
-python中class是什么意思