---

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 = 20fun3()
print(age)  # 20

032 递归函数

# 什么是递归函数
# 如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数
# 递归的组成部分
# 递归调用与递归终止条件
# 递归的调用过程
# 每递归调用一次函数，都会在栈内存分配一个栈帧，
# 每执行完一次函数，都会释放相应的空间
# 递归的优缺点
# 缺点：占用内存多，效率低下
# 优点：思路和代码简单# 案例，计算n的阶乘
def fac(n):if n == 1:return nelse:return n * fac(n - 1)n = 4
print(f"计算{n}的阶乘为:", fac(n))  # 计算4的阶乘为: 24

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 <module>a = 10 / 0ZeroDivisionError: division by zero'''

034 class自定义类

'''
类的创建
class 类名:pass'''class StudentEmpty:  # StudentEmpty 为类的名称（类名）由一个或多个单词组成，每个单词的首字母大写，其余小写pass# Python中一切皆对象StudentEmpty是对象吗？内存有开空间吗？
print(id(StudentEmpty))  # 2224771164736
print(type(StudentEmpty))  # <class 'type'>
print(StudentEmpty)  # <class '__main__.Student'>'''
类的组成类属性实例方法静态方法类方法
'''class Student:# 类属性name = "WSKH"age = 18# 初始化方法(构造函数)def __init__(self, name, age):self.name = nameself.age = age# 实例方法def eat(self):print("吃东西")# 类方法@classmethoddef cm(cls):print("我是类方法")# 静态方法@staticmethoddef sm():print("我是静态方法")# 对象的创建
student = Student("WSKH", 18)
print(id(student))  # 1816761272160
print(type(student))  # <class '__main__.Student'>
print(student)  # <__main__.Student object at 0x000001A6FF690760> 内存地址：0x000001A6FF690760# 使用实例方法：eat()方法
student.eat()  # 吃东西
Student.eat(student)  # 吃东西# 使用静态方法
Student.sm()  # 我是静态方法# 使用类方法
Student.cm()  # 我是类方法

class Student:def __init__(self, name, age):self.name = nameself.age = agedef 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'

# 类的封装
class Student:def __init__(self, name, age):self.name = nameself.__age = age# 年龄不希望在类的外部被使用，所以加了两个def show(self):print(self.name, self.__age)  # 张三 20stu = 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

# 类的继承
class Person(object):  # Person继承object类def __init__(self, name, age):self.name = nameself.age = agedef 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_nodef info(self):# 调用父类的info方法super().info() # 张三 20print(f"重写Person父类方法，我是学生{self.name}")class Teacher(Person):def __init__(self, name, age, teachofyear):super().__init__(name, age)self.teachofyear = teachofyearstu = Student('张三', 20, '1001')
teacher = Teacher('李四', 34, 10)
stu.info()  # 重写Person父类方法，我是学生张三
teacher.info()  # 李四 34# 多继承 C 同时继承A和B
class A(object):passclass B(object):passclass C(A, B):pass

035 object内置类

'''
·object类
·object类是所有类的父类，因此所有类都有object类的属性和方法
·内置函数dir0可以查看指定对象所有属性
·Object有一个__str__()方法，用于返回一个对于“对象的描述”，对应于内置函数str0经常用于print(0方法，帮
我们查看对象的信息，所以我们经常会对__str__()进行重写
'''class Person(object):  # Person继承object类def __init__(self, name, age):self.name = nameself.age = agedef __str__(self):return f"我是{self.name},我的年龄是{self.age}"p = Person("WSKH", 18)
print(p)  # 我是WSKH,我的年龄是18  直接输出对象，默认会调用对象的__str__()的方法

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('-------------------')

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:passclass B:passclass C(A, B):def __init__(self, name, age):self.name = nameself.age = age# 创建C类的对象
x = C('Jack', 18)
# __dict__ 查看对象中绑定了哪些属性
print(x.__dict__)  # {'name': 'Jack', 'age': 18}
# __class__ 输出对象所属的类的名称
print(x.__class__)  # <class '__main__.C'>
# __bases__ 输出C类的所有父类名称
print(C.__bases__)  # (<class '__main__.A'>, <class '__main__.B'>)
# __base__ 输出C类的的第一个父类的名称（代码中最上方的父类）
print(C.__base__)  # <class '__main__.A'>
# __mro__ 输出类的层次结构
print(C.__mro__)  # (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
# __subclasses__() 输出A类的子类的列表
print(A.__subclasses__())  # [<class '__main__.C'>]# 特殊方法
a = 20
b = 100
c = a + b
# 两个整数类型的对象的相加操作
d = a.__add__(b)
print(c)  # 120
print(d)  # 120class Student:def __init__(self, name):self.name = namedef __add__(self, other):return self.name + other.namedef __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))  # 2class Person(object):def __new__(cls, *args, **kwargs):print('new_被调用执行了，cls的id值为{0}'.format(id(cls)))  # new_被调用执行了，cls的id值为1911658120032obj = super().__new__(cls)print('创建的对象的id为：{0}'.format(id(obj)))  # 创建的对象的id为：1911677062736return objdef __init__(self, name, age):print('__init__被调用了，self的id值为：{0}'.format(id(self)))  # __init__被调用了，self的id值为：1911677062736self.name = nameself.age = ageprint('--------------------------------------------------')
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

038 类的深拷贝和浅拷贝

'''
类的浅拷贝与深拷贝
·变量的赋值操作
·只是形成两个变量，实际上还是指向同一个对象
·浅拷贝
Python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，
因此，源对象与拷贝对象会引用同一个子对象
·深拷贝
·使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同
'''class CPU:passclass Disk:passclass Computer:def __init__(self, cpu, disk):self.cpu = cpuself.disk = disk# 1.变量的赋值
cpu1 = CPU()
cpu2 = cpu1  # = 浅拷贝
print(id(cpu1))  # 2314243409712
print(id(cpu2))  # 2314243409712# 2.类有浅拷贝
disk = Disk()  # 创建一个硬盘对象
computer = Computer(cpu1, disk)  # 创建一个计算机对象# cpoy 浅拷贝
import copycomputer2 = 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>

039 模块化编程

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

'''
自定义模块
·创建模块
·新建一个.py文件，名称尽量不要与Python自带的标准模块名称相同
·导入模块
import模块名称
[as别名]
from模块名称import函数/变量/类
'''# 导入自定义模块
import Python.Python学习.lib.my_math as my_mathprint(my_math.add(1, 2))  # 3
print(my_math.div(1, 2))  # 0.5

040 以主程序方式运行

'''
·以主程序形式运行
·在每个模块的定义中都包括一个记录模块名称的变量name,；
程序可
以检查该变量，以确定他们在哪个模块中执行。如果一个模块不是被导
入到其它程序中执行，那么它可能在解释器的顶级模块中执行。顶级模
块的name_变量的值为main_
if name=='main':pass
'''if __name__ == '__main__':# 只有当点击运行此代码模块时，才会执行printprint("以主程序的方式运行")

041 python中的包

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

"""
·Python中的包
·包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下
·作用：
·代码规范
·避免模块名称冲突
·包与目录的区别
·包含_init_py文件的目录称为包
·目录里通常不包含_init_py文件
·包的导入
import包名.模块名
"""import my_package.module_A as aprint(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 bprint(b)  # 20

新建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))  # 24print(" time ".center(50, "="))
import timeprint(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 mathprint(f"2的3次方:{math.pow(2, 3)}")  # 2的3次方:8.0
print(f"e的1次方:{math.exp(1)}")  # e的1次方:2.718281828459045

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

'''
第三方模块的安装
pip install 模块名
或者
conda install 模块名第三方模块的卸载
pip uninstall 模块名
或者
conda uninstall 模块名第三方模块的使用
import 模块名
或者
form 模块名 import xxxxx
'''

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', '快来读取我吧！']

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("目录路径")

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.pycode2.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.pymodule_A.pymodule_B.py__init__.py'''else:print(f'该路径下的文件不是目录: {dir}')else:print(f'该目录不存在: {dir}')
except:traceback.print_exc()print("程序发生了意料之外的异常!")

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}

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

