【Python学习笔记】超详细Python快速入门教程（下）

---

031 变量的作用域

def fun(a, b):
    c = a + b  # c,就称为局部变量，因为c在是函数体内进行定义的变量，a,b为函数的形参，作用范围也是函数内部，相当于局部变量
    print(c)


# print(c),因为a,c超出了起作用的范围（超出了作用域）
# print(a)

name = '杨老师'
# name的作用范围为函数内部和外部都可以使用-->称为全局变量
print(name)  # 杨老师


def fun2():
    print(name)  # 杨老师


# 调用函数
fun2()


def fun3():
    global age  # 函数内部定义的变量，局部变量，局部变量使用g1oba1声明，这个变量实际上就变成了全局变量
    age = 20


fun3()
print(age)  # 20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

032 递归函数

# 什么是递归函数
# 如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数
# 递归的组成部分
# 递归调用与递归终止条件
# 递归的调用过程
# 每递归调用一次函数，都会在栈内存分配一个栈帧，
# 每执行完一次函数，都会释放相应的空间
# 递归的优缺点
# 缺点：占用内存多，效率低下
# 优点：思路和代码简单

# 案例，计算n的阶乘
def fac(n):
    if n == 1:
        return n
    else:
        return n * fac(n - 1)


n = 4
print(f"计算{n}的阶乘为:", fac(n))  # 计算4的阶乘为: 24
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

033 异常处理机制

'''
Bug的常见类型
1.粗心导致的语法错误 SyntaxError
2.索引越界问题 IndexError
3.除数(或模数)为0错误 ZeroDivisionError
4.映射中没有这个键 KeyError
5.未声明/初始化对象（没有属性） NameError

异常处理语法
1.try except
2.try except else 如果try块中没有拋出异常，则执行else块，如果try中抛出异常，则执行except块
3.try except else finally 其中，finally块中的代码无论是否发生报错，最后都会执行
4.traceback模块 使用traceback模块打印异常信息
'''

# try except
try:
    a = int(input("请输入一个整数："))
except ZeroDivisionError:
    print("除数不能为0")
except ValueError:
    print("只能输入一个整数")

# try except else
try:
    a = int(input("请输入一个整数："))
except ZeroDivisionError:
    print("除数不能为0")
except ValueError:
    print("只能输入一个整数")
else:
    print(f"成功获取整数{a}")  # 成功获取整数2

# try except else finally
try:
    a = int(input("请输入一个整数："))
except ZeroDivisionError:
    print("除数不能为0")
except ValueError:
    print("只能输入一个整数")
else:
    print(f"成功获取整数{a}")  # 成功获取整数2
finally:
    print("程序结束")

# traceback模块
import traceback  # 导入traceback模块

try:
    a = 10 / 0
except:
    traceback.print_exc()
    '''
    Traceback (most recent call last):
    File "E:/Software/JetBrainsIDEA/PythonIDEA/Projects/CXSJS/Python/Python学习/033 异常处理机制/code.py", line 55, in 
        a = 10 / 0
    ZeroDivisionError: division by zero
    '''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

034 class自定义类

'''
类的创建
class 类名:
    pass

'''


class StudentEmpty:  # StudentEmpty 为类的名称（类名）由一个或多个单词组成，每个单词的首字母大写，其余小写
    pass


# Python中一切皆对象StudentEmpty是对象吗？内存有开空间吗？
print(id(StudentEmpty))  # 2224771164736
print(type(StudentEmpty))  # 
print(StudentEmpty)  # 

'''
类的组成
    类属性
    实例方法
    静态方法
    类方法
'''


class Student:
    # 类属性
    name = "WSKH"
    age = 18

    # 初始化方法(构造函数)
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 实例方法
    def eat(self):
        print("吃东西")

    # 类方法
    @classmethod
    def cm(cls):
        print("我是类方法")

    # 静态方法
    @staticmethod
    def sm():
        print("我是静态方法")


# 对象的创建
student = Student("WSKH", 18)
print(id(student))  # 1816761272160
print(type(student))  # 
print(student)  # <__main__.Student object at 0x000001A6FF690760> 内存地址：0x000001A6FF690760

# 使用实例方法：eat()方法
student.eat()  # 吃东西
Student.eat(student)  # 吃东西

# 使用静态方法
Student.sm()  # 我是静态方法

