5个非常有意思的python代码,谁运行谁知道

Python58

Python 能做很多无聊,但有意思的事情,例如接下来的一些案例。

Python 整蛊程序

以下程序,不要发代码,要不实现不了你整蛊的目的。

要打包成一个 exe 程序,发给朋友才有意思。

使用 pip install pyinstaller。

打包命令如下:

pyinstaller -F 文件名.py

过程中如果出现 BUG(一般是编码错误),点击导航查看解决方案

有趣的代码一

while True:
    n = input("猜猜我在想啥?")
    print("猜错喽")
123

你的朋友将永远无法知道你在想什么。

当然我安装 360 之后,程序没了。
5个非常有意思的python代码,谁运行谁知道

有趣的代码二

死命弹窗

import tkinter.messagebox

while True:
    tkinter.messagebox.showerror('Windows 错误','你的电脑正在被攻击!')
1234

运行之后,很就刺激了,如果对方不会杀进程,更刺激。
5个非常有意思的python代码,谁运行谁知道

有趣的代码三

调用默认浏览器,无限打开 CSDN ,让他爱上学习。

import webbrowser
while True:
    webbrowser.open('www.csdn.net')
123

5个非常有意思的python代码,谁运行谁知道
额,使用之后,阿喵自己的电脑死机了。

瞬间 CPU...

5个非常有意思的python代码,谁运行谁知道

有趣的代码四

这个程序就动感多了,会随机出现弹窗。

import tkinter as tk
import random
import threading
import time

def boom():
    window = tk.Tk()
    width = window.winfo_screenwidth()
    height = window.winfo_screenheight()
    a = random.randrange(0, width)
    b = random.randrange(0, height)
    window.title('你是一个傻狍子')
    window.geometry("200x50" + "+" + str(a) + "+" + str(b))
    tk.Label(window, text='你是一个傻狍子', bg='green',
             font=('宋体', 17), width=20, height=4).pack()
    window.mainloop()

threads = []
for i in range(100):
    t = threading.Thread(target=boom)
    threads.append(t)
    time.sleep(0.1)
    threads[i].start()
12345678910111213141516171819202122232425

运行效果如下图所示,非常带劲,可以任意修改。
5个非常有意思的python代码,谁运行谁知道

有趣的代码五

该程序在阿喵看来能排到第一,甚至可以和当下最火的枪茅台案例结合一下。

'''
学习中遇到问题没人解答?小编创建了一个Python学习交流群:857662006
寻找有志同道合的小伙伴,互帮互助,群里还有不错的视频学习教程和PDF电子书!
'''
import os
import time
a = """

     oooo oooooooooo.            .oooooo..o                     oooo         o8o  oooo  oooo
     `888 `888'   `Y8b          d8P'    `Y8                     `888         `"'  `888  `888
     888  888      888         Y88bo.       .ooooo.   .ooooo.   888  oooo  oooo   888   888
     888  888      888          `"Y8888o.  d88' `88b d88' `"Y8  888 .8P'   `888   888   888
     888  888      888 8888888      `"Y88b 888ooo888 888        888888.     888   888   888
     888  888     d88'         oo     .d8P 888    .o 888   .o8  888 `88b.   888   888   888
.o. 88P o888bood8P'           8""88888P'  `Y8bod8P' `Y8bod8P' o888o o888o o888o o888o o888o
`Y888P

功能列表:
1.预约商品
2.秒杀抢购商品
"""
print(a)

key = input("请选择:")

if key == "1":
     time.sleep(1.5)
     print('没有预约到\n')
     time.sleep(3)
     print('没事的,来抱一哈\n')

else:
     print("既然如此...")
     time.sleep(3)
     print("那你想得美~~~~~")
     os.system('shutdown -r -t 10')
time.sleep(10)
123456789101112131415161718192021222324252627282930313233

别运行,运行之后别怪我。

pyinstaller 编码 BUG
在使用 pyinstaller 进行打包 exe 的时候,会出现如下错误:


  File "c:\users\administrator\appdata\local\programs\python\python37\lib\site-packages\PyInstaller\utils\hooks\__init__.py", line 68, in __exec_python_cmd
    txt = exec_python(*cmd, env=pp_env)
  File "c:\users\administrator\appdata\local\programs\python\python37\lib\site-packages\PyInstaller\compat.py", line 526, in exec_python
    return exec_command(*cmdargs, **kwargs)
  File "c:\users\administrator\appdata\local\programs\python\python37\lib\site-packages\PyInstaller\compat.py", line 321, in exec_command
    out = out.decode(encoding)
AttributeError: 'str' object has no attribute 'decode'
1234567

