python中定义一个狗类

① python 面向对象定义一个 dog 类，包含 jaw,paw,mouth 属性以及bark(),escape(),bite() 和 eat() 等动作

classdog(object):
def__init__(self,jaw,paw,mouth):
self.jaw=jaw
self.paw=paw
self.mouth=mouth

defbark(self):
return"Wang,wang"

defescape(self):
return"eacapewith"+self.paw

defbite(self):
return"bitewith"+self.jaw

defeat(self):
return"eatwith"+self.mouth

defreaction(self,provoke):
action={"attack":self.escape(),"food":self.eat()}
returnaction[provoke]

xiaohuang=dog("jaw","paw","month")
printxiaohuang.reaction("attack")

很好奇哪里会有这么奇怪的题目~

② python定义一个Dog类，实例化两个小狗对象。类属性有名字，颜色，体重。实现以下描述

程序写给你

classdogClass():

def__init__(self,name,color,weight):

self.name=name

self.color=color

self.weight=weight

def__del__(self):

self.name=""

self.color=""

self.weight=""

defname(self):

returnself.name

defcolor(self):

returnself.color

defweight(self):

returnself.weight

a=dogClass("旺财","棕色","5斤")

b=dogClass("来福","黑色","8斤")

print("小狗名字叫",a.name,"，颜色是",a.color,"，体重",a.weight)

print("小狗名字叫",b.name,"，颜色是",b.color,"，体重",b.weight)

执行结果：

③ 在Python中，一个类中方法的返回值可不可以是另外一个类呢

当然可以了。

Python中有个元类的概念, metaclass就是用来生成类的类。

还有工厂函数的概念，就是说一个函数直接返回一个类。

classMetaDog:
def__init__(self,color=''):
self.color=color

defshow_color(self):
print('mydogcoloris{}.'.format(self.color))

classAnimal:
defdog_class(self):
returnMetaDog

animal=Animal()

Dog=animal.dog_class()

my_dog=Dog()
my_dog.color='yellow'

#my_dog=Dog('yellow')

my_dog.show_color()

#mydogcolorisyellow.

④ 还是python问题

#python3.6

classDog:
def__init__(self,name,age):
self.name=name
self.age=age

defbark(self):
print("Thisisdog'sbarkbehavior")

defwatch(self):
print("Thisisdog'swatchingdoorbehavior")


deftest():
doudou=Dog(name="doudou",age=1)
print("name:",doudou.name,"age:",doudou.age)
doudou.bark()
doudou.watch()


if__name__=="__main__":
test()

⑤ python中如何定义类

一、类定义：

class <类名>:

<语句>

类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性

如果直接使用类名修改其属性，那么将直接影响到已经实例化的对象

类的私有属性：

__private_attrs两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问

在类内部的方法中使用时self.__private_attrs

类的方法

在类地内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self,且为第一个参数

私有的类方法

__private_method两个下划线开头，声明该方法为私有方法，不能在类地外部调用

在类的内部调用slef.__private_methods

类的专有方法：

__init__构造函数，在生成对象时调用

__del__析构函数，释放对象时使用

__repr__打印，转换

__setitem__按照索引赋值

__getitem__按照索引获取值

__len__获得长度

__cmp__比较运算

__call__函数调用

__add__加运算

__sub__减运算

__mul__乘运算

__div__除运算

__mod__求余运算

__pow__称方

示例:

[python]view plain

• #类定义

• classpeople:

⑥ java定义一个动物类 Dog 有属性 行为 == 求详细步骤 谢谢 很急很急 在线等。

package com.java;

/声明一个抽象类动物
abstract class Animal {

//声明一个方法gnaw（）啃骨头

public void gnaw() {
System.out.println("Animal gnaw（啃骨头）..");
}

//喝汤

public void eat() {
System.out.println("Animal eat（喝汤）...");
}

//咬人

public void bite() {
System.out.println("Animal bite（咬人）...");
}

//跑
public void run() {
System.out.println("Animal run（咬人）...");
}

//跳
public void jump() {
System.out.println("Animal jump...");

}

}

//声明一个Dog类，继承Animal类

class Dog extends Animal{

private String name;

private double weight；
private double height;
private String color;

public Dog (String name,String color){
this.name=name;

this.color=color;

}

}

//以下是测试结果，可以省略

public class NLL {

public static void main(String[] args) {

Animal smallDog =new Dog("smallDog","yellow");

Animal bigDog = new Dog("bigDog ","yellow");

smallDog.gnaw();
smallDog.eat();
smallDog.bite();

bigDog .bite();
}
}

⑦ python 建一个类是不是相当于自己建了一个库

准确来说，一个Python库是实现了某种功能，并暴露某些接口的代码组织，可能有很多py文件，也可能只是一个函数或者一个类。而一个Python类，更应当看作是一种数据结构，封装和定义了一些成员。绝大多数时候，两者是不同的两种东西。具体参考刘江的Python教程

⑧ python怎么定义addcat

Python中的Mole是比较重要的概念。常见的情况是，事先写好一个.py文 件，在另一个文件中需要import时，将事先写好的.py文件拷贝 到当前目录，或者是在sys.path中增加事先写好的.py文件所在的目录，然后import。这样的做法，对于少数文件是可行的，但如果程序数目很 多，层级很复杂，就很吃力了。
有没有办法，像Java的Package一样，将多个.py文件组织起来，以便在外部统一调用，和在内部互相调用呢？答案是有的。
主要是用到python的包的概念，python
__init__.py在包里起一个比较重要的作用
要弄明白这个问题，首先要知道，python在执行import语句时，到底进行了什么操作，按照python的文档，它执行了如下操作：
第1步，创建一个新的，空的mole对象（它可能包含多个mole）；
第2步，把这个mole对象插入sys.mole中
第3步，装载mole的代码（如果需要，首先必须编译）
第4步，执行新的mole中对应的代码。