# 使用类方法
Student.cm()  # 我是类方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print(self.name + '在吃饭')


stu1 = Student('张三', 20)
stu2 = Student('李四', 30)

# 动态绑定属性
print("为stu2动态绑定性别属性".center(50, '-'))
stu2.gender = '女'
# print(stu1.name, stu1.age, stu1.gender) # AttributeError: 'Student' object has no attribute 'gender'
print(stu2.name, stu2.age, stu2.gender)


# 动态绑定方法
def show():
    print("show方法执行")


print("为stu2动态绑定show方法".center(50, '-'))
stu2.show = show
stu2.show()  # show方法执行
# stu1.show() # AttributeError: 'Student' object has no attribute 'show'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 类的封装
class Student:
    def __init__(self, name, age):
        self.name = name
        self.__age = age

    # 年龄不希望在类的外部被使用，所以加了两个
    def show(self):
        print(self.name, self.__age)  # 张三 20


stu = Student('张三', 20)
stu.show()
# 在类的外使用使用name与age
print(stu.name)  # 张三
# print(stu.__age) # AttributeError: 'Student' object has no attribute '_Student__age'

# 当然也有方法访问
# 1.先用dir(stu)获取对象的所有属性
print(
    dir(stu))  # ['_Student__age', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'show']
# 2.再用_Student__age对age属性进行访问
print(stu._Student__age)  # 20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 类的继承
class Person(object):  # Person继承object类
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def info(self):
        print(self.name, self.age)


class Student(Person):  # Student继承Person类
    def __init__(self, name, age, stu_no):
        super().__init__(name, age)
        self.stu_no = stu_no
    def info(self):
        # 调用父类的info方法
        super().info() # 张三 20
        print(f"重写Person父类方法，我是学生{self.name}")


class Teacher(Person):
    def __init__(self, name, age, teachofyear):
        super().__init__(name, age)
        self.teachofyear = teachofyear


stu = Student('张三', 20, '1001')
teacher = Teacher('李四', 34, 10)
stu.info()  # 重写Person父类方法，我是学生张三
teacher.info()  # 李四 34


# 多继承 C 同时继承A和B
class A(object):
    pass


class B(object):
    pass


class C(A, B):
    pass
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

035 object内置类

'''
·object类
·object类是所有类的父类，因此所有类都有object类的属性和方法
·内置函数dir0可以查看指定对象所有属性
·Object有一个__str__()方法，用于返回一个对于“对象的描述”，对应于内置函数str0经常用于print(0方法，帮
我们查看对象的信息，所以我们经常会对__str__()进行重写
'''


class Person(object):  # Person继承object类
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"我是{self.name},我的年龄是{self.age}"


p = Person("WSKH", 18)
print(p)  # 我是WSKH,我的年龄是18  直接输出对象，默认会调用对象的__str__()的方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

036 多态

'''
类的多态

动态语言的多态崇尚“鸭子类型”当看到一只鸟走起来像鸭子、游泳起来像鸭子
收起来也像鸭子，那么这只鸟就可以被称为鸭子。在鸭子类型中，不需要关心
对象是什么类型，到底是不是鸭子，只关心对象的行为。
'''

class Animal(object):
    def eat(self):
        print('动物会吃')


class Dog(Animal):
    def eat(self):
        print('狗吃骨头...')


class Cat(Animal):
    def eat(self):
        print('猫吃鱼...')


# 定义一个函数
def fun(obj):
    obj.eat()


# 开始调用函数
fun(Cat())  # 猫吃鱼...
fun(Dog())  # 狗吃骨头..
fun(Animal())  # 动物会吃
print('-------------------')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

037 特殊方法和属性

# 查看object里的特殊属性和方法
print(dir(object))
'''
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
 '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__',
  '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
'''


class A:
    pass


class B:
    pass


class C(A, B):
    def __init__(self, name, age):
        self.name = name
        self.age = age


# 创建C类的对象
x = C('Jack', 18)
# __dict__ 查看对象中绑定了哪些属性
print(x.__dict__)  # {'name': 'Jack', 'age': 18}
# __class__ 输出对象所属的类的名称
print(x.__class__)  # 
# __bases__ 输出C类的所有父类名称
print(C.__bases__)  # (, )
# __base__ 输出C类的的第一个父类的名称（代码中最上方的父类）
print(C.__base__)  # 
# __mro__ 输出类的层次结构
print(C.__mro__)  # (, , , )
# __subclasses__() 输出A类的子类的列表
print(A.__subclasses__())  # []

