Merge branch 'master' of github.com:shao1chuan/pythonbook

Python 基础教程/1.10.1 C面向对象vs面向过程2.py

@@ -0,0 +1,25 @@
+def carI(type,price):
+    print(f"the type is: {type} and the price is: {price} ")
+carI('aaa',12)
+
+def drive(now,drive):
+    print(f"you drive {now+drive} miles")
+drive(12,23)
+
+
+class carI():
+    def __init__(self,type,price):
+        self.type = type
+        self.price = price
+        self.dis = 0
+    def drive(self,dis):
+        self.dis +=dis
+    def showprice(self):
+        self.price = self.price -self.dis*10
+        return self.price
+
+a = carI('aa',12000)
+print(a.showprice())
+
+a.drive(100)
+print(a.showprice())

Python 基础教程/1.10.8 练习.py

@@ -0,0 +1,50 @@
+# 需求：
+# 房子(House)有户型、总面积和家具名称列表
+# 新房子没有任何的家具
+# 家具(HouseItem)有名字和占地面积，其中
+# 席梦思(bed)占地4平米
+# 衣柜(chest)占地2平米
+# 餐桌(table)占地1.5平米
+# 将以上三件家具添加到房子中：
+# 打印房子时，要求输出：户型、总面积、剩余面积、家具名称列表
+# 剩余面积
+# 在创建房子对象时，定义一个剩余面积的属性，初始值和总面积相等
+# 当调用add_item方法，向房间添加家具时，让剩余面积-=家具面积
+# 思考：应该先开发哪一个类？
+
+class House:
+    def __init__(self,type,area):
+        self.type = type
+        self.area = area
+        self.fl = []
+        self.left = area
+    def show(self):
+        ss = f"the type is {self.type}, and the area is {self.area}, 剩余的面积是{self.left},家具是{self.fl}"
+        for i in self.fl:
+            print (i)
+        return ss
+
+    def add(self,h):
+        self.left -=h.area
+        self.fl.append(h)
+class HouseItem:
+    def __init__(self,name,area):
+        self.name = name
+        self.area = area
+    def __str__(self):
+        return f"{self.name}的占地面积是：{self.area}"
+
+bed = HouseItem("aa",4)
+chest = HouseItem("bb",2)
+table = HouseItem("cc",1.5)
+print(table.name)
+
+h = House("big",4000)
+h.add(bed)
+h.add(chest)
+h.add(table)
+
+print(h.show())
+
+
+

Python 基础教程/1.10.9.2 类属性的应用场景.py

@@ -0,0 +1,16 @@
+# 我们有一个班级类，创建班级对象的时候，需要按序号指定班级名称，
+# 我们就需要知道当前已经创建了多少个班级对象，这个数量可以设计成类属性
+
+class EduClass:
+    class_num = 0
+    price = "11111111111"
+    def __init__(self):
+        self.class_name = f'Python{EduClass.class_num+1}班'
+        EduClass.class_num += 1
+        self.price = "222222222"
+
+
+classList = [EduClass() for i in range(10)]
+for c in classList:
+    del c.price
+    print(c.class_name,c.price)

Python 基础教程/1.10.9.3 类方法.py

@@ -0,0 +1,36 @@
+# 类对象所拥有的方法，需要用修饰器@classmethod来标识其为类方法，
+# 对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数
+# （当然可以用其他名称的变量作为其第一个参数，但是大部分人都习惯以'cls'作为第一个参数的名字），
+# 能够通过实例对象和类对象去访问。
+
+class people:
+    country="china"
+
+    @classmethod
+    def getCountry(cls):
+        return cls.country
+    @classmethod
+    def setCountry(cls,country):
+        cls.country=country
+
+
+p=people()
+print(p.getCountry())   #实例对象调用类方法
+print(people.getCountry())  #类对象调用类方法
+
+p.setCountry("Japan")
+
+print(p.getCountry())
+print(people.getCountry())
+
+# 需要通过修饰器@staticmethod来进行修饰，静态方法不需要定义参数
+class people3:
+    country="china"
+
+    @staticmethod
+    def getCountry():
+        return people3.country
+
+p=people3()
+print(p.getCountry())   #实例对象调用类方法
+print(people3.getCountry())  #类对象调用类方法

Python 基础教程/1.11.1 异常.py

@@ -0,0 +1,41 @@
+try:
+    num = int(input("请输入整数："))
+    result = 8 / num
+    print(result)
+except ValueError:
+    print("请输入正确的整数")
+except ZeroDivisionError:
+    print("除 0 错误")
+except Exception as result:
+    print("未知错误 %s" % result)
+else:
+    # 没有异常才会执行的代码
+    print('没有异常才会执行的代码')
+    pass
+finally:
+    # 无论是否有异常，都会执行的代码
+    print("无论是否有异常，都会执行的代码")
+
+
+
+# try:
+#     # 尝试执行的代码
+#     pass
+# except 错误类型1:
+#     # 针对错误类型1，对应的代码处理
+#     pass
+# except 错误类型2:
+#     # 针对错误类型2，对应的代码处理
+#     pass
+# except (错误类型3, 错误类型4):
+#     # 针对错误类型3 和 4，对应的代码处理
+#     pass
+# except Exception as result:
+#     # 打印错误信息
+#     print(result)
+# else:
+#     # 没有异常才会执行的代码
+#     pass
+# finally:
+#     # 无论是否有异常，都会执行的代码
+#     print("无论是否有异常，都会执行的代码")

Python 基础教程/1.11.2 自主抛出异常.py

@@ -0,0 +1,21 @@
+def input_password():
+
+    # 1\. 提示用户输入密码
+    pwd = input("请输入密码：")
+
+    # 2\. 判断密码长度，如果长度 >= 8，返回用户输入的密码
+    if len(pwd) >= 8:
+        return pwd
+
+    # 3\. 密码长度不够，需要抛出异常
+    # 1> 创建异常对象 - 使用异常的错误信息字符串作为参数
+    ex = Exception("密码长度不够")
+
+    # 2> 抛出异常对象
+    raise ex
+
+try:
+    user_pwd = input_password()
+    print(user_pwd)
+except Exception as result:
+    print("发现错误：%s" % result)

Python 基础教程/1.14 package/syu/module1.py

@@ -0,0 +1,2 @@
+def output():
+    print('hello syu')

Python 基础教程/1.5.2 商品买卖练习.py

@@ -0,0 +1,24 @@
+# 列表综合练习 写一个循环，不断的问用户想买什么，用户选择一个商品编号，
+# 就把对应的商品添加到购物车里，最终用户输入q退出时，打印购物车里的商品列表
+l1 = [['a',23],['b',34],['c',33],['d',345]]
+l2 = []
+print("商品列表****************")
+for (index, i) in enumerate(l1):
+    print(f"商品{index}，价格为{i}")
+while True:
+
+    choise = input("请输入你选择的商品编号：")
+    if choise.isdigit():
+        if int(choise) in range(len(l1)) :
+            print("你选择的是{}".format(choise))
+            l2.append(l1[int(choise)])
+            print(l2)
+        else:
+            print("你选的商品不在列表中")
+    elif choise == 'q':
+        break
+
+if len(l2)>0:
+    print("你选的商品如下：")
+    for index,i in enumerate(l2):
+        print("商品编号{},商品名称{}，商品价格{}".format(index,i[0],i[1]))

Python 基础教程/1.5.2 商品买卖练习2.py

@@ -0,0 +1,25 @@
+# 列表综合练习 写一个循环，不断的问用户想买什么，用户选择一个商品编号，
+# 就把对应的商品添加到购物车里，最终用户输入q退出时，打印购物车里的商品列表
+l1 = [['a',23],['b',34],['c',33],['d',345]]
+l2 = []
+print("商品列表****************")
+for  i in l1:
+    print(f"商品{i[0]}，价格为{i[1]}")
+
+while True:
+    name = input("输入商品名称：")
+    if  name!="q":
+        for bb in l1:
+            if name==bb[0]:
+                print(f"你选择的是{name}")
+                l2.append(bb)
+                break
+        else:
+            print("你选择的没有再列表中")
+    else:
+        break
+
+if len(l2)>0:
+    print(f"您选择的商品是{l2}")
+
+

Python 基础教程/1.7.1 c字典应用.py

@@ -0,0 +1,5 @@
+import os
+dic = {}
+for name in os.listdir(os.path.join("练习")):
+    dic[name] = len(dic.keys())
+print(dic)

Python 基础教程/练习/readme.txt

@@ -0,0 +1,28 @@
+# 两个目的
+# - 综合运用学习过的知识点
+# - 运用面向对象思维解决实际问题
+# 模拟某培训机构，从招生，到开班，到学员学习课程，到学员毕业，计算公司总收入，统计学员人数
+# 一.类的识别
+# 1.学生类
+# 2.班级类
+# 3.课程类
+# 4.某公司类
+# 5.收入明细类：
+# 二.类的成员的定义（包括属性和方法）
+# 1.学生类Student：姓名，经验值，勤奋程度（0.9），聪明程度（1.9），是否进入班级（true）
+# 2.班级类Class：学员列表（List<Student>），开班日期，
+# 3.课程类Course：课程名称，课时。
+# 4.某公司类Company：班级列表(List<Class>)
+# ,课程列表(List<Course>),总收入，收入明细。学员列表，未进入班级的学员列表
+# 5.收入明细类：收入金额，收入日志
+# 三.类的成员方法的定义
+# 1.学生类：学习，缴费
+# 2.班级类：开班，关班，上课
+# 3.课程类：课程名，课时
+# 4.某公司类：统计在校人数，统计全年收入，统计班级数....
+# 5.收入明细类：
+# 四.启动一个定时器，模拟东软某公司的运营情况
+# 每一秒执行一个timer函数，模拟某一天的运营状况（某的一天）：
+# 1.招生（随机生成一个个学员对象，加入未开班班级，调用学员的缴费方法）
+# 2.开班（需要判断是否满足条件[学员数量达到某个阈值]）
+# 3.各班级上课。（判断关班[所有课程全部完毕]）

Python 基础教程/练习/test.py

@@ -0,0 +1,23 @@
+class Student:
+    def __init__(self,name,experence,deligent,smart,isEnter):
+        self.name = name
+        self.experence = experence
+        self.deligent = deligent
+        self.smart = smart
+        self.isEnter = isEnter
+
+class Class:
+    def __init__(self,date):
+        self.stulist = []
+        self.date = date
+    def add(self,student:Student):
+        self.stulist.append(student)
+
+class Course:
+    def __init__(self,name,hour):
+        self.name = name
+        self.hour = hour
+
+class Company:
+    def __init__(self):
+        classlist = []

Python 基础教程/练习/定时器.py

@@ -0,0 +1,8 @@
+#引入库 threading
+import threading
+#定义函数
+def printaaa():
+    print(111)
+
+timer = threading.Timer(1,printaaa)  #首次启动
+timer.start()

Python 基础教程/练习/综合实例---猜数游戏.py

@@ -0,0 +1,52 @@
+import random
+import pickle
+from collections import deque
+
+n = random.randint(0, 100)  # 随机找出0-100之中的数
+history_list = deque([], maxlen=5)  # 限制最大长度
+try_num = 0
+print(n)
+
+
+def pk(m):
+    if m != n:
+        if m > n:
+            print("大了")
+        else:
+            print("小了")
+        return False
+    return True
+
+
+def h_print():# pickle取
+    ret = pickle.load(open('history', 'rb'))
+    return ret
+
+
+def history(history_list): # pickle存
+    history_list = list(history_list)
+    pickle.dump(history_list, open('history', 'wb'))
+
+
+while True:
+    try_num += 1
+    if try_num > 10:
+        print("尝试次数过多，您已经笨死了！！！")
+        break
+    m = input("输入您的答案:")
+    try:                               # 异常处理 防止用户输入字母
+        # m = input("输入您的答案:")
+        if len(m) == 0:
+            print("not null")
+        m = int(m)
+        history_list.append(m)
+        history(history_list)
+        if pk(m) == True:
+            print("以您的智商，居然TM答对了")
+            break
+    except ValueError:
+        if m == "h":
+            print("您猜数的历史记录：")
+            print(h_print())
+        else:
+            print("格式有误，请输入整数字")

Python高级编程/0面向对象 多态.py

@@ -0,0 +1 @@
+# https://www.cnblogs.com/Eva-J/articles/7293890.html

Python高级编程/0面向对象 实例交互.py

@@ -0,0 +1,34 @@
+import abc
+class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
+    @abc.abstractmethod
+    def talk(self):
+        pass
+
+class People(Animal): #动物的形态之一:人
+    def talk(self):
+        print('say hello')
+
+class Dog(Animal): #动物的形态之二:狗
+    def talk(self):
+        print('say wangwang')
+
+class Pig(Animal): #动物的形态之三:猪
+    def talk(self):
+        print('say aoao')
+
+peo=People()
+dog=Dog()
+pig=Pig()
+
+#peo、dog、pig都是动物,只要是动物肯定有talk方法
+#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
+# peo.talk()
+# dog.talk()
+# pig.talk()
+
+#更进一步,我们可以定义一个统一的接口来使用
+def func(obj):
+    obj.talk()
+func(peo)
+func(dog)
+func(pig)

Python高级编程/0面向对象 实例属性和类属性.py

@@ -0,0 +1,12 @@
+class Person():
+    hight = 13
+    def __init__(self,age,sex,hight):
+        self.age = age
+        self.sex = sex
+        # self.hight = hight
+    def display(self):
+        print(f"person is displaying :{self.sex},{self.age},{self.hight},{Person.hight}")
+
+p1 = Person(12,'girl',14)
+p1.display()
+print(f"person1 is run :{p1.sex},{p1.age},{p1.hight},{Person.hight}")

Python高级编程/0面向对象 封装.py

@@ -0,0 +1,32 @@
+#类的设计者
+class Room:
+    def __init__(self,name,owner,width,length,high):
+        self.name=name
+        self.owner=owner
+        self.__width=width
+        self.__length=length
+        self.__high=high
+    def tell_area(self): #对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积
+        return self.__width * self.__length
+
+
+#使用者
+r1=Room('卧室','egon',20,20,20)
+ #使用者调用接口tell_area
+print(r1.tell_area())
+
+
+#类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码
+class Room:
+    def __init__(self,name,owner,width,length,high):
+        self.name=name
+        self.owner=owner
+        self.__width=width
+        self.__length=length
+        self.__high=high
+    def tell_area(self): #对外提供的接口，隐藏内部实现，此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法，但是功能已经变了
+        return self.__width * self.__length * self.__high
+
+
+#对于仍然在使用tell_area接口的人来说，根本无需改动自己的代码，就可以用上新功能
+print(r1.tell_area())

Python高级编程/0面向对象 概念.py

@@ -0,0 +1,32 @@
+# https://www.runoob.com/python/python-object.html
+
+# 面向对象技术简介
+# 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
+# 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
+# 数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
+# 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
+# 局部变量：定义在方法中的变量，只作用于当前实例的类。
+# 实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
+# 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
+# 实例化：创建一个类的实例，类的具体对象。
+# 方法：类中定义的函数。
+# 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
+
+# !/usr/bin/python
+# -*- coding: UTF-8 -*-
+
+class Employee:
+    # '所有员工的基类'
+    empCount = 0
+
+    def __init__(self, name, salary):
+        self.name = name
+        self.salary = salary
+        Employee.empCount += 1
+
+    def displayCount(self):
+        print("Total Employee %d" % Employee.empCount)
+
+
+    def displayEmployee(self):
+        print("Name : ", self.name, ", Salary: ", self.salary)

Python高级编程/0面向对象 继承.py

@@ -0,0 +1,20 @@
+class A:
+    def __init__(self):
+        print('init A')
+    def hahaha(self):
+        print(' A')
+
+class B(A):
+    def __init__(self):
+        print('init B')
+    def hahaha(self):
+        super().hahaha()
+        #super(B,self).hahaha()
+        # A.hahaha(self)
+        print('B')
+
+# a = A()
+b = B()
+b.hahaha()
+# super(B,b).hahaha()
+

Python高级编程/0面向对象 继承2.py

@@ -0,0 +1,59 @@
+class Animal:
+    '''
+    人和狗都是动物，所以创造一个Animal基类
+    '''
+    def __init__(self, name, aggressivity, life_value):
+        self.name = name  # 人和狗都有自己的昵称;
+        self.aggressivity = aggressivity  # 人和狗都有自己的攻击力;
+        self.life_value = life_value  # 人和狗都有自己的生命值;
+
+    def eat(self):
+        print('%s is eating'%self.name)
+
+class Dog(Animal):
+    '''
+    狗类，继承Animal类
+    '''
+    def __init__(self,name,breed,aggressivity,life_value):
+        super().__init__(name, aggressivity, life_value) #执行父类Animal的init方法
+        self.breed = breed  #派生出了新的属性
+
+    def bite(self, people):
+        '''
+        派生出了新的技能：狗有咬人的技能
+        :param people:
+        '''
+        people.life_value -= self.aggressivity
+
+    def eat(self):
+        # Animal.eat(self)
+        #super().eat()
+        print('from Dog')
+
+class Person(Animal):
+    '''
+    人类，继承Animal
+    '''
+    def __init__(self,name,aggressivity, life_value,money):
+        #Animal.__init__(self, name, aggressivity, life_value)
+        #super(Person, self).__init__(name, aggressivity, life_value)
+        super().__init__(name,aggressivity, life_value)  #执行父类的init方法
+        self.money = money   #派生出了新的属性
+
+    def attack(self, dog):
+        '''
+        派生出了新的技能：人有攻击的技能
+        :param dog:
+        '''
+        dog.life_value -= self.aggressivity
+
+    def eat(self):
+        #super().eat()
+        Animal.eat(self)
+        print('from Person')
+
+egg = Person('egon',10,1000,600)
+ha2 = Dog('二愣子','哈士奇',10,1000)
+print(egg.name)
+print(ha2.name)
+egg.eat()

Python高级编程/0面向对象 继承调用顺序.py

@@ -0,0 +1,37 @@
+# https://www.runoob.com/python/python-object.html
+# !/usr/bin/python
+# -*- coding: UTF-8 -*-
+
+class Parent:  # 定义父类
+    parentAttr = 100
+    def __init__(self):
+        print("调用父类构造函数")
+
+
+    def parentMethod(self):
+        print('调用父类方法')
+
+
+    def setAttr(self, attr):
+        Parent.parentAttr = attr
+
+    def getAttr(self):
+        print("父类属性 :", Parent.parentAttr)
+
+
+
+class Child(Parent):  # 定义子类
+    def __init__(self):
+        print("调用子类构造方法")
+
+
+    def childMethod(self):
+        print('调用子类方法')
+
+
+
+c = Child()  # 实例化子类
+c.childMethod()  # 调用子类的方法
+c.parentMethod()  # 调用父类方法
+c.setAttr(200)  # 再次调用父类的方法 - 设置属性值
+c.getAttr()  # 再次调用父类的方法 - 获取属性值

test.py

@@ -0,0 +1,112 @@
+import turtle
+import math
+import sys
+
+tick = 0.1
+
+position_human  = (150,50*(3**0.5))
+position_lion_1 = (0,0)
+position_lion_2 = (150,150*(3**0.5))
+
+speed_human   = 10*tick
+speed_lion_1  = 15*tick
+speed_lion_2  = 20*tick
+
+degree = 25
+times = 0
+
+#判断人在线上还是线下
+
+
+while(True): #使其无限循环下去
+  turtle.penup()
+  turtle.goto(position_human)
+  check_k = (position_lion_2[1]-position_lion_1[1])/(position_lion_2[0]-position_lion_1[0])
+  check_b = position_lion_2[1] - (check_k*position_lion_2[0])
+  check = check_k*position_human[0] + check_b
+  #以下是人前进代码
+  if(position_human[1]<check):
+    #人在线条之下
+    middle_dot = (((position_lion_2[0]+position_lion_1[0])/2),((position_lion_2[1]+position_lion_1[1])/2))
+    turtle.setheading(turtle.towards(middle_dot)+degree)
+    turtle.pendown()
+    turtle.fd(speed_human)
+    position_human = tuple(turtle.position())
+    print("below")
+  elif(position_human[1]>check):
+    axis_k = (position_human[1]-position_lion_1[1])/(position_human[0]-position_lion_1[0])
+    axis_b = position_human[1] - (axis_k*position_human[0])
+    middle_dot = (((position_lion_2[0]+position_lion_1[0])/2),((position_lion_2[1]+position_lion_1[1])/2))
+    vertical_k = -1/axis_k
+    vertical_b = middle_dot[1] - (vertical_k*middle_dot[0])
+    vertical_dot = ((vertical_b-axis_b)/(axis_k-vertical_k),(axis_k*((vertical_b-axis_b)/(axis_k-vertical_k)) + axis_b))
+    point_dot = ((2*vertical_dot[0]-middle_dot[0]),(2*vertical_dot[1]-middle_dot[1]))
+    turtle.pendown()
+    turtle.setheading(turtle.towards(point_dot) + degree)
+    turtle.fd(speed_human)
+    position_human = tuple(turtle.position())
+    print("above")
+  elif(position_human == check):
+    print("!!!!oneline")
+    break
+  distance_1 = turtle.distance(position_lion_1)
+  distance_2 = turtle.distance(position_lion_2)
+  if(distance_1<=speed_lion_1 or distance_2<=speed_lion_2):
+    print(times)
+    break
+  #以下是狮子追人代码
+  turtle.penup()
+  turtle.goto(position_lion_1)
+  turtle.setheading(turtle.towards(position_human))
+  turtle.pendown()
+  turtle.forward(speed_lion_1)
+  position_lion_1 = tuple(turtle.position())
+  turtle.penup()
+  turtle.goto(position_lion_2)
+  turtle.setheading(turtle.towards(position_human))
+  turtle.pendown()
+  turtle.forward(speed_lion_2)
+  position_lion_2 = tuple(turtle.position())
+  times = times + 1
+
+# axis_k = (position_human[1]-position_lion_1[1])/(position_human[0]-position_lion_1[0])
+# axis_b = position_human[1] - (axis_k*position_human[0])
+
+# middle_dot = (((position_lion_2[0]-position_lion_1[0])/2),((position_lion_2[1]-position_lion_1[1])/2))
+
+# vertical_k = -1/axis_k
+# vertical_b = middle_dot[1] - (vertical_k*middle_dot[0])
+
+
+# vertical_dot = ((vertical_b-axis_b)/(axis_k-vertical_k),(axis_k*((vertical_b-axis_b)/(axis_k-vertical_k)) + axis_b))
+
+# point_dot = ((2*vertical_dot[0]-middle_dot[0]),(2*vertical_dot[1]-middle_dot[1]))
+
+
+# turtle.pendown()
+# turtle.goto(position_lion_2)
+# turtle.penup()
+# turtle.goto(position_human)
+# turtle.pendown()
+# turtle.setheading(turtle.towards(point_dot)+40)
+# turtle.forward(100)
+# turtle.penup()
+# turtle.goto(position_human)
+# turtle.setheading(turtle.towards(middle_dot))
+# turtle.pendown()
+# turtle.forward(100)
+
+# turtle.penup()
+# turtle.goto(position_lion_1)
+# turtle.pendown()
+# turtle.goto(position_lion_2)
+# middle_dot = (((position_lion_2[0]-position_lion_1[0])/2),((position_lion_2[1]-position_lion_1[1])/2))
+# print(middle_dot)
+# turtle.penup()
+# turtle.goto(position_human)
+# turtle.pendown()
+# turtle.setheading(turtle.towards(middle_dot) + 40 )
+
+# turtle.fd(100)
+
+input("ssssss")

人与鳄鱼/test5.py

@@ -0,0 +1,33 @@
+# 5.机器人从原点（0,0）开始在平面中移动。 机器人可以通过给定的步骤向上，向下，向左和向右移动。
+# 机器人运动的痕迹如下所示： UP 5 DOWN 3 LETF 3 RIGHT 2 方向之后的数字是步骤。
+# 请编写一个程序来计算一系列运动和原点之后距当前位置的距离。
+# 如果距离是浮点数，则只打印最接近的整数。
+# 例：如果给出以下元组作为程序的输入：
+# UP 5 DOWN 3 LETF 3 RIGHT 2 然后，程序的输出应该是：2
+
+import turtle
+import math
+import time
+print("请输入：")
+str=input()
+lis=str.split(" ")
+for i in range(0,len(lis)-1):
+    if lis[i]=='UP':
+        turtle.left(90)
+        turtle.fd(int(lis[i+1]))
+        turtle.setheading(0)
+    if lis[i]=='DOWN':
+        turtle.right(90)
+        turtle.fd(int(lis[i+1]))
+        turtle.setheading(0)
+    if lis[i]=='LETF':
+        turtle.left(180)
+        turtle.fd(int(lis[i+1]))
+        turtle.setheading(0)
+    if lis[i]=='RIGHT':
+        turtle.fd(int(lis[i+1]))
+#pos=turtle.position()
+# print(pos)
+# dis=math.sqrt(math.pow((pos[0]-0.0),2)+math.pow((pos[1]-0.0),2))
+# print(round(dis))
+

人与鳄鱼/turtle例子.py

