杂谈 on 小盒子的技术分享

neo 下一代家庭人形机器人

Wed, 29 Oct 2025 02:27:38 +0000

我想起了小时候看过的一部电影，虽然可能为时尚早，但不久的将来，具身智能将和人类一起生活，AI 不止是智能，更是伙伴了 https://www.1x.tech/neo

分享几个扣子的邀请码

Mon, 21 Apr 2025 10:12:20 +0000

分享几个扣子的邀请码

今天扣子空间挺火，有点儿像 Manus, 体验下来不如 Manus 强,

需要邀请码，想体验的朋友们，可以自取

https://www.coze.cn/space-preview?invite_code=2HUGN0SQ https://www.coze.cn/space-preview?invite_code=YP8G30DB https://www.coze.cn/space-preview?invite_code=35WY7EJA https://www.coze.cn/space-preview?invite_code=YH4W846S https://www.coze.cn/space-preview?invite_code=4QK9CLAS

小盒子的技术分享

九个技巧，让你的Python代码运行得更快！

Mon, 07 Oct 2024 14:27:36 +0000

在编程语言的讨论中，我们经常听到 “Python 太慢了” 的声音，这往往掩盖了 Python 的许多优点。但事实上，如果你能以 Pythonic 的方式编写代码，Python 可以非常快。

细节决定成败。经验丰富的 Python 开发者拥有一系列微妙而强大的技巧，这些技巧可以显著提高代码的性能。

这些技巧乍一看可能微不足道，但它们可以带来效率的大幅提升。让我们深入探讨这 9 种方法，改变你编写和优化 Python 代码的方式。

1. 更快的字符串连接：巧妙选择 “join()” 或 “+”

如果有很多字符串需要处理，字符串连接就会成为 Python 程序的瓶颈。

在 Python 中，字符串连接基本上有两种方式：

使用join()函数将一个字符串列表合并为一个
使用+或+=符号将每个字符串添加到一个字符串中

那么哪种方式更快呢？

让我们来定义 3 个不同的函数来连接相同的字符串：

 1mylist = ["Yang", "Zhou", "is", "writing"]
 2
 3# 使用'+'
 4def concat_plus():
 5 result = ""
 6 for word in mylist:
 7 result += word + " "
 8 return result
 9
10# 使用'join()'
11def concat_join():
12 return " ".join(mylist)
13
14# 直接连接字符串，不使用列表
15def concat_directly():
16 return "Yang" + "Zhou" + "is" + "writing"

根据你的第一印象，你认为哪个函数最快，哪个最慢？

实际结果可能会让你惊讶：

1import timeit
2
3print(timeit.timeit(concat_plus, number=10000))
4# 0.002738415962085128
5print(timeit.timeit(concat_join, number=10000))
6# 0.0008482920238748193
7print(timeit.timeit(concat_directly, number=10000))
8# 0.00021425005979835987

如上所示，对于连接一个字符串列表，join()方法比在 for 循环中逐个添加字符串要快。

原因是直接的。一方面，字符串在 Python 中是不可变数据，在每次+=操作中都会创建一个新的字符串并复制旧字符串，这在计算上是昂贵的。

另一方面，.join()方法专门优化了字符串的连接。它预先计算结果字符串的大小，然后一次性构建它。因此，它避免了在循环中+=操作的开销，因此它更快。

然而，在我们的测试中最快的函数是直接连接字符串字面量。它的高速度是由于：

Python 解释器可以在编译时优化字符串字面量的连接，将它们变成单个字符串字面量。没有循环迭代或函数调用，这使得它是一个非常高效的操作。
由于所有字符串在编译时都是已知的，Python 可以非常快速地执行此操作，比循环中的运行时连接或甚至优化的.join()方法都要快得多。

总之，如果你需要连接一个字符串列表，请选择join()而不是+=。如果你想直接连接字符串，只需使用+即可。

2. 更快的列表创建：使用"[]“而不是"list()”

创建列表不是什么大不了的事。有两种常见的方式：

使用list()函数
直接使用[]

让我们使用一个简单的代码片段来测试它们的性能：

1import timeit
2
3print(timeit.timeit('[]', number=10 ** 7))
4# 0.1368238340364769
5print(timeit.timeit(list, number=10 ** 7))
6# 0.2958830420393497

如结果所示，执行list()函数比直接使用[]要慢。

这是因为[]是字面量语法，而list()是一个构造函数调用。调用函数无疑需要额外的时间。

