全网最详细超长python学习笔记、14章节知识点很全面十分详细，快速入门，只用看这一篇你就学会了！

相关文章：

全网最详细超长python学习笔记、14章节知识点很全面十分详细，快速入门，只用看这一篇你就学会了！

【1】windows系统如何安装后缀是whl的python库

【2】超级详细Python-matplotlib画图，手把手教你画图！（线条颜色、大小、线形、标签）

【3】超级详细matplotlib使用教程，手把手教你画图!(多个图、刻度、标签、图例等)

【4】python读写文件操作---详细讲解！

python入门合集：

python快速入门【一】-----基础语法

python快速入门【二】----常见的数据结构

python快速入门【三】-----For 循环、While 循环

python快速入门【四】-----各类函数创建

python快速入门【五】---- 面向对象编程

python快速入门【六】----真题测试

python学习笔记 jupyter notebook教学，14章节知识点很全面十分详细。

注意事项：本博客是我早起自己写的python笔记word版本，现在转成博客形式，由于ipython文件找不到了，很多代码都会以图片形式出现，不过放心不影响学习，对于比较长的程序例子我回重新贴好代码放入。

python笔记+代码下载地址：https://download.csdn.net/download/sinat_39620217/16658064

DLE （Integrated Development and Learning Environment）集成开发与学习环境

编辑器 交互模式---指令直接反馈

编辑器—new file

修改编辑器字体：Options ---  configure  IDLE 

Alt+p 重复上面输入  Alt+n，获取下一部分代码    ctrl+c 终止，整体缩进：tab    整体取消缩进：tab+shift，整体缩进 Ctrl+【 整体取消缩进 Ctrl+】。

1.变量名

py3.7中文可以当作变量名

#引入第三变量
#引用第三变量
X=3
Y=5
x,y=y,x
Print(x,y)

2.字符串

①单引号和双引号----基本差别

.单引号（双引号）用于引用； 转义字符

print("\"let\'s,go\"")
#"let's,go"---------------------转义字符保证引号无别的含义
#显示路径：
Print（d:\\das\\dasd\\das\\now）#---反斜杠转义反斜杠

②原始字符串：

print(r"d:dasd\dasda\gdf")     #加r 为原始字符串，及后面字符无含义

#d:dasd\dasda\gdf

字符串相加===字符串拼接：

>>> first_name=("abc")
>>> last_name=("efg")
>>> full_name=first_name+" "+last_name
>>> print(full_name)
abc efg

乘法----代表复制

3.修改字符串大小写等

>>> name=('asd love')
>>> print(name)
asd love
>>> print(name.title()) #只把首字母变大写
Asd Love

>>> print(name.upper()) #全部变大写
ASD LOVE

删除空白：
>>> massge=("python   ")
>>> massge.rstrip()    #删除末尾空白
'python'
>>> massge=("    python   ")
>>> massge.lstrip()          #删除前面的空白
'python

其中：函数：Str（） 转为字符串

3.Game：基础语法测试程序：

"""python game"""
import random

count=10   #猜三次
answer=random.randint(1,10) #生成随机数

while count > 0:
    temp = input("猜猜数字")
    guess =int(temp)
    if guess == answer:
        print("right")
        break
    else:
        if guess < answer:
            print("小了")
        else:
            print("大了")
    count-=1    #py没有自增自减
print("end")

随机数状态：Random.getstate()  random.setstate()获得原来的数字

 

4.数字类型

浮点数精度有误差0.1+0.2=0.30000004 ；

• Decimal 十进制模块

decimal.Dicimal(‘’)

保证计算正确性。

• 运算

//[向下去整]     3/2=1；     -3/2=-2地板除

取余%

divmod()  直接求得 取余和取商（//）
divmod(3，2)得（1，1）
dicmod(-3,2)得（-2,1）
int(3.14)=3  不是四舍五入
complex(“1+2j”)复数；
1e6 十的六次方  2e6:2十的六次方
Pow(x,y)计算x的y次方
X**y 计算x的y次方
其中：pow（x,y,z）==x**y%z

