精华内容
下载资源
问答
  • 近日,Python 官网再次发文,提醒将于 2020 年 1 月 1 日正式对 Python 2 停止支持,未升级到 Python 3 的童鞋,应当尽快做好迁移。 官网通告,摘翻如下: 我们是开发和维护 Python 编程语言的志愿者。我们已经...
  • Python3.8已经发布近一个月了,距离Python3.0第一个版本发布也将超过10年了。相信很多人还是依旧在使用Python2.7版本,想要迁移到最新版本却不知道怎么能够快速掌握其中最Amazing的方法。 下面这篇文章,我会给大家...

    作者 | 云爬虫技术研究笔记

    责编 | 郭芮

    出品 | CSDN 博客

    Python3.8已经发布近一个月了,距离Python3.0第一个版本发布也将超过10年了。相信很多人还是依旧在使用Python2.7版本,想要迁移到最新版本却不知道怎么能够快速掌握其中最Amazing的方法。

    下面这篇文章,我会给大家推荐3.0版本依赖最最新潮的函数和语法,让你们能够在Review代码时候“脱颖而出”!

    前言

    首先我们先来讲几个时间点:

    • Python2.7正式停止维护时间 2020年1月1日,距今还有1个多月

    • Python3.8正式开始发布时间 2019年10月14日,距今1个多月

    从这两个数字我们可以看出,Python3这个大版本已经发展很长的时间了,而距离Python2.7的结束也越来越近了。在距离Python2.7停止维护的一年内,很多优秀开源项目都已经停止了对 2.7 的支持,例如到今年 1 月份,NumPy 将停止支持 Python 2;到今年年末,Ipython、Cython 和 Pandas 等等都将陆续停止支持 Python 2。

    所以,为了响应号召,顺应趋势。我们慢慢的向Python3.X去迁移,那我们如何能够快速的掌握Python3.X版本的精髓呢?下面我们从几个有趣的新特性入手,这些特性或方法都是 Python 3 各个版本中新加的,它们相比传统的 Python 方法,更容易解决实践中的一些问题。

    所有的示例都是在 Python 3.7 的环境下编写的,每个特性示例都给出了其正常工作所需的最低的 Python 版本。

    潮流特性

    • 格式化字符串 f-string(最低 Python 版本为 3.6)

    “如何格式化字符串”这个话题我想是每个开发者在接触一门新语言的时候都会去学习的语法,而在Python中格式化语法的方式大家通常都会偏向于【Format】或者 【%S】这两种方法,操作如下:

    print("My name is %s" % ('phithon', ))
    print("My name is %(name)s" % {'name':'phithon'})
    print("My name is {}".format("bob"))
    print("My name is {name}".format(name="bob"))

    而到了Python3.6版本,推出了新的格式化字符串的灵活方法【f-string】,使用【f-string】编写的与上面功能相同的代码是这样的:

    name="bob"
    print(f"My name is {name}")

    我们对比这几种格式化字符串的方法,可以发现相比于常见的字符串格式符【%S】 或 【Format】 方法,【f-string】 直接在占位符中插入变量显得更加方便,也更好理解,关于格式化速度方面可以参考这个博文(https://stackoverflow.com/questions/56587807/why-are-f-strings-faster-than-str-to-parse-values)看看详细的解释。

    • 路径管理库 Pathlib(最低 Python 版本为 3.4)

    从上个特性可以看出【f-string】 确实非常强大和美观,而在文件路径方面,Python遵循了他们的开发理念:万物皆是对象,所以他们把路径也单拎出来搞了一个路径对象库,也就是一个处理文件路径的抽象库【pathlib】。如果你不知道为什么应该使用 【pathlib】,请参阅下面这篇 Trey Hunner 编写的炒鸡棒的博文(https://treyhunner.com/2018/12/why-you-should-be-using-pathlib/)以及它的后续版本。

    下面我们对比同一案例的新旧两个版本Python的实现:

    from glob import glob
    
    
    file_contents = []
    for filename in glob('**/*.py', recursive=True):
        with open(filename) as python_file:
            file_contents.append(python_file.read())
    from pathlib import Path
    
    file_contents = [
        path.read_text()
        for path in Path.cwd().rglob('*.py')
    ]s')

    如上所示,您可以read_text对Path对象使用方法和列表理解,将文件内容全部读入一个新列表中,相比于使用旧版本Python的实现,在语法和美观上无疑是更加出色!

    • 类型提示 Type hinting(最低 Python 版本为 3.5)

    编程语言有很多类型,静态编译型语言和动态解释型语言的对比是软件工程中一个热门的话题,几乎每个人对此有自己的看法。在静态语言中类型标注无疑是让人又爱又恨,爱的是编译速度加快,团队合作中准确了解函数方法的入参类型,恨的是Coding时极其繁琐的标注。不过,标注这种极其符合团队文化的操作还是在Python3中被引入,并且很快得到了人们的喜爱。

    def print_yes_or_no(codition: str) -> bool:
      pass
    • 枚举(最低 Python 版本为 3.4)

    大家在写Java或者C语言的时候都会接触到枚举这个特性,枚举也是帮我们节省了很多时间,也让我们的代码更加美观。旧版本Python中大家想要实现枚举的话实现方法五花八门,“八仙过海,各显神通”,充分发挥了Python的动态语言特性。我们下面举些例子:

    #利用type自建类的骚操作
    def enum(**enums):
        return type('Enum', (), enums)
    
    Numbers = enum(ONE=1, TWO=2, THREE='three')
    # Numbers.ONE == 1, Numbers.TWO == 2 and Numbers.THREE == 'three'
    #利用type自建类的骚操作升级版
    def enum(*sequential, **named):
        enums = dict(zip(sequential, range(len(sequential))), **named)
        return type('Enum', (), enums)
    
    Numbers = enum('ZERO', 'ONE', 'TWO')
    # Numbers.ZERO == 0 and Numbers.ONE == 1
    #有带值到名称映射的
    def enum(*sequential, **named):
        enums = dict(zip(sequential, range(len(sequential))), **named)
        reverse = dict((value, key) for key, value in enums.iteritems())
        enums['reverse_mapping'] = reverse
        return type('Enum', (), enums)
    
    
    # Numbers.reverse_mapping['three'] == 'THREE'
    # 更有甚者,利用namedtuple实现的
    from collections import namedtuple
    def enum(*keys):
        return namedtuple('Enum', keys)(*keys)
    
    MyEnum = enum('FOO', 'BAR', 'BAZ')
    
    # 带字符数字映射的,像C/C++
    def enum(*keys):
        return namedtuple('Enum', keys)(*range(len(keys)))
    
    # 带字典映射的,可以映射出各种类型,不局限于数字
    def enum(**kwargs):
        return namedtuple('Enum', kwargs.keys())(*kwargs.values())

    看过了以上这么多骚操作,现在Python3给你净化一下眼睛,Python3.4新推出通过「Enum」类编写枚举的简单方法。

    from enum import Enum, auto
    class Monster(Enum):    
           ZOMBIE = auto()    
           WARRIOR = auto()    
           BEAR = auto()
    print(Monster.ZOMBIE)
    for i in Monster:
      print(i)
    #Monster.ZOMBIE
    #Monster.ZOMBIE
    #Monster.WARRIOR
    #Monster.BEAR

    以上我们可以看出枚举是符号名称(成员)的集合,这些符号名称与唯一的常量值绑定在一起。在枚举中,可以通过标识对成员进行比较操作,枚举本身也可以被遍历。

    • 原生 LRU 缓存(最低 Python 版本为 3.2)

    缓存是大家在开发中都会用到的一个特性,如果我们准确的使用好它,它会节省我们很多时间和成本。相信很多人初学Python装饰器的时候都会去实现一个缓存的装饰器来节省斐波那契函数的计算时间。而Python 3 之后将 LRU(最近最少使用算法)缓存作为一个名为「lru_cache」的装饰器,使得对缓存的使用非常简单。

    下面是一个简单的斐波那契函数,我们知道使用缓存将有助于该函数的计算,因为它会通过递归多次执行相同的工作。

    import time
    def fib(number: int) -> int:    
      if number == 0: 
        return 0    
      if number == 1: 
        return 1    
      return fib(number-1) + fib(number-2)
    start = time.time()
    fib(40)
    print(f'Duration: {time.time() - start}s')
    # Duration: 30.684099674224854s

    我们看到,我们没用缓存装饰器的时候计算的时间是30秒左右,现在,我们可以使用「lru_cache」来优化它(这种优化技术被称为「memoization」)。通过这种优化,我们将执行时间从几秒降低到了几纳秒。

    from functools import lru_cache
    @lru_cache(maxsize=512)
    def fib_memoization(number: int) -> int:    
      if number == 0: 
        return 0    
      if number == 1: 
        return 1    
      return fib_memoization(number-1) + fib_memoization(number-2)
    start = time.time()
    fib_memoization(40)
    print(f'Duration: {time.time() - start}s')
    # Duration: 6.866455078125e-05s

    可以看出,我们在开发计算函数的时候使用缓存装饰器是多么提高成本的一种手段,另外,在新版本Python3.8之后,lru_cache现在可直接作为装饰器而不是作为返回装饰器的函数。因此这两种写法现在都被支持:

    @lru_cache
    def f(x):
        ...
    
    
    @lru_cache(maxsize=256)
    def f(x):
        ...
    
    • 扩展的可迭代对象解包(最低 Python 版本为 3.0)

    Python解包相信在我们初学Python的时候都有所了解,如果我们很多地掌握这个特性,相信是一件非常酷的事情。那什么是扩展的解包呢?我们可以从pep3132中了解更多,举个例子:

    # Python 3.4 中 print 函数 不允许多个 * 操作
    >>> print(*[1,2,3], *[3,4])
      File "<stdin>", line 1
        print(*[1,2,3], *[3,4])
                        ^
    SyntaxError: invalid syntax
    >>>
    # 再来看看 python3.5以上版本
    # 可以使用任意多个解包操作
    >>> print(*[1], *[2], 3)
    1 2 3
    >>> *range(4), 4
    (0, 1, 2, 3, 4)
    >>> [*range(4), 4]
    [0, 1, 2, 3, 4]
    >>> {*range(4), 4}
    {0, 1, 2, 3, 4}
    >>> {'x': 1, **{'y': 2}}
    {'x': 1, 'y': 2}

    我们可以看到,解包这个操作也算的上Python中极其潮流的玩法了,耍的一手好解包,真的会秀翻全场啊!

    • Data class 装饰器(最低 Python 版本为 3.7)

    Python 3.7 引入了【data class】,新特性大大简化了定义类对象的代码量,代码简洁明晰。通过使用@dataclass装饰器来修饰类的设计,可以用来减少对样板代码的使用,因为装饰器会自动生成诸如「__init__()」和「__repr()__」这样的特殊方法。在官方的文档中,它们被描述为「带有缺省值的可变命名元组」。

    from dataclasses import dataclass
    
    
    @dataclass
    class DataClassCard:
        rank: str
        suit: str
    
    
    
    
    #生成实例
    queen_of_hearts = DataClassCard('Q', 'Hearts')
    print(queen_of_hearts.rank)
    print(queen_of_hearts)
    print(queen_of_hearts == DataClassCard('Q', 'Hearts'))
    #Q
    #DataClassCard(rank='Q', suit='Hearts')
    #True

    而常规的类,按照Python 3.7之前的语法类似于这样:

    class RegularCard
        def __init__(self, rank, suit):
            self.rank = rank
            self.suit = suit
    queen_of_hearts = RegularCard('Q', 'Hearts')
    print(queen_of_hearts.rank)
    print(queen_of_hearts)
    print(queen_of_hearts == RegularCard('Q', 'Hearts'))
    #'Q'
    #<__main__.RegularCard object at 0x7fb6eee35d30>
    #False 
    

    虽然这种写法并没有使用更多的代码量,但是我们很容易看到为了初始化,仅仅只是为了初始化一个对象,rank和suit已经重复了三次。此外,如果你试图使用这个RegularCard类,你会注意到对象的表示不是很具描述性,并且已有的类与新声明的类是无法比较是否相同的。因为每次声明都会使用一个新的内存地址,而“==”不止比较类存储的信息,还比较内存地址是否相同。

    dataclass还在底层给我们做了更多的有用的封装。默认情况下dataclass实现了__repr__方法,可以很好的提供字符串表示;也是了__eq__方法,可以做基本的对象比较。而如果RegularCard想实现上面的功能需要写大量的声明,代码量多的吓人。

    class RegularCard(object):
        def __init__(self, rank, suit):
            self.rank = rank
            self.suit = suit
    
    
        def __repr__(self):
            #可以将类的信息打印出来
            return (f'{self.__class__.__name__}'  
                    f'(rank={self.rank!r}, suit={self.suit!r})')  
             #大家可以试着将“!r”去掉或者将其中的r改变为s或a,看看输出结果会有什么变化
             #conversion character: expected 's', 'r', or 'a'
    
    
        def __eq__(self, other):
            #可以比较类是否相同(不考虑内存地址)
            if other.__class__ is not self.__class__:
                return NotImplemented
            return (self.rank, self.suit) == (other.rank, other.suit)
    • 隐式命名空间包(最低 Python 版本为 3.3)

    一种组织 Python 代码文件的方式是将它们封装在程序包中(包含一个「init.py」的文件夹)。下面是官方文档提供的示例:

    sound/  Top-level package      
      __init__.py  Initialize the sound package      
      formats/ Subpackage for file format conversions              
        __init__.py              
        wavread.py              
        wavwrite.py              
        aiffread.py              
        aiffwrite.py              
        auread.py              
        auwrite.py              .
        ..      
      effects/  Subpackage for sound effects              
        __init__.py              
        echo.py              
        surround.py              
        reverse.py              
        ...      
      filters/  Subpackage for filters             
        __init__.py              
        equalizer.py              
        vocoder.py              
        karaoke.py              
        ...

    在 Python 2 中,上面每个文件夹都必须包含将文件夹转化为 Python 程序包的「init.py」文件。在 Python 3 中,随着隐式命名空间包的引入,这些文件不再是必须的了。

    sound/ Top-level package      
      __init__.py  Initialize the sound package      
      formats/  Subpackage for file format conversions 
        wavread.py              
        wavwrite.py              
        aiffread.py              
        aiffwrite.py              
        auread.py              
        auwrite.py              
        ...      
      effects/  Subpackage for sound effects              
        echo.py              
        surround.py              
        reverse.py              
        ...      
      filters/ Subpackage for filters              
        equalizer.py              
        vocoder.py              
        karaoke.py              
        ...

    正如有些人说的那样,这项工作并没有像这篇文章说的那么简单,官方文档「PEP 420 Specification」指出,常规的程序包仍然需要「init.py」,把它从一个文件夹中删除会将该文件夹变成一个本地命名空间包,这会带来一些额外的限制。本地命名空间包的官方文档给出了一个很好的示例,并且明确指出了所有的限制。

    总结

    上面给出的几个很潮流的特性可能并不是很全,更多的还需要大家去探索符合自己和团队的玩法,这篇文章只是向大家展示一些比较好玩的Python新功能,掌握它可以帮助你写出更加Pythonic的代码。

    声明:本文为CSDN博主「云爬虫技术研究笔记」的原创文章,版权归作者所有。

    Python的C位稳了!微软正式拥抱Python !

    https://edu.csdn.net/topic/python115?utm_source=csdn_bw

    技术的道路一个人走着极为艰难?

    一身的本领得不施展?

    优质的文章得不到曝光?

    别担心,

    即刻起,CSDN 将为你带来创新创造创变展现的大舞台,

    扫描下方二维码,欢迎加入 CSDN 「原力计划」!

    热 文 推 荐 

    15 年经验专家解读 IIoT 的挑战及应对思路!

    Android 支持主线 Linux 内核指日可待?

    GitHub 又又又挂了?

    网易患病员工被保安赶出公司,程序员该如何应对中年危机?

    华为电脑终于又能搭载正版 Windows 系统了!

    看完这篇还不了解Nginx,那我就哭了!

    通俗易懂:8大步骤图解注意力机制

    点击阅读原文,参加中国开发者现状调查!

    你点的每个“在看”,我都认真当成了喜欢

    展开全文
  • python3.7 倒计时

    千次阅读 2018-09-03 17:29:00
    #!/usr/bin/env python __author__ = "lrtao...# python3.7 倒计时 import time for i in range(10,-1,-1): print('\r','距离游戏结束还有 %s 秒!' % str(i).zfill(2),end='') time.sleep(1) print('\r'...
    #!/usr/bin/env python 
    __author__ = "lrtao2010" 
    
    # python3.7 倒计时
    import time
    for i in range(10,-1,-1):
        print('\r','距离游戏结束还有 %s 秒!' % str(i).zfill(2),end='')
        time.sleep(1)
    print('\r','{:^20}'.format('游戏结束!'))

     

    转载于:https://www.cnblogs.com/lrtao2010/p/9579677.html

    展开全文
  • 桌面美化 Python tkinter倒计时工具效果一、壁纸设计二、倒计时小工具实现1.引入库2.倒计时函数3.绘制UI载入数据以及创建窗口创建Label控件控件布局绘制分割线总结 效果 使用tkiner编写倒计时工具并放在桌面上,...


    效果

    使用tkiner编写倒计时工具并放在桌面上,配合ps制作的壁纸,实现桌面美化
    效果如下:

    效果预览


    一、壁纸设计

    根据桌面文件布局风格、个人喜好、可以自行搜集或设计

    我这里是用 PS 制作的壁纸,这里需要配合桌面的布局风格来制作,我主要就是按照布局绘制了底色,然后发现上边有点空,加了句话,这里使用的壁纸如下:在这里插入图片描述


    二、倒计时小工具实现

    设计啥的咱也不是专业的咱也不懂也不好说,直接说软件咋做的吧
    初心就是tkinter的试水,之前用pyqt5做过一些东西,但是打包后70多Mb,这次想试试tkiner
    (tkinter是真的轻便,也是真的不个性)

    废话不多说,开撸!

    1.引入库

    因为需要不断刷新我们的倒计时,而tkinter的线程又是阻塞的,所以这里使用多线程

    import tkinter as tk
    from threading import Thread
    import time
    

    2.倒计时函数

    主要就是根据时间截之差,计算相差的天数、以及余下的小时数、分钟数:

    def get_time(handle):
        while True:
            s = handle.endtime - int(time.time())
            days = int(s / 86400)
            hours = int((s % 86400) / 3600)
            mins = int((s % 3600) / 60)
            handle.LabelDays.config(text=f'{days} 天')
            handle.LabelHours.config(text=f'{hours} 时')
            handle.LabelMins.config(text=f'{mins} 分')
            handle.LabelS.config(text=f'共计 {format(s,",")} 秒')
            time.sleep(1)
    

    handle 是后边绘制UI时创建的类在调用此函数时传入的self(可以理解为继承???)
    int() 用于取整(直接舍弃小数部分)
    % 用于取余数
    config 用于修改控件

    3.绘制UI

    载入数据以及创建窗口

    首先,创建类,载入我们的倒计时数据,然后创建我们的窗口
    class APP():
        def __init__(self):
            with open('config','r',encoding='utf8') as f:
                self.Target = f.readline().strip()
                self.endtime=eval(f.readline().strip())
            self.window = tk.Tk()
            # 设置窗口大小以及位置
            self.window.geometry('405x270+1128+290')
    

    这里的 config 文件,是我存放倒计时目标以及时间截的地方
    config内容:

    开学
    1613577600

    self.window.geometry(‘405x270+1128+290’) 是指窗口宽为405,高为270,距离屏幕左边为1128,距离屏幕上边为290
    这里数值的大小是我自己尝试出来的


    创建Label控件

        def set_text(self):
            self.LabelTitle = tk.Label(self.window, text=f'距离 {self.Target} 还有', bg='#f9aea8',fg='white', font=('方正青铜体简体', 17))
            self.LabelDays = tk.Label(self.window, text='00 天', bg='#f9aea8', fg='white', font=('方正青铜体简体', 17))
            self.LabelHours = tk.Label(self.window, text='00 时', bg='#f9aea8', fg='white', font=('方正青铜体简体', 17))
            self.LabelMins = tk.Label(self.window, text='00 分', bg='#f9aea8', fg='white', font=('方正青铜体简体', 17))
            self.LabelS = tk.Label(self.window, text='共计 000,000 秒', bg='#f9aea8', fg='white', font=('方正青铜体简体', 17))
    

    这里用到的字体为 方正青铜体简体 ,可以改为自己电脑上的自己喜欢的字体。
    非常烦的一件事就是tkinter的控件带背景颜色且不能透明,这也是为何我最终选择了纯色背景——方便

    如果想用图片做背景,还想控件背景透明的话,可以参考 这篇文章,作者通过切割窗口背景图片然后将切割后的图片作为控件背景的方法,另辟蹊径的解决了这个问题,Nice!


    控件布局

        def set_layout(self):
            tk.Label(self.window, bg='#f9aea8').pack(expand='yes')  # 仅用来占地方,避免其它控件位置过于靠上
            self.LabelTitle.pack(expand='yes')
            self.LabelDays.pack(expand='yes')
            self.LabelHours.pack(expand='yes')
            self.LabelMins.pack(expand='yes')
            self.LabelS.pack(expand='yes')
            tk.Label(self.window, bg='#f9aea8').pack()  # 仅用来占地方,避免其它控件位置过于靠下
    

    这里采用的pack的方法来布局的,关于pack,可以参考这里

    绘制分割线

    这里还画了两条白色的分割线用于美化

        def set_Line(self):
            self.CanvasBg = tk.Canvas(self.window, bg='#f9aea8', width=405, height=270)
            self.CanvasBg.place(x=0, y=0)
            self.CanvasBg.create_line(0, 73, 405, 73, fill='white')
            self.CanvasBg.create_line(0, 200, 405, 200, fill='white')
    

    self.CanvasBg.create_line(0, 73, 405, 73, fill=‘white’)
    是指画一条从(0,73)到(405,73)的白色线段

    注意:需要在Canvas控件上进行绘制。

    绘制子窗口,用于修改倒计时目标

        def updata_window(self,event):  # 绘制子窗口
            self.UpdataWindow = tk.Toplevel()
            self.UpdataWindow['bg'] = '#f6ccb4'
            self.UpdataWindow.title('修  改')
            self.UpdataWindow.geometry('240x140')
    
            self.EntryTarget = tk.Entry(self.UpdataWindow)  # 目标输入框
            self.EntryEndtime = tk.Entry(self.UpdataWindow)  # 时间截输入框
    
            tk.Label(self.UpdataWindow,bg='#f6ccb4', text='目  标').grid(row=1, column=1,pady=10,padx=5)
            self.EntryTarget.grid(row=1,column=2)
            tk.Label(self.UpdataWindow,bg='#f6ccb4', text='时间截').grid(row=2,column=1,pady=10,padx=5)
            self.EntryEndtime.grid(row=2,column=2)
            # 修改按钮
            tk.Button(self.UpdataWindow, bg='#f9aea8', fg='white',width='19', text='修改',command=self.updata).grid(row=3,column=2)
    
        def updata(self):  # 用于将修改更新到父窗口
            if self.EntryEndtime.get():
                self.Target = self.EntryTarget.get()
                self.endtime = eval(self.EntryEndtime.get())  # 获取时间截数值
                self.LabelTitle.config(text=f'距离 {self.Target} 还有')
                self.UpdataWindow.destroy()  # 销毁子窗口
                with open('config', 'w', encoding='utf8') as f:  # 保存到本地
                    f.write(f'{self.Target}\n{self.endtime}')
    
    

    这里采用的是的是grid的布局方式,简单来说,按照表格的方式布局,row是第几行,column是第几列,还有其它参数这里没用到,如:
    padx 是单元格左右间距
    pady 是单元格上下间距
    ipadx是单元格内部元素与单元格左右的间距
    ipady是单元格内部元素与单元格上下的间距

    其它设置

        def set_others(self):
            self.window.resizable(0, 0)  # 固定窗口大小,不可调整
            self.window.overrideredirect(True)  # 去除窗口标题栏
            self.LabelTitle.bind("<Button-1>", self.updata_window)  # 绑定鼠标左击事件,用于修改目标
            Thread(target=get_time,args=(self,)).start()  # 多线程启动刷新时间函数
    

    最后,在init里该调用调用,在外面该初始化初始化,完整代码如下

    完整代码

    import tkinter as tk
    from threading import Thread
    import time
    
    
    def get_time(handle):
        while True:
            s = handle.endtime - int(time.time())
            days = int(s / 86400)
            hours = int((s % 86400) / 3600)
            mins = int((s % 3600) / 60)
            handle.LabelDays.config(text=f'{days} 天')
            handle.LabelHours.config(text=f'{hours} 时')
            handle.LabelMins.config(text=f'{mins} 分')
            handle.LabelS.config(text=f'共计 {format(s,",")} 秒')
            time.sleep(1)
    
    
    class APP():
        def __init__(self):
            with open('config','r',encoding='utf8') as f:
                self.Target = f.readline().strip()
                self.endtime=eval(f.readline().strip())
            self.window = tk.Tk()
            self.window.geometry('405x270+1128+290')
            self.set_Line()
            self.set_text()
            self.set_layout()
            self.set_others()
    
        def set_Line(self):
            self.CanvasBg = tk.Canvas(self.window, bg='#f9aea8', width=405, height=270)
            self.CanvasBg.place(x=0, y=0)
            self.CanvasBg.create_line(0, 73, 405, 73, fill='white')
            self.CanvasBg.create_line(0, 200, 405, 200, fill='white')
    
        def set_text(self):
            self.LabelTitle = tk.Label(self.window, text=f'距离 {self.Target} 还有', bg='#f9aea8',fg='white', font=('方正青铜体简体', 17))
            self.LabelDays = tk.Label(self.window, text='00 天', bg='#f9aea8', fg='white', font=('方正青铜体简体', 17))
            self.LabelHours = tk.Label(self.window, text='00 时', bg='#f9aea8', fg='white', font=('方正青铜体简体', 17))
            self.LabelMins = tk.Label(self.window, text='00 分', bg='#f9aea8', fg='white', font=('方正青铜体简体', 17))
            self.LabelS = tk.Label(self.window, text='共计 000,000 秒', bg='#f9aea8', fg='white', font=('方正青铜体简体', 17))
    
        def set_layout(self):
            tk.Label(self.window, bg='#f9aea8').pack(expand='yes')
            self.LabelTitle.pack(expand='yes')
            self.LabelDays.pack(expand='yes')
            self.LabelHours.pack(expand='yes')
            self.LabelMins.pack(expand='yes')
            self.LabelS.pack(expand='yes')
            tk.Label(self.window, bg='#f9aea8').pack()
    
        def set_others(self):
            self.window.resizable(0, 0)
            self.window.overrideredirect(True)
            self.LabelTitle.bind("<Button-1>", self.updata_window)
            Thread(target=get_time,args=(self,)).start()
    
        def updata_window(self,event):
            self.UpdataWindow = tk.Toplevel()
            self.UpdataWindow['bg'] = '#f6ccb4'
            self.UpdataWindow.title('修  改')
            self.UpdataWindow.geometry('240x140')
    
            self.EntryTarget = tk.Entry(self.UpdataWindow)
            self.EntryEndtime = tk.Entry(self.UpdataWindow)
    
            tk.Label(self.UpdataWindow,bg='#f6ccb4', text='目  标').grid(row=1, column=1,pady=10,padx=5)
            self.EntryTarget.grid(row=1,column=2)
            tk.Label(self.UpdataWindow,bg='#f6ccb4', text='时间截').grid(row=2,column=1,pady=10,padx=5)
            self.EntryEndtime.grid(row=2,column=2)
            tk.Button(self.UpdataWindow, bg='#f9aea8', fg='white',width='19', text='修改',command=self.updata).grid(row=3,column=2)
    
        def updata(self):
            if self.EntryEndtime.get():
                self.Target = self.EntryTarget.get()
                self.endtime = eval(self.EntryEndtime.get())
                self.LabelTitle.config(text=f'距离 {self.Target} 还有')
                self.UpdataWindow.destroy()
                with open('config', 'w', encoding='utf8') as f:
                    f.write(f'{self.Target}\n{self.endtime}')
                
    
    
    if __name__ == '__main__':
        myapp = APP()
        myapp.window.mainloop()
    
    

    打包并开机自启动

    打包成EXE

    pyinstaller -D de_desktop.py -p venv\Lib\site-packages --noconsole
    

    这里的 -D de_desktop.py 是指文件名是 de_desktop.py
    -p venv\Lib\site-packages 是指库函数的目录在这里(我这里用的是相对路径)
    –noconsole 是指不需要命令窗口(默认不加这句的话,启动程序后会有一个cmd似的窗口)

    开机自启动

    直接将打包好的EXE的快捷方式复制到开机启动项的文件夹内

    C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp

    注意:win+d快捷键返回桌面时,程序界面会被隐藏,按alt+f4可以调出;其他方式返回桌面时没问题。
    如果你有隐藏标题栏又同时不隐藏状态栏的方法,欢迎告知,在线求。

    展开全文
  • python 倒计时

    2021-03-16 15:27:49
    #python3 倒计时 #range 参数 #start: 计数从 start 开始。默认是从 0 开始。例如range(5)等价于range(0, 5); #stop: 计数到 stop 结束,但不包括 stop。例如:range(0, 5) 是[0, 1, 2, 3, 4]没有5 #step:...
    #!/usr/bin/env python
    #python3 倒计时
    #range 参数
    #start: 计数从 start 开始。默认是从 0 开始。例如range(5)等价于range(0, 5);
    #stop: 计数到 stop 结束,但不包括 stop。例如:range(0, 5) 是[0, 1, 2, 3, 4]没有5
    #step:步长,默认为1。例如:range(0, 5) 等价于 range(0, 5, 1)
    #负数就是倒数
    import time
    for times in range(12, -1, -1):
        print('\r','距离下一次刷新抖音结束还有 %s 秒!' % str(times).zfill(2), end='')
        time.sleep(1)
    print('\r','{:^20}'.format('开始刷新抖音!'))
    
    展开全文
  • Python2 开始倒计时

    2019-01-07 23:27:00
    迁移潮来袭 数十个项目宣布即将停止支持 Python 2 参考:https://www.cnbeta.com/articles/soft/805287.htm 列表地址:... 转载于:https://www.cnblogs.com/yvivid/articles/python2_dead.html...
  • 基于Python编写的倒计时工具

    万次阅读 2019-08-08 23:58:31
    基于Python编写的倒计时工具 特点: 1. 实时显示当前时间 2. 自动判断用户输入日期,计算当前日期与目标日期相差大概多少年、月、日以及准确的相差天数
  • Python 2“退休”倒计时 这几年,很多项目以及主要的开源 Python 包都在同时支持 Python 3.x 和 Python 2.7,虽然拥有有效保持兼容性的工具和技术,但是在很多开发中,还是存在一些问题。之前发布消息称 Python 2.7 ...
  • python计算春节倒计时

    2017-11-22 12:36:00
    先来无聊,想知道今年的春节还有几天,好久没写python代码了,下面就随便写了一个,如有不对之处,还请...2 3 4 5 6 7 8 9 10 11 12 13 14 #coding=utf-8 #!/usr/bin/env python importdatetime spring=dat...
  • Python 2“退休”倒计时   这几年,很多项目以及主要的开源 Python 包都在同时支持 Python 3.x 和 Python 2.7,虽然拥有有效保持兼容性的工具和技术,但是在很多开发中,还是存在一些问题。之前发布消息称 Python...
  • 昨天写了个计算距离今年春节还有几天的脚本,今天在群里看到可以实时刷新的一个脚本,利用flush()函数清空输出...2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 [root@localhost progressbar...
  • 它们的工作方式略有不同:R 版本为一系列 ggplot2 绘图设置动画,而 Python 版本直接使用 ImageMagick 的文本绘制功能。 两者都适用于一些小问题和解决方法(记录在代码中)。 他们正在行动:
  • python3.5 pyqt5 eric6 计时器源代码。5个倒计时器,2个正计时器,可同时计时。计时结束有声音提醒。
  • /usr/bin/python # -*- coding: utf-8 -*- import os import sys import time import platform # 乱码处理 sys_encoding = sys.getfilesystemencoding() def printcn(msg): print(msg.decode('utf-8')....
  • 用time模块实现倒计时。 程序实例: import time for i in range(10,0,-1): print(i) time.sleep(1) 运行结果: 10 9 8 7 6 5 4 3 2 1
  • 关注「实验楼」,每天分享一个项目教程 有开发者发布了一个网站以对 Python 2.7 的“退休”进行倒计时。可以看到 Python 2.7 预计将于两年后退休。该开发者表示,由于官方尚未放出准确的日期,所以预计 Python 2.7 ...
  • 有开发者发布了一个网站以对 Python 2.7 的“退休”进行倒计时。可以看到 Python 2.7 预计将于两年后退休。该开发者表示,由于官方尚未放出准确的日期,所以预计 Python 2.7 于 2020 年 4 月 12 日退休,这是到时 ...
  • python进阶练习题:倒计时 - 最长的单词【难度:2级】: 详情 [倒数](https://en.wikipedia.org/wiki/Countdown_(game_show)是英国游戏节目与数和字拼图字母轮由选手采摘9洗牌字母 - 无论是从元音桩拾取或.辅音桩参赛者...
  • Java 12现在处于“候选发布”阶段,这意味着倒计时已经开始! Java 12将在3月19日发布,为您做好准备–我们快到了! 9. Angular v8的测试版季节始于1月中旬,我们希望看到最终结果。 第七版Beta已在此处,但即使将...
  • 利用python GUI工具QtDesigner 生成了初始界面,pythonQt4后期的编写,做成了一个活动倒计时小程序。包括了pythonQt4编写界面的大部分技巧,如界面的绘制,事件响应,事件重载等,在github上有对应的源程序,里面写...
  • #倒计时七段数码管 import turtle def drawLine(draw): turtle.pendown() if draw else turtle.penup() turtle.fd(40) turtle.right(90) def drawDigits(digit): drawLine(True) if digit in [2,3,4,5,6,...
  • 乾明 栗子 发自 凹非寺量子位 报道 | 公众号 QbitAIPython 2终于走到了尽头。官方宣布,新一年的钟声响起之时(2020年1月1日),就是Python 2...
  • 自制python计时

    2020-04-03 12:31:30
    简单版-不加字体效果 出发点是想在工作的时候在电脑上放一个倒计时提醒一下自己,按照一般常规思路我去搜索下载一个倒计时的...为此我复习了怎么在同一行输出倒计时的 分钟:秒数,还学到了python怎么调用windo...
  • 倒计时 - 最长的单词【难度:2级】: 答案1: def longest_word(letters): unscrambled = [] for word in words: if set(word).issubset(set(letters)) and all(word.count(l) <= letters.count(l) for l in set...
  • 2.格式化日期:可将日期转换成平常我们所见的格式 python中时间日期格式化符号 %y 两位数的年份表示(00-99) %Y 四位数的年份表示(000-9999) %m 月份(01-12) %d 月内中的一天(0-31) %H ...
  • python-OpenCV做一个魔方墙找茬,现在是第2版本,增加了加上 分值计算、倒计时、记录存储三部分功能。

空空如也

空空如也

1 2 3 4 5
收藏数 96
精华内容 38
关键字:

python2倒计时

python 订阅