同样的逻辑，当创建字典时，我们也应该利用{}而不是dict()。

3. 更快的成员测试：使用集合而不是列表

成员检查操作的性能在很大程度上取决于底层数据结构：

 1import timeit
 2
 3large_dataset = range(100000)
 4search_element = 2077
 5
 6large_list = list(large_dataset)
 7large_set = set(large_dataset)
 8
 9def list_membership_test():
10 return search_element in large_list
11
12def set_membership_test():
13 return search_element in large_set
14
15print(timeit.timeit(list_membership_test, number=1000))
16# 0.01112208398990333
17print(timeit.timeit(set_membership_test, number=1000))
18# 3.27499583363533e-05

如上述代码所示，集合中的成员测试比列表中的要快得多。

为什么会这样？

在 Python 列表中，成员测试（element in list）是通过遍历每个元素直到找到所需元素或到达列表末尾来完成的。因此，此操作的时间复杂度为 O(n)。
Python 中的集合是作为哈希表实现的。当检查成员资格（element in set）时，Python 使用哈希机制，其平均时间复杂度为 O(1)。

这里的要点是在编写程序时要仔细考虑底层数据结构。利用正确的数据结构可以显著加快我们的代码速度。

4. 更快的数据生成：使用推导式而不是 for 循环

Python 中有四种类型的推导式：列表、字典、集合和生成器。它们不仅为创建相对数据结构提供了更简洁的语法，而且比使用 for 循环有更好的性能，因为它们在 Python 的 C 实现中进行了优化。

 1import timeit
 2
 3def generate_squares_for_loop():
 4 squares = []
 5 for i in range(1000):
 6 squares.append(i * i)
 7 return squares
 8
 9def generate_squares_comprehension():
10 return [i * i for i in range(1000)]
11
12print(timeit.timeit(generate_squares_for_loop, number=10000))
13# 0.2797503340989351
14print(timeit.timeit(generate_squares_comprehension, number=10000))
15# 0.2364629579242319

上述代码是列表推导式和 for 循环之间的简单速度比较。如结果所示，列表推导式更快。

5. 更快的循环：优先使用局部变量

在 Python 中，访问局部变量比访问全局变量或对象的属性要快。

这里有一个实例来证明这一点：

 1import timeit
 2
 3class Example:
 4 def __init__(self):
 5 self.value = 0
 6
 7obj = Example()
 8
 9def test_dot_notation():
10 for _ in range(1000):
11 obj.value += 1
12
13def test_local_variable():
14 value = obj.value
15 for _ in range(1000):
16 value += 1
17 obj.value = value
18
19print(timeit.timeit(test_dot_notation, number=1000))
20# 0.036605041939765215
21print(timeit.timeit(test_local_variable, number=1000))
22# 0.024470250005833805

这就是 Python 的工作方式。直观地说，当一个函数被编译时，里面的局部变量是已知的，但其他外部变量需要时间来检索。

这是一个小问题，但我们可以利用它来优化我们在处理大量数据时的代码。

6. 更快的执行：优先使用内置模块和库

当工程师们说 Python 时，他们通常指的是 CPython。因为 CPython 是 Python 语言的默认和最广泛使用的实现。

鉴于其大多数内置模块和库都是用 C 语言编写的，C 是一种更快的低级语言，我们应该利用内置的武器库，避免重新发明轮子。

 1import timeit
 2import random
 3from collections import Counter
 4
 5def count_frequency_custom(lst):
 6 frequency = {}
 7 for item in lst:
 8 if item in frequency:
 9 frequency[item] += 1
10 else:
11 frequency[item] = 1
12 return frequency
13
14def count_frequency_builtin(lst):
15 return Counter(lst)
16
17large_list = [random.randint(0, 100) for _ in range(1000)]
18
19print(timeit.timeit(lambda: count_frequency_custom(large_list), number=100))
20# 0.005160166998393834
21print(timeit.timeit(lambda: count_frequency_builtin(large_list), number=100))
22# 0.002444291952997446

上述程序比较了两种计算列表中元素频率的方法。我们可以看到，利用内置的Counter来自collections模块更快、更整洁、更好。

7. 更快的函数调用：利用缓存装饰器进行简单的记忆化

缓存是一种常用的技术，用于避免重复计算并加速程序。

幸运的是，在大多数情况下，我们不需要编写自己的缓存处理代码，因为 Python 为此目的提供了一个现成的装饰器——@functools.cache。