1. Python学习笔记--10.Django框架快速入门之后台管理admin（书籍管理系统）

   Python学习笔记--10.Django框架快速入门之后台管理 一.Django框架介绍 二.创建第一个Django项目 三.应用的创建和使用 四.项目的数据库模型 ORM对象关系映射 sqlite ...

2. BP神经网络python代码实现#超详细-小白快速入门

   注释为当前行的注释或者是下一行的注释. import numpy as np#科学计算的基础包# 定义sigmoid函数及其求导,deriv=False时进行前向传播的运算,deriv=True进行反 ...

3. JSF学习笔记超详细，从入门到精通，持续更新中~

   JSF笔记 1.JSF概述 JavaServer Faces (JSF) 是一种用于构建Java Web 应用程序的标准框架(是Java Community Process 规定的JSR-127标准) ...

4. Redis学习笔记①基础篇_Redis快速入门

   若文章内容或图片失效,请留言反馈.部分素材来自网络,若不小心影响到您的利益,请联系博主删除. 资料链接:https://pan.baidu.com/s/1189u6u4icQYHg_9_7ovWmA( ...

5. UE4学习笔记1st：编程快速入门

   UE4学习笔记1st:编程快速入门 今天我开始学习虚幻4游戏引擎,为了此我专门买了新的电脑,我将主要配置写在这里,有想学习的同学可以参考 显卡:丽台K620 CPU:E3-1230-V3 主板:b85 ...

