Python 必须掌握的知识

1.列表

​
#列表板块
​
#1.eval(str)方法的用法，是去掉字符串str两边的引号来进行计算
a=eval('3+3+6')
print(a)
​
#2.insert(a,b)方法是在第a个位置插入元素b,注意这里的位置指的是  从0开始到n-1所对应的位置
list1=['1','3','f','4']
list1.insert(1,5)
print(list1)
​
#3.访问列表中的元素
list1=['1','1','3','f','4']
for i in list1:
    print(i,end='\t')
    
#4.remove()方法只需要在函数中指定要删除的元素即可,缺点只能删除第一次出现的这个指定的元素，删除全部需要判断执行
list1=['1','1','3','f','4']
print(list1)
#经过多次的判断，删除这个list1中全部的'1'这个元素
[list1.remove('1') for i in range(list1.count('1'))]
print(list1)
​
​
#5.pop()方法如果括号内为空的时候，默认删除列表中的最后一个元素，pop(a)这里的a为想要删掉的元素的位置索引
list1=['1','1','3','f','4']
print(list1.pop())
print(list1)
list1=['1','1','3','f','4']
print(list1.pop(2))
print(list1)
​
#6.del方法在其后面指定列表则会删除整个列表，同时也可以删除列表上任意位置的元素，前提是要指定列表所在的位置索引
list1=['1','1','3','f','4']
del list1
print(list1)
list1=['1','1','3','f','4']
del list1[2]
print(list1)
​
#总结：remove(),pop(),del三个函数的区别：
    #remove()删除元素不需要指定元素的位置，直接就可以指定要删除的内        容就行，同时删除的元素还可以访问，缺点只能删除第一个出现的元素
    #pop()删除元素默认删除最后一个元素，还可以直接指定元素的位置进行删     除，同时删除的元素还可以继续访问
    #del可以删除整个列表，或者删除指定列表位置上的列表元素，同时删除的      元素不能够继续访问
#7.count()方法返回某个元素在列表中出现的次数
list1=['1','1','3','f','4']
print(list1.count('1'))
​
#8.extend()方法用于在列表末尾追加另一列表中的全部元素，以扩展列表
list1=['1','1','3','f','4']
list2=['你好','hdie']
list1.extend(list2)
print(list1)
​
#9.index()方法返回列表中第一次出现的元素的位置索引
list1=['1','1','3','f','4']
print(list1.index('f'))
​
#10.reverse()方法反转列表元素的排列顺序，此方法不需要输入任何参数
list1=['1','1','3','f','4']
list1.reverse()
print(list1)
​
#11.sort()方法永久性修改列表中元素的排列顺序，默认为升序，可以结合reverse()方法来颠倒顺序,或者直接用内置函数sort[reverse='True']
list1=[2,42,4,5,1,5]
list1.sort()
print(list1)
list1.sort(reverse=True)
print(list1)
#12.sorted()函数对列表元素进行临时排列，并且返回排序后的列表副本，即列表本身内部元素的顺序没有发生变化
list1=[2,42,4,5,1,5]
print(sorted(list1))
#13.clear()方法可以清空列表与del语句的功能类似
list1=[2,42,4,5,1,5]
list1.clear()
print(list1)

2.元组

#1.元组的创建 （当元组内只有元素的时候需要在元素的后面加逗号，否则不会创建元组）
tuple=('你好','world')
print(tuple)
tuple1=('你好',)
print(tuple1)
​
#2.元组的访问和列表的访问一样
tuple=('你好','hello','23783')
print(tuple[2])
print(tuple[:])
print(tuple[1:3])
​
#3.连接、删除元组（元组中的元素是不能够修改的，因此只能够追加元组；同时元组中的元素也是不允许删除的，可以使用del语句删除整个元组）
tuple=('你好','hello','23783')
tuple1=('1','2','3')
print(tuple+tuple1)
del tuple
print(tuple)
​
#3.元组的内置函数 (len(),max(),tuple())
tuple1=('1','2','3')
list1=['1','1','3','f','4']
print(len(tuple1))
print(max(tuple1))
print(tuple(list1))

3.字典