@@ -0,0 +1,135 @@
+# turtle.setheading()：设置当前画笔朝向，即人或鳄鱼的朝向
+# turtle.distance()：获取两个坐标之间的距离
+# turtle.position()：得到当前位置的坐标（用来获得人或鳄鱼在每次运动之后的坐标）
+# turtle.towards()：得到两个坐标之间的相位角（鳄鱼需要不停的调整角度来使鳄鱼的脸一直朝着人的方向
+
+
+#代码写的比较乱，直接在前一个案例基础上改进的
+
+import turtle, time
+def drawGap(): #绘制数码管间隔
+    turtle.penup()
+    turtle.fd(5)
+def drawLine(draw):   #绘制单段数码管
+    drawGap()
+    turtle.pendown() if draw else turtle.penup()
+    turtle.fd(40)
+    drawGap()
+    turtle.right(90)
+def drawDigit(d): #根据数字绘制七段数码管
+    drawLine(True) if d in [2,3,4,5,6,8,9] else drawLine(False)
+    drawLine(True) if d in [0,1,3,4,5,6,7,8,9] else drawLine(False)
+    drawLine(True) if d in [0,2,3,5,6,8,9] else drawLine(False)
+    drawLine(True) if d in [0,2,6,8] else drawLine(False)
+    turtle.left(90)
+    drawLine(True) if d in [0,4,5,6,8,9] else drawLine(False)
+    drawLine(True) if d in [0,2,3,5,6,7,8,9] else drawLine(False)
+    drawLine(True) if d in [0,1,2,3,4,7,8,9] else drawLine(False)
+    turtle.left(180)
+    turtle.penup()
+    turtle.fd(20)
+def drawDate(date):
+    turtle.pencolor("red")
+    for i in date:
+        if i == '-':
+            turtle.write('年',font=("Arial", 18, "normal"))
+            turtle.pencolor("green")
+            turtle.fd(40)
+        elif i == '=':
+            turtle.write('月',font=("Arial", 18, "normal"))
+            turtle.pencolor("blue")
+            turtle.fd(40)
+        elif i == '+':
+            turtle.write('日',font=("Arial", 18, "normal"))
+            turtle.fd(40)
+        else:
+            drawDigit(eval(i))
+def all(day):
+    turtle.goto(-350,-300)
+    turtle.pencolor("orange")
+    turtle.write('总共',font=("Arial", 40, "normal"))
+    turtle.fd(110)
+    for j in day:
+        drawDigit(eval(j))
+    turtle.write('天',font=("Arial", 18, "normal"))
+def count(t1,t2,t3):
+    t=t1*365
+    if t2 in [1,2]:
+        t+=t2*30
+    if t2 in [3]:
+        t=t+91
+    if t2==4:
+        t+=122
+    if t2==5:
+        t+=152
+    if t2==6:
+        t+=183
+    if t2==7:
+        t+=213
+    if t2==8:
+        t+=244
+    if t2==9:
+        t+=275
+    if t2==10:
+        t+=303
+    if t2==11:
+        t+=334
+    t+=t3
+    return(str(t))
+def text():
+    turtle.penup()
+    turtle.goto(-350,400)
+    turtle.pendown()
+    turtle.write('今天是：',font=("Arial", 18, "normal"))
+    turtle.pensize(5)
+    turtle.penup()
+    turtle.goto(-350,300)
+    turtle.pendown()
+    drawDate(time.strftime('%Y-%m=%d+',time.gmtime()))
+    turtle.penup()
+    turtle.goto(-350,200)
+    turtle.pensize(1)
+    turtle.pendown()
+    turtle.pencolor("black")
+    turtle.write('孙小姐和刘先生在一起：',font=("Arial", 18, "normal"))
+    turtle.penup()
+    turtle.goto(-350,100)
+    turtle.pendown()
+    turtle.pensize(5)
+    drawDate('2018-05=10+')
+    turtle.penup()
+    turtle.goto(-350,0)
+    turtle.pensize(1)
+    turtle.pendown()
+    turtle.pencolor("black")
+    turtle.write('我们一起经历了：',font=("Arial", 18, "normal"))
+    turtle.penup()
+    turtle.goto(0,-100)
+    turtle.pensize(1)
+    turtle.pendown()
+def main():
+    turtle.setup(900, 900, 200, 0)
+    text()
+    turtle.penup()
+    turtle.fd(-350)
+    turtle.pensize(5)
+#    drawDate('2018-10=10+')
+    t1=time.gmtime()
+    t2=t1.tm_year-2018
+    t3=t1.tm_mon-5
+    if t3<0:
+        t2-=1
+        t3+=12
+    t4=t1.tm_mday-10
+    if t4<0:
+        t3-=1
+        if t1.tm_mon-1 in [1,3,5,7,8,10,12]:
+            t4+=31
+        else:
+            t4+=30
+    tatol=count(t2,t3,t4)
+    drawDate(str(t2)+'-'+str(t3)+'='+str(t4)+'+')
+    all(tatol)
+    turtle.hideturtle()
+    turtle.done()
+main()

人与鳄鱼/turtle画形状.py

@@ -0,0 +1,18 @@
+# https://blog.csdn.net/zhubao124/article/details/82867759
+import turtle as tl
+import time
+
+tl.setup(500,500,0,0)
+tl.pensize(2)
+tl.pencolor('red')
+
+tl.home()
+for i in range(0,10):
+    # tl.pendown()
+    # tl.dot()
+    # tl.penup()
+    tl.forward(10)
+    tl.right(60)
+    tl.forward(10)
+
+time.sleep(10)

人与鳄鱼/人与鳄鱼问题.py

@@ -0,0 +1,76 @@
+# 设有三条鳄鱼ABC分别站在等边三角形的三个角上，一个人站在三角形的正中间。
+# 每条鳄鱼和人的距离为100米，人的奔跑速度是10m/s鳄鱼A的奔跑速度是15m/s鳄鱼B和C的奔跑速度是20m/s。
+# 问:这个人最多还能活几秒?
+
+
+# 贪心算法
+#
+# 贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。
+#
+# 我的做法是：每过一段时间（比如0.1秒）做一次判断，选择此刻延直线距离运动到人 所需时间最短的那只鳄鱼，使人下一时间段所奔跑的方向为背离此鳄鱼的方向。
+# 程序中以人为原点建立平面直角坐标系，输出每个时间点人和鳄鱼的坐标。当任意一只鳄鱼在下一时间段内，追上人所需时间小于单位时间，程序结束，并输出人奔跑的总时间。
+# 将人和鳄鱼的所有时刻的坐标写入文件，用来画出运动轨迹。
+
+import turtle
+
+positionHuman = (0.00, 86.00)
+positionLion1 = (-150.00, 0.00)
+positionLion2 = (150.00, 0.00)
+positionLion3 = (0.00, 260.00)
+escapeDregree = 240
+
+turtle.pensize(3)
+for x in range(100):
+    turtle.color("black")
+    turtle.penup()
+    turtle.goto(positionHuman)
+    turtle.dot(2, "yellow")
+    turtle.pendown()
+    turtle.setheading(escapeDregree)
+
+    lenthLion1 = turtle.distance(positionLion1)
+    lenthLion2 = turtle.distance(positionLion2)
+    if (x >= 2):
+        if (lenthLion1 > lenthLion2):
+            escapeDregree = escapeDregree - 20
+            turtle.fd(10)
+            print("1", escapeDregree)
+        else:
+            escapeDregree = escapeDregree + 20
+            turtle.fd(10)
+            print("2", escapeDregree)
+    else:
+        turtle.fd(10)
+        print("3", escapeDregree)
+
+    positionHuman = turtle.position()
+
+    turtle.color("green")
+    turtle.penup()
+    turtle.goto(positionLion1)
+    turtle.dot(2, "green")
+    turtle.pendown()
+    positionLion1ToHuman = turtle.towards(positionHuman)
+    turtle.setheading(positionLion1ToHuman)
+    turtle.fd(15)
+    positionLion1 = turtle.position()
+
+    turtle.color("red")
+    turtle.penup()
+    turtle.goto(positionLion2)
+    turtle.dot(2, "red")
+    turtle.pendown()
+    positionLion2ToHuman = turtle.towards(positionHuman)
+    turtle.setheading(positionLion2ToHuman)
+    turtle.fd(20)
+    positionLion2 = turtle.position()
+
+    turtle.color("yellow")
+    turtle.penup()
+    turtle.goto(positionLion3)
+    turtle.dot(2, "yellow")
+    turtle.pendown()
+    positionLion3ToHuman = turtle.towards(positionHuman)
+    turtle.setheading(positionLion3ToHuman)
+    turtle.fd(20)
+    positionLion3 = turtle.position()

人与鳄鱼/人与鳄鱼问题1 画简单图 init.py

@@ -0,0 +1,34 @@
+
+
+import turtle
+import time
+
+human = (0.00, 100)
+lion1 = (100, 0.00)
+angle1 = 0
+
+angle = 240
+
+turtle.pensize(3)
+
+turtle.color("black")
+turtle.penup()
+turtle.goto(human)
+turtle.dot(2, "red")
+turtle.pendown()
+turtle.setheading(angle)
+turtle.fd(10)
+
+human = turtle.position()
+
+turtle.color("green")
+turtle.penup()
+turtle.goto(lion1)
+turtle.dot(2, "black")
+turtle.pendown()
+angle1 = turtle.towards(human)
+turtle.setheading(angle1)
+turtle.forward(15)
+lion1 = turtle.position()
+
+time.sleep(10)

人与鳄鱼/人与鳄鱼问题1 画简单图.py

@@ -0,0 +1,62 @@
+# 设有三条鳄鱼ABC分别站在等边三角形的三个角上，一个人站在三角形的正中间。
+# 每条鳄鱼和人的距离为100米，人的奔跑速度是10m/s鳄鱼A的奔跑速度是15m/s鳄鱼B和C的奔跑速度是20m/s。
+# 问:这个人最多还能活几秒?
+
+
+# 贪心算法
+#
+# 贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。
+#
+# 我的做法是：每过一段时间（比如0.1秒）做一次判断，选择此刻延直线距离运动到人 所需时间最短的那只鳄鱼，使人下一时间段所奔跑的方向为背离此鳄鱼的方向。
+# 程序中以人为原点建立平面直角坐标系，输出每个时间点人和鳄鱼的坐标。当任意一只鳄鱼在下一时间段内，追上人所需时间小于单位时间，程序结束，并输出人奔跑的总时间。
+# 将人和鳄鱼的所有时刻的坐标写入文件，用来画出运动轨迹。
+
+import turtle
+
+positionHuman = (0.00, 86.00)
+positionLion1 = (-150.00, 0.00)
+positionLion2 = (150.00, 0.00)
+positionLion3 = (0.00, 260.00)
+escapeDregree = 240
+
+turtle.pensize(3)
+for x in range(100):
+    turtle.color("black")
+    turtle.penup()
+    turtle.goto(positionHuman)
+    turtle.dot(2, "yellow")
+    turtle.pendown()
+    turtle.setheading(escapeDregree)
+    turtle.fd(10)
+
+    positionHuman = turtle.position()
+
+    turtle.color("green")
+    turtle.penup()
+    turtle.goto(positionLion1)
+    turtle.dot(2, "green")
+    turtle.pendown()
+    positionLion1ToHuman = turtle.towards(positionHuman)
+    turtle.setheading(positionLion1ToHuman)
+    turtle.forward(15)
+    positionLion1 = turtle.position()
+
+    turtle.color("red")
+    turtle.penup()
+    turtle.goto(positionLion2)
+    turtle.dot(2, "red")
+    turtle.pendown()
+    positionLion2ToHuman = turtle.towards(positionHuman)
+    turtle.setheading(positionLion2ToHuman)
+    turtle.forward(20)
+    positionLion2 = turtle.position()
+
+    turtle.color("yellow")
+    turtle.penup()
+    turtle.goto(positionLion3)
+    turtle.dot(2, "yellow")
+    turtle.pendown()
+    positionLion3ToHuman = turtle.towards(positionHuman)
+    turtle.setheading(positionLion3ToHuman)
+    turtle.forward(20)
+    positionLion3 = turtle.position()

实例学习Numpy与Matplotlib/Nump 矩阵聚合.py

@@ -0,0 +1,31 @@
+import  numpy as np
+a1 = np.array([i for i in range(1,5)])
+
+a2 = a1.reshape((2,2))
+print(f"a1 = {a1}   "
+f"a2 = {a2}   "
+      )
+
+print(f"np.sum(a2) = {np.sum(a2)}\n"
+      f"np.sum(a2,axis = 0) = {np.sum(a2,axis = 0)}\n"
+f"np.std(a2) = {np.std(a2)}\n"
+f"np.mean(a2) = {np.mean(a2)}\n"
+f"np.var(a2) = {np.var(a2)}\n"
+f"np.median(a2) = {np.median(a2)}\n"
+f"np.random.shuffle(a2) = {a2}\n"
+      )
+np.random.shuffle(a2)
+print(
+f"np.random.shuffle(a2) = {a2}\n"
+      )
+np.sort(a2)
+print(
+f"np.random.sort(a2) = {a2}\n"
+      )
+
+X = np.random.randint(100, size=(4,4))
+print(X)
+np.sort(X, axis=0)
+print(X)
+np.sort(X, axis=1)
+print(X)

实例学习Numpy与Matplotlib/Nump 索引.py

@@ -0,0 +1,7 @@
+import  numpy as np
+a1 = np.array([i for i in range(1,5)])
+
+a2 = a1.reshape((2,2))
+print(f"a1 = {a1}   "
+f"a2 = {a2}   "
+      )

实例学习Numpy与Matplotlib/Numpy reshape.py

@@ -0,0 +1,19 @@
+import  numpy as np
+# reshape
+b1 = np.arange(15)
+# b1 = [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
+b2 = b1.reshape((3,5))
+#   b2 = [[ 0  1  2  3  4]
+#  [ 5  6  7  8  9]
+#  [10 11 12 13 14]]
+b3 = b2.reshape(-1,3)  #无论多少行  回城3列
+b4 = b1.reshape(5,-1) #无论多少列  回城5行
+print(f"b1 = {b1} \n  "
+      f"b2 = {b2} \n  "
+      f"b3 = {b3} \n  "
+      f"b4 = {b4} \n  ")
+
+
+
+
+

实例学习Numpy与Matplotlib/Numpy 2伪随机数的生成与显示.py

@@ -0,0 +1,42 @@
+import numpy as np
+import seaborn as sns
+import matplotlib.pyplot as plt
+from scipy import stats
+# 生成各种正态分布随机数
+np.random.seed(1234)
+rn1 = np.random.normal(loc = 0, scale = 1, size = 1000)
+rn2 = np.random.normal(loc = 0, scale = 2, size = 1000)
+rn3 = np.random.normal(loc = 2, scale = 3, size = 1000)
+rn4 = np.random.normal(loc = 5, scale = 3, size = 1000)
+# 绘图
+plt.style.use('ggplot')
+sns.distplot(rn1, hist = False, kde = False, fit = stats.norm,
+             fit_kws = {'color':'black','label':'u=0,s=1','linestyle':'-'})
+sns.distplot(rn2, hist = False, kde = False, fit = stats.norm,
+             fit_kws = {'color':'red','label':'u=0,s=2','linestyle':'--'})
+sns.distplot(rn3, hist = False, kde = False, fit = stats.norm,
+             fit_kws = {'color':'blue','label':'u=2,s=3','linestyle':':'})
+sns.distplot(rn4, hist = False, kde = False, fit = stats.norm,
+             fit_kws = {'color':'purple','label':'u=5,s=3','linestyle':'-.'})
+# 呈现图例
+plt.legend()
+# 呈现图形
+plt.show()
+
+
+# 生成各种指数分布随机数
+np.random.seed(1234)
+re1 = np.random.exponential(scale = 0.5, size = 1000)
+re2 = np.random.exponential(scale = 1, size = 1000)
+re3 = np.random.exponential(scale = 1.5, size = 1000)
+# 绘图
+sns.distplot(re1, hist = False, kde = False, fit = stats.expon,
+             fit_kws = {'color':'black','label':'lambda=0.5','linestyle':'-'})
+sns.distplot(re2, hist = False, kde = False, fit = stats.expon,
+             fit_kws = {'color':'red','label':'lambda=1','linestyle':'--'})
+sns.distplot(re3, hist = False, kde = False, fit = stats.expon,
+             fit_kws = {'color':'blue','label':'lambda=1.5','linestyle':':'})
+# 呈现图例
+plt.legend()
+# 呈现图形
+plt.show()

实例学习Numpy与Matplotlib/Numpy 2数组的产生.py