例如，以下代码将执行两个斐波那契数生成函数，一个有缓存装饰器，另一个没有：

 1import timeit
 2import functools
 3
 4def fibonacci(n):
 5 if n in (0, 1):
 6 return n
 7 return fibonacci(n - 1) + fibonacci(n - 2)
 8
 9@functools.cache
10def fibonacci_cached(n):
11 if n in (0, 1):
12 return n
13 return fibonacci_cached(n - 1) + fibonacci_cached(n - 2)
14
15# 测试每个函数的执行时间
16print(timeit.timeit(lambda: fibonacci(30), number=1))
17# 0.09499712497927248
18print(timeit.timeit(lambda: fibonacci_cached(30), number=1))
19# 6.458023563027382e-06

结果证明了functools.cache装饰器使我们的代码更快。

基本的fibonacci函数效率低下，因为在得到fibonacci(30)的结果过程中，它多次重新计算相同的斐波那契数。

缓存版本要快得多，因为它缓存了先前计算的结果。因此，它只计算一次每个斐波那契数，后续具有相同参数的调用从缓存中检索。

仅仅添加一个内置装饰器就可以带来如此大的改进，这就是 Pythonic 的意思。😎

8. 更快的无限循环：优先选择 “while 1” 而不是 “while True”

要创建一个无限 while 循环，我们可以使用while True或while 1。

它们性能的差异通常可以忽略不计。但有趣的是，while 1稍微快一点。

这是因为1是字面量，但True是一个需要在 Python 的全局作用域中查找的全局名称，因此需要一个微小的开销。

让我们也在代码片段中检查这两种方式的实际比较：

 1import timeit
 2
 3def loop_with_true():
 4 i = 0
 5 while True:
 6 if i >= 1000:
 7 break
 8 i += 1
 9
10def loop_with_one():
11 i = 0
12 while 1:
13 if i >= 1000:
14 break
15 i += 1
16
17print(timeit.timeit(loop_with_true, number=10000))
18# 0.1733035419601947
19print(timeit.timeit(loop_with_one, number=10000))
20# 0.16412191605195403

如我们所见，while 1确实稍微快一点。

然而，现代 Python 解释器（如 CPython）高度优化，这种差异通常可以忽略不计。更不用说while True比while 1更易读。

9. 更快的启动：智能导入 Python 模块

在 Python 脚本的顶部导入所有模块似乎是自然而然的事情。

实际上，我们不必这么做。

此外，如果一个模块太大，按需导入它是一个更好的主意。

1def my_function():
2 import heavy_module
3 # 函数的其余部分

如上述代码，heavy_module在函数内部导入。这是一种“懒加载”的思想，即导入被推迟到my_function被调用时。

这种方法的好处是，如果my_function在脚本执行过程中从未被调用，那么heavy_module就永远不会被加载，节省了资源并减少了脚本的启动时间。

理解 Python 中的星号用法

Sun, 28 Jul 2024 01:46:59 +0000

在 Python 编程中，星号（*）和双星号（**）操作符不仅仅用于乘法运算。它们在函数定义、函数调用、列表和字典构造等方面具有特殊的含义和功能。本文将深入探讨这些用法，帮助你更好地理解和运用这些操作符。

一、函数中的`*args`和`**kwargs`

1. `*args`在函数定义中的使用

最广为人知的星号用法是作为函数的参数，允许函数接受可变数量的参数。例如，我们有一个函数用于将两个数相加：

1def add(number_1, number_2):
2 return number_1 + number_2
3
4print(add(1, 2)) # 输出 3

如果我们想让这个函数接受任意数量的参数，可以在参数名前加一个星号：

1def add(*numbers):
2 total = 0
3 for number in numbers:
4 total += number
5 return total
6
7print(add(1, 2, 3, 4)) # 输出 10

在这里，numbers是一个元组，包含了所有传入的参数。

2. 在函数调用中使用`*`

除了在函数定义中使用星号，我们还可以在函数调用中使用它。假设有一个函数需要三个参数：

1def add(number_1, number_2, number_3):
2 return number_1 + number_2 + number_3

如果我们有一个包含三个元素的列表，可以这样调用函数：

1my_list = [1, 2, 3]
2add(*my_list) # 等同于 add(1, 2, 3)

3. `**kwargs`在函数定义中的使用

双星号（**）操作符用于处理关键字参数，允许我们传递任意数量的关键字参数给函数。例如：

