python基础2
1.文件操作：
- 文件的作用：可以永久的保存数据
- 文件在硬盘中存储的格式是二进制
- 步骤：
- 打开文件
- open ( file , mode='r' , encoding )
- file：要操作的文件名称，类型是 str
- mode：文件打开的方式，r（read）只读打开，w（write）只写打开，a（append）追加打开
- encoding：文件的编码格式，常见的编码格式有两种，一种是gbk，一种是utf-8
- 返回值：文件对象
- 读写文件
- 读文件：文件对象.read（）
- 写文件：文件对象.write（）
- 关闭文件
- 文件对象.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.概念：
-
⾯向对象和⾯向过程,是两种编程思想
-
⾯向过程: 注重的过程,实现的细节.亲⼒亲为。例：函数
-
⾯向对象: 关注的是结果, 偷懒。例：封装, 继承 和多态(三⼤技术)
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.多态：
-
实现步骤：
-
子类继承父类
-
子类重写父类中同名的方法
# 父类 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}在玩耍') -
定义一个共同的方法，参数为父类对象，在方法中调用子类和父类
# 方法 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 * 的导入行为，另外两种导入行为不受影响
- 如果没有定义all变量，模块中的所有功能，都可以被导入
- 如果定义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 ⽂件,这个⽬录就是包
7.异常：
-
异常：程序代码在运行过程中遇到的错误，程序会报错，会终止程序代码的运行
-
异常类型
:异常具体的描述信息 -
异常捕捉：是指在程序代码运行过程中，遇到错误，不让程序代码终止，让其继续运行，同时可以给使用者一个提示信息
-
格式：
try: 可能发生异常的代码 except 异常的类型: 发生异常执行额代码
美团公司氛围 1837人发布
