Python学习

先来个小栗子

在Python交互环境中实现：win+R

# 画一个正方形(颜色自己定)
import turtle
turtle.pensize(4); turtle.pencolor('red'); turtle.forward(100);
turtle.right(90); turtle.forward(100);turtle.right(90);
turtle.forward(100); turtle.right(90);turtle.forward(100);
turtle.mainloop

1.基础

1. 输入: print()

• 单引号与双引号的区分不是很大，但输出时不可重复，重复时应用转义字符

  print('Hello,world!') 与 print("Hello,world!")   # 结果是一样的
  print('I\'m a student') 
  # 等同于 print("I'm a student")   反之亦然

• 两个 print() 之间会自动换行，可以不用\n

• print() 可以接受多个字符串，但中间要用逗号隔开，打印时，逗号会变为空格

  eg. print('Hello,','world') 打印值：Hello, world

• 可以直接输出数字，或计算结果

  eg.print(2020)—>2020
       print(2*5)—>10
       print(2,4)—>2 4

  也可以多个输出，逗号一样变空格

• 可利用三重单引号或三重双引号进行多行输出，适用于一行太长的情况

  eg.print('''I\'m a student
     I\'m very lazy''')

  得：I'm a student
        I'm very lazy

  当然，换行输出也可以用\n

2. 输入: input()

• 可以直接输入

  eg. name = input() print(name)

• 也可以在 input() 里输入字符串,执行时 input() 里的字符串会显示出来

  eg. name = input("Please enter your name:")
      print('Hello',name)

  逗号不能少

3. 字符串

• 后缀：

  后缀名	作用
  .title()	输入字符串的首字母全大写
  .lower()	输入字符串全小写
  .upper()	输入字符串全大写

• f 字符串

  用法：string1=”…”， string2=”…” （单引号也行）

  f"{string1} {string2}"

  可以是多个字符串，也可以直接输入字符串，注意，空格也算

  注：不是直接的字符串使用时要用大括号括起来

  first_name="ada"
  last_name="lovelace"
  full_name=f"{first_name} {last_name}"
  print(f"Hello,{full_name.title()}!")

  得：Hello,Ada Lovelace!

拓充：
f 字符串是在3.6版本引入的，在此之前是函数format()，为一个后缀函数
用法为：full_name="{} {}".format(first_name,last_name)字符串必须要单/双引号括起来，此处可以是多个字符串

• 转义字符

  转义字符	作用
  \n	换行
  \r	回车
  \b	退格
  \	(在行尾时) 续航 (感觉跟三引号差不多)

  栗子：

  \b:

​ print("Hello!\b\b")

 得：`Hell`

\ :

    print('鬼\
    灭\
    之\
    刃')

​ 得：鬼灭之刃

• 可以用方括号截取字符串

  eg. name = "Hello,world"

       print(name[0]) —>H

       print(name[0:5]) —>Hello            //左闭右开，即 [0:5]是第零个到第四个字符

  注：0 也可以不写，即 [:5]是一样的

• 字符串运算符

  字符	作用	栗子	打印结果
  +	可以连接字符串	name="Hello,"; print(name+'world!')	Hello,world!
  *****	重复输出字符串	name="Hello"; print(name\*2)	HelloHello
  in	如果字符串中包含给定字符则返回 Ture，反之返回False	name="Hello"; print('H' in name)	True
  not in	与 in相反	name="Hello"; print('H' not in name)	False
  r/ R	打印原始字符串	print('\n'); print(r'\n')	换行\n

  注：r/R 是在引号外，如果写在引号里就是打印 r/R了

(附)Python 小常识：

• 有复数型表示，即 3+5j 这样的，把数学中的 i变成了 j
• 变量的命名与 C相同，即字母、数字、下划线，其中数字不能开头
• 用 type()可以检查变量类型
• print() 中用 %s等占位符时，后面不是用逗号，而是 %，因为用逗号会被认为是空格；如果有多个占位符，后面不要忘了加括号
• 两个字符串写在一起会自动拼接
• 字符串中打印 %要用 %%，打印 \要用 \\
• 逻辑运算中会有短路现象 (同 C)
• input()函数返回值都是字符串，故进行运算时应有强改