• 布尔类型

Bool（）false true

定义为false对象：none和false

         值为零的数字类型：0，0.0，0J,decimal(0),fraction(0,1)

         空的序列和集合：’’.[],{},set(),range(0)

True==1,false==0;

>>>3and4
4
>>>4or3
4
>>> "123" and "456 '
456
>>> " 123 and 345
345
>>>

除了逻辑运算，数值也可以

>>>(not1)or(0and1)or(3and4)or(5and6)or(7and8and9)
4

短路逻辑：从左往右，只有当第一个操作数的值无法确定逻辑运算的时候，才对第二个数进行求值
And 右边结果最终影响逻辑结果，3为true  4也为true 取4   or 第一个为4时就已经判断；
O or 3  ==3  o and 3==0（and两个都为真为true；or两个都为假为假 ）
not 1 or 0 and 1 or 3 and 4 and 5 and 6
6
优先级 not > and >or
not 1 or 0 and 1 or 3 and 4 or 5 and 6 or 7 and 8 and 9 ---------------4
小括号内容：False  0  4  6  9
因为是or  到4
得4

5.列表

①列表normal：

①列表normal：
>>> list = ["a","b","c","d"]   #构建列表
>>> print(list)
['a', 'b', 'c', 'd']
>>> print(list[0])   #找到列表中第一个元素
a
>>> print(list[0].title())   #首字母变大写
A
修改列表值：直接赋值
		>>> list[0]="A"
>>> print(list)                                  ②massage=[]
['A', 'b', 'c', 'd']                                   massage.append("a")
在列表末尾添加元素：①list.append("e")                      massage.append("b")
>>> print(list)                          massage.append("c")
['A', 'b', 'c', 'd', 'e']             print---['a', 'b', 'c']  #不断为空列表添加内容
在列表中插入元素：
                  massage.insert(0,"a")       ['a', 'a', 'b', 'c']    位置+内容化 insert
在列表中删除元素：>>> ①del massage[0]     #删除位置下标
>>> print(massage)
['a', 'b', 'c']
Pop()删除末尾元素  ②>>> massage=["a","b","c"]
>>> poped_massage=massage.pop()
>>> print(massage)                #pop删除的元素，可以调用
['a', 'b']
>>> print(poped_massage)
C                         #并且每使用一次pop，都会删除最后一个。如下：
>>> print(massage.pop())
b
>>> print(massage)
['a']

弹出列表任意位置元素：

根据值删除元素：

②组织列表

Sort()对列表进行永久性排序
                        >>> list=["aa","cc","bb"]
>>> list.sort()               #按字母排序，不能恢复
>>> print(list)
['aa', 'bb', 'cc']
>>> list=["aa","cc","bb"]
>>> list.sort(reverse=True)  相反打印排序；
>>> print(list)
['cc', 'bb', 'aa']
Sorted()临时排序
>>> list=["aa","cc","bb"]
>>> print(sorted(list))    对原序列不产生影响
['aa', 'bb', 'cc']
Reverse（）倒着打印

③操作列表

①遍历整个列表：

在for循环内可以进行别的·操作

②数值列表：
⑴>>> for value in range(1,5):
	print(value)           #打印1—n-1

⑵>>> num =list(range(1,6))
>>> print(num)
[1, 2, 3, 4, 5]
>>> num =list(range(1,8,2))   #步进为二
>>> print(num)
[1, 3, 5, 7]

⑶squars = []
for value in range(1,11):
	squar = value**2
	squars.append(squar) #添加到末尾         squars.append(value**2)
print(squars)
max(),sum(),min()等进行计算
④	列表解析
>>> nun=[value**2 for value in range(1,11)]
>>> print(nun)
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

④部分元素——切片等

• 切片

0---n-1个

索引数组，【：，4】则把前面四个打印出来
 【2：】则打印第二个开始的所有后面
