python绘图
基础知识
1 | type(被查看类型的数据) |
字符串定义：
三引号：
2
3
4
5
在三个引号的范围内
全部都是
字符串
"""
字符串拼接：
使用+直接相加，字符串无法和非字符串变量进行拼接，因为类型不一致，无法接上，就像接力赛一样，不是队友，不能接力的哦
字符串格式化：
1 | name = "111" |
1 | #input()语句的功能是，获取键盘输入的数据 |
数据类型转换
1 | int(x) #将x转换为一个整数 |
标识符命名规范
不推荐使用中文、数字不可以开头
运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 | 两个对象相加 a + b 输出结果 30 |
| - | 减 | 得到负数或是一个数减去另一个数 a - b 输出结果 -10 |
| * | 乘 | 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200 |
| / | 除 | b / a 输出结果 2 |
| // | 取整除 | 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0 |
| % | 取余 | 返回除法的余数 b % a 输出结果 0 |
| ** | 指数 | a**b 为10的20次方， 输出结果 100000000000000000000 |
循环语句
1 | while condition: |
函数
函数定义
1 | def 函数名（传入参数）： |
局部/全局变量
1 | ☆ 使用 global关键字 可以在函数内部声明变量为全局变量 |
函数进阶
多个返回值
2
3
4
5
return 1,2
x,y=test()
print(x) # 1
print(y) # 2按照返回值的顺序，写对应顺序的多个变量接收即可
变量之间用逗号隔开
支持不同类型的数据return
传参形式
位置参数
2
3
4
5
6
print(f'您的名字{name},年龄是{age},性别是{gender}')
user('Tom',20,'男')
#传递的参数和定义的参数的顺序及个数必须一致关键字参数
函数调用时通过“键=值”形式传递参数
2
3
4
5
6
7
8
9
10
print(f'您的名字{name},年龄是{age},性别是{gender}')
# 关键字传参
user(name="小明",age="20",gender="男")
# 可以不按照固定顺序
user(age="20",name="小明",gender="男")
# 可以和位置参数混用，位置参数必须在前，且匹配参数顺序
user("小名",age="20",gender="男")缺省参数
缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）
2
3
4
5
6
7
print(f'您的名字{name},年龄是{age},性别是{gender}')
user("Tom",20)
user('rose',18,"女")
# 函数调用时，如果为缺省参数传值则修改默认参数值, 否则使用这个默认值不定长参数
不定长参数也叫可变参数. 用于不确定调用的时候会传递多少个参数(不传参也可以)的场景
不定长参数的类型
①位置传递
2
3
4
5
6
7
print(args)
user("Tom")
user('rose',18)
# 传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是位置传递②关键字传递
2
3
4
5
6
print(kargs)
user(age="20",name="小明",gender="男")
# 参数是“键=值”形式的形式的情况下, 所有的“键=值”都会被kwargs接受, 同时会根据“键=值”组成字典.
匿名函数
函数作为参数传递
2
3
4
5
6
7
8
result = compute(1,2)
print(result)
def compute(x, y):
return x + y
test(compute) # 输出结果为3这是一种计算逻辑的传递，而非数据的传递
lambda匿名函数
数据容器
| 特性 | list | tuple | str | set | dict |
|---|---|---|---|---|---|
| 形式 | list=[, , , ,] | tuple =
(,,,) 变量名=tuple(,,,) 元组只有一个数据时也要添加逗号 |
字符串是字符的容器str=“” | set={,,,} | dic={key:value,key:value} |
| 索引 | 从0开始，list[0] list[-1]、list[-2]反向 嵌套：list[0][0] |
从0开始，list[0] list[-1]、list[-2]反向 嵌套：list[0][0] |
从0开始，list[0] list[-1]、list[-2]反向 嵌套：list[0][0] |
||
| 数据类型 | 任何且可以嵌套 | 任何且可以嵌套 | 只能是字符 | Key和Value可以是任意类型的数据（key不可为字典) | |
| 常见操作 | 方法列表 | index()， 统计某个数据再当前元组出现的次数count() ,len(元组) |
字符串方法列表 | 集合方法列表 | 字典方法列表 |
| 是否允许重复 | 是 | 是 | 是 | 否(因为要去重，所以无法保证顺序) | 否 |
| 可以修改吗c | 是 | 否，但是可以修改元组内的list内容 | 否 | 是 | 是 |
| 是否有序存储(或是否支持while循环) | 是 | 是 | 是 | 否 | 否 |
| 支持for循环 | 是 | 是 | 是 | 是 set1 = {1,2,3} for i in set1: print(i) |
是 |
| 使用场景 | 可修改、可重复的一批数据记录场景 | 不可修改、可重复的一批数据记录场景 | 一串字符的记录场景 | 不可重复的数据记录场景 | 以Key检索Value的数据记录场景 |
序列
内容连续、有序，可使用下标索引的一类数据容器（列表、元组、字符串，均可以可以视为序列）
序列支持切片
切片：从一个序列中，取出一个子序列
语法：序列[起始下标:结束下标:步长]
2
3
4
5
6
7
8
9
10
11
new_list = my_list[1:4]
print(new_list) # 结果：[2, 3, 4]
my_str = "12345"
new_str = my_str[::-1] # 从头（最后）开始，到尾结束，步长-1（倒序）
print(new_str) # 结果："54321"
my_tuple = (1, 2, 3, 4, 5)
new_tuple = my_tuple[:1:-2] # 从头（最后）开始，到下标1(不含)结束，步长-2（倒序）
print(new_tuple) # 结果：(5, 3)步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）
此操作不会影响序列本身，而是会的得到一个新的序列
list的方法
| 编号 | 使用方式 | 作用 |
|---|---|---|
| 1 | 列表.append(元素) | 向列表中追加一个元素 |
| 2 | 列表.extend(容器) | 将数据容器的内容依次取出，追加到列表尾部 |
| 3 | 列表.insert(下标, 元素) | 在指定下标处，插入指定的元素 |
| 4 | del 列表[下标] | 删除列表指定下标元素 |
| 5 | 列表.pop(下标) | 删除列表指定下标元素 |
| 6 | 列表.remove(元素) | 从前向后，删除此元素第一个匹配项 |
| 7 | 列表.clear() | 清空列表 |
| 8 | 列表.count(元素) | 统计此元素在列表中出现的次数 |
| 9 | 列表.index(元素) | 查找指定元素在列表的下标 找不到报错ValueError |
| 10 | len(列表) | 统计容器内有多少元素 |
列表while循环
1 | while index < len(列表) |
字符串的方法
| 编号 | 操作 | 说明 |
|---|---|---|
| 1 | 字符串[下标] | 根据下标索引取出特定位置字符 |
| 2 | 字符串.index(字符串） | 查找给定字符的第一个匹配项的下标 |
| 3 | 字符串.replace(字符串1, 字符串2) | 将字符串内的全部字符串1，替换为字符串2 不会修改原字符串，而是得到一个新的 |
| 4 | 字符串.split(字符串) | 按照给定字符串，对字符串进行分隔 不会修改原字符串，而是得到一个新的列表 |
| 5 | 字符串.strip() 字符串.strip(字符串) | 移除首尾的空格和换行符或指定字符串 |
| 6 | 字符串.count(字符串) | 统计字符串内某字符串的出现次数 |
| 7 | len(字符串) | 统计字符串的字符个数 |
集合的方法
| 编号 | 操作 | 说明 |
|---|---|---|
| 1 | 集合.add(元素) | 集合内添加一个元素 |
| 2 | 集合.remove(元素) | 移除集合内指定的元素 |
| 3 | 集合.pop() | 从集合中随机取出一个元素 |
| 4 | 集合.clear() | 将集合清空 |
| 5 | 集合1.difference(集合2) | 得到一个新集合，内含2个集合的差集 原有的2个集合内容不变 （集合1有而集合2没有的） |
| 6 | 集合1.difference_update(集合2) | 在集合1中，删除集合2中存在的元素 集合1被修改，集合2不变 |
| 7 | 集合1.union(集合2) | 得到1个新集合，内含2个集合的全部元素 原有的2个集合内容不变 |
| 8 | len(集合) | 得到一个整数，记录了集合的元素数量 |
字典的方法
| 编号 | 操作 | 说明 |
|---|---|---|
| 1 | 字典[Key] | 获取指定Key对应的Value值 |
| 2 | 字典[Key] = Value | 添加或更新键值对 |
| 3 | 字典.pop(Key) | 取出Key对应的Value并在字典内删除此Key的键值对 |
| 4 | 字典.clear() | 清空字典 |
| 5 | 字典.keys() | 获取字典的全部Key，可用于for循环遍历字典 |
| 6 | len(字典) | 计算字典内的元素数量 |
容器通用功能
| 功能 | 描述 |
|---|---|
| 通用for循环 | 遍历容器（字典是遍历key） |
| max | 容器内最大元素 |
| min() | 容器内最小元素 |
| len() | 容器元素个数 |
| list() | 转换为列表 |
| tuple() | 转换为元组 |
| str() | 转换为字符串 |
| set() | 转换为集合 |
| sorted(序列, [reverse=True]) | 排序，reverse=True表示降序 得到一个排好序的列表 |
文件操作
打开函数
使用open函数，可以打开一个已经存在的文件，或者创建一个新文件
2
3
4
5
6
7
8
9
10
name：是要打开的目标文件名的字符串(可以包含文件所在的具体路径)。
mode：设置打开文件的模式(访问模式)：只读、写入、追加等。
encoding:编码格式（推荐使用UTF-8
f = open('python.txt', 'r', encoding=”UTF-8)
# encoding的顺序不是第三位，所以不能用位置参数，用关键字参数直接指定
# 此时的`f`是`open`函数的文件对象，对象是Python中一种特殊的数据类型，拥有属性和方法，可以使用对象.属性或对象.方法对其进行访问
模式 描述 r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，原有内容会被删除。 如果该文件不存在，创建新文件。 a 打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有内容之后。 如果该文件不存在，创建新文件进行写入。
读操作
read()方法：
num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据。
readlines()方法：
readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素。
2
3
4
5
6
7
8
9
content = f.readlines()
# ['hello world\n', 'abcdefg\n', 'aaa\n', 'bbb\n', 'ccc']
print(content)
# 关闭文件
f.close()readline()方法：
一次读取一行内容
2
3
4
5
6
7
8
9
10
content = f.readline()
print(f'第一行：{content}')
content = f.readline()
print(f'第二行：{content}')
# 关闭文件
f.close()for循环读取文件行：
2
print(line)# 每一个line临时变量，就记录了文件的一行数据
close()关闭文件对象：
2
3
f.close()最后通过close，关闭文件对象，也就是关闭对文件的占用
如果不调用close,同时程序没有停止运行，那么这个文件将一直被Python程序占用。
with open语法：
2
f.readlines()通过在with open的语句块中对文件进行操作
可以在操作完成后自动关闭close文件，避免遗忘掉close方法
操作 功能 文件对象 = open(file, mode, encoding) 打开文件获得文件对象 文件对象.read(num) 读取指定长度字节 不指定num读取文件全部 文件对象.readline() 读取一行 文件对象.readlines() 读取全部行，得到列表 for line in 文件对象 for循环文件行，一次循环得到一行数据 文件对象.close() 关闭文件对象 with open() as f 通过with open语法打开文件，可以自动关闭
写操作
2
3
4
5
6
7
8
9
10
11
12
13
14
15
f = open('python.txt', 'w')
"""
文件如果不存在，使用”w”模式，会创建新文件
文件如果存在，使用”w”模式，会将原有内容清空
"""
# 2.文件写入
f.write('hello world')
# 3. 内容刷新
f.flush()
# close()方法，带有flush()方法的功能直接调用write，内容并未真正写入文件，而是会积攒在程序的内存中，称之为缓冲区
当调用flush的时候，内容会真正写入文件
这样做是避免频繁的操作硬盘，导致效率下降（攒一堆，一次性写磁盘）
文件追加
2
3
4
5
6
7
8
9
10
11
12
13
f = open('python.txt', 'a')
"""
a模式，文件不存在会创建文件
a模式，文件存在会在最后，追加写入文件
"""
# 2.文件写入
f.write('hello world')
# 可以使用”\n”来写出换行符
# 3. 内容刷新
f.flush()
面向对象
self
定义在类内部的函数称之为方法
可以看到，在方法定义的参数列表中，有一个：self关键字
self关键字是成员方法定义的时候，必须填写的。
它用来表示类对象自身的意思
当我们使用类对象调用方法的是，self会自动被python传入
在方法内部，想要访问类的成员变量，必须使用self
2
3
4
5
6
7
8
9
10
name = None
def say(self):
print("hello")
def say2(self,msg):
print(f"hello , {msg}")
stu1 = student()
stu.say() # 调用的时候无需传参
stu.say("很高兴认识") # 调用的时候需传msg参数可以看到，在传入参数的时候，self是透明的，可以不用理会它。
构造方法
在创建类对象（构造类）的时候，会自动执行。
在创建类对象（构造类）的时候，将传入参数自动传递给__init__方法使用。
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
name = None
age = None
tel = None
def __init__(self, name, age, tell):
self.name = name
self.age = age
self.tel = tel
print("Student类创建了一个对象")
stu = Student("周周",31,"13332282802")
"""
构建类时传入的参数会自动提供给__init__方法
构建类的时候__init__方法会自动执行
"""为了将一个类实例当做函数调用，我们需要在类中实现
__call__()方法
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def __init__(self, a, b, range):
self.a = a
self.b = b
self.range = range
def __call__(self, a, b):
self.a = a
self.b = b
print('__call__ with （{}, {}）'.format(self.a, self.b))
def __del__(self, a, b, range):
del self.a
del self.b
del self.range
xInstance = X(1, 2, 3)
xInstance(1,2)
__call__ with (1, 2)内置方法（魔法方法）
通过__str__方法，控制类转换为字符串的行为
2
3
返回值： 字符串
内容：自行定义
2
3
4
5
6
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return f"Student类对象,name={self.namm}, age={self.age}"通过__lt__小于符号比较方法
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def __init__(self, name, age):
self.name = name
self.age = age
stu1 = Student("周杰伦", 11)
sut2 = Studnet("林俊杰", 13)
print(stu1 < stu2) # 报错
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def __lt__(self, other):
return self.age < other.age
stu1 = Student("周杰伦", 11)
sut2 = Studnet("林俊杰", 13)
print(stu1 < stu2) # true
print(stu1 > stu2) # false通过__le__小于等于符号比较方法
2
3
4
5
6
7
8
9
10
11
def __init__(self, name, age):
self.name = name
self.age = age
def __le__(self, other):
return self.age < other.age
stu1 = Student("周杰伦", 11)
sut2 = Studnet("林俊杰", 13)
print(stu1 < stu2) # true
print(stu1 > stu2) # false通过__eq__比较运算符
2
3
4
5
6
7
8
9
10
def __init__(self, name, age):
self.name = name
self.age = age
def __e1__(self, other):
return self.age == other.age
stu1 = Student("周杰伦", 11)
sut2 = Studnet("林俊杰", 13)
print(stu1 == stu2) # true不实现__eq__方法，对象之间可以比较，但是是比较内存地址，也即是：不同对象==比较一定是False结果。
实现了__eq__方法，就可以按照自己的想法来决定2个对象是否相等了
封装
私有成员
私有成员变量：变量名以__开头（2个下划线）
2
3
4
5
6
7
8
9
10
11
12
13
14
15
IMEI = None # 序列号
producer = None # 厂商
__current_voltage = None # 当前电压
def call_by_5g(se1f):
print("5g通话已开启")
def __keep_single_core(se1f):
print("让CPU以单核模式运行以节省电量")
phone = Phone()
phone._current_voltage = 33 # 私有变量赋值不报错，但无效
print(phone._current_voltage) # 获取私有变量值报错，无法使用私有成员方法：方法名以__开头（2个下划线）
2
3
4
5
6
7
8
9
10
11
12
13
14
IMEI = None # 序列号
producer = None # 厂商
__current_voltage = None # 当前电压
def call_by_5g(se1f):
print("5g通话已开启")
def __keep_single_core(se1f):
print("让CPU以单核模式运行以节省电量")
phone = Phone() # 创建对象
phone.__keep_single_core() # 使用私有方注 会报错私有成员无法被类对象使用，但是可以被其它的成员使用
2
3
4
5
6
7
8
9
10
11
12
13
14
15
IMEI = None # 序列号
producer = None # 厂商
__current_voltage = None # 当前电压
def call_by_5g(se1f):
if self.__current_voltage >= 1:
self.__keep_single.core()
print("5g通话已开启")
else
print("通话失败，电量不足")
def __keep_single_core(se1f):
print("让CPU以单核模式运行以节省电量")继承
单继承
2
3
4
5
6
7
8
9
10
11
12
13
IMEI = None # 序列号
producer = None # 厂商
def call_by_4g(se1f):
print("4g通话已开启")
cIass Phone2022(Phone):
face_id = True # 面部识别
def call_by_5g(se1f):
print("5g通话已开启")将从父类那里继承（复制）来成员变量和成员方法（不含私有）
多继承
一个类，可以继承多个父类
2
3
4
5
face_id = True # 面部识别
def call_by_5g(se1f):
pass多个父类中，如果有同名的成员，那么默认以继承顺序（从左到右）为优先级。先继承的保留，后继承的被覆盖
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
IMEI = None # 序列号
producer = None # 厂商
def call_by_5g(se1f):
print("5g通话已开启")
class NFCReader:
nfc_type ="第五代"
producer ="HM"
def read_card(se1f):
print("读取NFC卡")
def write_card(self):
print("写入NFC卡")
class Remotecontro1:
rc_type = "红外遥控"
def contro1(self):print("红外遥控开启")
class MyPhone(phone，NFCReader， Remotecontro1):
pass
my_phone = MyPhone()
print(My_phone.producer) # 结果为None而非"HM"复写
2
3
4
5
6
7
8
9
10
11
12
IMEI = None # 序列号
producer = None # 厂商
def call_by_5g(se1f):
print("5g通话已开启")
class MyPhone(phone):
producer = "小米" # 复写父类属性
def call_by_5g(se1f):
print("子类5g通话已开启") # 复写父类方法调用父类同名成员
1
使用成员变量：父类名.成员变量
使用成员方法：父类名.成员方法(self)
2
使用成员变量：super().成员变量
使用成员方法：super().成员方法()
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
IMEI = None # 序列号
producer = "xuliehao" # 厂商
def call_by_5g(se1f):
print("5g通话已开启")
class MyPhone(phone):
producer = "小米" # 复写父类属性
def call_by_5g(se1f):
# 方式1调用父类成员
print(f"父类的品牌是: {phone.producer}")
phone.call_by_5g(se1f)
# 方式2调用父类成员
print(f"父类的品牌是:{super().producer}")
super().ca11_by_5g()
print("子类的5g通话”)
画图
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
import matplotlib.pyplot as plt
import numpy as np
# Data for plotting
x1=[1,2,3]
x2=[2,3,4]
x3=[3,4,5]
x4=[4,5,6]
y1=[2,5,7]
y2=[4,5,8]
y3=[5,7,9]
y4=[1,5,0]
plt.plot(x3,y3,linewidth =3.0, label = '第一个线名字',color='#F27970', linestyle='-',marker=",")
#功能依次为线粗、标签(图例)、颜色、线类型、点形状
plt.plot(x2,y2,linewidth =3.0, label = '第二个线名字',color='#00CC96', linestyle='-',marker=",")
plt.plot(x4,y4,linewidth =3.0, label = '第三个线名字,color='#10A5EA', linestyle='-',marker=",")
plt.plot(x1,y1,linewidth =3.0, label = '第四个线名字',color='#8983BF', linestyle='-',marker=",")
plt.xlabel("generation") #X轴信息
plt.ylabel("fitness") #y轴信息
plt.title("Ant") #标题
spines[:].set_visible(False) #不显示边框
plt.legend() #标签显示（一般称为图例）
plt.savefig('myplot.pdf') #保存为pdf格式
plt.show()
All articles in this blog are licensed under CC BY-NC-SA 4.0 unless stating additionally.
wechat
alipay
Related Articles