# 特殊方法
a = 20
b = 100
c = a + b
# 两个整数类型的对象的相加操作
d = a.__add__(b)
print(c)  # 120
print(d)  # 120


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

    def __add__(self, other):
        return self.name + other.name

    def __len__(self):
        return len(self.name)


stu1 = Student('张三')
stu2 = Student('李四')
s = stu1 + stu2
# 实现了两个对象的加法运算（因为在Student类中编写add()特殊的方法
print(s)  # 张三李四
s = stu1.__add__(stu2)
print(s)  # 张三李四

print('--------------------------------------------------')
lst = [11, 22, 33, 44]
print(len(lst))  # 4
# 1en是内容函数1en
print(lst.__len__())  # 4
print(len(stu1))  # 2


class Person(object):
    def __new__(cls, *args, **kwargs):
        print('new_被调用执行了，cls的id值为{0}'.format(id(cls)))  # new_被调用执行了，cls的id值为1911658120032
        obj = super().__new__(cls)
        print('创建的对象的id为：{0}'.format(id(obj)))  # 创建的对象的id为：1911677062736
        return obj

    def __init__(self, name, age):
        print('__init__被调用了，self的id值为：{0}'.format(id(self)))  # __init__被调用了，self的id值为：1911677062736
        self.name = name
        self.age = age


print('--------------------------------------------------')
print('object这个类对象的id为：{0}'.format(id(object)))  # object这个类对象的id为：140725703069648
print('Person1这个类对象的id为：{0}'.format(id(Person)))  # Person1这个类对象的id为：1911658120032

# 创建Person类的实例
p1 = Person("张三", 18)
print(f'p1这个Person类的实例对象的id:{id(p1)}')  # p1这个Person类的实例对象的id:1911677062736
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

038 类的深拷贝和浅拷贝

'''
类的浅拷贝与深拷贝
·变量的赋值操作
·只是形成两个变量，实际上还是指向同一个对象
·浅拷贝
Python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，
因此，源对象与拷贝对象会引用同一个子对象
·深拷贝
·使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同
'''


class CPU:
    pass


class Disk:
    pass


class Computer:
    def __init__(self, cpu, disk):
        self.cpu = cpu
        self.disk = disk


# 1.变量的赋值
cpu1 = CPU()
cpu2 = cpu1  # = 浅拷贝
print(id(cpu1))  # 2314243409712
print(id(cpu2))  # 2314243409712

# 2.类有浅拷贝
disk = Disk()  # 创建一个硬盘对象
computer = Computer(cpu1, disk)  # 创建一个计算机对象

# cpoy 浅拷贝
import copy

computer2 = copy.copy(computer)
print(computer, computer.cpu,
      computer.disk)  # <__main__.Computer object at 0x000001A4F195F760> <__main__.CPU object at 0x000001A4F195F730> <__main__.Disk object at 0x000001A4F195F8B0>
print(computer2, computer2.cpu,
      computer2.disk)  # <__main__.Computer object at 0x000001A4D8D17490> <__main__.CPU object at 0x000001A4F195F730> <__main__.Disk object at 0x000001A4F195F8B0>

# deepcopy 深拷贝
computer3 = copy.deepcopy(computer)
print(computer, computer.cpu,
      computer.disk)  # <__main__.Computer object at 0x000001A4F195F760> <__main__.CPU object at 0x000001A4F195F730> <__main__.Disk object at 0x000001A4F195F8B0>
print(computer3, computer3.cpu,
      computer3.disk)  # <__main__.Computer object at 0x000001A405B07340> <__main__.CPU object at 0x000001A41EF908B0> <__main__.Disk object at 0x000001A41EF90B20>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

039 模块化编程

'''
·模块
模块英文为Modules
函数与模块的关系
·一个模块中可以包含N多个函数
·在Python中一个扩展名为.py的文件就是一个模块
·使用模块的好处
方便其它程序和脚本的导入并使用
避免函数名和变量名冲突
提高代码的可维护性
提高代码的可重用性
'''
1
2
3
4
5
6
7
8
9
10
11
12

