python基础2

1.文件操作:

  • 文件的作用:可以永久的保存数据
  • 文件在硬盘中存储的格式是二进制
  • 步骤:
    1. 打开文件
      • open ( file , mode='r' , encoding )
      • file:要操作的文件名称,类型是 str
      • mode:文件打开的方式,r(read)只读打开,w(write)只写打开,a(append)追加打开
      • encoding:文件的编码格式,常见的编码格式有两种,一种是gbk,一种是utf-8
      • 返回值:文件对象
    2. 读写文件
      • 读文件:文件对象.read()
      • 写文件:文件对象.write()
    3. 关闭文件
      • 文件对象.close()

1.读文件-r:

文件对象.read(n):n一次读取多少字节的内容;默认不写,读取全部内容

文件对象.readLine():一次读取一行的内容,返回值是读取到的内容(str)

文件对象.readLines():一次性读取所有行,返回值是列表

f=open('1.txt','r',encoding='utf-8')   # 读取当前目录下的文件
buf=f.read(4)
print(buf)
f.close()

2.写文件-w:

# 文件不存在,会创建文件;文件存在,会覆盖清空原文件
f=open('1.txt','w',encoding='utf-8')
f.write('hello')
f.close()

3.追加文件-a:

# 文件不存在,会创建文件;文件存在,会覆盖清空原文件
f=open('1.txt','a',encoding='utf-8')
f.write('world')
f.newLines
f.close()

2.⽂件和⽂件夹的操作:

  • 文件重命名:os.rename(原文件路径名,新文件路径名)

    os.rename('1.txt','a.txt')   # 当前目录下的文件
    
  • 删除文件:os.remove(文件的路径名)

    os.remove('a.txt')     # 当前目录下的文件
    
  • 清空文件内容:

    open('students.txt', 'w').close()
    
  • 判断文件是否存在:

    os.path.exists('路径')
    
  • 创建目录:os.mkdir(目录路径名)

    os.mkdir('aa')   # 当前目录下的文件
    
  • 删除空目录:os.rmkdir(目录名)

    os.rmdir('aa')   # 当前目录下的文件
    
  • 获取当前所在的目录:os.getcwd()

    buf=os.getcwd()   # 当前目录下的文件
    print(buf)   # 输出:D:\编程文件\python项目\Project1\6文件操作
    
  • 修改当前的目录:os.chdir(目录名)

    os.chdir('test')  # 修改的当前目录的名称
    
  • 获取指定目录中的内容:os.listdir(目录)默认不写参数,是获取当前目录中的内容;返回值是列表

    puf=os.listdir()
    print(puf)   # 输出:['1.读文件.py', '2.写文件.py', '3.追加文件.py', '4.文件和文件夹操作.py']
    

3.面向对象:

1.概念:

  • ⾯向对象和⾯向过程,是两种编程思想

  • ⾯向过程: 注重的过程,实现的细节.亲⼒亲为。例:函数

  • ⾯向对象: 关注的是结果, 偷懒。例:封装, 继承 和多态(三⼤技术)

    image-20220324113151683

2.类和对象:

  • 类:
    • 类是泛指的,指代多个, 是由对的抽象来的
    • 在代码中, 是通过关键字 class 定义的
  • 对象:
    • 对象是特指的,指代⼀个,是具体存在的
    • 在代码中, 对象是由类创建的

3.类的定义:

class Demo:
    name='xiao'
    age=5

    def fun(a,b):
        return a+b	

4.创建对象:

class Demo:
    name='xiao'
    age=5

    def fun(self):
        print('我不懂')

demo=Demo()
demo.fun()

my_list = list() # 创建列表类对象
my_dict = dict() # 创建字典类对象
my_tuple = tuple() # 创建元组类对象

5.类外部添加和获取对象属性

class Dog():
    def play(self):
        print('多女哦奥i额')
dog=Dog()
# 给对象添加属性
dog.name='大黄'
dog.age=2
# 修改属性值(已存在),不存在就是添加
dog.name='小八'

6. 类内部操作属性:

self作为类中的方法的第一个形参,自动调用该方法的自身对象传递给self,所以self代表的是对象

class Dog():
    def play(self):
        print(f'self:{id(self)}')
        print(f'小狗{self.name} 在家拆家')

dog1=Dog()
dog1.name='算法v'
dog1.play()  # 输出:self:1810688283648 小狗算法v 在家拆家