4. 布尔值(bool)

• True 和 False 被定义为了关键字 但还是 1真 0假

  print(2>8)
  print(4>2)
  print(int(True),int(False))

  得：False和Ture和1 0

• 布尔值可以进行逻辑运算

  and , or , no

• 常见布尔值(False)：

  none

  0 ,0.0 ,0.0+0.0j

  空 (含 [] , (), {} , ‘’, “” )

5. 强改

• 形式 （有太多，就不全写了，格式都一样）

  int()
  float()
  chr() # 字符
  ord() # 将字符串转化为编码
  str()、repr() # 字符串，但有一点区别

  name='xiao shuang'
      print(str(name)) --->xiao shuang
      print(repr(name)) --->'xiao shuang'

  6. 运算符

符号	作用	栗子
**	指数	2**3=8
~	加1取反号	~4 = -5
^	异或

7. 后缀

后缀名	作用
.rstrip()	去除输入字符串末尾的空白
.lstrip()	去除输入字符串开头的空白
.strip()	去除输入字符串两边的空白
.capitalize()	输入字符串第一个字符大写
max(str)	返回 str中最大的字母
min(str)	返回 str中最小的字母

补充实例：

print('%.1f华氏度 = %.1摄氏度' % (f, c))			// f , c为常数
// 等价于
print(f'{f: .1f}华氏度 = {c: .1f}摄氏度')

(补)基础知识：

• 任意两数相乘结果都是偶数，即使是两个整数，比如：4/2 = 2.0
• 打印数字时下划线会被省略
• 注释是‘#’号，也可以用 ctrl+/ （注释整行）

8. 列表

• 许多特点与数组相似

name = ['gui', 'mie', 'zhi', 'ren']
print(name[0])

得：'gui'

注：可以与各函数一起用，如：name[1].title()

系列操作

• 修改：

name = ['gui', 'mie', 'zhi', 'ren']
name[0] = 'xiao'
print(name[0])

得：xiao

• 添加：name = ['gui', 'mie', 'zhi', 'ren']

name.append('xiao')       # 直接在最后面添加元素
print(name)
## 得：`['gui', 'mie', 'zhi', 'ren', 'xiao']`


name.insert(0, 'xiao')        # 在任意位置添加元素
print(name) 
## 得：['xiao', 'gui', 'mie', 'zhi', 'ren']

• 删除：name = ['gui', 'mie', 'zhi', 'ren']

del name[0]      # 删除后无法再访问
print(name)
## 得：['mie', 'zhi', 'ren']


pop_name = name.pop()       # 删除时可以接着使用，且默认是删最后一个
print(name)
print(pop_name)      # 也可以删除任意一个，只需在 pop() 内 加上索引
## 得：['gui', 'mie', 'zhi']和 ren


name.remove('gui')          # 指定元素删除，且与 pop() 一样可使用
print(name)
## 得：['mie', 'zhi', 'ren']

区分：在知道索引的情况下，不需要删除值时可用 del ,需要则用 pop() ,而不知道索引时应用 remove()

• 排序：name = ['gui', 'mie', 'zhi', 'ren']

name.sort()         # 永久排序，不能直接在括号里使用
print(name)

得：['gui', 'mie', 'ren', 'zhi']

sorted(name)         # 临时排序
print(name)
print(sorted(name))

得：['gui', 'mie', 'zhi', 'ren']和['gui', 'mie', 'ren', 'zhi']

name.reverse()        # 同 .sort()，不过是反向打印
print(name)         # 连续两次就复原了

得：['ren', 'zhi', 'mie', 'gui']

• 求长度len()

name = ['gui', 'mie', 'zhi', 'ren']
print(len(name)) 

得:4

• for 的应用

  注：在Python中，for、if 之类的语句没有括号，是以缩进来判断是否在循环语句/判断语句中