'''
自定义模块
·创建模块
·新建一个.py文件，名称尽量不要与Python自带的标准模块名称相同
·导入模块
import模块名称
[as别名]
from模块名称import函数/变量/类
'''

# 导入自定义模块
import Python.Python学习.lib.my_math as my_math

print(my_math.add(1, 2))  # 3
print(my_math.div(1, 2))  # 0.5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

040 以主程序方式运行

'''
·以主程序形式运行
·在每个模块的定义中都包括一个记录模块名称的变量name,；
程序可
以检查该变量，以确定他们在哪个模块中执行。如果一个模块不是被导
入到其它程序中执行，那么它可能在解释器的顶级模块中执行。顶级模
块的name_变量的值为main_
if name=='main':
    pass
'''

if __name__ == '__main__':
    # 只有当点击运行此代码模块时，才会执行print
    print("以主程序的方式运行")
1
2
3
4
5
6
7
8
9
10
11
12
13
14

041 python中的包

module_A和module_B中都只声明了一个变量（如下图所示）

"""
·Python中的包
·包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下
·作用：
·代码规范
·避免模块名称冲突
·包与目录的区别
·包含_init_py文件的目录称为包
·目录里通常不包含_init_py文件
·包的导入
import包名.模块名
"""

import my_package.module_A as a

print(a.a)  # 10

'''
#导入带有包的模块时注意事项
import my_package
import my_math
#使用import方式进行导入时，只能跟包名或模块名
'''

'''
from my_package import module A
from my_package.module A import a
使用from ... import可以导入包，模块，函数，变量
'''

from my_package.module_B import b

print(b)  # 20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

新建python包

042 常用内置模块

"""
sys
与Python解释器及其环境操作相关的标准库
time
提供与时间相关的各种函数的标准库
os
提供了访问操作系统服务功能的标准库
calendar
提供与日期相关的各种函数的标准库
urllib
用于读取来自网上（服务器）的数据标准库
json
用于使用JS0N序列化和反序列化对象
re
用于在字符串中执行正则表达式匹配和替换
math
提供标准算术运算函数的标准库
decimal
用于进行精确控制运算精度、有效数位和四舍五入操作的十进制运算
logging
提供了灵活的记录事件、错误、警告和调试信息等目志信息的功能
"""

print(" sys ".center(50, "="))
import sys

# sys.getsizeof 获取变量占的字节数
print(sys.getsizeof(24))  # 28
print(sys.getsizeof(45))  # 28
print(sys.getsizeof(True))  # 28
print(sys.getsizeof(False))  # 24

print(" time ".center(50, "="))
import time

print(time.time())  # 1655214283.7884552
print(time.localtime(
    time.time()))  # time.struct_time(tm_year=2022, tm_mon=6, tm_mday=14, tm_hour=21, tm_min=44, tm_sec=43, tm_wday=1, tm_yday=165, tm_isdst=0)

print(" urllib ".center(50, "="))
import urllib.request

# 访问指定的url，由于输出太长，下面进行了注释
# print(urllib.request.urlopen('http://www.baidu.com').read())

print(" math ".center(50, "="))
import math

print(f"2的3次方:{math.pow(2, 3)}")  # 2的3次方:8.0
print(f"e的1次方:{math.exp(1)}")  # e的1次方:2.718281828459045
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

043 第三方模块的安装与卸载

'''
第三方模块的安装
pip install 模块名
或者
conda install 模块名

第三方模块的卸载
pip uninstall 模块名
或者
conda uninstall 模块名

第三方模块的使用
import 模块名
或者
form 模块名 import xxxxx
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

044 文件操作

先看看项目结构

'''
·常见的字符编码格式
·Python的解释器使用的是Unicode（内存),py文件在磁盘上使用UTF-8存储（外存）
'''

'''
文件的读写俗称“IO操作”
    文件读写操作流程
        1.Python操作文件
        2.打开或新建文件
        3.读、写文件
        4.关闭资源
'''

# 初试 open(...) 方法
file = open('data/r_text.txt', 'r', encoding='utf-8')  # 获取文件流 r:指的是读取文件
print(file.readlines())  # 读取文件信息 ['我是数据\n', '快来读取我吧！']  返回值是一个列表
file.close()  # 关闭文件

'''
·文件的类型
·按文件中数据的组织形式，文件分为以下两大类
·文本文件：存储的是普通“字符"文本，默认为unicode:字符集，
可以使用记本事程
序打开
二进制文件：把数据内容用“字节”进行存储，无法用记事本打开，必须使用专用的软
件打开，举例：mp3音频文件，jpg图片.doc文档等

