python使用class

1. 怎样使用python 的“CLASS”

class就是类定义。就是把数据及其上的操作封装的单元。支持面向对象的语言都有这个概念。比如c++,java之类的。下面是我随手敲的例子：
IDLE 2.6.5 ==== No Subprocess ====
>>> class Point:
def __init__(self,x,y):
self.x=x
self.y=y
def getX(self):
return self.x
def getY(self):
return self.y

>>> p=Point(1,2)
>>> p
<__main__.Point instance at 0x97df54c>
>>> p.getX()
1
>>> p.getY()
2
>>>

2. 关于python里定义class的问题

它是python语法中固定的方法，主要作用就是创建类实例后做初始化工作，创建时调用__new__，初始化时调用__init__。这些方法叫做魔法方法，由python解释器调用

3. python关于class问题 小白求解答

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

#例：类的概念
class人类:
名字='未命名'#成员变量
def说话(内容):#成员函数
print内容#成员变量赋初始值

某人=人类()#定义一个人类对象某人
某人.名字="路人甲"
某人.说话('大家好')#路人甲说话
>>>大家好！#输出

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

#例：类定义及使用
classCAnimal:
name='unname'#成员变量
def__init__(self,voice='hello'):#重载构造函数
self.voice=voice#创建成员变量并赋初始值
def__del__(self):#重载析构函数
pass#空操作
defSay(self):
printself.voice

t=CAnimal()#定义动物对象t
t.Say()#t说话
>>hello#输出
dog=CAnimal('wow')#定义动物对象dog
dog.Say()#dog说话
>>wow#输出

4. python什么时候需要用class举例说明

def相当于每个组员，他们分别能完成一定的功能。
class相当于办公室，他可以将旗下组员定义起来，方便调用。
在使用某些库或者编写大程序的时候，class是比较好用的，很简单的程序自然用不上啦。

5. python 类里面的class是什么意思啊求

python这方面很灵活。其实java也一样允许这样子。你几乎可以在任何情况下做任何事情。
通常class Meta可以放在外面。不过，这样它就不能直接访问父类的一些属性了。

所以在python里class 如果放在另一个class 里面，通常并不是为了隐藏这个class，并不是让别人看不到它。而因为它需要父类里的一些属性。需要共享。

另外直接在类里定义的一些变量，比如queryset，也是属于类全局级的。只要引用了这个类，即使没有初始化，这些变量也已经实例化。这个有些象是java里static的全局定义结果。

我们通常用这个方法来在不同的函数变量间共享 一部分数据。同时又不需要初始化一个实例并用指针指向这一部分数据。而是通过类名直接引用。

比如下面的一个用法
class Config:
pass
Config.user_name="xxx"
Config.password="yyyy"
这样。只要你在当前模块里，通过Config就可以引用到user_name和password，而不需要global这个修饰符。

6. python类的定义与使用是什么

类Class：用来描述具体相同的属性和方法的对象的集合。定义了该集合中每个对象所共有的属性和方法。对象是类的示例。

类定义完成时（正常退出），就创建了一个 类对象。基本上它是对类定义创建的命名空间进行了一个包装；我们在下一节进一步学习类对象的知识。原始的局部作用域（类定义引入之前生效的那个）得到恢复，类对象在这里绑定到类定义头部的类名（例子中是 ClassName ）。

基本语法

Python的设计目标之一是让代码具备高度的可阅读性。它设计时尽量使用其它语言经常使用的标点符号和英文单字，让代码看起来整洁美观。它不像其他的静态语言如C、Pascal那样需要重复书写声明语句，也不像它们的语法那样经常有特殊情况和意外。

以上内容参考：网络-Python

7. python 类之间调用 class

python类的初始化函数是__init__,有两个“_”,你只有1个,所以python认为你的ThirdClass没有定义初始化函数,所以它就给你调用了默认的不接受参数的初始化函数,所以它才告诉你ThirdClass的不接受有参数的初始化。