#1.字典的创建和访问(键可以重复，而值不能重复)
dic={'身高':'170cm','体重':'60kg','姓名':'小明'}
print(dic['身高'])
#2.更新字典(如果字典中有对应的键，更新时其对应的值变成变化后的，如果没有对应的键，将会在后面加上一组 键：值)
dic={'身高':'170cm','体重':'60kg','姓名':'小明'}
dic['身高']='150cm'
print(dic)
dic['年龄']='12岁'
print(dic)
​
#3.删除键值对 使用del语句
dic={'身高':'170cm','体重':'60kg','姓名':'小明'}
del dic['身高']
print(dic)
​
#4.遍历字典
dic={'身高':'170cm','体重':'60kg','姓名':'小明'}
for i in dic:
    print(i)#这样可以访问对应的键名
for j,k in dic.items():
    print("key:",j)
    print("value:",k)
    
#5.字典的操作方法（clear()方法，copy()方法，get()方法,items()方法，keys()方法，update()方法，values()方法）
dic={'身高':'170cm','体重':'60kg','姓名':'小明'}
dic.clear()#清空字典
print(dic)
​
dic={'身高':'170cm','体重':'60kg','姓名':'小明'}
new_dic=dic.copy()#返回一个具有键值对相同的新字典，不是原来的那个字典
print(new_dic)
​
dic={'身高':'170cm','体重':'60kg','姓名':'小明'}
print(dic.get("身高"))#返回对应键的值，如果不存在则返回默认值
​
dic={'身高':'170cm','体重':'60kg','姓名':'小明'}
print(dic.items())#返回字典的所有键值对
​
dic={'身高':'170cm','体重':'60kg','姓名':'小明'}
print(dic.keys())#返回字典中的所有键
​
dic={'身高':'170cm','体重':'60kg','姓名':'小明'}
dic1={'年龄':'14岁','出生年月':'2000.09.23'}
dic.update(dic1)
print(dic)#将一个字典中的键值对更新到另一个字典当中
​
dic={'身高':'170cm','体重':'60kg','姓名':'小明'}
print(dic.values())#返回字典中的所有值

4.集合

#集合的特点：创建的元素时无序且不重复的。由于其元素间没有顺序，因此元素不能比较和排序
#1.集合的创建（用{}创建，或者用set()创建,括号里面的时列表）
set1={'爷爷','姥姥','大舅','二舅'}
set2=set(['爷爷','姥姥','大舅','二舅'])
set3={'爷爷','爷爷','姥姥','大舅','二舅'}#创建的时候有重复的，只显示重复中的一个
print(set1)
print(set2)
print(set3)
​
#2.访问集合元素(由于元组没有顺序，故而访问不能用索引)
set1={'爷爷','姥姥','大舅','二舅'}
for i in set1:
    print(i)
​
#3.集合的操作符
set1={'爷爷','姥姥','大舅','二舅'}
set2={'小姑','奶奶','爷爷','姥姥','大舅','二舅'}
print(set2-set1)#返回在只在set2中存在的元素，而不在set1中存在的元素
print(set1&set2)#返回set1和set2的交集
print(set1^set2)#返回set1和set2的非共同元素
print(set1|set2)#返回set1和set2的并集
​
#4.集合使用的方法（s.issubset(t)）
set1={'爷爷','姥姥','大舅','二舅'}
set2={'小姑','奶奶','爷爷','姥姥','大舅','二舅'}
print(set1.issubset(set2))#若set1是set2的子集，则返回True
print(set1.issuperset(set2))#若set1是set2的超集，则返回True
print(set1.union(set2))#返回set1与set2的并集
print(set1.intersection(set2))#返回set1和set2的交集
print(set1.difference(set2))#返回新的集合，元素属于set1,但不属于set2
print(set1.symmetric_difference(set2))#返回新的集合，是set1和set2中不重复元素
print(set1.copy())#返回新的集合是set1的赋值复制

5.Python 程序的控制结构

#1.简单的赋值语句(python定义的对象是有类型的，但是变量没有类型)
name='小明'
age=20
x=y=z=1
#2.序列赋值语句(可以为多个变量分别赋予不同的值)
name,age='小红',18
score1,score2=23,45
score1,score2=score2,score1
print(name,age)
print(score1,score2)
#3.顺序结构(程序按照编写的先后顺序依次执行)
physics=eval(input("请输入对应的物理成绩:"))
biology=eval(input("请输入对应的生物成绩:"))
avg=(physics+biology)/2
print('{:.2f}'.format(avg))
​
#4.分支结构(单分支结构，二分支结构，多分支结构)
#单分支结构(if语句)
score=eval(input("请输入你的成绩:"))
if score>=80:
    print('你的成绩是及格的')
