當前位置：首頁 > 编程语言 > python >内容正文

python

python定义构造函数、包括颜色价格品牌_《Python编程与算法基础教程》（第二版），蒋洪宇，青松，第9章：课后练习,程序设计,版江红余,第九章,习题,答案...

發布時間：2024/8/1 python 53 豆豆

生活随笔收集整理的這篇文章主要介紹了 python定义构造函数、包括颜色价格品牌_《Python编程与算法基础教程》（第二版），蒋洪宇，青松，第9章：课后练习,程序设计,版江红余,第九章,习题,答案... 小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

例9.1~例9.53

補充：

類名為有效的標識符，一般為多個單詞組成的名稱，每個單詞除第一個字母大寫外，其余的字母均小寫

一：類對象和實例對象

例9.1(創建類對象和實例對象)

>>> class Person:

pass

>>> p = Person()

>>> print(Person, type(Person), id(Person))

2096437524072

>>> print(p, type(p), id(p))

<__main__.person object at> 2096441625544

例9.2(實例對象的創建和使用)

Python創建實例對象的方法無須使用關鍵字new，而是直接像調用函數一樣調用類對象并傳遞參數，因此類對象是可調用對象(Callable)

在Python內置函數中，bool、float、int、str、list、dict、set等均為可調用內置類對象

>>> c = complex(1, 2)

>>> c.conjugate()

(1-2j)

>>> c.real

1.0

二：屬性

例9.3(定義實例屬性)

Python變量不需要聲明，可直接使用。所以建議用戶在類定義的開始位置初始化類屬性，或者在構造函數

__init__()

中初始化實例屬性

>>> class Person:

def __init__(self, name, age):

self.name = name

self.age = age

def say_hi(self):

print("您好，我叫", self.name)

>>> p = Person('zgh', 18)

>>> p.say_hi()

您好，我叫 zgh

>>> print(p.age)

例9.4(定義類對象屬性)

類屬性如果通過

obj.屬性名

來訪問，則屬于該實例地實例屬性

>>> class Person:

count = 0

name = "Person"

>>> Person.count += 1

>>> print(Person.count)

>>> print(Person.name)

Person

>>> p1 = Person(); p2 = Person()

>>> print(p1.name, p2.name)

Person Person

>>> Person.name = "雇員"

>>> print(p1.name, p2.name)

雇員雇員

>>> p1.name = '員工'

>>> print(p1.name, p2.name)

員工雇員

例9.5(私有屬性)

Python類的成員沒有訪問控制限制，這與其他面向對象語言不同

通常約定以兩個下劃線開頭，但是不以兩個下劃線結束的屬性是私有的(private)，其它為公共的(public)

>>> class Person:

__name = 'class Person'

def get_name():

print(Person.__name)

>>> Person.get_name()

class Person

>>> Person.__name

Traceback (most recent call last):

File "", line 1, in

Person.__name

AttributeError: type object 'Person' has no attribute '__name'

例9.6、9.7、9.8(property裝飾器)

面向對象編程的封裝性原則要求不直接訪問類中的數據成員

在Python中可以定義私有屬性，然后定義相應的訪問該私有屬性的函數，并使用@property裝飾器來裝飾這些函數

程序可以把函數“當作”屬性訪問，從而提供更加友好的訪問方式

>>> class Person:

def __init__(self, name):

self.__name = name

@property

def name(self):

return self.__name

>>> p = Person('zgh666')

>>> print(p.name)

zgh666

嘗試了一個想法(如果對象也有一個同名的屬性，會怎么樣？)：

>>> class Person:

name = 'zgh'

def __init__(self, name):

self.__name = name

@property

def name(self):

return self.__name

>>> p = Person('zgh666')

>>> print(p.name)

zgh666

很顯然，返回的是裝飾器修飾的name函數

@property裝飾器默認提供一個只讀屬性，如果需要，可以使用對應的getter、setter和deleter裝飾器實現其他訪問器函數

>>> class Person:

def __init__(self, name):

self.__name = name

@property

def name(self):

return self.__name

@name.setter

def name(self, value):

self.__name = value

@name.deleter

def name(self):

del self.__name

>>> p = Person('zgh')

