python库

最新推荐文章于 2023-05-02 11:18:22 发布
最新推荐文章于 2023-05-02 11:18:22 发布
阅读量125 收藏
点赞数
分类专栏： Python数据分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43579079/article/details/100162700
版权

1.内容

python的基本使用

2.代码

关于numpy、scipy、matplotlib
1.intro.py

#!/usr/bin/python
# -*- coding:utf-8 -*-

# 导入NumPy函数库，一般都是用这样的形式(包括别名np，几乎是约定俗成的)
import numpy as np  #重命名为np
import matplotlib
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm #做colormap使用
import time #使用时间
from scipy.optimize import leastsq
import scipy.optimize as opt
import scipy
import matplotlib.pyplot as plt
from scipy.stats import norm, poisson
from scipy.interpolate import BarycentricInterpolator
from scipy.interpolate import CubicSpline
import math


def residual(t, x, y):
    return y - (t[0] * x ** 2 + t[1] * x + t[2])


def residual2(t, x, y):
    print t[0], t[1]
    return y - t[0]*np.sin(t[1]*x)


# x ** x        x > 0
# (-x) ** (-x)  x < 0
def f(x):
    y = np.ones_like(x)
    i = x > 0
    y[i] = np.power(x[i], x[i])
    i = x < 0
    y[i] = np.power(-x[i], -x[i])
    return y