names = ['gui', 'mie', 'zhi', 'ren']
for name in names:         # 冒号一定不能少
print(name)

得：gui
        mie
        zhi
        ren

• 快速创建列表

for num in range(1,4):             # 左闭右开
print(num)

得：1
        2
        3

num = list(range(1,4))            # list() 是转换为列表
print(num)

得：[1, 2, 3]

• 解析列表            //就很厉害

# 解析前
names = []           # 先建一个空列表
for name in range(1,4):
    num = name**2            # **2是平方
    names.append(num)
    print(names)
# 解析后：
    names = [name**2 for name in range(1, 4)]
    print(names)

得：[1, 4, 9]和[1, 4, 9]

• 切片

name = ['gui', 'mie', 'zhi', 'ren']
print(name[1:3])

得：['mie', 'zhi']

注：name[:3] 指从第一个到三个，name[1:]指从第二个到最后一个，与数组有些相似，左闭右开

补充：在复制列表时应用切片，即：num = name[:]，这样才能保证两个列表之间不会互相干扰；若直接用 num = name，则这两个变量是指向同一个列表，一个改动另一个也会被影响

9. 元组

与列表十分相似，只是使用（），而且元组中的元素不允许像列表中的元素一样可以修改，也不能增添删减元素，但是可以重新赋值，见下例：

name = ('gui', 'mie')
name[0] = 'xiao'      # 会报错
name = ('xiao', 'shuang')        # 重新赋值
print(name)

得：('xiao', 'shuang')

• if-elif-else             //写法有些不同
  感觉跟 C没有太大差别，就是语法有些不同，多了 in、not in、and、or 等的应用，多练练就好了

2. 入门

1. 模块

1. 可以只调用模块中的某一确定元素使用，比如：若这个文件中有很多函数（不止 make_pizza(size, *toppings)）时，可以用from making_pizza import make_pizza, function_1, function_2 (举个例子)
   这样在使用时不用再写后缀，直接make_pizza(12, pep)

2. 调用模块时是直接调用这个模块里的所有函数代码

3. 函数也可以重命名：

   from making_pizza import make_pizza as mp

   上面将 making_pizza 命名为了 mp，在 import中实现 (针对某一具体函数)

4. 同理，模块也可以重命名，见下面的例子
   同样，也在 import中实现

5. 联系第三条，要调用模块里的所有函数可以用 *，即
   from making_pizza import *
   这时，也不需要后缀使用，可以直接： make_pizza(12, 'pep')
   (注：函数很多时最好不要这样用，记不住呀，后缀起码还有提示)

6. 像头文件一样， import一般放在开头

# 调用模块
import making_pizza

making_pizza.make_pizza(16, 'pep')
making_pizza.make_pizza(12, 'mushroom', 'green peppers', 'extra cheese')

# 引入的函数( making_pizza )
def make_pizza(size, *toppings):
    print(f"\nMaking a {size}-int pizza with the following toppings:")
    for topping in toppings:
        print(f"- {topping}")

"""栗4"""
# 调用模块并自命名
import making_pizza as p

p.make_pizza(16, 'pep')
p.make_pizza(12, 'mushroom', 'green peppers', 'extra cheese')

2. 类

小知识：

• 一般大写字母为类，小写为方法和变量

• 类中的函数称为方法，其调用与之前不同，如下例：
  __init__()是一个特殊的方法，在根据类创建实例时，会自动运行（其他方法在调用后才会运行），而且，两边的下划线一定不能少
  这是一种约定，如果少了，那函数是不会自动调用的

• 不难发现，每个方法 ()中都有变量 self，以该变量为前缀的变量可以在类中任意位置调用（即使不在同一函数中）

• 可以通过实例（restaurant_1）访问的变量（self.name）称为属性，属性可以修改（详见下面的例子 num）