print('你当前的成绩为:',score)
​
#二分支结构(if-else)
score=eval(input("请输入你的成绩:"))
if score>=80:
    print('你的成绩是及格的')
else:
    print('你当前的成绩不及格')
print('你当前的成绩为:',score)
#二分支结构的简洁形式
score=eval(input("请输入你的成绩:"))
token='是' if score>80 else '不是'
print('这个成绩{}及格的'.format(token))
​
#多分支结构(if-elif-else)
age=int(input("请输入您当前的年龄:"))
if age<7:
    print('幼儿')
elif 7<=age<=13:
    print('儿童')
else:
    print('青少年')
​
#5.循环结构(while循环，for循环)
#while循环
n=1
while n<10:
    print(n)
    n+=1
else:
    print('程序执行完成')
#for循环
for i in range(10):
    print(i)
list1=[1,2,3,4,5]
for i in list1:
    print(i)
else:
    print("循环结束")
    
#6.(try-except语句)程序的异常处理(特点:程序能够多次执行)
#try-except
while True:
    try:
        num=eval(input("请输入一个整数"))
        print(4**num)
    except:
        print("程序执行出错，请输入数字类型")
#try-except-except(在定义中间的except时一定要指定异常的类型，用来捕获异常)
while True:
    try:
        strl=['chdishihhs']
        num=eval(input(f"请输入一个0-{len(strl[0])-1}个整数："))
        print(strl[0][num])
    except NameError: #这里的NameError被提示的是用户输入异常
        print("程序出错，请输入数字")
    except:
        print("程序出现其他错误，请在合适的范围内输入数字长度")
#try-except与else和finally放在一起使用(当try的内容正常执行时，else的内容就会执行,finally与其他的正常执行与否无关，他最终都会执行)
while True:
    try:
        num=eval(input("请输入一个数字:"))
        print(num**4)
    except:
        print("程序运行出错，请输入数字类型:")
    else:
        print("程序正常运行")
    finally:
        print("程序运行完毕")
​

6.函数

#1.函数的定义和使用
def add(x,y):
    s=x+y
    return s
print(add(27,23))
#2.函数的返回值(Python使用return语句返回返回值，如果没有设置，默认返回None，当有多个返回值需要返回时，可以使用一个变量(元组数据类型)或多个变量保存结果)
def multiply(x,y):
    a=x*y
    return a
print(multiply(3,5))
​
def complex(x,y):
    return x+y,x*y,x/y
print(complex(10,4))
a,b,c=complex(10,4)
print(a,b,c)
#3.参数的传递方式:(参数有实参(函数调用时输入的真正的参数)和形参(函数定义时输入的参数) )
#4.位置参数(函数执行时，调用函数的参数的位置和数量必须和函数声明时的一样)
#5.默认参数值(在函数定义的时候给形参赋予一个值，当调用函数时没有输入对应的参数时会默认执行这个参数)
def people(name,age=13):
    print(name,age)
people('小明',36)
people('小明')
#当有了默认值的时候，默认值参数在定义时必须放在非默认值参数的后面，否则会报错
#6.关键字参数
def test(a,b,c):
    print(a,b,c)
test(b=12,c=3,a=5)
#7.可变参数(通过在形参的前面加上*，或者**。前者表示可以接收多个位置参数收集的实参组成的元组，后者表示可以接收多个关键字参数收集的实参名和值组成的字典)
def display(*tuplel):
    for i in tuplel:
        print(i)
display('a','s','d','6')
​
def display(**dic1):
    print(dic1.keys(),dic1.values())
dic={'身高':'170cm','体重':'60kg','姓名':'小明'}
display(**dic)
​
def display(**dicl):
    print(dicl)
display(x='你好',y='姓名')
#8.组合参数(将多种参数组合起来使用)
def test(a,b,c=1,*p,**k):
    print(a,b,c)
    for i in p:
        print(i)
    for j,k in k.items():
        print(j,k)