1def change_user_details(username, **kwargs):
2 user = get_user(username)
3 for attribute, value in kwargs.items():
4 setattr(user, attribute, value)

在这里，kwargs是一个字典，包含了所有传入的关键字参数。

4. 在函数调用中使用`**`

同样，我们可以在函数调用时使用双星号操作符传递字典参数：

1details = {
2 'email': 'example@example.com',
3 'phone': '123456789'
4}
5change_user_details('username', **details)

二、限制函数调用方式

1. 仅允许关键字参数

在函数定义中单独使用星号可以限制函数只能使用关键字参数：

1def my_function(*, keyword_arg_1):
2 ...

调用时，如果使用位置参数，将会抛出错误：

1my_function(1) # TypeError: my_function() takes 0 positional arguments but 1 was given

2. 仅允许位置参数

可以使用斜杠（/）来限制函数仅接受位置参数：

1def only_positional_arguments(arg1, arg2, /):
2 ...

调用时，如果使用关键字参数，将会抛出错误：

1only_positional_arguments(arg1=1, arg2=2) # TypeError

三、在列表和字典构造中的使用

1. 构造列表

星号操作符不仅可以在函数中使用，还可以用于构造列表。例如，合并两个列表并插入一个值：

1my_list_1 = [1, 2, 3]
2my_list_2 = [10, 20, 30]
3some_value = 42
4merged_list = [*my_list_1, some_value, *my_list_2]
5# 输出 [1, 2, 3, 42, 10, 20, 30]

2. 构造字典

双星号操作符可以用于合并字典：

1social_media_details = {'twitter': 'username'}
2contact_details = {'email': 'example@example.com'}
3user_dict = {'username': 'user', **social_media_details, **contact_details}
4# 输出 {'username': 'user', 'twitter': 'username', 'email': 'example@example.com'}

四、列表解构

星号操作符还可以用于列表解构，允许将列表的部分元素赋值给不同的变量：

1my_list = [1, 2, 3, 4, 5]
2a, *b, c = my_list
3# a -> 1
4# b -> [2, 3, 4]
5# c -> 5

在这个例子中，a获取列表的第一个元素，c获取最后一个元素，而b获取中间的所有元素。

结语

星号和双星号操作符在 Python 中有着广泛的应用，从函数定义到列表和字典的操作。理解并掌握这些用法，将帮助你写出更灵活和简洁的代码。希望这篇文章能为你提供清晰的指导，帮助你更好地利用这些强大的工具。

如果你想了解更多关于 Python 编程的技巧和知识，欢迎订阅我的微信公众号。

关于“小作文” 事件写了个脚本方便大家吃瓜

Sat, 16 Dec 2023 07:54:24 +0000

关于 “小作文” 事件写了个脚本方便大家吃瓜

这两天有关东方甄选的 “小作文” 事件闹得沸沸扬扬，各路吃瓜群众络绎不绝地到某音上吃瓜，我像很多人一样在各个账号之间来回切换，这边看看粉丝掉了多少，那边看看粉丝涨了多少，好不辛苦。于是就想写个程序方便吃瓜。

https://github.com/xiaobox/changeCEO

脚本比较简单，就是定时获取事件相关方账号的粉丝数量

效果如下：

由于吃瓜有时效性，我写的这会儿 CEO 都免职了，所以程序就没写的那么完美，大家凑合用吧。

不说了，我去看看董宇辉涨到多少粉儿了～～

日志为什么叫 "log"

Thu, 07 Dec 2023 05:46:43 +0000

疑问

熟悉计算机或者有过开发经验的朋友一定对 “日志” 很熟悉，日志记录着软件运行过程中的一些信息：异常、错误或者运行情况等，它就像日记本一样，记录着软件运行的 “流水账”。

日志的英文是 log ,当你搜索 log 是什么的时候，经常会看到下面这样的图片

这是“圆木” ？是的，log 有这个意思

当然 log 也有日志的意思。

但是为什么呢？日志为什么叫 log 呢，好像感觉它跟木头有点儿关系，不然怎么用同一个单词来表示呢？

答案

在找答案的过程中，我在牛津词典中查到了 “log-book”

“

A book in which the particulars of a ship’s voyage (including her rate of progress as indicated by the log) are entered daily from the log-board.

每天从航海日志中记录船舶航行详情（包括航海日志所示的航行速度）的一本书。

”

感觉这个词的起源跟航海有很大的关系，实际上确实如此。