players =["aa","bb","cc","dd"]
print(players[-2:])              ['cc', 'dd'] -2也可以打印出后面两个
②	遍历切片
players =["aa","bb","cc","dd"]
for player in players[:2]:           #遍历切片打印出前两个   没有切片则遍历全部全部列表。
        print(player)
③	复制列表
players =["aa","bb","cc","dd"]
num=players[:]     #即复制列表
print(num)
players.append("ee")  #后面添加新元素
num.append("ff")
④	定义元组

• 定义元组

元组小括号采用复制的方法修改；遍历所有值

6.If条件

cars=["audi","bmw","aubaru","toyota"]
for car in cars:
    if car=="bmw":
        print(car.upper())
    else :
        print(car.title())
大小写不相等，也会不相等
条件判断不相等！=，and or的使用；
①	检查特定值是否在列表中：

 in  

If elif else ；

可以多个elif，  数值转换str；

都加冒号：·， else可以等价为elif中条件最后一个的填入即可

7.字典

①alien={'color':'green','point':'5'}#键color 值green
print(alien['color'])

也可以在空白alien｛｝添加

修改字典中的值---直接赋值覆盖

   

alien={'color':'green','point':'5'}#键color 值green
del alien['point']
print(alien)            删除的键值永远消失

• 遍历字典键值（一对）

 声明两个变量  items返回一个键值对

遍历所有键  遍历所有值

找出列表中独一无二的元素，并使用这些元素创建一个新的列表等

• 嵌套，字典列表

切片显示

前三个参数修改字典中存储列表

字典嵌套字典

8.input&while

message=input("输入")

print(message)

输入打印前缀处理

• 让用户选择合适退出：

 

• 标志 true来标志程序运行状态

②	标志 true来标志程序运行状态
prompt="\n输入信息"
prompt+="\n信息为："
active=True        #使用标志
while active:
    message=input(prompt)
    if message=="quit":
            active=False
    else:
        print(message)      break

 打印奇数

删除列表中特定值：

用户输入填充字典

9.函数定义

①简单的定义：
①def guess():
    print("name")
guess()   输出name

• 关键字实参（顺序注意）

def describ_name(fist,last):
    print('name is '+last)
    print('baibia is '+fist)
    #因为是字符串，输出写上字符串
describ_name('asd','fsd')
#为了保证参数顺序，
describ_name(fist="asd",last="fsd")    默认值
等效的函数调用：

   

def get_name(first,last,middle_name=''):
        if middle_name:
            full_name=first+' '+middle_name+' '+last
        else:
            full_name=first+' '+last
        return full_name.title()
 message=get_name('ab','cd')
print(message) #返回值
message=get_name('ab','cd','bb')
print(message)      #可选实参

②返回值
   def get_name(first,last,middle_name=''):
        if middle_name:
            full_name=first+' '+middle_name+' '+last
        else:
            full_name=first+' '+last
        return full_name.title()
 message=get_name('ab','cd')
print(message) #返回值
message=get_name('ab','cd','bb')
print(message)      #可选实参
返回字典：
def get_name(first_name,last_name):
    """构建一个返回字典，包含个人信息"""
    person={'first':first_name,'last':last_name}
    return person
message=get_name('ab','cd')
print(message) #返回值

循环+函数，用户输入：→→→→（2192）

10.传递列表：

①函数中修改列表，

"""信息存储在一个列表中，打印后移到另一个列表中"""
"""不使用函数模拟过程"""
un_desigins=["iphone","robot","unkonow"]
completed_models=[]
#模拟打印每个列表内容，全部打印完结束；
#打印原列表内容后转移到列表complete_models中
while un_desigins:
    cunrrent_design=un_desigins.pop()
    print("model"+":"+cunrrent_design)
    completed_models.append(cunrrent_design)
#显示所有信息
print("\nthe following models")
for completed_model in completed_models:
    print(completed_model)

model:unkonow
model:robot
model:iphone

