json
json是一种轻量级的数据交互格式，可以按照json指定的格式去组织和封装数据.python语言使用json有很大优势，因为，json无非就是一个单独的字典或者一个内部元素都是字典的列表，所以，json可以直接和Python的字典或者列表进行无缝转换。
json本质上是一个带有特定格式的字符串
主要功能：json就是一种在各个编程语言中流通的数据格式，负责不同编程语言中的数据传递和交互。
例如：各种编程语言存储数据的容器不尽相同，在Python中有字典dict这样的数据类型，而其它语言可能没有对应的字典。为了让不同的语言都能够相互通用、相互传递数据，json就是一种非常优良的中转数据格式
# 导入json模块
import json
# 准备符合json格式要求的python数据
data = [{"name":"小明","age":19},{"name":"小红","age":18}]
# 通过json.dumps(data)方法把python数据转化为json数据
data = json.dumps(data)
# 通过json.loads(data)方法把json数据转化为了python列表或字典
data = json.loads(data)
但如果其中含有中文，则在转换数据时需要加上：ensure_ascii=False 来确保中文正常转换
# 导入json模块
import json
# 准备符合json格式要求的python数据
data = [{"name":"小明","age":19},{"name":"小红","age":18}]
# 通过json.dumps(data)方法把python数据转化为json数据
json_str = json.dumps(data, ensure_ascii=False)
Pyecharts
如果想要做出数据可视化效果图，可以借助pyecharts模块来完成
概况： Echarts是由百度开源的数据可视化，凭借着良好的交互性，精巧的图表设计，得到了众多开发者的认可。
示例：
折线图
# 导包，导入Line功能构建折线图对象
from pyecharts.charts import Line
# 得到折线图对象
line = Line()
# 添加x轴数据
line.add_xaxis(["中国", "美国", "英国"])
# 添加y轴数据
line.add_yaxis("GDP", [300,20,10])
# 生成图表
line.render()
运行之后就会生成一个网页文件，然后点击即可在右上方看到浏览器标识，点击即可打开页面
pyecharts模块中有很多的配置选项，常用的有2个类别： 全局配置选项， 系列配置选项
这里的全局配置选项可以通过set_global_opts方法来进行配置，相应的选项和选项的功能如下：
# 导包，导入Line功能构建折线图对象
from pyecharts.charts import Line
# 设置全局配置项需要先导入 每个要用的都需要提前导入
from pyecharts.options import TitleOpts, LegendOpts, ToolboxOpts, VisualMapOpts
# 得到折线图对象
line = Line()
# 添加x轴数据
line.add_xaxis(["中国", "美国", "英国"])
# 添加y轴数据
line.add_yaxis("GDP", [300,20,10])
# 设置全局配置项set_global_opts来设置
line.set_global_opts(
title_opts=TitleOpts(title="GDP展示",pos_left="center", pos_bottom="1%"), # 设置标题居中，置于底部
legend_opts=LegendOpts(is_show=True), # 展示图例
toolbox_opts=ToolboxOpts(is_show=True), # 展示工具箱
visualmap_opts=VisualMapOpts(is_show=True), # 展示视觉映射
)
# 生成图表
line.render()
基础地图演示
# 演示地图可视化的基本使用
from pyecharts.charts import Map
from pyecharts.options import VisualMapOpts, # 导入视觉映射
# 准备地图对象
map = Map()
# 准备数据
data = [
("北京市",99),
("上海市",199),
("湖南省",230),
("台湾省",400),
("广东省",499)
]
# 添加数据
map.add("测试地图", data, "china")
# 设置全局选项 手动设置视觉显示范围
map.set_global_opts(
visualmap_opts=VisualMapOpts(
is_show=True,
is_piecewise=True, # 是否分段
pieces=[
{"min":1, "max":9, "label": "1-9人", "color": "#CCFFFF"},
{"min":10, "max":99, "label": "10-99人", "color": "#FFFF99"},
{"min":100, "max":499, "label": "99-499人", "color": "#FF9966"}
]
)
)
# 绘图
map.render()
柱状图
通过Bar( )构建一个柱状图对象；
通过add_xaxis( )和add_yaxis( )添加x轴和y轴数据；
通过reversal_axis( )反转x和y轴；
通过label_opts=LabelOpts(position="right")设置数值标签在右侧显示
# 基础柱状图的开发
from pyecharts.charts import Bar
from pyecharts.options import LabelOpts # 导入数值标签功能
# 使用Bar构建基础柱状图
bar = Bar()
# 添加x轴数据
bar.add_xaxis(["中国", "美国", "英国"])
# 添加y轴数据
bar.add_yaxis("GDP", [30, 20, 10],label_opts=LabelOpts(position="right"))
# 反转x和y轴
bar.reversal_axis()
# 绘图
bar.render()
时间线Timeline( )
柱状图描述的是分类数据，同时柱状图很难动态的描述一个趋势性的数据，这里pyecharts提供了一种解决方案-时间线
如果说一个Bar、Line对象是一张图表的话，时间线就是创建一个一维的x轴，轴上每一个点就是一个图表对象
导入时间线：from pyecharts.charts import Timeline
构建对象：timeline = Timeline( )
设置自动播放：
# 设置自动播放
timeline.add_schema(
play_interval=1000, # 自动播放的时间间隔，单位毫秒
is_timeLine_show=True, # 是否在自动播放的时候，显示时间线
is_auto_play=True, # 是否自动播放
is_loop_play=True # 是否循环自动播放
)
时间线主题：
timeline = Timeline({"theme":ThemeType.LIGHT})
# 演示带有时间线的柱状图开发
from pyecharts.charts import Bar, Timeline
from pyecharts.globals import ThemeType
from pyecharts.options import LabelOpts
bar1 = Bar()
bar1.add_xaxis(["中国", "美国", "英国"])
bar1.add_yaxis("GDP", [30, 20, 10], label_opts=LabelOpts(position="right"))
bar1.reversal_axis()
bar2 = Bar()
bar2.add_xaxis(["中国", "美国", "英国"])
bar2.add_yaxis("GDP", [50, 30, 20], label_opts=LabelOpts(position="right"))
bar2.reversal_axis()
bar3 = Bar()
bar3.add_xaxis(["中国", "美国", "英国"])
bar3.add_yaxis("GDP", [70, 60, 60], label_opts=LabelOpts(position="right"))
bar3.reversal_axis()
# 构建时间线对象
timeline = Timeline({"theme": ThemeType.LIGHT})
# 在时间线内添加柱状图对象
timeline.add(bar1, "点1")
timeline.add(bar2, "点2")
timeline.add(bar3, "点3")
# 设置自动播放
timeline.add_schema(
play_interval=1000, # 自动播放的时间间隔，单位毫秒
is_timeline_show=True, # 是否在自动播放的时候，显示时间线
is_auto_play=True, # 是否自动播放
is_loop_play=True # 是否循环自动播放
)
# 通过时间线绘图
timeline.render("基础柱状图-时间线.html")
面向对象
生活中或是程序中，我们都可以使用设计表格、生产表格、填写表格的形式组织数据
设计表格，称之为：设计类（class）
打印表格，称之为：创建对象
填写表格，称之为：对象属性赋值
# 设计一个类（类比生活中：设计一张登记表）
class Student:
name = None # 记录学生姓名
gender = None # 记录学生性别
nationality = None # 记录学生国籍
native_place = None # 记录学生年龄
age = None # 记录学生年龄
# 创建一个对象（类比生活中，打印一张登记表）
stu_1 = Student()
# 对象属性进行赋值（类比生活中：填写表单）
stu_1.name = "小明"
stu_1.gender = "男"
stu_1.nationality = "china"
stu_1.native_place = "山东省"
stu_1.age = 31
# 获取对象中记录的信息
print(stu_1.name,stu_1.gender)
类的定义和使用：
- class是关键字，表示要定义类了
- 类的属性，即定义在类中的变量（成员变量）
- 类的行为，即定义在类中的函数（成员方法）
创建类对象的语法： 对象 = 类名称（ ）
类中不仅可以定义属性用来记录数据，也可以定义函数，用来记录行为
注意：类中定义的属性（变量），我们称之为：成员变量； 类中定义的行为（函数），我们称之为：成员方法
在类中定义成员方法和定义函数基本一致，但仍有细微区别：
def 方法名（self，形参1，......，形参N）：
方法体
注意：在定义的参数列表中有一个self关键字。它用来表示类对象自身的意思；当我们使用类对象调用方法，self会自动被python传入，在方法内部，想要访问类的成员变量，必须使用self
在传入参数时，self是透明的，可以不用理会它
# 定义一个带有成员方法的类
class Student:
name = None # 学生的姓名
def say_hi(self):
print(f"大家好呀，我是{self.name}，欢迎大家多多关照")
def say_hi2(self, msg):
print(f"大家好！我是:{self.name},{msg}")
stu = Student()
stu.name = "小明"
stu.say_hi()
stu2 = Student()
stu2.name = "小红"
stu2.say_hi2("很希望和大家做朋友！！") # 传入参数可以忽略self
现实世界的事物也有属性和行为，类也有属性和行为
# 设计一个闹钟类
class Clock:
id = None
price = None
def ring(self):
import winsound
winsound.Beep(2000,3000)
# 构建闹钟对象并让其工作
clock1 = Clock()
clock1.id = "003202"
clock1.price = 199
print(f"闹钟ID:{clock1.id},价格：{clock1.price}")
clock1.ring()
什么是面向对象编程：面向对象编程就是，使用对象进行编程，即：设计类，基于类创建对象，并使用对象来完成具体的工作
构造方法：
Python类可以使用：__init__( )方法，称之为构造方法（注意：init前后的2个下划线符号，类中的所有方法都要使用self关键字）
可以实现: 在创建类对象（构造类）的时候会自动执行，将传入的参数自动传递给__init__方法使用
在class中的定义可以省略，这样后面的构造方法中即既是定义又是传参；如果不省略，那后面的构造方法只是传参
# 演示构造方法,构造方法的名称:__init__
class Student:
name = None
age = None
tel = None
def __init__(self, name, age, tel):
self.name = name
self.age = age
self.tel = tel
print("Student类创建了一个类对象")
stu = Student("小明", 31, "183400002000")
print(stu.name,stu.age, stu.tel)
魔术方法
上面学习的__init__构造方法，是Python类内置的方法之一。这些内置的方法，各自有各自的特殊的功能，这些内置方法我们称之为：魔术方法
__init__:构造方法 __str__：字符串方法 __lt__：小于、大于符号比较
__le__：小于等于、大于等于符号比较 __eq__:==符号比较
__str__：字符串方法
当类对象需要被转换为字符串之时，会输出一下结果（内存地址）：
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
student = Student("小明", 11)
print(student) # 结果：<__main__.Student object at 0x0000017CB97EE580>
print(str(student)) # 结果：<__main__.Student object at 0x0000017CB97EE580>
我们可以通过__str__方法，控制类转换为字符串的行为
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
# __str__魔术方法：
def __str__(self):
return f"Student类对象，name:{self.name},age:{self.age}"
student = Student("小明", 11)
print(student) # 结果：Student类对象，name:小明,age:11
print(str(student)) # 结果：Student类对象，name:小明,age:11
__lt__：大于、小于符号比较方法
直接对2个对象进行比较是不可以的，但是在类中实现__lt__方法，即可同时完成：小于符号和大于符号2种比较
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
# __lt__魔术方法
def __lt__(self, other):
return self.age < other.age
stu1 = Student("小明", 21)
stu2 = Student("小红", 19)
print(stu1 < stu2) # 结果：False
print(stu1 > stu2) # 结果：True
__le__：小于等于、大于等于比较符号
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
# __le__魔术方法
def __le__(self, other):
return self.age <= other.age
stu1 = Student("小明", 21)
stu2 = Student("小红", 19)
print(stu1 <= stu2) # 结果：False
__eq__：等于比较运算符
不实现__eq__方法，对象之间可以比较，但是是比较的内存地址，结果一定是False。
实现了__eq__方法，就可以按照自己的想法来决定2个对象是否相等了。
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
# __eq__魔术方法
def __eq__(self, other):
return self.age == other.age
stu1 = Student("小明", 21)
stu2 = Student("小红", 19)
print(stu1 == stu2) # 结果：False
面向对象的三大特征：继承、封装、多态
面向对象编程，简单理解就是：基于模板（类）去创建实体（对象），使用对象完成功能开发。
封装
封装表示的是：将现实世界事物的属性、行为，封装到类中（成员变量、成员方法）从而完成程序对现实世界事物的描述
私有成员
现实事物中有不公开的属性和行为，那么作为现实事物在程序中映射的类，也会支持
类中提供了私有成员的形式来支持：私有成员变量、私有成员方法
定义私有成员的方法：
- 私有成员变量：变量名以__开头（2个下划线）
- 私有成员方法：方法名以__开头（2个下划线）
即可完成私有成员的设置
注意：私有方法无法直接被类对象使用；私有变量无法赋值，也无法获取
私有对象的意义：在类中提供仅供内部使用的属性和方法，而不对外开放（类对象无法使用）
# 定义一个类，内含有私有成员变量和私有成员方法
class Phone:
__current_voltage = None
def __keep_single_core(self):
print("让CPU以单核模式运行")
phone = Phone()
# 以下两种都无法实现 私有成员没办法直接访问调用
phong.__keep_single_core()
print(phong.__current_voltage)
使用私有成员：
私有成员无法被类对象使用，但是可以被其他成员使用。（内部可以访问，但是外部不可以访问）
# 定义一个类，内含有私有成员变量和私有成员方法
class Phone:
__current_voltage = int(input("请输入当前运行电压： "))
def __keep_single_core(self):
print("让CPU以单核模式运行")
# 定义一个方法可以调用私有成员
def call_by_5g(self):
if self.__current_voltage >= 1: # 调用私有变量
print("5g通话已开启！")
else:
self.__keep_single_core()
print("电量不足，无法使用5g通话，并已设置为单核运行进行省电！")
phone = Phone()
phone.call_by_5g()
继承
继承分为多继承和单继承，继承表示：将从父类那里继承（复制）来成员变量和成员方法（不含私有）
单继承
语法：
# 演示单继承
class Phone:
IMEI = None
producer = "HM" # 厂商
def call_by_4g(self):
print("4g通话")
# Phone2023 继承 Phone
class Phone2023(Phone):
face_id = "101101" # 面部识别id
# 在新的类中创建新方法
def call_by_5g(self):
print("2023年新功能，5g通话")
phone = Phone2023()
print(phone.producer) # 创建的是Phone2023对象，但是仍然可以使用producer变量
多继承
Python的类之间也支持多继承，即一个类继承多个父类
语法：
注意：多个父类中，如果有同名的成员，那么默认以继承顺序（从左到右）为优先级（先继承的保留，后继承的被覆盖）
class Phone:
IMEI = None
producer = "HM" # 厂商
def call_by_4g(self):
print("4g通话")
class NFCReader:
nfc_type = "第五代"
producer = "HM"
def read_card(self):
print("NFC读卡")
def write_caed(self):
print("NFC写卡")
class RemoteControl:
rc_type = "红外遥控"
# 演示多继承
class MyPhone(Phone, NFCReader, RemoteControl):
pass # 当方法已经足够多，没有想要在添加的方法，为了使得语法完善，可以使用 pass 关键字，是一个占位；表示：无内容，空 的意思
phone = MyPhone()
phone.call_by_4g()
phone.read_card()
phone.write_caed()
复写
子类继承父类的成员属性和成员方法后，如果对其“不满意”，那么可以进行复写！
即：在子类中重新定义同名的属性或方法即可
class Phone:
IMEI = None
producer = "HM" # 厂商
def call_by_5g(self):
print("使用5g网络进行通话")
# 定义子类，复写父类成员：
class MyPhone(Phone):
producer = "DC" # 复写父类的成员属性
def call_by_5g(self):
print("开启CPU单核模式，确保通话的时候省电")
print("使用5g网络进行通话")
print("关闭CPU单核模式，确保性能")
phone = MyPhone()
phone.call_by_5g()
"""
结果是：
开启CPU单核模式，确保通话的时候省电
使用5g网络进行通话
关闭CPU单核模式，确保性能
"""
调用父类同名成员
一旦复写父类成员，那么类对象调用成员的时候，就会调用复写后的新成员，如果需要使用被复写的父类的成员，需要特殊的调用方式：
- 方式1
调用父类成员：
使用成员变量： 父类名.成员变量 使用成员方法： 父类名.成员方法(self)
class Phone:
IMEI = None
producer = "HM" # 厂商
def call_by_5g(self):
print("使用5g网络进行通话")
# 定义子类，复写父类成员：
class MyPhone(Phone):
producer = "DC" # 复写父类的成员属性
def call_by_5g(self):
print("开启CPU单核模式，确保通话的时候省电")
# 调用父类的同名成员 方式一：
print(f"父类的厂商是：{Phone.producer}")
Phone.call_by_5g(self)
phone = MyPhone()
phone.call_by_5g()
"""
结果是：
开启CPU单核模式，确保通话的时候省电
父类的厂商是：HM
使用5g网络进行通话
"""
- 方式二
使用super（）调用父类成员
使用成员变量： super().成员变量 使用成员方法： super().成员方法()
class Phone:
IMEI = None
producer = "HM" # 厂商
def call_by_5g(self):
print("使用5g网络进行通话")
# 定义子类，复写父类成员：
class MyPhone(Phone):
producer = "DC" # 复写父类的成员属性
def call_by_5g(self):
print("开启CPU单核模式，确保通话的时候省电")
# 调用父类的同名成员 方式二：
print(f"父类的厂商是：{super().producer}")
super().call_by_5g()
phone = MyPhone()
phone.call_by_5g()
"""
结果是：
开启CPU单核模式，确保通话的时候省电
父类的厂商是：HM
使用5g网络进行通话
"""
标签：__,name,Python,self,学习,print,age,def From： https://www.cnblogs.com/gjwqz/p/17879259.html