if __name__ == "__main__":
    # # 开场白：
    # numpy是非常好用的数据包，如：可以这样得到这个二维数组
    # [[ 0  1  2  3  4  5]
    #  [10 11 12 13 14 15]
    #  [20 21 22 23 24 25]
    #  [30 31 32 33 34 35]
    #  [40 41 42 43 44 45]
    #  [50 51 52 53 54 55]]
    a = np.arange(0, 60, 10).reshape((-1, 1)) + np.arange(6)
    print a

    # 正式开始  -:)
    # 标准Python的列表(list)中，元素本质是对象。
    # 如：L = [1, 2, 3]，需要3个指针和三个整数对象，对于数值运算比较浪费内存和CPU。
    # 因此，Numpy提供了ndarray(N-dimensional array object)对象：存储单一数据类型的多维数组。保证效率。

    # # 1.使用array创建
    # 通过array函数传递list对象
    L = [1, 2, 3, 4, 5, 6]  #是py里面的列表类型
    print "L = ", L
    a = np.array(L) # 转换为np里面的ndarray类型
    print "a = ", a
    print type(a)
    # # # 若传递的是多层嵌套的list，将创建多维数组
    b = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]) #传递多个
    print b
    # # #
    # # # # 数组大小（形状）可以通过其shape属性获得
    print a.shape # 就是一个向量  （6L，）
    print b.shape #3行4列，是一个矩阵   （3L,4L）
    # # #
    # # # 也可以强制修改shape，不是转置，而是改变位置
    b.shape = 4, 3
    print b   
    # # # # 注：从(3,4)改为(4,3)并不是对数组进行转置，而只是改变每个轴的大小，数组元素在内存中的位置并没有改变
    # # #
    # # # 当某个轴为-1时，将根据数组元素的个数自动计算此轴的长度
    b.shape = 2, -1 #第二个维度自动算
    print b
    print b.shape # （2L,6L）
    # # #
    b.shape = 3, 4
    # # # 使用reshape方法，可以创建改变了尺寸的新数组，原数组的shape保持不变
    c = b.reshape((4, -1)) 
    print "b = \n", b #不变
    print 'c = \n', c #第二列自动算
    # #
    # # # 数组b和c共享内存，修改任意一个将影响另外一个
    b[0][1] = 20
    print "b = \n", b
    print "c = \n", c
    # # #
    # # # 数组的元素类型可以通过dtype属性获得
    print a.dtype # int32
    print b.dtype
    # # #
    # # # # 可以通过dtype参数在创建时指定元素类型
    d = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], dtype=np.float)
    f = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], dtype=np.complex)
    print d
    print f
    # # #
    # # # 如果更改元素类型，可以使用astype安全的转换
    f = d.astype(np.int)
    print f
    # #
    # # # 但不要强制仅修改元素类型，如下面这句，将会以int来解释单精度float类型
    d.dtype = np.int
    print d
    #
    # 2.使用函数创建
    # 如果生成一定规则的数据，可以使用NumPy提供的专门函数
    # arange函数类似于python的range函数：指定起始值、终止值和步长来创建数组
    # 和Python的range类似，arange同样不包括终值；但arange可以生成浮点类型，而range只能是整数类型
    a = np.arange(1, 10, 0.5)  #左闭右开，最后一个为步长
    print a
    # # #
    # # # linspace函数通过指定起始值、终止值和元素个数来创建数组，缺省包括终止值
    b = np.linspace(1, 10, 10)  #左闭右闭，最后一个为个数
    print 'b = ', b
    # # #
    # # 可以通过endpoint关键字指定是否包括终值
    c = np.linspace(1, 10, 10, endpoint=False)
    print 'c = ', c
    # # #
    # # 和linspace类似，logspace可以创建等比数列
    # # 下面函数创建起始值为10^1，终止值为10^2，有20个数的等比数列
    d = np.logspace(1, 2, 10, endpoint=True)
    print d
    # # #
    # # # 下面创建起始值为2^0，终止值为2^10(包括)，有10个数的等比数列
    f = np.logspace(0, 10, 11, endpoint=True, base=2)
    print f
    # # #
    # # # 使用 frombuffer, fromstring, fromfile等函数可以从字节序列创建数组
    s = 'abcd'
    g = np.fromstring(s, dtype=np.int8)
    print g
    # #
    # 3.存取
    # 3.1常规办法：数组元素的存取方法和Python的标准方法相同
    a = np.arange(10)
    print a
    # # # 获取某个元素，从第0号开始数
    print a[3]
    # # # # 切片[3,6)，左闭右开
    print a[3:6]
    # # # # 省略开始下标，表示从0开始
    print a[:5]
    # # # # 下标为负表示从后向前数
    print a[3:]
    # # # # 步长为2，打印1,3,5,7,
    print a[1:9:2]
    # # # # 步长为-1，即翻转，从后向前
    print a[::-1]
    # # # # 切片数据是原数组的一个视图，与原数组共享内容空间，可以直接修改元素值
    a[1:4] = 10, 20, 30
    print a
    # # # # 因此，在实践中，切实注意原始数据是否被破坏，如：
    b = a[2:5]
    b[0] = 200
    print a
    #
    # # 3.2 整数/布尔数组存取
    # # 3.2.1
    # 根据整数数组存取：当使用整数序列对数组元素进行存取时，
    # 将使用整数序列中的每个元素作为下标，整数序列可以是列表(list)或者数组(ndarray)。
    # 使用整数序列作为下标获得的数组不和原始数组共享数据空间。
    a = np.logspace(0, 9, 10, base=2)
    print a
    i = np.arange(0, 10, 2) #0,2,4,6,8
    print i
    # # # # 利用i取a中的元素，这里是生成新的对象
    b = a[i]
    print b
    # # # b的元素更改，a中元素不受影响
    b[2] = 1.6
    print b
    print a

    # # 3.2.2
    # 使用布尔bool数组i作为下标存取数组a中的元素：返回数组a中所有在数组b中对应下标为True的元素
    # # 生成10个满足[0,1)中均匀分布的随机数
    a = np.random.rand(10) #[0,1)中随机取数
    print a
    # # # 大于0.5的元素索引
    print a > 0.5 #打印bool数组，True和False构成
    # # # # 大于0.5的元素
    b = a[a > 0.5] # 提取出大于0.5的数本身
    print b
    # # # # 将原数组中大于0.5的元素截取成0.5
    a[a > 0.5] = 0.5
    print a
    # # # # b不受影响
    print b

    # 3.3 二维数组的切片
    # [[ 0  1  2  3  4  5]
    #  [10 11 12 13 14 15]
    #  [20 21 22 23 24 25]
    #  [30 31 32 33 34 35]
    #  [40 41 42 43 44 45]
    #  [50 51 52 53 54 55]]
    a = np.arange(0, 60, 10)    # 行向量
    print 'a = ', a
    b = a.reshape((-1, 1))      # 转换成列向量，重点是后面的1
    print b
    c = np.arange(6)
    print c
    f = b + c   # 行 + 列，变成一个二维数组
    print f
    # # 合并上述代码：
    a = np.arange(0, 60, 10).reshape((-1, 1)) + np.arange(6)
    print a
    # # 二维数组的切片
    print a[(0,1,2,3), (2,3,4,5)] #0123行，2345列，得到4*4的矩阵
    print a[3:, [0, 2, 5]] #3行之后，025列
    i = np.array([True, False, True, False, False, True])
    print a[i] #提取0,2,5行元素
    print a[i, 3] #再提取第3列

    # # 4. numpy与Python数学库的时间比较，numpy会小的多
    for j in np.logspace(0, 7, 10):
        j = int(j)
        x = np.linspace(0, 10, j)
        start = time.clock() #记录开始时间
        y = np.sin(x)
        t1 = time.clock() - start 
    
        x = x.tolist()
        start = time.clock()
        for i, t in enumerate(x):
            x[i] = math.sin(t)
        t2 = time.clock() - start
        print j, ": ", t1, t2, t2/t1

    # 5.绘图
    # 5.1 绘制正态分布概率密度函数
    mu = 0
    sigma = 1
    x = np.linspace(mu - 3 * sigma, mu + 3 * sigma, 50)
    y = np.exp(-(x - mu) ** 2 / (2 * sigma ** 2)) / (math.sqrt(2 * math.pi) * sigma) #平方**
    print x.shape
    print 'x = \n', x
    print y.shape
    print 'y = \n', y
    plt.plot(x, y, 'ro-', linewidth=2)
    plt.plot(x, y, 'r-', x, y, 'go', linewidth=2, markersize=8)
    plt.grid(True)
    plt.show()

	# 使用中文
    matplotlib.rcParams['font.sans-serif'] = [u'SimHei']  #FangSong/黑体 FangSong/KaiTi
    matplotlib.rcParams['axes.unicode_minus'] = False

    # 5.2 损失函数：Logistic损失(-1,1)/SVM Hinge损失/ 0/1损失
    x = np.array(np.linspace(start=-2, stop=3, num=1001, dtype=np.float))
    y_logit = np.log(1 + np.exp(-x)) / math.log(2)
    y_boost = np.exp(-x)
    y_01 = x < 0
    y_hinge = 1.0 - x
    y_hinge[y_hinge < 0] = 0
    plt.plot(x, y_logit, 'r-', label='Logistic Loss', linewidth=2)
    plt.plot(x, y_01, 'g-', label='0/1 Loss', linewidth=2)
    plt.plot(x, y_hinge, 'b-', label='Hinge Loss', linewidth=2)
    plt.plot(x, y_boost, 'm--', label='Adaboost Loss', linewidth=2)
    plt.grid() #网格线
    plt.legend(loc='upper right')
    plt.savefig('1.png') #储存图片
    plt.show()

    # # # 5.3 x^x
    x = np.linspace(-1.3, 1.3, 101)
    y = f(x)
    plt.plot(x, y, 'g-', label='x^x', linewidth=2)
    plt.grid()
    plt.legend(loc='upper left') #放图例
    plt.show()

    # # 5.4 胸型线
    x = np.arange(1, 0, -0.001)
    y = (-3 * x * np.log(x) + np.exp(-(40 * (x - 1 / np.e)) ** 4) / 25) / 2
    plt.figure(figsize=(5,7))
    plt.plot(y, x, 'r-', linewidth=2)
    plt.grid(True)
    plt.show()

    # 5.5 心形线
    t = np.linspace(0, 7, 100)
    x = 16 * np.sin(t) ** 3
    y = 13 * np.cos(t) - 5 * np.cos(2*t) - 2 * np.cos(3*t) - np.cos(4*t)
    plt.plot(x, y, 'r-', linewidth=2)
    plt.grid(True)
    plt.show()

    # # 5.6 渐开线
    t = np.linspace(0, 50, num=1000)
    x = t*np.sin(t) + np.cos(t)
    y = np.sin(t) - t*np.cos(t)
    plt.plot(x, y, 'r-', linewidth=2)
    plt.grid()
    plt.show()

    # # Bar
    matplotlib.rcParams['font.sans-serif'] = [u'SimHei']  #黑体 FangSong/KaiTi
    matplotlib.rcParams['axes.unicode_minus'] = False
    x = np.arange(0, 10, 0.1)
    y = np.sin(x)
    plt.bar(x, y, width=0.04, linewidth=0.2)
    plt.plot(x, y, 'r--', linewidth=2)
    plt.title(u'Sin曲线')
    plt.xticks(rotation=-60)
    plt.xlabel('X')
    plt.ylabel('Y')
    plt.grid()
    plt.show()

    # # 6. 概率分布
    # # 6.1 均匀分布
    x = np.random.rand(10000)
    t = np.arange(len(x))
    plt.hist(x, 30, color='m', alpha=0.5)
    plt.plot(t, x, 'r-', label=u'均匀分布')
    plt.legend(loc='upper left')
    plt.grid()
    plt.show()
    #
    # # # 6.2 验证中心极限定理
    t = 10000
    a = np.zeros(1000)
    for i in range(t):
       a += np.random.uniform(-5, 5, 1000)
    a /= t
    plt.hist(a, bins=30, color='g', alpha=0.5, normed=True)
    plt.grid()
    plt.show()

    # # 6.3 Poisson分布
    x = np.random.poisson(lam=5, size=10000)
    print x
    pillar = 15
    a = plt.hist(x, bins=pillar, normed=True, range=[0, pillar], color='g', alpha=0.5)
    plt.grid()
    plt.show()
    print a
    print a[0].sum()

    # # 6.4 直方图的使用
    mu = 2
    sigma = 3
    data = mu + sigma * np.random.randn(1000)
    h = plt.hist(data, 30, normed=1, color='#a0a0ff')
    x = h[1]
    y = norm.pdf(x, loc=mu, scale=sigma)
    plt.plot(x, y, 'r--', x, y, 'ro', linewidth=2, markersize=4)
    plt.grid()
    plt.show()

    # # 6.5 插值
    rv = poisson(5)
    x1 = a[1]
    y1 = rv.pmf(x1)
    itp = BarycentricInterpolator(x1, y1)  # 重心插值
    x2 = np.linspace(x.min(), x.max(), 50)
    y2 = itp(x2)
    cs = scipy.interpolate.CubicSpline(x1, y1)       # 三次样条插值
    plt.plot(x2, cs(x2), 'm--', linewidth=5, label='CubicSpine')           # 三次样条插值
    plt.plot(x2, y2, 'g-', linewidth=3, label='BarycentricInterpolator')   # 重心插值
    plt.plot(x1, y1, 'r-', linewidth=1, label='Actural Value')             # 原始值
    plt.legend(loc='upper right')
    plt.grid()
    plt.show()

    # 7. 绘制三维图像
    x, y = np.ogrid[-3:3:100j, -3:3:100j]
    u = np.linspace(-3, 3, 101)
    x, y = np.meshgrid(u, u)
    z = x*y*np.exp(-(x**2 + y**2)/2) / math.sqrt(2*math.pi)
    z = x*y*np.exp(-(x**2 + y**2)/2) / math.sqrt(2*math.pi)
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')
    ax.plot_surface(x, y, z, rstride=5, cstride=5, cmap=cm.coolwarm, linewidth=0.1)
    ax.plot_surface(x, y, z, rstride=5, cstride=5, cmap=cm.Accent, linewidth=0.5)
    plt.show()
    cmaps = [('Perceptually Uniform Sequential',
               ['viridis', 'inferno', 'plasma', 'magma']),
              ('Sequential', ['Blues', 'BuGn', 'BuPu',
                              'GnBu', 'Greens', 'Greys', 'Oranges', 'OrRd',
                              'PuBu', 'PuBuGn', 'PuRd', 'Purples', 'RdPu',
                              'Reds', 'YlGn', 'YlGnBu', 'YlOrBr', 'YlOrRd']),
              ('Sequential (2)', ['afmhot', 'autumn', 'bone', 'cool',
                                  'copper', 'gist_heat', 'gray', 'hot',
                                  'pink', 'spring', 'summer', 'winter']),
              ('Diverging', ['BrBG', 'bwr', 'coolwarm', 'PiYG', 'PRGn', 'PuOr',
                             'RdBu', 'RdGy', 'RdYlBu', 'RdYlGn', 'Spectral',
                             'seismic']),
              ('Qualitative', ['Accent', 'Dark2', 'Paired', 'Pastel1',
                               'Pastel2', 'Set1', 'Set2', 'Set3']),
              ('Miscellaneous', ['gist_earth', 'terrain', 'ocean', 'gist_stern',
                                 'brg', 'CMRmap', 'cubehelix',
                                 'gnuplot', 'gnuplot2', 'gist_ncar',
                                 'nipy_spectral', 'jet', 'rainbow',
                                 'gist_rainbow', 'hsv', 'flag', 'prism'])]

    # 8.1 scipy
    # 线性回归例1
    # x = np.linspace(-2, 2, 50)
    # A, B, C = 2, 3, -1
    # y = (A * x ** 2 + B * x + C) + np.random.rand(len(x))*0.75
    #
    # t = leastsq(residual, [0, 0, 0], args=(x, y))
    # theta = t[0]
    # print '真实值：', A, B, C
    # print '预测值：', theta
    # y_hat = theta[0] * x ** 2 + theta[1] * x + theta[2]
    # plt.plot(x, y, 'r-', linewidth=2, label=u'Actual')
    # plt.plot(x, y_hat, 'g-', linewidth=2, label=u'Predict')
    # plt.legend(loc='upper left')
    # plt.grid()
    # plt.show()

    # # 线性回归例2
    # x = np.linspace(0, 5, 100)
    # A = 5
    # w = 1.5
    # y = A * np.sin(w*x) + np.random.rand(len(x)) - 0.5
    #
    # t = leastsq(residual2, [3, 1], args=(x, y))
    # theta = t[0]
    # print '真实值：', A, w
    # print '预测值：', theta
    # y_hat = theta[0] * np.sin(theta[1] * x)
    # plt.plot(x, y, 'r-', linewidth=2, label='Actual')
    # plt.plot(x, y_hat, 'g-', linewidth=2, label='Predict')
    # plt.legend(loc='lower left')
    # plt.grid()
    # plt.show()

    # # 8.2 使用scipy计算函数极值
    # a = opt.fmin(f, 1)
    # b = opt.fmin_cg(f, 1)
    # c = opt.fmin_bfgs(f, 1)
    # print a, 1/a, math.e
    # print b
    # print c

    # marker	description
    # ”.”	point
    # ”,”	pixel
    # “o”	circle
    # “v”	triangle_down
    # “^”	triangle_up
    # “<”	triangle_left
    # “>”	triangle_right
    # “1”	tri_down
    # “2”	tri_up
    # “3”	tri_left
    # “4”	tri_right
    # “8”	octagon
    # “s”	square
    # “p”	pentagon
    # “*”	star
    # “h”	hexagon1
    # “H”	hexagon2
    # “+”	plus
    # “x”	x
    # “D”	diamond
    # “d”	thin_diamond
    # “|”	vline
    # “_”	hline
    # TICKLEFT	tickleft
    # TICKRIGHT	tickright
    # TICKUP	tickup
    # TICKDOWN	tickdown
    # CARETLEFT	caretleft
    # CARETRIGHT	caretright
    # CARETUP	caretup
    # CARETDOWN	caretdown