>>> p.name = 'Zhanggguohao'

>>> print(p.name)

Zhanggguohao

property(fget=None, fset=None, fdel=None, doc=None)

>>> class Person:

def __init__(self, name):

self.__name = name

def getname(self):

return self.__name

def setname(self, value):

self.__name = value

def delname(self):

del self.__name

name = property(getname, setname,delname, "I'm the 'name' property.")

>>> p = Person('zgh')

>>> print(p.name)

zgh

>>> p.name = 'zgh666'

>>> print(p.name)

zgh666

例9.9(自定義屬性)

在Python中，可以賦予一個對象自定義的屬性，即類定義中不存在的屬性。對象通過特殊屬性

__dict__

存儲自定義屬性

>>> class Person:

pass

>>> p = Person()

>>> p.name = 'custom name'

>>> p.name

'custom name'

>>> p.__dict__

{'name': 'custom name'}

通過重載

__getattr__

和

__setattr__

可以攔截對成員的訪問，從而自定義屬性的行為

__getattr__()

只有在訪問不存在的成員時才會被調用

__getattribute__()

攔截所有的(包括不存在)獲取操作

__setattr__()

設置屬性

__delattr__()

刪除屬性

>>> class CustomAttribute(object):

def __init__(self):

pass

def __getattribute__(self, name):

return str.upper(object.__getattribute__(self, name))

def __setattr__(self, name, value):

object.__setattr__(self, name, str.strip(value))

>>> p = CustomAttribute()

>>> p.firstname = ' mary'

>>> print(p.firstname)

MARY

三：方法

對象實例方法

的第一個參數一般為self，但是用戶調用時不需要也不能給該參數傳值

例9.11(靜態方法：攝氏溫度與華氏溫度之間的相互轉換)

class TemperatureConverter:

@staticmethod

def c2f(t_c):

return (float(t_c) * 9/5) + 32

@staticmethod

def f2c(t_f):

return ((float(t_f) - 32) * 5/9)

print("1. 從攝氏溫度到華氏溫度.")

print("2. 從華氏溫度到攝氏溫度.")

choice = int(input("請選擇轉換方向："))

if choice == 1:

t_c = float(input("請輸入攝氏溫度："))

t_f = TemperatureConverter.c2f(t_c)

print("華氏溫度為：{0:.2f}".format(t_f))

elif choice == 2:

t_f = float(input("請輸入華氏溫度："))

t_c = TemperatureConverter.f2c(t_f)

print("攝氏溫度為：{0:.2f}".format(t_c))

else:

print("無此選項，只能選擇1或2")

輸出：

====================== RESTART: D:\zgh\desktop\test.py ======================

1. 從攝氏溫度到華氏溫度.

2. 從華氏溫度到攝氏溫度.

請選擇轉換方向：1

請輸入攝氏溫度：30

華氏溫度為：86.00

>>>

====================== RESTART: D:\zgh\desktop\test.py ======================

1. 從攝氏溫度到華氏溫度.

2. 從華氏溫度到攝氏溫度.

請選擇轉換方向：2

請輸入華氏溫度：70

攝氏溫度為：21.11

>>>

補充一個很有意思的代碼：

(包含了很多知識點)

TempStr = input("請輸入帶有符號的溫度值：")

if TempStr[-1] in ['F', 'f']:

C = (eval(TempStr[0:-1]) - 32) / 1.8

print("轉化后的溫度是{:.2f}C".format(C))

elif TempStr[-1] in ['C', 'c']:

F = 1.8 * eval(TempStr[0:-1]) + 32

print("轉化后的溫度是{:.2f}F".format(F))

else:

print("輸入格式錯誤")

例9.12(類方法)

類方法的第一個參數為cls，但是調用時用戶不需要也不能給該參數傳值

>>> class Person:

classname = "zgh"

def __init__(self, name):

self.name = name

#實例方法

def f1(self):

print(self.name)

#靜態方法

@staticmethod

def f2():

print("static")

#類方法

@classmethod

def f3(cls):

print(cls.classname)

>>> p = Person("666")

>>> p.f1()

666

>>> Person.f2()

static

>>> p.f2()

static

>>> Person.f3()

zgh

>>> p.f3()

