Python 能做很多无聊,但有意思的事情,例如接下来的一些案例。
Python 整蛊程序
以下程序,不要发代码,要不实现不了你整蛊的目的。
要打包成一个 exe 程序,发给朋友才有意思。
使用 pip install pyinstaller。
打包命令如下:
pyinstaller -F 文件名.py
过程中如果出现 BUG(一般是编码错误),点击导航查看解决方案
有趣的代码一
while True:
n = input("猜猜我在想啥?")
print("猜错喽")
123
你的朋友将永远无法知道你在想什么。
当然我安装 360 之后,程序没了。
有趣的代码二
死命弹窗
import tkinter.messagebox
while True:
tkinter.messagebox.showerror('Windows 错误','你的电脑正在被攻击!')
1234
运行之后,很就刺激了,如果对方不会杀进程,更刺激。
有趣的代码三
调用默认浏览器,无限打开 CSDN ,让他爱上学习。
import webbrowser
while True:
webbrowser.open('www.csdn.net')
123
额,使用之后,阿喵自己的电脑死机了。
瞬间 CPU...
有趣的代码四
这个程序就动感多了,会随机出现弹窗。
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
运行效果如下图所示,非常带劲,可以任意修改。
有趣的代码五
该程序在阿喵看来能排到第一,甚至可以和当下最火的枪茅台案例结合一下。
'''
学习中遇到问题没人解答?小编创建了一个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
截图如下:
按照 BUG 提示的位置,修改下述代码:
out = out.decode(encoding) # 改为 out = out
打包成功在 dist 文件中找寻 exe 程序即可。
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()
加减乘除示例
我们使用函数实现一个基本的加减乘除运算。
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()
发现定义函数可以实现代码的多次复用。
多个返回值某些情况下,我们需要一个函数返回多个值,Python 也是支持的。
#定义多个返回值函数def more(a, b): na = a + 2 nb = b - 2 return na, nb#调用函数a, b = more(10, 10)print(a, b)
递归函数
有时候我们需要反复调用某个函数得到一个最后的值,这个时候使用递归函数是最好的解决方案。
编程语言中,函数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)用递归的方式写出来就是:
版权声明:本文为博主原创文章,未经博主允许不得转载。
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 使用 next 和 iter 魔术方法使自身可迭代(变为了可迭代对象)。
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 代码使用列表和字典解析式来实现 map
和 filter
,这些表达式的核心与 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_list
、 tmp_tuple
、 tmp_set
、 tmp_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 操作符查找的平均时间复杂度如下:
当我们在处理数据量大且需频繁查找元素时,最好使用 set、dict ,这样将会大幅度提升处理速度。
Original: https://www.cnblogs.com/djdjdj123/p/16566682.html
Author: Python探索牛
Title: Python在不同对象中使用 in 操作符的查找效率