weixin_43579079
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python绘制各种各样的图形
snowflake1103的博客
05-25 802
绘制图形
python绘制图形
aigo_2021的博客
03-22 1653
import turtle #引入turtle库 turtle.pensize(3) #画笔粗为3 turtle.pencolor('red') #画笔颜色为红色 count = 1 #计数器 while count<=18: #循环18次 turtle.forward(80) #画笔前进80 if count % 2 == 0: #如果count是偶数 turtle.left(170) #向左旋转170度 else: .
Python绘制常见图形
OliverkingLi的博客
02-02 1696
#!/usr/bin/python # -*- coding:utf-8 -*- import numpy as np import matplotlib as mpl from mpl_toolkits.mplot3d import Axes3D from matplotlib import cm import time from scipy.optimize import leastsq
绘制图形可以使用什么python数据库_使用Python的turtle画炫酷图形
weixin_39605191的博客
11-23 152
最近在学习Python，觉得很有意思，本人有一些Java编程基础经验，就跳过基本的语法学习，直接做一些小程序来试试，目前学到turtle，这个乌龟画图真的很有意思了，现在分享几个炫酷的图，代码如下，原理就不解释。例子一：import turtlet = turtle.Pen()turtle.bgcolor("black")sides=6colors=["red","yellow","green",...
Python图形绘制
Uncle_wangcode的博客
09-08 7633
文章目录前言一、turtle海龟绘图二、Python图形绘制三、绘画小黄人习题巩固 前言 海龟绘图很适合用来引导孩子学习编程。 最初来自于 Wally Feurzeig, Seymour Papert 和 Cynthia Solomon 于 1967 年所创造的 Logo 编程语言。。 一、turtle海龟绘图 1.了解海龟绘图的来源 2.掌握turtle库的基本方法 海龟绘图概述 Python语言标准库之一 ​ 标准库：随解释器直接安装到操作系统中的功能模块 ​ 第三方：需要经过安装才
python题库
01-27
本题库涵盖了 Python 的基础知识，包括填空题、判断题、操作题等，涵盖了 Python 的安装、标准库、数据类型、运算符、列表、元组、字符串、字典、集合、文件操作等方面的知识点。 一、Python 安装和基本概念 * ...
Python库 | wrf-python-1.1.3.tar.gz
04-19
资源分类：Python库 所属语言：Python 资源全名：wrf-python-1.1.3.tar.gz 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
Python库参考手册.pdf
08-05
“Python 语言参考手册"中精确地描述了Python 语言的句法及语义，罗列并说明了Python 标准库的各种功能, 以及许多非核心的模组(按不同的操作系统和编译时的设置而定, 不是每台机上的Python 都能用这些模组.) ,手册...
Python库 | mpmath-0.2.zip
05-25
资源分类：Python库 所属语言：Python 资源全名：mpmath-0.2.zip 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
Python库 | python_secrets-22.1.0-py3.8.egg
04-29
资源分类：Python库 所属语言：Python 使用前提：需要解压 资源全名：python_secrets-22.1.0-py3.8.egg 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
Python的画图工具
12-20
基于Python的matplotlib包的画图工具命令的总结，可以画折线图，柱状图，散点图，三维图等
基于python3.6用tkinter库制作的绘图程序
05-31
基于python3.6的tkinter库制作的绘图小程序，源于《python宝典》的例子。能绘制直线、矩形、椭圆和四分之一圆。
Python最简单的图形编程
热门推荐
vernice的专栏
06-07 2万+
使用Python进行图像编程，要使用到Graphics库。Graphics库可以从http://mcsp.wartburg.edu/zelle/python/graphics.py获取。在Windows平台上将下载的graphics.py保存在C:\Python31\Lib\site-packages即可。
【Python/绘图】python绘图
第三季度的博客
05-02 1万+
python绘图
Python程序绘制图形（7_9/30）
sssmmmx
08-11 606
前言 Life is short，you need Python ！（持续更新） 大纲 进一步理解程序的运行 模块turtle的使用 turtle程序解析 实例 电子时钟与机械表秒 进一步理解程序的运行 程序是如何运行的 中央处理器（CPU，central processing unit）作为计算 机系统的运算和控制核心，是信息处理、程序运行的最终 执行单元。 CPU是负责协调计算机的，我们写的源代码最终都是会提交给CPU，由CPU 来统一执行。 但是CPU对于我们写的代码也是一窍不通的，不管是J
Python画三个简单图形
we123aaa4567的博客
09-22 3972
用Python的turtle库做的三个简单图形，快来看~~~
Python基本图形绘制
M1314520ba的博客
08-13 2487
目录 实例2: Python蟒蛇绘制 turtle正方形绘制 turtle六边形绘制 turtle叠边形绘制 turtle风轮绘制 实例2: Python蟒蛇绘制 这是"实例"题，与课上讲解实例相同，请作答检验学习效果。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬ 使用turtle库
python基本图形绘制
夏末秋也凉的博客
08-26 363
目录 不同编程语言的开发目的和适用对象 编程语言的种类 机器语言： 汇编语言： 高级语言： 超级语言： turtle库的使用： turtle基本介绍： turtle绘图窗体布局 turtle空间坐标体系 绝对坐标 海龟坐标 turtle角度坐标体系 绝对角度 海龟角度 RGB色彩体系 程序语法元素分析 turtle画笔控制函数 turtle运动控制函数 turtle方向控制函数 基本循环语句 不同编程语言的开发目的和适用对象 学习内容
python中用于绘制各种图形_如何在Python绘制图形
weixin_36354744的博客
03-02 4727
如何在Python绘制图形Python提供了一种最流行的绘图库，称为Matplotlib。它是开源的，跨平台的，可以根据数组中的数据制作2D图。它通常用于数据可视化并通过各种图形表示。Matplotlib最初由John D. Hunter于2003年构思。matplotlib的最新版本是2.2.0，于2018年1月发布。在开始使用matplotlib库之前，我们需要在Python环境中安装。安装M...
zksanrks python库
最新发布
09-29
zksanrks是一个Python库。Python是一种高级编程语言，被广泛用于软件开发、数据分析、人工智能等领域。Python库是为了方便程序员开发和实现特定功能而封装的一组模块和函数。 zksanrks库可能是一个专门用于某种领域...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值