tuplel=('你好','小小','天真')
dic1={'体重':'15kg','性别':'男','年龄':'20岁'}
test(12,3,*tuplel,**dic1)
​

7.变量作用域

#全局变量和局部变量(全局变量是指在函数之外定义的变量，在程序执行全过程有效；局部变量是指在函数内部定义的变量，在函数内部有效)
#在函数外边使用全局变量
def calc():
    b=a+3#b是局部变量
    print(b)
a=1 #a是全局变量
calc()    
#在函数内部使用全局变量(当在函数内部使用全局变量之后，对应的全局变量的值会发生变化)
n=1
def clal(a,b):
    global n
    n=a+b
    return a
s=clal(3,4)
print(n,s)

8.匿名函数

#Python中可以使用关键字lambda创建匿名函数，其主体仅仅是一个表达式而不需要代码块
<函数名>=lambda<形式参数列表>:<表达式>，其优点是使用起来十分方便
fitness=lambda a,b:print(a+b)
fitness(3,4)#调用定义的函数

9.文件和数据维度

#1.文件的类型(文本文件、二进制文件)/
   文本文件在磁盘上是以二进制形式存储的，在读取的时候使用对应的编码标准解码使其变成人们可以理解的字符串信息
    二进制文件包括图形/图像文件、音频文件、视频文件、可执行文件、各种数据库文件、各类Office文件等。
    文本文件和二进制文件的区别:文本文件有统一的字符编码，如UTF-8,二进制文件没有统一的字符编码，其中的信息只能当作字节流，而不能看作字符串。

#2.文件的打开和关闭
<变量名>=open(<文件路径和文件名>,<打开方式>)
r:以只读的方式打开文件。文件必须存在，否则就会出现错误，其也是默认方式
w:以只写的方式打开文件。文件存在则将其覆盖，文件不存在则创建并写入
x:以只写方式创建文件。文件不存在时正常工作
a:打开一个文件，由于追加。如果该文件存在，则在已有的内容上接着写。如果文件不存在，则创建并写入
b:以二进制文件方式打开
t:以文本文件方式打开，默认打开方式
+:与r/w/x/a一同使用，在原有的基础上同时增加读/写功能
<变量名>.close() #关闭文件，系统释放该文件占用的内存资源，方便对文件进行其他操作

#3.文件的读取方法
#read()方法(该方法返回一个字符串。可用参数size表示读取的字符数或字节流，可以省略，若省略则表示读取所有内容并返回)
f=open('./wenzhang.txt','r',encoding='utf-8')
d=f.read(10)
print(d)

#readline()方法(该方法返回一个字符串，内容为文件的一行内容，换行符出现在字符串的末尾，若指针在文件的末尾，则返回一个空字符("");若是空行，则返回\n)
f=open('./wenzhang.txt','r',encoding='utf-8')
d=f.readline()
print(d)

#readlines()方法(该方法读取所有行，返回的是一个以每行为元素的列表。如果指定参数，则表示读完v的行数)
f=open('./wenzhang.txt','r',encoding='utf-8')
d=f.readlines()
print(d)

#seek()方法(该方法用来定位文件的读/写位置)
f.seek(<偏移位置>[,起始位置])#(起始位置0表示从文件的开头开始，1表示从当前的指针位置开始，为2表示从文件的末尾开始)，只有b模式才可以指定非0的偏移值
f.tell()#通过利用tell()函数来告诉你当前文件读写对应的指针位置
f=open('./wenzhang.txt','rb')
print(f.tell())
f.seek(1)
print(f.readlines())
f.seek(4,0)
print(f.tell())
d=f.readlines()
print(d)
f.close()

#4.文件写入方法
#write()方法(该方法用于指定的数据写入，参数必须为字符串或字符节,想要换行就用换行符)
content='今天是一个快\n乐的一天'
f=open('./weng.txt','w')
f.write(content)
f.close()
#writelines()方法(该方法将一个元素为字符串的序列(如列表)真体写入文件,同理想要换行就用换行符)
list1=['今天是\n一个快乐的一天']
f=open('./weng.txt','w')
f.writelines(list1)
f.close()

10.目录

11.Python标准库