截图如下:
5个非常有意思的python代码,谁运行谁知道
按照 BUG 提示的位置,修改下述代码:

out = out.decode(encoding) # 改为  out = out

打包成功在 dist 文件中找寻 exe 程序即可。
5个非常有意思的python代码,谁运行谁知道

Original: https://www.cnblogs.com/djdjdj123/p/16167495.html
Author: Python探索牛
Title: 5个非常有意思的python代码,谁运行谁知道



相关阅读1

Title: Python第5天--函数

函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段,所以我经常说函数是程序员规模化使用的基础。

函数能提高应用的模块性,和代码的重复利用率。在程序设计中,常将一些常用的功能模块编写成函数,放在函数库中供公共选用。善于利用函数,可以减少重复编写程序段的工作量。​

如何定义一个函数
定义一个函数有如下几个步骤​​​​

函数代码块以 def 关键词开头,后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始,并且缩进。
return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
语法

def 函数名(参数列表):    函数体

默认情况下,参数值和参数名称是按函数声明中定义的顺序匹配起来的。
简单示例
一个最简单的函数示例:

def hello() :   print("Hello World!")def main():    hello()if __name__ == "__main__":    main()

再来一个代参数的示例:

def hello(name) :   print("Hello World!", name)def main():    hello('neo')if __name__ == "__main__":    main()

5个非常有意思的python代码,谁运行谁知道

加减乘除示例
我们使用函数实现一个基本的加减乘除运算。

def add(a,b) :   return a+bdef reduce(a,b) :   return a-bdef multiply(a,b) :   return a*bdef divide(a,b) :   return a/bdef main():    print(add(8, 8))    print(reduce(88, 8))    print(multiply(8, 2))    print(divide(18, 9))if __name__ == "__main__":    main()

5个非常有意思的python代码,谁运行谁知道

发现定义函数可以实现代码的多次复用。

多个返回值某些情况下,我们需要一个函数返回多个值,Python 也是支持的。

#定义多个返回值函数def more(a, b):    na = a + 2    nb = b - 2    return na, nb#调用函数a, b = more(10, 10)print(a, b)

5个非常有意思的python代码,谁运行谁知道

递归函数
有时候我们需要反复调用某个函数得到一个最后的值,这个时候使用递归函数是最好的解决方案。

编程语言中,函数Func(Type a,......)直接或间接调用函数本身,则该函数称为递归函数。递归函数不能定义为内联函数​

举个例子,我们来计算阶乘n! = 1 x 2 x 3 x ... x n,用函数fact(n)表示,可以看出:
fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n
所以,fact(n)可以表示为n x fact(n-1),只有n=1时需要特殊处理。

于是,fact(n)用递归的方式写出来就是:

5个非常有意思的python代码,谁运行谁知道

版权声明:本文为博主原创文章,未经博主允许不得转载。

Python

Original: https://blog.51cto.com/u_15735145/5533549
Author: wx62e28ac222a20
Title: Python第5天--函数

相关阅读2

Title: 通过 for 循环,比较 Python 与 Ruby 编程思想的差别

作者:Doug Turnbull

译者:豌豆花下猫@Python猫

Ruby 与 Python 之间的差异在很大程度上可通过 for 循环看出本质。

Python 拥有 for语句。对象告诉 for如何进行协作,而 for的循环体会处理对象返回的内容。

Ruby 则相反。在 Ruby 中, for 本身(通过 each)是对象的一个方法。调用者将 for循环体传递给这个方法。

在 Python 的语言习惯中,对象模型服从于 for 循环。而在 Ruby 中,for 循环服从于对象模型。

也就是说,在 Python 中,如果你想自定义迭代的过程,可以让对象告诉解释器该如何作迭代:

class Stuff:
    def __init__(self):
        self.a_list = [1,2,3,4]
        self.position = 0
    def __next__(self):
        try:
            value = self.a_list[self.position]
            self.position += 1
            return value
        except IndexError:
            self.position = 0
            raise StopIteration
    def __iter__(self):
        return self

在这里,Stuff 使用 nextiter 魔术方法使自身可迭代(变为了可迭代对象)。

for data in Stuff():
    print(data)

然而,在 Ruby 的用法中,你要做的恰恰相反。你要将 for 创建成一个方法,它接收代码(body 体)来运行。Ruby 将过程代码放在代码块中,这样它们就可以被用于传递。

然后,在 each方法中,使用 yield与代码块进行交互,将值传递给代码块来做你需要做的事情(对于任何方法,代码块都是一种隐式参数)。

如果我们重写上面的代码,会成这样:

class Stuff
  def initialize
    @a_list = [1, 2, 3, 4]
  end

  def each
    for item in @a_list
      yield item
    end
  end
end

使用 each进行迭代:

Stuff.new().each do |item|
  puts item
end

不是将数据传给 for 循环(Python),而是将循环代码传给数据(Ruby)。

但区别还远不止于此:

Python 构建类似于 for 的结构,用于各种处理;Ruby 将数据处理工作放到方法中。

优秀的 Python 代码使用列表和字典解析式来实现 mapfilter,这些表达式的核心与 for/迭代的语义是相同的。

In [2]: [item for item in Stuff()]
Out[2]: [1, 2, 3, 4]

In [3]: [item for item in Stuff() if item % 2 == 0]
Out[3]: [2, 4]

Ruby 则继续使用方法优先的方式,除了 each 方法,还有一系列常用于处理集合的新方法,如下所示:

class Stuff
  ...

  def select
    out = []
    each do |e|
      # If block returns truthy on e, append to out
      if yield(e)
        out << e
      end
    end
    out
  end

  def map
    out = []
    # One line block syntax, append output of block processed on e to out
    each {|e| out << yield(e) }
    out
end
puts Stuff.new().map {|item| item}
puts Stuff.new().select{|item| item.even?}

Python 说:"你告诉我们如何迭代你的实例,我们将决定如何处理你的数据。" Python 有一些基于语言的用作迭代和处理的原语,如果要自定义迭代,只需将正确的代码添加到 for 循环体(或表达式)中。

Ruby 反转了剧本,赋予对象更深层的可定制性。是的,在某些情况下,我们可以在代码块中添加更多的控制流。是的,我们也可以把 each 方法用来做 map。但是 Ruby 允许对象们实现不同的 map 和 each(如果将"each"的实现用于"map",可能会非常不理想,甚至不安全)。Ruby 的对象在处理其数据方面,有着更好的方法。

在 Ruby 中,对象控制着功能可见性。而在 Python 中,是语法做着控制。

地道的 Python 对数据处理有着强势的看法。Python 说:"看,90% 的代码都能很好地融入这些想法,只要遵从它,完成工作就行了。"把你的对象变成可以 for-循环的,别再烦我了。

然而 Ruby 说:"在一些重要的情况下,我们不想给调用者太多能力。"所以 Ruby 让对象去控制它们被处理的方式,并要求开发人员遵循对象想要被交互的方式。Ruby 在数据处理上没那么强势。

Python 更像是基于 C 语言的"面向对象"编程的扩展。在基于 C 的 OO 中,就像 posix 文件描述符或 Win32 窗口句柄一样,语言并不强制将"方法"与对象本身绑定。相反,对象到方法的绑定只是基于约定。

Python 认为这个过程世界是可以进化的——它升级了这种思维方式,使之更安全。自由函数是存在的(Python猫注:应该指的是内置函数,因不依赖于任何类对象,故是"自由的"),而且确实经常比对象方法更受推荐。对象是存在的,但以一种相对犹豫的方式。

类方法接收"self"作为其第一个参数,几乎与 Win32 或 Posix API 中的 C 函数接受句柄的方式相同。当函数被传递时,它们几乎被当作 C 函数指针来对待。

Python 认为程序范式(procedural paradigm)是最重要的,它是一切的关键基础,在它之上是面向对象的语义层。

然而,Ruby 却将其颠倒过来。Ruby 将面向对象作为金字塔的基础。Ruby 在代码块中包含了混乱的过程世界,让对象使用这些过程块。

Ruby 并没有为了遵循语言的过程性基础而破坏对象,而是使过程性代码适应对象的世界观。Ruby 有真正的私有方法,不像 Python 的私有方法/参数,只是出于约定。

毫无疑问,当我从系统编程的角度接触 Python 时,它对我的观感来说是很自然的。具备着在必要的时候编写 C 语言的能力,它进化了,令那个世界更加安全。也许这就是为什么它在系统资源密集的数值计算领域中,找到了用武之地。

难怪 Ruby 很适合开发人员构建更流畅、也许更安全的 API 和 DSL。Ruby 希望程序员对领域进行建模,而不是对编程环境进行建模,这对于许多工作来说,似乎是正确的方法。

Original: https://www.cnblogs.com/pythonista/p/15594936.html
Author: 豌豆花下猫
Title: 通过 for 循环,比较 Python 与 Ruby 编程思想的差别

相关阅读3

Title: Python在不同对象中使用 in 操作符的查找效率

前言

在Python中 in 操作符可以用于判断某个元素是否存在于当前对象中,而对于不同的Python对象,使用 in 操作符的处理效率是不一样的。