the following models
unkonow
robot
iphone

def print_models(un_designs,complete_design):
    """打印并复制列表到下一个列表中"""
    while un_desigins:
        cunrrent_design=un_desigins.pop()
        print("model"+":"+cunrrent_design)
        completed_models.append(cunrrent_design)

def show_models(completed_models):
    print("\nthe following models")
    for completed_model in completed_models:
        print(completed_model)

un_desigins=["iphone","robot","unkonow"]
completed_models=[]

print_models(un_desigins,completed_models)
show_models(completed_models)

model:unkonow
model:robot
model:iphone

the following models
unkonow
robot
iphone

②传递任意数量实参

def make_pizza(price,*toppings):  #*创建一个topping的空元组
    """打印顾客菜单配料"""
    i=0
    for topping in toppings:
        i+=1
        print('价格'+str(price)+","+"配料"+" "+str(i)+" "+topping)

make_pizza(16,"meat","beaf","sala")

('meat',)
('sala',)

def make_pizza(*toppings):  #*创建一个topping的空元组
    """打印顾客菜单配料"""
    i=0
    for topping in toppings:
        i+=1
        print("配料"+" "+str(i)+" "+topping)
make_pizza("meat","beaf","sala")

配料 1 meat
配料 2 beaf
配料 3 sala

def make_pizza(price,*toppings):  #*创建一个topping的空元组
    """打印顾客菜单配料"""
    i=0
    for topping in toppings:
        i+=1
        print('价格'+str(price)+","+"配料"+" "+str(i)+" "+topping)

make_pizza(16,"meat","beaf","sala")

价格16,配料 1 meat
价格16,配料 2 beaf
价格16,配料 3 sala

③使用任意数量的关键字实参

def build_profile(first,last,**user_info):
    """创建字典，包含用户所有信息"""
    profile={}
    profile["first_name"]=first
    profile["last_name"]=last
    for key,value in user_info.items():
        profile[key]=value
    return profile
user_profile=build_profile("asd","qwe",
                          location="beijing",
                          field="pysicis")
print(user_profile)

{'first_name': 'asd', 'last_name': 'qwe', 'location': 'beijing', 'field': 'pysicis'}

④导入文件
①Import xxx  #文件 可以再Python vs都行
Demo：
Import pizza     #可以调用def 的文件里所有函数
Pizza.make_pizaa(xxxxxx)  需要模块模块名

②导入特定的函数
Form pizza import make_pizza
make_pizaa(xxxxxx)   不需要指定模块名了

③把指定调用函数函数名-----自己命名调用
Form pizza import make_pizza  as  mp
mp(xxxx)

④	给模块命名
Import  pizza as p

11.类 面相对象编程

①类创建以及属性值等

#创建小狗类别 dog
#包括名字+年龄 行为：蹲下+打滚
#创建类
class Dog():     #首字母大写就是类
    def __init__(self,name,age):   #两个下划线  __init__方法，初始化变量  self在其他形参前面
        """初始化"""
        self.name=name           #通过传递姓名+年龄，self会自动传递
        self.age=age
        #以SELF为前缀的昂量可以供类中变量所有方法使用
        #获取存贮在形参name中的值，并将其存储到变量name中，变量会被关联到当前创建实例
    def sit(self):
        """模拟小狗蹲下"""
        print(self.name.title()+"小狗下蹲")
    def roll_over(self):
        """模拟小狗蹲下"""
        print(self.name.title()+"小狗打滚")
my_dog=Dog("blue",4)
print("my dog is"+" "+my_dog.name.title())
print("my dog is"+" "+str(my_dog.age)+" "+"years old")
my_dog.sit()
my_dog.roll_over()

my dog is Blue
my dog is 4 years old
Blue小狗下蹲
Blue小狗打滚

汽车例子