#1.python库的导入
#import导入方式(如果导入的库位于代码的开始，则它的作用域属于全局；若是在某一个定义的函数内部，则它的作用域仅仅限于函数内部)同时在使用该库内的函数时需要加上库名，否则运行四会报错；如果库的文件名太长时，可以使用import ... as ... ,方便函数的调用
#from导入方式(把库中指定的函数或者属性导入当前的命名空间)from<库名> import<函数名>，同理当使用from <库名> import *，当使用这种方式的时候，调用函数时就不需要加上库名

#2.turtle库(turtle库是Python重要的标准库之一，它能够进行基本的图形绘制)
#setup(width,height,starx,starty)函数(窗体函数,参数分别代表，宽、高、窗体的水平起始位置、窗体的竖直起始位置)
import turtle 
turtle.setup(200,300,400,200)
#画笔状态函数
penup()  #  没有参数，作用是提起画笔后移动画笔不再绘制图形
pendown()#  没有参数，作用是放下画笔后移动可以绘制图形
pensize(width)#  参数是用来设置画笔的宽度，当无参数时返回当前的画笔宽度
pencolor(color)#  参数用来设置画笔的颜色，无参数时返回画笔当前的颜色
color() #设置画笔和填充颜色
begin_fill() #在填充之前调用
end_fill()   #在填充之后调用，表示填充颜色结束
filling()    #返回填充的状态，True表示已填充，False表示未填充
clear()   #清空当前窗口，但画笔的位置不改变
reset()   #清空当前窗口，并把所有状态重置为默认值
screensize() #设置画布的宽、高、背景颜色
hideturtle() #隐藏画笔的turtle形状
showturtle() #显示画笔的turtle形状
isvisable()  #如果turtle可见，返回True,否则返回false
write()  #输出中文标签，可选择的参数有对齐方式，aligh(left,center,right),font元组型字体设置(字体，字号，字形)
write('你好,欢迎2022年的到来',align='left',font=('black','100','normal'))
#画笔运动函数
forward(distance) #把画笔向当前的方向前进distance的距离
backward(distance)#把画笔向相反的方向前进distance的距离
right(angle)      #向右旋转angle的角度
left(angle)		  #向左旋转angle的角度
goto(x,y)         #把当前的坐标移动到(x,y)处
seth(to_angle)    #设置当前画笔朝向的角度，该角度是绝对方向的角度值
home()            #设置当前画笔位置为原点，向右为正
circle(radius,extent=None)#绘制半径为radius,角度为extent的图形

#3.random库
#random()函数 产生[0.0,1.0)的随机数,该函数没有参数
import random
a=random.random()
print(a)
#seed(a=None)函数 初始化随机数种子，默认为当前的系统时间。只要种子相同，每次生成的随机序列也相同
#randint(a,b)函数 随机生成[a,b]之间的整数
#uniform(a,b)函数 随机生成一个[a,b)之间的小数
#randrange(start,stop[,step])函数 生成一个[start,stop]之间的且以step为步长的随即整数
#getrandbits(k)函数 随机生成位数为k为的二进制数
#choice(seq)函数 从序列类型中随机返回一个元素
choice([1,4,5,5,6])
choice('python')
#shuffle(seq)函数 打乱序列seq的函数
a=[1,2,3,4,5]
shuffle(a)
print(a)
#sample(pop,k)函数 从pop类型中随机选取k个元素，以列表的形式返回
sample('ahuhvghh',5)

#4.time库 time库的功能主要分为三个方面：时间处理、时间格式化、计时
#1)时间处理函数
#time()函数 获取当前时间戳 ？
from time import *
time()
#gmtime(secs)函数 获取当前时间戳对应的struct_time对象
#ctime(secs)函数 获取的时间戳被内部函数调用,localtime()函数获取当地的时间

#2)时间格式化函数 time库使用mktime()、strftime()、strptime()进行时间格式化，strptime()函数与strftime()函数完全相反，用于提取字符串中的时间来生成struct_time对象，可以灵活地作为time库的接入口
from time import *
a=localtime()
b=strftime('%Y-%m-%d %H:%M:%S',a)
print(b)
#3)计时功能。通过time()函数计算两端代码的间隔的时间
import time
time_start=time.time()
a=2
b=6
c=a+b
time_end=time.time()
print(time_end-time_start)
print(a+b)

python中的一些基础知识

各种常见运算符的优先级