今天我们主要针对 4 种不同的Python数据类型进行学习:list列表、tuple元组、set集合、dict字典。

测试过程

我们用于测试的 4 种Python数据类型,分别为 tmp_listtmp_tupletmp_settmp_dict,测试过程中,它们所包含的元素都是相同的,均通过 random.randint(0, num) 随机生成,但它们的长度均为 num - 3 ,也就是说在 [0, num] 范围内,将有3个整数不在上面的对象中,我们需要把这3个整数找出来。

测试代码如下:

import time
import random

def demo(target, num):
    time1 = time.time()
    res = []
    for i in range(num):
        if i not in target:
            res.append(i)
    time2 = time.time()
    print("结果:{},当前类型:{},耗时:{}".format(res, type(target), time2 - time1))

num = 500
tmp_set = set()
while len(tmp_set)

当 num = 50 时,得到如下结果:

不包含的整数:[25, 31, 36],当前类型:,耗时:0.0
不包含的整数:[25, 31, 36],当前类型:,耗时:0.0
不包含的整数:[25, 31, 36],当前类型:,耗时:0.0
不包含的整数:[25, 31, 36],当前类型:,耗时:0.0

当 num = 500 时,得到如下结果:

不包含的整数:[114, 329, 355],当前类型:,耗时:0.0059354305267333984
不包含的整数:[114, 329, 355],当前类型:,耗时:0.0052182674407958984
不包含的整数:[114, 329, 355],当前类型:,耗时:0.0
不包含的整数:[114, 329, 355],当前类型:,耗时:0.0

当 num = 5000 时,得到如下结果:

不包含的整数:[445, 850, 3547],当前类型:,耗时:0.3342933654785156
不包含的整数:[445, 850, 3547],当前类型:,耗时:0.39918947219848633
不包含的整数:[445, 850, 3547],当前类型:,耗时:0.00099945068359375
不包含的整数:[445, 850, 3547],当前类型:,耗时:0.0

当 num = 50000 时,得到如下结果:

不包含的整数:[9296, 18652, 32281],当前类型:,耗时:26.92029118537903
不包含的整数:[9296, 18652, 32281],当前类型:,耗时:25.956974506378174
不包含的整数:[9296, 18652, 32281],当前类型:,耗时:0.009968996047973633
不包含的整数:[9296, 18652, 32281],当前类型:,耗时:0.009973287582397461

当 num = 55000 时,得到如下结果:

不包含的整数:[16086, 33891, 46161],当前类型:,耗时:52.91718029975891
不包含的整数:[16086, 33891, 46161],当前类型:,耗时:52.84810948371887
不包含的整数:[16086, 33891, 46161],当前类型:,耗时:0.009554624557495117
不包含的整数:[16086, 33891, 46161],当前类型:,耗时:0.007979393005371094

当 num = 75000 时,得到如下结果:

不包含的整数:[23057, 35827, 69232],当前类型:,耗时:75.57932734489441
不包含的整数:[23057, 35827, 69232],当前类型:,耗时:64.49729013442993
不包含的整数:[23057, 35827, 69232],当前类型:,耗时:0.005983591079711914
不包含的整数:[23057, 35827, 69232],当前类型:,耗时:0.005979776382446289

当 num = 100000 时,得到如下结果:

'''
学习中遇到问题没人解答?小编创建了一个Python学习交流群:711312441
寻找有志同道合的小伙伴,互帮互助,群里还有不错的视频学习教程和PDF电子书!
'''
不包含的整数:[22499, 22800, 29652],当前类型:,耗时:110.19707798957825
不包含的整数:[22499, 22800, 29652],当前类型:,耗时:109.08251285552979
不包含的整数:[22499, 22800, 29652],当前类型:,耗时:0.011965036392211914
不包含的整数:[22499, 22800, 29652],当前类型:,耗时:0.009937524795532227

结论

通过上面的测试,我们可以看到,总体来说,list、tuple它们使用 in 操作符的查找效率相差不多,set、dict它们使用 in 操作符的查找效率相差不多,但随着查找数据量的增大,list、tuple的处理效率变得越来越慢,而set、dict的处理效率,将远远优于list及tuple。

list列表、tuple元组、set集合、dict字典,使用 in 操作符查找的平均时间复杂度如下:

5个非常有意思的python代码,谁运行谁知道
当我们在处理数据量大且需频繁查找元素时,最好使用 set、dict ,这样将会大幅度提升处理速度。

Original: https://www.cnblogs.com/djdjdj123/p/16566682.html
Author: Python探索牛
Title: Python在不同对象中使用 in 操作符的查找效率