• ‘类’是可以继承的（我们亲切的称为’父、子类‘），在父类的基础上，子类有自己的方法和属性，使用如下：
  class hotel(Restaurant): 。。。
  此处创建了一个子类 hotel，显然，子类就是在类的基础上多了 (父类)，新的方法添加与类相同，注意，创建子类时，父类一定要在，且先有’父‘后有’子‘，父类应在子类之前，既然继承了父类，那么父类里的方法在子类中肯定是可以调用的：

  def __init__(self, restaurant_name, cuisine_type):
      supper().__init__(restaurant_name, cuisine_type)

  特有属性（需要自动运行的）
  对的，就是用特殊函数 supper()，注意，不需要 self,因为父类也称超类

如果没有特殊属性，那这就是不需要的，父类方法子类可以直接用

• 如果父类中的某一方法在子类中是矛盾的，那就因该在子类中重写父类的方法，即命名相同的函数名，这样在运行子类时会忽略父类中与子类相同名的方法，但并未改变父类 ———— 称为多态

• 如果一个类中信息太多，可以将一部分提出来放到另一个类中，并将另一个类作为类中的属性（类中类），例如：self.battery = Battery(),类 Battery 就是个例子，不展开

在调用时，应是 “实例.battery.方法（Battery()中的）”

• 与函数一样，类也是可以调用的，方法一样（可以同时调用多个类，用逗号分开），详见”学习 (模块)“

  灵活使用是关键

• 介绍几个函数：

  访问器、修改器：getter、setter                详见练习.4

  _slots_ = : 限制类的绑定属性

  如：__slots__ = ('_name', '_age', '_gender')

  则在该类的对象属性只有三个，强调：只是该类对象有效，其它包括子类均无效

• 并不是所有方法都是对象方法，也有类方法，即与对象无关的方法                详见练习.5

• 类方法：在类中定义类方法，不能直接对类赋值可以通过类方法创建对象详见                练习.6

• 类之间的关系有三种：

  • 一.is-a 关系也叫继承或泛化，比如学生和人的关系、手机和电子产品的关系都属于继承关系

  • 二.has-a 关系通常称之为关联，比如部门和员工的关系，汽车和引擎的关系都属于关联关系；

    关联关系如果是整体和部分的关联，那么我们称之为聚合关系；

    如果整体进一步负责了部分的生命周期(整体和部分是不可分割的，同时同在也同时消亡),那么这种就是最强的关联关系,我们称之为合成关系

  • 三.use-a 关系通常称之为依赖，比如司机有一个驾驶的行为（方法），其中（的参数）使用到了汽车，那么司机和汽车的关系就是依赖关系

• 有时，创建的类只作为父类（称为”抽象类”），这是需要借助 abc 模块                详见练习.7

演示

# 创建父类并演示
class Restaurant:
    """描述餐馆"""
    def __init__(self, restaurant_name, cuisine_type):
        self.name = restaurant_name
        self.type = cuisine_type
        self.num = 0

    def describe_restaurant(self):
        print(f"\nRestaurant's name is {self.name}")
        print(f"Restaurant's type is {self.type}")

    def open_restaurant(self):
        print(f"It's open now.")

    def number_served(self):
        print(f"\nHave {self.num} people eating here.")

    def increment_number_served(self, people):
        if people > 0:
            self.num += people
        else:
            print("你在干啥")


restaurant_1 = Restaurant('xiao', 'shuang')

restaurant_1.describe_restaurant()
restaurant_1.open_restaurant()
restaurant_1.number_served()

restaurant_1.num = 15
restaurant_1.number_served()

restaurant_1.increment_number_served(5)
restaurant_1.number_served()


# 创建子类并演示
class IceCream(Restaurant):
    def __init__(self, restaurant_name, cuisine_type):
        """为了示例 supper()，这里这个方法是可以不要的"""
        super().__init__(restaurant_name, cuisine_type)

    def flavors(self, *flavor):
        """增添子类独有方法"""
        print("You want to add following flavor:")
        for num in flavor:
            print(f"{num}")


icecream = IceCream('gui', 'mie')
icecream.describe_restaurant()
icecream.flavors('sugar', 'mike', 'chocolate')

3. 文件