6. Servlet和HTTP请求协议-学习笔记01【Servlet_快速入门-生命周期方法、Servlet_3.0注解配置、IDEA与tomcat相关配置】

   Java后端 学习路线 笔记汇总表[黑马程序员] Servlet和HTTP请求协议-学习笔记01[Servlet_快速入门-生命周期方法.Servlet_3.0注解配置.IDEA与tomcat相关配置 ...

7. JDBC学习笔记01【JDBC快速入门、JDBC各个类详解、JDBC之CRUD练习】

   黑马程序员-JDBC文档(腾讯微云)JDBC笔记.pdf:https://share.weiyun.com/Kxy7LmRm JDBC学习笔记01[JDBC快速入门.JDBC各个类详解.JDBC之CR ...

8. Python学习笔记：使用Python操作数据库

   Python学习笔记:使用Python操作数据库 一.数据库编程接口 为了对数据库进行统一的操作,大多数语言都提供了简单的.标准化的数据库接口(API).在Python Database API 2. ...

9. Python学习笔记：用Python获取数据（本地数据与网络数据）

   Python学习笔记:用Python获取数据(本地数据与网络数据) 一.用Python获取本地数据 读写文件(三种基本模式:r, w, a) 1.写文件 2.读文件

10. python学习笔记26（python中__name__的使用）

    python学习笔记26(python中__name__的使用) 在python中,每个py文件都是一个模块,也都是一个可执行文件,即包含main方法.因此,对每个py文件,可以单独运行,也可以imp ...

最新文章

1. pytorch优化器与学习率设置详解
2. 云计算简史_云计算简史
3. 【Linux】一步一步学Linux——dpkg-statoverride命令(277)
4. selenium自动化测试_Selenium测试可实现有效的测试自动化
5. 【剑指offer】面试题26： 树的子结构(Java)
6. 使用 Packer、Ansible 和 Terraform 构建不可变的基础设施
7. （计算机组成原理题目题型总结）第一章：计算机系统概述
8. python的json.dump参数使用
9. idea 初始界面_IDEA 初始配置教程
10. 使用apktool.jar工具反编译和回编译Android APK 终端命令模式
11. android cocos2dx pdf,(cocos2dx横幅)芒果广告AndroidSDK使用说明.pdf
12. java需要知道哪些英语单词_70个学习JAVA必背的英语单词，了解下
13. 个头小本领大的员工——火车站巡检机器人
14. ESXI7.0下载地址
15. css radial-gradient绘制渐变背景
16. 申请一个微信小程序有哪些需要注意的事项
17. 代驾APP开发多少钱才合适，你真知道吗
18. LaTeX入门学习(2)（安装）
19. 全球 AI 人工智能报告 —— 来自乌镇互联网大会
20. (七)继续对话库检索的闲聊系统

热门文章

1. linux下建立软链接
2. [Android Studio] 手机安装apk报错解决方法
3. mysql练习答案，mysql练习语句
4. 通信原理：信源编码（一）
5. 在线云html排版,云标签,关键字图排版 html5 canvas版
6. js实现玫瑰动画效果
7. 顺序表的基本操作C++
8. Jetbrains教育邮箱操作指南
9. js之延迟执行及循环执行
10. python-LASSO回归模型