这玩意是 chip log 以前航海时用来测航速的。

它是一个木轴上面缠一捆绳子，绳子头上绑一块木板，木板底部衬有铅。木板每个角绑着一根线，一共三根，测量时，把木板放到海里，海水会推着木板保持静止，然后木板拽出绳子，绳子上有绳结，用一个沙漏计时，最后算一下，一段时间内绳结的数量就得到了航速。

这下终于知道 log 为什么跟木头有关系了，因为它起源于 chip log 这个装置，那玩意看起来… 不对，实际上就是块木头。哈哈

可以通过下面这个视频了解一下，它是如何运行的。

如何快速编写 HTML CSS 代码

Sun, 03 Dec 2023 06:14:06 +0000

HTML 和 CSS 代码冗长而繁复，稍不留神就容易写错，而且大部分都是类似的内容，很多重复劳动，一行一行写的话，很费时。

我记得多年前前端刚流行的时候，有一款插件让我眼前一亮，它可以通过写一些 字母+回车 就能生成对应的 HTML 代码，当时它叫 Zen Coding ，现在它的名字是 Emmet

“

Emmet（是一套面向文本编辑器的插件，它允许通过内容辅助高速度的编写和编辑 HTML、XML、XSL和其他结构化的代码格式

”

好像新版的 Visual Studio Code 已经内置了 Emmet

本文我们就聊聊 Emmet 最常用的语法和示例。

语法

Child: >

作用：生成内部嵌套元素

例如： nav>ul>li

1<nav>
2 <ul>
3 <li></li>
4 </ul>
5</nav>

Multiplication: *

作用：生成重复元素例如： ul>li*5

1<ul>
2 <li></li>
3 <li></li>
4 <li></li>
5 <li></li>
6 <li></li>
7</ul>

ID and CLASS attributes

作用：ID 和 class 控制，# 对应 ID, . 对应 class 属性

例如：

1#header
2<div id="header"></div>
3.title
4<div class="title"></div>
5form#search.wide
6<form id="search" class="wide"></form>
7p.class1.class2.class3
8<p class="class1 class2 class3"></p>

Sibling: +

作用：生成兄弟元素

例如： div+p+bq

1<div></div>
2<p></p>
3<blockquote></blockquote>

Climb-up: ^

作用：虽然叫 climb-up ，但作用是跳出当前元素到元素的下面，多个 ^ 就是跳出多个父级元素。例如：

div+div>p>span+em^bq

1<div></div>
2<div>
3 <p><span></span><em></em></p>
4 <blockquote></blockquote>
5</div>

div+div>p>span+em^^bq

1<div></div>
2<div>
3 <p><span></span><em></em></p>
4</div>
5<blockquote></blockquote>

Item numbering: $

作用：生成元素序号例如：

ul>li.item$*5

1<ul>
2 <li class="item1"></li>
3 <li class="item2"></li>
4 <li class="item3"></li>
5 <li class="item4"></li>
6 <li class="item5"></li>
7</ul>

h$[title=item$]{Header $}*3

1<h1 title="item1">Header 1</h1>
2<h2 title="item2">Header 2</h2>
3<h3 title="item3">Header 3</h3>

ul>li.item$$$*5

1<ul>
2 <li class="item001"></li>
3 <li class="item002"></li>
4 <li class="item003"></li>
5 <li class="item004"></li>
6 <li class="item005"></li>
7</ul>

ul>li.item$@-*5

1<ul>
2 <li class="item5"></li>
3 <li class="item4"></li>
4 <li class="item3"></li>
5 <li class="item2"></li>
6 <li class="item1"></li>
7</ul>

ul>li.item$@3*5

1<ul>
2 <li class="item3"></li>
3 <li class="item4"></li>
4 <li class="item5"></li>
5 <li class="item6"></li>
6 <li class="item7"></li>
7</ul>

Custom attributes

作用：自定义元素

例如：

p[title="Hello world"]

1<p title="Hello world"></p>

td[rowspan=2 colspan=3 title]

1<td rowspan="2" colspan="3" title=""></td>

[a='value1' b="value2"]

1<div a="value1" b="value2"></div>

Grouping: ()

作用：分组

例如：

div>(header>ul>li*2>a)+footer>p

 1<div>
 2 <header>
 3 <ul>
 4 <li><a href=""></a></li>
 5 <li><a href=""></a></li>
 6 </ul>
 7 </header>
 8 <footer>
 9 <p></p>