r
以只读模式打开文件，文件的指针将会放在文件的开头
w
以只写模式打开文件，如果文件不存在则创建，如果文件存在，则覆盖原有内容，文件指针在文件的开头
a
以追加模式打开文件，如果文件不存在则创建，文件指针在文件开头，如果文件存在，则在文件末尾追加内容，文件指针在原文件末尾
b
以二进制方式打开文件，不能单独使用，需要与共它模式一起使用，rb,或者wb
+
以读写方式打开文件，不能单独使用，需要与其它模式一起使用，a+
'''

# w 只写模式 写入文件
file = open('data/w_text.txt', 'w', encoding='utf-8')
file.write('我是被W模式写入的数据')
file.close()

# a 追加写入模式 写入文件
file = open('data/a_text.txt', 'a', encoding='utf-8')
for _ in range(10):
    file.write('我是被A模式写入的数据\n')
file.close()

# rb 和 wb 模式实现图片的复制
# 1.读取原图片
old = open('img/old.jpg', 'rb')
# 2.创建新图片
new = open('img/new.jpg', 'wb')
# 3.开始复制
new.write(old.read())
# 4.关闭新旧文件流对象
old.close()
new.close()

'''
read([size])
从文件中读取size个字节或字符的内容返回。若省略[size],则读取到文件末尾，即一次读取文件所有内容

readline()
从文本文件中读取一行内容

readlines()
把文本文件中每一行都作为独立的字符串对象，并将这些对象放入列表返回

write(str)
将字符串str内容写入文件

writelines(s_list)
将字符串列表s_1ist写入文本文件，不添加换行符

seek(offset[,whence])
把文件指针移动到新的位置，offset表示相对于whence的位置：
offset:为正往结束方向移动，为负往开始方向移动
whence不同的值代表不同含义：
0:从文件头开始计算（默认值）
1:从当前位置开始计算
2:从文件尾开始计算

tell()
返回文件指针的当前位置

flush()
把缓冲区的内容写入文件，但不关闭文件

close()
把缓冲区的内容写入文件，同时关闭文件，释放文件对象相关资源
'''

'''
With语句（上下文管理器）

