精华内容
下载资源
问答
  • Python小技巧之列表推导式到匿名函数 最近又看了一遍python的基础知识,所谓温故而知新,哈哈哈,所以在这里写下自己的一些见解,我觉得在实战过程中还是非常有用的一些小技巧,也分享给大家,如果写的不好,请大家...
  • 要想让你的 Python 代码同时在 Windows 和 Mac/Linux 上工作,你需要处理不同系统文件名用不同斜杠的问题。而 Python 3 有一个名为「pathlib」的新模块,可以帮你解决这个麻烦,需要的朋友可以参考下
  • Python时间日期转换在开发中是非常高频的一个操作,你经常会遇到需要将字符串转换成 datetime 或者是反过来将 datetime 转换成字符串,今天小编给大家带来了一个Python小技巧,感兴趣的朋友一起看看吧
  • 主要介绍了10个Python小技巧,非常不错,具有一定的参考借鉴价值,需要的朋友可以参考下
  • 在用jupyter notebook写python代码的过程中会产生很多变量,而关闭后或者restart jupyter kernel后所有变量均会消失,想要查看变量就必须将代码重新再运行一遍,而想在另一个jupyter notebook中调用变量就更加麻烦。...
  • 将自动化测试的结果生成一个报告: 闲话少说,上代码: # author:闫振兴 # contact: 1753502691@qq.com # datetime:2020/4/9 21:04 # software: PyCharm """ 文件说明: """ # encoding:utf-8 ...
  • 在编程过程中,我们往往会遇到一个麻烦——微软 Windows 系统在文件夹名之间使用反斜杠字符,而几乎所有其它的计算机(操作系统)都使用正斜杠: 这是由于上世纪 80 年代早期计算机历史上的一个意外。「MS-...
  • python小技巧

    2012-10-11 16:43:30
    python小技巧,请多多提意见,多对分享经验,谢谢
  • Python小技巧:获取Linux系统基本信息.pdf
  • Python常用小技巧总结

    2020-12-23 17:50:54
    本文实例总结了Python常用的小技巧。分享给大家供大家参考。具体分析如下: 1. 获取本地mac地址: import uuid mac = uuid.uuid1().hex[-12:] print(mac) 运行结果:e0cb4e077585 2. del 的使用 a = ['b','c','d...
  • python实用30个小技巧

    千次阅读 2019-06-16 15:01:40
    Python 提供了一个直观的在一行代码中赋值与交换(变量值)的方法,请参见下面的示例: In [1]: x,y = 10 ,20 In [2]: print(x,y) 10 20 In [3]: x, y = y, x In [4]: print(x,y) 20 10 赋值的右侧形成了一...

    1.原地交换两个数字

    Python 提供了一个直观的在一行代码中赋值与交换(变量值)的方法,请参见下面的示例:

    In [1]: x,y = 10 ,20 
    
    In [2]: print(x,y)
    10 20
    
    In [3]: x, y = y, x 
    
    In [4]: print(x,y)
    20 10
    

    赋值的右侧形成了一个新的元组,左侧立即解析(unpack)那个(未被引用的)元组到变量 <x> 和 <y>。

    一旦赋值完成,新的元组变成了未被引用状态并且被标记为可被垃圾回收,最终也完成了变量的交换。

    2.链状比较操作符

    比较操作符的聚合是另一个有时很方便的技巧:

    In [5]: n = 10 
    
    In [6]: result = 1 < n < 20 
    
    In [7]: result 
    Out[7]: True
    
    In [8]: result = 1 > n <= 9 
    
    In [9]: result 
    Out[9]: False
    

    3.使用三元操作符来进行条件赋值

    三元操作符是 if-else 语句也就是条件操作符的一个快捷方式:

    [表达式为真的返回值] if [表达式] else [表达式为假的返回值]
    

    这里给出几个你可以用来使代码紧凑简洁的例子。下面的语句是说“如果 y 是 9,给 x 赋值 10,不然赋值为 20”。如果需要的话我们也可以延长这条操作链。

    x = 10 if (y == 9) else 20
    

    同样地,我们可以对类做这种操作:

    x = (classA if y == 1 else classB)(param1, param2)
    

    在上面的例子里 classA 与 classB 是两个类,其中一个类的构造函数会被调用.

    下面是另一个多个条件表达式链接起来用以计算最小值的例子:

    In [10]: def small(a,b,c):
        ...:     return a if a<=b and a<=c else ( b if b<=a and b<=c else c) 
        ...: 
    
    In [11]: small(1,0,1)
    Out[11]: 0
    
    In [12]: small(1,2,3)
    Out[12]: 1
    

    我们甚至可以在列表推导中使用三元运算符:

    
    In [14]: [ m**2 if m > 10 else m**4 for m in range(20) ] 
    Out[14]: 
    [0,1,16,81,256,625,1296,2401,4096,6561,10000,121,144,169,196,225,256,289,324,61]
    

    4.多行字符串

    基本的方式是使用源于 C 语言的反斜杠:

    In [20]: multistr = " select * from multi_row \
        ...: where row_id < 5"
    
    In [21]: multistr
    Out[21]: ' select * from multi_row where row_id < 5'
    

    另一个技巧是使用三引号

    In [23]: multistr ="""select * from multi_row 
        ...: where row_id < 5"""
    
    In [24]: multistr
    Out[24]: 'select * from multi_row \nwhere row_id < 5'
    

    上面方法共有的问题是缺少合适的缩进,如果我们尝试缩进会在字符串中插入空格。所以最后的解决方案是将字符串分为多行并且将整个字符串包含在括号中:

    In [25]: multistr = ("select * from multi_row "
        ...: "where row_id < 5 " 
        ...: "order by age")  
    
    In [26]: multistr
    Out[26]: 'select * from multi_row where row_id < 5 order by age'
    

    5.存储列表元素到新的变量中

    我们可以使用列表来初始化多个变量,在解析列表时,变量的数目不应该超过列表中的元素个数:【译者注:元素个数与列表长度应该严格相同,不然会报错】

    In [27]: testlist = [1,2,3] 
    
    In [28]: x,y,z = testlist 
    
    In [29]: print(x,y,z) 
    1 2 3
    

    6.打印引入模块的文件路径

    如果你想知道引用到代码中模块的绝对路径,可以使用下面的技巧:

    In [30]: import threading 
    
    In [31]: import socket 
    
    In [32]: print(threading)
    <module 'threading' from '/usr/local/lib/python3.5/threading.py'>
    
    In [33]: print(socket) 
    <module 'socket' from '/usr/local/lib/python3.5/socket.py'>
    

    7.交互环境下的"_"操作符

    这是一个我们大多数人不知道的有用特性,在 Python 控制台,不论何时我们测试一个表达式或者调用一个方法,结果都会分配给一个临时变量: _(一个下划线)。

    In [34]: 2 + 3 
    Out[34]: 5
    
    In [35]: _
    Out[35]: 5
    
    In [36]: print(_) 
    5
    

    “_” 是上一个执行的表达式的输出。

    8.字典/集合推导式

    与我们使用的列表推导相似,我们也可以使用字典/集合推导,它们使用起来简单且有效,下面是一个例子:

    In [37]: testDict = {i : i*i for i in range(5)} 
    
    In [38]: testSet = { i*2 for i in range(5)} 
    
    In [39]: testDict
    Out[39]: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
    
    In [40]: testSet
    Out[40]: {0, 2, 4, 6, 8}
    

    注:两个语句中只有一个 <:> 的不同,另,在 Python3 中运行上述代码时,将 <xrange> 改为 <range>。

    9.调试脚本

    我们可以在 <pdb> 模块的帮助下在 Python 脚本中设置断点,下面是一个例子:

    import pdb
    pdb.set_trace()
    

    我们可以在脚本中任何位置指定 <pdb.set_trace()> 并且在那里设置一个断点,相当简便。

    10.开启文件分享

    Python 允许运行一个 HTTP 服务器来从根路径共享文件,下面是开启服务器的命令:(python3环境)

    python3 -m http.server
    

    上面的命令会在默认端口也就是 8000 开启一个服务器,你可以将一个自定义的端口号以最后一个参数的方式传递到上面的命令中。

    Paste_Image.png

    11.检查Python中的对象

    我们可以通过调用 dir() 方法来检查 Python 中的对象,下面是一个简单的例子:

    In [41]: test = [1,3,5,7]
    
    In [42]: print(dir(test)) 
    ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
    

    会列出对象的属性方法。

    12.简化if语句

    我们可以使用下面的方式来验证多个值:

     if m in [1,3,5,7]:
    

    而不是

    if m==1 or m==3 or m==5 or m==7:
    

    或者,对于 in 操作符我们也可以使用 '{1,3,5,7}' 而不是 '[1,3,5,7]',因为 set 中取元素是 O(1) 操作。

    13.运行时检测Python版本

    当正在运行的 Python 低于支持的版本时,有时我们也许不想运行我们的程序。为达到这个目标,你可以使用下面的代码片段,它也以可读的方式输出当前 Python 版本:

    import sys
     
    #Detect the Python version currently in use.
    if not hasattr(sys, "hexversion") or sys.hexversion != 50660080:
        print("Sorry, you aren't running on Python 3.5n")
        print("Please upgrade to 3.5.n")
        sys.exit(1)
     
    #Print Python version in a readable format.
    print("Current Python version: ", sys.version)
    

    或者你可以使用 sys.version_info >= (3, 5) 来替换上面代码中的 sys.hexversion != 50660080,这是一个读者的建议。

    python3运行结果:

    Python 3.5.1 (default, Dec 2015, 13:05:11)
    [GCC 4.8.2] on linux
     
    Current Python version:  3.5.2 (default, Aug 22 2016, 21:11:05) 
    [GCC 5.3.0]
    

    14.组合多个字符串

    如果你想拼接列表中的所有记号,比如下面的例子:

    In [44]: test = ['I', 'Like', 'Python', 'automation']
    
    In [45]: ''.join(test)
    Out[45]: 'ILikePythonautomation'
    

    15.四种翻转字符串/列表的方式

    翻转列表本身

    In [49]: testList = [1, 3, 5] 
    
    In [50]: testList.reverse() 
    
    In [51]: testList
    Out[51]: [5, 3, 1]
    

    在一个循环中翻转并迭代输出

    In [52]: for element in reversed([1,3,5]):
        ...:     print(element) 
        ...:     
    5
    3
    1
    

    一行代码翻转字符串

    In [53]: "Test Python"[::-1]
    Out[53]: 'nohtyP tseT'
    

    使用切片翻转列表

    [1, 3, 5][::-1]
    

    16.玩转枚举

    使用枚举可以在循环中方便地找到(当前的)索引:

    In [54]: testList= [10,20,30] 
    
    In [55]: for i,value in enumerate(testList):
        ...:     print(i,':',value)
        ...:     
    0 : 10
    1 : 20
    2 : 30
    

    17.在python中使用枚举量

    我们可以使用下面的方式来定义枚举量:

    In [56]: class Shapes:
        ...:     Circle,Square,Triangle,Quadrangle = range(4) 
        ...:     
    
    In [57]: Shapes.Circle
    Out[57]: 0
    
    In [58]: Shapes.Square
    Out[58]: 1
    
    In [59]: Shapes.Triangle
    Out[59]: 2
    
    In [60]: Shapes.Quadrangle
    Out[60]: 3
    

    18.从方法中返回多个值

    并没有太多编程语言支持这个特性,然而 Python 中的方法确实(可以)返回多个值,请参见下面的例子来看看这是如何工作的:

    In [61]: def x():
        ...:     return 1,2,3,4 
        ...: 
    
    In [62]: a,b,c,d = x()
    
    In [63]: print(a,b,c,d) 
    1 2 3 4
    

    20.使用字典来存储选择操作

    我们能构造一个字典来存储表达式:

    In [70]: stdacl = { 
        ...: 'sum':lambda x,y : x + y,
        ...: 'subtract':lambda x,y : x - y 
        ...: } 
    
    
    In [73]: stdacl['sum'](9,3) 
    Out[73]: 12
    
    In [74]: stdacl['subtract'](9,3) 
    Out[74]: 6
    

    21.一行代码计算任何数的阶乘

    python3环境:

    In [75]: import functools
    
    In [76]: result = ( lambda k : functools.reduce(int.__mul__,range(1,k+1),1))(3) 
    
    In [77]: result
    Out[77]: 6
    

    22.找到列表中出现最频繁的数

    
    In [82]: test = [1,2,3,4,2,2,3,1,4,4,4] 
    
    In [83]: print(max(set(test),key=test.count)) 
    4
    

    23.重置递归限制

    Python 限制递归次数到 1000,我们可以重置这个值:

    import sys
     
    x=1001
    print(sys.getrecursionlimit())
     
    sys.setrecursionlimit(x)
    print(sys.getrecursionlimit())
     
    #1-> 1000
    #2-> 100
    

    谨慎修改

    24.检查一个对象的内存使用

    在 Python 2.7 中,一个 32 比特的整数占用 24 字节,在 Python 3.5 中利用 28 字节。为确定内存使用,我们可以调用 getsizeof 方法:
    python2.7:

    import sys
    x=1
    print(sys.getsizeof(x))
     
    #-> 24
    

    python3:

    In [86]: import sys 
    
    In [87]: x = 1
    
    In [88]: sys.getsizeof(x) 
    Out[88]: 28
    

    25.使用slots来减少内存开支

    你是否注意到你的 Python 应用占用许多资源特别是内存?有一个技巧是使用 slots 类变量来在一定程度上减少内存开支。

    import sys
    class FileSystem(object):
     
        def __init__(self, files, folders, devices):
            self.files = files
            self.folders = folders
            self.devices = devices
    print(sys.getsizeof( FileSystem ))
     
    class FileSystem1(object):
     
        __slots__ = ['files', 'folders', 'devices']
        def __init__(self, files, folders, devices):
            self.files = files
            self.folders = folders
            self.devices = devices
     
    print(sys.getsizeof( FileSystem1 ))
    #In Python 3.5
    #1-> 1016
    #2-> 888
    

    很明显,你可以从结果中看到确实有内存使用上的节省,但是你只应该在一个类的内存开销不必要得大时才使用 slots。只在对应用进行性能分析后才使用它,不然地话,你只是使得代码难以改变而没有真正的益处。

    26.使用lambda来模仿输出方法

    In [89]: import sys 
    
    In [90]: lprint = lambda *args: sys.stdout.write("".join(map(str,args))) 
    
    In [91]: lprint("python","tips",1000,1001) 
    Out[91]: pythontips1000100118
    

    27.从两个相关的序列构建一个字典

    In [92]: t1 = (1,2,3) 
    
    In [93]: t2 =(10,20,30) 
    
    In [94]: dict(zip(t1,t2)) 
    Out[94]: {1: 10, 2: 20, 3: 30}
    

    28.一行代码搜索字符串的多个前后缀

    In [95]: print("http://www.google.com".startswith(("http://", "https://")))
    True
    
    In [96]: print("http://www.google.co.uk".endswith((".com", ".co.uk")))
    True
    

    29. 不使用循环构造一个列表

    In [101]: test = [[-1, -2], [30, 40], [25, 35]] 
    
    In [102]: import itertools
    
    In [103]: print(list(itertools.chain.from_iterable(test)))
    [-1, -2, 30, 40, 25, 35]
    

    30.在Python中实现一个真正的switch-case语句

    下面的代码使用一个字典来模拟构造一个switch-case。

    In [104]: def xswitch(x):
         ...:     return xswitch._system_dict.get(x, None) 
         ...: 
    
    In [105]: xswitch._system_dict = {'files': 10, 'folders': 5, 'devices': 2}
    
    In [106]: print(xswitch('default'))
    None
    
    In [107]: print(xswitch('devices'))
    2



    作者:海贼之路飞
    链接:https://www.jianshu.com/p/cdceff697af8
    来源:简书
    简书著作权归作者所有,任何形式的转载都请联系作者获得授权并注明出处。

    展开全文
  • from datetime import datetime, timedelta class Date_today(object): def __init__(self): self.today = datetime.today() def next_day(self): self.tomorrow = self.today + ti...
    from datetime import datetime, timedelta
    
    
    class Date_today(object):
    
        def __init__(self):
            self.today = datetime.today()
        
        def next_day(self):
            self.tomorrow = self.today + timedelta(hours= 24)
            return self.tomorrow
        
        def next_year(self):
            self.nextyear = self.today + timedelta(days= 365)
            return self.nextyear
    
    def main():
        date = Date_today()
    
        while True:
            x = input("请输入(a:今天,b:明天,c:明年。退出:任意键)")
        
            if x in ["a", "b", "c"]:
            	 y = {"a": date.today.strftime("%Y-%m-%d"), "b": date.next_day().strftime("%Y-%m-%d"),
                     "c": date.next_year().strftime("%Y-%m-%d")}.get(x)
                         print(y)
            else:
                break
    
    if __name__ == "__main__":
        main()
    
    

    讨论:

     if x in ["a", "b", "c"]:
    
    • 这里使用 x in [“a”, “b”, “c”]: 代替了 :
      if x == “a”:

      if x == “b”:

      if x == “c”:
    y = {"a": date.today.strftime("%Y-%m-%d"),  "b": date.next_day().strftime("%Y-%m-%d"), 
    	 "c": date.next_year().strftime("%Y-%m-%d")}.get(x)
    
    • 结合 if x in [“a”, “b”, “c”]:语句,使用字典表达式达到 x == “a”, x == “b”, x == “c” 情况下分支语句的实现的目的。
    • 下面的例子更直观一些吧:
    def fun(x):
        if x == "a":
            return 1
        if x == "b":
            return 2
    
    def f(x):
        return {"a":fun("a"), "b":fun("b")}.get(x)
    
    y = f("b")
    print(y)  # 2
    
    • 今天发现如果字典的value是调用没有返回值,或者调用的是类方法的情况(调用的方法,在语句中不能带(),类似函数闭包的return),需要另一种实现方式:
    def f1():
    	print("--1--")
    def f2():
    	print("--2--")
    def f3():
    	x = input("请选择:")
    	if x in ["1", "2"]:
    		{"1":f1, "2":f2}.get(x).__call__()
    f3()
    请选择:2
    --2--
    请选择:1
    --1--
    
    
    展开全文
  • python小技巧:一步步教你用Python实现2048小游戏

    千次阅读 多人点赞 2020-05-17 21:59:37
    相信2048这个游戏对大家来说一定不陌生,下面这篇文章就主要给大家介绍了怎么用Python实现2048游戏,文中通过注释与示例代码介绍的很详细,相信对大家的理解和学习具有一定的参考借鉴价值,有需要的朋友们一起来看...

    @本文来源于公众号:csdn2299,喜欢可以关注公众号 程序员学府
    相信2048这个游戏对大家来说一定不陌生,下面这篇文章就主要给大家介绍了怎么用Python实现2048小游戏,文中通过注释与示例代码介绍的很详细,相信对大家的理解和学习具有一定的参考借鉴价值,有需要的朋友们一起来看看吧。
    前言

    2048游戏规则:简单的移动方向键让数字叠加,并且获得这些数字每次叠加后的得分,当出现2048这个数字时游戏胜利。同时每次移动方向键时,都会在这个4*4的方格矩阵的空白区域随机产生一个数字2或者4,如果方格被数字填满了,那么就GameOver了。

    主逻辑图
    在这里插入图片描述
    逻辑图解:黑色是逻辑层,蓝色是外部方法,红色是类内方法,稍后即可知道~在这里插入图片描述
    下面容我逐行解释主逻辑main()函数,并且在其中穿叉外部定义的函数与类。
    主逻辑代码解读(完整代码见文末)
    主逻辑main如下,之后的是对主函数中的一些方法的解读:

    def main(stdscr):
     def init():
     #重置游戏棋盘
     game_field.reset()
     return 'Game'
     
     def not_game(state):
     #画出 GameOver 或者 Win 的界面
     game_field.draw(stdscr)
     #读取用户输入得到action,判断是重启游戏还是结束游戏
     action = get_user_action(stdscr)
     responses = defaultdict(lambda: state) #默认是当前状态,没有行为就会一直在当前界面循环
     responses['Restart'], responses['Exit'] = 'Init', 'Exit' #对应不同的行为转换到不同的状态
     return responses[action]
     
     def game():
     #画出当前棋盘状态
     game_field.draw(stdscr)
     #读取用户输入得到action
     action = get_user_action(stdscr)
     
     if action == 'Restart':
      return 'Init'
     if action == 'Exit':
      return 'Exit'
     if game_field.move(action): # move successful
      if game_field.is_win():
      return 'Win'
      if game_field.is_gameover():
      return 'Gameover'
     return 'Game'
     
     
     state_actions = {
      'Init': init,
      'Win': lambda: not_game('Win'),
      'Gameover': lambda: not_game('Gameover'),
      'Game': game
     }
     
     curses.use_default_colors()
     game_field = GameField(win=32)
     
     state = 'Init'
     
     #状态机开始循环
     while state != 'Exit':
     state = state_actions[state]()
    

    逐条解读(代码框内会标注是来自外部,无标注则是来自内部):定义主函数

    def main(stdscr):
    
    def init():
    #重置游戏棋盘
    game_field.reset()
    

    reset出自外部定义的类,game_field=GameField的一个方法reset:

    外部:

    def reset(self):
     if self.score > self.highscore:
      self.highscore = self.score
     self.score = 0
     self.field = [[0 for i in range(self.width)] for j in range(self.height)]
     self.spawn()
     self.spawn()
    #其中highscore为程序初始化过程中定义的一个变量。记录你win游戏的最高分数记录。
    
    return 'Game'
    

    返回一个游戏进行中的状态。game_field=GameField状态在后面有定义:

    主函数底部定义:

    state_actions = {
     'Init': init,
     'Win': lambda: not_game('Win'),
     'Gameover': lambda: not_game('Gameover'),
     'Game': game
    }
    
    def not_game(state):
    #画出 GameOver 或者 Win 的界面
    game_field.draw(stdscr)
    

    draw是导入的类game_field=GameField中的方法:

    #来自外部类
     def draw(self, screen):
     help_string1 = '(W)Up (S)Down (A)Left (D)Right'
     help_string2 = ' (R)Restart (Q)Exit'
     gameover_string = '  GAME OVER'
     win_string = '  YOU WIN!'
    #定义各个字符串
     def cast(string):
      screen.addstr(string + '\n')
     
     def draw_hor_separator():
      line = '+' + ('+------' * self.width + '+')[1:]
      separator = defaultdict(lambda: line)
      if not hasattr(draw_hor_separator, "counter"):
      draw_hor_separator.counter = 0
      cast(separator[draw_hor_separator.counter])
      draw_hor_separator.counter += 1
     
     def draw_row(row):
      cast(''.join('|{: ^5} '.format(num) if num > 0 else '| ' for num in row) + '|')
     
     screen.clear()
     cast('SCORE: ' + str(self.score))
     if 0 != self.highscore:
      cast('HGHSCORE: ' + str(self.highscore))
     for row in self.field:
      draw_hor_separator()
      draw_row(row)
     draw_hor_separator()
     if self.is_win():
      cast(win_string)
     else:
      if self.is_gameover():
      cast(gameover_string)
      else:
      cast(help_string1)
     cast(help_string2)
    #这里面的draw方法的字函数我就不做多的解释了,很简单的一些概念。
    #但是又运用到了很优秀的精简代码。
    #有的地方建议去查一下python的一些高级概念,我就不做多的介绍了。
    

    这里面的draw方法的字函数我就不做多的解释了,很简单的一些概念。
    但是又运用到了很优秀的精简代码。
    有的地方建议去查一下python的一些高级概念,我就不做多的介绍了。

    #读取用户输入得到action,判断是重启游戏还是结束游戏
    action = get_user_action(stdscr)
    

    读取用户行为,函数来自于代码初始的定义

    #来自外部定义的函数
    def get_user_action(keyboard): 
     char = "N"
     while char not in actions_dict: 
     char = keyboard.getch()
     return actions_dict[char]
    

    在结尾处,也即是主函数执行的第三步,定义了state = state_actionsstate这一实例:

    #主函数底部:
     state = 'Init'
     
     #状态机开始循环
     while state != 'Exit':
     state = state_actions[state]()
    
    responses = defaultdict(lambda: state) #默认是当前状态,没有行为就会一直在当前界面循环
    responses['Restart'], responses['Exit'] = 'Init', 'Exit' #对应不同的行为转换到不同的状态
    return responses[action]
    
    def game():
     #画出当前棋盘状态
     game_field.draw(stdscr)
     #读取用户输入得到action
     action = get_user_action(stdscr)
     
     if action == 'Restart':
      return 'Init'
     if action == 'Exit':
      return 'Exit'
     if game_field.move(action): # move successful
      if game_field.is_win():
      return 'Win'
      if game_field.is_gameover():
      return 'Gameover'
     return 'Game'
    #game()函数的定义类似于上面已经讲过的not_game(),只是game()有了内部循环
    #即如果不是Restart/Exit或者对move之后的状态进行判断,如果不是结束游戏,就一直在game()内部循环。
    

    game()函数的定义类似于上面已经讲过的not_game() ,只是game()有了内部循环,即如果不是Restart/Exit或者对move之后的状态进行判断,如果不是结束游戏,就一直在game()内部循环。

    state_actions = {
      'Init': init,
      'Win': lambda: not_game('Win'),
      'Gameover': lambda: not_game('Gameover'),
      'Game': game
       }
     
     curses.use_default_colors()
     game_field = GameField(win=32)
     
     
     state = 'Init'
     
     #状态机开始循环
     while state != 'Exit':
     state = state_actions[state]()
    #此处的意思是:state=state_actions[state] 可以看做是:
    #state=init()或者state=not_game(‘Win')或者是另外的not_game(‘Gameover')/game()
    

    此处的意思是:state=state_actions[state] 可以看做是:state=init()或者state=not_game(‘Win’)或者是另外的not_game(‘Gameover’)/game()

    废话不多说,上一个我的成功的图,另外,可以通过设置最后几行中的win=32来决定你最终获胜的条件!在这里插入图片描述
    完整代码

    #-*- coding:utf-8 -*-
    import curses
    from random import randrange, choice # generate and place new tile
    from collections import defaultdict
    letter_codes = [ord(ch) for ch in 'WASDRQwasdrq']
    actions = ['Up', 'Left', 'Down', 'Right', 'Restart', 'Exit']
    actions_dict = dict(zip(letter_codes, actions * 2))
    def transpose(field):
     return [list(row) for row in zip(*field)]
     
    def invert(field):
     return [row[::-1] for row in field]
     
    class GameField(object):
     def __init__(self, height=4, width=4, win=2048):
     self.height = height
     self.width = width
     self.win_value = win
     self.score = 0
     self.highscore = 0
     self.reset()
     
     def reset(self):
     if self.score > self.highscore:
      self.highscore = self.score
     self.score = 0
     self.field = [[0 for i in range(self.width)] for j in range(self.height)]
     self.spawn()
     self.spawn()
     
     def move(self, direction):
     def move_row_left(row):
      def tighten(row): # squeese non-zero elements together
      new_row = [i for i in row if i != 0]
      new_row += [0 for i in range(len(row) - len(new_row))]
      return new_row
     
      def merge(row):
      pair = False
      new_row = []
      for i in range(len(row)):
       if pair:
       new_row.append(2 * row[i])
       self.score += 2 * row[i]
       pair = False
       else:
       if i + 1 < len(row) and row[i] == row[i + 1]:
        pair = True
        new_row.append(0)
       else:
        new_row.append(row[i])
      assert len(new_row) == len(row)
      return new_row
      return tighten(merge(tighten(row)))
     
     moves = {}
     moves['Left'] = lambda field:    \
      [move_row_left(row) for row in field]
     moves['Right'] = lambda field:    \
      invert(moves['Left'](invert(field)))
     moves['Up'] = lambda field:    \
      transpose(moves['Left'](transpose(field)))
     moves['Down'] = lambda field:    \
      transpose(moves['Right'](transpose(field)))
     
     if direction in moves:
      if self.move_is_possible(direction):
      self.field = moves[direction](self.field)
      self.spawn()
      return True
      else:
      return False
     
     def is_win(self):
     return any(any(i >= self.win_value for i in row) for row in self.field)
     
     def is_gameover(self):
     return not any(self.move_is_possible(move) for move in actions)
     
     def draw(self, screen):
     help_string1 = '(W)Up (S)Down (A)Left (D)Right'
     help_string2 = ' (R)Restart (Q)Exit'
     gameover_string = '  GAME OVER'
     win_string = '  YOU WIN!'
     def cast(string):
      screen.addstr(string + '\n')
     
     def draw_hor_separator():
      line = '+' + ('+------' * self.width + '+')[1:]
      separator = defaultdict(lambda: line)
      if not hasattr(draw_hor_separator, "counter"):
      draw_hor_separator.counter = 0
      cast(separator[draw_hor_separator.counter])
      draw_hor_separator.counter += 1
     
     def draw_row(row):
      cast(''.join('|{: ^5} '.format(num) if num > 0 else '| ' for num in row) + '|')
     
     screen.clear()
     cast('SCORE: ' + str(self.score))
     if 0 != self.highscore:
      cast('HGHSCORE: ' + str(self.highscore))
     for row in self.field:
      draw_hor_separator()
      draw_row(row)
     draw_hor_separator()
     if self.is_win():
      cast(win_string)
     else:
      if self.is_gameover():
      cast(gameover_string)
      else:
      cast(help_string1)
     cast(help_string2)
     
     def spawn(self):
     new_element = 4 if randrange(100) > 89 else 2
     (i,j) = choice([(i,j) for i in range(self.width) for j in range(self.height) if self.field[i][j] == 0])
     self.field[i][j] = new_element
     
     def move_is_possible(self, direction):
     def row_is_left_movable(row): 
      def change(i): # true if there'll be change in i-th tile
      if row[i] == 0 and row[i + 1] != 0: # Move
       return True
      if row[i] != 0 and row[i + 1] == row[i]: # Merge
       return True
      return False
      return any(change(i) for i in range(len(row) - 1))
     
     check = {}
     check['Left'] = lambda field:    \
      any(row_is_left_movable(row) for row in field)
     
     check['Right'] = lambda field:    \
       check['Left'](invert(field))
     
     check['Up'] = lambda field:    \
      check['Left'](transpose(field))
     
     check['Down'] = lambda field:    \
      check['Right'](transpose(field))
     
     if direction in check:
      return check[direction](self.field)
     else:
      return False
    def main(stdscr):
     def init():
     #重置游戏棋盘
     game_field.reset()
     return 'Game'
     def not_game(state):
     #画出 GameOver 或者 Win 的界面
     game_field.draw(stdscr)
     #读取用户输入得到action,判断是重启游戏还是结束游戏
     action = get_user_action(stdscr)
     responses = defaultdict(lambda: state) #默认是当前状态,没有行为就会一直在当前界面循环
     responses['Restart'], responses['Exit'] = 'Init', 'Exit' #对应不同的行为转换到不同的状态
     return responses[action]
     
     def game():
     #画出当前棋盘状态
     game_field.draw(stdscr)
     #读取用户输入得到action
     action = get_user_action(stdscr)
     
     if action == 'Restart':
      return 'Init'
     if action == 'Exit':
      return 'Exit'
     if game_field.move(action): # move successful
      if game_field.is_win():
      return 'Win'
      if game_field.is_gameover():
      return 'Gameover'
     return 'Game'
     
     
     state_actions = {
      'Init': init,
      'Win': lambda: not_game('Win'),
      'Gameover': lambda: not_game('Gameover'),
      'Game': game
     }
     curses.use_default_colors()
     game_field = GameField(win=32)
     state = 'Init'
     #状态机开始循环
     while state != 'Exit':
     state = state_actions[state]()
    curses.wrapper(main)
    

    非常感谢你的阅读
    大学的时候选择了自学python,工作了发现吃了计算机基础不好的亏,学历不行这是没办法的事,只能后天弥补,于是在编码之外开启了自己的逆袭之路,不断的学习python核心知识,深入的研习计算机基础知识,整理好了,我放在我们的微信公众号《程序员学府》,如果你也不甘平庸,那就与我一起在编码之外,不断成长吧!

    其实这里不仅有技术,更有那些技术之外的东西,比如,如何做一个精致的程序员,而不是“屌丝”,程序员本身就是高贵的一种存在啊,难道不是吗?[点击加入]想做你自己想成为高尚人,加油!

    展开全文
  • ????“Python猫” ,一个值得加星标的公众号众所周知,升级某个库(假设为 xxx),可以用pip install --upgrade xxx 命令,或者简写成pip insta...

    ???? “Python猫” ,一个值得加星标的公众号

    众所周知,升级某个库(假设为 xxx),可以用pip install --upgrade xxx 命令,或者简写成pip install -U xxx

    如果有多个库,可以依次写在 xxx 后面,以空格间隔。那么,如何简单优雅地批量更新系统中全部已安装的库呢?

    接下来我们直奔主题,带大家学习几种方法/骚操作吧!

    方法一:pip list 结合 Linux 命令

    pip list 命令可以查询已安装的库,结合 Linux 的一些命令(cut、sed、awk、grep……),可以直接在命令行中实现批量升级。

    先查询一下,看看是什么格式的:

    可以看到,前两行是一些提示信息,我们需要从第 3 行开始过滤,那就可以使用awk 命令:

    python3 -m pip list | awk 'NR>=3{print}' | awk '{print $1}' | xargs python3 -m pip install -U
    

    解释一下这句命令的操作过程:先 list 查询,接着第一个 awk 取出行号大于等于 3 的内容,第二个 awk 取出第一列的内容,然后作为参数传给最后的升级命令。

    (PS:测试服务器上有不同版本的 Python,所以作了指定。关于“-m”的用法,推荐阅读:Python 中 -m 的典型用法、原理解析与发展演变

    pip 还支持查询已过期的库,即使用pip list --outdated 命令。默认情况下,查询出的格式跟pip list 相似,有效内容从第三行开始,大家可以试试。

    另外,我们还可以指定--format=freeze 格式,效果是这样的:

    这样的格式,可以用 cut 命令切割“=”号,然后取第一列:

    pip list --outdated --format=freeze | cut -d = -f 1 | xargs pip install -U
    

    以上命令在 Windows 系统中用不了。有没有更为通用的方法呢?

    方法二:使用 pip freeze

    如果是全量升级已安装的库,可以先用pip freeze 命令生成依赖文件,获取到已安装的库及其当前版本号:

    pip freeze > requirements.txt
    

    然后修改文件中的“==”为“>=”,接着执行:

    pip install -r requirements.txt --upgrade
    

    此方法比较适合于带有依赖文件的具体项目,可以针对该项目来升级所需的库。

    方法三:代码中调用 pip 的方法

    早期的 pip 库(<10.0.1)提供了 get_installed_distributions() 方法查询已安装的库,可以在代码中使用:

    # 只在早期 pip 版本中用
    import pip
    from subprocess import call
    
    packages = [dist.project_name for dist in pip.get_installed_distributions()]
    call("pip install --upgrade " + ' '.join(packages), shell=True)
    

    在较新版本中,此方法已被废弃,同样的功能要这样写:

    # 较新的 pip 版本。但不建议使用
    from subprocess import call
    from pip._internal.utils.misc import get_installed_distributions
    
    for dist in get_installed_distributions():
        call("pip install --upgrade " + dist.project_name, shell=True)
    

    但是,“_internal”带前缀下划线,表明它并不希望被导出使用。

    方法四:使用 pkg_resources 库

    跟方法二和三相似的还有一种方法。

    pkg_resourcessetuptools 库的一部分,用于查找和管理 Python 库、版本依赖关系、相关联的资源文件等。可以这样写:

    # 需要安装 setuptools
    import pkg_resources
    from subprocess import call
    
    packages = [dist.project_name for dist in pkg_resources.working_set]
    call("pip install --upgrade " + ' '.join(packages), shell=True)
    

    方法五:使用 pip-review 库

    pip-review 库是一个专门用来方便升级 Python 库的工具,可以查看已过期的库、自动升级或者交互式选择性地升级:

    还有一个类似的pip-upgrader 库,也是为了解决批量升级的问题,感兴趣的同学请自行搜索。

    方法六:pip 计划的全量升级命令

    pip 官方有计划要提供一个全量升级的(upgrade-all)命令,如果开发出来了,那应该会是最佳选择。

    然后,坏消息是这个计划被阻塞了近三年,目前 issue 仍处于 Open 状态,不知道何时能有进展。这里暂且一提吧,未来留意。

    前面介绍了六种方法,各有其适用的场景,小伙伴们都学会了么?

    除此之外,当然还有其它的方法,比如 stackoverflow 网站上有个“How to upgrade all Python packages with pip?”问题,其下就有比较多的回答。

    优质文章,推荐阅读:

    Python 小技巧:如何实现操作系统兼容性打包?

    玩转 Python 命令行:4 大主流工具库的对比

    Python 中 -m 的典型用法、原理解析与发展演变

    超详细 Pycharm 部署项目视频教程

    支持猫哥创作更多好文

    展开全文
  • python小技巧及速度提高

    千次阅读 2016-04-05 22:32:11
    Python 3: 1. 列表推导式 你有一个list:bag = [1, 2, 3, 4, 5] 现在你想让所有元素翻倍,让它看起来是这个样子:[2, 4, 6, 8, 10] 大多初学者,根据之前语言的经验会大概这样来做 bag = [1, 2, 3, 4...
  • /usr/bin/env python # -*- coding:UTF-8 -*- # @Time : 2020/10/26 0026 22:09 # @File : tst.py # @email : spirit_az@foxmail.com __author__ = 'ChenLiang.Miao' # +--+--+--+--+--+--+--+--+--+--+--+--+--+--...
  • 以500每英寸内的点数(其实就是提升了图片的像素,更容易看)来对图片进行存储,dpi适当变大,不就清晰多了。 plt.savefig(“1.jpg”, dpi=500)
  • 赶快收藏,好用到起飞的 30 个 Python 小技巧

    千次阅读 多人点赞 2021-11-28 09:41:47
    在本文中,我将向大家介绍 30 个简短、实用的 Python 技巧。内容较多,建议收藏学习,喜欢点赞支持,文末提供技术交流群。 1. All unique 下面的方法检查给定的列表是否有重复的元素,它使用 set() 的属性从列表中...
  • 下午有同学Python学习群里说,使用pyinstaller打包源码时,因为代码中使用了图像、音频、视频等资源文件,无法将程序打包成单一的可执行文件。有没有方法将这些资源文件按保存在代码中呢?我想了一下,应该是可以的...
  • 项目中涉及到的Python小技巧(1)——保存数据到TXTPython保存数据到.TXT文件1. 打开.txt文件**2. 读取.txt文件3. 写入.txt文件4. 清除.txt文件 由于现在原创的文章不够15篇,不够开专栏,所以只能这样来写。以后...
  • 当我跑一些模型的时候,通常是几个小时,这个时候我就会在代码的前面和后面加一句表示时间的话,总共是下面这三句: '''import XX import XX''' import time #第一句 print(time.strftime('%Y-%m-%d %H:%M:%S',time...
  • 主要介绍了常用的10个Python实用小技巧,帮助大家更好的理解和学习Python,感兴趣的朋友可以了解下
  • 如题,如何获取一个MP4文件格式的视频时长?嗯,对MP4格式的文件进行解析,如果有表示时长的字段,直接读取即可。而我对该格式又不熟悉该怎么办?当然是使用搜索引擎了。果不其然,看到了这个字...
  • 我们在对字典进行操作时,比如要比较大小或者排序这些操作,对于字典的键是可以的,但无法对值进行直接操作,比如下面的字典, price={ 'apple':20.59, 'BERKSHIRE':280000, 'amazon':296, 'alibaba':365 ...
  • Python小技巧 - argmax

    万次阅读 2019-03-31 04:34:14
    argmax 返回的是输入列表中最大值的位置,其重要性不必多言,但是据我所知 Python 自带的库中只提供 max 这个函数,并没有 argmax,但是实现起来不难。
  • s=‘hello! my word’ print s.split() #输出结果为[‘hello!’, ‘my’, ‘word’]
  • 前言 把这个文件导入到python自带的IDE下,再按TAB键就会有提示,需要readline库,在新的版本中,可能名字是gnureadline库, ...也可以在pipy.python.org下载源码进行 /opt/python35/bin/python3 setup.py install ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 93,960
精华内容 37,584
关键字:

python小技巧

python 订阅