8. python怎么用class定义的类

这里有个二叉树的例子

classTreeNode(object):
def__init__(self,data=0,left=0,right=0):
self.data=data
self.left=left
self.right=right

classBTree(object):
"""docstringforBTree"""
def__init__(self,root=0):
self.root=root

defis_empty(self):
ifself.rootis0:
returnTrue
else:
returnFalse

defpreOrder(self,treenode):
iftreenodeis0:
return
print(treenode.data,end=',')
self.preOrder(treenode.left)
self.preOrder(treenode.right)

definOrder(self,trennode):
iftrennodeis0:
return
self.inOrder(trennode.left)
print(trennode.data,end=',')
self.inOrder(trennode.right)

defpostOrder(self,treenode):
iftreenodeis0:
return
self.postOrder(treenode.left)
self.postOrder(treenode.right)
print(treenode.data,end=',')

defcount_BiTNode(self,treenode):
iftreenodeisNone:
return0
else:
return(1+self.count_BiTNode(treenode.left)+self.count_BiTNode(treenode.right))


n1=TreeNode(data=1)
n2=TreeNode(2,left=n1,right=0)
n3=TreeNode(3)
n4=TreeNode(4)

n5=TreeNode(5,n3,n4)
n6=TreeNode(6,n2,n5)
n7=TreeNode(7,n6,0)
n8=TreeNode(data=8)
root=TreeNode('root',n7,n8)

bt=BTree(root)
print("先序遍历:")
print(bt.preOrder(bt.root))
print("中序遍历:")
print(bt.inOrder(bt.root))
print("后序遍历:")
print(bt.postOrder(bt.root))
print(bt.count_BiTNode(bt.root))

9. python里面怎么调用class

以下代码调试通过：