前提：
Python 在读取文件时将所有文本解读为字符串，如果数字的话，使用时应用 int()转换

• 对文件进行任何操作的前提是打开文件，利用函数 open(文件名)，但打开的文件应与当前文件在同一个目录中（下例目录为：学习）

  with 的使用：由 Python判断，在不使用文件时将文件关闭也可以用 finally代码配合 .close关闭文件，其中 finally代码为总是执行代码

访问的文件不一定在同一个目录中，这时就应注意文件路径

• 路径

  相对路径：需打开的文件在当前文件目录的子目录中（以 text_file为例）

  with open('text_file/读取.txt') as file_object:。。。

  绝对路径：需打开的文件不在当前目录中（以 other_files为例）

  file = 'C:/用户/hw/other_files/读取.txt'        ## 路径太长，以一个变量代替

  with open(file) as file_object:。。。

  !! 注：如果用’\‘一定要进行转义(‘\\‘)，否则出现 \n之类的会被解读为换行

• 函数解释：

  .read()：读取文件里的全部内容，并将其作为一个字符串返回

  .readline()：读取文件里的一行

  .readlines()：一行行的读取文件内容，并将其存储在一列表中

  replace('。。1', '。。2')：将字符串中的特定单词替换（字符串2 替换 字符串1）

• 写入文件的格式有一些不同：

  with open('文件名', 'w') as file_object:。。。

  其实后面都有实参，再没有指定的情况下会默认为是读取模式，即：'r'

  附：'w'：写入模式

         'r'：读取模式

         'r+'：读写模式          ## 可读(read()) 可写(write())

         'a'：附加模式
  注：'a'：此模式下，是给文件添加内容，而不会覆盖原先的内容，如果指定的文件不存在，会自动创建一个空文件

         'b'：二进制模式
  注：似乎可以两个一起用          ## 详见实例.2

• 读取文件时可用 encoding='' 来指定编码，没有指定则以系统默认编码读取

演示

# open()返回的是文件里的对象，将其赋给 file_object待用
with open('读取.txt') as file_object:
    # read() 读取文件的全部内容
    contents = file_object.read()
print(contents)

# 逐行读取
print('\n')
file = '读取.txt'
with open(file) as file_object:
    for line in file_object:
        # 文件每行的末尾都有'看不见'的换行符，所以打印出来会有很多换行，可以用 rstrip()去掉
        print(line)

# 将读取内容存储在列表中，使其在 with代码块之外也可以进行操作
print('\n')
file = '读取.txt'
with open(file) as file_object:
    list = file_object.readlines()
# 打印列表 list
for line in list:
    print(line.rstrip())

# 写入信息
with open('写入.txt', 'w') as files:
    files.write("xiao_shuang\n")
    files.write("gui mie zhi ren\n")
    # 写入文件的只能是字符串，如果是数字应以字符串格式，可借助函数 str()，当然 "123"也行
    files.write(f"{str(123)}\n")

# 附加模式
with open('写入.txt', 'a') as files:
    files.write('xiao\n')
    files.write('shuang\n')

4. 异常

前提：
写的程序出现错误是经常有的，这是’异常’,当然的有对策

• 使用 try-except 提高程序容错率，不是出现那鲜红的提示（有好的提示），一般把可能出现错误的代码放在 try中，若 try中代码成功执行，则会忽略 except代码，执行 else代码；
  如果出现异常，执行的是 except代码，且后面还有代码，则程序仍会继续执行
  静默失败：即在 except中的代码是 pass

• 函数介绍

  .split()：以空格为分隔符将字符串拆分并存储在一个列表中       ## 再配合 len(。。。)可得知有多少单词
  注：直接用 len(。。。)得到的是字符串的长度

  .count(。。。)：确定字符串/列表中特定的单词（也有误差,the 在 then里）出现了几次        ## 大小写严格区分

