python大数据 pycharm中的面向对象-文件读写-异常

一、继承

# 类的定义 
# 旧式类定义 一般在定义单个类时使用
class 类名:
    name = None
    
   	def func(self):
        pass

# 新式类定义   一般在继承时使用
class 类名(指定需要继承的类):
    name = None
    
    def func(self):
        pass

# 新式类定义
class A():
    name = '张三'

    def func(self):
        # pass 不做处理
        pass
# 旧式类
class B:

    age = 20

    def fucn(self):
        pass


print(A.name)
print(B.age)

1-1 单继承

# 单继承  只继承一个类
class Father:

    gender = '男'

    def run(self):
        print('跑步很快')



# 子类继承父类获取父类中属性和方法
class Son(Father):

    # 定义子类的属性和方法
    age = 20

    def play(self):
        print('玩游戏')

        
# 创建子类对象
s = Son()
# 使用子类对象操作父类的属性和方法以及自己的属性和方法
print(s.gender)
print(s.age)

s.run()
s.play()

# 单继承的使用
class Master:
    name = '师父'

    def flapjack(self):
        print('摊鸡蛋煎饼')



class Apprentice(Master):
    # 子类继承后可以不定义属性和方法，直接使用父类的方法
    pass


a = Apprentice()

# 子类使用父类方法
a.flapjack()

1-2 多继承

# 单继承的使用
class Master:
    name = '师父'

    def flapjack(self):
        print('摊鸡蛋煎饼')


class School:

    name = '学校'

    def flapjack(self):
        print('摊肉肠煎饼')


class Apprentice(Master,School):
    # 子类继承后可以不定义属性和方法，直接使用父类的方法

    pass


a = Apprentice()

# 子类使用父类方法
a.flapjack()

# 查看子类的继承父类顺序
print(Apprentice.__mro__)

1-3 方法重写

# 重写父类方法  子类继承父类后定义了一个和父类相同名字的方法

# 单继承的使用
class Master:
    name = '师父'

    def flapjack(self):
        print('摊鸡蛋煎饼')


class Apprentice(Master):

    # 子类中定义了自己方法，和父类方法名一样
    # 子类相当于重写了父类的方法，在执行时按照子类的逻辑执行
    def flapjack(self):
        print('摊手抓饼')


a = Apprentice()
a.flapjack()

1-4 多层继承

# 多层继承
# 重写父类方法  子类继承父类后定义了一个和父类相同名字的方法

# 单继承的使用
class Master:
    name = '师父'
    def flapjack(self):
        print('摊鸡蛋煎饼')


class Apprentice(Master):
    name = '徒弟'
    def flapjack(self):
        print('摊手抓饼')
        super().flapjack()



class LittleApprentice(Apprentice):
    name = '小弟'

    def flapjack(self):
        print('蒸包子')
        super().flapjack()
        

# 创建对象
la = LittleApprentice()
la.flapjack()

print(LittleApprentice.__mro__)

# 多层继承
# 重写父类方法  子类继承父类后定义了一个和父类相同名字的方法

# 单继承的使用
class Master:
    name = '师父'
    def flapjack(self):
        print('摊鸡蛋煎饼')

class School:

    name = '学校'

    def school_flapjack(self):
        print('摊肉肠煎饼')


class Apprentice(Master,School):
    name = '徒弟'
    def flapjack(self):
        print('摊手抓饼')
        super().flapjack()



class LittleApprentice(Apprentice):
    name = '小弟'

    def flapjack(self):
        print('蒸包子')
        super().flapjack()
        

# 创建对象
la = LittleApprentice()
la.flapjack()
la.school_flapjack()
print(LittleApprentice.__mro__)

二，多态

# 多态
class Teacher:

    def __init__(self,name):
        self.name = name

    def run(self):
        print(f'{self.name}老师开车')

    def stop(self):
        print(f'{self.name}老师停车')

class Car:

    def __init__(self,type):
        self.type = type

    def start(self):
        print(f'{self.type}启动')

    def close(self):
        print(f'{self.type}熄火')

t = Teacher('张三')
c = Car('小汽车')

c.start()
t.run()
c.close()
t.stop()

# 多态
class Teacher:

    def __init__(self,name):
        self.name = name

    def run(self):
        print(f'{self.name}老师开车')

    def stop(self):
        print(f'{self.name}老师停车')

