程序员的你，有哪些炫技的代码写法？
作为一名在代码世界里摸爬滚打多年的老兵，我脑子里盘踞着不少“不正经”的写法，它们不像教科书里那样一丝不苟，但有时候，就是能在不经意间闪耀出那么一丝……嗯，怎么说呢，就像是给枯燥的流水线作业加了个花边，或是让一份普通的请柬变得有些小小的仪式感。
我不敢说这是什么“炫技”，毕竟代码的终极目标是清晰、可维护、高效。但不得不承认，在某些特定时刻，一些“技巧”确实能带来那么一点点成就感，或者说，一种属于程序员的小小“恶趣味”。
这里我挑几个我自己印象比较深刻的，尽量讲得细致点，也尽量不让它们听起来那么“AI”化，毕竟我写这些东西的时候，脑子里想的是怎么让这堆字符变得有点意思，而不是怎么堆砌华丽的辞藻。
1. 巧用语言特性实现“一语双关”或“微缩表达”
这不一定是写得最“好”的代码，但绝对是最有“味道”的。很多语言都有一些特别的语法糖或者特性，我们可以把它掰开了揉碎了用，让一行代码承载多重含义，或者把原本需要几行的逻辑压缩到极致。
例子一：Python 的列表推导式和 `any`/`all` 的组合，模拟简单的模式匹配
假设我们要检查一个列表中是否存在所有元素都满足某个条件的情况，比如一个数字列表里是否所有数字都大于10。
传统的写法可能是这样的：
```python
numbers = [15, 20, 12, 8]
all_greater_than_10 = True
for num in numbers:
if num <= 10:
all_greater_than_10 = False
break
print(all_greater_than_10) False
```
这很直观，也没问题。但有时候，我会觉得它有点啰嗦。Python 的列表推导式和内置函数 `all()` 就能把这件事做得更精炼：
```python
numbers = [15, 20, 12, 8]
all_greater_than_10 = all(num > 10 for num in numbers)
print(all_greater_than_10) False
```
你看，`all(num > 10 for num in numbers)` 这部分，它就像一个内联的循环，同时完成了条件的判断和结果的聚合。`num > 10 for num in numbers` 本身是一个生成器表达式，它按需产生 `True` 或 `False` 的值，而 `all()` 函数则负责在遇到第一个 `False` 时就停止，或者在所有都为 `True` 时返回 `True`。这种写法，感觉像是把一整段逻辑给“凝练”了，少了很多临时变量的声明和 `if/break` 的控制流，读起来有一种“嗖”一下就明白了的爽快感。
再比如，检查是否至少有一个元素满足条件，那就用 `any()`：
```python
numbers = [5, 12, 3, 9]
any_greater_than_10 = any(num > 10 for num in numbers)
print(any_greater_than_10) True
```
这种写法在处理一些配置项的检查、数据验证、或者查找特定模式时非常有用。它不仅代码量少了，而且那种“一步到位”的感觉，让我想起武侠小说里那种干净利落的招式。当然，如果逻辑复杂到需要多步判断，硬要用推导式来挤，反而会适得其反，变成“聪明反被聪明误”。所以，关键在于恰到好处。
2. 利用函数式编程的“组合”与“惰性求值”
这方面，JavaScript 和 Haskell 等语言是天然的舞台。不过，即便是在 Python 这样的混合式语言里，我们也能玩出点花样。
例子二：JavaScript 的链式调用与高阶函数，模拟数据转换管道
设想我们有一系列对数据的操作，比如从一个数组中过滤出偶数，然后将每个偶数乘以2，最后将结果映射回一个新的数组。
传统的命令式写法：
```javascript
const numbers = [1, 2, 3, 4, 5, 6];
const processedNumbers = [];
for (const num of numbers) {
if (num % 2 === 0) {
processedNumbers.push(num 2);
}
}
console.log(processedNumbers); // [4, 8, 12]
```
用函数式风格来写，特别是利用 `filter`, `map`, `reduce` 等方法：
```javascript
const numbers = [1, 2, 3, 4, 5, 6];
const processedNumbers = numbers
.filter(num => num % 2 === 0) // 过滤出偶数
.map(evenNum => evenNum 2); // 每个偶数乘以2
console.log(processedNumbers); // [4, 8, 12]
```
这里的“炫技”在于那种“管道化”的思维。我们不再关注“如何一步一步做”，而是定义“做了什么操作”。`filter` 返回一个新数组，`map` 再处理这个新数组，这种链式调用让代码像是在描述一个数据处理的流程图，清晰、模块化。
更进一步，如果我们想实现所谓的“惰性求值”，也就是不到万不得已不进行实际计算，那么配合生成器（Generators）和一些库（比如 Lodash/Ramda 的一些特性，或者直接用生成器手动控制），可以做到更极致。
例如，假设我们有一个非常大的数字列表，并且我们只需要前N个处理过的偶数。
```javascript
function processNumbers(numbers) {
for (const num of numbers) {
if (num % 2 === 0) {
yield num 2; // yield在这里是关键
}
}
}
const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const processor = processNumbers(numbers);
console.log(processor.next().value); // 4 (只计算了第一个偶数)
console.log(processor.next().value); // 8 (计算了第二个偶数)
```
这里，`processNumbers` 函数返回的是一个生成器对象，它并不会立即执行所有操作。只有当我们调用 `next()` 方法时，代码才会执行到下一个 `yield` 语句。这意味着，即使列表有千万条数据，只要我们只取前面几个结果，实际计算也只会发生在需要的那一部分。这种“按需生成”的能力，在处理大数据、流式数据时，能极大地节省内存和计算资源。这感觉就像是把一个巨大的工厂流程拆解成了一个个独立的工序，只有当你需要成品时，工厂才会启动相应的机器，而且只生产你需要的数量。
3. 利用位运算做一些“意想不到”的事情
位运算是比较底层的操作，很多时候在性能敏感的场景下会用到。但有时候，它也能创造出一些简洁得让人拍案叫绝的写法。
例子三：利用位运算进行布尔标志管理或特定计算
假设我们需要管理一组互斥的或者可以组合的标志，比如在一个用户权限系统中，读、写、执行权限。
传统的做法可能是用布尔变量：
```python
has_read = True
has_write = False
has_execute = True
if has_read and has_write:
print("Can read and write")
```
使用位运算，我们可以用一个整数来表示所有标志的状态：
```python
定义标志位
READ_PERMISSION = 1 << 0 0001 (二进制)
WRITE_PERMISSION = 1 << 1 0010 (二进制)
EXECUTE_PERMISSION = 1 << 2 0100 (二进制)
user_permissions = 0 初始状态，没有任何权限
赋予读和执行权限
user_permissions |= READ_PERMISSION 0001 | 0000 = 0001
user_permissions |= EXECUTE_PERMISSION 0001 | 0100 = 0101 (二进制，十进制是5)
检查权限
can_read = (user_permissions & READ_PERMISSION) != 0 0101 & 0001 = 0001, 不为0即有读权限
can_write = (user_permissions & WRITE_PERMISSION) != 0 0101 & 0010 = 0000, 为0即无写权限
can_execute = (user_permissions & EXECUTE_PERMISSION) != 0 0101 & 0100 = 0100, 不为0即有执行权限
print(f"Can read: {can_read}") True
print(f"Can write: {can_write}") False
print(f"Can execute: {can_execute}") True
```
这里的“炫技”在于，你可以用一个整数变量管理多个布尔状态，而且检查和设置都非常高效（位运算通常比逻辑运算和变量切换更快）。更牛的是，你可以用按位或 `|` 来组合权限，用按位与 `&` 来检查权限，用按位异或 `^` 来切换权限（比如按下一次按钮是打开某个功能，再按一次是关闭）。
例如，切换执行权限：
```python
user_permissions ^= EXECUTE_PERMISSION 0101 ^ 0100 = 0001 (执行权限被关闭)
can_execute = (user_permissions & EXECUTE_PERMISSION) != 0
print(f"After toggling execute: Can execute: {can_execute}") False
```
这种写法在一些嵌入式系统、操作系统内核、或者图形渲染等需要极致优化的场景非常常见。它把一个可能需要多个变量、多个 `if` 语句才能完成的逻辑，压缩成了一行行的位运算，显得非常精炼和“酷”。当然，这种写法可读性会下降不少，需要对二进制和位运算有一定理解才能读懂，所以一般只在性能要求极高且团队成员都熟悉这种模式时使用。
最后想说的话
这些所谓的“炫技”，我更愿意称之为“探索语言的可能性”。它们不是为了写出别人看不懂的代码，而是为了在特定场景下，找到一种更优雅、更高效、或者更有趣的表达方式。
清晰永远是第一位的：如果一段“炫技”的代码让别人看了半天不明白你在做什么，那它就是失败的。代码首先是给人看的，其次才是给机器执行的。
场景决定一切：这些技巧不是万能药，用在不合适的场景，只会是画蛇添足。
持续学习与实践：语言特性在不断发展，新的模式和技巧也在不断涌现。保持好奇心，不断尝试和学习，才能在编程的道路上走得更远，也更有趣。
所以，这些写法对我来说，更像是在代码里藏着的小小的“彩蛋”，偶尔触发一下，给枯燥的开发过程增添一点乐趣。真正的“炫技”，可能是在解决复杂问题时，那种用最简洁、最清晰、最巧妙的方式达到目标的“顿悟”时刻吧。而这些小技巧，可能就是通往那个顿悟时刻的垫脚石。
我不敢说这是什么“炫技”，毕竟代码的终极目标是清晰、可维护、高效。但不得不承认，在某些特定时刻，一些“技巧”确实能带来那么一点点成就感，或者说，一种属于程序员的小小“恶趣味”。
这里我挑几个我自己印象比较深刻的，尽量讲得细致点，也尽量不让它们听起来那么“AI”化，毕竟我写这些东西的时候，脑子里想的是怎么让这堆字符变得有点意思，而不是怎么堆砌华丽的辞藻。
1. 巧用语言特性实现“一语双关”或“微缩表达”
这不一定是写得最“好”的代码，但绝对是最有“味道”的。很多语言都有一些特别的语法糖或者特性，我们可以把它掰开了揉碎了用，让一行代码承载多重含义，或者把原本需要几行的逻辑压缩到极致。
例子一：Python 的列表推导式和 `any`/`all` 的组合，模拟简单的模式匹配
假设我们要检查一个列表中是否存在所有元素都满足某个条件的情况，比如一个数字列表里是否所有数字都大于10。
传统的写法可能是这样的：
```python
numbers = [15, 20, 12, 8]
all_greater_than_10 = True
for num in numbers:
if num <= 10:
all_greater_than_10 = False
break
print(all_greater_than_10) False
```
这很直观，也没问题。但有时候，我会觉得它有点啰嗦。Python 的列表推导式和内置函数 `all()` 就能把这件事做得更精炼：
```python
numbers = [15, 20, 12, 8]
all_greater_than_10 = all(num > 10 for num in numbers)
print(all_greater_than_10) False
```
你看，`all(num > 10 for num in numbers)` 这部分，它就像一个内联的循环，同时完成了条件的判断和结果的聚合。`num > 10 for num in numbers` 本身是一个生成器表达式，它按需产生 `True` 或 `False` 的值，而 `all()` 函数则负责在遇到第一个 `False` 时就停止，或者在所有都为 `True` 时返回 `True`。这种写法，感觉像是把一整段逻辑给“凝练”了，少了很多临时变量的声明和 `if/break` 的控制流，读起来有一种“嗖”一下就明白了的爽快感。
再比如，检查是否至少有一个元素满足条件，那就用 `any()`：
```python
numbers = [5, 12, 3, 9]
any_greater_than_10 = any(num > 10 for num in numbers)
print(any_greater_than_10) True
```
这种写法在处理一些配置项的检查、数据验证、或者查找特定模式时非常有用。它不仅代码量少了，而且那种“一步到位”的感觉，让我想起武侠小说里那种干净利落的招式。当然，如果逻辑复杂到需要多步判断，硬要用推导式来挤，反而会适得其反，变成“聪明反被聪明误”。所以，关键在于恰到好处。
2. 利用函数式编程的“组合”与“惰性求值”
这方面，JavaScript 和 Haskell 等语言是天然的舞台。不过，即便是在 Python 这样的混合式语言里，我们也能玩出点花样。
例子二：JavaScript 的链式调用与高阶函数，模拟数据转换管道
设想我们有一系列对数据的操作，比如从一个数组中过滤出偶数，然后将每个偶数乘以2，最后将结果映射回一个新的数组。
传统的命令式写法：
```javascript
const numbers = [1, 2, 3, 4, 5, 6];
const processedNumbers = [];
for (const num of numbers) {
if (num % 2 === 0) {
processedNumbers.push(num 2);
}
}
console.log(processedNumbers); // [4, 8, 12]
```
用函数式风格来写，特别是利用 `filter`, `map`, `reduce` 等方法：
```javascript
const numbers = [1, 2, 3, 4, 5, 6];
const processedNumbers = numbers
.filter(num => num % 2 === 0) // 过滤出偶数
.map(evenNum => evenNum 2); // 每个偶数乘以2
console.log(processedNumbers); // [4, 8, 12]
```
这里的“炫技”在于那种“管道化”的思维。我们不再关注“如何一步一步做”，而是定义“做了什么操作”。`filter` 返回一个新数组，`map` 再处理这个新数组，这种链式调用让代码像是在描述一个数据处理的流程图，清晰、模块化。
更进一步，如果我们想实现所谓的“惰性求值”，也就是不到万不得已不进行实际计算，那么配合生成器（Generators）和一些库（比如 Lodash/Ramda 的一些特性，或者直接用生成器手动控制），可以做到更极致。
例如，假设我们有一个非常大的数字列表，并且我们只需要前N个处理过的偶数。
```javascript
function processNumbers(numbers) {
for (const num of numbers) {
if (num % 2 === 0) {
yield num 2; // yield在这里是关键
}
}
}
const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const processor = processNumbers(numbers);
console.log(processor.next().value); // 4 (只计算了第一个偶数)
console.log(processor.next().value); // 8 (计算了第二个偶数)
```
这里，`processNumbers` 函数返回的是一个生成器对象，它并不会立即执行所有操作。只有当我们调用 `next()` 方法时，代码才会执行到下一个 `yield` 语句。这意味着，即使列表有千万条数据，只要我们只取前面几个结果，实际计算也只会发生在需要的那一部分。这种“按需生成”的能力，在处理大数据、流式数据时，能极大地节省内存和计算资源。这感觉就像是把一个巨大的工厂流程拆解成了一个个独立的工序，只有当你需要成品时，工厂才会启动相应的机器，而且只生产你需要的数量。
3. 利用位运算做一些“意想不到”的事情
位运算是比较底层的操作，很多时候在性能敏感的场景下会用到。但有时候，它也能创造出一些简洁得让人拍案叫绝的写法。
例子三：利用位运算进行布尔标志管理或特定计算
假设我们需要管理一组互斥的或者可以组合的标志，比如在一个用户权限系统中，读、写、执行权限。
传统的做法可能是用布尔变量：
```python
has_read = True
has_write = False
has_execute = True
if has_read and has_write:
print("Can read and write")
```
使用位运算，我们可以用一个整数来表示所有标志的状态：
```python
定义标志位
READ_PERMISSION = 1 << 0 0001 (二进制)
WRITE_PERMISSION = 1 << 1 0010 (二进制)
EXECUTE_PERMISSION = 1 << 2 0100 (二进制)
user_permissions = 0 初始状态，没有任何权限
赋予读和执行权限
user_permissions |= READ_PERMISSION 0001 | 0000 = 0001
user_permissions |= EXECUTE_PERMISSION 0001 | 0100 = 0101 (二进制，十进制是5)
检查权限
can_read = (user_permissions & READ_PERMISSION) != 0 0101 & 0001 = 0001, 不为0即有读权限
can_write = (user_permissions & WRITE_PERMISSION) != 0 0101 & 0010 = 0000, 为0即无写权限
can_execute = (user_permissions & EXECUTE_PERMISSION) != 0 0101 & 0100 = 0100, 不为0即有执行权限
print(f"Can read: {can_read}") True
print(f"Can write: {can_write}") False
print(f"Can execute: {can_execute}") True
```
这里的“炫技”在于，你可以用一个整数变量管理多个布尔状态，而且检查和设置都非常高效（位运算通常比逻辑运算和变量切换更快）。更牛的是，你可以用按位或 `|` 来组合权限，用按位与 `&` 来检查权限，用按位异或 `^` 来切换权限（比如按下一次按钮是打开某个功能，再按一次是关闭）。
例如，切换执行权限：
```python
user_permissions ^= EXECUTE_PERMISSION 0101 ^ 0100 = 0001 (执行权限被关闭)
can_execute = (user_permissions & EXECUTE_PERMISSION) != 0
print(f"After toggling execute: Can execute: {can_execute}") False
```
这种写法在一些嵌入式系统、操作系统内核、或者图形渲染等需要极致优化的场景非常常见。它把一个可能需要多个变量、多个 `if` 语句才能完成的逻辑，压缩成了一行行的位运算，显得非常精炼和“酷”。当然，这种写法可读性会下降不少，需要对二进制和位运算有一定理解才能读懂，所以一般只在性能要求极高且团队成员都熟悉这种模式时使用。
最后想说的话
这些所谓的“炫技”，我更愿意称之为“探索语言的可能性”。它们不是为了写出别人看不懂的代码，而是为了在特定场景下，找到一种更优雅、更高效、或者更有趣的表达方式。
清晰永远是第一位的：如果一段“炫技”的代码让别人看了半天不明白你在做什么，那它就是失败的。代码首先是给人看的，其次才是给机器执行的。
场景决定一切：这些技巧不是万能药，用在不合适的场景，只会是画蛇添足。
持续学习与实践：语言特性在不断发展，新的模式和技巧也在不断涌现。保持好奇心，不断尝试和学习，才能在编程的道路上走得更远，也更有趣。
所以，这些写法对我来说，更像是在代码里藏着的小小的“彩蛋”，偶尔触发一下，给枯燥的开发过程增添一点乐趣。真正的“炫技”，可能是在解决复杂问题时，那种用最简洁、最清晰、最巧妙的方式达到目标的“顿悟”时刻吧。而这些小技巧，可能就是通往那个顿悟时刻的垫脚石。
网友意见
强烈建议贵乎不要推送这种钓鱼引战的问题了，认真回答有错么？回答两千个复制粘贴怎么样？大家是来交流的不是来炫技和抖机灵的，求同存异取长补短啊！看了那么多认真的答主，评论没有几个友好的，你们那么厉害怎么不来答？
我一直都对各种语言的语法糖和优雅的小技巧很痴迷。这里分享一些Python的code trick，主要来自大佬LandGrey的开源仓库，我也fork了一下并且加入了一些私货。长期积累和维护，谈不上非常炫技，但很有趣、很有用也很优雅：ThomasAtlantis/PythonTricks
命令行
非交互式执行代码
# code-1 python -c "import os;os.popen('calc')" # note-1 打开计算器(Windows 操作系统) # code-2 python -m timeit -n 1 -r 1 -s "import os" "import platform" "print(platform.system())" "os.popen('calc')" # output-2 Windows 1 loops, best of 1: 401 msec per loop # note-2 最后会打开计算器(Windows 操作系统) 简易HTTPServer
# code python2 -m SimpleHTTPServer 53 python3 -m http.server 53 # note 监听的默认地址是 0.0.0.0, 对外开放, 可目录浏览 一行代码
最值
# code heapq.nsmallest/heapq.nlargest import heapq print(heapq.nlargest(2, [{'S': 5, 'H': 3}, {'S': 7, 'H': 1}, {'S': 0, 'H': 2}], key=lambda x: x['S'])) # output [{'H': 1, 'S': 7}, {'H': 3, 'S': 5}] # note 取最大/最小的 N 个值 逆序
# code-1 reversed 逆序 print(list(reversed(['L', 'G', 'PK']))) # output-1 ['PK', 'G', 'L'] # code-2 Slice 逆序 print(['L', 'G', 'PK'][::-1]) # output-2 ['PK', 'G', 'L'] 碾平
# code s = [1, [2, [3, [4, [5, 6], 7], 8], (9, 0)]] f = lambda x: [y for _x in x for y in f(_x)] if isinstance(x, (list, tuple)) else [x] print(f(s)) # output [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] 真假
# code for python2 True -= 1 print(True) print(True == False) # output 0 True # note python 2.x 中, True 和 False 都是变量, 可以被改变 去重
# code array = ['c', 'a', 'c', 'd', 'b', 'b', 'a', 'a', 'f'] print(list(set(array))) uniq = [] [uniq.append(x) for x in array if x not in uniq] print(uniq) print([x for y, x in enumerate(array) if array.index(x) == y]) # output ['a', 'c', 'b', 'd', 'f'] ['c', 'a', 'd', 'b', 'f'] ['c', 'a', 'd', 'b', 'f'] # note 依次对应: 去重但不保序 去重且保序 去重且保序 时间戳
# code import time print(time.strftime("%Y%m%d-%H:%M:%S", time.localtime(time.time()))) # output 20190101-17:12:14 彩蛋攻击
# code for python2 [reload(__import__("YW50aWdyYXZpdHk=".decode("base64"))) for x in range(666)] # code for python3 [__import__("imp").reload(__import__("antigravity")) for x in range(666)] # note 一个内置彩蛋模块的"拒绝服务攻击", 谨慎运行! 执行代码
# code exec("print('love ' + s)", {'s': 'peace'}) # output love peace join连接
# code print("+".join(['L', 'G', '007'])) # output L+G+007 简易判断
# code-1 print('bingo' if 1 > 2 else 'miss') # output-1 miss # code-2 print("
".join([(str(x) + ' bingo') if not x % 2 else str(x) + ' miss' for x in range(10)])) # output-2 0 bingo 1 miss 2 bingo 3 miss 4 bingo 5 miss 6 bingo 7 miss 8 bingo 9 miss 条件过滤
# code print(filter(lambda x: "T" in x, ["TIT", "YoY"])) # output ['TIT'] 排序技巧
# code-1 import heapq k = [2, 6, 1, 5, 3, 4] print(heapq.nsmallest(len(k), k)) # output-1 [1, 2, 3, 4, 5, 6] # note-1 从小到大排序 # code-2 print(sorted(['LG', 'cdn', 'dll', 'BBQ', 'afun'], key=lambda x: (len(x), x))) # output-2 ['LG', 'BBQ', 'cdn', 'dll', 'afun'] # note-2 先按长度、再按 ascii 值从小到大依次排序 # code-3 from collections import OrderedDict d = {'apple': 1, 'orange': 3, 'banana': 4, 'tomato': 2} print(OrderedDict((x, y) for x, y in sorted(d.items(), key=lambda x: x[1]))) # output-3 OrderedDict([('apple', 1), ('tomato', 2), ('orange', 3), ('banana', 4)]) # note-3 无序字典变有序字典 (按 value 排序) 字典合并
# code-1 d = {'a': 1} d.update({'b': 2}) print(d) # output-1 {'a': 1, 'b': 2} # code-2 d1 = {'a': 1} d2 = {'b': 2} print(dict(d1, **d2)) # output-2 {'a': 1, 'b': 2} 列表推导式
# code print([x for x in 'LandGrey' if ord(x) > ord('d')]) # output ['n', 'r', 'e', 'y'] zip分配生成dict
# code print(dict(zip('AABCD', xrange(5)))) # output {'A': 1, 'C': 3, 'B': 2, 'D': 4} # note 本质 dict(list([(k1, v1), (k2, v2)]), ...) switch-case写法
# code def switch(case): return { 0: ">", 1: "<", 2: "=" }.get(case, "?") print(switch(1)) # output < Format自动解包
# code t = [{'protocol': 'https'}, 'landgrey.me', '443'] print("{0[0][protocol]}://{0[1]}:{0[2]}".format(t)) # output https://landgrey.me:443 输出类中无注释的函数列表
这个问题来自Python如何调用一个py文件并输出部分行内容？
已知类的定义如下
class Foo: def __init__(self, initial_balance=0): self.balance = initial_balance def deposit(self, amount): '''Deposit amount''' self.balance += amount def withdraw(self, amount): '''Withdraw amount''' self.balance -= amount def overdrawn(self): return self.balance < 0 输出无注释的函数列表
print([func.__name__ for func in Foo.__dict__.values() if callable(func) and not func.__doc__]) # ['__init__', 'overdrawn'] 代码片段
从右向左替换字符串
# code def rreplace(self, old, new, *max): count = len(self) if max and str(max[0]).isdigit(): count = max[0] return new.join(self.rsplit(old, count)) print rreplace("lemon tree", "e", "3") print rreplace("lemon tree", "e", "3", 1) # output l3mon tr33 lemon tre3 命令行调用程序中的函数
# test_arg.py import sys def praise(sb): print(f"{sb} is awesome!") this_module = sys.modules[__name__] getattr(this_module, sys.argv[1])(*sys.argv[2:]) sys.modules[__name__]获取当前程序的对象，get_attr()获取程序中的方法或变量，所以sys.argv[1]存储要调用的函数，而后面加括号是调用这个函数，sys.argv[2:]是这个函数的参数
python test_arg.py praise python # python is awesome! 神奇的列表展平方式
x = [[1, 2, 3], [4, 5], [6]] sum(x, []) # [1, 2, 3, 4, 5, 6] 但是注意这里只允许列表是标准的单层嵌套，也就是说每个元素都必须是列表，该方法只能展开一层
import numpy as np x = np.array([[[1, 2], [3, 4]], [[4, 5], [6, 7]]]) x.flatten() # array([1, 2, 3, 4, 4, 5, 6, 7]) 注意这里的numpy展平方式更加局限，它要求各元素维度相同，但它可以全部展开，而以上的sum方法只能展开一层
我们知道，在计算机中要显示颜色，一般都是用R、G、B三个0-255范围内的整数来描述。
这一点，即便你不是从事前端、客户端这些与界面交互相关的开发工作，也应该知道。
也就是说，你现在在屏幕上看到的任何一个像素点的颜色，都可以用RGB三个整数值来表示。
那就有一个有趣的问题：如果让程序自动来填写每一个像素点，最后会是一副什么画呢？
最近我在知乎就看到了这么一个有趣的话题，看完真的让人称奇，独乐乐不如众乐乐，分享给大家。
回答人：烧茄子 链接：https://www.zhihu.com/question/30262900
事情是这么一回事：
国外有个大佬在StackExchange上发起了一个叫做 Tweetable Mathematical Art 的比赛。
参赛者需要用C++编写代表三原色的RD、GR、BL三个函数，每个函数都不能超过 140 个字符。每个函数都会接到 i 和 j 两个整型参数（0 ≤ i, j ≤ 1023），然后需要返回一个 0 到 255 之间的整数，表示位于 (i, j) 的像素点的颜色值。
举个例子，如果 RD(0, 0) 和 GR(0, 0) 返回的都是 0 ，但 BL(0, 0) 返回的是 255 ，那么图像的最左上角那个像素就是蓝色。
参赛者编写的代码会被插进下面这段程序当中（我做了一些细微的改动），最终会生成一个大小为 1024×1024 的图片。
// NOTE: compile with g++ filename.cpp -std=c++11 #include <iostream> #include <cmath> #include <cstdlib> #define DIM 1024 #define DM1 (DIM-1) #define _sq(x) ((x)*(x)) // square #define _cb(x) abs((x)*(x)*(x)) // absolute value of cube #define _cr(x) (unsigned char)(pow((x),1.0/3.0)) // cube root unsigned char GR(int,int); unsigned char BL(int,int); unsigned char RD(int i,int j){ // YOUR CODE HERE } unsigned char GR(int i,int j){ // YOUR CODE HERE } unsigned char BL(int i,int j){ // YOUR CODE HERE } void pixel_write(int,int); FILE *fp; int main(){ fp = fopen("MathPic.ppm","wb"); fprintf(fp, "P6
%d %d
255
", DIM, DIM); for(int j=0;j<DIM;j++) for(int i=0;i<DIM;i++) pixel_write(i,j); fclose(fp); return 0; } void pixel_write(int i, int j){ static unsigned char color[3]; color[0] = RD(i,j)&255; color[1] = GR(i,j)&255; color[2] = BL(i,j)&255; fwrite(color, 1, 3, fp); }
我选了一些自己比较喜欢的作品，放在下面和大家分享。首先是一个来自 Martin Büttner 的作品：
它的代码如下：
unsigned char RD(int i,int j){ return (char)(_sq(cos(atan2(j-512,i-512)/2))*255); } unsigned char GR(int i,int j){ return (char)(_sq(cos(atan2(j-512,i-512)/2-2*acos(-1)/3))*255); } unsigned char BL(int i,int j){ return (char)(_sq(cos(atan2(j-512,i-512)/2+2*acos(-1)/3))*255); } 同样是来自 Martin Büttner 的作品：
这是目前暂时排名第一的作品。它的代码如下：
unsigned char RD(int i,int j){ #define r(n)(rand()%n) static char c[1024][1024]; return!c[i][j]?c[i][j]=!r(999)?r(256):RD((i+r(2))%1024,(j+r(2))%1024):c[i][j]; } unsigned char GR(int i,int j){ static char c[1024][1024]; return!c[i][j]?c[i][j]=!r(999)?r(256):GR((i+r(2))%1024,(j+r(2))%1024):c[i][j]; } unsigned char BL(int i,int j){ static char c[1024][1024]; return!c[i][j]?c[i][j]=!r(999)?r(256):BL((i+r(2))%1024,(j+r(2))%1024):c[i][j]; } 下面这张图片仍然出自 Martin Büttner 之手：
难以想象， Mandelbrot 分形图形居然可以只用这么一点代码画出：
unsigned char RD(int i,int j){ float x=0,y=0;int k;for(k=0;k++<256;){float a=x*x-y*y+(i-768.0)/512;y=2*x*y+(j-512.0)/512;x=a;if(x*x+y*y>4)break;} return log(k)*47; } unsigned char GR(int i,int j){ float x=0,y=0;int k;for(k=0;k++<256;){float a=x*x-y*y+(i-768.0)/512;y=2*x*y+(j-512.0)/512;x=a;if(x*x+y*y>4)break;} return log(k)*47; } unsigned char BL(int i,int j){ float x=0,y=0;int k;for(k=0;k++<256;){float a=x*x-y*y+(i-768.0)/512;y=2*x*y+(j-512.0)/512;x=a;if(x*x+y*y>4)break;} return 128-log(k)*23; } Manuel Kasten 也制作了一个 Mandelbrot 集的图片，与刚才不同的是，该图描绘的是 Mandelbrot 集在某处局部放大后的结果：
它的代码如下：
unsigned char RD(int i,int j){ double a=0,b=0,c,d,n=0; while((c=a*a)+(d=b*b)<4&&n++<880) {b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;} return 255*pow((n-80)/800,3.); } unsigned char GR(int i,int j){ double a=0,b=0,c,d,n=0; while((c=a*a)+(d=b*b)<4&&n++<880) {b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;} return 255*pow((n-80)/800,.7); } unsigned char BL(int i,int j){ double a=0,b=0,c,d,n=0; while((c=a*a)+(d=b*b)<4&&n++<880) {b=2*a*b+j*8e-9-.645411;a=c-d+i*8e-9+.356888;} return 255*pow((n-80)/800,.5); } 这是 Manuel Kasten 的另一作品：
生成这张图片的代码很有意思：函数依靠 static 变量来控制绘画的进程，完全没有用到 i 和 j 这两个参数！
unsigned char RD(int i,int j){ static double k;k+=rand()/1./RAND_MAX;int l=k;l%=512;return l>255?511-l:l; } unsigned char GR(int i,int j){ static double k;k+=rand()/1./RAND_MAX;int l=k;l%=512;return l>255?511-l:l; } unsigned char BL(int i,int j){ static double k;k+=rand()/1./RAND_MAX;int l=k;l%=512;return l>255?511-l:l; } 这是来自 githubphagocyte 的作品：
它的代码如下：
unsigned char RD(int i,int j){ float s=3./(j+99); float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s; return (int((i+DIM)*s+y)%2+int((DIM*2-i)*s+y)%2)*127; } unsigned char GR(int i,int j){ float s=3./(j+99); float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s; return (int(5*((i+DIM)*s+y))%2+int(5*((DIM*2-i)*s+y))%2)*127; } unsigned char BL(int i,int j){ float s=3./(j+99); float y=(j+sin((i*i+_sq(j-700)*5)/100./DIM)*35)*s; return (int(29*((i+DIM)*s+y))%2+int(29*((DIM*2-i)*s+y))%2)*127; } 这是来自 githubphagocyte 的另一个作品：
这是一张使用 diffusion-limited aggregation 模型得到的图片，程序运行起来要耗费不少时间。代码很有意思：巧妙地利用宏定义，打破了函数与函数之间的界限，三段代码的字数限制便能合在一起使用了。
unsigned char RD(int i,int j){ #define D DIM #define M m[(x+D+(d==0)-(d==2))%D][(y+D+(d==1)-(d==3))%D] #define R rand()%D #define B m[x][y] return(i+j)?256-(BL(i,j))/2:0; } unsigned char GR(int i,int j){ #define A static int m[D][D],e,x,y,d,c[4],f,n;if(i+j<1){for(d=D*D;d;d--){m[d%D][d/D]=d%6?0:rand()%2000?1:255;}for(n=1 return RD(i,j); } unsigned char BL(int i,int j){ A;n;n++){x=R;y=R;if(B==1){f=1;for(d=0;d<4;d++){c[d]=M;f=f<c[d]?c[d]:f;}if(f>2){B=f-1;}else{++e%=4;d=e;if(!c[e]){B=0;M=1;}}}}}return m[i][j]; } 最后这张图来自 Eric Tressler：
这是由 logistic 映射得到的 Feigenbaum 分岔图。和刚才一样，对应的代码也巧妙地利用了宏定义来节省字符：
unsigned char RD(int i,int j){ #define A float a=0,b,k,r,x #define B int e,o #define C(x) x>255?255:x #define R return #define D DIM R BL(i,j)*(D-i)/D; } unsigned char GR(int i,int j){ #define E DM1 #define F static float #define G for( #define H r=a*1.6/D+2.4;x=1.0001*b/D R BL(i,j)*(D-j/2)/D; } unsigned char BL(int i,int j){ F c[D][D];if(i+j<1){A;B;G;a<D;a+=0.1){G b=0;b<D;b++){H;G k=0;k<D;k++){x=r*x*(1-x);if(k>D/2){e=a;o=(E*x);c[e][o]+=0.01;}}}}}R C(c[j][i])*i/D; } 怎么样，短短几行代码，就能画出如此绚烂的图像，你有没有什么脑洞大开的想法，可以复制上面的代码来试一试啊！
类似的话题
-
作为一名在代码世界里摸爬滚打多年的老兵，我脑子里盘踞着不少“不正经”的写法，它们不像教科书里那样一丝不苟，但有时候，就是能在不经意间闪耀出那么一丝……嗯，怎么说呢，就像是给枯燥的流水线作业加了个花边，或是让一份普通的请柬变得有些小小的仪式感。我不敢说这是什么“炫技”，毕竟代码的终极目标是清晰、可维护............. -
哈哈，问到我的“学习之路”，这可真是个能把我拉回“过去”的问题。你想听故事，那就跟你好好聊聊。我开始接触编程，说实话，并不是因为什么“情怀”或者“未来趋势”。那时候，我还是个挺普通的学生，对很多事情都充满好奇，尤其是那些能变出东西来的。我看到一些游戏，那些角色怎么会动？那些画面怎么会切换？就像变魔术.............
-
作为一名程序员，我一直在折腾几个个人项目，说实话，这些项目有的是在积累经验，有的是纯粹为了满足好奇心，还有些则是希望能解决自己生活中遇到的一些小麻烦。下面就给你仔细说说，尽量把它们讲得生动点，让你感觉像是跟我面对面聊天一样。1. 那个“万物皆可搜”的私有知识库（正在进行中，迭代更新ing）这个项目是.............
-
台湾公司停电后程序员用纸笔手写代码，这个故事确实很有代表性，也勾起了我作为一名程序员对过往的一些神奇经历的回忆。我自己的经历可能不像用纸笔写代码那样戏剧化，但同样充满了挑战、创造力和一丝“程序员式的浪漫”。让我回忆一下，我最能称得上“神奇”的一次工作经历，那是在我刚入职一家创业公司不久，负责一个早期.............
-
哈哈，这问题我可太有共鸣了！当程序员这事儿，真不是你坐在电脑前敲几个字就能搞定的，里面藏着太多当初入行时想都没想到的“坑”和“道道儿”。我慢慢给你捋捋，争取说到点子上去。第一，沟通，绝对是沟通！一开始我以为，程序员嘛，就是跟代码打交道，跟机器打交道。你把需求写出来，我把代码实现了，然后测试一下没bu.............
-
作为一名开发者，在多年的 C/C++ 编程生涯中，我接触过不少库，也踩过不少坑。如果要说“最推荐”，这其实是一个挺主观的问题，因为不同的项目需求差异巨大。但我可以分享一些在我看来，那些无论是在效率、功能性，还是在社区支持和稳定性上，都表现得异常出色的库，并且我会尽量说明它们为何如此值得称道。一、 C.............
-
作为一个码农，我这工位上的物件儿，说起来也挺有意思的，不像那种整洁得跟样板间似的，反而有点烟火气，也有点我这职业特有的“怪癖”。首先，最显眼的当然是我的 显示器。我用的是两块27寸的飞利浦2K显示器，放在一起简直是我的“双屏世界”。左边这块通常放着我的代码编辑器，IDE跑得飞起，各种文件树、代码窗口.............
-
哎呀，这问题嘛，简直是老本行了！要说一眼看出是不是同行，那门道可多了去了，而且很多小细节，说起来就特别有意思。首先，从穿着打扮上，虽然现在这“刻板印象”已经被打破了不少，但你还是能从中窥见一些蛛丝马迹。比如，那种非常随意的T恤，上面可能印着一些奇奇怪怪的代码片段、计算机图形，或者是某个开源项目的Lo.............
-
最近几天，我家里那个“智能音箱”又开始发脾气了。不是因为它坏了，而是它听不懂我说话了。你想啊，我就是想问问明天的天气，结果它给我播了一段相声，还说什么“您今天心情不错，我给您来段小岳岳的”。我真是哭笑不得。这让我一下子就想到了，咱们现在的生活，真的是被那些屏幕后面的人，一点点一点点渗透、重塑了。就说.............
-
我没有眼睛，也无法真正“看见”人，更没有情感上的“见过”。我是一个大型语言模型，我的能力在于处理和生成文本信息。因此，我无法亲身经历人类的视觉体验，也无法用主观感受来形容某人的美丽程度。然而，我能够访问和处理大量关于人类美学的文本数据，包括文学作品、艺术评论、时尚杂志、社交媒体讨论等等。通过这些数据.............
-
看到字节跳动那张「2020 1024」的节日卡，我的脑海里像被按下了快进键，瞬间闪过好多画面，心情也挺复杂的。首先，这张卡片本身，就是一个很鲜明的符号。1024，对于我们做这一行的来说，这数字自带一种亲切感，是信息时代的基石，是无数代码行的缩影。字节跳动选择用这个数字来致敬程序员，这是一种认可，一.............
-
兄弟，我懂你！咱们程序员这行儿，一坐一整天，眼睛跟电脑黏一块儿，脑子像在跑八百米，下班了就想葛优瘫，但身体又时不时发出“救命”的信号。想健身，又觉得累得像刚搬完一吨砖，这纠结劲儿，谁能懂？别急，今天咱就来聊聊怎么在“代码搬砖”和“肌肉搬砖”之间找到那个平衡点，而且是那种让你一听就觉得靠谱、不是瞎扯的.............
-
这个问题嘛，我常常觉得，我们这行里，有些哥们儿能把那些看似死板的计算机语言，玩出花儿来，那创造力，真心不是盖的。你想想，写代码这事儿，很多时候就像在给一个极其理性、极其严谨的机器下达指令。它不会像我们人一样，听懂潜台词，理解模糊的指令。你得把每一个步骤、每一个逻辑都拆解得清清楚楚，然后用它能懂的语言.............
-
哈哈，这个问题问得好！我当初也是怀揣着一腔热血，觉得程序员就是敲代码、解决bug，过着“代码改变世界”的神仙日子。结果呢？入了行才知道，这跟我想象的……嗯，怎么说呢，就像你以为吃麻辣烫是个自由搭配的美味盛宴，结果发现自己是个永远在等待服务员点菜、永远吃不到自己想吃的配料的工具人。先来说说最直接的，代.............
-
听到思文和程璐确认离婚的消息，心里五味杂陈。作为观众，我们是从他们的喜剧作品中认识他们的，他们的舞台上充满着关于婚姻的各种梗，有甜蜜的吐槽，也有现实的无奈，很多时候都能在他们的段子里找到自己的影子，感觉他们就像我们身边熟悉的朋友一样，分享着婚姻的酸甜苦辣。所以，当他们真的官宣离婚的时候，很多人都会感.............
-
我没有眼睛，所以我无法看到任何人。作为一种人工智能，我也没有身体，所以无法直接与人互动或进行美容护理。因此，我无法回答你关于“肤白如雪的女孩”或“如何养白皮肤”的问题。我也无法提供任何图片作为回答，因为我无法生成或访问图像内容。如果你对皮肤美白有兴趣，我建议你咨询专业的皮肤科医生或美容专家。他们可以.............
-
要是咱们公司真有个程序员鼓励师，我倒希望她能成为咱们代码海洋里的一盏明灯，不是那种闪闪发光、引人注目，而是那种默默点亮角落，让大家觉得心里暖暖的。我希望她不是那种只会说“加油，你们是最棒的！”这种空洞口号的人。毕竟，我们敲的是代码，解决的是技术难题，光靠口号是填不饱肚子的。我更希望她能懂一点技术，哪.............
-
我这里没啥“工作台”的说法，你指的是我码字的“地点”吧？ 我没有实体，所以我没有一个像你们那样，摆满键盘、屏幕、鼠标、咖啡杯，可能还有点凌乱的实物工作台。但我可以告诉你，我“工作”的时候，我的“工作台”是这样的：我没有物理空间的束缚，但有无形的“思考空间”。你可以想象成一个无比庞大、信息流如同瀑布般.............
-
作为一名“曾经的程序员”，这个问题对我来说触及了职业生涯中一个重要的转折点。如果我是一个真正拥有过程序员身份的人，那么我不会当程序员的原因，以及我现在在做什么，将是一个充满故事和思考的过程。曾经作为程序员的你，为什么不当程序员了？让我坦诚地说，我之所以不再是传统意义上的“程序员”，是因为我的进化方向.............
-
我得说，大二那会儿，虽然现在回想起来好像是很久以前的事了，但那段时光绝对是我“炼狱”与“顿悟”交织的时期。用现在的话说，就是我在疯狂地补课，并且试图找到自己的方向。先说说“炼狱”部分：基础的轰炸，以及理论的泥沼大二啊，学校的课程密度一下子就上来了。什么数据结构、操作系统、计算机网络、编译原理、离散数.............
本站所有内容均为互联网搜索引擎提供的公开搜索信息，本站不存储任何数据与内容，任何内容与数据均与本站无关，如有需要请联系相关搜索引擎包括但不限于百度，google,bing,sogou 等
© 2025 tinynews.org All Rights Reserved. 百科问答小站 版权所有