• 存储数据        ## 详见练习.9、练习.10

  在程序中，需要用户输入数据，且在程序结束时希望数据保留下来以便下次直接使用，那数据必须存储起来，常用 JSON 格式存储，注意该格式文件后缀为.json

  json.dump(。。。)：接受两个实参，第一个为存储内容，第二个为文件对象

  json.load(。。。)：接受一个实参，为文件对象

  注：在存储的数据仅为字符串时可以直接用 write()，但为列表、字典时只能用 json

附：json.dumps()：将 Python对象处理为 JSON 中的字符串格式
        json.loads()：类似

• 重构：将代码化为作用单一的代码块（起码目前我是不会这么做的，没事找事）

演示

# 除零错误 (ZeroDivisionError)
print("You can input tow numbers and I'll divide them.")
print('You can stop whenever input q')
while True:
    # 先要判断是否为'q'，所以不能再此处直接用 int()转换
    first_number = input('First num: ')
    if first_number == 'q':
        break
    second_number = input('Second num: ')
    if second_number == 'q':
        break
    try:
        answer = int(first_number)/int(second_number)
    except ZeroDivisionError:
        print("You can't divide by zero!\n")
    else:
        print(f"{answer}\n")

5. 测试

• 在开发项目中（有点远。。。）对代码进行测试是必不可少的测试需引用模块 unittest，为测试函数需创建一个继承 unittest.TestCase的类，在类中编写方进行测试            ## 详见下例

• 在子类中以 test_ 开头的方法将自动运行（与一般的类不同，需区分）
  断言方法：
  unittest模块中（常用）

  assertEqual(a, b)：   核实 a == b

  assertNotEqual(a, b)：   核实 a != b

  assertTure(x)：   核实 x为 Ture

  assertFalse(x)：  核实 x为 False

  assertIn(item, list)：   核实 item在 list中

  assertNotIn(item, list)：   核实 item不在 list中

• 方法 setUp()：在类中先运行          ## 详见练习.11
  注：类中不同方法所拥有的共同代码写入 setUp()中可简化代码

• if __name__ == '__main__'
  在写的代码中有 def main(): 时，其下应有 main()，若是直接执行当前文件，则正常执行，若是该文件被调用，则不会执行，而在测试代码中也是一样的，不过是 unittest.main()

演示

import unittest


# 需测试的函数
def get_name(first, last, middle=''):
    if middle:
        full_name = f"{first} {middle} {last}"
        return full_name.title()
    else:
        full_name = f"{first} {last}"
    return full_name.title()


# 创建子类
class NameTest(unittest.TestCase):

    # 以 test_ 开头，自动运行
    def test_first_last_name(self):
        # 需要在整个类中使用的属性定义为 self.
        name = get_name('xiao', 'shuang')
        # 断言：name 与 'Xiao Shuang' 是否相等
        self.assertEqual(name, 'Xiao Shuang')

    # 以 test_ 开头，自动运行
    def test_first_middle_last_name(self):
        name = get_name('zheng', 'shuang', 'xiao')
        # 断言：name 与 'Zheng Xiao Shuang' 是否相等
        self.assertEqual(name, 'Zheng Xiao Shuang')


# 判断当前文件是否作为主程序执行，若是，则__name__ 被设置为'__main__'
if __name__ == '__main__':
    unittest.main()

3. 数据可视化

前提
需下载 python包 matplotlib，plotly

!!!默认是不能加中文标签的，以下两行使得中文标签可用

from pylab import *
mpl.rcParams['font.sans-serif'] = ['SimHei']

还需注意代码使用位置，应在使用中文前，表格布置后（样式之类的）

基础绘图

折线图

# 导入模块 pyplot并命名为 plt
from pylab import *
import matplotlib.pyplot as plt

input_values = [1, 2, 3, 4, 5]
squares = [1, 4, 9, 16, 25]

# 使用样式(这个好看)
plt.style.use('bmh')

# fig表示整张图片，ax表示图片中的各个图表
# 大多数情况要使用
fig, ax = plt.subplots()
# 根据给定数据以有意义的方式绘制图表，linewidth决定了绘制线条的粗细(x轴、y轴)
ax.plot(input_values, squares, linewidth=3)