@@ -0,0 +1,221 @@
+# 导入模块，并重命名为np
+import numpy as np
+# 单个列表创建一维数组
+arr1 = np.array([3,10,8,7,34,11,28,72])
+# 嵌套元组创建二维数组
+arr2 = np.array(((8.5,6,4.1,2,0.7),(1.5,3,5.4,7.3,9),(3.2,3,3.8,3,3),(11.2,13.4,15.6,17.8,19)))
+print('一维数组：\n',arr1)
+print('二维数组：\n',arr2)
+
+# 一维数组元素的获取
+print(arr1[[2,3,5,7]])
+# 二维数组元素的获取
+# 第2行第3列元素
+print("# 第2行第3列元素",arr2[1,2])
+# 第3行所有元素
+print("# 第3行所有元素",arr2[2,:])
+# 第2列所有元素
+print("# 第2列所有元素",arr2[:,1])
+# 第2至4行，2至5行
+print("# 第2至4行，2至5列",arr2[1:4,1:5])
+# 第一行、最后一行和第二列、第四列构成的数组
+print("# 第一行、最后一行和第二列、第四列构成的数组",arr2[[0,-1],[1,3]])
+# 第一行、最后一行和第一列、第三列、第四列构成的数组
+print("# 第一行、最后一行和第一列、第三列、第四列构成的数组",arr2[np.ix_([0,-1],[1,2,3])])
+# 第一行、最后一行和第二列、第四列构成的数组
+print("# 第一行、最后一行和第二列、第四列构成的数组",arr2[np.ix_([0,-1],[1,3])])
+# 第一行、最后一行和第一列、第三列、第四列构成的数组
+print("# 第一行、最后一行和第二列、第三列、第四列构成的数组",arr2[np.ix_([0,-1],[1,2,3])])
+
+# 读入数据
+stu_score = np.genfromtxt(fname = r'stu_socre.txt',delimiter='\t',skip_header=1)
+
+print("# 查看数据结构",type(stu_score))
+print("# 查看数据维数",stu_score.ndim)
+print("# 查看数据行列数",stu_score.shape)
+print("# 查看数组元素的数据类型",stu_score.dtype)
+print("# 查看数组元素个数",stu_score.size)
+arr3 = np.array([[1,5,7],[3,6,1],[2,4,8],[5,8,9],[1,5,9],[8,5,2]])
+
+print("# 数组的行列数",arr3.shape)
+print("# 使用reshape方法更改数组的形状",arr3.reshape(2,9))
+print("# 打印数组arr3的行列数",arr3.shape)
+print("# 使用resize方法更改数组的形状",arr3.resize(2,9))
+print("# 打印数组arr3的行列数",arr3.shape)
+
+arr4 = np.array([[1,10,100],[2,20,200],[3,30,300]])
+print('原数组：\n',arr4)
+# 默认排序降维
+print('数组降维：\n',arr4.ravel())
+print(arr4.flatten())
+print(arr4.reshape(-1))
+
+print("# 改变排序模式的降维",arr4.ravel(order = 'F'))
+print(arr4.flatten(order = 'F'))
+print(arr4.reshape(-1, order = 'F'))
+
+# 更改预览值
+arr4.flatten()[0] = 2000
+print('flatten方法：\n',arr4)
+arr4.ravel()[1] = 1000
+print('ravel方法：\n',arr4)
+arr4.reshape(-1)[4] = 3000
+print('reshape方法：\n',arr4)
+
+arr5 = np.array([1,2,3])
+print('vstack纵向合并数组：\n',np.vstack([arr4,arr5]))
+print('row_stack纵向合并数组：\n',np.row_stack([arr4,arr5]))
+arr6 = np.array([[5],[15],[25]])
+print('hstack横向合并数组：\n',np.hstack([arr4,arr6]))
+print('column_stack横向合并数组：\n',np.column_stack([arr4,arr6]))
+print(arr4)
+print('垂直方向计算数组的和：\n',np.sum(arr4,axis = 0))
+print('水平方向计算数组的和：\n',np.sum(arr4, axis = 1))
+
+
+# 加法运算
+math = np.array([98,83,86,92,67,82])
+english = np.array([68,74,66,82,75,89])
+chinese = np.array([92,83,76,85,87,77])
+tot_symbol = math+english+chinese
+tot_fun = np.add(np.add(math,english),chinese)
+print('符号加法：\n',tot_symbol)
+print('函数加法：\n',tot_fun)
+
+# 除法运算
+height = np.array([165,177,158,169,173])
+weight = np.array([62,73,59,72,80])
+BMI_symbol = weight/(height/100)**2
+BMI_fun = np.divide(weight,np.divide(height,100)**2)
+print('符号除法：\n',BMI_symbol)
+print('函数除法：\n',BMI_fun)
+arr7 = np.array([[1,2,10],[10,8,3],[7,6,5]])
+arr8 = np.array([[2,2,2],[3,3,3],[4,4,4]])
+print('数组arr7：\n',arr7)
+print('数组arr8：\n',arr8)
+# 求余数
+print('计算余数：\n',arr7 % arr8)
+# 求整除
+print('计算整除：\n',arr7 // arr8)
+# 求指数
+print('计算指数：\n',arr7 ** arr8)
+# 整除部分
+np.modf(arr7/arr8)[1]
+
+
+# 取子集
+# 从arr7中取出arr7大于arr8的所有元素
+print(arr7)
+print('满足条件的二维数组元素获取：\n',arr7[arr7>arr8])
+# 从arr9中取出大于10的元素
+arr9 = np.array([3,10,23,7,16,9,17,22,4,8,15])
+print('满足条件的一维数组元素获取：\n',arr9[arr9>10])
+
+# 判断操作
+# 将arr7中大于7的元素改成5，其余的不变
+print('二维数组的条件操作：\n',np.where(arr7>7,5,arr7))
+# 将arr9中大于10 的元素改为1，否则改为0
+print('一维数组的条件操作：\n',np.where(arr9>10,1,0))
+
+
+# 各输入数组维度一致，对应维度值相等
+arr10 = np.arange(12).reshape(3,4)
+arr11 = np.arange(101,113).reshape(3,4)
+print('3×4的二维矩阵运算：\n',arr10 + arr11)
+# 各输入数组维度不一致，对应维度值相等
+arr12 = np.arange(60).reshape(5,4,3)
+arr10 = np.arange(12).reshape(4,3)
+print('维数不一致，但末尾的维度值一致：\n',arr12 + arr10)
+# 各输入数组维度不一致，对应维度值不相等，但其中有一个为1
+arr12 = np.arange(60).reshape(5,4,3)
+arr13 = np.arange(4).reshape(4,1)
+print('维数不一致，维度值也不一致，但维度值至少一个为1：\n',arr12 + arr13)
+# 加1补齐
+arr14 = np.array([5,15,25])
+print('arr14的维度自动补齐为(1,3)：\n',arr10 + arr14)
+
+
+# 一维数组的点积
+vector_dot = np.dot(np.array([1,2,3]), np.array([4,5,6]))
+print('一维数组的点积：\n',vector_dot)
+# 二维数组的乘法
+print('两个二维数组：')
+print(arr10)
+print(arr11)
+arr2d = np.dot(arr10,arr11)
+print('二维数组的乘法：\n',arr2d)
+# diag的使用
+arr15 = np.arange(16).reshape(4,-1)
+print('4×4的矩阵：\n',arr15)
+print('取出矩阵的主对角线元素：\n',np.diag(arr15))
+print('由一维数组构造的方阵：\n',np.diag(np.array([5,15,25])))
+# 计算方阵的特征向量和特征根
+arr16 = np.array([[1,2,5],[3,6,8],[4,7,9]])
+print('计算3×3方阵的特征根和特征向量：\n',arr16)
+print('求解结果为：\n',np.linalg.eig(arr16))
+# 计算偏回归系数
+X = np.array([[1,1,4,3],[1,2,7,6],[1,2,6,6],[1,3,8,7],[1,2,5,8],[1,3,7,5],[1,6,10,12],[1,5,7,7],[1,6,3,4],[1,5,7,8]])
+Y = np.array([3.2,3.8,3.7,4.3,4.4,5.2,6.7,4.8,4.2,5.1])
+
+X_trans_X_inverse = np.linalg.inv(np.dot(np.transpose(X),X))
+beta = np.dot(np.dot(X_trans_X_inverse,np.transpose(X)),Y)
+print('偏回归系数为：\n',beta)
+# 多元线性方程组
+A = np.array([[3,2,1],[2,3,1],[1,2,3]])
+b = np.array([39,34,26])
+X = np.linalg.solve(A,b)
+print('三元一次方程组的解：\n',X)
+# 范数的计算
+arr17 = np.array([1,3,5,7,9,10,-12])
+# 一范数
+res1 = np.linalg.norm(arr17, ord = 1)
+print('向量的一范数：\n',res1)
+# 二范数
+res2 = np.linalg.norm(arr17, ord = 2)
+print('向量的二范数：\n',res2)
+# 无穷范数
+res3 = np.linalg.norm(arr17, ord = np.inf)
+print('向量的无穷范数：\n',res3)
+
+
+import seaborn as sns
+import matplotlib.pyplot as plt
+from scipy import stats
+# 生成各种正态分布随机数
+np.random.seed(1234)
+rn1 = np.random.normal(loc = 0, scale = 1, size = 1000)
+rn2 = np.random.normal(loc = 0, scale = 2, size = 1000)
+rn3 = np.random.normal(loc = 2, scale = 3, size = 1000)
+rn4 = np.random.normal(loc = 5, scale = 3, size = 1000)
+# 绘图
+plt.style.use('ggplot')
+sns.distplot(rn1, hist = False, kde = False, fit = stats.norm, 
+             fit_kws = {'color':'black','label':'u=0,s=1','linestyle':'-'})
+sns.distplot(rn2, hist = False, kde = False, fit = stats.norm, 
+             fit_kws = {'color':'red','label':'u=0,s=2','linestyle':'--'})
+sns.distplot(rn3, hist = False, kde = False, fit = stats.norm, 
+             fit_kws = {'color':'blue','label':'u=2,s=3','linestyle':':'})
+sns.distplot(rn4, hist = False, kde = False, fit = stats.norm, 
+             fit_kws = {'color':'purple','label':'u=5,s=3','linestyle':'-.'})
+# 呈现图例
+plt.legend()
+# 呈现图形
+plt.show()
+
+
+# 生成各种指数分布随机数
+np.random.seed(1234)
+re1 = np.random.exponential(scale = 0.5, size = 1000)
+re2 = np.random.exponential(scale = 1, size = 1000)
+re3 = np.random.exponential(scale = 1.5, size = 1000)
+# 绘图
+sns.distplot(re1, hist = False, kde = False, fit = stats.expon, 
+             fit_kws = {'color':'black','label':'lambda=0.5','linestyle':'-'})
+sns.distplot(re2, hist = False, kde = False, fit = stats.expon, 
+             fit_kws = {'color':'red','label':'lambda=1','linestyle':'--'})
+sns.distplot(re3, hist = False, kde = False, fit = stats.expon, 
+             fit_kws = {'color':'blue','label':'lambda=1.5','linestyle':':'})
+# 呈现图例
+plt.legend()
+# 呈现图形
+plt.show()

实例学习Numpy与Matplotlib/Numpy使用.py

@@ -0,0 +1,46 @@
+import  numpy as np
+a1 = np.array([i for i in range(10)])
+a2 = np.zeros(10)
+a3 = np.ones(10)
+a4 = np.ones((3,5))
+a5 = np.full((3,5),123)
+a6 = np.arange(0,10,2)
+# 0到10之间 插入15个元素
+a7 = np.linspace(0,10,15)
+# random
+a8 = np.random.randint(0,10,size=(3,5),dtype=int)
+a9 = np.random.random((3,5))
+# 参数loc(float)：正态分布的均值，对应着这个分布的中心。
+# 参数scale(float)：正态分布的标准差
+# 参数size(int 或者整数元组)：输出矩阵的shape，默认为None
+a10 = np.random.normal(0,10,(3,5))
+
+# seed( ) 是用于指定随机数生成时所用算法开始的整数值，
+# 代码中每执行一次都使用了相同的随机数种子28，所以生成的随机数是相同的。
+np.random.seed(12)
+a11 = np.random.random((3,5))
+np.random.seed(12)
+a12 = np.random.random((3,5))
+
+a13 = np.ndarray((4,2),dtype='f')
+l = [1,2,3,4]
+a14 = np.array(l)
+print(f"a1 = {a1}   "
+      f"a2 = {a2}   "
+      f"a3 = {a3}   "
+      f"a4 = {a4}   "
+      f"a5 = {a5}   "
+      f"a6 = {a6}   "
+      f"a7 = {a7}   "
+f"a8 = {a8}   "
+f"a9 = {a9}   "
+f"a10 = {a10}   "
+f"a11 = {a11}   "
+f"a12 = {a12}   "
+f"a13 = {a13}   "
+f"a14 = {a14}   "
+      )
+
+a = np.array([2,3,1])
+b = np.array([1,2,1])
+print(f"a15 = {(a*b).sum()}  a len = {len(a)}")

实例学习Numpy与Matplotlib/Numpy分割.py

@@ -0,0 +1,17 @@
+import  numpy as np
+# reshape
+b1 = np.arange(15)
+
+a1,a2,a3 = np.split(b1,[3,7])
+print(f"np.split(b1,[3,7] = \n",a1,a2,a3,"\n")
+
+b2 = b1.reshape((3,5))
+a1,a2,a3 = np.split(b2,[1,2],axis=1)
+print(f"a1 = {a1}\n"
+      f"a2 = {a2}\n"
+      f"a3 = {a3}\n")
+
+
+c1,c2 = np.hsplit(b2,[-1])
+print(f"c1 = {c1}\n"
+      f"c2 = {c2}\n")

实例学习Numpy与Matplotlib/Numpy分片.py

@@ -0,0 +1,42 @@
+import  numpy as np
+# reshape
+b1 = np.arange(15)
+b2 = b1.reshape((3,5))
+
+# b1 = [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
+#   b2 = [[ 0  1  2  3  4]
+#  [ 5  6  7  8  9]
+#  [10 11 12 13 14]]
+
+print(f"b1 = {b1} \n  ")
+
+print(
+    f"b1[0:5] = {b1[0:5]} \n  "
+    f"b1[-1] = {b1[-1]} \n  "
+    f"b1[0:-1] = {b1[0:-1]} \n  "
+    f"b1[:] = {b1[:]} \n  "
+    f"b1[5:-1] = {b1[5:7]} \n  "
+    f"b1[::] = {b1[::]} \n  "
+    f"b1[::2] = {b1[::2]} \n  "
+    f"b1[::-1] = {b1[::-1]} \n  ")
+
+print( f"b2 = {b2}  \n  ")
+
+print(
+f"b2[0:-1] = {b2[0:-1]}  \n  "
+f"b2[0,-1] = {b2[0,-1]}  \n  "
+# 0可以不写。以下两个柿子结果不一样，在numpy中使用","做多维索引
+f"b2[0:2,0:3] = {b2[:2,:3]}  \n  "
+f"b2[:2][:3] = {b2[:2][:3]}  \n  "
+# 取第0行
+f"b2[0,:] = {b2[0,:]}  \n  "
+# 取第0列
+f"b2[:,0] = {b2[:,0]}  \n  "
+# 取最后1列
+f"b2[:,-1] = {b2[:,-1]}  \n  "
+# 行全取，列全取，行倒过来
+f"b2[::-1,::] = {b2[::-1,::]}  \n  "
+            )
+
+
+

实例学习Numpy与Matplotlib/Numpy合并.py

@@ -0,0 +1,18 @@
+import  numpy as np
+# reshape
+b1 = np.arange(15)
+# b1 = [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
+b2 = b1.reshape((3,5))
+b2 = b2.reshape(1,-1)
+b3 = b1[::-1].reshape(1,-1)
+#   b2 = [[ 0  1  2  3  4]
+#  [ 5  6  7  8  9]
+#  [10 11 12 13 14]]
+print(b1.shape,b2.shape,b3.shape)
+b4 = np.concatenate([b2, b3])
+print(f"b4 = {b4} \n  ")
+
+
+
+
+

实例学习Numpy与Matplotlib/Numpy属性.py

@@ -0,0 +1,11 @@
+import  numpy as np
+# reshape
+b1 = np.arange(15)
+b2 = b1.reshape((3,5))
+print(f"b1 = {b1} \n  "
+      f"b2 = {b2}  \n  "
+f"b1.ndim = {b1.ndim}  b2.ndim= {b2.ndim}  \n "
+f"b1.shape = {b1.shape}  b2.shape = {b2.shape} \n "
+f"b1.size = {b1.size}  b2.size = {b2.size} \n "
+            )
+

实例学习Numpy与Matplotlib/Numpy拷贝.py

@@ -0,0 +1,13 @@
+import  numpy as np
+# reshape
+b1 = np.arange(15)
+b2 = b1.reshape((3,5))
+
+b3 = b2[:2,:3]
+b4 = b2[:2,:3].copy()
+print(b3,b3)
+b2[0,0] = 100
+print(b3,b4)
+
+
+

实例学习Numpy与Matplotlib/Nump运算.py

@@ -0,0 +1,18 @@
+import  numpy as np
+a1 = np.array([i for i in range(1,5)])
+np.exp2(a1)
+np.power(3, a1)
+np.log10(a1)
+print(f"a1 = {a1}   "
+      )
+a2 = a1.reshape((2,2))
+a3 = a2.T
+print(f"a2 = {a2}\n"
+      f"a3 = {a3}\n"
+      f"加法 ：a2+a3 = {a2+a3}\n"
+      f"矩阵乘 a2.dot(a3) = {a2.dot(a3)}\n"
+      f"乘法：a2*a3 = {a2*a3}\n"
+f"矩阵的逆：np.linalg.inv(a2) = {np.linalg.inv(a2)}\n"
+      f" a2.dot(np.linalg.inv(a2)) = {a2.dot(np.linalg.inv(a2))}\n"
+f"矩阵的伪逆：np.linalg.pinv(a2) = {np.linalg.pinv(a2)}\n"
+      )

实例学习Numpy与Matplotlib/matplotlib入门例子1.py

@@ -0,0 +1,10 @@
+
+import matplotlib.pyplot as plt
+import numpy as np
+li = [i for i in range(100)]
+x = np.array(li)
+
+y = np.sin(x)
+
+plt.plot(x, y)
+plt.show()

实验/1.1 列表方式打印质数.py

@@ -0,0 +1,11 @@
+l = [i for i in range(2,30)]
+print(l)
+for i in range(2,30):
+    for j in range(2,i):
+        if i%j ==0:
+            print(f"{i} is not zhishu")
+            l.remove(i)
+            break
+print(l)
+
+

实验/Python语言文件操作--学生成绩管理系统.py

@@ -0,0 +1,260 @@
+# -*- coding: UTF-8 -*-
+# https://blog.csdn.net/tian_123456789/article/details/78914692
+
+import os
+import re
+import numpy as np
+
+class Student: #定义一个学生类
+    def __init__(self):
+        self.name = ''
+        self.ID =''
+        self.score1 = 0
+        self.score2 = 0
+        self.score3 = 0
+        self.sum = 0
+
+
+def searchByID(stulist, ID): #按学号查找看是否学号已经存在
+    for item in stulist:
+        if item.ID == ID:
+            return True
+
+def Add(stulist,stu): #添加一个学生信息
+    if searchByID(stulist, stu.ID) == True:
+        print("学号已经存在！")
+        return False
+    stulist.append(stu)
+    print (stu.name,stu.ID, stu.score1, stu.score2, stu.score3, stu.sum)
+    print ("是否要保存学生信息？")
+    nChoose = input("Choose Y/N")
+    if nChoose == 'Y' or nChoose == 'y':
+        file_object = open("students.txt", "a")
+        file_object.write(stu.ID)
+        file_object.write(" ")
+        file_object.write(stu.name)
+        file_object.write(" ")
+        file_object.write(str(stu.score1))
+        file_object.write(" ")
+        file_object.write(str(stu.score2))
+        file_object.write(" ")
+        file_object.write(str(stu.score3))
+        file_object.write(" ")
+        file_object.write(str(stu.sum))
+        file_object.write("\n")
+        file_object.close()
+        print (u"保存成功！")
+
+def Search(stulist, ID): #搜索一个学生信息
+    print (u"学号   姓名    语文    数学    英语    总分")
+    count = 0
+    for item in stulist:
+        if item.ID == ID:
+            print (item.ID, '\t' ,item.name,'\t', item.score1,'\t',item.score2, '\t', item.score3, '\t',item.sum)
+            break
+        count = 0
+    if count == len(stulist):
+        print ("没有该学生学号！")
+
+def Del(stulist, ID): #删除一个学生信息
+    count = 0
+    for item in stulist:
+        if item.ID == ID:
+            stulist.remove(item)
+            print ("删除成功！")
+            break
+        count +=1
+    # if count == len(stulist):
+    #   print "没有该学生学号！"
+    file_object = open("students.txt", "w")
+    for stu in stulist:
+        print (stu.ID, stu.name, stu.score1,stu.score2, stu.score3, stu.sum)
+        file_object.write(stu.ID)
+        file_object.write(" ")
+        file_object.write(stu.name)
+        file_object.write(" ")
+        file_object.write(str(stu.score1))
+        file_object.write(" ")
+        file_object.write(str(stu.score2))
+        file_object.write(" ")
+        file_object.write(str(stu.score3))
+        file_object.write(" ")
+        file_object.write(str(stu.sum))
+        file_object.write("\n")
+        file_object.close()
+    #   print "保存成功！"
+    file_object.close()
+def Change(stulist, ID):
+    count = 0
+    for item in stulist:
+        if item.ID == ID:
+            stulist.remove(item)
+            file_object = open("students.txt", "w")
+            for stu in stulist:
+                #print li.ID, li.name, li.score
+                file_object.write(stu.ID)
+                file_object.write(" ")
+                file_object.write(stu.name)
+                file_object.write(" ")
+                file_object.write(str(stu.score1))
+                file_object.write(" ")
+                file_object.write(str(stu.score2))
+                file_object.write(" ")
+                file_object.write(str(stu.score3))
+                file_object.write(" ")
+                file_object.write(str(stu.sum))
+                file_object.write("\n")
+            #   print "保存成功！"
+            file_object.close()
+            stu = Student()
+            stu.name = input("请输入学生的姓名")
+            while True:
+                stu.ID = input("请输入学生的ID")
+                p = re.compile('^[0-9]{3}$')
+                if p.match(stu.ID):
+                    break
+                else:
+                    print ("输入的有错误！")
+            while True:
+                stu.score1 = int(input("请输入学生语文成绩"))
+                if stu.score1 <= 100 and stu.score1 > 0 :
+                    break
+                else:
+                    print ("输入的学生成绩有错误！")
+            while True:
+                stu.score2 = int(input("请输入学生数学成绩"))
+                if stu.score2 <= 100 and stu.score2 > 0 :
+                    break
+                else:
+                    print ("输入的学生成绩有错误！")
+            while True:
+                stu.score3 = int(input("请输入学生英语成绩"))
+                if stu.score3 <= 100 and stu.score3 > 0 :
+                    break
+                else:
+                    print ("输入的学生成绩有错误！")
+            stu.sum = stu.score1 + stu.score2 + stu.score3
+            Add(stulist,stu)
+def display(stulist): #显示所有学生信息
+    print (u"学号   姓名    语文    数学    英语    总分")
+    for item in stulist:
+        print (item.ID, '\t' ,item.name,'\t', item.score1,'\t',item.score2, '\t', item.score3, '\t',item.sum)
+
+def Sort(stulist): #按学生成绩排序
+    Stu = []
+    sum_count = []
+    for li in stulist:
+        temp = []
+        temp.append(li.ID)
+        temp.append(li.name)
+        temp.append(int(li.score1))
+        temp.append(int(li.score2))
+        temp.append(int(li.score3))
+        temp.append(int(li.sum))
+        sum_count.append(int(li.sum))
+        Stu.append(temp)
+
+    #print sum_count
+    #print Stu;
+    #print stulist
+    insertSort(sum_count, stulist)
+    #print stulist;
+    display(stulist)
+
+def insertSort(a, stulist):
+    for i in range(len(a)-1):
+        #print a,i
+        for j in range(i+1,len(a)):
+            if a[i]<a[j]:
+                temp = stulist[i]
+                stulist[i] = stulist[j]
+                stulist[j] = temp
+    #return a
+
+def Init(stulist):  #初始化函数
+    print ("初始化......")
+    file_object = open('students.txt', 'r')
+    for line in file_object:
+        stu = Student()
+        line = line.strip("\n")
+        s = line.split(" ")
+        stu.ID = s[0]
+        stu.name = s[1]
+        stu.score1 = s[2]
+        stu.score2 = s[3]
+        stu.score3 = s[4]
+        stu.sum = s[5]
+        stulist.append(stu)
+    file_object.close()
+    print ("初始化成功！")
+    main()
+
+def main(): #主函数 该程序的入口函数
+    while True:
+        print ("*********************")
+        print (u"--------菜单---------")
+        print (u"增加学生信息--------1")
+        print (u"查找学生信息--------2")
+        print (u"删除学生信息--------3")
+        print (u"修改学生信息--------4")
+        print (u"所有学生信息--------5")
+        print (u"按照分数排序--------6")
+        print (u"退出程序------------0")
+        print ("*********************")
+
+        nChoose = input("请输入你的选择：")
+        if nChoose == "1":
+            stu = Student()
+            stu.name = input("请输入学生的姓名")
+            while True:
+                stu.ID = input("请输入学生的ID")
+                p = re.compile('^[0-9]{3}$')
+                if p.match(stu.ID):
+                    break
+                else:
+                    print ("输入的有错误！")
+            while True:
+                stu.score1 = int(input("请输入学生语文成绩"))
+                if stu.score1 <= 100 and stu.score1 > 0 :
+                    break
+                else:
+                    print ("输入的学生成绩有错误！")
+            while True:
+                stu.score2 = int(input("请输入学生数学成绩"))
+                if stu.score2 <= 100 and stu.score2 > 0 :
+                    break
+                else:
+                    print ("输入的学生成绩有错误！")
+            while True:
+                stu.score3 = int(input("请输入学生英语成绩"))
+                if stu.score3 <= 100 and stu.score3 > 0 :
+                    break
+                else:
+                    print ("输入的学生成绩有错误！")
+            stu.sum = stu.score1 + stu.score2 + stu.score3
+            Add(stulist,stu)
+
+        if nChoose == '2':
+            ID = input("请输入学生的ID")
+            Search(stulist, ID)
+
+        if nChoose == '3':
+            ID = input("请输入学生的ID")
+            Del(stulist, ID)
+        if nChoose == '4':
+            ID = input("请输入学生的ID")
+            Change(stulist, ID)
+
+        if nChoose == '5':
+            display(stulist)
+
+        if nChoose == '6':
+            Sort(stulist)
+
+
+        if nChoose == '0':
+            break
+
+if __name__ == '__main__':
+    stulist =[]
+Init(stulist)

实验/students.txt

@@ -0,0 +1 @@
+123 a 12 23 13 48

实验/猪肉价格.py

@@ -0,0 +1,38 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import json, time, requests, os
+
+url = "https://zhujia.zhuwang.cc/api/chartData?areaId=-1&aa=%d"% int(time.time()*1000)
+
+header = {'User-Agent': 'Mozilla/5.0'}
+html = requests.get(url, headers=header).text
+
+j0 = json.loads(html)
+
+priceList = []
+
+print("***********",j0.keys())
+
+if not os.path.exists("猪肉价格"):
+    os.mkdir("猪肉价格")
+
+# j0['pig_in'][i], j0['pig_local'][i], j0['maizeprice'][i], j0['bean'][i]
+for item in j0:
+    if item != "time":
+        f = open("猪肉价格/"+item+'.txt', 'w+')
+        for i in range(366):
+            f.write("%.2f\n" % float(j0[item][i]))
+        f.close()
+        plt.figure(item)
+        plt.title(item)
+        plt.plot(j0[item])
+        plt.xlabel("时间")
+        plt.ylabel("元/公斤")
+        plt.xlim([0, 366])
+        plt.savefig("猪肉价格/"+item + '.png', dpi=600)
+    else:
+        f = open("猪肉价格/"+item+'.txt', 'w+')
+        for i in range(4):
+            for j in range(3):
+                f.write("%s" % j0[item][i][j])
+            f.write("\n")

实验/猪肉价格/bean.txt

@@ -0,0 +1,366 @@
+3186.00
+3192.00
+3174.00
+3165.00
+3177.00
+3189.00
+3158.00
+3174.00
+3164.00
+3162.00
+3147.00
+3162.00
+3158.00
+3161.00
+3153.00
+3153.00
+3157.00
+3161.00
+3144.00
+3138.00
+3140.00
+3146.00
+3107.00
+3125.00
+3129.00
+3135.00
+3178.00
+3189.00
+3186.00
+3182.00
+3110.00
+3112.00
+3124.00
+3093.00
+3096.00
+3110.00
+3087.00
+3088.00
+3070.00
+3077.00
+3088.00
+3073.00
+3078.00
+3080.00
+3078.00
+3068.00
+3047.00
+3075.00
+3070.00
+3043.00
+3047.00
+3082.00
+3048.00
+3027.00
+3075.00
+3067.00
+3050.00
+3039.00
+3119.00
+3036.00
+3011.00
+3016.00
+3004.00
+2983.00
+2987.00
+2993.00
+3055.00
+3097.00
+3086.00
+3121.00
+3093.00
+3085.00
+3081.00
+3076.00
+3078.00
+3113.00
+3071.00
+3070.00
+3132.00
+3134.00
+3136.00
+3107.00
+3122.00
+3124.00
+3137.00
+3101.00
+3095.00
+3113.00
+3111.00
+3084.00
+3133.00
+3127.00
+3142.00
+3128.00
+3161.00
+3146.00
+3135.00
+3132.00
+3125.00
+3153.00
+3139.00
+3142.00
+3137.00
+3123.00
+3118.00
+3134.00
+3119.00
+3111.00
+3133.00
+3105.00
+3120.00
+3112.00
+3122.00
+3122.00
+3114.00
+3109.00
+3131.00
+3115.00
+3149.00
+3149.00
+3143.00
+3125.00
+3162.00
+3160.00
+3147.00
+3198.00
+3219.00
+3233.00
+3240.00
+3244.00
+3243.00
+3273.00
+3276.00
+3278.00
+3301.00
+3298.00
+3294.00
+3309.00
+3303.00
+3309.00
+3306.00
+3308.00
+3305.00
+3317.00
+3370.00
+3300.00
+3306.00
+3320.00
+3303.00
+3304.00
+3288.00
+3278.00
+3297.00
+3281.00
+3282.00
+3281.00
+3294.00
+3262.00
+3306.00
+3267.00
+3241.00
+3268.00
+3246.00
+3259.00
+3254.00
+3258.00
+3242.00
+3239.00
+3246.00
+3268.00
+3274.00
+3226.00
+3242.00
+3214.00
+3186.00
+3191.00
+3178.00
+3167.00
+3153.00
+3161.00
+3128.00
+3142.00
+3126.00
+3152.00
+3147.00
+3137.00
+3151.00
+3141.00
+3105.00
+3154.00
+3123.00
+3125.00
+3116.00
+3115.00
+3102.00
+3132.00
+3122.00
+3131.00
+3131.00
+3130.00
+3116.00
+3135.00
+3135.00
+3152.00
+3124.00
+3130.00
+3130.00
+3119.00
+3135.00
+3123.00
+3127.00
+3106.00
+3120.00
+3120.00
+3113.00
+3111.00
+3118.00
+3125.00
+3123.00
+3123.00
+3120.00
+3119.00
+3116.00
+3084.00
+3095.00
+3122.00
+3119.00
+3114.00
+3141.00
+3140.00
+3147.00
+3135.00
+3159.00
+3153.00
+3139.00
+3171.00
+3152.00
+3148.00
+3150.00
+3156.00
+3152.00
+3154.00
+3169.00
+3169.00
+3178.00
+3172.00
+3154.00
+3191.00
+3178.00
+3184.00
+3206.00
+3196.00
+3224.00
+3227.00
+3227.00
+3218.00
+3229.00
+3225.00
+3233.00
+3244.00
+3253.00
+3237.00
+3244.00
+3260.00
+3242.00
+3254.00
+3227.00
+3224.00
+3226.00
+3212.00
+3218.00
+3219.00
+3224.00
+3201.00
+3212.00
+3212.00
+3194.00
+3210.00
+3206.00
+3202.00
+3178.00
+3190.00
+3203.00
+3200.00
+3178.00
+3191.00
+3199.00
+3212.00
+3198.00
+3232.00
+3226.00
+3212.00
+3200.00
+3207.00
+3208.00
+3196.00
+3223.00
+3225.00
+3218.00
+3220.00
+3238.00
+3230.00
+3229.00
+3238.00
+3235.00
+3248.00
+3237.00
+3251.00
+3253.00
+3257.00
+3228.00
+3237.00
+3249.00
+3266.00
+3258.00
+3248.00
+3264.00
+3267.00
+3262.00
+3267.00
+3275.00
+3279.00
+3274.00
+3269.00
+3289.00
+3274.00
+3292.00
+3291.00
+3319.00
+3319.00
+3318.00
+3328.00
+3344.00
+3331.00
+3351.00
+3353.00
+3353.00
+3340.00
+3375.00
+3371.00
+3381.00
+3366.00
+3403.00
+3409.00
+3401.00
+3397.00
+3403.00
+3414.00
+3394.00
+3412.00
+3392.00
+3400.00
+3387.00
+3381.00
+3403.00
+3394.00
+3414.00
+3418.00
+3414.00
+3406.00
+3393.00
+3391.00
+3421.00
+3406.00
+3430.00
+3413.00

实验/猪肉价格/maizeprice.txt

@@ -0,0 +1,366 @@
+1965.00
+1990.00
+1977.00
+1991.00
+1988.00
+1995.00
+2002.00
+1982.00
+1987.00
+1982.00
+1987.00
+1989.00
+1992.00
+1991.00
+1980.00
+1985.00
+1979.00
+1971.00
+1975.00
+1967.00
+1968.00
+1976.00
+1971.00
+1972.00
+1960.00
+1976.00
+1966.00
+1970.00
+1967.00
+1970.00
+1969.00
+1968.00
+1971.00
+1970.00
+1963.00
+1968.00
+1973.00
+1973.00
+1953.00
+1965.00
+1967.00
+1955.00
+1962.00
+1965.00
+1959.00
+1962.00
+1975.00
+1955.00
+1965.00
+1988.00
+1964.00
+1962.00
+1961.00
+1947.00
+1946.00
+1949.00
+1950.00
+1957.00
+1975.00
+1943.00
+1948.00
+1930.00
+1960.00
+1947.00
+1946.00
+1926.00
+1939.00
+1945.00
+1941.00
+1958.00
+1955.00
+1959.00
+1951.00
+1973.00
+1973.00
+1962.00
+1955.00
+1965.00
+1976.00
+1986.00
+1989.00
+1977.00
+2000.00
+1981.00
+2010.00
+1986.00
+1999.00
+2018.00
+2004.00
+2004.00
+2022.00
+2021.00
+2021.00
+2028.00
+2033.00
+2031.00
+2022.00
+2016.00
+2027.00
+2043.00
+2034.00
+2027.00
+2026.00
+2022.00
+1996.00
+2018.00
+2008.00
+2002.00
+1994.00
+2016.00
+2003.00
+1993.00
+1994.00
+1997.00
+1984.00
+1998.00
+1986.00
+1998.00
+2007.00
+2003.00
+2015.00
+1998.00
+1995.00
+1987.00
+1999.00
+1998.00
+2001.00
+2006.00
+1997.00
+2009.00
+1987.00
+1999.00
+1990.00
+2009.00
+2004.00
+2010.00
+2017.00
+2028.00
+2022.00
+2034.00
+2026.00
+2032.00
+2024.00
+2030.00
+2033.00
+2024.00
+2039.00
+2030.00
+2037.00
+2040.00
+2050.00
+2057.00
+2062.00
+2041.00
+2048.00
+2048.00
+2061.00
+2070.00
+2060.00
+2057.00
+2073.00
+2072.00
+2075.00
+2081.00
+2081.00
+2080.00
+2090.00
+2080.00
+2085.00
+2098.00
+2094.00
+2096.00
+2104.00
+2118.00
+2107.00
+2112.00
+2107.00
+2113.00
+2113.00
+2102.00
+2123.00
+2111.00
+2112.00
+2118.00
+2128.00
+2122.00
+2125.00
+2114.00
+2105.00
+2106.00
+2099.00
+2095.00
+2098.00
+2097.00
+2114.00
+2111.00
+2117.00
+2105.00
+2107.00
+2114.00
+2103.00
+2127.00
+2108.00
+2113.00
+2104.00
+2129.00
+2120.00
+2115.00
+2114.00
+2103.00
+2119.00
+2127.00
+2134.00
+2131.00
+2141.00
+2155.00
+2144.00
+2142.00
+2124.00
+2128.00
+2148.00
+2147.00
+2148.00
+2160.00
+2158.00
+2162.00
+2177.00
+2178.00
+2165.00
+2176.00
+2176.00
+2172.00
+2181.00
+2178.00
+2203.00
+2213.00
+2190.00
+2216.00
+2211.00
+2212.00
+2205.00
+2197.00
+2215.00
+2208.00
+2200.00
+2218.00
+2225.00
+2242.00
+2247.00
+2255.00
+2259.00
+2268.00
+2278.00
+2288.00
+2316.00
+2316.00
+2309.00
+2343.00
+2341.00
+2344.00
+2367.00
+2352.00
+2362.00
+2368.00
+2354.00
+2362.00
+2359.00
+2364.00
+2364.00
+2335.00
+2378.00
+2345.00
+2368.00
+2376.00
+2339.00
+2367.00
+2354.00
+2377.00
+2351.00
+2362.00
+2342.00
+2355.00
+2345.00
+2343.00
+2346.00
+2354.00
+2358.00
+2350.00
+2340.00
+2339.00
+2321.00
+2329.00
+2347.00
+2333.00
+2356.00
+2350.00
+2324.00
+2325.00
+2326.00
+2347.00
+2331.00
+2340.00
+2339.00
+2334.00
+2316.00
+2327.00
+2330.00
+2335.00
+2337.00
+2327.00
+2316.00
+2319.00
+2320.00
+2327.00
+2320.00
+2344.00
+2303.00
+2312.00
+2323.00
+2325.00
+2330.00
+2320.00
+2323.00
+2313.00
+2316.00
+2325.00
+2324.00
+2333.00
+2338.00
+2345.00
+2341.00
+2341.00
+2339.00
+2369.00
+2360.00
+2383.00
+2358.00
+2399.00
+2391.00
+2407.00
+2419.00
+2420.00
+2438.00
+2444.00
+2430.00
+2445.00
+2451.00
+2443.00
+2456.00
+2466.00
+2460.00
+2458.00
+2452.00
+2421.00
+2436.00
+2457.00
+2465.00
+2460.00
+2468.00
+2463.00
+2465.00
+2450.00
+2479.00
+2451.00
+2454.00
+2457.00

实验/猪肉价格/pig_in.txt

@@ -0,0 +1,366 @@
+31.58
+32.10
+32.01
+32.15
+32.23
+32.22
+32.19
+31.86
+31.39
+31.07
+31.17
+31.52
+32.12
+33.29
+33.62
+33.68
+34.00
+33.68
+33.60
+33.47
+33.44
+33.32
+32.91
+32.61
+32.60
+32.44
+32.65
+32.77
+32.98
+32.72
+32.84
+32.89
+32.89
+32.79
+32.82
+32.97
+32.90
+33.02
+32.96
+32.95
+32.93
+33.03
+33.15
+33.93
+34.53
+34.57
+34.61
+34.66
+34.99
+35.25
+35.11
+35.26
+35.17
+35.08
+35.37
+35.71
+35.67
+35.76
+35.08
+35.22
+35.27
+35.40
+35.32
+35.49
+35.09
+35.25
+35.33
+35.55
+35.85
+35.85
+35.68
+35.70
+35.55
+35.41
+35.86
+35.60
+35.69
+35.96
+35.64
+35.93
+35.91
+36.15
+36.42
+36.34
+36.97
+36.89
+37.32
+37.19
+37.20
+37.38
+37.18
+36.89
+37.10
+37.11
+36.94
+36.28
+36.14
+35.90
+36.47
+36.15
+36.10
+35.66
+35.76
+35.68
+35.62
+35.76
+35.73
+36.09
+35.80
+36.14
+35.81
+35.90
+35.81
+35.80
+35.69
+35.83
+35.72
+35.46
+35.52
+35.61
+35.68
+35.36
+35.24
+34.97
+34.72
+34.48
+34.37
+34.27
+34.23
+34.09
+33.75
+33.88
+33.88
+33.78
+33.72
+33.63
+33.55
+32.99
+33.07
+32.94
+33.20
+33.11
+32.78
+32.86
+32.83
+32.86
+32.72
+33.04
+32.79
+32.90
+32.77
+32.68
+32.81
+32.69
+32.56
+32.36
+32.23
+32.05
+32.04
+32.00
+31.85
+31.64
+31.56
+31.43
+31.14
+31.17
+31.16
+31.14
+30.91
+30.57
+30.01
+29.78
+29.40
+29.10
+28.77
+28.41
+27.86
+27.03
+25.70
+25.57
+26.07
+26.44
+26.66
+27.00
+27.37
+27.90
+28.35
+28.58
+28.42
+28.47
+28.39
+28.60
+28.57
+28.72
+28.74
+28.95
+29.75
+30.46
+30.72
+30.65
+30.66
+30.90
+31.06
+31.17
+31.30
+31.33
+31.55
+31.73
+31.79
+32.07
+32.50
+33.08
+33.49
+33.61
+33.43
+33.47
+33.78
+33.83
+33.91
+33.69
+33.79
+34.32
+34.69
+35.13
+35.33
+35.50
+35.45
+35.58
+35.63
+35.93
+36.52
+37.11
+37.38
+37.35
+37.43
+37.55
+37.73
+37.65
+37.45
+37.21
+37.07
+37.05
+37.03
+36.93
+36.97
+36.72
+36.51
+36.41
+36.36
+36.30
+36.43
+36.69
+36.73
+36.90
+37.04
+37.16
+37.17
+37.18
+37.17
+37.14
+37.13
+36.75
+37.03
+36.96
+36.83
+36.79
+36.77
+36.56
+36.38
+36.30
+36.27
+36.40
+36.44
+36.47
+36.48
+36.51
+36.77
+36.93
+36.94
+36.96
+36.68
+36.46
+36.29
+36.12
+35.81
+36.10
+36.26
+36.46
+36.42
+36.27
+36.26
+36.12
+36.13
+36.20
+36.00
+35.89
+35.53
+35.59
+35.11
+35.19
+34.76
+34.97
+34.97
+34.79
+34.37
+34.16
+34.00
+34.04
+33.85
+33.18
+32.62
+32.56
+32.68
+32.98
+32.67
+32.64
+32.65
+32.82
+32.96
+32.81
+32.29
+32.13
+32.14
+31.86
+31.52
+31.11
+30.81
+30.50
+30.28
+29.84
+29.39
+29.05
+29.59
+29.62
+29.73
+29.74
+29.38
+29.14
+29.02
+28.48
+28.46
+28.32
+28.63
+28.67
+28.72
+28.62
+28.69
+28.79
+28.96
+29.26
+29.35
+29.54
+29.24
+29.34
+29.18
+29.37
+29.35
+29.38
+29.15
+29.13
+29.17
+29.04
+29.07
+29.17
+29.19
+29.19

实验/猪肉价格/pig_local.txt

@@ -0,0 +1,366 @@
+30.99
+31.25
+31.31
+31.39
+31.40
+31.60
+31.43
+31.23
+30.78
+30.59
+30.58
+30.94
+31.45
+32.41
+32.87
+33.06
+33.34
+33.18
+32.91
+32.78
+32.85
+32.68
+32.40
+32.18
+31.91
+32.00
+31.93
+32.15
+32.45
+32.23
+32.36
+32.43
+32.42
+32.37
+32.33
+32.54
+32.37
+32.33
+32.40
+32.39
+32.38
+32.45
+32.59
+33.53
+34.00
+34.10
+34.06
+34.14
+34.37
+34.72
+34.62
+34.66
+34.56
+34.56
+34.84
+35.14
+35.24
+35.16
+34.56
+34.66
+34.77
+34.93
+34.94
+34.88
+34.52
+34.70
+34.85
+34.98
+35.25
+35.31
+35.07
+35.03
+34.92
+34.83
+35.32
+34.89
+35.11
+35.09
+34.88
+35.20
+35.30
+35.58
+35.78
+35.88
+36.45
+36.31
+36.81
+36.56
+36.73
+36.73
+36.30
+36.19
+36.40
+36.33
+36.24
+35.64
+35.57
+35.30
+35.70
+35.53
+35.48
+35.09
+35.15
+35.07
+35.29
+35.13
+35.09
+35.52
+35.21
+35.61
+35.25
+35.37
+35.43
+35.25
+35.10
+35.26
+35.19
+35.00
+35.00
+35.06
+35.06
+34.96
+34.66
+34.48
+34.15
+33.87
+33.81
+33.73
+33.65
+33.52
+33.31
+33.40
+33.36
+33.30
+33.26
+33.07
+33.04
+32.52
+32.37
+32.26
+32.53
+32.47
+32.25
+32.25
+32.26
+32.27
+32.21
+32.40
+32.18
+32.30
+32.21
+32.15
+32.25
+32.31
+32.08
+31.80
+31.69
+31.67
+31.54
+31.45
+31.42
+31.13
+31.12
+30.86
+30.53
+30.59
+30.69
+30.54
+30.38
+29.99
+29.62
+29.36
+28.86
+28.57
+28.19
+27.86
+27.41
+26.48
+25.17
+24.99
+25.60
+25.92
+26.20
+26.39
+26.81
+27.24
+27.76
+28.00
+27.81
+27.88
+27.97
+28.18
+28.21
+28.21
+28.41
+28.59
+29.21
+29.98
+30.09
+30.27
+30.12
+30.35
+30.50
+30.66
+30.87
+30.82
+30.96
+31.17
+31.25
+31.43
+31.87
+32.45
+33.06
+33.08
+32.88
+32.97
+33.25
+33.29
+33.44
+33.25
+33.25
+33.73
+34.15
+34.58
+34.77
+35.01
+34.85
+35.15
+35.20
+35.48
+35.85
+36.50
+36.87
+36.82
+36.90
+37.16
+37.26
+37.16
+36.90
+36.76
+36.63
+36.53
+36.66
+36.50
+36.48
+36.25
+36.13
+35.96
+35.86
+35.90
+36.02
+36.23
+36.27
+36.35
+36.57
+36.64
+36.71
+36.68
+36.67
+36.66
+36.74
+36.18
+36.62
+36.54
+36.46
+36.33
+36.26
+36.06
+35.91
+35.78
+35.76
+35.85
+35.93
+35.97
+36.02
+36.05
+36.32
+36.44
+36.39
+36.43
+36.25
+36.01
+35.79
+35.61
+35.27
+35.62
+35.80
+36.04
+35.96
+35.83
+35.78
+35.66
+35.62
+35.65
+35.47
+35.42
+35.01
+35.16
+34.60
+34.72
+34.33
+34.42
+34.54
+34.36
+33.92
+33.81
+33.60
+33.59
+33.21
+32.70
+31.97
+32.03
+32.19
+32.32
+32.13
+32.16
+32.30
+32.30
+32.45
+32.32
+31.83
+31.72
+31.47
+31.37
+30.98
+30.61
+30.38
+30.08
+29.72
+29.41
+29.31
+28.75
+29.09
+29.13
+29.20
+29.25
+28.91
+28.67
+28.54
+28.04
+27.99
+27.78
+28.23
+28.31
+28.25
+28.11
+28.22
+28.41
+28.54
+28.81
+28.93
+29.06
+28.90
+28.91
+28.77
+28.96
+28.93
+28.94
+28.81
+28.75
+28.74
+28.59
+28.66
+28.88
+28.79
+28.85

实验/猪肉价格/pigprice.txt

@@ -0,0 +1,366 @@
+32.41
+32.66
+32.70
+32.82
+33.30
+33.22
+32.88
+32.57
+32.18
+32.00
+31.98
+32.30
+33.00
+34.25
+34.82
+34.84
+35.00
+34.94
+34.80
+34.68
+34.46
+34.39
+34.06
+33.75
+33.40
+33.21
+33.44
+33.52
+33.82
+33.68
+33.65
+33.77
+33.74
+33.69
+33.67
+33.77
+33.72
+33.80
+33.81
+33.66
+33.73
+33.77
+34.02
+34.74
+35.42
+35.58
+35.67
+35.63
+35.98
+36.14
+36.10
+36.18
+36.06
+36.13
+36.12
+36.50
+36.68
+36.56
+36.14
+36.24
+36.32
+36.44
+36.47
+36.46
+36.33
+36.72
+36.95
+36.17
+36.41
+36.34
+36.35
+36.17
+36.18
+37.09
+37.49
+37.12
+37.44
+37.41
+37.57
+37.55
+37.47
+37.78
+37.86
+38.05
+38.30
+38.52
+38.74
+38.46
+38.54
+38.66
+38.75
+38.46
+38.39
+38.20
+38.07
+37.58
+37.44
+36.92
+37.54
+37.11
+37.04
+36.75
+36.50
+36.55
+36.60
+36.46
+36.54
+36.82
+36.64
+36.71
+36.50
+36.59
+36.61
+36.50
+36.42
+36.49
+36.41
+36.33
+36.26
+36.31
+36.19
+36.17
+35.88
+35.81
+35.46
+35.17
+35.13
+35.06
+34.91
+34.83
+34.62
+34.56
+34.46
+34.38
+34.32
+34.23
+34.20
+33.97
+33.77
+33.75
+33.97
+33.85
+33.76
+33.76
+33.27
+33.72
+33.78
+33.77
+33.78
+33.78
+33.64
+33.63
+33.62
+33.40
+33.31
+33.20
+32.92
+32.92
+32.75
+32.80
+32.72
+32.56
+32.43
+32.19
+32.13
+32.06
+32.13
+32.04
+31.82
+31.57
+31.05
+30.77
+30.37
+30.05
+29.63
+29.35
+28.74
+28.04
+26.94
+26.81
+27.32
+27.40
+27.51
+27.60
+27.87
+28.42
+28.91
+29.05
+29.07
+29.18
+29.14
+29.15
+29.41
+29.49
+29.51
+29.79
+30.55
+31.45
+31.52
+31.58
+31.55
+31.74
+31.90
+31.93
+32.05
+32.16
+32.28
+32.53
+32.64
+32.89
+33.32
+33.93
+34.34
+34.51
+34.46
+34.52
+34.57
+34.68
+34.64
+34.54
+34.64
+35.00
+35.42
+35.90
+36.09
+36.23
+36.27
+36.28
+36.34
+36.68
+37.30
+38.09
+38.34
+38.34
+38.22
+38.39
+38.45
+38.40
+38.23
+37.96
+37.85
+37.74
+37.71
+37.65
+37.42
+37.35
+37.19
+37.03
+36.98
+36.93
+37.09
+37.19
+37.31
+37.31
+37.54
+37.57
+37.81
+37.76
+37.82
+37.86
+37.81
+37.72
+37.59
+37.56
+37.49
+37.37
+37.35
+37.11
+36.97
+36.90
+36.92
+36.93
+36.97
+36.97
+37.18
+37.21
+37.29
+37.51
+37.56
+37.53
+37.42
+37.25
+36.89
+36.83
+36.66
+36.78
+36.79
+36.95
+37.07
+36.94
+36.87
+36.87
+36.81
+36.69
+36.59
+36.43
+36.15
+35.99
+35.75
+35.60
+35.42
+35.47
+35.43
+35.31
+35.02
+34.86
+34.69
+34.45
+34.20
+33.67
+33.18
+33.07
+33.39
+33.52
+33.21
+33.21
+33.15
+33.40
+33.43
+33.36
+33.19
+32.79
+32.76
+32.59
+32.20
+31.68
+31.26
+31.06
+30.65
+30.27
+29.93
+29.74
+29.86
+30.08
+30.17
+30.01
+29.93
+29.80
+29.43
+29.05
+28.89
+28.85
+28.89
+28.99
+28.92
+28.87
+28.98
+29.17
+29.48
+29.74
+29.83
+29.81
+29.66
+29.62
+29.60
+29.72
+29.67
+29.64
+29.55
+29.42
+29.41
+29.49
+29.54
+29.48
+29.46
+29.51

实验/猪肉价格/pork.txt

@@ -0,0 +1,366 @@
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+47.18
+46.86
+46.86
+46.83
+47.31
+47.47
+47.35
+47.32
+47.15
+48.12
+48.76
+48.11
+49.10
+49.19
+49.36
+49.29
+49.04
+48.68
+49.11
+48.71
+49.37
+49.64
+49.56
+50.06
+49.97
+49.55
+49.93
+50.43
+50.12
+49.91
+50.14
+50.23
+50.47
+50.49
+50.47
+50.20
+49.99
+50.07
+49.67
+49.46
+49.44
+49.21
+49.14
+48.79
+48.88
+48.89
+49.33
+48.52
+48.51
+48.49
+48.44
+48.38
+48.56
+48.42
+48.42
+48.16
+47.89
+47.96
+48.24
+48.14
+48.09
+47.65
+47.86
+47.61
+47.53
+47.48
+47.52
+47.29
+47.40
+47.23
+47.25
+47.13
+46.86
+46.92
+47.18
+46.64
+46.64
+46.28
+46.26
+46.23
+46.16
+45.96
+45.70
+45.59
+45.38
+45.12
+44.71
+45.15
+44.98
+44.99
+44.89
+44.93
+44.77
+44.61
+44.78
+44.90
+44.57
+44.49
+44.36
+44.18
+44.15
+44.51
+43.87
+44.25
+43.90
+43.42
+43.52
+43.53
+43.44
+43.17
+43.20
+43.11
+43.16
+42.75
+42.76
+42.29
+42.11
+41.54
+41.45
+40.87
+40.59
+39.68
+39.21
+39.60
+39.30
+39.12
+38.86
+38.81
+38.86
+39.25
+38.91
+39.18
+38.87
+39.08
+38.74
+38.75
+38.79
+38.64
+38.85
+39.13
+39.86
+39.73
+39.94
+40.46
+40.51
+40.19
+40.84
+40.24
+40.80
+40.69
+41.39
+41.50
+41.27
+41.73
+42.25
+42.72
+43.25
+44.02
+44.20
+44.67
+44.69
+44.72
+44.97
+45.05
+45.41
+45.35
+45.60
+45.87
+46.09
+46.49
+46.42
+46.72
+47.03
+47.24
+47.77
+47.93
+48.11
+48.85
+48.84
+48.80
+48.80
+48.82
+48.53
+48.46
+48.99
+48.83
+48.80
+48.92
+48.88
+48.67
+48.94
+49.34
+48.63
+48.90
+48.24
+48.49
+48.35
+48.47
+48.34
+48.25
+48.46
+48.30
+48.33
+48.47
+48.55
+48.88
+48.58
+48.54
+48.25
+48.20
+48.11
+48.41
+48.08
+48.18
+48.10
+48.40
+48.18
+48.75
+48.07
+48.80
+48.03
+48.57
+48.41
+48.25
+48.43
+48.42
+48.22
+48.31
+48.47
+47.95
+48.24
+48.07
+48.03
+48.17
+48.36
+48.37
+47.85
+47.71
+47.40
+47.73
+47.71
+47.68
+47.67
+47.28
+47.29
+47.27
+47.29
+47.27
+46.77
+47.09
+46.32
+46.09
+46.07
+45.74
+46.03
+45.38
+46.08
+45.87
+45.58
+45.57
+45.16
+44.70
+44.55
+44.34
+44.55
+43.96
+43.65
+42.90
+42.77
+43.17
+42.63
+42.41
+42.30
+41.95
+42.52
+41.53
+41.13
+40.97
+40.43
+41.09
+40.46
+39.75
+39.75
+40.09
+39.10
+38.85
+38.59
+39.24
+39.54
+39.34
+39.40
+39.18
+39.37
+39.27
+39.33
+39.38
+39.26
+39.32
+39.73
+39.26
+38.70
+38.85
+39.65
+39.23
+39.27

实验/猪肉价格/time.txt

@@ -0,0 +1,4 @@
+20201020
+20200820
+20200523
+20191120

机器学习/adboost/adboost.py

@@ -0,0 +1,309 @@
+#!/usr/bin/python
+# coding:utf8
+# https://blog.csdn.net/qq_36523839/article/details/81904966
+'''
+Created on Nov 28, 2010
+Update  on 2017-05-18
+Adaboost is short for Adaptive Boosting
+Author: Peter/片刻
+GitHub: https://github.com/apachecn/AiLearning
+'''
+from __future__ import print_function
+from numpy import *
+
+
+def loadSimpData():
+    """ 测试数据
+    Returns:
+        dataArr   feature对应的数据集
+        labelArr  feature对应的分类标签
+    """
+    dataArr = array([[1., 2.1], [2., 1.1], [1.3, 1.], [1., 1.], [2., 1.]])
+    labelArr = [1.0, 1.0, -1.0, -1.0, 1.0]
+    return dataArr, labelArr
+
+
+# general function to parse tab -delimited floats
+def loadDataSet(fileName):
+    # get number of fields
+    numFeat = len(open(fileName).readline().split('\t'))
+    dataArr = []
+    labelArr = []
+    fr = open(fileName)
+    for line in fr.readlines():
+        lineArr = []
+        curLine = line.strip().split('\t')
+        for i in range(numFeat-1):
+            lineArr.append(float(curLine[i]))
+        dataArr.append(lineArr)
+        labelArr.append(float(curLine[-1]))
+    return dataArr, labelArr
+
+
+def stumpClassify(dataMat, dimen, threshVal, threshIneq):
+    """stumpClassify(将数据集，按照feature列的value进行 二分法切分比较来赋值分类)
+    Args:
+        dataMat    Matrix数据集
+        dimen      特征列
+        threshVal  特征列要比较的值
+    Returns:
+        retArray 结果集
+    """
+    # 默认都是1
+    retArray = ones((shape(dataMat)[0], 1))
+    # dataMat[:, dimen] 表示数据集中第dimen列的所有值
+    # threshIneq == 'lt'表示修改左边的值，gt表示修改右边的值
+    # print '-----', threshIneq, dataMat[:, dimen], threshVal
+    if threshIneq == 'lt':
+        retArray[dataMat[:, dimen] <= threshVal] = -1.0
+    else:
+        retArray[dataMat[:, dimen] > threshVal] = -1.0
+    return retArray
+
+
+def buildStump(dataArr, labelArr, D):
+    """buildStump(得到决策树的模型)
+    Args:
+        dataArr   特征标签集合
+        labelArr  分类标签集合
+        D         最初的样本的所有特征权重集合
+    Returns:
+        bestStump    最优的分类器模型
+        minError     错误率
+        bestClasEst  训练后的结果集
+    """
+    # 转换数据
+    dataMat = mat(dataArr)
+    labelMat = mat(labelArr).T
+    # m行 n列
+    m, n = shape(dataMat)
+
+    # 初始化数据
+    numSteps = 10.0
+    bestStump = {}
+    bestClasEst = mat(zeros((m, 1)))
+    # 初始化的最小误差为无穷大
+    minError = inf
+
+    # 循环所有的feature列，将列切分成 若干份，每一段以最左边的点作为分类节点
+    for i in range(n):
+        rangeMin = dataMat[:, i].min()
+        rangeMax = dataMat[:, i].max()
+        # print 'rangeMin=%s, rangeMax=%s' % (rangeMin, rangeMax)
+        # 计算每一份的元素个数
+        stepSize = (rangeMax-rangeMin)/numSteps
+        # 例如:  4=(10-1)/2   那么  1-4(-1次)   1(0次)  1+1*4(1次)   1+2*4(2次)
+        # 所以:  循环 -1/0/1/2
+        for j in range(-1, int(numSteps)+1):
+            # go over less than and greater than
+            for inequal in ['lt', 'gt']:
+                # 如果是-1，那么得到rangeMin-stepSize; 如果是numSteps，那么得到rangeMax
+                threshVal = (rangeMin + float(j) * stepSize)
+                # 对单层决策树进行简单分类，得到预测的分类值
+                predictedVals = stumpClassify(dataMat, i, threshVal, inequal)
+                # print predictedVals
+                errArr = mat(ones((m, 1)))
+                # 正确为0，错误为1
+                errArr[predictedVals == labelMat] = 0
+                # 计算 平均每个特征的概率0.2*错误概率的总和为多少，就知道错误率多高
+                # 例如:  一个都没错，那么错误率= 0.2*0=0 ， 5个都错，那么错误率= 0.2*5=1， 只错3个，那么错误率= 0.2*3=0.6
+                weightedError = D.T*errArr
+                '''
+                dim            表示 feature列
+                threshVal      表示树的分界值
+                inequal        表示计算树左右颠倒的错误率的情况
+                weightedError  表示整体结果的错误率
+                bestClasEst    预测的最优结果
+                '''
+                # print "split: dim %d, thresh %.2f, thresh ineqal: %s, the weighted error is %.3f" % (i, threshVal, inequal, weightedError)
+                if weightedError < minError:
+                    minError = weightedError
+                    bestClasEst = predictedVals.copy()
+                    bestStump['dim'] = i
+                    bestStump['thresh'] = threshVal
+                    bestStump['ineq'] = inequal
+
+    # bestStump 表示分类器的结果，在第几个列上，用大于／小于比较，阈值是多少
+    return bestStump, minError, bestClasEst
+
+
+def adaBoostTrainDS(dataArr, labelArr, numIt=40):
+    """adaBoostTrainDS(adaBoost训练过程放大)
+    Args:
+        dataArr   特征标签集合
+        labelArr  分类标签集合
+        numIt     实例数
+    Returns:
+        weakClassArr  弱分类器的集合
+        aggClassEst   预测的分类结果值
+    """
+    weakClassArr = []
+    m = shape(dataArr)[0]
+    # 初始化 D，设置每行数据的样本的所有特征权重集合，平均分为m份
+    D = mat(ones((m, 1))/m)
+    aggClassEst = mat(zeros((m, 1)))
+    for i in range(numIt):
+        # 得到决策树的模型
+        bestStump, error, classEst = buildStump(dataArr, labelArr, D)
+
+        # alpha 目的主要是计算每一个分类器实例的权重(加和就是分类结果)
+        # 计算每个分类器的 alpha 权重值
+        alpha = float(0.5*log((1.0-error)/max(error, 1e-16)))
+        bestStump['alpha'] = alpha
+        # store Stump Params in Array
+        weakClassArr.append(bestStump)
+
+        # print "alpha=%s, classEst=%s, bestStump=%s, error=%s " % (alpha, classEst.T, bestStump, error)
+        # 分类正确: 乘积为1，不会影响结果，-1主要是下面求e的-alpha次方
+        # 分类错误: 乘积为 -1，结果会受影响，所以也乘以 -1
+        expon = multiply(-1*alpha*mat(labelArr).T, classEst)
+        # print '\n'
+        # print 'labelArr=', labelArr
+        # print 'classEst=', classEst.T
+        # print '\n'
+        # print '乘积: ', multiply(mat(labelArr).T, classEst).T
+        # 判断正确的，就乘以-1，否则就乘以1， 为什么？ 书上的公式。
+        # print '(-1取反)预测值expon=', expon.T
+        # 计算e的expon次方，然后计算得到一个综合的概率的值
+        # 结果发现:  判断错误的样本，D对于的样本权重值会变大。
+        D = multiply(D, exp(expon))
+        D = D/D.sum()
+        # print "D: ", D.T
+        # print '\n'
+
+        # 预测的分类结果值，在上一轮结果的基础上，进行加和操作
+        # print '当前的分类结果: ', alpha*classEst.T
+        aggClassEst += alpha*classEst
+        # print "叠加后的分类结果aggClassEst: ", aggClassEst.T
+        # sign 判断正为1， 0为0， 负为-1，通过最终加和的权重值，判断符号。
+        # 结果为: 错误的样本标签集合，因为是 !=,那么结果就是0 正, 1 负
+        aggErrors = multiply(sign(aggClassEst) != mat(labelArr).T, ones((m, 1)))
+        errorRate = aggErrors.sum()/m
+        # print "total error=%s " % (errorRate)
+        if errorRate == 0.0:
+            break
+    return weakClassArr, aggClassEst
+
+
+def adaClassify(datToClass, classifierArr):
+    # do stuff similar to last aggClassEst in adaBoostTrainDS
+    dataMat = mat(datToClass)
+    m = shape(dataMat)[0]
+    aggClassEst = mat(zeros((m, 1)))
+
+    # 循环 多个分类器
+    for i in range(len(classifierArr)):
+        # 前提:  我们已经知道了最佳的分类器的实例
+        # 通过分类器来核算每一次的分类结果，然后通过alpha*每一次的结果 得到最后的权重加和的值。
+        classEst = stumpClassify(dataMat, classifierArr[i]['dim'], classifierArr[i]['thresh'], classifierArr[i]['ineq'])
+        aggClassEst += classifierArr[i]['alpha']*classEst
+        # print aggClassEst
+    return sign(aggClassEst)
+
+
+def plotROC(predStrengths, classLabels):
+    """plotROC(打印ROC曲线，并计算AUC的面积大小)
+    Args:
+        predStrengths  最终预测结果的权重值
+        classLabels    原始数据的分类结果集
+    """
+    print('predStrengths=', predStrengths)
+    print('classLabels=', classLabels)
+
+    import matplotlib.pyplot as plt
+    # variable to calculate AUC
+    ySum = 0.0
+    # 对正样本的进行求和
+    numPosClas = sum(array(classLabels)==1.0)
+    # 正样本的概率
+    yStep = 1/float(numPosClas)
+    # 负样本的概率
+    xStep = 1/float(len(classLabels)-numPosClas)
+    # argsort函数返回的是数组值从小到大的索引值
+    # get sorted index, it's reverse
+    sortedIndicies = predStrengths.argsort()
+    # 测试结果是否是从小到大排列
+    print('sortedIndicies=', sortedIndicies, predStrengths[0, 176], predStrengths.min(), predStrengths[0, 293], predStrengths.max())
+
+    # 开始创建模版对象
+    fig = plt.figure()
+    fig.clf()
+    ax = plt.subplot(111)
+    # cursor光标值
+    cur = (1.0, 1.0)
+    # loop through all the values, drawing a line segment at each point
+    for index in sortedIndicies.tolist()[0]:
+        if classLabels[index] == 1.0:
+            delX = 0
+            delY = yStep
+        else:
+            delX = xStep
+            delY = 0
+            ySum += cur[1]
+        # draw line from cur to (cur[0]-delX, cur[1]-delY)
+        # 画点连线 (x1, x2, y1, y2)
+        print(cur[0], cur[0]-delX, cur[1], cur[1]-delY)
+        ax.plot([cur[0], cur[0]-delX], [cur[1], cur[1]-delY], c='b')
+        cur = (cur[0]-delX, cur[1]-delY)
+    # 画对角的虚线线
+    ax.plot([0, 1], [0, 1], 'b--')
+    plt.xlabel('False positive rate')
+    plt.ylabel('True positive rate')
+    plt.title('ROC curve for AdaBoost horse colic detection system')
+    # 设置画图的范围区间 (x1, x2, y1, y2)
+    ax.axis([0, 1, 0, 1])
+    plt.show()
+    '''
+    参考说明: http://blog.csdn.net/wenyusuran/article/details/39056013
+    为了计算 AUC ，我们需要对多个小矩形的面积进行累加。
+    这些小矩形的宽度是xStep，因此可以先对所有矩形的高度进行累加，最后再乘以xStep得到其总面积。
+    所有高度的和(ySum)随着x轴的每次移动而渐次增加。
+    '''
+    print("the Area Under the Curve is: ", ySum*xStep)
+
+
+if __name__ == "__main__":
+    # # 我们要将5个点进行分类
+    dataArr, labelArr = loadSimpData()
+    print ('dataArr', dataArr, 'labelArr', labelArr)
+
+    # # D表示最初值，对1进行均分为5份，平均每一个初始的概率都为0.2
+    # # D的目的是为了计算错误概率:  weightedError = D.T*errArr
+
+    D = mat(ones((5, 1))/5)
+    print ('D=', D.T)
+
+    bestStump, minError, bestClasEst = buildStump(dataArr, labelArr, D)
+    print ('bestStump=', bestStump)
+    print ('minError=', minError)
+    print ('bestClasEst=', bestClasEst.T)
+
+    # # 分类器: weakClassArr
+    # # 历史累计的分类结果集
+    weakClassArr, aggClassEst = adaBoostTrainDS(dataArr, labelArr, 9)
+    print ('\nweakClassArr=', weakClassArr, '\naggClassEst=', aggClassEst.T)
+
+    # """
+    # 发现:
+    # 分类的权重值: 最大的值，为alpha的加和，最小值为-最大值
+    # 特征的权重值: 如果一个值误判的几率越小，那么D的特征权重越少
+    # """
+
+    # # 测试数据的分类结果, 观测: aggClassEst分类的最终权重
+    print (adaClassify([0, 0], weakClassArr).T)
+    print (adaClassify([[5, 5], [0, 0]], weakClassArr).T)
+
+    # 马疝病数据集
+    # 训练集合
+    # dataArr, labelArr = loadDataSet("horseColicTraining2.txt")
+    # weakClassArr, aggClassEst = adaBoostTrainDS(dataArr, labelArr, 40)
+    # print(weakClassArr, '\n-----\n', aggClassEst.T)
+    # # 计算ROC下面的AUC的面积大小
+    # plotROC(aggClassEst.T, labelArr)
+    # # 测试集合
+    # dataArrTest, labelArrTest = loadDataSet("horseColicTest2.txt")
+    # m = shape(dataArrTest)[0]
+    # predicting10 = adaClassify(dataArrTest, weakClassArr)
+    # errArr = mat(ones((m, 1)))
+    # # 测试: 计算总样本数，错误样本数，错误率
+    # print(m, errArr[predicting10 != mat(labelArrTest).T].sum(), errArr[predicting10 != mat(labelArrTest).T].sum()/m)

机器学习/adboost/horseColicTest2.txt

@@ -0,0 +1,67 @@
+2.000000	1.000000	38.500000	54.000000	20.000000	0.000000	1.000000	2.000000	2.000000	3.000000	4.000000	1.000000	2.000000	2.000000	5.900000	0.000000	2.000000	42.000000	6.300000	0.000000	0.000000	1.000000
+2.000000	1.000000	37.600000	48.000000	36.000000	0.000000	0.000000	1.000000	1.000000	0.000000	3.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	44.000000	6.300000	1.000000	5.000000	1.000000
+1.000000	1.000000	37.700000	44.000000	28.000000	0.000000	4.000000	3.000000	2.000000	5.000000	4.000000	4.000000	1.000000	1.000000	0.000000	3.000000	5.000000	45.000000	70.000000	3.000000	2.000000	1.000000
+1.000000	1.000000	37.000000	56.000000	24.000000	3.000000	1.000000	4.000000	2.000000	4.000000	4.000000	3.000000	1.000000	1.000000	0.000000	0.000000	0.000000	35.000000	61.000000	3.000000	2.000000	-1.000000
+2.000000	1.000000	38.000000	42.000000	12.000000	3.000000	0.000000	3.000000	1.000000	1.000000	0.000000	1.000000	0.000000	0.000000	0.000000	0.000000	2.000000	37.000000	5.800000	0.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	60.000000	40.000000	3.000000	0.000000	1.000000	1.000000	0.000000	4.000000	0.000000	3.000000	2.000000	0.000000	0.000000	5.000000	42.000000	72.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.400000	80.000000	60.000000	3.000000	2.000000	2.000000	1.000000	3.000000	2.000000	1.000000	2.000000	2.000000	0.000000	1.000000	1.000000	54.000000	6.900000	0.000000	0.000000	1.000000
+2.000000	1.000000	37.800000	48.000000	12.000000	2.000000	1.000000	2.000000	1.000000	3.000000	0.000000	1.000000	2.000000	0.000000	0.000000	2.000000	0.000000	48.000000	7.300000	1.000000	0.000000	1.000000
+2.000000	1.000000	37.900000	45.000000	36.000000	3.000000	3.000000	3.000000	2.000000	2.000000	3.000000	1.000000	2.000000	1.000000	0.000000	3.000000	0.000000	33.000000	5.700000	3.000000	0.000000	1.000000
+2.000000	1.000000	39.000000	84.000000	12.000000	3.000000	1.000000	5.000000	1.000000	2.000000	4.000000	2.000000	1.000000	2.000000	7.000000	0.000000	4.000000	62.000000	5.900000	2.000000	2.200000	-1.000000
+2.000000	1.000000	38.200000	60.000000	24.000000	3.000000	1.000000	3.000000	2.000000	3.000000	3.000000	2.000000	3.000000	3.000000	0.000000	4.000000	4.000000	53.000000	7.500000	2.000000	1.400000	1.000000
+1.000000	1.000000	0.000000	140.000000	0.000000	0.000000	0.000000	4.000000	2.000000	5.000000	4.000000	4.000000	1.000000	1.000000	0.000000	0.000000	5.000000	30.000000	69.000000	0.000000	0.000000	-1.000000
+1.000000	1.000000	37.900000	120.000000	60.000000	3.000000	3.000000	3.000000	1.000000	5.000000	4.000000	4.000000	2.000000	2.000000	7.500000	4.000000	5.000000	52.000000	6.600000	3.000000	1.800000	-1.000000
+2.000000	1.000000	38.000000	72.000000	36.000000	1.000000	1.000000	3.000000	1.000000	3.000000	0.000000	2.000000	2.000000	1.000000	0.000000	3.000000	5.000000	38.000000	6.800000	2.000000	2.000000	1.000000
+2.000000	9.000000	38.000000	92.000000	28.000000	1.000000	1.000000	2.000000	1.000000	1.000000	3.000000	2.000000	3.000000	0.000000	7.200000	0.000000	0.000000	37.000000	6.100000	1.000000	1.100000	1.000000
+1.000000	1.000000	38.300000	66.000000	30.000000	2.000000	3.000000	1.000000	1.000000	2.000000	4.000000	3.000000	3.000000	2.000000	8.500000	4.000000	5.000000	37.000000	6.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	37.500000	48.000000	24.000000	3.000000	1.000000	1.000000	1.000000	2.000000	1.000000	0.000000	1.000000	1.000000	0.000000	3.000000	2.000000	43.000000	6.000000	1.000000	2.800000	1.000000
+1.000000	1.000000	37.500000	88.000000	20.000000	2.000000	3.000000	3.000000	1.000000	4.000000	3.000000	3.000000	0.000000	0.000000	0.000000	0.000000	0.000000	35.000000	6.400000	1.000000	0.000000	-1.000000
+2.000000	9.000000	0.000000	150.000000	60.000000	4.000000	4.000000	4.000000	2.000000	5.000000	4.000000	4.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	-1.000000
+1.000000	1.000000	39.700000	100.000000	30.000000	0.000000	0.000000	6.000000	2.000000	4.000000	4.000000	3.000000	1.000000	0.000000	0.000000	4.000000	5.000000	65.000000	75.000000	0.000000	0.000000	-1.000000
+1.000000	1.000000	38.300000	80.000000	0.000000	3.000000	3.000000	4.000000	2.000000	5.000000	4.000000	3.000000	2.000000	1.000000	0.000000	4.000000	4.000000	45.000000	7.500000	2.000000	4.600000	1.000000
+2.000000	1.000000	37.500000	40.000000	32.000000	3.000000	1.000000	3.000000	1.000000	3.000000	2.000000	3.000000	2.000000	1.000000	0.000000	0.000000	5.000000	32.000000	6.400000	1.000000	1.100000	1.000000
+1.000000	1.000000	38.400000	84.000000	30.000000	3.000000	1.000000	5.000000	2.000000	4.000000	3.000000	3.000000	2.000000	3.000000	6.500000	4.000000	4.000000	47.000000	7.500000	3.000000	0.000000	-1.000000
+1.000000	1.000000	38.100000	84.000000	44.000000	4.000000	0.000000	4.000000	2.000000	5.000000	3.000000	1.000000	1.000000	3.000000	5.000000	0.000000	4.000000	60.000000	6.800000	0.000000	5.700000	-1.000000
+2.000000	1.000000	38.700000	52.000000	0.000000	1.000000	1.000000	1.000000	1.000000	1.000000	3.000000	1.000000	0.000000	0.000000	0.000000	1.000000	3.000000	4.000000	74.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.100000	44.000000	40.000000	2.000000	1.000000	3.000000	1.000000	3.000000	3.000000	1.000000	0.000000	0.000000	0.000000	1.000000	3.000000	35.000000	6.800000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.400000	52.000000	20.000000	2.000000	1.000000	3.000000	1.000000	1.000000	3.000000	2.000000	2.000000	1.000000	0.000000	3.000000	5.000000	41.000000	63.000000	1.000000	1.000000	1.000000
+1.000000	1.000000	38.200000	60.000000	0.000000	1.000000	0.000000	3.000000	1.000000	2.000000	1.000000	1.000000	1.000000	1.000000	0.000000	4.000000	4.000000	43.000000	6.200000	2.000000	3.900000	1.000000
+2.000000	1.000000	37.700000	40.000000	18.000000	1.000000	1.000000	1.000000	0.000000	3.000000	2.000000	1.000000	1.000000	1.000000	0.000000	3.000000	3.000000	36.000000	3.500000	0.000000	0.000000	1.000000
+1.000000	1.000000	39.100000	60.000000	10.000000	0.000000	1.000000	1.000000	0.000000	2.000000	3.000000	0.000000	0.000000	0.000000	0.000000	4.000000	4.000000	0.000000	0.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	37.800000	48.000000	16.000000	1.000000	1.000000	1.000000	1.000000	0.000000	1.000000	1.000000	2.000000	1.000000	0.000000	4.000000	3.000000	43.000000	7.500000	0.000000	0.000000	1.000000
+1.000000	1.000000	39.000000	120.000000	0.000000	4.000000	3.000000	5.000000	2.000000	2.000000	4.000000	3.000000	2.000000	3.000000	8.000000	0.000000	0.000000	65.000000	8.200000	3.000000	4.600000	1.000000
+1.000000	1.000000	38.200000	76.000000	0.000000	2.000000	3.000000	2.000000	1.000000	5.000000	3.000000	3.000000	1.000000	2.000000	6.000000	1.000000	5.000000	35.000000	6.500000	2.000000	0.900000	1.000000
+2.000000	1.000000	38.300000	88.000000	0.000000	0.000000	0.000000	6.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	-1.000000
+1.000000	1.000000	38.000000	80.000000	30.000000	3.000000	3.000000	3.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	6.000000	0.000000	0.000000	48.000000	8.300000	0.000000	4.300000	1.000000
+1.000000	1.000000	0.000000	0.000000	0.000000	3.000000	1.000000	1.000000	1.000000	2.000000	3.000000	3.000000	1.000000	3.000000	6.000000	4.000000	4.000000	0.000000	0.000000	2.000000	0.000000	-1.000000
+1.000000	1.000000	37.600000	40.000000	0.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	0.000000	0.000000	0.000000	1.000000	1.000000	0.000000	0.000000	2.000000	2.100000	1.000000
+2.000000	1.000000	37.500000	44.000000	0.000000	1.000000	1.000000	1.000000	1.000000	3.000000	3.000000	2.000000	0.000000	0.000000	0.000000	0.000000	0.000000	45.000000	5.800000	2.000000	1.400000	1.000000
+2.000000	1.000000	38.200000	42.000000	16.000000	1.000000	1.000000	3.000000	1.000000	1.000000	3.000000	1.000000	0.000000	0.000000	0.000000	1.000000	0.000000	35.000000	60.000000	1.000000	1.000000	1.000000
+2.000000	1.000000	38.000000	56.000000	44.000000	3.000000	3.000000	3.000000	0.000000	0.000000	1.000000	1.000000	2.000000	1.000000	0.000000	4.000000	0.000000	47.000000	70.000000	2.000000	1.000000	1.000000
+2.000000	1.000000	38.300000	45.000000	20.000000	3.000000	3.000000	2.000000	2.000000	2.000000	4.000000	1.000000	2.000000	0.000000	0.000000	4.000000	0.000000	0.000000	0.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	48.000000	96.000000	1.000000	1.000000	3.000000	1.000000	0.000000	4.000000	1.000000	2.000000	1.000000	0.000000	1.000000	4.000000	42.000000	8.000000	1.000000	0.000000	1.000000
+1.000000	1.000000	37.700000	55.000000	28.000000	2.000000	1.000000	2.000000	1.000000	2.000000	3.000000	3.000000	0.000000	3.000000	5.000000	4.000000	5.000000	0.000000	0.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	36.000000	100.000000	20.000000	4.000000	3.000000	6.000000	2.000000	2.000000	4.000000	3.000000	1.000000	1.000000	0.000000	4.000000	5.000000	74.000000	5.700000	2.000000	2.500000	-1.000000
+1.000000	1.000000	37.100000	60.000000	20.000000	2.000000	0.000000	4.000000	1.000000	3.000000	0.000000	3.000000	0.000000	2.000000	5.000000	3.000000	4.000000	64.000000	8.500000	2.000000	0.000000	1.000000
+2.000000	1.000000	37.100000	114.000000	40.000000	3.000000	0.000000	3.000000	2.000000	2.000000	2.000000	1.000000	0.000000	0.000000	0.000000	0.000000	3.000000	32.000000	0.000000	3.000000	6.500000	1.000000
+1.000000	1.000000	38.100000	72.000000	30.000000	3.000000	3.000000	3.000000	1.000000	4.000000	4.000000	3.000000	2.000000	1.000000	0.000000	3.000000	5.000000	37.000000	56.000000	3.000000	1.000000	1.000000
+1.000000	1.000000	37.000000	44.000000	12.000000	3.000000	1.000000	1.000000	2.000000	1.000000	1.000000	1.000000	0.000000	0.000000	0.000000	4.000000	2.000000	40.000000	6.700000	3.000000	8.000000	1.000000
+1.000000	1.000000	38.600000	48.000000	20.000000	3.000000	1.000000	1.000000	1.000000	4.000000	3.000000	1.000000	0.000000	0.000000	0.000000	3.000000	0.000000	37.000000	75.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	82.000000	72.000000	3.000000	1.000000	4.000000	1.000000	2.000000	3.000000	3.000000	0.000000	3.000000	0.000000	4.000000	4.000000	53.000000	65.000000	3.000000	2.000000	-1.000000
+1.000000	9.000000	38.200000	78.000000	60.000000	4.000000	4.000000	6.000000	0.000000	3.000000	3.000000	3.000000	0.000000	0.000000	0.000000	1.000000	0.000000	59.000000	5.800000	3.000000	3.100000	-1.000000
+2.000000	1.000000	37.800000	60.000000	16.000000	1.000000	1.000000	3.000000	1.000000	2.000000	3.000000	2.000000	1.000000	2.000000	0.000000	3.000000	0.000000	41.000000	73.000000	0.000000	0.000000	-1.000000
+1.000000	1.000000	38.700000	34.000000	30.000000	2.000000	0.000000	3.000000	1.000000	2.000000	3.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	33.000000	69.000000	0.000000	2.000000	-1.000000
+1.000000	1.000000	0.000000	36.000000	12.000000	1.000000	1.000000	1.000000	1.000000	1.000000	2.000000	1.000000	1.000000	1.000000	0.000000	1.000000	5.000000	44.000000	0.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.300000	44.000000	60.000000	0.000000	0.000000	1.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	6.400000	36.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	37.400000	54.000000	18.000000	3.000000	0.000000	1.000000	1.000000	3.000000	4.000000	3.000000	2.000000	2.000000	0.000000	4.000000	5.000000	30.000000	7.100000	2.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	0.000000	0.000000	4.000000	3.000000	0.000000	2.000000	2.000000	4.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	54.000000	76.000000	3.000000	2.000000	1.000000
+1.000000	1.000000	36.600000	48.000000	16.000000	3.000000	1.000000	3.000000	1.000000	4.000000	1.000000	1.000000	1.000000	1.000000	0.000000	0.000000	0.000000	27.000000	56.000000	0.000000	0.000000	-1.000000
+1.000000	1.000000	38.500000	90.000000	0.000000	1.000000	1.000000	3.000000	1.000000	3.000000	3.000000	3.000000	2.000000	3.000000	2.000000	4.000000	5.000000	47.000000	79.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	75.000000	12.000000	1.000000	1.000000	4.000000	1.000000	5.000000	3.000000	3.000000	0.000000	3.000000	5.800000	0.000000	0.000000	58.000000	8.500000	1.000000	0.000000	1.000000
+2.000000	1.000000	38.200000	42.000000	0.000000	3.000000	1.000000	1.000000	1.000000	1.000000	1.000000	2.000000	2.000000	1.000000	0.000000	3.000000	2.000000	35.000000	5.900000	2.000000	0.000000	1.000000
+1.000000	9.000000	38.200000	78.000000	60.000000	4.000000	4.000000	6.000000	0.000000	3.000000	3.000000	3.000000	0.000000	0.000000	0.000000	1.000000	0.000000	59.000000	5.800000	3.000000	3.100000	-1.000000
+2.000000	1.000000	38.600000	60.000000	30.000000	1.000000	1.000000	3.000000	1.000000	4.000000	2.000000	2.000000	1.000000	1.000000	0.000000	0.000000	0.000000	40.000000	6.000000	1.000000	0.000000	1.000000
+2.000000	1.000000	37.800000	42.000000	40.000000	1.000000	1.000000	1.000000	1.000000	1.000000	3.000000	1.000000	0.000000	0.000000	0.000000	3.000000	3.000000	36.000000	6.200000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.000000	60.000000	12.000000	1.000000	1.000000	2.000000	1.000000	2.000000	1.000000	1.000000	1.000000	1.000000	0.000000	1.000000	4.000000	44.000000	65.000000	3.000000	2.000000	-1.000000
+2.000000	1.000000	38.000000	42.000000	12.000000	3.000000	0.000000	3.000000	1.000000	1.000000	1.000000	1.000000	0.000000	0.000000	0.000000	0.000000	1.000000	37.000000	5.800000	0.000000	0.000000	1.000000
+2.000000	1.000000	37.600000	88.000000	36.000000	3.000000	1.000000	1.000000	1.000000	3.000000	3.000000	2.000000	1.000000	3.000000	1.500000	0.000000	0.000000	44.000000	6.000000	0.000000	0.000000	-1.000000

机器学习/adboost/horseColicTraining2.txt

@@ -0,0 +1,299 @@
+2.000000	1.000000	38.500000	66.000000	28.000000	3.000000	3.000000	0.000000	2.000000	5.000000	4.000000	4.000000	0.000000	0.000000	0.000000	3.000000	5.000000	45.000000	8.400000	0.000000	0.000000	-1.000000
+1.000000	1.000000	39.200000	88.000000	20.000000	0.000000	0.000000	4.000000	1.000000	3.000000	4.000000	2.000000	0.000000	0.000000	0.000000	4.000000	2.000000	50.000000	85.000000	2.000000	2.000000	-1.000000
+2.000000	1.000000	38.300000	40.000000	24.000000	1.000000	1.000000	3.000000	1.000000	3.000000	3.000000	1.000000	0.000000	0.000000	0.000000	1.000000	1.000000	33.000000	6.700000	0.000000	0.000000	1.000000
+1.000000	9.000000	39.100000	164.000000	84.000000	4.000000	1.000000	6.000000	2.000000	2.000000	4.000000	4.000000	1.000000	2.000000	5.000000	3.000000	0.000000	48.000000	7.200000	3.000000	5.300000	-1.000000
+2.000000	1.000000	37.300000	104.000000	35.000000	0.000000	0.000000	6.000000	2.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	74.000000	7.400000	0.000000	0.000000	-1.000000
+2.000000	1.000000	0.000000	0.000000	0.000000	2.000000	1.000000	3.000000	1.000000	2.000000	3.000000	2.000000	2.000000	1.000000	0.000000	3.000000	3.000000	0.000000	0.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	37.900000	48.000000	16.000000	1.000000	1.000000	1.000000	1.000000	3.000000	3.000000	3.000000	1.000000	1.000000	0.000000	3.000000	5.000000	37.000000	7.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	60.000000	0.000000	3.000000	0.000000	0.000000	1.000000	0.000000	4.000000	2.000000	2.000000	1.000000	0.000000	3.000000	4.000000	44.000000	8.300000	0.000000	0.000000	-1.000000
+2.000000	1.000000	0.000000	80.000000	36.000000	3.000000	4.000000	3.000000	1.000000	4.000000	4.000000	4.000000	2.000000	1.000000	0.000000	3.000000	5.000000	38.000000	6.200000	0.000000	0.000000	-1.000000
+2.000000	9.000000	38.300000	90.000000	0.000000	1.000000	0.000000	1.000000	1.000000	5.000000	3.000000	1.000000	2.000000	1.000000	0.000000	3.000000	0.000000	40.000000	6.200000	1.000000	2.200000	1.000000
+1.000000	1.000000	38.100000	66.000000	12.000000	3.000000	3.000000	5.000000	1.000000	3.000000	3.000000	1.000000	2.000000	1.000000	3.000000	2.000000	5.000000	44.000000	6.000000	2.000000	3.600000	1.000000
+2.000000	1.000000	39.100000	72.000000	52.000000	2.000000	0.000000	2.000000	1.000000	2.000000	1.000000	2.000000	1.000000	1.000000	0.000000	4.000000	4.000000	50.000000	7.800000	0.000000	0.000000	1.000000
+1.000000	1.000000	37.200000	42.000000	12.000000	2.000000	1.000000	1.000000	1.000000	3.000000	3.000000	3.000000	3.000000	1.000000	0.000000	4.000000	5.000000	0.000000	7.000000	0.000000	0.000000	1.000000
+2.000000	9.000000	38.000000	92.000000	28.000000	1.000000	1.000000	2.000000	1.000000	1.000000	3.000000	2.000000	3.000000	0.000000	7.200000	1.000000	1.000000	37.000000	6.100000	1.000000	0.000000	-1.000000
+1.000000	1.000000	38.200000	76.000000	28.000000	3.000000	1.000000	1.000000	1.000000	3.000000	4.000000	1.000000	2.000000	2.000000	0.000000	4.000000	4.000000	46.000000	81.000000	1.000000	2.000000	1.000000
+1.000000	1.000000	37.600000	96.000000	48.000000	3.000000	1.000000	4.000000	1.000000	5.000000	3.000000	3.000000	2.000000	3.000000	4.500000	4.000000	0.000000	45.000000	6.800000	0.000000	0.000000	-1.000000
+1.000000	9.000000	0.000000	128.000000	36.000000	3.000000	3.000000	4.000000	2.000000	4.000000	4.000000	3.000000	3.000000	0.000000	0.000000	4.000000	5.000000	53.000000	7.800000	3.000000	4.700000	-1.000000
+2.000000	1.000000	37.500000	48.000000	24.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	37.600000	64.000000	21.000000	1.000000	1.000000	2.000000	1.000000	2.000000	3.000000	1.000000	1.000000	1.000000	0.000000	2.000000	5.000000	40.000000	7.000000	1.000000	0.000000	1.000000
+2.000000	1.000000	39.400000	110.000000	35.000000	4.000000	3.000000	6.000000	0.000000	0.000000	3.000000	3.000000	0.000000	0.000000	0.000000	0.000000	0.000000	55.000000	8.700000	0.000000	0.000000	1.000000
+1.000000	1.000000	39.900000	72.000000	60.000000	1.000000	1.000000	5.000000	2.000000	5.000000	4.000000	4.000000	3.000000	1.000000	0.000000	4.000000	4.000000	46.000000	6.100000	2.000000	0.000000	1.000000
+2.000000	1.000000	38.400000	48.000000	16.000000	1.000000	0.000000	1.000000	1.000000	1.000000	3.000000	1.000000	2.000000	3.000000	5.500000	4.000000	3.000000	49.000000	6.800000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.600000	42.000000	34.000000	2.000000	1.000000	4.000000	0.000000	2.000000	3.000000	1.000000	0.000000	0.000000	0.000000	1.000000	0.000000	48.000000	7.200000	0.000000	0.000000	1.000000
+1.000000	9.000000	38.300000	130.000000	60.000000	0.000000	3.000000	0.000000	1.000000	2.000000	4.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	50.000000	70.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.100000	60.000000	12.000000	3.000000	3.000000	3.000000	1.000000	0.000000	4.000000	3.000000	3.000000	2.000000	2.000000	0.000000	0.000000	51.000000	65.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	37.800000	60.000000	42.000000	0.000000	0.000000	0.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.300000	72.000000	30.000000	4.000000	3.000000	3.000000	2.000000	3.000000	3.000000	3.000000	2.000000	1.000000	0.000000	3.000000	5.000000	43.000000	7.000000	2.000000	3.900000	1.000000
+1.000000	1.000000	37.800000	48.000000	12.000000	3.000000	1.000000	1.000000	1.000000	0.000000	3.000000	2.000000	1.000000	1.000000	0.000000	1.000000	3.000000	37.000000	5.500000	2.000000	1.300000	1.000000
+1.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	-1.000000
+2.000000	1.000000	37.700000	48.000000	0.000000	2.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	0.000000	0.000000	0.000000	45.000000	76.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	37.700000	96.000000	30.000000	3.000000	3.000000	4.000000	2.000000	5.000000	4.000000	4.000000	3.000000	2.000000	4.000000	4.000000	5.000000	66.000000	7.500000	0.000000	0.000000	-1.000000
+2.000000	1.000000	37.200000	108.000000	12.000000	3.000000	3.000000	4.000000	2.000000	2.000000	4.000000	2.000000	0.000000	3.000000	6.000000	3.000000	3.000000	52.000000	8.200000	3.000000	7.400000	-1.000000
+1.000000	1.000000	37.200000	60.000000	0.000000	2.000000	1.000000	1.000000	1.000000	3.000000	3.000000	3.000000	2.000000	1.000000	0.000000	4.000000	5.000000	43.000000	6.600000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.200000	64.000000	28.000000	1.000000	1.000000	1.000000	1.000000	3.000000	1.000000	0.000000	0.000000	0.000000	0.000000	4.000000	4.000000	49.000000	8.600000	2.000000	6.600000	1.000000
+1.000000	1.000000	0.000000	100.000000	30.000000	3.000000	3.000000	4.000000	2.000000	5.000000	4.000000	4.000000	3.000000	3.000000	0.000000	4.000000	4.000000	52.000000	6.600000	0.000000	0.000000	1.000000
+2.000000	1.000000	0.000000	104.000000	24.000000	4.000000	3.000000	3.000000	2.000000	4.000000	4.000000	3.000000	0.000000	3.000000	0.000000	0.000000	2.000000	73.000000	8.400000	0.000000	0.000000	-1.000000
+2.000000	1.000000	38.300000	112.000000	16.000000	0.000000	3.000000	5.000000	2.000000	0.000000	0.000000	1.000000	1.000000	2.000000	0.000000	0.000000	5.000000	51.000000	6.000000	2.000000	1.000000	-1.000000
+1.000000	1.000000	37.800000	72.000000	0.000000	0.000000	3.000000	0.000000	1.000000	5.000000	3.000000	1.000000	0.000000	1.000000	0.000000	1.000000	1.000000	56.000000	80.000000	1.000000	2.000000	1.000000
+2.000000	1.000000	38.600000	52.000000	0.000000	1.000000	1.000000	1.000000	1.000000	3.000000	3.000000	2.000000	1.000000	1.000000	0.000000	1.000000	3.000000	32.000000	6.600000	1.000000	5.000000	1.000000
+1.000000	9.000000	39.200000	146.000000	96.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	-1.000000
+1.000000	1.000000	0.000000	88.000000	0.000000	3.000000	3.000000	6.000000	2.000000	5.000000	3.000000	3.000000	1.000000	3.000000	0.000000	4.000000	5.000000	63.000000	6.500000	3.000000	0.000000	-1.000000
+2.000000	9.000000	39.000000	150.000000	72.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	47.000000	8.500000	0.000000	0.100000	1.000000
+2.000000	1.000000	38.000000	60.000000	12.000000	3.000000	1.000000	3.000000	1.000000	3.000000	3.000000	1.000000	1.000000	1.000000	0.000000	2.000000	2.000000	47.000000	7.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	120.000000	0.000000	3.000000	4.000000	4.000000	1.000000	4.000000	4.000000	4.000000	1.000000	1.000000	0.000000	0.000000	5.000000	52.000000	67.000000	2.000000	2.000000	-1.000000
+1.000000	1.000000	35.400000	140.000000	24.000000	3.000000	3.000000	4.000000	2.000000	4.000000	4.000000	0.000000	2.000000	1.000000	0.000000	0.000000	5.000000	57.000000	69.000000	3.000000	2.000000	-1.000000
+2.000000	1.000000	0.000000	120.000000	0.000000	4.000000	3.000000	4.000000	2.000000	5.000000	4.000000	4.000000	1.000000	1.000000	0.000000	4.000000	5.000000	60.000000	6.500000	3.000000	0.000000	-1.000000
+1.000000	1.000000	37.900000	60.000000	15.000000	3.000000	0.000000	4.000000	2.000000	5.000000	4.000000	4.000000	2.000000	2.000000	0.000000	4.000000	5.000000	65.000000	7.500000	0.000000	0.000000	1.000000
+2.000000	1.000000	37.500000	48.000000	16.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	0.000000	1.000000	0.000000	37.000000	6.500000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.900000	80.000000	44.000000	3.000000	3.000000	3.000000	2.000000	2.000000	3.000000	3.000000	2.000000	2.000000	7.000000	3.000000	1.000000	54.000000	6.500000	3.000000	0.000000	-1.000000
+2.000000	1.000000	37.200000	84.000000	48.000000	3.000000	3.000000	5.000000	2.000000	4.000000	1.000000	2.000000	1.000000	2.000000	0.000000	2.000000	1.000000	73.000000	5.500000	2.000000	4.100000	-1.000000
+2.000000	1.000000	38.600000	46.000000	0.000000	1.000000	1.000000	2.000000	1.000000	1.000000	3.000000	2.000000	1.000000	1.000000	0.000000	0.000000	2.000000	49.000000	9.100000	1.000000	1.600000	1.000000
+1.000000	1.000000	37.400000	84.000000	36.000000	1.000000	0.000000	3.000000	2.000000	3.000000	3.000000	2.000000	0.000000	0.000000	0.000000	4.000000	5.000000	0.000000	0.000000	3.000000	0.000000	-1.000000
+2.000000	1.000000	0.000000	0.000000	0.000000	1.000000	1.000000	3.000000	1.000000	1.000000	3.000000	1.000000	0.000000	0.000000	0.000000	2.000000	2.000000	43.000000	7.700000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.600000	40.000000	20.000000	0.000000	0.000000	0.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	41.000000	6.400000	0.000000	0.000000	1.000000
+2.000000	1.000000	40.300000	114.000000	36.000000	3.000000	3.000000	1.000000	2.000000	2.000000	3.000000	3.000000	2.000000	1.000000	7.000000	1.000000	5.000000	57.000000	8.100000	3.000000	4.500000	-1.000000
+1.000000	9.000000	38.600000	160.000000	20.000000	3.000000	0.000000	5.000000	1.000000	3.000000	3.000000	4.000000	3.000000	0.000000	0.000000	4.000000	0.000000	38.000000	0.000000	2.000000	0.000000	-1.000000
+1.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	24.000000	6.700000	0.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	64.000000	36.000000	2.000000	0.000000	2.000000	1.000000	5.000000	3.000000	3.000000	2.000000	2.000000	0.000000	0.000000	0.000000	42.000000	7.700000	0.000000	0.000000	-1.000000
+1.000000	1.000000	0.000000	0.000000	20.000000	4.000000	3.000000	3.000000	0.000000	5.000000	4.000000	3.000000	2.000000	0.000000	0.000000	4.000000	4.000000	53.000000	5.900000	3.000000	0.000000	-1.000000
+2.000000	1.000000	0.000000	96.000000	0.000000	3.000000	3.000000	3.000000	2.000000	5.000000	4.000000	4.000000	1.000000	2.000000	0.000000	4.000000	5.000000	60.000000	0.000000	0.000000	0.000000	-1.000000
+2.000000	1.000000	37.800000	48.000000	32.000000	1.000000	1.000000	3.000000	1.000000	2.000000	1.000000	0.000000	1.000000	1.000000	0.000000	4.000000	5.000000	37.000000	6.700000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.500000	60.000000	0.000000	2.000000	2.000000	1.000000	1.000000	1.000000	2.000000	2.000000	2.000000	1.000000	0.000000	1.000000	1.000000	44.000000	7.700000	0.000000	0.000000	1.000000
+1.000000	1.000000	37.800000	88.000000	22.000000	2.000000	1.000000	2.000000	1.000000	3.000000	0.000000	0.000000	2.000000	0.000000	0.000000	4.000000	0.000000	64.000000	8.000000	1.000000	6.000000	-1.000000
+2.000000	1.000000	38.200000	130.000000	16.000000	4.000000	3.000000	4.000000	2.000000	2.000000	4.000000	4.000000	1.000000	1.000000	0.000000	0.000000	0.000000	65.000000	82.000000	2.000000	2.000000	-1.000000
+1.000000	1.000000	39.000000	64.000000	36.000000	3.000000	1.000000	4.000000	2.000000	3.000000	3.000000	2.000000	1.000000	2.000000	7.000000	4.000000	5.000000	44.000000	7.500000	3.000000	5.000000	1.000000
+1.000000	1.000000	0.000000	60.000000	36.000000	3.000000	1.000000	3.000000	1.000000	3.000000	3.000000	2.000000	1.000000	1.000000	0.000000	3.000000	4.000000	26.000000	72.000000	2.000000	1.000000	1.000000
+2.000000	1.000000	37.900000	72.000000	0.000000	1.000000	1.000000	5.000000	2.000000	3.000000	3.000000	1.000000	1.000000	3.000000	2.000000	3.000000	4.000000	58.000000	74.000000	1.000000	2.000000	1.000000
+2.000000	1.000000	38.400000	54.000000	24.000000	1.000000	1.000000	1.000000	1.000000	1.000000	3.000000	1.000000	2.000000	1.000000	0.000000	3.000000	2.000000	49.000000	7.200000	1.000000	0.000000	1.000000
+2.000000	1.000000	0.000000	52.000000	16.000000	1.000000	0.000000	3.000000	1.000000	0.000000	0.000000	0.000000	2.000000	3.000000	5.500000	0.000000	0.000000	55.000000	7.200000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.000000	48.000000	12.000000	1.000000	1.000000	1.000000	1.000000	1.000000	3.000000	0.000000	1.000000	1.000000	0.000000	3.000000	2.000000	42.000000	6.300000	2.000000	4.100000	1.000000
+2.000000	1.000000	37.000000	60.000000	20.000000	3.000000	0.000000	0.000000	1.000000	3.000000	0.000000	3.000000	2.000000	2.000000	4.500000	4.000000	4.000000	43.000000	7.600000	0.000000	0.000000	-1.000000
+1.000000	1.000000	37.800000	48.000000	28.000000	1.000000	1.000000	1.000000	1.000000	1.000000	2.000000	1.000000	2.000000	0.000000	0.000000	1.000000	1.000000	46.000000	5.900000	2.000000	7.000000	1.000000
+1.000000	1.000000	37.700000	56.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	-1.000000
+1.000000	1.000000	38.100000	52.000000	24.000000	1.000000	1.000000	5.000000	1.000000	4.000000	3.000000	1.000000	2.000000	3.000000	7.000000	1.000000	0.000000	54.000000	7.500000	2.000000	2.600000	-1.000000
+1.000000	9.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	37.000000	4.900000	0.000000	0.000000	-1.000000
+1.000000	9.000000	39.700000	100.000000	0.000000	3.000000	3.000000	5.000000	2.000000	2.000000	3.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	48.000000	57.000000	2.000000	2.000000	-1.000000
+1.000000	1.000000	37.600000	38.000000	20.000000	3.000000	3.000000	1.000000	1.000000	3.000000	3.000000	2.000000	0.000000	0.000000	0.000000	3.000000	0.000000	37.000000	68.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.700000	52.000000	20.000000	2.000000	0.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	0.000000	1.000000	1.000000	33.000000	77.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	0.000000	0.000000	3.000000	3.000000	3.000000	3.000000	5.000000	3.000000	3.000000	3.000000	2.000000	0.000000	4.000000	5.000000	46.000000	5.900000	0.000000	0.000000	-1.000000
+1.000000	1.000000	37.500000	96.000000	18.000000	1.000000	3.000000	6.000000	2.000000	3.000000	4.000000	2.000000	2.000000	3.000000	5.000000	0.000000	4.000000	69.000000	8.900000	3.000000	0.000000	1.000000
+1.000000	1.000000	36.400000	98.000000	35.000000	3.000000	3.000000	4.000000	1.000000	4.000000	3.000000	2.000000	0.000000	0.000000	0.000000	4.000000	4.000000	47.000000	6.400000	3.000000	3.600000	-1.000000
+1.000000	1.000000	37.300000	40.000000	0.000000	0.000000	3.000000	1.000000	1.000000	2.000000	3.000000	2.000000	3.000000	1.000000	0.000000	3.000000	5.000000	36.000000	0.000000	3.000000	2.000000	1.000000
+1.000000	9.000000	38.100000	100.000000	80.000000	3.000000	1.000000	2.000000	1.000000	3.000000	4.000000	1.000000	0.000000	0.000000	0.000000	1.000000	0.000000	36.000000	5.700000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.000000	0.000000	24.000000	3.000000	3.000000	6.000000	2.000000	5.000000	0.000000	4.000000	1.000000	1.000000	0.000000	0.000000	0.000000	68.000000	7.800000	0.000000	0.000000	-1.000000
+1.000000	1.000000	37.800000	60.000000	80.000000	1.000000	3.000000	2.000000	2.000000	2.000000	3.000000	3.000000	0.000000	2.000000	5.500000	4.000000	0.000000	40.000000	4.500000	2.000000	0.000000	1.000000
+2.000000	1.000000	38.000000	54.000000	30.000000	2.000000	3.000000	3.000000	3.000000	3.000000	1.000000	2.000000	2.000000	2.000000	0.000000	0.000000	4.000000	45.000000	6.200000	0.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	88.000000	40.000000	3.000000	3.000000	4.000000	2.000000	5.000000	4.000000	3.000000	3.000000	0.000000	0.000000	4.000000	5.000000	50.000000	7.700000	3.000000	1.400000	-1.000000
+2.000000	1.000000	0.000000	40.000000	16.000000	0.000000	0.000000	0.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	50.000000	7.000000	2.000000	3.900000	-1.000000
+2.000000	1.000000	39.000000	64.000000	40.000000	1.000000	1.000000	5.000000	1.000000	3.000000	3.000000	2.000000	2.000000	1.000000	0.000000	3.000000	3.000000	42.000000	7.500000	2.000000	2.300000	1.000000
+2.000000	1.000000	38.300000	42.000000	10.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	38.000000	61.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.000000	52.000000	16.000000	0.000000	0.000000	0.000000	0.000000	2.000000	0.000000	0.000000	0.000000	3.000000	1.000000	1.000000	1.000000	53.000000	86.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	40.300000	114.000000	36.000000	3.000000	3.000000	1.000000	2.000000	2.000000	3.000000	3.000000	2.000000	1.000000	7.000000	1.000000	5.000000	57.000000	8.100000	3.000000	4.500000	-1.000000
+2.000000	1.000000	38.800000	50.000000	20.000000	3.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	2.000000	1.000000	0.000000	3.000000	1.000000	42.000000	6.200000	0.000000	0.000000	1.000000
+2.000000	1.000000	0.000000	0.000000	0.000000	3.000000	3.000000	1.000000	1.000000	5.000000	3.000000	3.000000	1.000000	1.000000	0.000000	4.000000	5.000000	38.000000	6.500000	0.000000	0.000000	-1.000000
+2.000000	1.000000	37.500000	48.000000	30.000000	4.000000	1.000000	3.000000	1.000000	0.000000	2.000000	1.000000	1.000000	1.000000	0.000000	1.000000	1.000000	48.000000	8.600000	0.000000	0.000000	1.000000
+1.000000	1.000000	37.300000	48.000000	20.000000	0.000000	1.000000	2.000000	1.000000	3.000000	3.000000	3.000000	2.000000	1.000000	0.000000	3.000000	5.000000	41.000000	69.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	0.000000	84.000000	36.000000	0.000000	0.000000	3.000000	1.000000	0.000000	3.000000	1.000000	2.000000	1.000000	0.000000	3.000000	2.000000	44.000000	8.500000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.100000	88.000000	32.000000	3.000000	3.000000	4.000000	1.000000	2.000000	3.000000	3.000000	0.000000	3.000000	1.000000	4.000000	5.000000	55.000000	60.000000	0.000000	0.000000	-1.000000
+2.000000	1.000000	37.700000	44.000000	40.000000	2.000000	1.000000	3.000000	1.000000	1.000000	3.000000	2.000000	1.000000	1.000000	0.000000	1.000000	5.000000	41.000000	60.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	39.600000	108.000000	51.000000	3.000000	3.000000	6.000000	2.000000	2.000000	4.000000	3.000000	1.000000	2.000000	0.000000	3.000000	5.000000	59.000000	8.000000	2.000000	2.600000	1.000000
+1.000000	1.000000	38.200000	40.000000	16.000000	3.000000	3.000000	1.000000	1.000000	1.000000	3.000000	0.000000	0.000000	0.000000	0.000000	1.000000	1.000000	34.000000	66.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	60.000000	20.000000	4.000000	3.000000	4.000000	2.000000	5.000000	4.000000	0.000000	0.000000	1.000000	0.000000	4.000000	5.000000	0.000000	0.000000	0.000000	0.000000	-1.000000
+2.000000	1.000000	38.300000	40.000000	16.000000	3.000000	0.000000	1.000000	1.000000	2.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	37.000000	57.000000	0.000000	0.000000	1.000000
+1.000000	9.000000	38.000000	140.000000	68.000000	1.000000	1.000000	1.000000	1.000000	3.000000	3.000000	2.000000	0.000000	0.000000	0.000000	2.000000	1.000000	39.000000	5.300000	0.000000	0.000000	1.000000
+1.000000	1.000000	37.800000	52.000000	24.000000	1.000000	3.000000	3.000000	1.000000	4.000000	4.000000	1.000000	2.000000	3.000000	5.700000	2.000000	5.000000	48.000000	6.600000	1.000000	3.700000	-1.000000
+1.000000	1.000000	0.000000	70.000000	36.000000	1.000000	0.000000	3.000000	2.000000	2.000000	3.000000	2.000000	2.000000	0.000000	0.000000	4.000000	5.000000	36.000000	7.300000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.300000	52.000000	96.000000	0.000000	3.000000	3.000000	1.000000	0.000000	0.000000	0.000000	1.000000	1.000000	0.000000	1.000000	0.000000	43.000000	6.100000	0.000000	0.000000	1.000000
+2.000000	1.000000	37.300000	50.000000	32.000000	1.000000	1.000000	3.000000	1.000000	1.000000	3.000000	2.000000	0.000000	0.000000	0.000000	1.000000	0.000000	44.000000	7.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.700000	60.000000	32.000000	4.000000	3.000000	2.000000	2.000000	4.000000	4.000000	4.000000	0.000000	0.000000	0.000000	4.000000	5.000000	53.000000	64.000000	3.000000	2.000000	-1.000000
+1.000000	9.000000	38.400000	84.000000	40.000000	3.000000	3.000000	2.000000	1.000000	3.000000	3.000000	3.000000	1.000000	1.000000	0.000000	0.000000	0.000000	36.000000	6.600000	2.000000	2.800000	-1.000000
+1.000000	1.000000	0.000000	70.000000	16.000000	3.000000	4.000000	5.000000	2.000000	2.000000	3.000000	2.000000	2.000000	1.000000	0.000000	4.000000	5.000000	60.000000	7.500000	0.000000	0.000000	-1.000000
+1.000000	1.000000	38.300000	40.000000	16.000000	3.000000	0.000000	0.000000	1.000000	1.000000	3.000000	2.000000	0.000000	0.000000	0.000000	0.000000	0.000000	38.000000	58.000000	1.000000	2.000000	1.000000
+1.000000	1.000000	0.000000	40.000000	0.000000	2.000000	1.000000	1.000000	1.000000	1.000000	3.000000	1.000000	1.000000	1.000000	0.000000	0.000000	5.000000	39.000000	56.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	36.800000	60.000000	28.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	10.000000	-1.000000
+1.000000	1.000000	38.400000	44.000000	24.000000	3.000000	0.000000	4.000000	0.000000	5.000000	4.000000	3.000000	2.000000	1.000000	0.000000	4.000000	5.000000	50.000000	77.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	0.000000	0.000000	40.000000	3.000000	1.000000	1.000000	1.000000	3.000000	3.000000	2.000000	0.000000	0.000000	0.000000	0.000000	0.000000	45.000000	70.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.000000	44.000000	12.000000	1.000000	1.000000	1.000000	1.000000	3.000000	3.000000	3.000000	2.000000	1.000000	0.000000	4.000000	5.000000	42.000000	65.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	39.500000	0.000000	0.000000	3.000000	3.000000	4.000000	2.000000	3.000000	4.000000	3.000000	0.000000	3.000000	5.500000	4.000000	5.000000	0.000000	6.700000	1.000000	0.000000	-1.000000
+1.000000	1.000000	36.500000	78.000000	30.000000	1.000000	0.000000	1.000000	1.000000	5.000000	3.000000	1.000000	0.000000	1.000000	0.000000	0.000000	0.000000	34.000000	75.000000	2.000000	1.000000	1.000000
+2.000000	1.000000	38.100000	56.000000	20.000000	2.000000	1.000000	2.000000	1.000000	1.000000	3.000000	1.000000	1.000000	1.000000	0.000000	0.000000	0.000000	46.000000	70.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	39.400000	54.000000	66.000000	1.000000	1.000000	2.000000	1.000000	2.000000	3.000000	2.000000	1.000000	1.000000	0.000000	3.000000	4.000000	39.000000	6.000000	2.000000	0.000000	1.000000
+1.000000	1.000000	38.300000	80.000000	40.000000	0.000000	0.000000	6.000000	2.000000	4.000000	3.000000	1.000000	0.000000	2.000000	0.000000	1.000000	4.000000	67.000000	10.200000	2.000000	1.000000	-1.000000
+2.000000	1.000000	38.700000	40.000000	28.000000	2.000000	1.000000	1.000000	1.000000	3.000000	1.000000	1.000000	0.000000	0.000000	0.000000	1.000000	0.000000	39.000000	62.000000	1.000000	1.000000	1.000000
+1.000000	1.000000	38.200000	64.000000	24.000000	1.000000	1.000000	3.000000	1.000000	4.000000	4.000000	3.000000	2.000000	1.000000	0.000000	4.000000	4.000000	45.000000	7.500000	1.000000	2.000000	-1.000000
+2.000000	1.000000	37.600000	48.000000	20.000000	3.000000	1.000000	4.000000	1.000000	1.000000	1.000000	3.000000	2.000000	1.000000	0.000000	1.000000	1.000000	37.000000	5.500000	0.000000	0.000000	-1.000000
+1.000000	1.000000	38.000000	42.000000	68.000000	4.000000	1.000000	1.000000	1.000000	3.000000	3.000000	2.000000	2.000000	2.000000	0.000000	4.000000	4.000000	41.000000	7.600000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.700000	0.000000	0.000000	3.000000	1.000000	3.000000	1.000000	5.000000	4.000000	2.000000	0.000000	0.000000	0.000000	0.000000	0.000000	33.000000	6.500000	2.000000	0.000000	1.000000
+1.000000	1.000000	37.400000	50.000000	32.000000	3.000000	3.000000	0.000000	1.000000	4.000000	4.000000	1.000000	2.000000	1.000000	0.000000	1.000000	0.000000	45.000000	7.900000	2.000000	1.000000	1.000000
+1.000000	1.000000	37.400000	84.000000	20.000000	0.000000	0.000000	3.000000	1.000000	2.000000	3.000000	3.000000	0.000000	0.000000	0.000000	0.000000	0.000000	31.000000	61.000000	0.000000	1.000000	-1.000000
+1.000000	1.000000	38.400000	49.000000	0.000000	0.000000	0.000000	1.000000	1.000000	0.000000	0.000000	1.000000	2.000000	1.000000	0.000000	0.000000	0.000000	44.000000	7.600000	0.000000	0.000000	1.000000
+1.000000	1.000000	37.800000	30.000000	12.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	-1.000000
+2.000000	1.000000	37.600000	88.000000	36.000000	3.000000	1.000000	1.000000	1.000000	3.000000	3.000000	2.000000	1.000000	3.000000	1.500000	0.000000	0.000000	44.000000	6.000000	0.000000	0.000000	-1.000000
+2.000000	1.000000	37.900000	40.000000	24.000000	1.000000	1.000000	1.000000	1.000000	2.000000	3.000000	1.000000	0.000000	0.000000	0.000000	0.000000	3.000000	40.000000	5.700000	0.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	100.000000	0.000000	3.000000	0.000000	4.000000	2.000000	5.000000	4.000000	0.000000	2.000000	0.000000	0.000000	2.000000	0.000000	59.000000	6.300000	0.000000	0.000000	-1.000000
+1.000000	9.000000	38.100000	136.000000	48.000000	3.000000	3.000000	3.000000	1.000000	5.000000	1.000000	3.000000	2.000000	2.000000	4.400000	2.000000	0.000000	33.000000	4.900000	2.000000	2.900000	-1.000000
+1.000000	1.000000	0.000000	0.000000	0.000000	3.000000	3.000000	3.000000	2.000000	5.000000	3.000000	3.000000	3.000000	2.000000	0.000000	4.000000	5.000000	46.000000	5.900000	0.000000	0.000000	-1.000000
+1.000000	1.000000	38.000000	48.000000	0.000000	1.000000	1.000000	1.000000	1.000000	1.000000	2.000000	4.000000	2.000000	2.000000	0.000000	4.000000	5.000000	0.000000	0.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.000000	56.000000	0.000000	1.000000	2.000000	3.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	0.000000	1.000000	1.000000	42.000000	71.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.000000	60.000000	32.000000	1.000000	1.000000	0.000000	1.000000	3.000000	3.000000	0.000000	1.000000	1.000000	0.000000	0.000000	0.000000	50.000000	7.000000	1.000000	1.000000	1.000000
+1.000000	1.000000	38.100000	44.000000	9.000000	3.000000	1.000000	1.000000	1.000000	2.000000	2.000000	1.000000	1.000000	1.000000	0.000000	4.000000	5.000000	31.000000	7.300000	0.000000	0.000000	1.000000
+2.000000	1.000000	36.000000	42.000000	30.000000	0.000000	0.000000	5.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	64.000000	6.800000	0.000000	0.000000	-1.000000
+1.000000	1.000000	0.000000	120.000000	0.000000	4.000000	3.000000	6.000000	2.000000	5.000000	4.000000	4.000000	0.000000	0.000000	0.000000	4.000000	5.000000	57.000000	4.500000	3.000000	3.900000	-1.000000
+1.000000	1.000000	37.800000	48.000000	28.000000	1.000000	1.000000	1.000000	2.000000	1.000000	2.000000	1.000000	2.000000	0.000000	0.000000	1.000000	1.000000	46.000000	5.900000	2.000000	7.000000	1.000000
+1.000000	1.000000	37.100000	84.000000	40.000000	3.000000	3.000000	6.000000	1.000000	2.000000	4.000000	4.000000	3.000000	2.000000	2.000000	4.000000	5.000000	75.000000	81.000000	0.000000	0.000000	-1.000000
+2.000000	1.000000	0.000000	80.000000	32.000000	3.000000	3.000000	2.000000	1.000000	2.000000	3.000000	3.000000	2.000000	1.000000	0.000000	3.000000	0.000000	50.000000	80.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.200000	48.000000	0.000000	1.000000	3.000000	3.000000	1.000000	3.000000	4.000000	4.000000	1.000000	3.000000	2.000000	4.000000	5.000000	42.000000	71.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.000000	44.000000	12.000000	2.000000	1.000000	3.000000	1.000000	3.000000	4.000000	3.000000	1.000000	2.000000	6.500000	1.000000	4.000000	33.000000	6.500000	0.000000	0.000000	-1.000000
+1.000000	1.000000	38.300000	132.000000	0.000000	0.000000	3.000000	6.000000	2.000000	2.000000	4.000000	2.000000	2.000000	3.000000	6.200000	4.000000	4.000000	57.000000	8.000000	0.000000	5.200000	1.000000
+2.000000	1.000000	38.700000	48.000000	24.000000	0.000000	0.000000	0.000000	0.000000	1.000000	1.000000	0.000000	1.000000	1.000000	0.000000	1.000000	0.000000	34.000000	63.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.900000	44.000000	14.000000	3.000000	1.000000	1.000000	1.000000	2.000000	3.000000	2.000000	0.000000	0.000000	0.000000	0.000000	2.000000	33.000000	64.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	39.300000	0.000000	0.000000	4.000000	3.000000	6.000000	2.000000	4.000000	4.000000	2.000000	1.000000	3.000000	4.000000	4.000000	4.000000	75.000000	0.000000	3.000000	4.300000	-1.000000
+1.000000	1.000000	0.000000	100.000000	0.000000	3.000000	3.000000	4.000000	2.000000	0.000000	4.000000	4.000000	2.000000	1.000000	2.000000	0.000000	0.000000	68.000000	64.000000	3.000000	2.000000	1.000000
+2.000000	1.000000	38.600000	48.000000	20.000000	3.000000	1.000000	1.000000	1.000000	1.000000	3.000000	2.000000	2.000000	1.000000	0.000000	3.000000	2.000000	50.000000	7.300000	1.000000	0.000000	1.000000
+2.000000	1.000000	38.800000	48.000000	40.000000	1.000000	1.000000	3.000000	1.000000	3.000000	3.000000	4.000000	2.000000	0.000000	0.000000	0.000000	5.000000	41.000000	65.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.000000	48.000000	20.000000	3.000000	3.000000	4.000000	1.000000	1.000000	4.000000	2.000000	2.000000	0.000000	5.000000	0.000000	2.000000	49.000000	8.300000	1.000000	0.000000	1.000000
+2.000000	1.000000	38.600000	52.000000	20.000000	1.000000	1.000000	1.000000	1.000000	3.000000	3.000000	2.000000	1.000000	1.000000	0.000000	1.000000	3.000000	36.000000	6.600000	1.000000	5.000000	1.000000
+1.000000	1.000000	37.800000	60.000000	24.000000	1.000000	0.000000	3.000000	2.000000	0.000000	4.000000	4.000000	2.000000	3.000000	2.000000	0.000000	5.000000	52.000000	75.000000	0.000000	0.000000	-1.000000
+2.000000	1.000000	38.000000	42.000000	40.000000	3.000000	1.000000	1.000000	1.000000	3.000000	3.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	0.000000	0.000000	12.000000	1.000000	1.000000	2.000000	1.000000	2.000000	1.000000	2.000000	3.000000	1.000000	0.000000	1.000000	3.000000	44.000000	7.500000	2.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	4.000000	0.000000	0.000000	1.000000	1.000000	0.000000	0.000000	5.000000	35.000000	58.000000	2.000000	1.000000	1.000000
+1.000000	1.000000	38.300000	42.000000	24.000000	0.000000	0.000000	0.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	40.000000	8.500000	0.000000	0.000000	-1.000000
+2.000000	1.000000	39.500000	60.000000	10.000000	3.000000	0.000000	0.000000	2.000000	3.000000	3.000000	2.000000	2.000000	1.000000	0.000000	3.000000	0.000000	38.000000	56.000000	1.000000	0.000000	1.000000
+1.000000	1.000000	38.000000	66.000000	20.000000	1.000000	3.000000	3.000000	1.000000	5.000000	3.000000	1.000000	1.000000	1.000000	0.000000	3.000000	0.000000	46.000000	46.000000	3.000000	2.000000	-1.000000
+1.000000	1.000000	38.700000	76.000000	0.000000	1.000000	1.000000	5.000000	2.000000	3.000000	3.000000	2.000000	2.000000	2.000000	0.000000	4.000000	4.000000	50.000000	8.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	39.400000	120.000000	48.000000	0.000000	0.000000	5.000000	1.000000	0.000000	3.000000	3.000000	1.000000	0.000000	0.000000	4.000000	0.000000	56.000000	64.000000	1.000000	2.000000	-1.000000
+1.000000	1.000000	38.300000	40.000000	18.000000	1.000000	1.000000	1.000000	1.000000	3.000000	1.000000	1.000000	0.000000	0.000000	0.000000	2.000000	1.000000	43.000000	5.900000	1.000000	0.000000	1.000000
+2.000000	1.000000	0.000000	44.000000	24.000000	1.000000	1.000000	1.000000	1.000000	3.000000	3.000000	1.000000	2.000000	1.000000	0.000000	0.000000	1.000000	0.000000	6.300000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.400000	104.000000	40.000000	1.000000	1.000000	3.000000	1.000000	2.000000	4.000000	2.000000	2.000000	3.000000	6.500000	0.000000	4.000000	55.000000	8.500000	0.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	65.000000	24.000000	0.000000	0.000000	0.000000	2.000000	5.000000	0.000000	4.000000	3.000000	1.000000	0.000000	0.000000	5.000000	0.000000	0.000000	0.000000	0.000000	-1.000000
+2.000000	1.000000	37.500000	44.000000	20.000000	1.000000	1.000000	3.000000	1.000000	0.000000	1.000000	1.000000	0.000000	0.000000	0.000000	1.000000	0.000000	35.000000	7.200000	0.000000	0.000000	1.000000
+2.000000	1.000000	39.000000	86.000000	16.000000	3.000000	3.000000	5.000000	0.000000	3.000000	3.000000	3.000000	0.000000	2.000000	0.000000	0.000000	0.000000	68.000000	5.800000	3.000000	6.000000	-1.000000
+1.000000	1.000000	38.500000	129.000000	48.000000	3.000000	3.000000	3.000000	1.000000	2.000000	4.000000	3.000000	1.000000	3.000000	2.000000	0.000000	0.000000	57.000000	66.000000	3.000000	2.000000	1.000000
+1.000000	1.000000	0.000000	104.000000	0.000000	3.000000	3.000000	5.000000	2.000000	2.000000	4.000000	3.000000	0.000000	3.000000	0.000000	4.000000	4.000000	69.000000	8.600000	2.000000	3.400000	-1.000000
+2.000000	1.000000	0.000000	0.000000	0.000000	3.000000	4.000000	6.000000	0.000000	4.000000	0.000000	4.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	-1.000000
+1.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.200000	60.000000	30.000000	1.000000	1.000000	3.000000	1.000000	3.000000	3.000000	1.000000	2.000000	1.000000	0.000000	3.000000	2.000000	48.000000	66.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	68.000000	14.000000	0.000000	0.000000	4.000000	1.000000	4.000000	0.000000	0.000000	0.000000	1.000000	4.300000	0.000000	0.000000	0.000000	0.000000	2.000000	2.800000	-1.000000
+1.000000	1.000000	0.000000	60.000000	30.000000	3.000000	3.000000	4.000000	2.000000	5.000000	4.000000	4.000000	1.000000	1.000000	0.000000	4.000000	0.000000	45.000000	70.000000	3.000000	2.000000	1.000000
+2.000000	1.000000	38.500000	100.000000	0.000000	3.000000	3.000000	5.000000	2.000000	4.000000	3.000000	4.000000	2.000000	1.000000	0.000000	4.000000	5.000000	0.000000	0.000000	0.000000	0.000000	-1.000000
+1.000000	1.000000	38.400000	84.000000	30.000000	3.000000	1.000000	5.000000	2.000000	4.000000	3.000000	3.000000	2.000000	3.000000	6.500000	4.000000	4.000000	47.000000	7.500000	3.000000	0.000000	-1.000000
+2.000000	1.000000	37.800000	48.000000	14.000000	0.000000	0.000000	1.000000	1.000000	3.000000	0.000000	2.000000	1.000000	3.000000	5.300000	1.000000	0.000000	35.000000	7.500000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.000000	0.000000	24.000000	3.000000	3.000000	6.000000	2.000000	5.000000	0.000000	4.000000	1.000000	1.000000	0.000000	0.000000	0.000000	68.000000	7.800000	0.000000	0.000000	-1.000000
+2.000000	1.000000	37.800000	56.000000	16.000000	1.000000	1.000000	2.000000	1.000000	2.000000	1.000000	1.000000	2.000000	1.000000	0.000000	1.000000	0.000000	44.000000	68.000000	1.000000	1.000000	1.000000
+2.000000	1.000000	38.200000	68.000000	32.000000	2.000000	2.000000	2.000000	1.000000	1.000000	1.000000	1.000000	3.000000	1.000000	0.000000	1.000000	1.000000	43.000000	65.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.500000	120.000000	60.000000	4.000000	3.000000	6.000000	2.000000	0.000000	3.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	54.000000	0.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	39.300000	64.000000	90.000000	2.000000	3.000000	1.000000	1.000000	0.000000	3.000000	1.000000	1.000000	2.000000	0.000000	0.000000	0.000000	39.000000	6.700000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.400000	80.000000	30.000000	4.000000	3.000000	1.000000	1.000000	3.000000	3.000000	3.000000	3.000000	3.000000	0.000000	4.000000	5.000000	32.000000	6.100000	3.000000	4.300000	1.000000
+1.000000	1.000000	38.500000	60.000000	0.000000	1.000000	1.000000	0.000000	1.000000	0.000000	1.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	33.000000	53.000000	1.000000	0.000000	1.000000
+1.000000	1.000000	38.300000	60.000000	16.000000	3.000000	1.000000	1.000000	1.000000	2.000000	1.000000	1.000000	2.000000	2.000000	3.000000	1.000000	4.000000	30.000000	6.000000	1.000000	3.000000	1.000000
+1.000000	1.000000	37.100000	40.000000	8.000000	0.000000	1.000000	4.000000	1.000000	3.000000	3.000000	1.000000	1.000000	1.000000	0.000000	3.000000	3.000000	23.000000	6.700000	3.000000	0.000000	1.000000
+2.000000	9.000000	0.000000	100.000000	44.000000	2.000000	1.000000	1.000000	1.000000	4.000000	1.000000	1.000000	0.000000	0.000000	0.000000	1.000000	0.000000	37.000000	4.700000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.200000	48.000000	18.000000	1.000000	1.000000	1.000000	1.000000	3.000000	3.000000	3.000000	1.000000	2.000000	0.000000	4.000000	0.000000	48.000000	74.000000	1.000000	2.000000	1.000000
+1.000000	1.000000	0.000000	60.000000	48.000000	3.000000	3.000000	4.000000	2.000000	4.000000	3.000000	4.000000	0.000000	0.000000	0.000000	0.000000	0.000000	58.000000	7.600000	0.000000	0.000000	-1.000000
+2.000000	1.000000	37.900000	88.000000	24.000000	1.000000	1.000000	2.000000	1.000000	2.000000	2.000000	1.000000	0.000000	0.000000	0.000000	4.000000	1.000000	37.000000	56.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.000000	44.000000	12.000000	3.000000	1.000000	1.000000	0.000000	0.000000	1.000000	2.000000	0.000000	0.000000	0.000000	1.000000	0.000000	42.000000	64.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.500000	60.000000	20.000000	1.000000	1.000000	5.000000	2.000000	2.000000	2.000000	1.000000	2.000000	1.000000	0.000000	2.000000	3.000000	63.000000	7.500000	2.000000	2.300000	-1.000000
+2.000000	1.000000	38.500000	96.000000	36.000000	3.000000	3.000000	0.000000	2.000000	2.000000	4.000000	2.000000	1.000000	2.000000	0.000000	4.000000	5.000000	70.000000	8.500000	0.000000	0.000000	-1.000000
+2.000000	1.000000	38.300000	60.000000	20.000000	1.000000	1.000000	1.000000	2.000000	1.000000	3.000000	1.000000	0.000000	0.000000	0.000000	3.000000	0.000000	34.000000	66.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.500000	60.000000	40.000000	3.000000	1.000000	2.000000	1.000000	2.000000	1.000000	2.000000	0.000000	0.000000	0.000000	3.000000	2.000000	49.000000	59.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	37.300000	48.000000	12.000000	1.000000	0.000000	3.000000	1.000000	3.000000	1.000000	3.000000	2.000000	1.000000	0.000000	3.000000	3.000000	40.000000	6.600000	2.000000	0.000000	1.000000
+1.000000	1.000000	38.500000	86.000000	0.000000	1.000000	1.000000	3.000000	1.000000	4.000000	4.000000	3.000000	2.000000	1.000000	0.000000	3.000000	5.000000	45.000000	7.400000	1.000000	3.400000	-1.000000
+1.000000	1.000000	37.500000	48.000000	40.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	1.000000	1.000000	0.000000	0.000000	5.000000	41.000000	55.000000	3.000000	2.000000	-1.000000
+2.000000	1.000000	37.200000	36.000000	9.000000	1.000000	1.000000	1.000000	1.000000	2.000000	3.000000	1.000000	2.000000	1.000000	0.000000	4.000000	1.000000	35.000000	5.700000	0.000000	0.000000	1.000000
+1.000000	1.000000	39.200000	0.000000	23.000000	3.000000	1.000000	3.000000	1.000000	4.000000	4.000000	2.000000	2.000000	0.000000	0.000000	0.000000	0.000000	36.000000	6.600000	1.000000	3.000000	1.000000
+2.000000	1.000000	38.500000	100.000000	0.000000	3.000000	3.000000	5.000000	2.000000	4.000000	3.000000	4.000000	2.000000	1.000000	0.000000	4.000000	5.000000	0.000000	0.000000	0.000000	0.000000	-1.000000
+1.000000	1.000000	38.500000	96.000000	30.000000	2.000000	3.000000	4.000000	2.000000	4.000000	4.000000	3.000000	2.000000	1.000000	0.000000	3.000000	5.000000	50.000000	65.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	45.000000	8.700000	0.000000	0.000000	-1.000000
+1.000000	1.000000	37.800000	88.000000	80.000000	3.000000	3.000000	5.000000	2.000000	0.000000	3.000000	3.000000	2.000000	3.000000	0.000000	4.000000	5.000000	64.000000	89.000000	0.000000	0.000000	-1.000000
+2.000000	1.000000	37.500000	44.000000	10.000000	3.000000	1.000000	1.000000	1.000000	3.000000	1.000000	2.000000	2.000000	0.000000	0.000000	3.000000	3.000000	43.000000	51.000000	1.000000	1.000000	1.000000
+1.000000	1.000000	37.900000	68.000000	20.000000	0.000000	1.000000	2.000000	1.000000	2.000000	4.000000	2.000000	0.000000	0.000000	0.000000	1.000000	5.000000	45.000000	4.000000	3.000000	2.800000	-1.000000
+1.000000	1.000000	38.000000	86.000000	24.000000	4.000000	3.000000	4.000000	1.000000	2.000000	4.000000	4.000000	1.000000	1.000000	0.000000	4.000000	5.000000	45.000000	5.500000	1.000000	10.100000	-1.000000
+1.000000	9.000000	38.900000	120.000000	30.000000	1.000000	3.000000	2.000000	2.000000	3.000000	3.000000	3.000000	3.000000	1.000000	3.000000	0.000000	0.000000	47.000000	6.300000	1.000000	0.000000	1.000000
+1.000000	1.000000	37.600000	45.000000	12.000000	3.000000	1.000000	3.000000	1.000000	0.000000	2.000000	2.000000	2.000000	1.000000	0.000000	1.000000	4.000000	39.000000	7.000000	2.000000	1.500000	1.000000
+2.000000	1.000000	38.600000	56.000000	32.000000	2.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	2.000000	0.000000	0.000000	2.000000	0.000000	40.000000	7.000000	2.000000	2.100000	1.000000
+1.000000	1.000000	37.800000	40.000000	12.000000	1.000000	1.000000	1.000000	1.000000	1.000000	2.000000	1.000000	2.000000	1.000000	0.000000	1.000000	2.000000	38.000000	7.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.000000	76.000000	18.000000	0.000000	0.000000	0.000000	2.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	71.000000	11.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.100000	40.000000	36.000000	1.000000	2.000000	2.000000	1.000000	2.000000	2.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	-1.000000
+1.000000	1.000000	0.000000	52.000000	28.000000	3.000000	3.000000	4.000000	1.000000	3.000000	4.000000	3.000000	2.000000	1.000000	0.000000	4.000000	4.000000	37.000000	8.100000	0.000000	0.000000	1.000000
+1.000000	1.000000	39.200000	88.000000	58.000000	4.000000	4.000000	0.000000	2.000000	5.000000	4.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	2.000000	2.000000	-1.000000
+1.000000	1.000000	38.500000	92.000000	40.000000	4.000000	3.000000	0.000000	1.000000	2.000000	4.000000	3.000000	0.000000	0.000000	0.000000	4.000000	0.000000	46.000000	67.000000	2.000000	2.000000	1.000000
+1.000000	1.000000	0.000000	112.000000	13.000000	4.000000	4.000000	4.000000	1.000000	2.000000	3.000000	1.000000	2.000000	1.000000	4.500000	4.000000	4.000000	60.000000	6.300000	3.000000	0.000000	1.000000
+1.000000	1.000000	37.700000	66.000000	12.000000	1.000000	1.000000	3.000000	1.000000	3.000000	3.000000	2.000000	2.000000	0.000000	0.000000	4.000000	4.000000	31.500000	6.200000	2.000000	1.600000	1.000000
+1.000000	1.000000	38.800000	50.000000	14.000000	1.000000	1.000000	1.000000	1.000000	3.000000	1.000000	1.000000	1.000000	1.000000	0.000000	3.000000	5.000000	38.000000	58.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.400000	54.000000	24.000000	1.000000	1.000000	1.000000	1.000000	1.000000	3.000000	1.000000	2.000000	1.000000	0.000000	3.000000	2.000000	49.000000	7.200000	1.000000	8.000000	1.000000
+1.000000	1.000000	39.200000	120.000000	20.000000	4.000000	3.000000	5.000000	2.000000	2.000000	3.000000	3.000000	1.000000	3.000000	0.000000	0.000000	4.000000	60.000000	8.800000	3.000000	0.000000	-1.000000
+1.000000	9.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	45.000000	6.500000	2.000000	0.000000	1.000000
+1.000000	1.000000	37.300000	90.000000	40.000000	3.000000	0.000000	6.000000	2.000000	5.000000	4.000000	3.000000	2.000000	2.000000	0.000000	1.000000	5.000000	65.000000	50.000000	3.000000	2.000000	-1.000000
+1.000000	9.000000	38.500000	120.000000	70.000000	0.000000	0.000000	0.000000	0.000000	0.000000	1.000000	0.000000	2.000000	0.000000	0.000000	1.000000	0.000000	35.000000	54.000000	1.000000	1.000000	1.000000
+1.000000	1.000000	38.500000	104.000000	40.000000	3.000000	3.000000	0.000000	1.000000	4.000000	3.000000	4.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	39.500000	92.000000	28.000000	3.000000	3.000000	6.000000	1.000000	5.000000	4.000000	1.000000	0.000000	3.000000	0.000000	4.000000	0.000000	72.000000	6.400000	0.000000	3.600000	-1.000000
+1.000000	1.000000	38.500000	30.000000	18.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	40.000000	7.700000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.300000	72.000000	30.000000	4.000000	3.000000	3.000000	2.000000	3.000000	3.000000	3.000000	2.000000	1.000000	0.000000	3.000000	5.000000	43.000000	7.000000	2.000000	3.900000	1.000000
+2.000000	1.000000	37.500000	48.000000	30.000000	4.000000	1.000000	3.000000	1.000000	0.000000	2.000000	1.000000	1.000000	1.000000	0.000000	1.000000	1.000000	48.000000	8.600000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.100000	52.000000	24.000000	1.000000	1.000000	5.000000	1.000000	4.000000	3.000000	1.000000	2.000000	3.000000	7.000000	1.000000	0.000000	54.000000	7.500000	2.000000	2.600000	-1.000000
+2.000000	1.000000	38.200000	42.000000	26.000000	1.000000	1.000000	1.000000	1.000000	3.000000	1.000000	2.000000	0.000000	0.000000	0.000000	1.000000	0.000000	36.000000	6.900000	0.000000	0.000000	1.000000
+2.000000	1.000000	37.900000	54.000000	42.000000	2.000000	1.000000	5.000000	1.000000	3.000000	1.000000	1.000000	0.000000	1.000000	0.000000	0.000000	2.000000	47.000000	54.000000	3.000000	1.000000	1.000000
+2.000000	1.000000	36.100000	88.000000	0.000000	3.000000	3.000000	3.000000	1.000000	3.000000	3.000000	2.000000	2.000000	3.000000	0.000000	0.000000	4.000000	45.000000	7.000000	3.000000	4.800000	-1.000000
+1.000000	1.000000	38.100000	70.000000	22.000000	0.000000	1.000000	0.000000	1.000000	5.000000	3.000000	0.000000	0.000000	0.000000	0.000000	0.000000	5.000000	36.000000	65.000000	0.000000	0.000000	-1.000000
+1.000000	1.000000	38.000000	90.000000	30.000000	4.000000	3.000000	4.000000	2.000000	5.000000	4.000000	4.000000	0.000000	0.000000	0.000000	4.000000	5.000000	55.000000	6.100000	0.000000	0.000000	-1.000000
+1.000000	1.000000	38.200000	52.000000	16.000000	1.000000	1.000000	2.000000	1.000000	1.000000	2.000000	1.000000	1.000000	1.000000	0.000000	1.000000	0.000000	43.000000	8.100000	0.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	36.000000	32.000000	1.000000	1.000000	4.000000	1.000000	5.000000	3.000000	3.000000	2.000000	3.000000	4.000000	0.000000	4.000000	41.000000	5.900000	0.000000	0.000000	-1.000000
+1.000000	1.000000	38.400000	92.000000	20.000000	1.000000	0.000000	0.000000	2.000000	0.000000	3.000000	3.000000	0.000000	0.000000	0.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	1.000000
+1.000000	9.000000	38.200000	124.000000	88.000000	1.000000	3.000000	2.000000	1.000000	2.000000	3.000000	4.000000	0.000000	0.000000	0.000000	0.000000	0.000000	47.000000	8.000000	1.000000	0.000000	1.000000
+2.000000	1.000000	0.000000	96.000000	0.000000	3.000000	3.000000	3.000000	2.000000	5.000000	4.000000	4.000000	0.000000	1.000000	0.000000	4.000000	5.000000	60.000000	0.000000	0.000000	0.000000	-1.000000
+1.000000	1.000000	37.600000	68.000000	32.000000	3.000000	0.000000	3.000000	1.000000	4.000000	2.000000	4.000000	2.000000	2.000000	6.500000	1.000000	5.000000	47.000000	7.200000	1.000000	0.000000	1.000000
+1.000000	1.000000	38.100000	88.000000	24.000000	3.000000	3.000000	4.000000	1.000000	5.000000	4.000000	3.000000	2.000000	1.000000	0.000000	3.000000	4.000000	41.000000	4.600000	0.000000	0.000000	-1.000000
+1.000000	1.000000	38.000000	108.000000	60.000000	2.000000	3.000000	4.000000	1.000000	4.000000	3.000000	3.000000	2.000000	0.000000	0.000000	3.000000	4.000000	0.000000	0.000000	3.000000	0.000000	1.000000
+2.000000	1.000000	38.200000	48.000000	0.000000	2.000000	0.000000	1.000000	2.000000	3.000000	3.000000	1.000000	2.000000	1.000000	0.000000	0.000000	2.000000	34.000000	6.600000	0.000000	0.000000	1.000000
+1.000000	1.000000	39.300000	100.000000	51.000000	4.000000	4.000000	6.000000	1.000000	2.000000	4.000000	1.000000	1.000000	3.000000	2.000000	0.000000	4.000000	66.000000	13.000000	3.000000	2.000000	-1.000000
+2.000000	1.000000	36.600000	42.000000	18.000000	3.000000	3.000000	2.000000	1.000000	1.000000	4.000000	1.000000	1.000000	1.000000	0.000000	0.000000	5.000000	52.000000	7.100000	0.000000	0.000000	-1.000000
+1.000000	9.000000	38.800000	124.000000	36.000000	3.000000	1.000000	2.000000	1.000000	2.000000	3.000000	4.000000	1.000000	1.000000	0.000000	4.000000	4.000000	50.000000	7.600000	3.000000	0.000000	-1.000000
+2.000000	1.000000	0.000000	112.000000	24.000000	3.000000	3.000000	4.000000	2.000000	5.000000	4.000000	2.000000	0.000000	0.000000	0.000000	4.000000	0.000000	40.000000	5.300000	3.000000	2.600000	1.000000
+1.000000	1.000000	0.000000	80.000000	0.000000	3.000000	3.000000	3.000000	1.000000	4.000000	4.000000	4.000000	0.000000	0.000000	0.000000	4.000000	5.000000	43.000000	70.000000	0.000000	0.000000	1.000000
+1.000000	9.000000	38.800000	184.000000	84.000000	1.000000	0.000000	1.000000	1.000000	4.000000	1.000000	3.000000	0.000000	0.000000	0.000000	2.000000	0.000000	33.000000	3.300000	0.000000	0.000000	-1.000000
+1.000000	1.000000	37.500000	72.000000	0.000000	2.000000	1.000000	1.000000	1.000000	2.000000	1.000000	1.000000	1.000000	1.000000	0.000000	1.000000	0.000000	35.000000	65.000000	2.000000	2.000000	-1.000000
+1.000000	1.000000	38.700000	96.000000	28.000000	3.000000	3.000000	4.000000	1.000000	0.000000	4.000000	0.000000	0.000000	3.000000	7.500000	0.000000	0.000000	64.000000	9.000000	0.000000	0.000000	-1.000000
+2.000000	1.000000	37.500000	52.000000	12.000000	1.000000	1.000000	1.000000	1.000000	2.000000	3.000000	2.000000	2.000000	1.000000	0.000000	3.000000	5.000000	36.000000	61.000000	1.000000	1.000000	1.000000
+1.000000	1.000000	40.800000	72.000000	42.000000	3.000000	3.000000	1.000000	1.000000	2.000000	3.000000	1.000000	2.000000	1.000000	0.000000	0.000000	0.000000	54.000000	7.400000	3.000000	0.000000	-1.000000
+2.000000	1.000000	38.000000	40.000000	25.000000	0.000000	1.000000	1.000000	1.000000	4.000000	3.000000	2.000000	1.000000	1.000000	0.000000	4.000000	0.000000	37.000000	69.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.400000	48.000000	16.000000	2.000000	1.000000	1.000000	1.000000	1.000000	0.000000	2.000000	2.000000	1.000000	0.000000	0.000000	2.000000	39.000000	6.500000	0.000000	0.000000	1.000000
+2.000000	9.000000	38.600000	88.000000	28.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	35.000000	5.900000	0.000000	0.000000	1.000000
+1.000000	1.000000	37.100000	75.000000	36.000000	0.000000	0.000000	3.000000	2.000000	4.000000	4.000000	2.000000	2.000000	3.000000	5.000000	4.000000	4.000000	48.000000	7.400000	3.000000	3.200000	-1.000000
+1.000000	1.000000	38.300000	44.000000	21.000000	3.000000	1.000000	2.000000	1.000000	3.000000	3.000000	3.000000	2.000000	1.000000	0.000000	1.000000	5.000000	44.000000	6.500000	2.000000	4.400000	1.000000
+2.000000	1.000000	0.000000	56.000000	68.000000	3.000000	1.000000	1.000000	1.000000	3.000000	3.000000	1.000000	2.000000	1.000000	0.000000	1.000000	0.000000	40.000000	6.000000	0.000000	0.000000	-1.000000
+2.000000	1.000000	38.600000	68.000000	20.000000	2.000000	1.000000	3.000000	1.000000	3.000000	3.000000	2.000000	1.000000	1.000000	0.000000	1.000000	5.000000	38.000000	6.500000	1.000000	0.000000	1.000000
+2.000000	1.000000	38.300000	54.000000	18.000000	3.000000	1.000000	2.000000	1.000000	2.000000	3.000000	2.000000	0.000000	3.000000	5.400000	0.000000	4.000000	44.000000	7.200000	3.000000	0.000000	1.000000
+1.000000	1.000000	38.200000	42.000000	20.000000	0.000000	0.000000	1.000000	1.000000	0.000000	3.000000	0.000000	0.000000	0.000000	0.000000	3.000000	0.000000	47.000000	60.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	39.300000	64.000000	90.000000	2.000000	3.000000	1.000000	1.000000	0.000000	3.000000	1.000000	1.000000	2.000000	6.500000	1.000000	5.000000	39.000000	6.700000	0.000000	0.000000	1.000000
+1.000000	1.000000	37.500000	60.000000	50.000000	3.000000	3.000000	1.000000	1.000000	3.000000	3.000000	2.000000	2.000000	2.000000	3.500000	3.000000	4.000000	35.000000	6.500000	0.000000	0.000000	-1.000000
+1.000000	1.000000	37.700000	80.000000	0.000000	3.000000	3.000000	6.000000	1.000000	5.000000	4.000000	1.000000	2.000000	3.000000	0.000000	3.000000	1.000000	50.000000	55.000000	3.000000	2.000000	1.000000
+1.000000	1.000000	0.000000	100.000000	30.000000	3.000000	3.000000	4.000000	2.000000	5.000000	4.000000	4.000000	3.000000	3.000000	0.000000	4.000000	4.000000	52.000000	6.600000	0.000000	0.000000	1.000000
+1.000000	1.000000	37.700000	120.000000	28.000000	3.000000	3.000000	3.000000	1.000000	5.000000	3.000000	3.000000	1.000000	1.000000	0.000000	0.000000	0.000000	65.000000	7.000000	3.000000	0.000000	-1.000000
+1.000000	1.000000	0.000000	76.000000	0.000000	0.000000	3.000000	0.000000	0.000000	0.000000	4.000000	4.000000	0.000000	0.000000	0.000000	0.000000	5.000000	0.000000	0.000000	0.000000	0.000000	-1.000000
+1.000000	9.000000	38.800000	150.000000	50.000000	1.000000	3.000000	6.000000	2.000000	5.000000	3.000000	2.000000	1.000000	1.000000	0.000000	0.000000	0.000000	50.000000	6.200000	0.000000	0.000000	-1.000000
+1.000000	1.000000	38.000000	36.000000	16.000000	3.000000	1.000000	1.000000	1.000000	4.000000	2.000000	2.000000	3.000000	3.000000	2.000000	3.000000	0.000000	37.000000	75.000000	2.000000	1.000000	-1.000000
+2.000000	1.000000	36.900000	50.000000	40.000000	2.000000	3.000000	3.000000	1.000000	1.000000	3.000000	2.000000	3.000000	1.000000	7.000000	0.000000	0.000000	37.500000	6.500000	0.000000	0.000000	1.000000
+2.000000	1.000000	37.800000	40.000000	16.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	0.000000	0.000000	0.000000	1.000000	1.000000	37.000000	6.800000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.200000	56.000000	40.000000	4.000000	3.000000	1.000000	1.000000	2.000000	4.000000	3.000000	2.000000	2.000000	7.500000	0.000000	0.000000	47.000000	7.200000	1.000000	2.500000	1.000000
+1.000000	1.000000	38.600000	48.000000	12.000000	0.000000	0.000000	1.000000	0.000000	1.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	36.000000	67.000000	0.000000	0.000000	1.000000
+2.000000	1.000000	40.000000	78.000000	0.000000	3.000000	3.000000	5.000000	1.000000	2.000000	3.000000	1.000000	1.000000	1.000000	0.000000	4.000000	1.000000	66.000000	6.500000	0.000000	0.000000	-1.000000
+1.000000	1.000000	0.000000	70.000000	16.000000	3.000000	4.000000	5.000000	2.000000	2.000000	3.000000	2.000000	2.000000	1.000000	0.000000	4.000000	5.000000	60.000000	7.500000	0.000000	0.000000	-1.000000
+1.000000	1.000000	38.200000	72.000000	18.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	35.000000	6.400000	0.000000	0.000000	1.000000
+2.000000	1.000000	38.500000	54.000000	0.000000	1.000000	1.000000	1.000000	1.000000	3.000000	1.000000	1.000000	2.000000	1.000000	0.000000	1.000000	0.000000	40.000000	6.800000	2.000000	7.000000	1.000000
+1.000000	1.000000	38.500000	66.000000	24.000000	1.000000	1.000000	1.000000	1.000000	3.000000	3.000000	1.000000	2.000000	1.000000	0.000000	4.000000	5.000000	40.000000	6.700000	1.000000	0.000000	1.000000
+2.000000	1.000000	37.800000	82.000000	12.000000	3.000000	1.000000	1.000000	2.000000	4.000000	0.000000	3.000000	1.000000	3.000000	0.000000	0.000000	0.000000	50.000000	7.000000	0.000000	0.000000	-1.000000
+2.000000	9.000000	39.500000	84.000000	30.000000	0.000000	0.000000	0.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	28.000000	5.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.000000	50.000000	36.000000	0.000000	1.000000	1.000000	1.000000	3.000000	2.000000	2.000000	0.000000	0.000000	0.000000	3.000000	0.000000	39.000000	6.600000	1.000000	5.300000	1.000000
+2.000000	1.000000	38.600000	45.000000	16.000000	2.000000	1.000000	2.000000	1.000000	1.000000	1.000000	0.000000	0.000000	0.000000	0.000000	1.000000	1.000000	43.000000	58.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	38.900000	80.000000	44.000000	3.000000	3.000000	3.000000	1.000000	2.000000	3.000000	3.000000	2.000000	2.000000	7.000000	3.000000	1.000000	54.000000	6.500000	3.000000	0.000000	-1.000000
+1.000000	1.000000	37.000000	66.000000	20.000000	1.000000	3.000000	2.000000	1.000000	4.000000	3.000000	3.000000	1.000000	0.000000	0.000000	1.000000	5.000000	35.000000	6.900000	2.000000	0.000000	-1.000000
+1.000000	1.000000	0.000000	78.000000	24.000000	3.000000	3.000000	3.000000	1.000000	0.000000	3.000000	0.000000	2.000000	1.000000	0.000000	0.000000	4.000000	43.000000	62.000000	0.000000	2.000000	-1.000000
+2.000000	1.000000	38.500000	40.000000	16.000000	1.000000	1.000000	1.000000	1.000000	2.000000	1.000000	1.000000	0.000000	0.000000	0.000000	3.000000	2.000000	37.000000	67.000000	0.000000	0.000000	1.000000
+1.000000	1.000000	0.000000	120.000000	70.000000	4.000000	0.000000	4.000000	2.000000	2.000000	4.000000	0.000000	0.000000	0.000000	0.000000	0.000000	5.000000	55.000000	65.000000	0.000000	0.000000	-1.000000
+2.000000	1.000000	37.200000	72.000000	24.000000	3.000000	2.000000	4.000000	2.000000	4.000000	3.000000	3.000000	3.000000	1.000000	0.000000	4.000000	4.000000	44.000000	0.000000	3.000000	3.300000	-1.000000
+1.000000	1.000000	37.500000	72.000000	30.000000	4.000000	3.000000	4.000000	1.000000	4.000000	4.000000	3.000000	2.000000	1.000000	0.000000	3.000000	5.000000	60.000000	6.800000	0.000000	0.000000	-1.000000
+1.000000	1.000000	36.500000	100.000000	24.000000	3.000000	3.000000	3.000000	1.000000	3.000000	3.000000	3.000000	3.000000	1.000000	0.000000	4.000000	4.000000	50.000000	6.000000	3.000000	3.400000	1.000000
+1.000000	1.000000	37.200000	40.000000	20.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	4.000000	1.000000	36.000000	62.000000	1.000000	1.000000	-1.000000

机器学习/adboost/信息熵.py

@@ -0,0 +1,29 @@
+# https://www.bilibili.com/video/BV1p7411t7ri?from=search&seid=7286286693409120190
+
+# https://blog.csdn.net/gyqjn/article/details/45501185
+import numpy as np
+# 条件熵
+def h(x):
+    return np.sum([-p*np.log2(p) for p in x])
+def alpha(e):
+    return 0.5*np.log2((1-e)/e)
+# print(h([1/2,1/2]))
+print(h([3/7,4/7]))
+print("阈值为2.5条件熵： ",0.3*h([1])+0.7*h([3/7,4/7]))
+print("阈值为5.5条件熵： ",0.6*h([3/6,3/6])+0.4*h([3/4,1/4]))
+print("阈值为8.5条件熵： ",0.9*h([3/9,6/9])+0.1*h([1]))
+
+print(alpha(0.3))
+
+# 六.举例
+# 信息熵
+# 假如双十一我要剁手买一件衣服，但是我一直犹豫着要不要买，我决定买这件事的不确定性（熵）为2.6。
+# 条件熵
+# 我在看了这件衣服的评价后，我决定买衣服这件事的不确定性是1.2。
+# 我在线下实体店试穿衣服后，我决定买衣服这件事的不确定性是0.9。
+# 信息增益
+# 上面条件熵给出了两个：
+# 一个是看了网上的评价，此时的信息增益是Gain1=2.6−1.2=1.4Gain1=2.6−1.2=1.4。
+# 另一个是线下试穿了衣服，此时的信息增益
+# Gain2=2.6−0.9=1.7Gain2=2.6−0.9=1.7。
+# # 很显然我在线下试穿衣服之后对于决定买这件衣服的不确定度下降更多，更通俗的说就是我试穿衣服之后买这件衣服的可能性更大了。所以如果有看买家评价和线下试穿两个属性，首先应该选择线下试穿来构建内部节点。

机器学习/交叉熵/demo.py

@@ -0,0 +1,26 @@
+import  torch
+import  torch.nn.functional as F
+
+# a表示数据样本的概率
+a = torch.tensor([0.3,0.3,0.3,0.3])
+b = torch.tensor([0.001,0.001,0.009])
+# a1的和表示数据样本的信息熵
+a1 = -(a*torch.log2(a)).sum()
+b1 = -(b*torch.log2(b)).sum()
+print("a1的和表示数据样本的信息熵 : ",a1," b1的和表示数据样本的信息熵 : ",b1)
+
+# a表示真是样本的分类信息 比如狗的照片，其余都不是狗
+a = torch.tensor([1.,0,0])
+out = torch.tensor([1.1,1,0.1])
+# 首先out需要softmax
+out = out.view(1,-1)
+out = F.softmax(out,dim=1)
+print("out需要softmax",out)
+# tensor([[0.6590, 0.2424, 0.0986]])
+# a与out的交叉熵表示为
+out= out.view(1,-1)
+print(-(a*torch.log2(out)).sum())
+
+
+print(torch.nn.CrossEntropyLoss(out,a.view(-1,1)))
+

机器学习/信息增益/信息增益的计算.py

@@ -0,0 +1,67 @@
+import numpy as np
+import math
+def createData():
+    datasets = [[0,0,0,0,'no'],
+                [0,0,0,1,'no'],
+                [0,1,0,1,'yes'],
+                [0,1,1,0,'yes'],
+                [0,0,0,0,'no'],
+                [1,0,0,0,'no'],
+                [1,0,0,1,'no'],
+                [1,1,1,1,'yes'],
+                [1,0,1,2,'yes'],
+                [1,0,1,2,'yes'],
+                [2,0,1,2,'yes'],
+                [2,0,1,1,'yes'],
+                [2,1,0,1,'yes'],
+                [2,1,0,2,'yes'],
+                [2,0,0,0,'no']]
+    lables = ['age','work','hourse','credit','apply']
+    return datasets,lables
+
+def shannoEnt(datasets):
+    lableCount = {}
+    for dataset in datasets:
+        lable = dataset[-1]
+        if lable not in lableCount.keys():
+            lableCount[lable] =0
+        lableCount[lable]+=1
+    shanoEnt = 0
+    l = len(datasets)
+    for key in lableCount.keys():
+        tmp = float(lableCount[key])/l
+        shanoEnt -= tmp*math.log2(tmp)
+    return shanoEnt
+datasets,lables = createData()
+shanoEnt = shannoEnt(datasets)
+print("shanoEnt",shanoEnt)
+
+# 计算每个特征的信息增益
+
+def splitdatasets(datasets,axis,value):
+    retDataset = []
+    for featVec in datasets:
+        if featVec[axis] == value:
+            reducedFeatVec = featVec[:axis]
+            reducedFeatVec.extend(featVec[axis+1:])
+            retDataset.append(reducedFeatVec)
+    return retDataset
+# 计算axis为列的信息增益
+def infoGain(datasets,axis):
+    baseEnt = shannoEnt(datasets)
+    newEnt = 0.0
+    featlist = [example[axis] for example in datasets]
+    uniqueVals = set(featlist)
+    for value in uniqueVals:
+        subDataSet = splitdatasets(datasets,axis,value)
+        prob = len(subDataSet)/float(len(datasets))
+        newEnt +=prob*shannoEnt(subDataSet)
+    infoGain = baseEnt -newEnt
+    return infoGain
+
+print(infoGain(datasets,0))
+print(infoGain(datasets,1))
+print(infoGain(datasets,2))
+print(infoGain(datasets,3))
+
+

梯度下降/data.txt

@@ -0,0 +1,100 @@
+32.502345269453031,31.70700584656992
+53.426804033275019,68.77759598163891
+61.530358025636438,62.562382297945803
+47.475639634786098,71.546632233567777
+59.813207869512318,87.230925133687393
+55.142188413943821,78.211518270799232
+52.211796692214001,79.64197304980874
+39.299566694317065,59.171489321869508
+48.10504169176825,75.331242297063056
+52.550014442733818,71.300879886850353
+45.419730144973755,55.165677145959123
+54.351634881228918,82.478846757497919
+44.164049496773352,62.008923245725825
+58.16847071685779,75.392870425994957
+56.727208057096611,81.43619215887864
+48.955888566093719,60.723602440673965
+44.687196231480904,82.892503731453715
+60.297326851333466,97.379896862166078
+45.618643772955828,48.847153317355072
+38.816817537445637,56.877213186268506
+66.189816606752601,83.878564664602763
+65.41605174513407,118.59121730252249
+47.48120860786787,57.251819462268969
+41.57564261748702,51.391744079832307
+51.84518690563943,75.380651665312357
+59.370822011089523,74.765564032151374
+57.31000343834809,95.455052922574737
+63.615561251453308,95.229366017555307
+46.737619407976972,79.052406169565586
+50.556760148547767,83.432071421323712
+52.223996085553047,63.358790317497878
+35.567830047746632,41.412885303700563
+42.436476944055642,76.617341280074044
+58.16454011019286,96.769566426108199
+57.504447615341789,74.084130116602523
+45.440530725319981,66.588144414228594
+61.89622268029126,77.768482417793024
+33.093831736163963,50.719588912312084
+36.436009511386871,62.124570818071781
+37.675654860850742,60.810246649902211
+44.555608383275356,52.682983366387781
+43.318282631865721,58.569824717692867
+50.073145632289034,82.905981485070512
+43.870612645218372,61.424709804339123
+62.997480747553091,115.24415280079529
+32.669043763467187,45.570588823376085
+40.166899008703702,54.084054796223612
+53.575077531673656,87.994452758110413
+33.864214971778239,52.725494375900425
+64.707138666121296,93.576118692658241
+38.119824026822805,80.166275447370964
+44.502538064645101,65.101711570560326
+40.599538384552318,65.562301260400375
+41.720676356341293,65.280886920822823
+51.088634678336796,73.434641546324301
+55.078095904923202,71.13972785861894
+41.377726534895203,79.102829683549857
+62.494697427269791,86.520538440347153
+49.203887540826003,84.742697807826218
+41.102685187349664,59.358850248624933
+41.182016105169822,61.684037524833627
+50.186389494880601,69.847604158249183
+52.378446219236217,86.098291205774103
+50.135485486286122,59.108839267699643
+33.644706006191782,69.89968164362763
+39.557901222906828,44.862490711164398
+56.130388816875467,85.498067778840223
+57.362052133238237,95.536686846467219
+60.269214393997906,70.251934419771587
+35.678093889410732,52.721734964774988
+31.588116998132829,50.392670135079896
+53.66093226167304,63.642398775657753
+46.682228649471917,72.247251068662365
+43.107820219102464,57.812512976181402
+70.34607561504933,104.25710158543822
+44.492855880854073,86.642020318822006
+57.50453330326841,91.486778000110135
+36.930076609191808,55.231660886212836
+55.805733357942742,79.550436678507609
+38.954769073377065,44.847124242467601
+56.901214702247074,80.207523139682763
+56.868900661384046,83.14274979204346
+34.33312470421609,55.723489260543914
+59.04974121466681,77.634182511677864
+57.788223993230673,99.051414841748269
+54.282328705967409,79.120646274680027
+51.088719898979143,69.588897851118475
+50.282836348230731,69.510503311494389
+44.211741752090113,73.687564318317285
+38.005488008060688,61.366904537240131
+32.940479942618296,67.170655768995118
+53.691639571070056,85.668203145001542
+68.76573426962166,114.85387123391394
+46.230966498310252,90.123572069967423
+68.319360818255362,97.919821035242848
+50.030174340312143,81.536990783015028
+49.239765342753763,72.111832469615663
+50.039575939875988,85.232007342325673
+48.149858891028863,66.224957888054632
+25.128484647772304,53.454394214850524

梯度下降/little use 梯度下降解决回归问题 data.py

@@ -0,0 +1,59 @@
+# https://blog.csdn.net/qq_37236745/article/details/103698507
+import numpy as np
+# compute loss
+def compute_error(b, w, points):
+    totalError = 0
+    for i in range(len(points)):
+        x = points[i, 0]
+        y = points[i, 1]
+        totalError += (y - (w * x + b)) ** 2
+    return totalError / float(len(points)) # average
+
+# compute gradient
+def step_gradient(b_current, w_current, points, learningRate):
+    b_gradient = 0
+    w_gradient = 0
+    N = float(len(points))
+    for i in range(len(points)):
+        x = points[i, 0]
+        y = points[i, 1]
+        b_gradient += 2 * ((w_current * x) + b_current - y)
+        w_gradient += 2 * x * ((w_current * x) + b_current - y)
+    b_gradient = b_gradient / N
+    w_gradient = w_gradient / N
+    new_b = b_current - (learningRate * b_gradient)
+    new_w = w_current - (learningRate * w_gradient)
+    return [new_b, new_w]
+
+def gradient_descent_runner(points, starting_b, starting_w, learning_rate, num_iterations): # num_iteration 迭代次数
+    b = starting_b
+    w = starting_w
+    error = np.zeros(num_iterations)
+    for i in range(num_iterations):
+        b, w = step_gradient(b, w, np.array(points), learning_rate)
+        error[i] = compute_error(b, w, points)
+    return [b, w],error
+
+def run():
+    points = np.genfromtxt("data.txt", delimiter=",")
+    learning_rate = 0.000001
+    initial_b = np.random.random()
+    initial_w = np.random.random()
+    num_iterations = 1000
+    print("Starting gradient descent at b = {0}, w = {1}, error = {2}"
+          .format(initial_b, initial_w,
+                  compute_error(initial_b, initial_w, points)))
+    print("Running...")
+    [b, w],error = gradient_descent_runner(points, initial_b, initial_w, learning_rate, num_iterations)
+    print("After {0} iterations at b = {1}, w = {2}, error = {3}"
+          .format(num_iterations, b, w,
+                  compute_error(b, w, points)))
+
+    import matplotlib.pyplot as plt
+    fig, bx = plt.subplots(figsize=(8, 6))
+    bx.plot(np.arange(num_iterations), error, 'r')
+    bx.set_xlabel('Iterations')
+    bx.set_ylabel('Cost')
+    bx.set_title('Error vs. Training Epoch')
+    plt.show()
+run()

梯度下降/test.py

@@ -0,0 +1,19 @@
+import numpy as np
+import pandas as pd
+
+a = np.array([1,2])
+b = a.reshape(1,2)
+# b = np.mat(a)
+c = np.array([[1,2],[1,3],[1,4]])
+# d = c.reshape(3,2)
+d = np.mat(c)
+print(f"a is {a} {a.shape} shape {a.shape[0]}, b is {b} {b.shape} shape {b.shape[0],b.shape[1]}, "
+      f"c is {c} {c.shape}, d is {d} {d.shape}")
+# 注意 e = np.mat([[2],[1],[3]]) 是错误的
+# 矩阵与矩阵相乘，  矩阵与数组相乘完全不同
+e = np.array([[2],[1],[3]])
+print(f"c*e is {c*e}\n")
+
+f = np.mat([[2],[1]])
+print(f" c shape is {c}, and f shape is {f} \n"
+      f"c*f  ",c*f)

梯度下降/梯度下降 Class.py

@@ -0,0 +1,73 @@
+# https://www.cnblogs.com/judejie/p/8999832.html
+
+# 工作年限与收入之间的散点图
+# 导入第三方模块
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+import numpy as np
+# 导入数据集
+# income = pd.read_csv(r'Salary_Data.csv')
+# 绘制散点图
+# sns.lmplot(x = 'YearsExperience', y = 'Salary', data = income, ci = None)
+# 显示图形
+
+
+
+class GD():
+    def __init__(self,data,w,b, lr, nstep):
+        self.data = data
+        self.w = w
+        self.b = b
+        self.lr = lr
+        self.nstep = nstep
+
+    def loss(self,w,b):
+        x,y = self.data[:, 0],self.data[:, 1]
+        loss = 0
+        for i in range(self.data.shape[0]):
+            loss += (w*x[i]+b-y[i])**2
+        print(f"loss {loss}")
+        return loss/float(self.data.shape[0])
+    def grad(self,w,b,x,y):
+        x_grad,y_grad = 2*(w*x+b-y)*x,2*(w*x+b-y)
+        return x_grad,y_grad
+    def step_grad(self,w,b):
+        x, y = self.data[:, 0], self.data[:, 1]
+        w_gradient = 0
+        b_gradient = 0
+        for i in range(self.data.shape[0]):
+            w_tmp,b_tmp = self.grad(w,b,x[i],y[i])
+            w_gradient += w_tmp
+            b_gradient += b_tmp
+        w_new = w - w_gradient/self.data.shape[0]*self.lr
+        b_new = b - b_gradient /self.data.shape[0] * self.lr
+        return w_new,b_new
+
+    def gradientDescent(self):
+        # history = np.empty( (self.nstep+1, 2) )
+        error = np.zeros(self.nstep)
+        w,b = self.w,self.b
+        for i in range(self.nstep):
+            w,b = self.step_grad(w, b)
+            error[i]=self.loss(w,b)
+        return w,b,error
+w = 12
+b =12
+income = pd.read_csv(r'Salary_Data.csv')
+data = np.array(income.values)
+nstep = 1000
+lr = 0.001
+gd = GD(data,w,b,lr,nstep)
+w,b,error = gd.gradientDescent()
+print("w,b is :",w,b)
+x = data[:,0]
+y = data[:,1]
+plt.scatter(x,y)
+# plt.legend()
+plt.plot(x, w*x+b, 'r')
+plt.show()
+
+plt.plot(np.arange(nstep), error, 'r')
+plt.show()
+# 回归参数  11768.548124439758 10167.865862562581

梯度下降/梯度下降解决面积问题 tensor.py

@@ -0,0 +1,25 @@
+import  numpy as np
+import math
+from    matplotlib import pyplot as plt
+import  torch
+
+def f(r):
+    g = torch.tan(r)+9*torch.tan(3/4*math.pi-r)
+    return g
+def drawfig(f):
+
+    x = torch.linspace(1.1/4*math.pi,0.99/2*math.pi,100)
+    y = f(x)
+    plt.plot(x,y)
+    plt.show()
+
+r = torch.tensor([1.16/4*np.pi], requires_grad=True)
+optimizer = torch.optim.Adam([r], lr=1e-4)
+for step in range(10000):
+    pred = f(r)
+    optimizer.zero_grad()
+    pred.backward()
+    optimizer.step()
+    if step % 200 == 0:
+        print (f'step {step}: r = {r.tolist()}, f(r) = {pred.item()}')
+drawfig(f)

梯度下降/梯度下降解决面积问题.py

@@ -0,0 +1,39 @@
+import math
+import numpy as np
+import matplotlib.pyplot as plt
+
+def f(r):
+    g = np.tan(r)+9*np.tan(3/4*np.pi-r)
+    return g
+
+def drawfig(f):
+
+    x = np.linspace(1.1/4*np.pi,0.99/2*np.pi,100)
+    y = f(x)
+    # print(y)
+    plt.plot(x,y)
+    plt.show()
+
+def grad(r):
+    g = 1.0/(np.cos(r)**2) - 9.0/(np.cos(3/4*np.pi-r)**2)
+    return g
+
+def gradientDescent(f,r0, eta, nstep):
+    r_history = np.zeros(nstep+1)
+    f_history = np.zeros(nstep+1)
+    r_history[0] = r0
+    f_history[0] = f(r0)
+    r = r0
+    for i in range(1,nstep+1):
+        r = r - eta * grad(r)
+        r_history[i] = r
+        f_history[i] = f(r)
+        print(f"r is :{r}   f(r) is {f(r)}")
+    return r_history,f_history
+# print(f(1/3*np.pi))
+drawfig(f)
+x,y = gradientDescent(f, 1.12/4*np.pi, 0.0001*np.pi, 10000)
+plt.plot(x,y)
+plt.show()
+
+