精华内容
下载资源
问答
  • Python中的NumPy是什么?NumPy或NumericPython是用于科学计算的通用数组处理python软件包。它包含许多强大的功能,其中包括:具有许多有用功能的健壮的多维数组对象。用于将其他编程语言与大量例程集成在一起的许多...

    Python中的NumPy是什么?NumPy或NumericPython是用于科学计算的通用数组处理python软件包。它包含许多强大的功能,其中包括:具有许多有用功能的健壮的多维数组对象。用于将其他编程语言与大量例程集成在一起的许多工具,包括形状处理,逻辑,数学等,以及可用于对NumPyArray对象进行操作的更多工具。除了其明显的科学用途外,NumPy还被用作通用的多维数据容器。NumPy还可以集成各种数据库。

    NumPy是常规版本,带有最新版本的Anaconda(可从https://www.anaconda.com/distribution/#download-section下载,适用于Windows,Mac和Linux)

    如果万一它不可用,您可以随时使用以下命令在AnacondaPowershell提示符中下载并安装它。python-mpipinstallnumpy,运行上面的命令后,您应该看到命令行输出为“SuccessfulInstalled”。NumPy是Python中使用最广泛的软件包之一,它使您可以利用数据集中的现有列创建许多派生列。

    二.Python中NumPy的示例

    让我们讨论更多示例,以及如何使用NumPy实现相同的示例:第一步是在代码中导入包:将NumPy导入为np,点击“Shift+Enter”导入指定的包,NumPy的别名为“np”,可用于将NumPy引用为任何其他参考。

    u9991622393334028165fm26gp0.jpg

    三.NumPy数组的算术运算

    1.减法

    NumPy数组减法运算遵循下面提到的常用数学语法。如果我们想从数组“x”中减去数组“y”,则其写为:Result=x-y。使用print(Result)打印结果数组“Result”

    2.加法

    NumPy数组加法运算也遵循与前面讨论的减法类似的数学语法。如果我们想将数组“y”添加到“x”,则其写为:Result=x+y,使用print(Result)打印结果数组“Result”

    3.乘法

    如果我们想将数组“x”与“y”相乘,则将其写为:Result=x*y。使用print(Result)打印结果数组“Result”

    4.布尔索引

    它使我们能够基于逻辑条件为NumPy数组建立索引。例如,返回数组中小于2的所有值。a=np.array([4,1,9])相同的将被实现为:a[a<2]逻辑索引的输出将是数组“a”内小于2的任何值,因此结果将是[1]。

    NumPy是python中一个功能强大的库,在数据解释分析(以更好地理解数据),数据操作和清理中被广泛使用。创建KPI指标等等。

    展开全文
  • Python有什么

    2021-05-31 14:51:00
    <p>Python 是一种广泛使用...如 EVE Online 使用 Python 来处理游戏繁多的逻辑。 <p>YouTube、Google、Yahoo!、NASA 都在内部大量地使用 Python。OLPC 的作业系统 Sugar 项目的大多数软件都是使用 Python 编写。</p>
  •  在刚刚结束天猫大数据s1比赛逻辑回归是大家都普遍使用且效果不错一种算法。   (1)回归    先来说说什么是回归,比如说我们两类数据,各50十个点组成,当我门把这些点画出来,会一条线区分...

    1.背景知识

          在刚刚结束的天猫大数据s1比赛中,逻辑回归是大家都普遍使用且效果不错的一种算法。
     

    (1)回归     

         
        先来说说什么是回归,比如说我们有两类数据,各有50十个点组成,当我门把这些点画出来,会有一条线区分这两组数据,我们拟合出这个曲线(因为很有可能是非线性),就是回归。我们通过大量的数据找出这条线,并拟合出这条线的表达式,再有数据,我们就以这条线为区分来实现分类。下图是我画的一个数据集的两组数据,中间有一条区分两组数据的线。


       (2)sigmoid函数

             我们看到了上图中两组数据的划分,那么我们怎么来找出两组数据的边界表达式呢,这里用到sigmoid函数。它的形状大致是(如下),公式

    把数据集的特征值设为x1,x2,x3......。我们要求出它们的回归系数。只要设z=w1*x1+w2*x2.....用sigmoid函数出理是防止数据从0到1发生跳变,因为目标函数是0到1,我们要把带入x1,x2...多项式数据控制在这之间。

     (3)梯度上升算法

       梯度上升是指找到函数增长的方向。公式。在具体实现的过程中,不停地迭代运算直到w的值几乎不再变化为止。

    2.代码

       数据集在工程中有。

    导入数据集,并定义sigmoid函数
    1. def loadDataSet():  
    2.     dataMat = []; labelMat = []  
    3.     fr = open('/Users/hakuri/Desktop/testSet.txt')  
    4.     for line in fr.readlines():  
    5.         lineArr = line.strip().split()  
    6.         dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])  
    7.         labelMat.append(int(lineArr[2]))  
    8.     return dataMat,labelMat  
    9.   
    10. def sigmoid(inX):  
    11.     return 1.0/(1+exp(-inX))  
    def loadDataSet():
        dataMat = []; labelMat = []
        fr = open('/Users/hakuri/Desktop/testSet.txt')
        for line in fr.readlines():
            lineArr = line.strip().split()
            dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
            labelMat.append(int(lineArr[2]))
        return dataMat,labelMat
    
    def sigmoid(inX):
        return 1.0/(1+exp(-inX))


    返回回归系数,对应于每个特征值,for循环实现了递归梯度上升算法。
    1. def gradAscent(dataMatIn, classLabels):  
    2.     dataMatrix = mat(dataMatIn)             #convert to NumPy matrix  
    3.     labelMat = mat(classLabels).transpose() #convert to NumPy matrix  
    4.       
    5.     m,n = shape(dataMatrix)  
    6.     alpha = 0.001  
    7.     maxCycles = 500  
    8.     weights = ones((n,1))  
    9.       
    10.     for k in range(maxCycles):              #heavy on matrix operations  
    11.         h = sigmoid(dataMatrix*weights)     #matrix mult  
    12.         error = (labelMat - h)              #vector subtraction  
    13.         weights = weights + alpha * dataMatrix.transpose()* error #matrix mult  
    14.     return weights  
    def gradAscent(dataMatIn, classLabels):
        dataMatrix = mat(dataMatIn)             #convert to NumPy matrix
        labelMat = mat(classLabels).transpose() #convert to NumPy matrix
        
        m,n = shape(dataMatrix)
        alpha = 0.001
        maxCycles = 500
        weights = ones((n,1))
        
        for k in range(maxCycles):              #heavy on matrix operations
            h = sigmoid(dataMatrix*weights)     #matrix mult
            error = (labelMat - h)              #vector subtraction
            weights = weights + alpha * dataMatrix.transpose()* error #matrix mult
        return weights
    


    结果,返回了特征值的回归系数。我们的数据集有两个特征值分别是x1,x2。我们又增设了了x0变量。得到的结果

    [[ 4.12414349]

     [ 0.48007329]

     [-0.6168482 ]]

    我们得出x1和x2的关系(设x0=1),0=4.12414349+0.48007329*x1-0.6168482*x2


    画出x1与x2的关系图



    3.代码

     
    下载地址(Logical Regression)


      从这节算是开始进入“正规”的机器学习了吧,之所以“正规”因为它开始要建立代价函数(cost function),接着优化价值函数求出权重,然后测试验证。这整套的流程是机器学习必经环节。今天要学习的话题是逻辑回归,逻辑回归也是一种有监督学习方法(supervised machine learning)。逻辑回归一般用来做预测,也可以用来做分类,预测是某个类别^.^!线性回归想比大家都不陌生了,y=kx+b,给定一堆数据点,拟合出k和b的值就行了,下次给定X时,就可以计算出y,这就是回归。而逻辑回归跟这个有点区别,它是一种非线性函数,拟合功能颇为强大,而且它是连续函数,可以对其求导,这点很重要,如果一个函数不可求导,那它在机器学习用起来很麻烦,早期的海维赛德(Heaviside)阶梯函数就因此被sigmoid函数取代,因为可导意味着我们可以很快找到其极值点,这就是优化方法的重要思想之一:利用求导,得到梯度,然后用梯度下降法更新参数。

            下面来看看逻辑回归的sigmoid函数,如(图一)所示:


    (图一)

                (图一)中上图是sigmoid函数在定义域[-5,5] 上的形状,而下图是在定义域[-60,60]上的形状,由这两个图可以看出,它比较适合做二类的回归,因为严重两级分化。Sigmoid函数的如(公式一)所示:

    (公式一)

             现在有了二类回归函数模型,就可以把特征映射到这个模型上了,而且sigmoid函数的自变量只有一个Z,假设我们的特征为X=[x0,x1,x2…xn]。令

    ,当给定大批的训练样本特征X时,我们只要找到合适的W=[w0,w1,w2…wn]来正确的把每个样本特征X映射到sigmoid函数的两级上,也就是说正确的完成了类别回归就行了,那么以后来个测试样本,只要和权重相乘后,带入sigmoid函数计算出的值就是预测值啦,很简单是吧。那怎么求权重W呢?

              要计算W,就要进入优化求解阶段咯,用的方法是梯度下降法或者随机梯度下降法。说到梯度下降,梯度下降一般对什么求梯度呢?梯度是一个函数上升最快的方向,沿着梯度方向我们可以很快找到极值点。我们找什么极值?仔细想想,当然是找训练模型的误差极值,当模型预测值和训练样本给出的正确值之间的误差和最小时,模型参数就是我们要求的。当然误差最小有可能导致过拟合,这个以后再说。我们先建立模型训练误差价值函数(cost function),如(公式二)所示:

    (公式二)

            (公式二)中Y表示训练样本真实值,当J(theta)最小时的所得的theta就是我们要求的模型权重,可以看出J(theta)是个凸函数,得到的最小值也是全局最小。对其求导后得出梯度,如(公式三)所示:

    (公式三)

            由于我们是找极小值,而梯度方向是极大值方向,因此我们取负号,沿着负梯度方向更新参数,如(公式四)所示:

    (公式四)

            按照(公式四)的参数更新方法,当权重不再变化时,我们就宣称找到了极值点,此时的权重也是我们要求的,整个参数更新示意图如(图二)所示:

    (图二)

            原来到此为止逻辑回归基本就说完了,下面进入代码实战阶段:


    [python] view plaincopy
    1. from numpy import *  
    2.   
    3. def loadDataSet():  
    4.     dataMat = []; labelMat = []  #tuple ,list
    5.     fr = open('testSet.txt')  
    6.     for line in fr.readlines():  
    7.         lineArr = line.strip().split()   #strip split default space
    8.         dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])  #type_cast
    9.         labelMat.append(int(lineArr[2]))  
    10.     return dataMat,labelMat  
    11.   
    12. def sigmoid(inX):  
    13.     return 1.0/(1+exp(-inX))  

    上面两个函数分别是加载训练集和定义sigmoid函数,都比较简单。下面发出梯度下降的代码:

    [python] view plaincopy
    1. def gradAscent(dataMatIn, classLabels):  
    2.     dataMatrix = mat(dataMatIn)             #convert to NumPy matrix  
    3.     labelMat = mat(classLabels).transpose() #convert to NumPy matrix  
    4.     m,n = shape(dataMatrix)   #matlab size 
    5.     alpha = 0.001  
    6.     maxCycles = 500  
    7.     weights = ones((n,1))  
    8.     for k in range(maxCycles):              #heavy on matrix operations  
    9.         h = sigmoid(dataMatrix*weights)     #matrix mult  
    10.         error = (labelMat - h)              #vector subtraction  
    11.         weights = weights + alpha * dataMatrix.transpose()* error #matrix mult  
    12.     return weights  

             梯度下降输入训练集和对应标签,接着就是迭代跟新参数,计算梯度,然后更新参数,注意倒数第二句就是按照(公式三)和(公式四)来更新参数。

    为了直观的看到我们得到的权重是否正确的,我们把权重和样本打印出来,下面是相关打印代码:

    [python] view plaincopy
    1. def plotBestFit(weights):  
    2.     import matplotlib.pyplot as plt  
    3.     dataMat,labelMat=loadDataSet()  
    4.     dataArr = array(dataMat)  
    5.     n = shape(dataArr)[0]   
    6.     xcord1 = []; ycord1 = []  
    7.     xcord2 = []; ycord2 = []  
    8.     for i in range(n):  
    9.         if int(labelMat[i])== 1:  
    10.             xcord1.append(dataArr[i,1]); ycord1.append(dataArr[i,2])  
    11.         else:  
    12.             xcord2.append(dataArr[i,1]); ycord2.append(dataArr[i,2])  
    13.     fig = plt.figure()  
    14.     ax = fig.add_subplot(111)  
    15.     ax.scatter(xcord1, ycord1, s=30, c='red', marker='s')  
    16.     ax.scatter(xcord2, ycord2, s=30, c='green')  
    17.     x = arange(-3.03.00.1)  
    18.     y = (-weights[0]-weights[1]*x)/weights[2]  
    19.     ax.plot(x, y)  
    20.     plt.xlabel('X1'); plt.ylabel('X2');  
    21.     plt.show()  

    打印的效果图如(图三)所示:

    (图三)

           可以看出效果蛮不错的,小错误是难免的,如果训练集没有错误反而危险,说到这基本就说完了,但是考虑到这个方法对少量样本(几百的)还行,在实际中当遇到10亿数量级时,而且特征维数上千时,这种方法很恐怖,光计算梯度就要消耗大量时间,因此要使用随机梯度下降方法。随机梯度下降算法和梯度下降算法原理一样,只是计算梯度不再使用所有样本,而是使用一个或者一小批来计算梯度,这样可以减少计算代价,虽然权重跟新的路径和曲折,但最终也会收敛的,如(图四)所示


    (图四)

           下面也发出随机梯度下降的代码:

    [python] view plaincopy
    1. def stocGradAscent1(dataMatrix, classLabels, numIter=150):  
    2.     m,n = shape(dataMatrix)  
    3.     weights = ones(n)   #initialize to all ones  
    4.     for j in range(numIter):  
    5.         dataIndex = range(m)  
    6.         for i in range(m):  
    7.             alpha = 4/(1.0+j+i)+0.0001    #apha decreases with iteration, does not   
    8.             randIndex = int(random.uniform(0,len(dataIndex)))#go to 0 because of the constant  
    9.             h = sigmoid(sum(dataMatrix[randIndex]*weights))  
    10.             error = classLabels[randIndex] - h  
    11.             weights = weights + alpha * error * dataMatrix[randIndex]  
    12.             del(dataIndex[randIndex])  
    13.     return weights  

           最后也给出一个分类的代码,只要把阈值设为0.5,大于0.5划为一类,小于0.5划为另一类就行了,代码如下:

    [python] view plaincopy
    1. def classifyVector(inX, weights):  
    2.     prob = sigmoid(sum(inX*weights))  
    3.     if prob > 0.5return 1.0  
    4.     elsereturn 0.0  

    总结:

            优点:计算量不高,容易实现,对现实数据也很容易描述

            缺点:很容易欠拟合,精度可能也会不高

    参考文献:

        [1] machine learning in action. Peter Harrington

        [2] machine learning.Andrew Ng


    展开全文
  • Python中的模块

    2017-01-21 11:14:00
    本文参考《Ptyhon核心编程》 ...类似C#中的命名空间的概念(个人觉得)。 2、模块和文件 模块是按照逻辑来组织Python代码的方法,那么文件边便是物理层上组织模块的方法,因此,一个模块也可以...

    本文参考《Ptyhon核心编程》

    1、什么是模块

    模块支持从逻辑上组织Python代码。当代码量变得相当大的时候,最好把代码分成一些有组织的代码段,前提是保证它们的彼此交互。那些自我包含并且有组织的代码片段就是模块(module)。
    类似C#中的命名空间的概念(个人觉得)
    425900-20170118143318796-1110418162.png

    2、模块和文件

    模块是按照逻辑来组织Python代码的方法,那么文件边便是物理层上组织模块的方法,因此,一个模块也可以被看作一个文件。模块的文件名就是模块的名字加上扩展名.py。

    1.模块的名称空间
    425900-20170118143945765-652265424.png

    3、名称空间

    名称空间是名称到对象的映射。分三个活动的名称空间:
    1.局部名称空间
    2.全局名称空间
    3.内建名称空间

    425900-20170118145137406-1781670876.png

    4、导入模块

    1.import语句

    import语法:
    *多行
    *import module1*
    .
    .
    .
    *import module2*
    *行内导入
    *import module1[,moduel2,......moduleN]*

    425900-20170118150538265-462200638.png

    2.from-import语句
    你可以在你的模块中导入指定模块属性,使用form-import语句可以实现我们的目的,它的语法

    from module import name1[,name2,....nameN]
    

    3.扩展的import语句(as)

    如果你导入的模块或者属性已经存在你的程序中,就是使用AS语法给他取别名。

    import longmodulename
    short=longmodulename
    
    import longmodulename as short
    

    5、模块内建函数

    Python1.5加入的__import__()函数,就是类似import关键字用法。
    425900-20170118151112140-539155790.png

    转载于:https://www.cnblogs.com/wxc-kingsley/p/6296611.html

    展开全文
  • 但考虑到该任务每日日志较大,为以后有什么问题方便排查,便到网上查找python按天分割日志记录方法,发现python自带一个TimedRotatingFileHandler,便按照网上代码例子把日志给配到了自己项目。 相关链接...

          日前公司需要用到python做一个后台的自动任务。以前使用python写日志都是写入同一个文件里头。但考虑到该任务每日日志量较大,为以后有什么问题方便排查,便到网上查找python按天分割的日志记录方法,发现python自带一个TimedRotatingFileHandler,便按照网上的代码例子把日志给配到了自己的项目中。

            相关链接:https://blog.csdn.net/energysober/article/details/53263295

        TimedRotatingFileHandler类的重点就在于log_file_handler = TimedRotatingFileHandler(filename=LOG_PATH+"thread_", when="D", interval=1, backupCount=7)这个初始化方法。filename是日志名,when是间隔时间单位,interval是间隔时间数值,backupCount是要保留几个分割后的日志文件。

        我当时想要配的是每天的日志都分开来打吧,于是便设置了when="D",interval=1。从字面上来看也是没问题了。但是自测的时候把间隔调成了秒,方便调试嘛。调试也没什么问题,每隔两三秒运行一次打印日志,日志信息都会打印到最新的日志文件中,而以前的日志信息会按照设定好的命名格式放在另一个日志文件中。

         于是我就把这个项目开发自测好后,就上测试环境了。测试人员测了两三天,发现日志根本就没有滚动呀。我去看了也是一头雾水。于是点进去TimedRotatingFileHandler看了源码,看了里面的时间计算逻辑才恍然大悟为什么测试环境无法分割的原因。附上init方法

    def __init__(self, filename, when='h', interval=1, backupCount=0, encoding=None, delay=False, utc=False, atTime=None):
        BaseRotatingHandler.__init__(self, filename, 'a', encoding, delay)
        self.when = when.upper()
        self.backupCount = backupCount
        self.utc = utc
        self.atTime = atTime
        # Calculate the real rollover interval, which is just the number of
        # seconds between rollovers.  Also set the filename suffix used when
        # a rollover occurs.  Current 'when' events supported:
        # S - Seconds
        # M - Minutes
        # H - Hours
        # D - Days
        # midnight - roll over at midnight
        # W{0-6} - roll over on a certain day; 0 - Monday
        #
        # Case of the 'when' specifier is not important; lower or upper case
        # will work.
        if self.when == 'S':
            self.interval = 1 # one second
            self.suffix = "%Y-%m-%d_%H-%M-%S"
            self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}(\.\w+)?$"
        elif self.when == 'M':
            self.interval = 60 # one minute
            self.suffix = "%Y-%m-%d_%H-%M"
            self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}(\.\w+)?$"
        elif self.when == 'H':
            self.interval = 60 * 60 # one hour
            self.suffix = "%Y-%m-%d_%H"
            self.extMatch = r"^\d{4}-\d{2}-\d{2}_\d{2}(\.\w+)?$"
        elif self.when == 'D' or self.when == 'MIDNIGHT':
            self.interval = 60 * 60 * 24 # one day
            self.suffix = "%Y-%m-%d"
            self.extMatch = r"^\d{4}-\d{2}-\d{2}(\.\w+)?$"
        elif self.when.startswith('W'):
            self.interval = 60 * 60 * 24 * 7 # one week
            if len(self.when) != 2:
                raise ValueError("You must specify a day for weekly rollover from 0 to 6 (0 is Monday): %s" % self.when)
            if self.when[1] < '0' or self.when[1] > '6':
                raise ValueError("Invalid day specified for weekly rollover: %s" % self.when)
            self.dayOfWeek = int(self.when[1])
            self.suffix = "%Y-%m-%d"
            self.extMatch = r"^\d{4}-\d{2}-\d{2}(\.\w+)?$"
        else:
            raise ValueError("Invalid rollover interval specified: %s" % self.when)
    
        self.extMatch = re.compile(self.extMatch, re.ASCII)
        self.interval = self.interval * interval # multiply by units requested
        if os.path.exists(filename):
            t = os.stat(filename)[ST_MTIME]
        else:
            t = int(time.time())
        self.rolloverAt = self.computeRollover(t)

         它在初始化时会计算出什么时候日志文件需要进行分割。实例变量self.rolloverAt便存放着下次分割的时间。而判断是否需要把日志分割开来的逻辑,居然是根据当前文件的修改时间或当前时间戳来的。每次初始化这个类,这个时间就会重新算一次。这就是在测试环境两三天都无法进分割日志的原因!!!因为测试环境经常需要发布版本,而这个类经常被重新初始化,然后就会重新计算24小时才会进行日志分割。附上它计算什么时候分割日志的时间点的代码

        def computeRollover(self, currentTime):
            """
            Work out the rollover time based on the specified time.
            """
            result = currentTime + self.interval
            # If we are rolling over at midnight or weekly, then the interval is already known.
            # What we need to figure out is WHEN the next interval is.  In other words,
            # if you are rolling over at midnight, then your base interval is 1 day,
            # but you want to start that one day clock at midnight, not now.  So, we
            # have to fudge the rolloverAt value in order to trigger the first rollover
            # at the right time.  After that, the regular interval will take care of
            # the rest.  Note that this code doesn't care about leap seconds. :)
            if self.when == 'MIDNIGHT' or self.when.startswith('W'):
                # This could be done with less code, but I wanted it to be clear
                if self.utc:
                    t = time.gmtime(currentTime)
                else:
                    t = time.localtime(currentTime)
                currentHour = t[3]
                currentMinute = t[4]
                currentSecond = t[5]
                currentDay = t[6]
                # r is the number of seconds left between now and the next rotation
                if self.atTime is None:
                    rotate_ts = _MIDNIGHT
                else:
                    rotate_ts = ((self.atTime.hour * 60 + self.atTime.minute)*60 +
                        self.atTime.second)
    
                r = rotate_ts - ((currentHour * 60 + currentMinute) * 60 +
                    currentSecond)
                if r < 0:
                    # Rotate time is before the current time (for example when
                    # self.rotateAt is 13:45 and it now 14:15), rotation is
                    # tomorrow.
                    r += _MIDNIGHT
                    currentDay = (currentDay + 1) % 7
                result = currentTime + r
                # If we are rolling over on a certain day, add in the number of days until
                # the next rollover, but offset by 1 since we just calculated the time
                # until the next day starts.  There are three cases:
                # Case 1) The day to rollover is today; in this case, do nothing
                # Case 2) The day to rollover is further in the interval (i.e., today is
                #         day 2 (Wednesday) and rollover is on day 6 (Sunday).  Days to
                #         next rollover is simply 6 - 2 - 1, or 3.
                # Case 3) The day to rollover is behind us in the interval (i.e., today
                #         is day 5 (Saturday) and rollover is on day 3 (Thursday).
                #         Days to rollover is 6 - 5 + 3, or 4.  In this case, it's the
                #         number of days left in the current week (1) plus the number
                #         of days in the next week until the rollover day (3).
                # The calculations described in 2) and 3) above need to have a day added.
                # This is because the above time calculation takes us to midnight on this
                # day, i.e. the start of the next day.
                if self.when.startswith('W'):
                    day = currentDay # 0 is Monday
                    if day != self.dayOfWeek:
                        if day < self.dayOfWeek:
                            daysToWait = self.dayOfWeek - day
                        else:
                            daysToWait = 6 - day + self.dayOfWeek + 1
                        newRolloverAt = result + (daysToWait * (60 * 60 * 24))
                        if not self.utc:
                            dstNow = t[-1]
                            dstAtRollover = time.localtime(newRolloverAt)[-1]
                            if dstNow != dstAtRollover:
                                if not dstNow:  # DST kicks in before next rollover, so we need to deduct an hour
                                    addend = -3600
                                else:           # DST bows out before next rollover, so we need to add an hour
                                    addend = 3600
                                newRolloverAt += addend
                        result = newRolloverAt
            return result

         如果项目是持续运行的,这个类只初始化一次,那这个日志分割还是可以达到目的的。而且里面还设计有按年,按月分割的,一年内项目不重启不升级,说实话概率还是蛮低的,一重启这个时间就会重新算,然后日志分割时间就会推迟了。阅读源码后看到它有一个按midnight分割日期的功能。就是它会在计算当前时间到凌晨零点的秒数,然后每次写日志时都会判断过没过凌晨,到了后就会自动分割日志。这个功能还蛮符合我需求的。

           但这次我自己在开发环境自测了下,先自己打印一条日志。然后把系统时间(调整时区)调为第二天的时间,再一次打印日志,发现日志还在一起,并没有分割。怎么回事? 看了下源码,发现代码里是根据time.time()返回一个当前时间戳来判断是否过凌晨的,不管系统时间如何调整,程序返回的时间戳都是一秒一秒加的。所以如果想要真的分割一次日志,还真得跨越一次凌晨才行。附上判断是否需要分割的源代码:

        def shouldRollover(self, record):
            """
            Determine if rollover should occur.
    
            record is not used, as we are just comparing times, but it is needed so
            the method signatures are the same
            """
            t = int(time.time())
            if t >= self.rolloverAt:
                return 1
            return 0

     

    展开全文
  • Python函数

    2017-07-26 10:47:33
    把 重复代码放到函数而不是进行大量拷贝-------这样既能节省空间,也助于保持一致性,因为你只需改变单个拷贝而无需去寻找再修改大量复制代码拷贝。 函数可以以不同形式出现。下面简单展示了一些创建,...
  • 什么是混合应用? 混合应用程序是本地移动应用程序和Web应用程序的组合。...这使您可以专注于程序的逻辑而不是连接等其他事项。 Selenium Selenium是最受欢迎和广泛使用的Web应用程序自动化测试工.
  • Python 2.5

    2007-05-28 12:33:42
    一个比较流行办法是在Python中原型一个程序,直到你相信设计是正确再换到C++,一个更好办法是将Python应用程序轮廓化,然后在C++重写速度至关重要部分。 <br/> <br/>一个调试工具 <br/>新...
  • 8、使用scikit-learn库中的逻辑回归模型实现 逻辑回归_手写数字识别_OneVsAll 1、随机显示100个数字 2、OneVsAll 3、手写数字识别 4、预测 5、运行结果 6、使用scikit-learn库中的逻辑回归模型实现 三、BP...
  • 在遍历集合时,从逻辑上来说使用iteration与list并没有什么区别,但是当集合数据比较大时候,两者还是区别。 list是以数组形式存储数据,需要在内存分配一块连续空间,所以当集合数据比较大...
  • 玩转Python图像处理

    千人学习 2020-06-12 16:58:51
    【课程简介】 本课程基于面向Python的OpenCV,以OpenCV官方文档知识脉络为主线,介绍了OpenCV函数具体使用方法、函数所使用算法具体原理。 在介绍函数使用时,提供了大量程序案例演示。 在介绍具体原理...
  • Python入门经典(2K超清)

    千人学习 2020-09-21 14:23:43
    让初学者彻底明白python到底可用于什么领域,学了有什么好处。本课程既适合初学者夯实基础,又能帮助Python程序员提升技能,即使是高级Python程序员,也能从书里找到耳目一新内容。课程第一章介绍python官网,...
  • Python函数基础

    2021-02-19 11:13:13
    函数基础: 1、什么是函数: (1)函数是对程序逻辑进行结构化或者过程化的一种编程方法 (2) 将整块代码巧妙的隔离成易于管理的小块 ...(6)要想函数中的代码执行,需要通过函数名加一对小括号进行调用 def cr
  • Python变量与常量

    2020-07-29 22:20:34
    变量就是可以变化的量是一个事物量的大小,比如人年龄,性别,游戏内角色等级,属性等等。 2.2 为什么变量 为了让计算机可以标记识别某种事物状态,并且这种状态是可变化。详细说,程序执行...
  • #为什么我们需要python中的promise? 并发编程,每个程序员迟早都必须这样做。 如果运行的服务器为多个客户端提供服务,或者进行了大量的科学计算,则无法逃避它们。当前两种解决方法:同步和异步编程。 ##同步...
  • 17.1 为什么要调试 代码本身问题,需要我们找到 root cause 并修复 ...但是对于大型程序,怀疑出错地方可能很多,就可能代码需要写大量print函数。调试完毕后,还要再删除掉。显然比较麻烦。 17.2.2 Pycharm断
  • 什么是函数函数式对程序逻辑进行结构化或者过程化一种编程方法。能将整块代码巧妙地隔离成易于管理小块,把重复代码放到函数而不是进行大量拷贝——这样既节省空间,也助于保持一致性,因为你只需改变单个...
  • 现存代码很多,不过如果你从质上无法接受代码中的逻辑关系,恐怕也很难接受代码跑出来的比例结果,本文先从质上提供了几种思路详细阐述了为什么换的概率是大的,继而给出代码验证上比例关系。 对于初次想这个...
  • Python - 100天从新手到大师 作者:骆昊 说明:从项目上线到获得8w+星标以来,一直收到反馈说基础部分(前15天的内容)对新手来说是比较困难的,建议配套视频进行讲解。...Python中的单元测试 Django框架...
  • 本章节主要讲python中的判断逻辑、循环逻辑、异常处理、时间操作、文件操作和基本的系统操作函数。 2. 系统包导入 为什么要先介绍这个呢,因为后面可能很多地方会用到这个,所这里先介绍系统包的概念,举个例子...
  • 尹成Python27天入门到项目实战

    千人学习 2020-12-05 17:04:22
    业day19up 深度遍历与广度遍历正则表达式小结最简单递归递归顺序递归求和递归腾讯台阶面试题文件夹函数遍历文件夹遍历文件夹层次感栈模拟递归栈模拟递归遍历文件夹栈模拟递归遍历文件夹层次感普及网站提取概念栈...
  • python软件开发规范

    2019-10-08 10:52:40
    设计项目目录结构,就和编码风格一样,是每个程序员都有的风格,但是在流水化标准化作业过程,个性和风格是 不被鼓励。如果你去维护一个非常不好读项目,虽然实现逻辑并不复杂,但是对后续维护者来说...
  • 一、简介 Python中的函数具有预期特性,还支持多种调用方式以及参数类型并实现了一些函数式编程接口。Python函数中变量的作用域和递归函数都是必须理解的内容。二、详解1、什么是函数 函数是对程序逻辑进行结构化...
  • 它还显示了FFT在机器振动数据特征工程中的帮助。 这个怎么运作 从最基本的(FFT)到最复杂的(高斯混合模型),几种方法不需要训练神经网络就能检测到故障。 它们的优点是可以在不同的数据流上进行较小的修改就...
  • 模块支持从逻辑上组织Python代码,当代码时候,就把代码分成一些组织代码段,但是要保证它们彼此交互。代码片段一定联系,可能是一个包含数据成员和方法类,也可能是一组相关彼此独立操作函数。...

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 258
精华内容 103
关键字:

python中的逻辑量有什么

python 订阅