2.4
class Flower:
def __init__(self, name='peony', number=6, price=3.66):
self._name = name
self._number = number
self._price = price
f1=Flower()
print(f1._name)
2.5
class CreditCard:
"""A consumer credit card."""
def __init__(self, customer, bank, acnt, limit):
"""Create a new credit card instance.
The initial balance is zero.
customer the name of the customer (e.g., 'John Bowman')
bank the name of the bank (e.g., 'California Savings')
acnt the acount identifier (e.g., '5391 0375 9387 5309')
limit credit limit (measured in dollars)
"""
self._customer = customer
self._bank = bank
self._account = acnt
self._limit = limit
self._balance = 0
def get_customer(self):
"""Return name of the customer."""
return self._customer
def get_bank(self):
"""Return the bank's name."""
return self._bank
def get_account(self):
"""Return the card identifying number (typically stored as a string)."""
return self._account
def get_limit(self):
"""Return current credit limit."""
return self._limit
def get_balance(self):
"""Return current balance."""
return self._balance
def charge(self, price):
"""Charge given price to the card, assuming sufficient credit limit.
Return True if charge was processed; False if charge was denied.
"""
try:
float(price)
if price + self._balance > self._limit: # if charge would exceed limit,
return False # cannot accept charge
else:
self._balance += price
return True
except ValueError:
print('charge function need a numerical input')
def make_payment(self, amount):
"""Process customer payment that reduces balance."""
try:
float(amount)
self._balance -= amount
except ValueError:
print('charge make_payment need a numerical input')
if __name__ == '__main__':
wallet = []
wallet.append(CreditCard('John Bowman', 'California Savings',
'5391 0375 9387 5309', 2500))
wallet.append(CreditCard('John Bowman', 'California Federal',
'3485 0399 3395 1954', 3500))
wallet.append(CreditCard('John Bowman', 'California Finance',
'5391 0375 9387 5309', 5000))
for val in range(1, 17):
wallet[0].charge(val)
wallet[1].charge(2 * val)
wallet[2].charge(3 * val)
for c in range(3):
print('Customer =', wallet[c].get_customer())
print('Bank =', wallet[c].get_bank())
print('Account =', wallet[c].get_account())
print('Limit =', wallet[c].get_limit())
print('Balance =', wallet[c].get_balance())
while wallet[c].get_balance() > 100:
wallet[c].make_payment(100)
print('New balance =', wallet[c].get_balance())
wallet[c].charge('a')
wallet[c].make_payment('a')
2.6
class CreditCard:
"""A consumer credit card."""
def __init__(self, customer, bank, acnt, limit):
"""Create a new credit card instance.
The initial balance is zero.
customer the name of the customer (e.g., 'John Bowman')
bank the name of the bank (e.g., 'California Savings')
acnt the acount identifier (e.g., '5391 0375 9387 5309')
limit credit limit (measured in dollars)
"""
self._customer = customer
self._bank = bank
self._account = acnt
self._limit = limit
self._balance = 0
def get_customer(self):
"""Return name of the customer."""
return self._customer
def get_bank(self):
"""Return the bank's name."""
return self._bank
def get_account(self):
"""Return the card identifying number (typically stored as a string)."""
return self._account
def get_limit(self):
"""Return current credit limit."""
return self._limit
def get_balance(self):
"""Return current balance."""
return self._balance
def charge(self, price):
"""Charge given price to the card, assuming sufficient credit limit.
Return True if charge was processed; False if charge was denied.
"""
try:
if price < 0:
raise ValueError('price must be positive')
if price + self._balance > self._limit: # if charge would exceed limit,
return False # cannot accept charge
else:
self._balance += price
return True
except TypeError:
print('charge function need a numerical input')
def make_payment(self, amount):
"""Process customer payment that reduces balance."""
try:
if amount < 0:
raise ValueError('amount must be positive')
self._balance -= amount
except TypeError:
print('charge make_payment need a numerical input')
if __name__ == '__main__':
wallet = []
wallet.append(CreditCard('John Bowman', 'California Savings',
'5391 0375 9387 5309', 2500))
wallet.append(CreditCard('John Bowman', 'California Federal',
'3485 0399 3395 1954', 3500))
wallet.append(CreditCard('John Bowman', 'California Finance',
'5391 0375 9387 5309', 5000))
for val in range(1, 17):
wallet[0].charge(val)
wallet[1].charge(2 * val)
wallet[2].charge(3 * val)
for c in range(3):
print('Customer =', wallet[c].get_customer())
print('Bank =', wallet[c].get_bank())
print('Account =', wallet[c].get_account())
print('Limit =', wallet[c].get_limit())
print('Balance =', wallet[c].get_balance())
while wallet[c].get_balance() > 100:
wallet[c].make_payment(100)
print('New balance =', wallet[c].get_balance())
wallet[c].charge('a')
wallet[c].make_payment('a')
wallet[c].charge(-1)
wallet[c].make_payment(-2)
2.7
class CreditCard:
"""A consumer credit card."""
def __init__(self, customer, bank, acnt, limit, nrz=0):
"""Create a new credit card instance.
The initial balance is zero.
customer the name of the customer (e.g., 'John Bowman')
bank the name of the bank (e.g., 'California Savings')
acnt the acount identifier (e.g., '5391 0375 9387 5309')
limit credit limit (measured in dollars)
"""
self._customer = customer
self._bank = bank
self._account = acnt
self._limit = limit
self._balance = nrz
def get_customer(self):
"""Return name of the customer."""
return self._customer
def get_bank(self):
"""Return the bank's name."""
return self._bank
def get_account(self):
"""Return the card identifying number (typically stored as a string)."""
return self._account
def get_limit(self):
"""Return current credit limit."""
return self._limit
def get_balance(self):
"""Return current balance."""
return self._balance
def charge(self, price):
"""Charge given price to the card, assuming sufficient credit limit.
Return True if charge was processed; False if charge was denied.
"""
try:
if price < 0:
raise ValueError('price must be positive')
if price + self._balance > self._limit: # if charge would exceed limit,
return False # cannot accept charge
else:
self._balance += price
return True
except TypeError:
print('charge function need a numerical input')
def make_payment(self, amount):
"""Process customer payment that reduces balance."""
try:
if amount < 0:
raise ValueError('amount must be positive')
self._balance -= amount
except TypeError:
print('charge make_payment need a numerical input')
if __name__ == '__main__':
wallet = []
wallet.append(CreditCard('John Bowman', 'California Savings',
'5391 0375 9387 5309', 2500))
wallet.append(CreditCard('John Bowman', 'California Federal',
'3485 0399 3395 1954', 3500))
wallet.append(CreditCard('John Bowman', 'California Finance',
'5391 0375 9387 5309', 5000))
for val in range(1, 17):
wallet[0].charge(val)
wallet[1].charge(2 * val)
wallet[2].charge(3 * val)
for c in range(3):
print('Customer =', wallet[c].get_customer())
print('Bank =', wallet[c].get_bank())
print('Account =', wallet[c].get_account())
print('Limit =', wallet[c].get_limit())
print('Balance =', wallet[c].get_balance())
while wallet[c].get_balance() > 100:
wallet[c].make_payment(100)
print('New balance =', wallet[c].get_balance())
wallet[c].charge('a')
wallet[c].make_payment('a')
# wallet[c].charge(-1)
# wallet[c].make_payment(-2)
wallet2=CreditCard('John Bowman', 'California Savings',
'5391 0375 9387 5309', 2500,3)
print(wallet2.get_balance())
2.8
class CreditCard:
"""A consumer credit card."""
def __init__(self, customer, bank, acnt, limit, nrz=0):
"""Create a new credit card instance.
The initial balance is zero.
customer the name of the customer (e.g., 'John Bowman')
bank the name of the bank (e.g., 'California Savings')
acnt the acount identifier (e.g., '5391 0375 9387 5309')
limit credit limit (measured in dollars)
"""
self._customer = customer
self._bank = bank
self._account = acnt
self._limit = limit
self._balance = nrz
def get_customer(self):
"""Return name of the customer."""
return self._customer
def get_bank(self):
"""Return the bank's name."""
return self._bank
def get_account(self):
"""Return the card identifying number (typically stored as a string)."""
return self._account
def get_limit(self):
"""Return current credit limit."""
return self._limit
def get_balance(self):
"""Return current balance."""
return self._balance
def charge(self, price):
"""Charge given price to the card, assuming sufficient credit limit.
Return True if charge was processed; False if charge was denied.
"""
try:
if price < 0:
raise ValueError('price must be positive')
if price + self._balance > self._limit: # if charge would exceed limit,
return False # cannot accept charge
else:
self._balance += price
return True
except TypeError:
print('charge function need a numerical input')
def make_payment(self, amount):
"""Process customer payment that reduces balance."""
try:
if amount < 0:
raise ValueError('amount must be positive')
self._balance -= amount
except TypeError:
print('charge make_payment need a numerical input')
if __name__ == '__main__':
wallet = []
wallet.append(CreditCard('John Bowman', 'California Savings',
'5391 0375 9387 5309', 2500))
wallet.append(CreditCard('John Bowman', 'California Federal',
'3485 0399 3395 1954', 3500))
wallet.append(CreditCard('John Bowman', 'California Finance',
'5391 0375 9387 5309', 5000))
for val in range(1,100):
wallet[0].charge(val)
wallet[1].charge(2 * val)
wallet[2].charge(3 * val)
for c in range(3):
print('Customer =', wallet[c].get_customer())
print('Bank =', wallet[c].get_bank())
print('Account =', wallet[c].get_account())
print('Limit =', wallet[c].get_limit())
print('Balance =', wallet[c].get_balance())
while wallet[c].get_balance() > 1000:
wallet[c].make_payment(1000)
print('New balance =', wallet[c].get_balance())
wallet[c].charge('a')
wallet[c].make_payment('a')
# wallet[c].charge(-1)
# wallet[c].make_payment(-2)
wallet2=CreditCard('John Bowman', 'California Savings',
'5391 0375 9387 5309', 2500,3)
print(wallet2.get_balance())
"""都不会出现，因为在charge函数中，到了极限就return false，并无增加额度的操作"""
2.9
import collections
class Vector:
"""Represent a vector in a multidimensional space."""
def __init__(self, d):
if isinstance(d, int):
self._coords = [0] * d
else:
try: # we test if param is iterable
self._coords = [val for val in d]
except TypeError:
raise TypeError('invalid parameter type')
def __len__(self):
"""Return the dimension of the vector."""
return len(self._coords)
def __getitem__(self, j):
"""Return jth coordinate of vector."""
return self._coords[j]
def __setitem__(self, j, val):
"""Set jth coordinate of vector to given value."""
self._coords[j] = val
def __add__(self, other):
"""Return sum of two vectors."""
if len(self) != len(other): # relies on __len__ method
raise ValueError('dimensions must agree')
result = Vector(len(self)) # start with vector of zeros
for j in range(len(self)):
result[j] = self[j] + other[j]
return result
def __eq__(self, other):
"""Return True if vector has same coordinates as other."""
return self._coords == other._coords
def __ne__(self, other):
"""Return True if vector differs from other."""
return not self == other # rely on existing __eq__ definition
def __str__(self):
"""Produce string representation of vector."""
return '<' + str(self._coords)[1:-1] + '>' # adapt list representation
def __neg__(self):
"""Return copy of vector with all coordinates negated."""
result = Vector(len(self)) # start with vector of zeros
for j in range(len(self)):
result[j] = -self[j]
return result
def __lt__(self, other):
"""Compare vectors based on lexicographical order."""
if len(self) != len(other):
raise ValueError('dimensions must agree')
return self._coords < other._coords
def __le__(self, other):
"""Compare vectors based on lexicographical order."""
if len(self) != len(other):
raise ValueError('dimensions must agree')
return self._coords <= other._coords
def __sub__(self, other):
if len(self)!= len(other):
raise ValueError('dimensions must agree')
result = Vector(len(self))
for j in range(len(self._coords)):
result=self._coords[j]-other[j]
return result
if __name__ == '__main__':
# the following demonstrates usage of a few methods
v = Vector(5) # construct five-dimensional <0, 0, 0, 0, 0>
v[1] = 23 # <0, 23, 0, 0, 0> (based on use of __setitem__)
v[-1] = 45 # <0, 23, 0, 0, 45> (also via __setitem__)
print(v[4]) # print 45 (via __getitem__)
u = v + v # <0, 46, 0, 0, 90> (via __add__)
print(u) # print <0, 46, 0, 0, 90>
total = 0
for entry in v: # implicit iteration via __len__ and __getitem__
total += entry
z=v+[1,5,3,5,4]
print(z)
2.10
import collections
class Vector:
"""Represent a vector in a multidimensional space."""
def __init__(self, d):
if isinstance(d, int):
self._coords = [0] * d
else:
try: # we test if param is iterable
self._coords = [val for val in d]
except TypeError:
raise TypeError('invalid parameter type')
def __len__(self):
"""Return the dimension of the vector."""
return len(self._coords)
def __getitem__(self, j):
"""Return jth coordinate of vector."""
return self._coords[j]
def __setitem__(self, j, val):
"""Set jth coordinate of vector to given value."""
self._coords[j] = val
def __add__(self, other):
"""Return sum of two vectors."""
if len(self) != len(other): # relies on __len__ method
raise ValueError('dimensions must agree')
result = Vector(len(self)) # start with vector of zeros
for j in range(len(self)):
result[j] = self[j] + other[j]
return result
def __eq__(self, other):
"""Return True if vector has same coordinates as other."""
return self._coords == other._coords
def __ne__(self, other):
"""Return True if vector differs from other."""
return not self == other # rely on existing __eq__ definition
def __str__(self):
"""Produce string representation of vector."""
return '<' + str(self._coords)[1:-1] + '>' # adapt list representation
def __neg__(self):
"""Return copy of vector with all coordinates negated."""
result = Vector(len(self)) # start with vector of zeros
for j in range(len(self)):
result[j] = -self[j]
return result
def __lt__(self, other):
"""Compare vectors based on lexicographical order."""
if len(self) != len(other):
raise ValueError('dimensions must agree')
return self._coords < other._coords
def __le__(self, other):
"""Compare vectors based on lexicographical order."""
if len(self) != len(other):
raise ValueError('dimensions must agree')
return self._coords <= other._coords
def __sub__(self, other):
if len(self)!= len(other):
raise ValueError('dimensions must agree')
result = Vector(len(self))
for j in range(len(self._coords)):
result[j]=self._coords[j]-other[j]
return result
if __name__ == '__main__':
# the following demonstrates usage of a few methods
v = Vector(5) # construct five-dimensional <0, 0, 0, 0, 0>
v[1] = 23 # <0, 23, 0, 0, 0> (based on use of __setitem__)
v[-1] = 45 # <0, 23, 0, 0, 45> (also via __setitem__)
print(v[4]) # print 45 (via __getitem__)
u = v + v # <0, 46, 0, 0, 90> (via __add__)
print(u) # print <0, 46, 0, 0, 90>
total = 0
for entry in v: # implicit iteration via __len__ and __getitem__
total += entry
z = v - [1, 5, 3, 5, 4]
print(z)
z=-z
print(z)
2.11+2.12
import collections
class Vector:
"""Represent a vector in a multidimensional space."""
def __init__(self, d):
if isinstance(d, int):
self._coords = [0] * d
else:
try: # we test if param is iterable
self._coords = [val for val in d]
except TypeError:
raise TypeError('invalid parameter type')
def __len__(self):
"""Return the dimension of the vector."""
return len(self._coords)
def __getitem__(self, j):
"""Return jth coordinate of vector."""
return self._coords[j]
def __setitem__(self, j, val):
"""Set jth coordinate of vector to given value."""
self._coords[j] = val
def __add__(self, other):
"""Return sum of two vectors."""
if len(self) != len(other): # relies on __len__ method
raise ValueError('dimensions must agree')
result = Vector(len(self)) # start with vector of zeros
for j in range(len(self)):
result[j] = self[j] + other[j]
return result
def __radd__(self, other):
"""Return sum of two vectors."""
if len(self) != len(other): # relies on __len__ method
raise ValueError('dimensions must agree')
result = Vector(len(self)) # start with vector of zeros
for j in range(len(self)):
result[j] = self[j] + other[j]
return result
def __eq__(self, other):
"""Return True if vector has same coordinates as other."""
return self._coords == other._coords
def __ne__(self, other):
"""Return True if vector differs from other."""
return not self == other # rely on existing __eq__ definition
def __str__(self):
"""Produce string representation of vector."""
return '<' + str(self._coords)[1:-1] + '>' # adapt list representation
def __neg__(self):
"""Return copy of vector with all coordinates negated."""
result = Vector(len(self)) # start with vector of zeros
for j in range(len(self)):
result[j] = -self[j]
return result
def __lt__(self, other):
"""Compare vectors based on lexicographical order."""
if len(self) != len(other):
raise ValueError('dimensions must agree')
return self._coords < other._coords
def __le__(self, other):
"""Compare vectors based on lexicographical order."""
if len(self) != len(other):
raise ValueError('dimensions must agree')
return self._coords <= other._coords
def __sub__(self, other):
if len(self)!= len(other):
raise ValueError('dimensions must agree')
result = Vector(len(self))
for j in range(len(self._coords)):
result[j]=self._coords[j]-other[j]
return result
def __mul__(self, other):
result=Vector(len(self._coords))
for j in range(len(self._coords)):
result[j]=self._coords[j]*other
return result
if __name__ == '__main__':
# the following demonstrates usage of a few methods
v = Vector(5) # construct five-dimensional <0, 0, 0, 0, 0>
v[1] = 23 # <0, 23, 0, 0, 0> (based on use of __setitem__)
v[-1] = 45 # <0, 23, 0, 0, 45> (also via __setitem__)
print(v[4]) # print 45 (via __getitem__)
u = v + v # <0, 46, 0, 0, 90> (via __add__)
print(u) # print <0, 46, 0, 0, 90>
total = 0
for entry in v: # implicit iteration via __len__ and __getitem__
total += entry
z = v - [1, 5, 3, 5, 4]
print(z)
z=-z
print(z)
print(z*3)
z=[1,6,6,6,6]+z
print(z)
2.13
import collections
class Vector:
"""Represent a vector in a multidimensional space."""
def __init__(self, d):
if isinstance(d, int):
self._coords = [0] * d
else:
try: # we test if param is iterable
self._coords = [val for val in d]
except TypeError:
raise TypeError('invalid parameter type')
def __len__(self):
"""Return the dimension of the vector."""
return len(self._coords)
def __getitem__(self, j):
"""Return jth coordinate of vector."""
return self._coords[j]
def __setitem__(self, j, val):
"""Set jth coordinate of vector to given value."""
self._coords[j] = val
def __add__(self, other):
"""Return sum of two vectors."""
if len(self) != len(other): # relies on __len__ method
raise ValueError('dimensions must agree')
result = Vector(len(self)) # start with vector of zeros
for j in range(len(self)):
result[j] = self[j] + other[j]
return result
def __radd__(self, other):
"""Return sum of two vectors."""
if len(self) != len(other): # relies on __len__ method
raise ValueError('dimensions must agree')
result = Vector(len(self)) # start with vector of zeros
for j in range(len(self)):
result[j] = self[j] + other[j]
return result
def __eq__(self, other):
"""Return True if vector has same coordinates as other."""
return self._coords == other._coords
def __ne__(self, other):
"""Return True if vector differs from other."""
return not self == other # rely on existing __eq__ definition
def __str__(self):
"""Produce string representation of vector."""
return '<' + str(self._coords)[1:-1] + '>' # adapt list representation
def __neg__(self):
"""Return copy of vector with all coordinates negated."""
result = Vector(len(self)) # start with vector of zeros
for j in range(len(self)):
result[j] = -self[j]
return result
def __lt__(self, other):
"""Compare vectors based on lexicographical order."""
if len(self) != len(other):
raise ValueError('dimensions must agree')
return self._coords < other._coords
def __le__(self, other):
"""Compare vectors based on lexicographical order."""
if len(self) != len(other):
raise ValueError('dimensions must agree')
return self._coords <= other._coords
def __sub__(self, other):
if len(self)!= len(other):
raise ValueError('dimensions must agree')
result = Vector(len(self))
for j in range(len(self._coords)):
result[j]=self._coords[j]-other[j]
return result
def __mul__(self, other):
result=Vector(len(self._coords))
for j in range(len(self._coords)):
result[j]=self._coords[j]*other
return result
def __rmul__(self, other):
result=Vector(len(self._coords))
for j in range(len(self._coords)):
result[j]=self._coords[j]*other
return result
if __name__ == '__main__':
# the following demonstrates usage of a few methods
v = Vector(5) # construct five-dimensional <0, 0, 0, 0, 0>
v[1] = 23 # <0, 23, 0, 0, 0> (based on use of __setitem__)
v[-1] = 45 # <0, 23, 0, 0, 45> (also via __setitem__)
print(v[4]) # print 45 (via __getitem__)
u = v + v # <0, 46, 0, 0, 90> (via __add__)
print(u) # print <0, 46, 0, 0, 90>
total = 0
for entry in v: # implicit iteration via __len__ and __getitem__
total += entry
z = v - [1, 5, 3, 5, 4]
print('z=v-[]',z)
z=-z
print('-z ',z)
print('z*3 ',z*3)
z=[1,6,6,6,6]+z
print('[]+z ',z)
print('3*z ',3*z)
2.14
import collections
class Vector:
"""Represent a vector in a multidimensional space."""
def __init__(self, d):
if isinstance(d, int):
self._coords = [0] * d
else:
try: # we test if param is iterable
self._coords = [val for val in d]
except TypeError:
raise TypeError('invalid parameter type')
def __len__(self):
"""Return the dimension of the vector."""
return len(self._coords)
def __getitem__(self, j):
"""Return jth coordinate of vector."""
return self._coords[j]
def __setitem__(self, j, val):
"""Set jth coordinate of vector to given value."""
self._coords[j] = val
def __add__(self, other):
"""Return sum of two vectors."""
if len(self) != len(other): # relies on __len__ method
raise ValueError('dimensions must agree')
result = Vector(len(self)) # start with vector of zeros
for j in range(len(self)):
result[j] = self[j] + other[j]
return result
def __radd__(self, other):
"""Return sum of two vectors."""
if len(self) != len(other): # relies on __len__ method
raise ValueError('dimensions must agree')
result = Vector(len(self)) # start with vector of zeros
for j in range(len(self)):
result[j] = self[j] + other[j]
return result
def __eq__(self, other):
"""Return True if vector has same coordinates as other."""
return self._coords == other._coords
def __ne__(self, other):
"""Return True if vector differs from other."""
return not self == other # rely on existing __eq__ definition
def __str__(self):
"""Produce string representation of vector."""
return '<' + str(self._coords)[1:-1] + '>' # adapt list representation
def __neg__(self):
"""Return copy of vector with all coordinates negated."""
result = Vector(len(self)) # start with vector of zeros
for j in range(len(self)):
result[j] = -self[j]
return result
def __lt__(self, other):
"""Compare vectors based on lexicographical order."""
if len(self) != len(other):
raise ValueError('dimensions must agree')
return self._coords < other._coords
def __le__(self, other):
"""Compare vectors based on lexicographical order."""
if len(self) != len(other):
raise ValueError('dimensions must agree')
return self._coords <= other._coords
def __sub__(self, other):
if len(self)!= len(other):
raise ValueError('dimensions must agree')
result = Vector(len(self))
for j in range(len(self._coords)):
result[j]=self._coords[j]-other[j]
return result
def __mul__(self, other):
result=0
for j in range(len(self._coords)):
result+=self._coords[j]*other[j]
return result
def __rmul__(self, other):
result=Vector(len(self._coords))
for j in range(len(self._coords)):
result[j]=self._coords[j]*other
return result
if __name__ == '__main__':
# the following demonstrates usage of a few methods
v = Vector(5) # construct five-dimensional <0, 0, 0, 0, 0>
v[1] = 23 # <0, 23, 0, 0, 0> (based on use of __setitem__)
v[-1] = 45 # <0, 23, 0, 0, 45> (also via __setitem__)
print(v[4]) # print 45 (via __getitem__)
u = v + v # <0, 46, 0, 0, 90> (via __add__)
print(u) # print <0, 46, 0, 0, 90>
total = 0
for entry in v: # implicit iteration via __len__ and __getitem__
total += entry
z = v - [1, 5, 3, 5, 4]
print('z=v-[]',z)
z=-z
print('-z ',z)
# print('z*3 ',z*3)
z=[1,6,6,6,6]+z
print('[]+z ',z)
print('3*z ',3*z)
print('z*v ', z * v)
a=Vector([1,2,3])
print(a)
2.16
stop-1-start表示差值，-1表示range末端不能到stop，最多只能到stop-1。
差值并没有包括start，所以应该再加上start的一位数。
整数除step表示除不尽的小于1，不能取到
2.18
class Progression:
"""Iterator producing a generic progression.
Default iterator produces the whole numbers 0, 1, 2, ...
"""
def __init__(self, start=0):
"""Initialize current to the first value of the progression."""
self._current = start
def _advance(self):
"""Update self._current to a new value.
This should be overridden by a subclass to customize progression.
By convention, if current is set to None, this designates the
end of a finite progression.
"""
self._current += 1
def __next__(self):
"""Return the next element, or else raise StopIteration error."""
if self._current is None: # our convention to end a progression
raise StopIteration()
else:
answer = self._current # record current value to return
self._advance() # advance to prepare for next time
return answer # return the answer
def __iter__(self):
"""By convention, an iterator must return itself as an iterator."""
return self
def print_progression(self, n):
"""Print next n values of the progression."""
print(' '.join(str(next(self)) for j in range(n)))
class ArithmeticProgression(Progression): # inherit from Progression
"""Iterator producing an arithmetic progression."""
def __init__(self, increment=1, start=0):
"""Create a new arithmetic progression.
increment the fixed constant to add to each term (default 1)
start the first term of the progression (default 0)
"""
super().__init__(start) # initialize base class
self._increment = increment
def _advance(self): # override inherited version
"""Update current value by adding the fixed increment."""
self._current += self._increment
class GeometricProgression(Progression): # inherit from Progression
"""Iterator producing a geometric progression."""
def __init__(self, base=2, start=1):
"""Create a new geometric progression.
base the fixed constant multiplied to each term (default 2)
start the first term of the progression (default 1)
"""
super().__init__(start)
self._base = base
def _advance(self): # override inherited version
"""Update current value by multiplying it by the base value."""
self._current *= self._base
class FibonacciProgression(Progression):
"""Iterator producing a generalized Fibonacci progression."""
def __init__(self, first=0, second=1):
"""Create a new fibonacci progression.
first the first term of the progression (default 0)
second the second term of the progression (default 1)
"""
super().__init__(first) # start progression at first
self._prev = second - first # fictitious value preceding the first
def _advance(self):
"""Update current value by taking sum of previous two."""
self._prev, self._current = self._current, self._prev + self._current
if __name__ == '__main__':
print('Default progression:')
Progression().print_progression(10)
print('Arithmetic progression with increment 5:')
ArithmeticProgression(5).print_progression(10)
print('Arithmetic progression with increment 5 and start 2:')
ArithmeticProgression(5, 2).print_progression(10)
print('Geometric progression with default base:')
GeometricProgression().print_progression(10)
print('Geometric progression with base 3:')
GeometricProgression(3).print_progression(10)
print('Fibonacci progression with default start values:')
FibonacciProgression().print_progression(10)
print('Fibonacci progression with start values 4 and 6:')
FibonacciProgression(4, 6).print_progression(10)
FibonacciProgression(2,2)
FibonacciProgression(2,2).print_progression(8)
ArithmeticProgression(128,0).print_progression(2**10)
2.25
class Vector:
"""Represent a vector in a multidimensional space."""
def __init__(self, d):
if isinstance(d, int):
self._coords = [0] * d
else:
try: # we test if param is iterable
self._coords = [val for val in d]
except TypeError:
raise TypeError('invalid parameter type')
def __len__(self):
"""Return the dimension of the vector."""
return len(self._coords)
def __getitem__(self, j):
"""Return jth coordinate of vector."""
return self._coords[j]
def __setitem__(self, j, val):
"""Set jth coordinate of vector to given value."""
self._coords[j] = val
def __add__(self, other):
"""Return sum of two vectors."""
if len(self) != len(other): # relies on __len__ method
raise ValueError('dimensions must agree')
result = Vector(len(self)) # start with vector of zeros
for j in range(len(self)):
result[j] = self[j] + other[j]
return result
def __radd__(self, other):
"""Return sum of two vectors."""
if len(self) != len(other): # relies on __len__ method
raise ValueError('dimensions must agree')
result = Vector(len(self)) # start with vector of zeros
for j in range(len(self)):
result[j] = self[j] + other[j]
return result
def __eq__(self, other):
"""Return True if vector has same coordinates as other."""
return self._coords == other._coords
def __ne__(self, other):
"""Return True if vector differs from other."""
return not self == other # rely on existing __eq__ definition
def __str__(self):
"""Produce string representation of vector."""
return '<' + str(self._coords)[1:-1] + '>' # adapt list representation
def __neg__(self):
"""Return copy of vector with all coordinates negated."""
result = Vector(len(self)) # start with vector of zeros
for j in range(len(self)):
result[j] = -self[j]
return result
def __lt__(self, other):
"""Compare vectors based on lexicographical order."""
if len(self) != len(other):
raise ValueError('dimensions must agree')
return self._coords < other._coords
def __le__(self, other):
"""Compare vectors based on lexicographical order."""
if len(self) != len(other):
raise ValueError('dimensions must agree')
return self._coords <= other._coords
def __sub__(self, other):
if len(self) != len(other):
raise ValueError('dimensions must agree')
result = Vector(len(self))
for j in range(len(self._coords)):
result[j] = self._coords[j] - other[j]
return result
def __mul__(self, other):
if isinstance(other,int):
result = Vector(len(self._coords))
for j in range(len(self._coords)):
result[j] = self._coords[j] * other
else:
result = 0
for j in range(len(self._coords)):
result += self._coords[j] * other[j]
return result
def __rmul__(self, other):
result = Vector(len(self._coords))
for j in range(len(self._coords)):
result[j] = self._coords[j] * other
return result
if __name__ == '__main__':
# the following demonstrates usage of a few methods
v = Vector(5) # construct five-dimensional <0, 0, 0, 0, 0>
v[1] = 23 # <0, 23, 0, 0, 0> (based on use of __setitem__)
v[-1] = 45 # <0, 23, 0, 0, 45> (also via __setitem__)
print(v[4]) # print 45 (via __getitem__)
u = v + v # <0, 46, 0, 0, 90> (via __add__)
print(u) # print <0, 46, 0, 0, 90>
total = 0
for entry in v: # implicit iteration via __len__ and __getitem__
total += entry
z = v - [1, 5, 3, 5, 4]
print('z=v-[]', z)
z = -z
print('-z ', z)
print('z*3 ',z*3)
z = [1, 6, 6, 6, 6] + z
print('[]+z ', z)
print('3*z ', 3 * z)
print('z*v ', z * v)
a = Vector([1, 2, 3])
print(a)
2.26
class ReversedIterator:
"""An iterator for any of Python's sequence types."""
def __init__(self, sequence):
"""Create an iterator for the given sequence."""
self._seq = sequence # keep a reference to the underlying data
self._k = 0 # will increment to 0 on first call to next
def __next__(self):
"""Return the next element, or else raise StopIteration error."""
self._k -= 1 # advance to next index
if self._k > -1*len(self._seq)-1:
return (self._seq[self._k]) # return the data element
else:
raise StopIteration() # there are no more elements
def __iter__(self):
"""By convention, an iterator must return itself as an iterator."""
return self
Myclass=ReversedIterator([0,2,6,9,7,10])
for i in Myclass:
print(i)
2.27
import time
class Range:
"""A class that mimic's the built-in range class."""
def __init__(self, start, stop=None, step=1):
"""Initialize a Range instance.
Semantics is similar to built-in range class.
"""
if step == 0:
raise ValueError('step cannot be 0')
if stop is None: # special case of range(n)
start, stop = 0, start # should be treated as if range(0,n)
# calculate the effective length once
self._length = max(0, (stop - start + step - 1) // step)
# need knowledge of start and step (but not stop) to support __getitem__
self._start = start
self._step = step
def __len__(self):
"""Return number of entries in the range."""
return self._length
def __getitem__(self, k):
"""Return entry at index k (using standard interpretation if negative)."""
if k < 0:
k += len(self) # attempt to convert negative index
if not 0 <= k < self._length:
raise IndexError('index out of range')
return self._start + k * self._step
def __contains__(self, item):
print(self._start, self._step, self._length)
if item >= self._start and item <= self._start + self._step * (self._length - 1):
if ((item - self._start) % self._step) == 0:
return True
return False
start_time = time.time()
A = Range(1, 100000000)
if 50000 in A:
end_time = time.time()
interval1 = (end_time - start_time)
print('in ')
print('final_name:\t', interval1)
start_time = time.time()
if 2 in A:
end_time = time.time()
interval2 = (end_time - start_time)
print('in ')
print('final_name:\t', interval2)
if interval1>interval2:
print(('>'))
2.33
def dif(polynomial):
if not isinstance(polynomial, list):
raise TypeError('dif函数输入应为列表')
for j in range(len(polynomial)-1):
polynomial[j] *= len(polynomial) - j-1
print(polynomial[j], 'x**', len(polynomial) - j-1, '+')
poly=[4, 3, 2, 1]
dif(poly)
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