#创建一个表示汽车的类，存储汽车的信息，还有一个汇总这些信息的方法   get_descriptive_name
class Car():
        def __init__(self,make,model,year):
                        """初始化汽车属性"""
                        self.make=make
                        self.model=model
                        self.year=year
                        self.odometer=0
        def get_descriptive_name(self):
            """返回信息描述"""
            long_name=str(self.year)+" "+self.model+" "+self.make
            return long_name.title()
        def read_odometer(self):
            """打印里程数"""
            print("this car is "+str(self.odometer)+" km")

        def update_odometer(self,odo):
            """修改里程数值"""              #2通过方法修改里程值，
            if odo>=self.odometer:
                self.odometer=odo
            else:
                print("你不可以更改")

my_newcar=Car("audi","a4",2018)
print(my_newcar.get_descriptive_name())
#1.直接修改属性值
my_newcar.odometer=23
my_newcar.update_odometer(24)
my_newcar.read_odometer()
    

2018 A4 Audi
this car is 24 km

#创建一个表示汽车的类，存储汽车的信息，还有一个汇总这些信息的方法   get_descriptive_name
class Car():
        def __init__(self,make,model,year):
                        """初始化汽车属性"""
                        self.make=make
                        self.model=model
                        self.year=year
                        self.odometer=0
        def get_descriptive_name(self):
            """返回信息描述"""
            long_name=str(self.year)+" "+self.model+" "+self.make
            return long_name.title()
        def read_odometer(self):
            """打印里程数"""
            print("this car is "+str(self.odometer)+" km")

        def update_odometer(self,odo):
            """修改里程数值"""              #2通过方法修改里程值，
            if odo>=self.odometer:
                self.odometer=odo
            else:
                print("你不可以更改")
        def increase_odometer(self,miles):
            """增加制定里程读数"""    #3.通过方法对属性的值进行递增
            self.odometer+=miles

my_newcar=Car("audi","a4",2018)
print(my_newcar.get_descriptive_name())
#1.直接修改属性值
my_newcar.odometer=10
my_newcar.read_odometer()
my_newcar.update_odometer(20)
my_newcar.read_odometer()
my_newcar.increase_odometer(30)
my_newcar.read_odometer()

2018 A4 Audi
this car is 10 km
this car is 20 km
this car is 50 km

修改属性的值三种方法

1. 直接修改属性
2. 通过方法修改属性值
3. 通过方法对属性的值进行递增

②继承

1.原有类为父类，新类为子类

#创建一个表示汽车的类，存储汽车的信息，还有一个汇总这些信息的方法   get_descriptive_name
class Car():
        def __init__(self,make,model,year):
                        """初始化汽车属性"""
                        self.make=make
                        self.model=model
                        self.year=year
                        self.odometer=0
        def get_descriptive_name(self):
            """返回信息描述"""
            long_name=str(self.year)+" "+self.model+" "+self.make
            return long_name.title()
        def read_odometer(self):
            """打印里程数"""
            print("this car is "+str(self.odometer)+" km")

        def update_odometer(self,odo):
            """修改里程数值"""              #2通过方法修改里程值，
            if odo>=self.odometer:
                self.odometer=odo
            else:
                print("你不可以更改")
        def increase_odometer(self,miles):
            """增加制定里程读数"""    #3.通过方法对属性的值进行递增
            self.odometer+=miles

class EletricCar(Car):     #继承父类 Car
    def __init__(self,make,model,year):
        """初始化父类属性"""
        super().__init__(make,model,year)  #super使父类子类关联起来
my_car=EletricCar("bmw","model2",2020)
my_car.get_descriptive_name()

'2020 Model2 Bmw'

2.给子类定义属性和方法

3.重写父类（在子类写相同的类）

！子类和父类def 相同则只会运行子类的定义函数函数

4.将实例用作属性----把属性放到另外一个类中---重新定类

电瓶续航补充

注意实例作为属性的调用

完整代码：