7.魔法方法:

  • 在 python 的类中,有⼀类⽅法,这类⽅法以 两个下划线开头两个下划线结尾, 并且在`满⾜某个特定条件的情况

    下,会⾃动调⽤`. 这类⽅法,称为魔法⽅法

  • init() 【构造方法】

    class Dog():
        def __init__(self):  # self是自身对象
            print('我是__init__,我被调用了')
            self.name='小王'
    
    dog=Dog()
    print(dog.name)  # 输出:小王
    
    class Dog():
        def __init__(self,name):
            print('我是__init__,我被调用了')
            self.name=name
    
    dog=Dog('大患')
    print(dog.name) # 输出:大患
    
  • str()【toString】

    class Dog():
        def __str__(self):
            return '无耐阿斯顿'
    dog=Dog()    
    print(dog) #输出:无耐阿斯顿
    
  • del()

  • dict():可以查看对象具有的属性信息,类型是字典

    print(animal.__dict__)  # 输出:{'_Animal__name': 0}
    

8.案例:

  • 烤地瓜:

  • 搬家具:

4.面向对象2:

1.继承的基本语法:

  • 继承: 描述的类与类之间所属关系.

  • 特点: B类的对象可以使⽤ A类的属性和⽅法

  • 优点: 代码复⽤.重复相同的代码不⽤多次书写.

  • 名词:

    类A: ⽗类------基类;类B: ⼦类------派⽣类

    # 父类
    class Animal(object):
        def play(self):
            print('快乐的玩耍......')
    # 子类
    class Dog(Animal):
        def fun(self):
            print(f'名字是{self.name}')
    dog=Dog()
    dog.play()
    

2.单继承和多层继承:

  • 单继承:一个类只有一个父类
  • 多层继承:C --> B --> A

3.子类重写父类的同名方法:

  • 重写: ⼦类定义和⽗类名字相同的⽅法

  • 为什么重写: ⽗类中的⽅法,不能满⾜⼦类对象的需求,所以要重写

  • 重写之后的特点: ⼦类对象调⽤⼦类⾃⼰的⽅法,不再调⽤的⽅法,⽗类对象调⽤⽗类⾃⼰的⽅法

    # 父类
    class Animal():
        def fun(self):
            print('动物而已')
    # 子类
    class Dog(Animal):
        def fun(self):
            print('狗而已')
    # 创建子类对象
    dog=Dog()
    dog.fun()  # 输出:狗而已
    # 创建父类对象
    animal=Animal()
    animal.fun()  # 输出:动物而已
    

4.子类调用父类的同名方法:

  • 方法一:父类名:方法名(self,其他参数)

    # 父类
    class Animal():
        def bark(self,name):
            print(f'{name}嗷嗷嗷叫。。。。')
    # 子类
    class Dog(Animal):
        def see_host(self,name):
            Animal.bark(self,name)  # 需要手传参数
    # 创建对象
    dog=Dog()
    dog.see_host('阿斯顿')
    
  • 方法二:super(当前类,self).方法名(参数)

    # 父类
    class Animal():
        def bark(self,name):
            print(f'{name}嗷嗷嗷叫。。。。')
    # 子类
    class Dog(Animal):
        def see_host(self,name):
            super(Dog, self).bark(name)  # 需要手传参数
    # 创建对象
    dog=Dog()
    dog.see_host('阿斯顿')
    
    
  • 方法三:是方法二的简写,super().方法名(参数)

    # 父类
    class Animal():
        def bark(self,name):
            print(f'{name}嗷嗷嗷叫。。。。')
    # 子类
    class Dog(Animal):
        def see_host(self,name):
            super().bark(name)  # 需要手传参数
    # 创建对象
    dog=Dog()
    dog.see_host('阿斯顿')
    

5.继承中的init

  • 子类重写父类的init方法,子类需要调用父类的init方法,给对象添加从父类继承的属性

  • 子类的init方法的形参,一般都先写父类的形参,再写自己独有的方法

    # 父类
    class Animal():
        def __init__(self,name):
            self.age=0
            self.name=name
    # 子类
    class Dog(Animal):
        def __init__(self,name,color):  # 构造方法
            super(Dog, self).__init__(name)
            self.color=color
        def __str__(self):   # toString
            return f'名字{self.name},年龄{self.age},颜色{self.color}'
    # 创建对象
    dog=Dog('阿斯顿','红色')
    print(dog)
    

6.多继承:

  • 如果⼀个类有两个及以上的⽗类,就把这种继承关系称为多继承.

7.私有权限:

  • 定义: 在⽅法和属性前加上两个下划线, 就变为私有.

  • 不能在类外部通过对象直接访问和使⽤, 只能在类内部访问和使⽤;

  • 不能被⼦类继承

  • 私有属性:

    class Animal():
        def __init__(self):
            self.__name=0
    
    animal=Animal()
    print('赋值之前',animal.__dict__)  # 输出:赋值之前 {'_Animal__name': 0}
    animal.__name=100 # 此处的__name不是私有属性
    print('赋值之后',animal.__dict__)  # 输出:赋值之后 {'_Animal__name': 0, '__name': 100}
    
  • 私有方法:

    class Dog():
        def born(self):
            print('阿斯顿飞过')
            self.__sleep()
        def __sleep(self):
            print('阿斯顿出生了')
    
    dog=Dog()
    dog.born() # 输出:阿斯顿飞过 阿斯顿出生了
    

