零基础掌握Python入门到实战(2)

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")