#创建一个表示汽车的类，存储汽车的信息，还有一个汇总这些信息的方法   get_descriptive_name
class Car():
        def __init__(self,make,model,year):
                        """初始化汽车属性"""
                        self.make=make
                        self.model=model
                        self.year=year
                        self.odometer=0
        def get_descriptive_name(self):
            """返回信息描述"""
            long_name=str(self.year)+" "+self.model+" "+self.make
            return long_name.title()
        def read_odometer(self):
            """打印里程数"""
            print("this car is "+str(self.odometer)+" km")

        def update_odometer(self,odo):
            """修改里程数值"""              #2通过方法修改里程值，
            if odo>=self.odometer:
                self.odometer=odo
            else:
                print("你不可以更改")
        def increase_odometer(self,miles):
            """增加制定里程读数"""    #3.通过方法对属性的值进行递增
            self.odometer+=miles

class Battery():    #无继承
        def __init__(self,battery_size=70):
            self.battery_size=battery_size
            """初始化属性"""
        def describe_battery(self):
            """打印描述电瓶容量信息"""    #将实例放到新的
            print("电池 "+str(self.battery_size)+" kwh")
        def get_range(self):
            """打印电瓶续航里程"""
            if self.battery_size==70:
                range=240
            elif self.battery_size==85:
                range=270
            message="this car can go approximately "+str(range)
            message+="miles on a full charge"  #不上语句
            print(message)           

class EletricCar(Car):     #继承父类 Car
        def __init__(self,make,model,year):
            """初始化父类，在初始化子类"""
            super().__init__(make,model,year)
            self.battery=Battery()       #电池,子类属性

        def increase_odometer(self,miles):
                """增加制定里程读数"""    #3.通过方法对属性的值进行递增
                self.odometer+=miles*10

my_car=EletricCar("bmw","model2",2020)
print(my_car.get_descriptive_name())
my_car.battery.describe_battery()
my_car.battery.get_range()

2020 Model2 Bmw
电池 70 kwh
this car can go approximately 240miles on a full charge

12.Vs code文件导入以及异常处理

基础配置完成后：

绝对路径时：

会报错，

斜杠反方向   rstrip删除末尾空白

读取每一行：

Or

判断内容有无在文件text中：

写入文本中：

file_path='C:/Users/Administrator/Desktop/py_demo/test_files/kong.txt'
with open(file_path,'w') as file_object:
    file_object.write("i love you \n")
    file_object.write("you \n")
with open(file_path,'a') as file_object:   #附加到文本里 add
    file_object.write("i love you \n")
    file_object.write("you \n")

检验代码：

文件不存在提示：

一个字符串分割成字符串数组

json

文件加载：

加载不存在信息

import json

file="numbers.json"
try:
    with open(file) as file_json:
        username=json.load(file_json)
except FileNotFoundError:
    username=input("you name\n")
    with open(file,"w")  as file_json:
        json.dump(username,file_json)
        print("加载成功")
else:
    print("see you"+str(username))
#json.load加载储存在numbers.json文件内容

13文件测试

测试函数

①测试文件是否能通过：

显示ok则测试通过，

assertEqual   核实a==b    unittest测试，创建类

②demo

结果

测试多个答案的，确保每个答案都在my_survey.reponses

Srtup创建例子供测试调用

14.项目实战

①生成折线图：

x.ylabel 在下面散点图中绘制修复了

原因：可能之前运行，变量或者参数erro导致的，重新构建即可

②散点图—渐变色

生成多个点数据

颜色设置

plt.scatter(x_values,y_values,c='red',s=40)  RGB模式：c=(0,0,0.8)  蓝的，RGB 色彩模式默认采用小数值

颜色映射，Plt.cm

保存在文件图片指令。

项目三-随机漫步