classLuciaClass:#定义类
defluciaprint(self,text):#类里面的方法
print('
',text)#方法就是输出text


x=LuciaClass()#方法的实例x
x.luciaprint('todayisabadday~~~')#实例调用类方法

运行效果：

10. 如何在Python中使用static，class，abstract方法

方法在Python中是如何工作的

方法就是一个函数，它作为一个类属性而存在，你可以用如下方式来声明、访问一个函数：

Python

>>> class Pizza(object):
... def __init__(self, size):
... self.size = size
... def get_size(self):
... return self.size
...
>>> Pizza.get_size
<unbound method Pizza.get_size>

Python在告诉你，属性_get_size是类Pizza的一个未绑定方法。这是什么意思呢？很快我们就会知道答案：

Python

>>> Pizza.get_size()
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: unbound method get_size() must be called with Pizza instance as first argument (got nothing instead)

我们不能这么调用，因为它还没有绑定到Pizza类的任何实例上，它需要一个实例作为第一个参数传递进去（Python2必须是该类的实例，Python3中可以是任何东西），尝试一下：

Python

>>> Pizza.get_size(Pizza(42))
42

>>> Pizza.get_size(Pizza(42))
42

太棒了，现在用一个实例作为它的的第一个参数来调用，整个世界都清静了，如果我说这种调用方式还不是最方便的，你也会这么认为的；没错，现在每次调用这个方法的时候我们都不得不引用这个类，如果不知道哪个类是我们的对象，长期看来这种方式是行不通的。

那么Python为我们做了什么呢，它绑定了所有来自类_Pizza的方法以及该类的任何一个实例的方法。也就意味着现在属性get_size是Pizza的一个实例对象的绑定方法，这个方法的第一个参数就是该实例本身。

Python

>>> Pizza(42).get_size
<bound method Pizza.get_size of <__main__.Pizza object at 0x7f3138827910>>
>>> Pizza(42).get_size()
42

和我们预期的一样，现在不再需要提供任何参数给_get_size，因为它已经是绑定的，它的self参数会自动地设置给Pizza实例，下面代码是最好的证明：

Python

>>> m = Pizza(42).get_size
>>> m()
42

更有甚者，你都没必要使用持有Pizza对象的引用了，因为该方法已经绑定到了这个对象，所以这个方法对它自己来说是已经足够了。

也许，如果你想知道这个绑定的方法是绑定在哪个对象上，下面这种手段就能得知：

Python

>>> m = Pizza(42).get_size
>>> m.__self__
<__main__.Pizza object at 0x7f3138827910>
>>> # You could guess, look at this:
...
>>> m == m.__self__.get_size
True

显然，该对象仍然有一个引用存在，只要你愿意你还是可以把它找回来。

在Python3中，依附在类上的函数不再当作是未绑定的方法，而是把它当作一个简单地函数，如果有必要它会绑定到一个对象身上去，原则依然和Python2保持一致，但是模块更简洁：

Python

>>> class Pizza(object):
... def __init__(self, size):
... self.size = size
... def get_size(self):
... return self.size
...
>>> Pizza.get_size
<function Pizza.get_size at 0x7f307f984dd0>

静态方法

静态方法是一类特殊的方法，有时你可能需要写一个属于这个类的方法，但是这些代码完全不会使用到实例对象本身，例如：

Python

class Pizza(object):
@staticmethod
def mix_ingredients(x, y):
return x + y

def cook(self):
return self.mix_ingredients(self.cheese, self.vegetables)

这个例子中，如果把_mix_ingredients作为非静态方法同样可以运行，但是它要提供self参数，而这个参数在方法中根本不会被使用到。这里的@staticmethod装饰器可以给我们带来一些好处：

Python不再需要为Pizza对象实例初始化一个绑定方法，绑定方法同样是对象，但是创建他们需要成本，而静态方法就可以避免这些。

Python

>>> Pizza().cook is Pizza().cook
False
>>> Pizza().mix_ingredients is Pizza.mix_ingredients
True
>>> Pizza().mix_ingredients is Pizza().mix_ingredients
True

可读性更好的代码，看到@staticmethod我们就知道这个方法并不需要依赖对象本身的状态。
可以在子类中被覆盖，如果是把mix_ingredients作为模块的顶层函数，那么继承自Pizza的子类就没法改变pizza的mix_ingredients了如果不覆盖cook的话。

类方法

话虽如此，什么是类方法呢？类方法不是绑定到对象上，而是绑定在类上的方法。

Python

>>> class Pizza(object):
... radius = 42
... @classmethod
... def get_radius(cls):
... return cls.radius
...
>>>
>>> Pizza.get_radius
<bound method type.get_radius of <class '__main__.Pizza'>>
>>> Pizza().get_radius
<bound method type.get_radius of <class '__main__.Pizza'>>
>>> Pizza.get_radius is Pizza().get_radius
True
>>> Pizza.get_radius()
42

无论你用哪种方式访问这个方法，它总是绑定到了这个类身上，它的第一个参数是这个类本身（记住：类也是对象）。

什么时候使用这种方法呢？类方法通常在以下两种场景是非常有用的：

工厂方法：它用于创建类的实例，例如一些预处理。如果使用@staticmethod代替，那我们不得不硬编码Pizza类名在函数中，这使得任何继承Pizza的类都不能使用我们这个工厂方法给它自己用。

Python

class Pizza(object):
def __init__(self, ingredients):
self.ingredients = ingredients

@classmethod
def from_fridge(cls, fridge):
return cls(fridge.get_cheese() + fridge.get_vegetables())

调用静态类：如果你把一个静态方法拆分成多个静态方法，除非你使用类方法，否则你还是得硬编码类名。使用这种方式声明方法，Pizza类名明永远都不会在被直接引用，继承和方法覆盖都可以完美的工作。

Python

class Pizza(object):
def __init__(self, radius, height):
self.radius = radius
self.height = height

@staticmethod
def compute_area(radius):
return math.pi * (radius ** 2)

@classmethod
def compute_volume(cls, height, radius):
return height * cls.compute_area(radius)

def get_volume(self):
return self.compute_volume(self.height, self.radius)

抽象方法

抽象方法是定义在基类中的一种方法，它没有提供任何实现，类似于Java中接口(Interface)里面的方法。

在Python中实现抽象方法最简单地方式是：

Python

class Pizza(object):
def get_radius(self):
raise NotImplementedError

任何继承自_Pizza的类必须覆盖实现方法get_radius，否则会抛出异常。

这种抽象方法的实现有它的弊端，如果你写一个类继承Pizza，但是忘记实现get_radius，异常只有在你真正使用的时候才会抛出来。

Python

>>> Pizza()
<__main__.Pizza object at 0x7fb747353d90>
>>> Pizza().get_radius()
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
File "<stdin>", line 3, in get_radius
NotImplementedError

还有一种方式可以让错误更早的触发，使用Python提供的abc模块，对象被初始化之后就可以抛出异常：

Python

import abc

class BasePizza(object):
__metaclass__ = abc.ABCMeta

@abc.abstractmethod
def get_radius(self):
"""Method that should do something."""

使用abc后，当你尝试初始化BasePizza或者任何子类的时候立马就会得到一个TypeError，而无需等到真正调用get_radius的时候才发现异常。

Python

>>> BasePizza()
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: Can't instantiate abstract class BasePizza with abstract methods get_radius

混合静态方法、类方法、抽象方法

当你开始构建类和继承结构时，混合使用这些装饰器的时候到了，所以这里列出了一些技巧。

记住，声明一个抽象的方法，不会固定方法的原型，这就意味着虽然你必须实现它，但是我可以用任何参数列表来实现：

Python

import abc

class BasePizza(object):
__metaclass__ = abc.ABCMeta

@abc.abstractmethod
def get_ingredients(self):
"""Returns the ingredient list."""

class Calzone(BasePizza):
def get_ingredients(self, with_egg=False):
egg = Egg() if with_egg else None
return self.ingredients + egg

这样是允许的，因为Calzone满足BasePizza对象所定义的接口需求。同样我们也可以用一个类方法或静态方法来实现：

Python

import abc

class BasePizza(object):
__metaclass__ = abc.ABCMeta

@abc.abstractmethod
def get_ingredients(self):
"""Returns the ingredient list."""

class DietPizza(BasePizza):
@staticmethod
def get_ingredients():
return None

这同样是正确的,因为它遵循抽象类BasePizza设定的契约。事实上get_ingredients方法并不需要知道返回结果是什么，结果是实现细节，不是契约条件。

因此，你不能强制抽象方法的实现是一个常规方法、或者是类方法还是静态方法，也没什么可争论的。从Python3开始（在Python2中不能如你期待的运行，见issue5867），在abstractmethod方法上面使用@staticmethod和@classmethod装饰器成为可能。

Python

import abc

class BasePizza(object):
__metaclass__ = abc.ABCMeta

ingredient = ['cheese']

@classmethod
@abc.abstractmethod
def get_ingredients(cls):
"""Returns the ingredient list."""
return cls.ingredients

别误会了，如果你认为它会强制子类作为一个类方法来实现get_ingredients那你就错了，它仅仅表示你实现的get_ingredients在BasePizza中是一个类方法。

可以在抽象方法中做代码的实现？没错，Python与Java接口中的方法相反，你可以在抽象方法编写实现代码通过super()来调用它。（译注：在Java8中，接口也提供的默认方法，允许在接口中写方法的实现）

Python

import abc

class BasePizza(object):
__metaclass__ = abc.ABCMeta

default_ingredients = ['cheese']

@classmethod
@abc.abstractmethod
def get_ingredients(cls):
"""Returns the ingredient list."""
return cls.default_ingredients

class DietPizza(BasePizza):
def get_ingredients(self):
return ['egg'] + super(DietPizza, self).get_ingredients()

这个例子中，你构建的每个pizza都通过继承BasePizza的方式，你不得不覆盖get_ingredients方法，但是能够使用默认机制通过super()来获取ingredient列表。