zgh

>>> Person.f1()

Traceback (most recent call last):

File "", line 1, in

Person.f1()

TypeError: f1() missing 1 required positional argument: 'self'

類名不能訪問實例方法

補充：

無論是靜態方法還是類方法一般通過類名來訪問，也可以通過對象實例來調用

在靜態方法中訪問對象實例會導致錯誤

在類方法中訪問對象實例屬性會導致錯誤

例9.15(

__init__()

方法、

__new__()

方法、

__del__()

方法)

__init__()

構造函數，用于執行類的實例的初始化工作。在創建完對象后調用，初始化當前對象的實例，無返回值

__new__()

是一個類方法，在創建對象時調用，返回當前對象的一個實例，一般無須重載該方法

__del__()

析構函數，用于實現銷毀類的實例所需的操作，如釋放對象占用的非托管資源(打開的文件、網絡連接等)

在默認情況下，當對象不再被使用時，

__del__()

方法運行。由于Python解釋器實現自動垃圾回收，所以無法保證這個方法究竟在什么時候運行

但通過

del

語句可以強制銷毀一個對象實例，從而保證調用對象實例的

__del__()

方法

>>> class Person:

count = 0

def __init__(self, name, age):

self.name = name

self.age = age

Person.count += 1

def __del__(self):

Person.count -= 1

def say_hi(self):

print("hello, i'm ", self.name)

def get_count():

print("count: ",Person.count)

>>> print("count: ", Person.count)

>>> p1 = Person('zhangsan', 18)

>>> p1.say_hi()

hello, i'm zhangsan

>>> Person.get_count()

>>> p2 = Person('lisi', 28)

>>> p2.say_hi()

hello, i'm lisi

>>> Person.get_count()

>>> del p1

>>> Person.get_count()

>>> del p2

>>> Person.get_count()

例9.16(私有方法)

與私有屬性類似，Python約定以兩個下劃線開頭，但不以兩個下劃線結束的方法是私有的

不能直接訪問私有的

>>> class Book:

def __init__(self, name, author, price):

self.name = name

self.author = author

self.price = price

def __check_name(self):

if self.name == '': return False

else: return True

def get_name(self):

if self.__check_name(): print(self.name, self.author)

else: print("No Value")

>>> b = Book("Python", 'zgh', 666)

>>> b.get_name()

Python zgh

>>> b.__check_name()#直接調用私有方法，非法

Traceback (most recent call last):

File "", line 1, in

b.__check_name()

AttributeError: 'Book' object has no attribute '__check_name'

例9.17(方法的重載)

Python本身是動態語言，

方法的參數沒有聲明類型(在調用傳值時確定參數的類型)

參數的數量由可選參數和可變參數來控制

故Python對象方法不需要重載，定義一個方法即可實現多種調用，從而實現相當于其他程序設計語言的重載功能

>>> class Person:

def say_hi(self, name=None):

self.name = name

if name ==None: print("hello!")

else: print("hello, i'm ", self.name)

>>> p = Person()

>>> p.say_hi()

hello!

>>> p.say_hi('zgh')

hello, i'm zgh

>>>

注意：在Python類體中定義多個重名的方法雖然不會報錯，但只有最后一個方法有效，所以建議不要定義重名的方法

四：繼承

Pyhon支持多重繼承，即一個派生類可以繼承多個基類

如果在類定義中沒有指定基類，則默認其基類為

object

在聲明派生類時，必須在其構造函數中調用基類的構造函數

例9.19(派生類)

>>> class Person:

def __init__(self, name, age):

self.name = name

self.age = age

def say_hi(self):

print("hello, i'm {0}, {1} olds".format(self.name, self.age))

>>> class Student(Person):

def __init__(self, name, age, stu_id):

Person.__init__(self, name, age)

self.stu_id = stu_id

def say_hi(self):

Person.say_hi(self)

print("i'm student, my student_number is ", self.stu_id)

>>> p =Person('zhangsan',18)

>>> p.say_hi()

hello, i'm zhangsan, 18 olds

>>> s = Student('lisi', 5, '17202030118')

>>> s.say_hi()

hello, i'm lisi, 5 olds

i'm student, my student_number is 17202030118