#模拟随机漫步
from random import choice
#choice 返回非空序列里的随机元素
class RandomWalk():
    """生成随机漫步数的类"""
    def __init__(self,num_points=5000):
        self.num_points=num_points
        #所有随机漫步都始于(0,0)
        self.x_value=[0]   #FIXME: 标识处代码需要修正，甚至代码是错误的
        self.y_value=[0]  #TODO:标识处有功能代码待编写

    def fill_walk(self):
        #不断漫步，直到达到表达指定长度
        while len(self.x_value)<self.num_points:

            #决定前进方向以及沿着这个方向前进的距离
            x_direction=choice([-1,1])
            x_distance=choice([0,1,2,3,4])
            x_step=x_direction*x_distance
            #choice([0, 1, 2, 3, 4]) 随机地选择一个0~4之间的整数
            y_direction=choice([-1,1])
            y_distance=choice([0,1,2,3,4])
            y_step=y_direction*y_distance

            #拒绝原地踏步
            if x_step==0 and y_step==0:
                continue
            #计算下一个点的x和y值
            next_x=self.x_value[-1]+x_step  #将x_step x_value最后值相加
            next_y=self.y_value[-1]+y_step

            self.x_value.append(next_x)
            self.y_value.append(next_y)

进阶版：

效果：

import matplotlib.pyplot as plt
#import matplotlib as mpl
import numpy as np
from submanbu import RandomWalk

while True:

    rw=RandomWalk(50000)  #自己设置点数5w.原来为5k
    rw.fill_walk()
    #设置绘图窗口的尺寸n
    #分辨率128,dpi 确定了图形每英寸包含的像素数，图形尺寸相同的情况下， dpi 越高，则图像的清晰度越高
    plt.figure(dpi=128,figsize=(10,6))
    #给数据点着色,渐变色无轮廓-----------cmap=plt.cm.Blues 大写颜色,这个erro不用管
    point_number=list(range(rw.num_points))
    plt.scatter(rw.x_value,rw.y_value,c=point_number,cmap=plt.cm.Blues,edgecolors="none",s=1)
    #突出起点和终点
    plt.scatter(0,0,c="green",edgecolors="none",s=50)
    plt.scatter(rw.x_value[-1],rw.y_value[-1],c="red",edgecolors="none",s=50)

    #隐藏坐标轴
    plt.axes().get_xaxis().set_visible(False)
    plt.axes().get_yaxis().set_visible(False)
    plt.show()

    keep_running=input("make another walk?(y/n): ")
    if keep_running=='n':
        break
    #(看终端处，当图片被关闭，就会询问是否再次模拟漫步，需要保存)
    #无法在编辑中操作，去setting中设置run code config，保存即可

四掷骰子可视化

• 一个骰子：基础版

from random import randint
#导入函数randint可以返回（a,b）范围内的数
class Shaizi():
    """一类骰子"""
    def __init__(self,num_sudes=6):
        #骰子有6面
        self.num_sudes=num_sudes
    def roll(self):
        #返回一个位于1和骰子面熟之间的随机值
        return randint(1,self.num_sudes)

Svg文件浏览器可以打开

• 两个骰子

import pygal
from shaizi import Shaizi

#创建一个D6 6面骰子
shaizi_1=Shaizi()
shaizi_2=Shaizi(10)

#投几次并将结果存储在一个列表中
results=[]
for roll_num in range(1000):
    result=shaizi_1.roll()+shaizi_2.roll()
    results.append(result)

#分析结果频率
frequencies=[]
max_result=shaizi_1.num_sudes+shaizi_2.num_sudes
for value in range(2,max_result+1):
    frequency=results.count(value) #计算每种点数在结果中出现次数
    frequencies.append(frequency)

#可视化列表,直方图
hist=pygal.Bar()

hist.title=("Biao ti")
hist.x_labels=["2","3","4","5","6","7","8","9","10","11","12","13","14","15","16"]
hist.x_title=("reslt")
hist.y_title=("numbers")

hist.add("shuaizi:6+10",frequencies) #add传递图表值，将图表渲染为svg文件
hist.render_to_file("shuaizi_visual.svg")

"""
    range(start, stop[, step])
    start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
    stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
    step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
    

Svg文件浏览器可以打开

至此教程全部结束，辛苦学习了！