8.类属性和类方法:

  • 类属性:

    class Dog():
        class_name='狗Sad'
        age=18
    
    print(Dog.class_name)
    
  • 类方法:使用@classmethod装饰,默认参数cls代表对象自己

    class Dog():
        @classmethod
        def fun(cls):
            print('吾辈之楷模')
    
    Dog.fun()
    

9.静态方法:

  • 使用@staticmethod修饰的方法

  • 静态方法如果有参数,就必须传递实参值

    class Dog():
        @staticmethod
        def show_info(name):
            print(f'名字是{name}')
    
    dog=Dog()
    dog.show_info('阿斯顿')
    

10.多态:

  • 实现步骤:

    1. 子类继承父类

    2. 子类重写父类中同名的方法

      # 父类
      class Animal():
          def __init__(self,name):
              self.name=name
          def fun(self):
              print(f'小狗{self.name}在玩耍')
      # 子类
      class Dog(Animal):
          def fun(self):
              print(f'小猫{self.name}在玩耍')
      
    3. 定义一个共同的方法,参数为父类对象,在方法中调用子类和父类

      # 方法
      def play(obj):
          obj.fun()
          
      # 创建对象
      animal=Animal('阿斯顿')
      play(animal)  # 输出:小狗阿斯顿在玩耍
      dog=Dog('啊v的')
      play(dog)  # 输出:小猫啊v的在玩耍
      

5.模块:

1.模块的制作:

  • 模块就是⼀个 python ⽂件

  • 制作⼀个模块,其实就是定义⼀个 python 代码⽂件

  • 注意点: 模块的名字要遵循标识符的规则(由字⺟,数字和下划线组成,不能以数字开头)

  • 使用:

    num=1
    
    def func():
        print('my_module1 func.......')
    
    class Dog():
        @staticmethod
        def show_info():
            print('这是个Dog类')
    

2.模块的导入:

  • 注意点: 如果导⼊的是⾃⼰书写的模块,使⽤的模块和代码⽂件需要在⼀个⽬录中

  • 使用:

    • 方法一:import 模块名

      使用:模块名.功能名

      import myModule
      
      print(myModule.num)  # 导入模块中的变量
      myModule.func()  # 导入模块中的方法
      dog=myModule.Dog()  # 导入模块中的类
      dog.show_info()
      
    • 方法二:from 模块名 import 功能名1,功能名2.......

      使用:功能名

      注意点:如果存在同名的方法名,则会被覆盖

      from myModule2 import func
      
      func()  # 导入模块中的方法func
      
    • 方法三:from 模块名 import *

      使用:功能名

      from myModule2 import *
      
      print(num)
      func()
      
    • 方法四:as 起别名(可以对模块和功能起别名)

      注意:如果使用as别名,就不能再使用原来的名字

      import myModule2 as mm2
      
      mm2.func()
      
      from myModule2 import func as m2_fun
      
      m2_fun()
      

3.模块中的变量_all_:

  • 可以在每个代码文件中(模块中)定义,类型是元组,列表

  • 作用:影响from 模块名 import * 的导入行为,另外两种导入行为不受影响

    1. 如果没有定义all变量,模块中的所有功能,都可以被导入
    2. 如果定义all变量,只能导入变量中定义的内容
    __all__=['num','func']
    num=100
    
    def func():
        print('my_module2 func.......')
    
    class Animal():
        @staticmethod
        def show_info():
            print('这是个Animal类')
    

4.模块中的变量_name_:

  • 判断主模块(直接运行的代码)

  • 使用:

    def add(a,b):
        print(a+b)
    
    if __name__=='__main__':   # 输出:30s
        add(10,20)
        print(__name__)  
    

5.模块的注意点:

  • 自己定义的模块名字,不要和系统中你要使用的模块名字相同
  • 模块的搜索顺序:当前目录---->系统目录---->程序报错

6.包:

  • 功能相近或者相似的模块放在⼀个⽬录中,并在⽬录中定义⼀个 init.py ⽂件,这个⽬录就是包

    image-20220327130918268

7.异常:

  • 异常:程序代码在运行过程中遇到的错误,程序会报错,会终止程序代码的运行

  • 异常类型: 异常具体的描述信息

  • 异常捕捉:是指在程序代码运行过程中,遇到错误,不让程序代码终止,让其继续运行,同时可以给使用者一个提示信息

  • 格式:

    try:
    	可能发生异常的代码
    except 异常的类型:
        发生异常执行额代码
    

1.捕获单个异常:

2.捕获多个异常:

3.打印异常信息:

全部评论

相关推荐

我是小红是我:学校换成中南
点赞 评论 收藏
分享
尊尼获获:闺蜜在哪?
点赞 评论 收藏
分享
点赞 收藏 评论
分享
牛客网
牛客企业服务