10 </footer>
11</div>

(div>dl>(dt+dd)*3)+footer>p

 1<div>
 2 <dl>
 3 <dt></dt>
 4 <dd></dd>
 5 <dt></dt>
 6 <dd></dd>
 7 <dt></dt>
 8 <dd></dd>
 9 </dl>
10</div>
11<footer>
12 <p></p>
13</footer>

Text:

作用：为标签内添加文本内容

例如：

a{Click me}

1<a href="">Click me</a>

p>{Click }+a{here}+{ to continue}

1<p>Click <a href="">here</a> to continue</p>

有趣的知识

上面 gif 图中有个例子

ul>li*4>lorem4

效果是生成了如下代码

1 <ul>
2 <li>Lorem ipsum dolor sit.</li>
3 <li>Labore eum dignissimos exercitationem.</li>
4 <li>Et sed quod distinctio?</li>
5 <li>Voluptate dolor omnis maiores.</li>
6 </ul>

你知道 lorem 是什么东西吗？

其实它是用来表示随机文本的，用来进行占位的。它的全文是：

“

Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

”

这只是一段用来测试排版效果的占位文字，没有实际的含义。据说，16世纪的时候就有人开始用了。当时的某个印刷工人，从古罗马政治家西塞罗的文章中，选了一段拉丁文，“Neque porro quisquam est qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit “，进行了混排，就把它创造出来了。这句拉丁文的英译是"Neither is there anyone who loves grief itself since it is grief and thus wants to obtain it”，译成中文就是"无人爱苦，亦无人寻之欲之，乃因其苦……"（不知是谁的手笔，译得真漂亮啊。）

所以 lorem4 就是生成4个单词的随机文本

参考

你可以通过下面的地址看到 Emmet 完整的语法介绍

https://docs.emmet.io/cheat-sheet/

Google 高级搜索运算符完整列表（44 个）

Sun, 26 Nov 2023 04:20:02 +0000

Google 高级搜索运算符是过滤搜索结果的特殊命令和字符。他们通过使你的搜索更加精确和集中来做到这一点。

例如， site: 运算符将结果限制为来自特定站点的结果：

在这篇文章中，你将了解所有 Google 搜索运算符。

完整列表

以下是每个 Google 搜索运算符的作用的简要说明。我将它们分为三类：

Working – 按预期工作。
Unreliable – 谷歌并未正式弃用，但结果却时好时坏。
Not working – 已被 Google 正式弃用。

以下是完整列表

Working

搜索运算符	它能做什么	例子
“ ”	搜索提及单词或短语的结果	“steve jobs”
OR	搜索与 X 或 Y 相关的结果	jobs OR gates
		与 OR 相同
AND	搜索与 X 和 Y 相关的结果	jobs AND gates
-	搜索未提及单词或短语的结果	jobs -apple
*	通配符匹配任何单词或短语	steve * apple
( )	对多个搜索进行分组	(ipad OR iphone) apple
define:	搜索单词或短语的定义	define:AI
cache:	查找网页的最新缓存	cache:apple.com
filetype:	搜索特定类型的文件（例如 PDF）	apple filetype:pdf
ext:	与 filetype: 相同	apple ext:pdf
site:	从特定网站搜索结果	USB site:apple.com
related:	搜索与给定域相关的站点	related:apple.com
intitle:	搜索标题标签中包含特定单词的页面	intitle:apple
allintitle:	搜索标题标签中包含多个单词的页面	allintitle:apple iphone
inurl:	搜索网址中包含特定字词的网页	inurl:apple
allinurl:	搜索网址中包含多个单词的网页	allinurl:apple iphone
intext:	搜索内容中包含特定单词的页面	intext:apple
allintext:	搜索内容中包含多个单词的页面	allintext:apple iphone
weather:	搜索某个位置的天气	weather:beijing
stocks:	搜索股票代码的股票信息	stocks:baba
map:	强制 Google 显示地图结果	map:silicon valley
movie:	搜索有关电影的信息	movie:steve jobs
in	将一个单位转换为另一种单位	$329 in RMB (329美元兑换人民币)
source:	在 Google 新闻中搜索特定来源的结果	apple source:the_verge
before:	搜索特定日期之前的结果	apple before:2017-06-29
after:	搜索特定日期之后的结果	apple after:2017-06-29

“

您还可以使用 _ 运算符，它在 Google 中充当通配符。

”

Unreliable