例9.20(查看類的繼承關系)

多個類的繼承可以形成層次關系，通過類的方法

mro()

或類的屬性

__mro__

可以輸出其繼承的層次關系

>>> class A: pass

>>> class B(A): pass

>>> class C(B): pass

>>> class D(A): pass

>>> class E(B,D): pass

>>> A.mro()

[, ]

>>> B.__mro__

(, , )

>>> C.mro()

[, , , ]

>>>

>>> D.mro()

[, , ]

>>>

>>> E.__mro__

(, , , , )

例9.21(類成員的繼承和重寫)

>>> class Dimension:

def __init__(self, x, y):

self.x = x

self.y = y

def area(self):

pass

>>> class Circle(Dimension):

def __init__(self, r):

Dimension.__init__(self, r, 0)

def area(self):

return 3.14 * self.x * self.x

>>> class Rectangle(Dimension):

def __init__(self, w, h):

Dimension.__init__(self, w, h)

def area(self):

return self.x * self.y

>>> d1 = Circle(2.0)

>>> d2 = Rectangle(3.0, 4.0)

>>> print(d1.area(), d2.area())

12.56 12.0

五：對象的特殊方法

在Python對象中包含許多以雙下劃線開始和結束的方法，稱之為特殊方法。

特殊方法通常在針對對象的某種操作時自動調用

例9.22(重寫對象的特殊方法)

特殊方法

含義

__init__()

，

__del__()

創建或銷毀對象時調用

__setitem__()

，

__getitem__()

按索引賦值、取值

__len__()

對應于內置函數

len()

__repr__(self)

對應于內置函數

repr()

__str__(self)

對應于內置函數

str()

__bytes__(self)

對應于內置函數

bytes()

__format__(self, format_spec)

對應于內置函數

format()

__bool__(self)

對應于內置函數

bool()

__hash__(self)

對應于內置函數

hash()

__dir__(self)

對應于內置函數

dir()

>>> class Person:

def __init__(self, name, age):

self.name = name

self.age = age

def __str__(self):

return '{0}, {1}'.format(self.name, self.age)

>>> p = Person('zgh', '18')

>>> print(p)

zgh, 18

例9.23(運算符重載)

特殊方法

含義

__lt__()

，

__le__()

，

__eq__()

對應于運算符

__gt__()

，

__ge__()

，

__ne__()

對應于運算符

>,>=,!=

__or__()

，

__ror__()

；

__xor__()

，

__rxor__()

；

__and__()

，

__rand__()

對應于運算符

|,^,&

__ior__()

，

__ixor__()

，

__iand__()

對應于運算符

|=,^=,&=

__lshift__()

，

__rlshift__()

；

__rshift__()

，

__rrshift__()

對應于運算符

__ilshift__()

，

__irlshift__()

；

__irshift__()

，

__irrshift__()

對應于運算符

<<=,>>=

__add__()

，

__radd__()

；

__sub__()

，

__rsub__()

對應于運算符

+,-

__iaddr__()

，

__isub__()

對應于運算符

+=,-=

__mul__()

，

__rmul__()

；

__truediv__()

，

__rtruediv__()

對應于運算符

*,/

__mod__()

，

__rmod__()

；

__floordiv__()

，

__rfloordiv__()

對應于運算符

%,//

__imul__()

，

__idiv__()

，

__itruediv__()

，

__imod__()

，

__ifloordiv__()

對應于運算符

*=,/=,%=,//=

__pos__()

，

__neg__()

正負號

__invert__()

按位翻轉

__pow__()

，

__rpow__()

，

__ipow__()

指數運算

看了上這么多特殊方法和運算符的對應，你是否會感到一些奇怪的地方：

，某些運算符為啥子有兩個，然后其中一個的最前面加了一個

舉個例子就懂了：

x.__mul__(y) == x / y

；而

x.__rmul__(y) == y / x

如果上手去嘗試的話，發現復合賦值運算對應的特殊方法都使用不了(未找到原因，暫過，哪位大佬知道啊，評論區留言)

>>> class MyList:

def __init__(self, *args):

self.__mylist = []

for arg in args:

self.__mylist.append(arg)

def __add__(self, n):