with语句可以自动管理上下文资源，不论什么原因跳出with块,
都能确保文件正确的关闭，以此来达到释放资源的目的
'''

with open('data/r_text.txt', 'r', encoding='utf-8') as file:
    print(file.readlines())  # ['我是数据\n', '快来读取我吧！']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

045 目录操作

'''
·os模块是Python内置的与操作系统功能和文件系统相关的模块
该模块中的语句的执行结果通常与操作系统有关，在不同的操作系统上运行，得到的结果可能不一样。
·os模块与os.path模块用于对目录或文件进行操作
'''

import os

# 打开系统自带的计算器程序
# os.system('calc.exe')

# 直接调用可执行文件(打开QQ)
# os.startfile(r'E:\Software\QQ\install\Bin\QQScLauncher.exe')

# 获取当前.py文件所在目录的绝对路径
print(os.getcwd())  # E:\Software\JetBrainsIDEA\PythonIDEA\Projects\CXSJS\Python\Python学习\045 目录操作

# 获取指定目录下的所有文件和目录（不会递归获取）
print(os.listdir('../044 文件操作'))  # ['code.py', 'data', 'img']

# 创建目录
# os.mkdir("要创建的路径")

# 创建多级目录
# os.makedirs("A/B/C/D")

# 删除目录
# os.rmdir("要删除的目录路径")

# 删除多级目录
# os.removedirs("A/B/C/D")

# 将path设置为当前工作目录
# os.chdir("目录路径")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

046 路径操作

import os.path

# 获取绝对路径
print(
    os.path.abspath('code.py'))  # E:\Software\JetBrainsIDEA\PythonIDEA\Projects\CXSJS\Python\Python学习\046 路径操作\code.py

# 判断路径是否存在
print(os.path.exists('code.py'), os.path.exists('code2.py'))  # True False

# 路径拼接
print(os.path.join(r'E:\Software\JetBrainsIDEA\PythonIDEA', 'code.py'))  # E:\Software\JetBrainsIDEA\PythonIDEA\code.py

# 路径分割
print(os.path.split(
    'E:\Software\JetBrainsIDEA\PythonIDEA\code.py'))  # ('E:\\Software\\JetBrainsIDEA\\PythonIDEA', 'code.py')

# 文件后缀分割
print(os.path.splitext('code.py'))  # ('code', '.py')
print(os.path.splitext(
    r'E:\Software\JetBrainsIDEA\PythonIDEA\code.py'))  # ('E:\\Software\\JetBrainsIDEA\\PythonIDEA\\code', '.py')

# 获取文件名（含后缀）
print(os.path.basename(r'E:\Software\JetBrainsIDEA\PythonIDEA\code.py'))  # code.py

# 获取文件所在目录的绝对路径
print(os.path.dirname(r'E:\Software\JetBrainsIDEA\PythonIDEA\code.py'))  # E:\Software\JetBrainsIDEA\PythonIDEA

# 判断该文件是否为目录
print(os.path.isdir(r'E:\Software\JetBrainsIDEA\PythonIDEA\code.py'))  # False

# 小案例1：获取指定目录下的所有指定后缀的文件名（不会递归获取）
# 指定目录
dir = r'E:\Software\JetBrainsIDEA\PythonIDEA\Projects\CXSJS\Python\Python学习\039 模块化编程'
# 指定后缀
suffix = '.py'
import traceback

# 开始读取
try:
    if os.path.exists(dir):
        if os.path.isdir(dir):
            for file_name in os.listdir(dir):
                if file_name.endswith(suffix):
                    print(file_name)
                    '''
                    code.py
                    code2.py
                    '''
        else:
            print(f'该路径下的文件不是目录: {dir}')
    else:
        print(f'该目录不存在: {dir}')
except:
    traceback.print_exc()
    print("程序发生了意料之外的异常!")

# 小案例2：获取指定目录下的所有指定后缀的文件名（会递归获取）
# 指定目录
dir = r'E:\Software\JetBrainsIDEA\PythonIDEA\Projects\CXSJS\Python\Python学习\041 Python中的包'
# 指定后缀
suffix = '.py'

# 开始读取
try:
    if os.path.exists(dir):
        if os.path.isdir(dir):
            for dir_path, dir_names, file_names in os.walk(dir):
                for file_name in file_names:
                    if file_name.endswith(suffix):
                        print(file_name)
                        '''
                        code.py
                        module_A.py
                        module_B.py
                        __init__.py
                        '''
        else:
            print(f'该路径下的文件不是目录: {dir}')
    else:
        print(f'该目录不存在: {dir}')
except:
    traceback.print_exc()
    print("程序发生了意料之外的异常!")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

047 序列化和反序列化

'''
我们把变量从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。
序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。
反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。
Python提供了pickle模块来实现序列化。
'''

import pickle

# 将字典对象序列化到文件中
d = dict(name='Bob', age=20, score=88)
print(f"序列化前：{d}")  # 序列化前：{'name': 'Bob', 'age': 20, 'score': 88}
with open(r'dump.txt', 'wb') as file:
    pickle.dump(d, file)
print(f"序列化后：{d}")  # 序列化后：{'name': 'Bob', 'age': 20, 'score': 88}

# 反序列化（读取文件以获取对象）
with open(r'dump.txt', 'rb') as file:
    d2 = pickle.load(file)
print(f"反序列化后：{d2}")  # 反序列化后：{'name': 'Bob', 'age': 20, 'score': 88}

'''
JSON
如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，
比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，
可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。
JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。
'''
import json

# 将字典对象转化为json格式
d = dict(name='Bob', age=20, score=88)
print(f"JSON化前：{d}")  # JSON化前：{'name': 'Bob', 'age': 20, 'score': 88}
with open(r'dump.json', 'w') as file:
    json.dump(d, file)
print(f"JSON化后：{d}")  # JSON化后：{'name': 'Bob', 'age': 20, 'score': 88}

# 读取json文件，以获取字典对象
with open(r'dump.json', 'rb') as file:
    d2 = json.load(file)
print(f"读取JSON文件：{d2}")  # 读取JSON文件：{'name': 'Bob', 'age': 20, 'score': 88}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41