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+"：咩咩~~");
}
}