class Car(Teacher):

    def __init__(self,type,name):
        super().__init__(name)
        self.type = type

    def start(self):
        print(f'{self.type}启动')
        super().run()
    def close(self):
        print(f'{self.type}熄火')
        super().stop()


c = Car('小汽车','张三')

c.start()
c.close()

# 多态
class Teacher:

    def __init__(self,name):
        self.name = name

    def run(self):
        pass

    def stop(self):
        pass

class Car(Teacher):

    def __init__(self,type,name):
        super().__init__(name)
        self.type = type

    def run(self):
        # 在多态实现时，子类继承父类并对父类方法进行重写
        print(f'{self.type}启动')
        print(f'{self.name}老师开车')
    def stop(self):
        print(f'{self.type}熄火')
        print(f'{self.name}老师停车')

class Metro(Teacher):

    def __init__(self,type,name):
        super().__init__(name)
        self.type = type

    def run(self):
        # 在多态实现时，子类继承父类并对父类方法进行重写
        print(f'{self.type}启动')
        print(f'{self.name}老师乘坐地铁')
        
    def stop(self):
        print(f'{self.type}到站')
        print(f'{self.name}老师下车')


# 单独封装一个行为函数
# 该函数就是对外提供一个函数接口，其他开发人员使用，就调用函数
def action(obj):
    # obj接收一个对象
    obj.run()
    obj.stop()

c = Car('越野车','张三')
action(c)


m = Metro('地铁1号线','李四')
action(m)

三、文件读写

3-1 文件数据读取

# 文件数据读取
# 1-打开文件 创建文件描述符
# open的第一个参数指定读取的文件路径  可以使用绝对路径  也可以使用相对路径  windos的路径需要改斜杠
# 第二参数指定读写方式  r读 w写
# 第三个参数指定文件编码格式，方便读取中文数据  常用的两种utf-8  gbk
f = open('D:/Python大数据就业/4-Python基础/day06-面向对象-文件处理-异常-模块/4-资料/students.txt','r',encoding='utf-8')

# 读取数据文件
# 第一种 读取一行数据
# line_data1 = f.readline()
# print(line_data1)
# line_data2 = f.readline()
# print(line_data2)

# 第二种读取多行数据  将读取的多行数据放入列表中  该方式最常用
lines_data = f.readlines()
print(lines_data)

# 第三种  一次将所有数据读取出来当成一个完整的字符串数据  前面已经读取过数据 read就无法再读到数据 所以在实际开发中三种方式选择一种
# data = f.read()
# print(data)
# print(type(data))


# 数据取完成后可以使用close方法关闭文件
f.close()

3-2 数据写入文件

• 写入方式

四、异常处理

# 索引下标取值错误
data = 'itcast'
data[100]

# 字典取值错误
data = {'name':'张三'}
data['age']

# 类型错误
data = '100'
data2 = 10
data3 = data/data2

# 文件读取错误 路径不存在
with open('aaa.txt','r',encoding='utf-8') as f:
    f.read()

指定异常类型捕获

# 可以捕获所有异常
try:
    data_str = 'itcast'
    # data_str[100]
    f = open('aasd.txt','r',encoding='utf-8')
except:
    # 捕获到异常处理的业务逻辑
    print('异常被捕获')
    # 异常被捕获后，可以正常执行后续的逻辑
print('其他代码逻辑')

# 捕获固定的异常 处理固定错误
try:
    # data = 15/0
    # f = open('aasd.txt', 'r', encoding='utf-8')
    data_str='itcast'
    data_str[100]
# 捕获指定异常
except (FileNotFoundError,ZeroDivisionError,IndexError):
    print('捕获0为除数的异常')
print('其他代码逻辑')

异常的其他处理

try:
    data = 15/0
    # Exception as e 获取异常的错误信息
    # 可以捕获到异常后输出错误信息
except Exception as e:
    print('异常被捕获')
    print(e)
else:
    print('else  没有异常逻辑')
finally:
    print('finally ：无论是否有异常都执行')

函数中的异常处理

def func(a,b):

    data = a + b
    print(data)

try:
    # 调用其他开发人员编写的代码处理错误
    func('10',20)
except Exception as e:
    print(e)