搜索运算符	它能做什么	例子
#..#	在数字范围内搜索	iphone case 60
inanchor:	搜索带有包含特定锚文本的反向链接的页面	inanchor:apple
allinanchor:	搜索具有锚文本中包含多个单词的反向链接的页面	allinanchor:apple iphone
AROUND(X)	搜索两个单词或短语在 X 个单词之间的页面	apple AROUND(4) iphone
loc:	查找给定区域的结果	loc:“san francisco” apple
location:	在 Google 新闻中查找特定位置的新闻	location:“san francisco” apple
daterange:	搜索特定日期范围内的结果	steve jobs daterange:11278-13278

Not working (已被Google 正式删除)

搜索运算符	它能做什么	例子
~	在搜索中包含同义词	~apple
“+”	搜索提及确切单词或短语的结果	jobs +apple
inpostauthor:	在已停止使用的 Google 博客搜索中搜索特定作者的帖子	inpostauthor:”steve jobs”
allinpostauthor:	与 inpostauthor: 相同，但不需要引号	allinpostauthor:steve jobs
inposttitle:	在 Google 已停止使用的博客搜索中搜索标题中包含某些单词的帖子	inposttitle:apple iphone
link:	搜索链接到特定域或 URL 的页面	link:apple.com
info:	搜索有关特定页面或网站的信息	info:apple.com
id:	与 info: 相同	id:apple.com
phonebook:	搜索某人的电话号码	phonebook:tim cook
#	在 Google+ 上搜索主题标签	#apple

举例使用 Google 搜索运算符的几种方法

如果你知道如何使用和组合 Google 高级运算符，你几乎可以实现任何目标。因此，不要害怕尝试下面的示例。你可能会发现一些新东西。

查找可能的索引问题

密切关注网站的 site: 搜索结果可以发现潜在的索引问题。

例如，如果我们将其与 filetype: 运算符结合使用，我们会看到这家 3D 打印公司有相当多的 PDF 被索引：

如果这是故意的，这并不是一件坏事，但对于某一些人来说，就不一定了。

例如，其网站有一个关于 3D 打印机总拥有成本白皮书的潜在客户登陆页面：

但此 PDF 已建立索引，因此你无需填写详细信息即可轻松访问它：

网站所有者可能应该添加 x-robots noindex 标签来解决此问题。

找到您想要联系的人的电子邮件地址

人们经常在 Twitter 上分享他们的电子邮件地址，因此你可以使用搜索运算符来查找这些推文

例如，如果您想查找 Tim Soulo 的电子邮件地址，您可以搜索他的任何提及“email”和“gmail.com”或“ahrefs.com”一词的推文（因为他的电子邮件地址几乎可以肯定是在这些域）

如果你这样做，他的电子邮件地址会立即弹出：

查找相关的知乎问题并回答

知乎是一个网站，人们可以在这里提出问题，贡献者可以发布答案，最好的答案会被投票到顶部。

知乎的搜索功能效果很好。缺点是你一次只能搜索一个主题。

因此你可以使用以下搜索运算符来解决此问题：

site:quora.com intext:([topic 1] | topic 2)

例如，如果你有一个健康和健身网站，您可以搜索如下内容：

site:zhihu.com intext:( 蛋白质 | 肌肉 | 力量 )

喜欢很多年的一首歌

Wed, 11 Oct 2023 06:45:18 +0000

这首歌我喜欢很多年了，说来也怪，每次听它都能让我安静下来。

那是多年前的一个早晨，我起得很早，很早来到公司，屋子里空荡荡的，可能我是第一个到的。

脑子清醒得很，感觉好像有很长的时间可以 “肆意妄为”。

很随机地打开豆瓣，点击音乐，很随机地点开这首歌。然后开始单曲循环，时间变得很慢。

有一瞬间我甚至不记得那天要完成的工作是什么，想象自己是一个陪朋友喝了半夜的酒，坐船到对岸回家的人……

那应该是第一班船，船上人不算多，有个抱孩子的女人坐在对面，穿着格子上衣，黑色头发，时而低头哄孩子，时而看向船外的远方。

她注意到我在她看，礼貌又有些不好意思地笑了笑，然后继续哄着孩子。

我那个朋友酒量一般，今晚却特别 “能喝”，一瓶接着一瓶，他显然是会醉的。毫无疑问。

他问我有没有感觉今天特别冷，我说秋天了嘛，天自然是凉了。他说他们认识的时候也是秋天，那年秋天景色特别好。