运算符	描述
**	指数运算符
+、-	正负号（这是一元运算符，注意与加减号的区别）
*、/、%、//	算术运算符（乘、除、取余、整除）
+、-	算数运算符（加、减）
<、<=、>、>=	比较运算符（小于、小于等于、大于、大于等于）
==、!=	比较运算符（等于、不等于）
=	赋值运算符
is、is not	身份运算符（相同、不同）
in、not in	成员运算符（属于、不属于）
and、or、not	逻辑运算符（且、或、非）

1.格式控制符

#有关python输出的三种格式控制符
a=4
b=5
print(str.format('a的值为{0:.2f},b的值为{1:.2f}',a,b))#这里':'前的0和1，表示后面a和b的位置符
print('a的值{:.2f},b的值为{:.2f}'.format(a,b))
print(f'a的值为{a},b的值为{b}')
print('a的值为%.2f,b的值为%.2f'%(a,b))

2.将列表转换成字符串的方法

#python中list转换成string的方法
num=['ww','ed','12']
num=','.join(num)#这里的','.join()指的是将列表num，并以列表中的','为分割点将这个列表转换成字符串
data=''.join(num)#这里''.join()是指的不用分割直接将列表转换成字符串
print(num)
print(data)
#当列表中的元素存在数字类型时，得将数字类型的元素转换成str类型再转换
data=[2,3,4,5]
num=','.join(map(str,data))#这里的map()函数是指调用str函数将data中的元素由数字型转换成字符串型
print(num)

3.Python 的内置函数(比较常用的函数)

#1.abs(x)函数 #求x的绝对值
#2.all(x)函数 #组合类型的变量中所有的元素为真时，则为真；否则，为假
list1=[1,3,4]
list2=[0,1,3]
print(all(list1))
print(all(list2))
#3.any(x)函数 #组合变量中的元素有一个为真的时候返回真；否则，为假
list1=[1,3,4]
list2=[0,1,3]
print(any(list1))
print(any(list2))
#4.round()函数 #四舍五入的函数
number=round(4.2)
print(number)
#5.max()函数 #返回参数的最大值
list1=[2,34,56,6]
print(max(list1))
#6.min()函数 #返回参数的最小值
list1=[3,45,6,0]
print(min(list1))
#7.sum()函数 #对组合数据类型的各元素求和
list1=[1,2,3,4,4]
print(sum(list1))
#8.type()函数 #返回参数的数据类型
list1=[1,2,3,4]
dic1={'姓名':'小明','身高':'167cm'}
print(type(list1))
print(type(dic1))
#9.exec()函数 #计算字符串s作为Python语句的值
exec('b=2+3*5')
print(b)
#10.set()函数 #将组合类型转换为集合类型(即转换后的集合内部没有相同的元素)
lis=[2,3,4,2,4,5,6,7]
print(set(lis))
#11.dict()函数 #创建字典类型
a=dict(python='一种编程语言')
print(a)
#12.zip()函数 打包为元组的列表，而且元素的个数与最短的列表一致
a=[1,3,4]
b=[3,4,5]
a_bzip=zip(a,b)
print(a_bzip)

4.time库strftime()函数的格式控制符

格式控制符	描述
%a	星期几的缩写名称Mon-Sun
%A	星期几的完整名称Monday-Sunday
%b	月名的缩写Jan-Dec
%B	完整月名January-December
%c	语言环境的适当日期和时间表示
%d	日期01-31
%H	24小时的小时00-23
%I	12小时中的小时01-12
%j	一年中的一天
%m	月份01-12
%M	分钟数00-59
%p	上/下午AM/PM
%S	秒数
%U	一年中的星期(00-53),星期天为星期的开始
%w	星期(0-6),星期天为星期的开始
%W	一年中的星期数(00-53),以星期一为星期的开始
%x	本地相应的日期表示
%X	本地相应的时间表示
%y	两位数的年份01-99
%Y	4位数的年份0001-9999
%Z	当地时区的名称
%%	%本身

##import numpy as np
##
##A=np.array([[1,2,2,2],
##            [2,1,3,4],
##            [2,1,1,1],
##            [4,5,6,7]
##])
##b=np.sum(A[:3,0:3],axis=0)
##print(b)
##print(sum(b))
##
figure(num=None, figsize=None, dpi=None, facecolor=None, edgecolor=None, frameon=True)

