python基础篇之面向对象和常用模块
注：适合萌新学习python并且里面的内容会持续的更新！
说明：并非是最优代码，但程序完全正确！因为此时作者也处在学习阶段！
对象(object)：表示客观世界问题空间中的某个具体事物，又表示软件系统解空间中的基本元素。
面向对象程序设计：是一种程序设计范型，也是一种程序开发的方法。
例题：
编写一个程序，用于判断学生是否已经完成作业，如果完成教师会给予表扬，否则要进行批评 。
class Student:
def __init__(self,name,grade,subject):
self.name=name
self.grade=grade
self.subject=subject
def do_work(self,time):
if self.grade >3 and time>2:
return True
elif self.grade <3 and time>0.5:
return True
else:
return False
class Teacher:
def __init__(self,name,subject):
self.name = name
self.subject=subject
def evaluate(self,result=True):
if result:
return "you are great"
else:
return "you should work hard"
wrr=Student('wrr',4,'math')
tea =Teacher ( '杨老师','math')
tea_said=tea.evaluate(wrr.do_work(7))
print("Teacher:{0}said:{1} ,{2}".format(tea.name,wrr.name,tea_said))
结果是：
Teacher：杨老师said:wrr ,you are great
例题：
创建一个类，用于可以计算任意两个日期之间的天数和周数
import datetime
from dateutil import rrule
class BetDate:
def __init__(self,start_date,stop_date):
self.start=datetime.datetime.strptime(start_date,"%Y,%m,%d")
self.stop=datetime.datetime.strptime(stop_date,"%Y,%m,%d")
def day(self):
d=self.start-self.stop
return d.days if d.days > 0 else False
def weeks(self):
weeks = rrule.rrule(rrule.WEEKLY,dtstar t= self.start,until=self.stop)
return weeks.count()
fir_twe =BetDate("2020,1,1","2020,10,1")
d = fir_twe.day()
w = fir_twe.weeks()
print("Between 2020-1-1,2020-10-1:")
print("Days is:",d)
print("Week is:",w)
例题：
创建类，能够通过“年-月-日”字符串创建实例，并检查年月日是否合法。
class Date(object):
def __init__(self,year,month,day):
self.year = year
self.month = month
self.day = day
@classmethod #创建类方法
def from_string(cls,date_as_string):
year,month,day = map(int,date_as_string.split('-'))
date1 = cls(year,month,day)#通过date_as_string字符串创建实例，这里的cls相当于Date
return date1
@staticmethod #创建静态方法
def is_date_valid(date_as_string):
year,month,day = map(int,date_as_string.split('-'))
return day <= 31 and month <= 12 and year <= 2050 #判断年月日是否合法
d = Date.from_string("2020-10-1")#实例化
is_date = Date.is_date_valid("2020-10-1") #实例化
print(is_date)
继承
单继承：
'''
如果在子类里写了一个与父类同名的方法，
那么子类的这个方法会把父类的这个方法覆盖掉（重写）
'''
class Person:
def __init__(self,name,age):
self.name=name
self.age=age
def get_name(self):
return self.name
def get_age(self):
return self.age
class Student(Person):
#实现父类被覆盖的方法继续在子类中使用
def __init__(self,school,name,age):#增加了父类的name和age
self.school=school
super().__init__(name,age) #括号内是父类参数，注意：不需要加self ，此处与Person.__init__(self,name,age)相同的意思
def grade(self,n):
print("{0} is in {1} class {2}".format(self.name,str(n),self.age))
stu1 = Student('nanshan',"wrr","20")
stu1.grade(15)
print("年龄是：",stu1.get_age())
print("姓名是：",stu1.get_name())
运行的结果：
wrr is in 15 class 20
年龄是： 20
姓名是： wrr
多继承：
class K1:
def foo(self):
print("k1-foo")
class K2:
def foo(self):
print("k2-foo")
def bar(self):
print("k2-bar")
class J1(K1,K2):#多继承
pass #表示除了继承在J1中什么也不做
class J2(K1,K2):#多继承
def bar(self):
print("J2-bar")
class C(J1,J2):#多继承
pass #表示除了继承在J1中什么也不做
print(C.__mro__) #__mro__算法体现的是一个继承的顺序
结果就是表示查找某一个方法或者属性的顺序就是如下：
(<class '__main__.C'>, <class '__main__.J1'>, <class '__main__.J2'>, <class '__main__.K1'>, <class '__main__.K2'>, <class 'object'>)
斐波那契数列
这个数列从第3项开始，每一项都等于前两项之和。
利用迭代器实现：
'''
斐波那契数列利用迭代器实现优化内存
'''
class Fibs:
def __init__(self,max):
self.max = max
self.a = 0 # 斐波那契数列的第一二项值是0和1
self.b = 1
def __iter__(self):#定义的此方法表示当前的类是可迭代的
return self
def __next__(self):
fib = self.a
if fib > self.max:
raise StopIteration
self.a,self.b = self.b,self.b + self.a #实现斐波那契数列。前两项的和是第三项
return fib
fibs = Fibs(1000000) #初始化了一个100万个元素。但是这一百万个元素并没有读入到内存，而是使用多少个读入多少个
lst = [fibs.__next__() for i in range(10)] #使用__next__方法依次获取前十个数
print(lst)
输出的结果：
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
'''
利用生成器写斐波那契数列
引入import itertools 专门用来创建迭代器对象的工具
'''
def fibs():
prev,curr = 0,1
while True:
yield prev
prev,curr = curr,prev + curr#实现斐波那契数列。前两项的和是第三项
import itertools
print(list(itertools.islice(fibs(),10)))#fibs()里面有无限多个对象，用itertools.islice方法取前十个
利用生成器实现：
'''
利用生成器写斐波那契数列
引入import itertools 专门用来创建迭代器对象的工具
'''
def fibs():
prev,curr = 0,1
while True:
yield prev
prev,curr = curr,prev + curr #实现斐波那契数列。前两项的和是第三项
import itertools
print(list(itertools.islice(fibs(),10))) #fibs()里面有无限多个对象，用itertools.islice方法取前十个
异常处理
主要用到try …except…
while True:
try:
a=float(input("please enter first number:"))
b=float(input("please enter second number:"))
r=a/b
print("{0}/{1}={2}".format(a,b,r))
break
except ZeroDivisionError:
print ("Please enter the second number again")
except ValueError:
print ("plase enter the number")
except:
break
#也可以组合异常
# except (ZeroDivisionError,ValueError): #表示遇到这两个异常中的一个就会执行下面的代码
# print ("Please enter the second number again")