我说，别光顾着喝，吃点儿东西……

他吐了，不出所料。他说，你回吧，明天还要上班。

我看着他晃晃悠悠坐上出租车，喊老板结账，打包了些吃的。

我买了船票，坐上了船。城市还没有醒来，路灯还格外地刺眼，我也有些醉了。

迷迷糊糊地，我分不清自己在哪儿，船是向前开还是向后开。恍惚间想起了我们刚来这里时的样子。那时候有四五个人，好像也是这个时间，不同的是，我们格外兴奋和激动，嘴上说个不停，甚至有人在唱歌。而现在这船上，就只剩下我了。

忽然一声巨大而沉闷的汽笛声把我从回忆里惊醒，海风很大，我的酒醒了不少。

其实我明天不上班，因为没有班可上。

看着手里的食物想起这些年我仍然吃不惯这里的东西，苦笑了一下。

回过神，对面的女人已然不在了，我在想，是不是在哪儿见过她？想不起来，无所谓了。

海风很大，海浪的声音很响，除了海浪声，我好像什么声音都听不进去，就这么漂着，漂着。

下船时天亮了不少，手机响，打开是朋友发来的微信红包：“饭钱”。

ShangHai Wulumuqi Rd.(M)

Sun, 27 Nov 2022 06:36:23 +0000

南京传媒大学

吉林大学

西安外国语大学

华中科技大学

深圳大学

西安理工大学

中国美术学院

西北政法大学

上海大学

上海交通大学

中国石油大学

四川美术学院

四川传媒学院

中国政法大学

暨南大学

南京林业大学

浙江万里学院

四川电影电视学院

河北传媒学院

中国人民大学

华中科技大学同济医学院

湖南大学

中国矿业大学

广州美术学院

西安美术学院

武汉大学

重庆大学

四川外国语大学

华中师范大学

南京艺术学院

青岛电影学院

华东政法大学

浙江传媒学院

中国戏曲学院

中央戏剧学院

武汉理工大学

山东大学

复旦大学

天津美术学院

中山大学

浙江大学

华南理工大学

上海戏剧学院

东北农业大学

北京电影学院

广州美术学院

北京航空航天大学

成都大学

四川师范大学

北京服装学院

鲁迅美术学院

杂谈 on 小盒子的技术分享

neo 下一代家庭人形机器人

分享几个扣子的邀请码

分享几个扣子的邀请码

九个技巧，让你的Python代码运行得更快！

1. 更快的字符串连接：巧妙选择 “join()” 或 “+”

2. 更快的列表创建：使用"[]“而不是"list()”

3. 更快的成员测试：使用集合而不是列表

4. 更快的数据生成：使用推导式而不是 for 循环

5. 更快的循环：优先使用局部变量

6. 更快的执行：优先使用内置模块和库

7. 更快的函数调用：利用缓存装饰器进行简单的记忆化

8. 更快的无限循环：优先选择 “while 1” 而不是 “while True”

9. 更快的启动：智能导入 Python 模块

理解 Python 中的星号用法

一、函数中的*args和**kwargs

1. *args在函数定义中的使用

2. 在函数调用中使用*

3. **kwargs在函数定义中的使用

4. 在函数调用中使用**

二、限制函数调用方式

1. 仅允许关键字参数

2. 仅允许位置参数

三、在列表和字典构造中的使用

1. 构造列表

2. 构造字典

四、列表解构

结语

关于“小作文” 事件 写了个脚本方便大家吃瓜

日志为什么叫 "log"

疑问

答案

如何快速编写 HTML CSS 代码

语法

Child: >

Multiplication: *

ID and CLASS attributes

Sibling: +

Climb-up: ^

Item numbering: $

Custom attributes

Grouping: ()

Text:

有趣的知识

参考

Google 高级搜索运算符完整列表（44 个）

完整列表

Working

Unreliable

Not working (已被Google 正式删除)

举例 使用 Google 搜索运算符的几种方法

查找可能的索引问题

找到您想要联系的人的电子邮件地址

查找相关的知乎问题并回答

喜欢很多年的一首歌

ShangHai Wulumuqi Rd.(M)

一、函数中的`*args`和`**kwargs`

1. `*args`在函数定义中的使用

2. 在函数调用中使用`*`

3. `**kwargs`在函数定义中的使用

4. 在函数调用中使用`**`

关于“小作文” 事件写了个脚本方便大家吃瓜

举例使用 Google 搜索运算符的几种方法