在执行第3步时，首先要找到mole程序所在的位置，其原理为：
如 果需要导入的mole的名字是m1，则解释器必须找到m1.py，它首先在当前目录查找，然后是在环境变量PYTHONPATH中查找。 PYTHONPATH可以视为系统的PATH变量一类的东西，其中包含若干个目录。如果PYTHONPATH没有设定，或者找不到m1.py，则继续搜索 与python的安装设置相关的默认路径，在Unix下，通常是/usr/local/lib/python。
事实上，搜索的顺序是：当前路径 （以及从当前目录指定的sys.path），然后是PYTHONPATH，然后是python的安装设置相关的默认路径。正因为存在这样的顺序，如果当前 路径或PYTHONPATH中存在与标准mole同样的mole，则会覆盖标准mole。也就是说，如果当前目录下存在xml.py，那么执 行import
xml时，导入的是当前目录下的mole，而不是系统标准的xml。

了解了这些，我们就可以先构建一个package，以普通mole的方式导入，就可以直接访问此package中的各个mole了。

Python中的package定义很简单，其层次结构与程序所在目录的层次结构相同，这一点与Java类似，唯一不同的地方在于，python中的package必须包含一个__init__.py的文件。
例如，我们可以这样组织一个package:

package1/
__init__.py
subPack1/
__init__.py
mole_11.py
mole_12.py
mole_13.py
subPack2/
__init__.py
mole_21.py
mole_22.py
……

__init__.py可以为空，只要它存在，就表明此目录应被作为一个package处理。当然，__init__.py中也可以设置相应的内容，下文详细介绍。

好了，现在我们在mole_11.py中定义一个函数：

def funA():
print "funcA in mole_11"
return

在顶层目录（也就是package1所在的目录，当然也参考上面的介绍，将package1放在解释器能够搜索到的地方）运行python:

>>>from package1.subPack1.mole_11 import funcA
>>>funcA()
funcA in mole_11

这样，我们就按照package的层次关系，正确调用了mole_11中的函数。

细心的用户会发现，有时在import语句中会出现通配符*，导入某个mole中的所有元素，这是怎么实现的呢？
答案就在__init__.py中。我们在subPack1的__init__.py文件中写

__all__ = ['mole_13', 'mole_12']

然后进入python
>>>from package1.subPack1 import *
>>>mole_11.funcA()
Traceback (most recent call last):
File "", line 1, in
ImportError: No mole named mole_11

也就是说，以*导入时，package内的mole是受__init__.py限制的。

好了，最后来看看，如何在package内部互相调用。
如果希望调用同一个package中的mole，则直接import即可。也就是说，在mole_12.py中，可以直接使用
import mole_11

如果不在同一个package中，例如我们希望在mole_21.py中调用mole_11.py中的FuncA，则应该这样：
from mole_11包名.mole_11 import
funcA

包机制

# a.py
def add_func(a,b):
return a+b

# b.py
from a import add_func # Also can be : import a

print ("Import add_func from mole a")
print ("Result of 1 plus 2 is: ")
print (add_func(1,2)) # If using "import a" , then here should be "a.add_func"

mole可以定义在包里面.Python定义包的方式稍微有点古怪,假设我们有一个parent文件夹,该文件夹有一个child子文件夹.child中有一个mole
a.py . 如何让Python知道这个文件层次结构?很简单,每个目录都放一个名为_init_.py 的文件.该文件内容可以为空.这个层次结构如下所示:

parent
--__init_.py
--child
-- __init_.py
--a.py

b.py
那么Python如何找到我们定义的mole?在标准包sys中,path属性记录了Python的包路径.你可以将之打印出来:
import sys

print(sys.path)
通常我们可以将mole的包路径放到环境变量PYTHONPATH中,该环境变量会自动添加到sys.path属性.另一种方便的方法是编程中直接指定我们的mole路径到sys.path 中:
import sys
import os
sys.path.append(os.getcwd()+'\\parent\\child')
print(sys.path)
from a import add_func
print (sys.path)
print ("Import add_func from mole a")
print ("Result of 1 plus 2 is: ")
print (add_func(1,2))

知识点:

如何定义模块和包

如何将模块路径添加到系统路径,以便python找到它们

如何得到当前路径

⑨ python类的定义与使用是什么

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

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

基本语法

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

以上内容参考：网络-Python

⑩ 定义一个基类动物类(Animal),定义三个子类:猫类(Cat),狗类(Dog),羊类(Sheep),

为了方便我就写在同一个java文件时了
package test;
public class A {
public static void main(String[] args) {
Animal an=null;

an=new Cat();
an.m_name="猫";
an.shout();

an=new Dog();
an.m_name="狗";
an.shout();

an=new Sheep();
an.m_name="羊";
an.shout();

}
}

abstract class Animal {
protected String m_name;
protected abstract void shout();
}

class Cat extends Animal {
protected void shout() {
System.out.println(m_name+"：喵喵~~");
}
}

class Dog extends Animal {
protected void shout() {
System.out.println(m_name+"：旺旺~~");
}
}

class Sheep extends Animal {
protected void shout() {
System.out.println(m_name+"：咩咩~~");
}
}