mpl.rcParams['font.sans-serif'] = ['SimHei']

# 设置图表标题并给坐标轴加上标签(下面都是方法)，fontsize决定了图表中文字大小
ax.set_title("平方数", fontsize=24)
ax.set_xlabel("值", fontsize=14)
ax.set_ylabel("值的平方", fontsize=14)

# 设置刻度标记的大小，axis='both' 同时影响 x和 y轴，labelsize决定刻度标记字号
# colors='gold' 默认为黑色，可以自定义（这里是坐标轴上的字体）
ax.tick_params(axis='both', labelsize=14, color='gold')
# 显示绘制的图表
plt.show()

散点图

# 详细解说见折线图
from pylab import *
import matplotlib.pyplot as plt

# 自动计算
x_values = range(1, 1001)
y_values = [x**2 for x in x_values]

plt.style.use('bmh')
fig, ax = plt.subplots()

# 绘制点(s：设置点的尺寸)
# 参数c：设置点的颜色，可以直接用英文，也可以用 RGB模式定义，范围为 0~1（绿色好看）
# 颜色映射：颜色由浅变深，格式见下
ax.scatter(x_values, y_values, c=y_values, cmap=plt.cm.Blues, s=10)

mpl.rcParams['font.sans-serif'] = ['SimHei']

ax.set_title("平方数", fontsize=24)
ax.set_xlabel("值", fontsize=14)
ax.set_ylabel("值的平方", fontsize=14)
# which 有三个参数：'major'、'minor'、'both'（主、副刻度线）
ax.tick_params(axis='both', which='major', labelsize=14, colors='gold')
# 设置坐标轴的取值范围（先是x轴，再是y轴）
ax.axis([0, 1100, 0, 1100000])

# 将显示的 plt.show()改为自动保存 plt.savefig()
# 图片保存到当前文件所在目录，自定义文件名;
# bbox_inches='tight'：将多余空白区裁剪掉（直接加在括号里）
plt.savefig('平方数.jpg')

条形图

from random import randint
from plotly.graph_objs import Bar, Layout
from plotly import offline

# 创建一个含随机元素的列表
lis = []
for num in range(1000):
    x = randint(0, 11)
    lis.append(x)
# 统计数据
fres = []
for n in range(0, 11):
    fre = lis.count(n)
    fres.append(fre)

# 可视化
x_values = list(range(1, 11))
data = [Bar(x=x_values, y=fres)]
x_axis_config = {'title': '结果', 'dtick': 1}
y_axis_config = {'title': '结果的频率'}
my_layout = Layout(title='随机数生成', xaxis=x_axis_config, yaxis=y_axis_config)
offline.plot({'data': data, 'layout': my_layout}, filename='random_num.html')

掷骰子实例

形成交互式界面

from plotly.graph_objs import Bar, Layout
from plotly import offline

from die import Die

# 两个骰子
die_1 = Die()
die_2 = Die()
results = []
for roll_number in range(1000):
    result = die_1.roll() + die_2.roll()
    results.append(result)

# 分析结果
frequencies = []
for value in range(2, die_1.num_sides+die_2.num_sides+1):
    frequency = results.count(value)
    frequencies.append(frequency)

# 对结果进行可视化
x_values = list(range(2, die_1.num_sides+die_2.num_sides+1))
# Bar类用于绘制条形图(数据)
data = [Bar(x=x_values, y=frequencies)]
# dtick：指定了 x轴的刻度间距并显示
x_axis_config = {'title': '结果', 'dtick': 1}
y_axis_config = {'title': '结果的频率'}
my_layout = Layout(title='掷两个六面骰子1000次的结果', xaxis=x_axis_config, yaxis=y_axis_config)
offline.plot({'data': data, 'layout': my_layout}, filename='d6_d6.html')

调用的函数(die)

from random import randint


class Die:
    """表示一个骰子的类"""

    def __init__(self, num_sides=6):
        # 默认6面
        self.num_sides = num_sides

    def roll(self):
        return randint(1, self.num_sides)