面向对象练习

编写程序片段，定义表示课程的类Course。课程的属性包括课程名、编号、选修课号；方法包括设置课程名、设置编号、设置选修课号以及获取课程名、获取编号、获取选修课程号，然后打印输出该对象的课程名、编号以及选修课号

class Course(object):
def init(self,course_name,course_id,course_number):
self.course_name=course_name
self.course_id=course_id
self.course_number=course_number
def set_course_name(self):
pass
def set_course_id(self):
pass
def set_course_number(self):
pass
def get_course_name(self):
print(self.course_name)
def get_course_id(self):
print(self.course_id)
def get_course_number(self):
print(self.course_number)

c1=Course(“java”,“1”,“A1”)
c1.get_course_name()
c1.get_course_id()
c1.get_course_number()

c2=Course(“python”,“2”,“A2”)
c2.get_course_name()
c2.get_course_id()
c2.get_course_number()

执行结果：
java
1
A1
python
2
A2

10、实现一个多重继承类，并访问该类
多重继承：除了从一个父类继承外，Python允许从多个父类继承，称为多重继承。

类：动物Animal
动物Aniaml分为：哺乳动物Mammal和鸟类Bird

按动物的行走方式可以分成：能跑的Runnable和能飞的Flyable

动物：狗Dog，鹦鹉Parrot

class Animal(object):
def eat(self):
print(‘eating…’)
class Mammal(Animal):
def Reproductive(self):
print(‘viviparity…’)
class Bird(Animal):
def Reproductive(self):
print(‘egg-laying…’)
class Runnable(object):
def run(self):
print(‘Running…’)
class Flyable(object):
def fly(self):
print(‘Flying…’)

class Dog(Mammal,Runnable):
pass
class Parrot(Bird,Flyable):
pass

D1=Dog()
D1.run()
D1.Reproductive()
D1.eat()
print("************")
P1=Parrot()
P1.fly()
P1.Reproductive()
P1.eat()

执行结果：
Running…
viviparity…
eating…

---

Flying…
egg-laying…
eating…

12、在不运行情况下给出下面程序执行结果
#coding=utf-8
class Parent(object):
x = 1
class Child1(Parent):
pass
class Child2(Parent):
pass
print(Parent.x, Child1.x, Child2.x) #给出结果
print(id(Parent.x), id(Child1.x), id(Child2.x)) #不需要给结果，只说是否一致
答案：1,1,1
答案：一致
Child1.x = 2
print(Parent.x, Child1.x, Child2.x) #给出结果
print(id(Parent.x), id(Child1.x), id(Child2.x))#不需要给结果，只说是否一致
答案：1,2,1
答案：不一致
Parent.x = 3
print(Parent.x, Child1.x, Child2.x) #给出结果
print(id(Parent.x), id(Child1.x), id(Child2.x))#不需要给结果，只说是否一致不一致
答案：3,3,3
答案：一致

13、在不运行情况下给出下面程序执行的结果，并说明为什么？
class Parson(object):
def init(self, name, f1, f2 = 1) :
self.name = name
self.f1 = f1
self.f2 = f2
self.__inName = ‘jack’
def f1(self, a) :
print(self.f1, a)

@staticmethod
def f2(b):
    print(b)

p1 = Parson(‘joy’, 100, 200)
#print p1.dict, p1
p1.f1(2)
p1.f2(5)

执行结果：

p1.f1(2)

TypeError: ‘int’ object is not callable

Parson()类中中属性名为f1、f2，之后再定义了方法名为f1、f2，所以报错。
说明在同一个类中方法名和属性名不要重名，当类中属性名与方法名重复时，属性会覆盖方法。
14、 按如下规律打印列表
1 [1*, 2, 3, 4, 5]
2 [1, 2*, 3, 4, 5]
3 [1, 2, 3*, 4, 5]
4 [2, 3, 4*, 5, 6]
5 [3, 4, 5*, 6, 7]
6 [4, 5, 6*, 7, 8]
…
20 [16, 17, 18, 19, 20*]

代码：
line=[]
dict1={‘k1’:1,‘k2’:2,‘k3’:3,‘k4’:4,‘k5’:5}
for i in range(1,21):
print(i,end=" “)
if i < 3 or i >17:
for m in dict1.keys():
if dict1[m]==i:
line.append(str(i)+”")
else:
line.append(dict1[m])
else:
for m,n in dict1.items():
if dict1[m]==i:
line.append(str(i)+"")
else:
line.append(dict1[m])
dict1[m]=n+1
print(line)
line=[]

执行结果：
1 [‘1*’, 2, 3, 4, 5]
2 [1, ‘2*’, 3, 4, 5]
3 [1, 2, ‘3*’, 4, 5]
4 [2, 3, ‘4*’, 5, 6]
5 [3, 4, ‘5*’, 6, 7]
6 [4, 5, ‘6*’, 7, 8]
7 [5, 6, ‘7*’, 8, 9]
8 [6, 7, ‘8*’, 9, 10]
9 [7, 8, ‘9*’, 10, 11]
10 [8, 9, ‘10*’, 11, 12]
11 [9, 10, ‘11*’, 12, 13]
12 [10, 11, ‘12*’, 13, 14]
13 [11, 12, ‘13*’, 14, 15]
14 [12, 13, ‘14*’, 15, 16]
15 [13, 14, ‘15*’, 16, 17]
16 [14, 15, ‘16*’, 17, 18]
17 [15, 16, ‘17*’, 18, 19]
18 [16, 17, ‘18*’, 19, 20]
19 [16, 17, 18, ‘19*’, 20]
20 [16, 17, 18, 19, ‘20*’]

15、 写一个函数, 将驼峰命名法字符串转成下划线命名字符串，如GetItem -> get_item， getItem -> get_item。

def hump2underline(hunp_str): #驼峰形式字符串转成下划线形式
result=[]
for i in range(0,len(hunp_str)):
if hunp_str[i].isupper() and i!=0:
result.append("_")
result.append(hunp_str[i].lower())
return “”.join(result)

print(hump2underline(‘GetItem’))
print(hump2underline(‘getItem’))

执行结果：
get_item
get_item

def underline2hump(underline_str): #下划线形式字符串转成驼峰形式
result=[]
result_tmp=underline_str.split("_")
for i in result_tmp:
result.append(i.capitalize())
return “”.join(result)

print(underline2hump(“get_item”))
print(underline2hump(“person_name_pattern”))

执行结果：
getItem
personNamePattern

第二种使用re.sub()函数写
def hump2underline(hunp_str): # 驼峰形式字符串转成下划线形式
import re
p = re.compile(r’([a-z]|\d)([A-Z])’) # 匹配正则，匹配小写字母和大写字母的分界位置
sub = re.sub(p, r’\1_\2’, hunp_str).lower() # 这里第二个参数使用了正则分组的后向引用
return sub

print(hump2underline(‘GetItem’))
print(hump2underline(‘getItem’))

执行结果：
get_item
get_item

def underline2hump(underline_str): #下划线形式字符串转成驼峰形式
import re
# 这里re.sub()函数第二个替换参数用到了一个匿名回调函数，回调函数的参数x为一个匹配对象，返回值为一个处理后的字符串
sub = re.sub(r’(_\w)’,lambda x:x.group(1)[1].upper(),underline_str)
return sub

print(underline2hump(“get_item”))
print(underline2hump(“person_name_pattern”))

执行结果：
getItem
personNamePattern