num: 图像编号或名称，字符串为名称
figsize: 指定figure的宽和高，单位为英寸；
dpi：参数指定绘图对象的分辨率，默认值为80
facecolor:背景颜色
edgecolor:边框颜色
frameon:是否显示边框

# author:           inspurer(月小水长)
# pc_type           lenovo
# create_date:      2019/1/23
# file_name:        3DTest
# github            https://github.com/inspurer
# qq_mail           2391527690@qq.com

# -*- coding: utf-8 -*-
"""
绘制3d图形
"""

import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D
# 定义figure
fig = plt.figure()
# 创建3d图形的两种方式
# 将figure变为3d
ax = Axes3D(fig)

#ax = fig.add_subplot(111, projection='3d')

# 定义x, y
x = np.arange(-4, 4, 0.25)
y = np.arange(-4, 4, 0.25)

# 生成网格数据
X, Y = np.meshgrid(x, y)

# 计算每个点对的长度
R = np.sqrt(X ** 2 + Y ** 2)
# 计算Z轴的高度
Z = np.sin(R)

# 绘制3D曲面


# rstride:行之间的跨度  cstride:列之间的跨度
# rcount:设置间隔个数，默认50个，ccount:列的间隔个数  不能与上面两个参数同时出现


# cmap是颜色映射表
# from matplotlib import cm
# ax.plot_surface(X, Y, Z, rstride = 1, cstride = 1, cmap = cm.coolwarm)
# cmap = "rainbow" 亦可
# 我的理解的 改变cmap参数可以控制三维曲面的颜色组合, 一般我们见到的三维曲面就是 rainbow 的
# 你也可以修改 rainbow 为 coolwarm, 验证我的结论
ax.plot_surface(X, Y, Z, rstride = 1, cstride = 1, cmap = plt.get_cmap('rainbow'))

# 绘制从3D曲面到底部的投影,zdir 可选 'z'|'x'|'y'| 分别表示投影到z,x,y平面
# zdir = 'z', offset = -2 表示投影到z = -2上
ax.contour(X, Y, Z, zdir = 'z', offset = -2, cmap = plt.get_cmap('rainbow'))

# 设置z轴的维度，x,y类似
ax.set_zlim(-2, 2)

plt.show()
————————————————
版权声明：本文为CSDN博主「月小水长」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/ygdxt/article/details/86618606
    
# 设置随机种子
np.random.seed(325)
 
# 随机生成o数据
o_data_x = np.random.randint(40, 80, 5)
o_data_y = np.random.randint(20, 80, 5)
o_label = np.array([0,0,0,0,0])
 
# 随机生成x数据
x_data_x = np.random.randint(10, 50, 5)
x_data_y = np.random.randint(60, 90, 5)
x_label = np.array([1,1,1,1,1])
 
# 随机生成初始的直线
w1_w2 = np.random.random(2)
t = np.linspace(-100,100, 18)
画图

# 设置画布
plt.figure(figsize=(8, 8))
 
# 作点
plt.scatter(o_data_x, o_data_y, c='b', marker='o', label='0')
plt.scatter(x_data_x, x_data_y, c='r', marker='x', label='1')
plt.legend()
 
# 作初始线
plt.plot(t, -w1_w2[0]/w1_w2[1]*t)
 
# 获取当前的坐标轴, gca = get current axis
ax = plt.gca()
 
# 设置标题，也可用plt.title()设置
ax.set_title('Inital', fontsize=20, loc='left')
 
# 设置右边框和上边框，隐藏
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
 
# 设置x坐标轴为下边框
ax.xaxis.set_ticks_position('bottom')
# 设置y坐标轴为左边框
ax.yaxis.set_ticks_position('left')
 
# 设置x轴, y轴在(0, 0)的位置
ax.spines['bottom'].set_position(('data', 0))
ax.spines['left'].set_position(('data', 0))
 
# ax.set_xticks与plt.xticks功能一样，都是自行定义x坐标轴的刻度；y轴同理。在这里使用避免原点出现两个同样的0
ax.set_xticks([-100, -75, -50, -25, 0, 25, 50, 75, 100])
ax.set_yticks([-100, -75, -50, -25, 25, 50, 75, 100])
plt.savefig('output.jpg')