X分钟讲解Y系列

2018年05月16日留言

Every Linux Distro Explained in 13 Minutes

https://www.youtube.com/watch?v=QFzXQNZ6zvQ

Ubuntu

Ubuntu 是一个非常受欢迎的 Linux 操作系统，以用户友好和庞大的社区而闻名。它使用一个简单但直观的桌面界面。Ubuntu 是免费且开源的，这意味着你可以自由修改并分发它。

Ubuntu 有很多变种：

默认的 Ubuntu，适用于普通使用；
Kubuntu，如果你想比 Windows 或 Mac 有更多自定义界面；
Xubuntu，一个轻量级操作系统；
Lubuntu，适用于非常老的电脑；
Ubuntu Mate，提供更经典的 Ubuntu 体验；
Ubuntu Budgie，带来更现代和精致的体验；
Ubuntu Studio，适合创作者使用。

Ubuntu 非常适合刚开始接触 Linux 的新手、服务器管理员以及注重隐私的用户，因为它不像 Windows 或 Mac 那样有追踪功能。

Ubuntu 是基于 Debian（DBN）的。

Debian

说到 Debian，它是最古老、最稳定的 Linux 操作系统之一，以强调开源而著称。它可以用于桌面、服务器和嵌入式系统。与 Ubuntu 不同，Debian 完全由社区驱动，没有企业支持。Debian 支持多种桌面环境，如 Gnome、KDE Plasma、XFCE 或 LXDE。Debian 是许多其他 Linux 发行版的基础。

Kali Linux

Kali Linux 是另一个基于 Debian 的发行版，专为网络安全和道德黑客设计。它是 BackTrack Linux 的继承者，内置数百种安全工具。它包括数字取证、网络分析和漏洞扫描工具，如 Metasploit、Wireshark、Burp Suite 和 Aircrack-ng。Kali Linux 可在 Raspberry Pi、安卓设备和嵌入式系统上运行。主要用户包括道德黑客、IT 安全专家、网络安全学生以及取证调查人员。缺点是它不像其他发行版那样适合初学者。它还有其他版本，如 Kali Light 和 Kali ARM。

Arch Linux

Arch Linux 是一个轻量级、DIY 风格的滚动更新 Linux 发行版。它以极简主义和高度可定制而著称。与 Ubuntu 不同，Arch 没有预配置设置。你需要从零开始构建系统，可以选择内核、桌面环境和软件栈。主要适用于希望完全掌控系统的高级用户，也适合 Linux 爱好者和追求最新软件的用户，因为 Arch 是滚动更新的。但就像 Kali Linux 一样，它不适合初学者。

Fedora

Fedora 是由 Red Hat 支持的 Linux 发行版，是 Red Hat Enterprise Linux 的测试平台。它专注于创新和最新软件，提供多个变种：KDE Plasma（可定制桌面）、XFCE（轻量级）、LXQT（超轻量）、Server（服务器版）和 CoreOS（云平台专用）。它拥有强大的安全性，默认启用 SELinux（Security Enhanced Linux），并且发布周期很短，每 6 个月就有一个新版本。趣闻：Linux 之父 Linus Torvalds 使用 Fedora。

Tails

Tails 是一个专注隐私的 Linux 发行版，旨在实现最大程度的匿名性。它会通过 Tor 浏览器路由所有网络流量，并且在关闭时不会留下任何数字痕迹。它可以从 DVD 或 USB 启动，关机后自动清除所有数据。它预装了多个隐私工具，如用于加密邮件的 Enigma、密码管理器 KeePass、安全文件分享工具 OnionShare。Tails 的缺点是由于路径重定向，网络速度较慢，而且需要手动更新，不适合日常计算使用。历史上，Tails 被压迫xx下的活动家、隐私保护者和举报人使用。

Mint

Mint 是一个非常用户友好的基于 Ubuntu 的发行版，专为桌面用户设计。如果你想要一个稳定且易于使用的系统，它是个不错的选择，因为它以“开箱即用”的体验而著称。它拥有类似 Windows 的布局，提供多个版本，如最流行的 Cinnamon、适用于老电脑的 XFCE、轻量级的 Mate。Mint 非常适合那些不喜欢 Ubuntu 的 Snap 软件包机制或从 Windows 迁移过来的用户。

OpenSUSE

OpenSUSE 是一个多功能、社区驱动的 Linux 发行版，由 SUSE 公司赞助。它有两个版本：Leap（稳定版，适合服务器和工作站）和 Tumbleweed（滚动更新版）。OpenSUSE 非常适合系统管理员、开发者或 KDE 桌面环境爱好者。它的变色龙 logo 象征其高度适应性。

Pop!_OS

Pop!_OS 是一个基于 Ubuntu 的 Linux 发行版，由 System76 开发。它为创作者、开发者和游戏玩家而设计，因支持 NVIDIA 和 AMD GPU 而具有高性能。它非常用户友好且高度可定制，采用 GNOME 桌面环境。它适合 STEM 领域用户，预装了 TensorFlow、CUDA、VS Code 和 Python。它也支持游戏，拥有混合图形支持。虽然听起来复杂，但它对想要精致、无烦恼体验的 Linux 初学者来说其实也很友好。

Red Hat Enterprise Linux

Red Hat Enterprise Linux 是一个商业级企业 Linux 发行版，由 Red Hat 公司开发。与其他发行版不同，它不是免费的，需要付费订阅来获取更新和技术支持。它默认启用 SELinux，每个主版本有 10 年的生命周期。它为企业级数据中心和云计算进行了优化，并兼容数千种企业应用。Red Hat 被银行、财富 500 强公司、政府和军方、高安全性需求单位、AWS 或 Azure 等云服务商及 IT 管理员广泛使用。

CentOS Stream

CentOS Stream 是一个 Linux 发行版，作为 Red Hat Enterprise Linux 的上游版本，起到未来更新的测试平台作用。与 Red Hat 不同，它是免费的、由社区驱动的。CentOS Stream 是 CentOS 项目唯一存续的版本，传统的 CentOS 8 已于 2021 年停止支持。如果你想提前体验 Red Hat 的功能，CentOS Stream 是个好选择。

Raspberry Pi OS

Raspberry Pi OS 是 Raspberry Pi 官方的基于 Linux 的操作系统，由 Raspberry Pi 基金会设计，针对低功耗 ARM 硬件优化。它预装了摄像头和传感器控制工具、自有 Python IDE、VLC 和 Chromium 浏览器。提供 32 位、64 位和无图形界面的轻量版本。适用于机器人、家庭自动化爱好者、教育工作者、STEM 学生及学习 Python 或 Scratch 的初学者。

Parrot OS

Parrot OS 是一个专注安全的 Linux 发行版，专为渗透测试设计。内置 600 多种工具，是一个比 Kali Linux 更精致的选择。自带 VPN 和 MAC 地址伪装功能。它有多个版本：Parrot Security（用于渗透测试和黑客）、Parrot Home（注重隐私的日常使用）、Parrot ARM（适用于树莓派和移动设备）、Parrot Cloud（用于服务器和云端渗透测试）。Parrot OS 被全球执法机关和网络安全专家使用。

Puppy Linux

Puppy Linux 是一个便携式 Linux 发行版，专为非常老旧或低配置硬件而设计。与其他发行版不同，Puppy 完全加载到内存中运行，即使只有 256MB 内存也能极快运行。无需硬盘，可从 USB 启动。它有多种版本，如 Fauci Pup（通用）、Bionic Pup（旧硬件）、Slacko Puppy（轻量级）、Tahrpup（适用于更古老电脑）。整个系统的大小不到 300MB。

Rocky Linux

Rocky Linux 是一个 1:1 兼容 Red Hat Enterprise Linux 的发行版。它是在 Red Hat 停止 CentOS 后创建的，免费且由社区拥有。它针对云计算、数据中心和高性能计算进行了优化。如果你想要 Red Hat 的兼容性但不想付费，Rocky Linux 是个不错的选择。

Alpine Linux

Alpine Linux 是一个极其轻量级、专注安全的 Linux 发行版，主要用于边缘计算和极简主义。它是 Docker 和 Kubernetes 用户的常用选择，其基础镜像大小仅为 5MB。

Steam OS

Steam OS 是由 Valve 开发的基于 Linux 的操作系统，主要用于运行 Steam Deck。它是一个基于 Arch Linux 的专用发行版，专为运行 Steam 游戏而设计，界面类似游戏机，支持滚动更新，桌面模式采用 KDE Plasma。尽管为 Steam Deck 优化，但也可在普通电脑上运行。

antiX

antiX 是一个轻量级的基于 Debian 的 Linux 发行版，专为老旧电脑设计。与 Puppy Linux 不同，antiX 是全功能操作系统，可运行在 2000 年代早期的硬件上。它没有臃肿软件，适合注重隐私的用户。但它不适合游戏、现代应用或追求精致桌面体验的用户。

Gentoo

Gentoo 是一个高度可定制的 Linux 发行版，适合希望对系统拥有完全控制的高级用户。它将定制推向极致。你知道吗？Google 的 Chrome OS 最初就是基于 Gentoo 的。

Slackware

Slackware 是现存最古老的 Linux 发行版之一，首次发布于 1993 年，以其简洁、稳定和类 Unix 哲学著称。它被称为最像 Unix 的 Linux 发行版。安装过程没有图形界面，全部基于文本。更新非常保守，发布前经过充分测试。适合想深入学习 Linux 的资深用户。

NixOS

NixOS 是一个独特、声明式的 Linux 发行版，围绕 Nix 包管理器构建。你可以用一个配置文件定义整个操作系统。如果你想要传统的点击操作体验，这不是你的选择；但如果你想要一个适合 DevOps 的系统，支持原子更新和回滚功能，Nix 是一个好选择。Nix 被 Bloomberg、Shopify 和 AWS 使用。

Peppermint OS

Peppermint OS 是一个基于 Debian 的云优先 Linux 发行版，轻巧快速，适合旧硬件。它有一个网站专用浏览器管理器，可以把 Gmail、Discord 等网络应用变成桌面快捷方式。界面简洁，类似 Windows。

Void Linux

Void Linux 是一个独立的滚动发布 Linux 发行版，以其独特的初始化系统而著称。它不基于 Debian、Arch 或 Red Hat，而是完全从零构建，注重简洁并避免使用 systemd。它适合非常高级的 Linux 用户，默认没有图形安装程序，软件包经过严格测试，实现滚动更新但稳定性强。

AlmaLinux

AlmaLinux 是一个免费开源的 Linux 发行版，也可以作为 Red Hat Enterprise Linux 的兼容替代。它实现了 bug 对 bug 的兼容，但没有授权费用，由非营利组织 AlmaLinux OS 基金会支持。它非常适合 Web 服务器和云环境，针对 Apache、Nginx、MySQL、Azure 和 AWS 等进行了优化。AlmaLinux 的名字来自拉丁语“Alma”，意为“灵魂”，体现了其社区精神。它被 Wikipedia、Docker 和 Microsoft Azure 等使用。

Manjaro

Manjaro 是一个用户友好的基于 Arch 的 Linux 发行版，旨在提供 Arch 的强大功能但更易安装，开箱即用。它可以访问 Arch 用户仓库，有多个桌面版本，如 Manjaro KDE、GNOME、XFCE 和 Sway。它也是一款为游戏准备好的发行版，自动检测 Nvidia 和 AMD 驱动。

MX Linux

MX Linux 是一个中等体量、基于 Debian 的 Linux 发行版，力求在性能和用户友好之间取得平衡。它带有一些独特工具，如 MX 安装器、MX 快照和 MX 软件包安装器。

EndeavourOS

EndeavourOS 是一个用户友好、终端为中心的 Linux 发行版，基于 Arch Linux。它填补了原始 Arch（完全手动）和 Manjaro（预配置）之间的空隙，旨在提供更顺畅的 Arch 体验，又不牺牲 DIY 精神。它鼓励学习 Arch 命令（如 pacman 和 yay），可访问 Arch 用户仓库，支持游戏和硬件，内置 Steam、Wine 和 Proton。它基本上是带辅助轮的 Arch Linux。

请确保分享这个视频，谢谢观看！

Every Programming Language Ever Explained in 15 Minutes

汇编语言 是一种低级编程语言，它允许人类向计算机硬件发出指令。你知道，计算机只能以0和1的形式执行操作，所以汇编语言的诞生就是为了让计算机指令对人类来说更易于操作。它通过一种叫做汇编器（Assembler）的工具，将人类可读的代码翻译成计算机能理解的0和1。

汇编语言是世界上最早的编程语言之一，曾经是运行超级计算机的标准语言。即便在今天，它仍然被用于处理CPU内存等底层操作，有时也通过WebAssembly在浏览器中使用。

Fortran 是世界上最早的高级编程语言之一。高级语言与低级语言的区别在于：使用低级语言可以更直接地操作计算机内存，执行速度也更快，但学习难度较大；而高级语言更易于理解，支持也更多，但运行速度较慢。

Fortran由IBM在1950年代创建，名称是“Formula Translator”（公式翻译器）的缩写。编写Fortran程序当时需要使用打孔卡，然后通过打卡机读取，并被翻译成计算机可理解的代码，这个翻译过程就叫做“编译”，即将人类可读代码转化为0和1。

Comtran（Commercial Translator）是IBM开发的另一种编程语言，被视为Fortran在商业领域的对应版本。Fortran主要用于科学计算，而Comtran则用于商业数据处理。它还受到了另一种编程语言Flow-Matic的影响，该语言运行在一台名为UNIVAC 1的巨型计算机上。

LISP（List Processing）在Fortran之后不久被创建。它以在代码中使用大量括号而闻名，是一门非常具有创新性的语言，启发了许多编程概念。

COBOL（Common Business-Oriented Language）是一种在1959年为商业用途开发的编程语言。虽然它诞生已有几十年，今天仍被许多金融机构用于处理交易。这种语言的代码看起来像英语句子，随后会被转译到打孔卡中。美国国防部是该语言的早期用户之一。

IBM RPG（Report Program Generator）是IBM开发的一种编程语言，主要运行于IBM系统上。它是为数不多使用行和列结构编写代码的编程语言之一。

ALGOL 60（Algorithmic Language 1960）是一种不太为人所知的编程语言，但它启发了后来非常著名的语言---C语言。它也是最早支持嵌套函数的编程语言之一。

APL（A Programming Language）出现于1960年代，主要为了解决代数等数学问题。它在代码中大量使用数学符号和希腊字母。

SIMULA 是几十年前开发的一种编程语言，被认为是世界上最早的面向对象编程语言之一。面向对象编程是一种将代码封装成可重用模块（对象）的方式，对象由类创建，具有属性和方法。例如你可以创建一个类叫“Pokemon”，生成一个叫“Charmander”的对象，赋予它“火属性”，并让它执行“喷火”和“抓挠”等方法。

SPEAKEASY 是1960年代物理学家常用的一种编程语言，它以在代码中使用颜色而著称。

BASIC（Beginner’s All-purpose Symbolic Instruction Code）诞生于1963年的达特茅斯学院，旨在让普通大众也能学会编程。在此之前，编程仅限于科学家和数学家使用。BASIC的语法非常简单易懂，语法指的是编程语言中写代码的规则。

MUMPS（Massachusetts General Hospital Utility Multi-Programming System），有时简称为“M”，是为管理医院实验室信息系统和电子健康记录而创建的。它的代码非常简洁，很多命令都可以简写为几个字母。

LOGO 是1960年代开发的一种教育类编程语言，它使用一种叫“海龟绘图”的功能（不是实际的乌龟，而是光标的名字）来绘制几何图形。

Pascal 是1970年代非常流行的一种编程语言，甚至曾是很多电脑的默认语言。它是最早支持IDE（集成开发环境）的编程语言之一。Photoshop就是用Pascal开发的。

C语言 是1970年代由贝尔实验室开发的，至今仍是最受欢迎的编程语言之一，是很多操作系统（如Windows和Linux）的基础。它启发了后来的C++、Objective-C、Go、Java、JavaScript、PHP、Python等语言。C语言以其对内存的低级访问能力而闻名，通过使用“指针”来操作内存。在过去，计算机内存非常有限，程序员必须小心分配，否则会导致内存泄漏，使电脑变得非常慢。

Smalltalk 是1970年代的一种编程语言，以其面向对象编程而知名，启发了许多后来的面向对象语言。

Prolog 是第一种逻辑编程语言，建模理念源于哲学中的形式逻辑。

ML（Meta Language）开创了静态类型的函数式编程，意即数据类型在编写时就明确，如字符串、整数、浮点数或布尔值。字符串是文字和字母，整数是整数，浮点数是带小数的实数，布尔值是“真”或“假”。

SQL（Structured Query Language）是一种用于创建和管理数据库的语言。信息储存在“表格”中，结构由行和列组成。代码看起来像英语句子。今天仍广泛用于存储用户名、密码、交易记录、账户信息等。可以将其类比为Excel表格系统。

C++ 是C语言的扩展，主要区别是它支持面向对象编程，而C语言不支持。C++以学习曲线陡峭著称，但至今仍被广泛用于开发操作系统、网页浏览器、数据库和游戏，是最重要的编程语言之一。

Ada 是1980年代由美国国防部开发的编程语言，命名来自世界上第一位程序员 Ada Lovelace。

MATLAB（Matrix Laboratory）是一种为数据科学家和工程师设计的数学编程语言，广泛用于统计、机器人、人工智能，在学术界仍被广泛使用。

Objective-C 是1980年代受C语言启发而创建的编程语言，曾是苹果电脑和早期iPhone的主语言。虽然它的流行度逐渐下降，但仍可见于某些开发中。苹果在2020年代中期用Swift取而代之。

LabVIEW 是1980年代由National Instruments开发的一种图形化编程语言，不使用传统代码，而是通过图像构建用户界面和处理逻辑。

Erlang 是为电信行业设计的编程语言。

Perl 是一种非常适合处理文本的编程语言，广泛应用于系统管理、网络编程、金融等领域，人称“维系互联网的胶水”。不过其代码看起来可能比较奇怪。

Wolfram Language 是由Stephen Wolfram创建的，可以用于数据可视化、图像处理、数学计算等几乎所有任务，甚至可以帮你找出穿越欧洲的最短路线。

Haskell 是一种函数式编程语言，变量不可变（即声明后不能更改），基于λ演算。

Visual Basic 是微软在1990年代初推出的编程语言，用于创建带有图形用户界面的程序。图形界面即你用鼠标操作的所有屏幕元素。它也有一个同名的IDE。

（以下内容因篇幅较长，分下一条回复继续整理）

Every Programming Language Ever Explained in 8 Minutes Part 2

https://www.youtube.com/watch?v=U1emdbGzKzk

Brainf（是的，它真的叫这个）是一种非常奇特的编程语言，它只使用八个字符。这就是它的代码样子---每一个字符都有其用处。你可以进行数据输入输出、执行条件循环等等。你知道下面这段代码是做什么的吗？它的作用是输出“hi”这个词（小写）。而下面是大写的版本。如果有人能翻译这段代码，我会送你一个饼干。

Malbolge 被称为人类已知最难的编程语言，名字来自《神曲》中地狱的第八层圈。它之所以困难，有几个原因。一般编程语言编译成的是机器码（二进制），而Malbolge 编译成一种叫“三进制”（trinary）的东西，它使用0、1和2三种数字。

另外，你输入的内容还必须先经过一层加密处理，并且数据是通过一个叫“疯狂操作符表”（crazy operator）的表格来解释的。所有这些疯狂的机制，使得Malbolge 的代码看起来就像这样：

由于这些复杂结构，Malbolge 最初并不图灵完备。人们花了2年时间才弄清楚如何用它输出“Hello, World”，而且，这个解决方法不是人想出来的，而是一个算法完成的。

Forth 是一种在1970年诞生的编程语言，它是基于“堆栈”的语言。堆栈是一种数据结构，就像是积木一样层层叠加，采用“先进后出”（FILO）的方式处理数据。

你知道电脑的“撤销”功能吗？就是用堆栈实现的。电脑会记住你在程序中执行的每一步操作，撤销时就从堆栈顶部移除一步。将数据放入堆栈叫“压栈”（push），移除数据叫“出栈”（pop）。

ATLAS（Abbreviated Test Language for All Systems）是一种用于自动化测试设备的编程语言。它主要用于执行车辆和机器的诊断测试，广泛应用于航空航天和军事领域。它的语法中包含大量缩写词。

RPG II 是由IBM开发的RPG语言（报告程序生成器）的第二个版本，是一种固定格式的编程语言，允许程序员通过列来书写代码。虽然这门语言很老，但在金融和制造业中仍有应用。它也有后续版本，比如RPG III 和 RPG IV。

REXX 是IBM开发的另一种编程语言，全称是 Restructured Extended Executor，主要用于自动化和在IBM大型机上处理数据。它的代码几乎像英语句子一样易读，不使用复杂符号或花括号。

KAL（Common Algorithmic Language），1970年代在丹麦创建。代码读起来像英语，也不使用太多特殊符号或花括号。最初为小型计算机设计，后来被改编为可运行于微型计算机上。

Mojo 是一种 Python 的超集语言，也就是说，如果你已经会 Python，那么学 Mojo 不太费劲。它的主要优势是运行速度比 Python 快很多。Python 是一门非常通用的语言，但人们经常批评它太慢。而 Mojo 结合了高级语言的简洁性与低级语言的速度，主要用于机器学习和人工智能领域。不过，这门语言非常新，因此相关资料还不太多。

Bash 既是命令行程序也是脚本语言，它使用一种叫“Shell”的命令行界面。你可以用它来自动化日常任务、管理文件，甚至自定义用户界面。学会基础很简单，但精通却很难。Bash 在 Linux 和 Unix 系统中非常实用。

Visual FoxPro 是一种用于数据库（如dBase和Microsoft Access）操作的语言，它有一个同名的IDE，内置可视化拖拽编辑器，用于创建图形用户界面、表单和菜单。后续版本还加入了面向对象编程功能。不过，该语言自2015年起已停止支持。

dBase 是数据库管理语言，虽然不再更新，但曾经推出过多个版本，如dBase II、dBase III 和 dBase III Plus。dBase 也是一个数据库管理系统。

Clipper 也是一种用于数据库编程的语言，可以与dBase结合使用，但运行速度更快，因为它使用即时编译（Just-in-Time compiling）。不过，自1990年代以来Clipper已不再更新，逐渐被淘汰。

Uniface 是一种编程语言和开发平台，采用低代码开发方式，也就是说你只需写少量代码，配合拖拽编辑器就能构建按钮、菜单和表单等组件。它还可用于数据库管理。但由于社区规模较小，获取支持可能较困难。

SPSS（Statistical Package for the Social Sciences）并不是像C++或Java那样的传统编程语言，而是一款带有专用命令语法的软件包，主要用于学术研究和统计分析。其界面看起来类似Microsoft Excel。

VHDL（VHSIC Hardware Description Language），VHSIC 是“Very High Speed Integrated Circuits”的缩写。这是一种用于电路板和集成电路的语言，用于控制逻辑门、内存等电路运作。最初由美国国防部命令创建。

Scheme 是LISP家族的一员，也使用大量括号，优化支持Lambda函数的执行。

PLEX 是为爱立信的AX电话交换机设计的专用语言，用于控制电话交换、确保连接顺畅和管理系统资源。PLEX 是一种遗留语言，现已不再被现代系统使用。

GML（Game Maker Language）是专为 Game Maker Studio 而设计的语言。它分为两种类型：GML代码和GML可视化。GML代码就是通过代码编辑器编写，而GML可视化则是通过拖拽图形控制游戏功能。无论是哪种方式，最终都会编译为相同的内容。

IDL（Interactive Data Language）主要用于科学领域，如物理、生物、地质、天文、大气物理、医学影像等，擅长处理大量数据并进行计算。所使用的软件还支持数据可视化。

ALAM 是一种用于并发编程的语言，允许你创建可以同时执行多个任务的程序。它的名字来源于哲学家威廉·奥卡姆（William of Ockham），就像“奥卡姆剃刀”这个思想实验一样，这门语言也以简洁为设计理念。

B语言 是C语言之前的语言，与C语言不同的是，B语言没有数据类型（如字符、整数、浮点数），也不支持结构体和指针，且可移植性也较差。B语言最早是为了简化BCPL语言而在贝尔实验室开发的。

Verilog 是为电路和微芯片设计的语言，主要由硬件工程师使用，也能执行计算和数据存储。它属于硬件描述语言（HDL），与传统编程语言不同，HDL代码不是由CPU执行，而是被硬件部件（如集成电路IC、数字信号处理器DSP）使用。

TCL（Tool Command Language），有时发音为“Tickle”，是一种用于脚本编写、创建应用、自动化任务等多用途的语言。它由John Ousterhout在1980年代创建，是一种多范式语言，支持面向对象编程和函数式编程。

D语言 是在C之后出现的一种语言，也叫“Dang”，创建于2000年代，目标是成为C/C++的现代版本。不同的是，D语言自动管理内存，无需像C那样使用指针，也更擅长并发编程，支持多线程。

ABAP（Advanced Business Application Programming）是一种主要用于商业领域的语言，用于构建企业应用、管理数据和处理业务逻辑。

Odin 是一种较新的编程语言，可用于构建游戏引擎、网页服务器和数据分析工具。它使用LLVM作为编译工具。

（完）

13 分钟讲解所有 Python 库/模块

https://www.youtube.com/watch?v=Yh5gcLG6C3Q

Every Python Library / Module Explained in 13 Minutes

Pygame

Pygame 是一个 Python 模块，可以让你开发视频游戏。当你导入 Pygame 后，通常会从设置屏幕的高度和宽度开始。Pygame 允许你通过代码绘制图形和对象。之后，你可以添加事件监听器，监听键盘按键，从而控制对象在屏幕上的移动。你还可以上传图像和音效，并在游戏中使用它们。它还支持动画和碰撞检测。

人们通常使用 Pygame 来创建 2D 游戏，但在 OpenGL 的帮助下，也可以进行 3D 游戏开发。

TensorFlow

TensorFlow 是一个用于机器学习的 Python 库。它的名称来源于线性代数中的“张量”（tensor），这是它所使用的数学形式。你可以用它来构建人工智能模型，具备图像识别、语音识别、深度学习等能力。你可以从互联网上获取样本训练数据，然后将其导入 Python 项目或 Jupyter Notebook 中，再使用如 Keras 这样的深度学习 API 创建人工神经网络。

PyTorch

PyTorch 是另一个用于构建神经网络的库。与 TensorFlow 不同，PyTorch 更加用户友好，不依赖像 Keras 这样的 API。虽然 TensorFlow 的学习曲线更陡峭，但它也可以进行数据可视化；而 PyTorch 则依赖外部库来完成这一点。使用 PyTorch 构建神经网络非常简单，例如在图像识别中，你可以将每一个像素作为输入层，然后定义多个隐藏层，并指定每个节点使用的激活函数，且代码量非常少。

Tkinter

Tkinter（也称为 Tinker 或 Tkinter） 是一个用于构建图形用户界面的 Python 工具。它自带预设小部件，允许你轻松创建文本框、按钮、菜单等。你还可以使用行和网格来控制程序的外观和布局。它也可以与数据库结合使用，并进行 API 调用。Tkinter 与其他 Python 库（如 Matplotlib）配合使用效果也非常好。基本上，屏幕上你能看到的东西，都可以用 Tkinter 创建。

OpenCV

OpenCV（Open Computer Vision）是一个著名的图像识别库。但图像识别只是它的冰山一角，它在实时对象检测、人脸识别、手部追踪、运动控制、使用 AI 进行物体识别、增强现实等方面表现出色，甚至可以让机器人“看见”。

https://github.com/opencv/opencv 是用C++开发的

https://github.com/opencv/opencv-python 为python版本

NumPy

NumPy（Numerical Python 的缩写）是一个用于科学计算的包，主要用于构建多维数组。那么什么是多维数组呢？在原生 Python 中，你可以使用列表来存储多个信息，比如一个购物清单或数字列表。但把多个项目放在一个列表中，并不意味着它们在内存中是连续存储的。NumPy 确保你输入的数据在内存中是连续排列的。

一个列表是一维数组，如果你使用行而不是列来排列项，就创建了一个网格，这就是多维数组。二维数组被称为矩阵，而超过二维的数组被称为张量。总之，NumPy 让数据和信息的处理更加高效。

Pandas

Pandas 是一个用于数据科学的 Python 库。它允许你通过数据框（DataFrame）来结构化信息。数据框是由行和列组成的表格，有助于组织信息。一个完整的表格是二维数据框，而一列数据则是一维数据框。你可以导入和导出数据，也可以创建 CSV 或 TXT 文件。基本上，只要是与数据处理相关的内容，Pandas 都擅长。Pandas 是建立在 NumPy 之上的。

Kivy

Kivy 是一个用于开发移动应用或其他触屏界面的 Python 框架。Kivy 允许你创建自然用户界面（NUI），不同于图形用户界面，NUI 使用语音命令、触摸手势、眼动、面部识别等方式，不再依赖按钮点击。它使用诸如标签、图像和输入框等小部件。

BeautifulSoup

BeautifulSoup 是一个用于网络爬虫的 Python 模块。它允许你从网站抓取 HTML 元素，并可以筛选要提取的元素类型，比如链接、div 等。

MechanicalSoup

MechanicalSoup 也是一个用于网络爬取的 Python 模块，不过它更适合数据库操作，也可以抓取 HTML 元素。

Selenium

Selenium 同样是一个 Python 网络爬虫工具，但与只抓取 HTML 和 XML 的 BeautifulSoup 不同，Selenium 可以抓取更多 UI 内容，非常适用于动态网站和高度交互性的网站。例如，你可以自动化抓取 Instagram 上的标签、话题或其他内容。

https://github.com/SeleniumHQ/selenium

https://github.com/seleniumbase/SeleniumBase

更多算是自动化测试框架吧

Scrapy

Scrapy 是一个完整的 Python 网络爬虫框架，用于构建网络蜘蛛和机器人。Scrapy 适合大规模网页爬取，不仅可以抓取网站，还能处理抓取的数据。而 BeautifulSoup 只抓取 HTML，Selenium 自动化操作动态网站。

SQLite

SQLite 允许你在 Python 项目中使用 SQL 创建无服务器数据库。你可以建立数据库连接和游标，然后像平常一样写入 SQL 代码，包括创建表、插入、删除、更新和读取数据，它还会自动生成数据库文件。

https://github.com/sqlite/sqlite 原始项目用C开发

Pillow

Pillow 是一个用于图像处理和编辑的 Python 包，是 Python Imaging Library（PIL）的分支。它允许你导入和导出图像，进行图像编辑、绘图、添加滤镜等。虽然看起来只是用于图像编辑，但实际上你也可以在数据科学、AI 和 Web 开发中使用 Pillow。

Matplotlib

Matplotlib 是一个用于数据可视化的 Python 包，可以创建图形、图表和绘图，并进行自定义。它通常与 NumPy 和 Pandas 一起使用，用于探索数据、发现模式、洞察和趋势。

SymPy

SymPy 是一个强大的数学包，用于执行符号运算。它可以做代数、因式分解、解方程，甚至是微积分，比如求导和积分。可以说是功能强大的计算器。

SciPy

SciPy 是一个用于科学计算的 Python 包，包括微积分、线性代数和统计学。它基本上是 NumPy 的增强版。SciPy 用于数值计算，而 SymPy 用于符号运算。

Scikit-learn

Scikit-learn 是一个用于机器学习的库，专注于监督学习和无监督学习。与 TensorFlow 和 PyTorch 主要专注于深度学习不同，Scikit-learn 更适用于通用机器学习。

PyBrain

PyBrain 是一个基于 Python 的强化学习人工智能神经网络库。这个库已不再维护，但在活跃开发时，用于构建神经网络。现在已有更好的替代品，如 TensorFlow 和 PyTorch。

Theano

Theano 是一个用于数值计算的库，适用于深度学习，也已不再维护。它可以进行符号计算，并使用 GPU 提升性能。

NLTK

Natural Language Toolkit（NLTK） 是一个自然语言处理的库。它允许你使用大量单词的训练数据（称为语料库），并进行分词（将词语分开以便训练神经网络）。它还可以实现如 NRS 算法等算法，该算法使用前文单词预测下一个单词。自然语言处理不仅用于 ChatGPT，还用于关键词搜索、搜索建议、广告定位等。

Pickle

Pickle 是用于序列化的 Python 模块。序列化是将 Python 对象（如列表、字典、类等）转换为字节流或一串计算机可读的“0”和“1”。这样可以将信息发送或存储起来，以便之后反序列化回原始数据。

你可以这样理解：想象你用乐高拼了一个飞船，它由很多积木按特定方式拼好。序列化就是记录飞船的每个角度的照片、用到的积木数量和拼装蓝图，然后将这些信息打包成一个盒子。这就是序列化。别人收到后可以按说明书再搭建出来，这就是反序列化。

Pyglet

Pyglet 是一个用于创建游戏的库。它赋予 Python 程序显示图形、播放声音和处理用户输入的能力。你可以用它制作跨平台游戏，它是建立在强大的图形库 OpenGL 之上的。

VPython

Visual Python（VPython） 是一个用于创建 3D 对象的库。它允许你用非常少的代码创建 3D 图像和动画，适合用于物理仿真。

Turtle

Turtle 是一个用于绘画的 Python 库。只需极少的代码就能绘制出螺旋图案。你也可以用它来创建其他类型的 2D 艺术，如分形图。

RPy

RPy 是一个让你在 Python 项目中使用 R 语言的包。R 是专为统计、数据可视化和数据科学设计的语言，不像通用编程语言那样工作。它通常与 Pandas 等库一起使用。

SpaCy

SpaCy 是一个高级自然语言处理的 Python 库，常用于创建聊天机器人、分析文本中的趋势、提取信息以及语言翻译。它可以将文本分解为单元（称为 token），还能识别名词、动词和形容词，并使用最先进的算法实现高精度。

Bokeh

Bokeh 是一个库，允许你将任何数据结构（如 CSV、JSON 文件，或数据库中的数据）可视化。你可以创建图表、散点图、折线图、柱状图等，常用于股票分析。

Plotly

Plotly 是一个用于创建交互式、视觉美观图表的 Python 库。你可以进行基于网页的可视化，图表高度可自定义。常用于数据科学、金融分析、工程和商业智能。

SQLAlchemy

SQLAlchemy 是一个非常强大且用户友好的库，允许你用 Python 创建关系型数据库。你可以使用 Python 操作数据库和表格，而不是手写 SQL。当然你也可以写原生 SQL。它支持多种数据库，如 PostgreSQL、MySQL、SQLite、Oracle 和 SQL Server。

FastAPI

FastAPI 是一个使用 Python 创建 API 的工具。API（应用程序编程接口）是让两个程序交换信息的一种方式。例如，当你被提示使用 Google 账户登录时，就是在使用 API。

Django

Django 是一个用于创建网站的 Python 框架。它允许你构建网页（称为视图）、创建和管理数据库（称为模型），并实现处理逻辑（称为控制器）。你可以将 Python 嵌入到 HTML 文件中，使网站更具动态性。Django 还自带后台管理面板，提供了从头到尾构建网站所需的一切。

Flask

Flask 是另一个用于构建网站的 Python 框架。与 Django 不同，它更适合小型项目。虽然也可以用 Flask 构建大型项目，但学习曲线更陡峭。

PyWin32

PyWin32 是一个提供对 Windows Win32 API 访问权限的库。它让 Python 程序能在更底层上与 Windows 操作系统交互，包括文件系统、目录、注册表、线程管理、UI 控件操作、自动化任务等。

py2exe

py2exe 允许你将 Python 脚本转换为 Windows 可执行程序（.exe），使其无需安装 Python 即可在 Windows 上运行。

PyQt

PyQt 是 QT 框架的 Python 绑定，允许你用 Python 创建图形用户界面和应用程序。通常要创建类似的程序需要 C++ 或 Java 语言，但 PyQt 让你用 Python 也能开发跨平台应用（Windows、Linux、Mac 和 Android）。你还可以配合 QT Designer 使用，用可视化方式手动设计应用程序，软件会返回模板或 Python 代码，大大缩短开发时间。

希望对你有帮助！

12 分钟讲解所有 JavaScript 库/模块

Every Javascript Library / Module Explained in 12 Minutes

https://www.youtube.com/watch?v=iGp1kVi1Zjo

jQuery

jQuery 是一个 JavaScript 库，用于简化 HTML DOM 操作，更容易地处理事件，也使得创建动画和执行 Ajax 更加简单。DOM，即文档对象模型，基本上就是网页上每个元素的组织方式。你可以将其想象为一个家谱图，有父元素和子元素等等。

过去人们使用 jQuery 是因为它比原生 JavaScript 更加用户友好，更容易学习和理解。它的语法非常简单，正如前面所说，这种易于阅读的语法让 Ajax（异步 JavaScript）变得更加容易。

自从 ECMAScript 6 标准（简称 ES6）出现后，jQuery 的使用开始减少。随后，JavaScript 框架开始流行起来，用于构建网站。不过别搞错了，直到今天，仍然有许多网站使用 jQuery。

Polymer

Polymer 是由 Google 开发的 JavaScript 库，用于构建可重用的 Web 组件。Web 组件是一段表示网页中某个元素的代码，比如一个按钮、列表、导航栏、巨幕（jumbotron）或轮播图（carousel）。其目的是让这些组件具有可重用性和模块化，使得将它们添加到网页变得非常简单，无需重复编写相同的代码。

Web 组件使用一种称为 shadow DOM 的技术，它是该组件独有的特定元素。这意味着每当 Web 组件更新时，只有该组件对应的网页部分被重新加载，而不是整个页面。

MooTools

MooTools 是一个与 jQuery 类似的 JavaScript 库，用于 DOM 操作、事件处理和 Ajax。它的用途与 jQuery 非常相似，虽然语法略有不同。

Masonry

Masonry 是一个帮助你在网站上构建网格布局（masonry）的工具。它允许你创建基于列的网格布局，添加动画，并能够自定义、对图片进行排序和过滤，同时优化网页上的空间使用，打造美观的设计。

Three.js

Three.js 是一个用于 3D 建模和 3D 动画的库。它使用名为 WebGL 的 JavaScript API，在网页浏览器中渲染 3D 对象。你不仅可以创建 3D 对象，还可以从像 Blender 这样的程序中导入对象。Three.js 通常用于构建 3D 游戏、数据可视化，甚至有时用于 VR 和 AR。

GreenSock

GreenSock，也被称为 GreenSock Animation Platform（GSAP），是一个以高性能动画著称的 JavaScript 库。基本上，任何你可以用 JavaScript 操作的东西，都可以用 GreenSock 动画化，包括 HTML、SVG、Canvas 元素等。它也能与 React、Vue 和 Angular 等 JavaScript 框架无缝配合使用。它最初还是用于 ActionScript 的库，也就是 Flash 使用的语言。啊，Flash，那真是美好的时代。

D3.js

D3.js，也称为 Data-Driven Documents，是一个功能非常强大的 JavaScript 数据可视化库。你能想到的图表、绘图、图形、动画、交互式仪表板，甚至是复杂数据的操作，都可以通过几行代码完成。D3 最著名的是创建和操作 SVG。

Chart.js

Chart.js 是一个 JavaScript 库，用于创建图表。它的名字已经说明了一切，它能让你创建折线图、柱状图、饼图、环形图、散点图，并且图表都是响应式设计，能够适应任何屏幕尺寸。而不是用于创建复杂的 AI 和机器学习算法（开个玩笑）。

AOS

AOS（Animate On Scroll）是一个 JavaScript 库，允许你在滚动时触发动画。它的动画效果很好……

Anime.js

Anime.js 是一个强大而轻量的 JavaScript 动画库。你只需在网页中引入 anime.min.js 文件，就可以开始为网页上的任何元素创建动画。你可以用类名或 ID 选择元素，还可以通过代码实现帧精度的动画控制，同时调整动画的缓动函数和持续时间。

Video.js

Video.js 允许你在网站上放置全屏视频背景。你甚至可以添加文字覆盖层和控制按钮。它非常适合用于着陆页和首页。

Plotly

Plotly 是一个用于创建实时更新图表和数据可视化的库。你可以缩放、平移、悬停查看数据点，并执行其他操作来探索数据。它也支持跨平台和多语言开发，并且可以创建多种类型的图表，就像其他库一样。

Brain.js

Brain.js 是一个在 JavaScript 中实现机器学习和人工智能的方式。你通过在项目中引入 Brain.js 来开始创建神经网络。创建神经网络基本上就是教计算机如何学习。首先，你提供一些训练数据，比如猫的图片，这些数据进入输入层。然后信息通过隐藏层传播，隐藏层处理信息并教神经网络识别特征，比如尖耳朵和胡须。最终结果通过输出层得出。Brain.js 用于模式识别、文本分析和简单预测。

TensorFlow.js

TensorFlow.js 是 TensorFlow 的 JavaScript 版本。虽然它不像 Python 版本那样强大，因为它必须在浏览器中运行，而 Python 版本可以利用高性能的 CPU 和 GPU，但它仍是一个非常优秀的机器学习库。它能够进行图像识别、预测模型、自然语言处理，甚至驱动自动驾驶汽车。

你将数据输入到称为张量（tensor）的结构中，这也是它名字的来源。张量本质上是一个多维数组。想象一个购物清单是一维数组，一个带行和列的表格是二维数组。你甚至可以组织更高维度的信息，这些就被称为张量。

Socket.io

Socket.io 是一个可以实现用户与 Web 服务器之间实时双向通信的库。它主要使用 WebSocket 实现功能。你是否曾想创建自己的实时聊天、直播应用或协作编辑程序？Socket.io 就是实现的方法。

PDF.js

PDF.js 允许你用 JavaScript 为网站创建自定义的 PDF 查看器。它主要通过 HTML canvas 实现功能。你也可以用它来操作 PDF 文档。

Node.js

Node.js 是一个非常流行的 JavaScript 运行环境，允许你在 Web 服务器上运行 JavaScript。在 Node 出现之前，服务器端语言通常是 PHP 或 Java。但 Node.js 能够工作，是因为它建立在 V8 JavaScript 引擎之上，也就是 Chrome 使用的引擎。这为 JavaScript 开发者成为全栈开发者提供了机会。Node.js 还可以处理异步 JavaScript。最重要的是，它自带了 Node 包管理器，也就是常说的 npm，这是一个允许你安装和管理库与模块的工具。

Granim.js

Granim.js 用于实现流畅的渐变动画。通过 HTML canvas 元素，你可以控制颜色数量、动画方向、配色方案等，让你的网站设计脱颖而出。

Deno

Deno 是一个现代化的 JavaScript 和 TypeScript 运行环境，由创建 Node.js 的同一个人开发。它用于在 Web 服务器上运行 JavaScript 和 TypeScript。与 Node.js 的不同之处在于它强调安全性，因为在 Deno 中，程序默认无法访问文件系统或网络，除非获得许可。正如前面所说，它也支持 TypeScript。尽管 Deno 没有像 Node 那样的包管理系统。

Ionic

Ionic 是一个 UI 工具包，用于构建渐进式 Web 应用、桌面应用和移动应用。它支持跨平台开发，包括 iOS、Android 和 Web。它自带预构建的 UI 组件，如列表、按钮、表单、导航栏，并可以与 JavaScript 框架集成使用，比如 React。

Vite

Vite 是一个前端构建工具，可以让 JavaScript 网站的构建速度变得更快。它由 Vue.js 的作者开发。Vite 在法语中意为“快”，这正是它的核心目的。你可以在任何命令行工具中开始，选择一个 vanilla JavaScript 项目或其他多个框架的选项，然后几秒钟内就可以开始构建。

例如，在 Vite 出现之前，要启动一个 React 项目，你必须通过 Node 包管理器使用 create-react-app 命令。如果你用过，你就知道这可能需要一段时间。Vite 使用原生的 ES 模块，这是现代 JavaScript 的标准。它也支持 TypeScript，并具备热模块替换功能（hot module replacement），这意味着你能看到代码的修改实时反映在网页上，而无需刷新页面。

Gatsby

Gatsby 是一个静态网站生成器，主要用于 React，但也可以用于原生 JavaScript。这意味着它可以在构建过程中将网站预构建成静态的 HTML、CSS 和 JavaScript。Gatsby 驱动着很多博客、电商网站、作品集网站，并且非常易于使用插件。

Jest

Jest 是一个主要用于 React 的 JavaScript 测试工具，但也可以用于其他 JavaScript 项目。它主要用于单元测试。单元测试是逐个测试代码片段的方式，以确保每个部分在部署前都能正常运行。其他功能包括为 UI 组件创建快照以用于测试和比较，以及隔离代码进行测试。

Mocha

Mocha 是一个可以在 NodeJS 和浏览器中运行的 JavaScript 测试框架。它适用于单元测试、集成测试和端到端测试。它以异步测试著称，适用于测试处理网络请求和数据库交互的异步代码。

React

React 是一个非常流行的 UI 框架和库，用于构建网站。React 主要用于网站的前端，即用户实际与之交互的部分。它的主要特点是使用可重用的代码块，称为组件。这些组件可以是按钮、文本框、图片、菜单、导航等。组件不仅可重用，而且是模块化的，与其他 React 项目可以很好地配合。

React 使用一种叫做 JSX 的语言编写，看起来像是 HTML 和 JavaScript 的结合。React 还附带自己的库，比如 Redux 和 React Router。

Vue，也和 React 类似，是一个用于构建 UI 组件的 JavaScript 库。虽然它没那么流行，但通常性能更快一些。

Angular

Angular，同样用于构建 UI 组件，不过它更适用于大型和企业级项目。

Svelte

Svelte，是的，也和前面三个类似，用于构建 UI 组件。但它与前面几个的主要区别在于页面渲染方式。之前提到的框架使用虚拟 DOM 来渲染网页，而 Svelte 使用的是编译器。这带来了更快的性能和更小的文件体积。

Express.js

Express.js 是一个用于构建 API（应用程序编程接口）的框架。API 就是两个程序之间交换信息的方式。如果你曾尝试用 Google 账号登录，那就是通过 API 实现的。

Next.js

Next.js 是一个后端 JavaScript 框架，用于搜索引擎优化。它还通过服务器端渲染（在将网页发送给用户之前在服务器上完成渲染）来提升网站性能。

Nest.js 是一个用于构建服务器端应用的框架，构建在 NodeJS 之上。它允许你使用 WebSocket、创建 RESTful API，并处理网站的安全问题。虽然它不是 JavaScript，而是使用 TypeScript 编写的。TypeScript 本质上是 JavaScript 的超集，也就是带有额外功能的 JavaScript，使得代码更可靠。

JavaScript 非常灵活，但有时这会带来问题。TypeScript 更加严格，其中一个方式是使用静态类型。比如你有一个函数应该传入两个数字相加，但你不小心传了一个字符串和一个数字。JavaScript 可能会做出奇怪的事情，或者返回错误。但使用 TypeScript，在运行代码之前就能发现这种错误。

Nuxt.js

Nuxt.js 是一个建立在 Vue.js 之上的框架。Vue.js 是一个专注于网站前端开发的框架，而 Nuxt 是一个处理后端的框架。Nuxt 能够进行服务器端渲染、静态网站生成、数据获取等各种功能，适用于成为一名全栈 Vue 开发者。

请一定要分享这个视频，谢谢观看。
🎵【音乐播放】

Every Web Framework Explained in 12 Minutes

12 分钟讲解所有 Web 框架

https://www.youtube.com/watch?v=yl6QbMWd4xc

https://www.bilibili.com/video/BV1nz5EzzEHA

Ruby on Rails

Ruby on Rails 是一个基于 Ruby 编程语言开发的服务器端 Web 框架。它诞生于 2004 年，主要用于构建网站。你可以通过它创建和管理数据库、构建网页，并在后端进行整体管理。这种架构被称为 MVC（模型-视图-控制器）。它还使用可重用的代码，称为 gems。

像 Ruby on Rails 这样的 Web 框架通常的工作方式是将编程语言嵌入到 HTML 和 CSS 中。这不仅缩短了开发时间，还使得构建网站变得更加容易。使用 Ruby on Rails 的知名平台有 Crunchbase、GitHub、Twitch 和 Airbnb。

ASP.NET

ASP.NET 是一个 Web 框架，它允许你使用 C# 编程语言来创建网站。它支持创建所谓的 CRUD 应用，即创建（Create）、读取（Read）、更新（Update）和删除（Delete）。它由微软在 20 多年前创建，与 Ruby on Rails 一样，采用 MVC 架构设计。

.NET 平台用于开发多种类型的软件，如桌面应用、移动应用和游戏，但 ASP.NET 是专门用于开发网站的。尽管 .NET 框架通常使用 C# 语言，但它实际上也可以使用其他编程语言，例如 Ruby、Python、C++ 和 Java。

Vapor

Vapor 是一个用 Swift 编写的 Web 框架，主要由 iOS 开发者使用。它允许你构建网站和 API 的后端部分，从而使用户界面（前端）可以与存储和管理数据的后端进行通信。

Django

Django 是一个使用 Python 编写的 Web 框架，它与 Ruby on Rails 有很多相似之处，不同的是它使用的是 Python。它允许你创建和管理称为模型（Model）的数据库，设计视图（View），并创建控制器（Controller）来管理数据的流动及网页的路由逻辑。

Flask

Flask 也是一个使用 Python 编写的 Web 框架。那么它和 Django 有什么不同呢？Django 被认为是一个高级的全栈 Web 框架，意味着你可以从零开始构建一个完整的网站，内含数据库管理、管理面板和用户认证等功能。而 Flask 则没有 Django 那样的“全套功能”，但它更适合初学者，可以更快速地创建小型网站。

不过别误会，使用 Flask 同样可以构建大型和功能强大的网站，只是学习曲线会更陡一些。

Phoenix

Phoenix 是一个使用 Elixir 编写的 Web 框架，主要用于构建后端，同样采用 MVC 架构。Phoenix 通常与一个名为 Phoenix LiveView 的库配合使用。

那么什么是 Phoenix LiveView 呢？在过去，当网页上的某个内容需要更新时，整个网页都必须重新加载，这种方式效率低下。后来使用异步 JavaScript（AJAX）来解决这个问题，只更新页面的局部内容，而不是整个网页。再后来，开发者使用在网页与服务器之间传输 JSON 文档的方式进行通信，但这仍显得有些繁琐。

这时，LiveView 出现了。它通过在网页和服务器之间保持持续连接来实现实时更新，当网页内容发生变化时，信息会立即发送到服务器，然后返回到网页上，无需使用 JavaScript 或传输文档。这使得网页更新更快、性能更高。

Laravel

Laravel 是一个使用 PHP 编写的 Web 框架，它配有一个命令行工具，叫 Artisan。Laravel 还提供一个名为 Blade 的功能，允许你使用可重用的 HTML 和 PHP 代码，这些被称为 Blade 模板。它使得网页中的代码更简洁、开发更高效。

Next.js

Next.js 是一个常与 React 一起使用的 Web 开发框架。它的主要功能是解决搜索引擎优化（SEO）问题，同时让你的网站运行更快。它通过在服务器端渲染网页，再将其发送给用户来实现这一点。它还优化了图片加载，并能够生成静态网页构建，因此运行速度更快。

Astro

Astro 是一个允许你结合多个 Web 框架开发的框架。它的主要特点是只在必要时才在网页上使用 JavaScript。网页运行速度是 Web 开发中的重要考虑因素，而 JavaScript 的使用越多，网页通常越慢。但 JavaScript 又能实现更复杂、交互性更强的网页体验。

Astro 的解决方案是只向用户渲染 HTML，并仅在用户与网页交互时使用 JavaScript。这使得网站在性能、SEO 和用户体验方面表现更佳。

Spring Boot

Spring Boot 是 Java 编程语言的一个框架，不仅可以用来构建 Web 应用，也可以用于 Android 和 iOS 的开发。Spring Boot 主要用于处理后端任务，如服务器和数据库。它是 Spring 框架的一个变体。

Express.js

Express.js 是一个用于构建 API 的后端框架。API 是应用程序编程接口，它允许不同类型的程序彼此通信。举一个简单的例子：你在餐厅点餐，不会直接跑到厨房告诉厨师你要吃什么，而是通过服务员传达你的需求。在这个比喻中，你是一个程序，厨房是另一个程序，服务员就是 API。

你是否曾经在别的网站上使用 Google 账号登录？那就是 API 的一个例子。

Rocket

Rocket 是 Rust 编程语言的 Web 框架。通常来说，Rust 并不适合用于 Web 开发，但自从 WebAssembly 的出现，让使用 Rust 进行 Web 开发成为可能。

Ktor

Ktor 是 Kotlin 编程语言的 Web 框架，是 Java 开发者在不喜欢 Spring 框架时的替代选择。

FastAPI

FastAPI 是一个使用 Python 构建 API 的框架。

NestJS

NestJS 是一个使用 TypeScript 编写的服务器端 Web 框架，它运行在 Node.js 环境中。它采用 MVC 架构，支持网站安全、数据库管理等后端功能。

Gin

Gin 是 Go 语言的 Web 框架，像其他框架一样，它允许你构建 API 和处理网站后端。

React

React 是一个使用 JavaScript 的 Web 框架，也可以和 TypeScript 一起使用。它是世界上最流行的 Web 框架之一，主要用于构建用户界面（前端）。

React 使用名为组件（Component）的可复用代码构建网页，极大地简化和加快了开发过程。其代码格式称为 JSX，看起来像是 HTML 和 JavaScript 的结合体。React 由 Facebook 于 2013 年发布，还推出了移动版本 React Native，可用于开发跨平台的移动应用。

Vue.js

Vue.js 是一个与 React 类似的 Web 框架，也使用 JavaScript 构建用户界面。它同样使用可复用的组件，并采用虚拟 DOM 技术---即网页更新时只更新需要变动的部分，而不是整个页面。尽管 Vue 的人气不如 React，但它在页面渲染速度上略胜一筹。

Angular

Angular 是由 Google 开发的 JavaScript 和 TypeScript 框架，和 React、Vue 一样，也使用组件构建应用。Angular 更适合企业级大型应用开发，能够完成从头到尾的网站构建，这一点区别于 React，需要借助第三方库来扩展功能。

Svelte

Svelte 是另一个 JavaScript Web 框架。是的，又是一个 JavaScript 框架，这在圈内甚至成了笑谈---几乎每天都有新的 JavaScript 框架发布。

Svelte 也使用组件构建网页，但与 React 和 Vue 使用虚拟 DOM 不同，Svelte 使用编译器将代码直接转换为原生 JavaScript，从而实现更小的文件大小和更快的性能。

Jamy

Jamy 是一个用于构建数据库应用的 JavaScript 和 Python 框架，主要面向数据库驱动型企业，被称为低代码或无代码框架。

Fastify

Fastify 是一个为 Node.js 开发的框架，用于构建后端服务器和 API，正如其名，专为高性能而设计。

CakePHP

CakePHP 是一个受 Ruby on Rails 启发、用于 PHP 的 Web 框架。它是一个后端框架，采用 MVC 架构，以简洁著称，主要用于开发小型应用。

Catalyst

Catalyst 是 Perl 编程语言的 Web 框架。

ColdBox

ColdBox 是 ColdFusion 编程语言的 Web 框架，它使用可复用代码模块，称为 ColdBox 模块。令人惊讶的是，至今仍有一些公司使用 ColdFusion。

WebKit

WebKit 是一个 C++ 的 Web 框架，有时也被称为 Wt（Witty）。由于 C++ 相较其他语言更快，因此 Witty 受到青睐，但它的学习门槛也更高。Witty 是一个服务器端框架，用于构建 API。

Yesod

Yesod 是一个用于 Haskell 编程语言的 Web 框架，它采用函数式编程，而非面向对象编程。

Remix

Remix 是另一个 JavaScript Web 框架，值得一提的是它的流行程度。它于 2020 年发布，主打性能优势，原因是它采用服务器端渲染技术，特别适用于拥有大量网页的网站。Remix 可作为 Next.js 的替代方案，最近还被 Spotify 收购。

Grails

Grails 是 Apache Groovy 编程语言的框架，也被称为 Groovy on Rails，它集成了 Java 平台。

Lift

Lift 是 Scala 编程语言的框架，也受到了 Ruby on Rails 的启发。

Solid

Solid 是最后一个要介绍的 JavaScript 框架。和许多 JavaScript 框架一样，它使用可复用组件。但和 Svelte 类似，它不使用虚拟 DOM，而是使用编译器将代码转换为原生 JavaScript，因此更为轻量。

Bootstrap

Bootstrap 是一个用于 CSS 的 Web 框架。CSS 是负责网页设计和美化的语言。Bootstrap 提供预制组件（如按钮、网格和布局），而且可以自定义，还支持可选的 JavaScript 功能。

Tailwind

Tailwind 是另一个 CSS 框架，但与 Bootstrap 不同，它没有预制组件，而是提供预设的类，你可以将这些类添加到 HTML 元素中。这使得 Tailwind 的可定制性更高，但学习曲线更陡。一个常见的抱怨是它的 CSS 类名可能会非常冗长。

Flutter

Flutter 是 Dart 编程语言的框架，虽然它也可以用于 Web 开发，但更常用于开发 iOS、Android 和桌面应用。Flutter 提供了预制组件，称为 Widget，尤其适用于构建移动应用。Flutter 会编译为机器码，因此用它开发的应用非常快速。

请一定记得分享这个视频，谢谢观看！

Every React Library Explained in 12 Minutes

https://www.youtube.com/watch?v=FN34m0npIxM

React Router

React Router 是一个用于控制网站导航的库，同时也允许你自定义网站的 URL。它使用自定义组件，如 BrowserRouter、Routes 和 Route 组件，以创建 URL 和链接页面，你可以通过 path 属性来定义这些链接。在 React Router 中，你使用 Link 组件代替传统的 <a> 标签来放置链接。你也可以创建嵌套路由。React Router 还提供了自定义 Hook，如 useNavigate 和 useParams。

ShadCN

ShadCN 是 React 的 UI 组件库。你可以使用它搭建漂亮且实用的 UI 组件，这些组件使用 Tailwind CSS 样式，并基于 Radix UI 构建，因此高度可自定义。与其安装组件和 node 模块，你只需要复制粘贴代码到你的项目中即可。你也可以使用名为 V0 的聊天机器人创建 ShadCN 组件，V0 会自动生成组件，你只需点击几下就能将其添加到项目中。

Redux

Redux 是一个状态管理库。状态管理是将网站不同部分连接起来的一种方式，使它们协同工作。网站的不同部分，如视频、播放列表、按钮、菜单、描述等，都依赖同一份信息。但由于用户不断与网站互动，这些组件需要不断更新变化。

这时状态（state）就发挥作用了。状态就像网站的“记忆”，它包含了网站用来判断显示什么内容以及如何响应的所有信息。网站会在你在搜索框中输入文字时使用状态---比如自动补全或显示历史搜索、切换浅色/深色模式、添加或删除购物车中的商品等。

Redux 使用一个叫做 store（存储） 的地方来保存这些信息。然后通过 container（容器） 获取这些数据并传递给相应的组件。它还响应被称为 actions（动作） 的事件，比如用户点击、输入等。当用户执行一个动作后，这个动作会被传递给 reducer（简化器），reducer 决定如何更新 store 中的信息。

Formik

Formik 是一个表单管理库，让构建表单变得更容易。它处理状态管理、验证和错误处理。它还可以与另一个工具 Yup 配合使用。你通常从 Formik 组件开始，然后使用 Formik 的 Hooks 为表单添加功能。

Framer Motion

Framer Motion 是一个非常强大的 React 动画库。你可以使用 animate、initial 和 transition 等属性控制动画。它还支持手势操作，如悬停、点击、拖动和滚动。你使用 motion.div 组件开始，然后实现 useAnimation Hook 来自定义动画。Framer Motion 优化为 60 帧/秒，并可以使用 CSS 变换和 WebGL 图形。

Swiper

Swiper 是一个用于创建轮播图、图片画廊和 Hero 区块的库，适用于桌面、平板和手机。其 UI 组件具有响应式设计和流畅的过渡效果，并允许你创建导航控件。比如，你可以使用 Swiper 组件作为主滑块，使用 SwiperSlide 组件创建每个幻灯片。

TanStack Query

React Query（现称为 TanStack Query）是一个用于 React 的服务端状态管理库。它用于处理异步请求和 API 调用。你可以用它进行分页和无限滚动，通过处理数据的获取和重新获取。你可以使用 useQuery Hook 来获取和缓存数据，使用 useMutation Hook 来修改服务器数据。

React Three Fiber

React Three Fiber 是 3JS 库的 React 渲染器。它允许你创建 3D 场景、动画和游戏图形。可与其他库如 Framer Motion 和 React Spring 搭配使用。你可以使用 useLoader Hook 加载 3D 模型或 glTF 文件，还可以使用 useThree Hook 使用诸如相机等 3JS 对象。但需要掌握一些基本的 3D 概念，如网格（mesh）、材质（material）、着色器（shader）。

React Admin

React Admin 是一个用于构建管理面板和企业级应用的框架，内置了许多组件。你可以使用 GraphQL 或 Firebase 将其连接到后端。它可以创建包括身份验证和权限控制在内的 CRUD 操作，也非常适合构建后台管理系统和 CMS。

React Bootstrap

React Bootstrap 是 Bootstrap 的 React 版本。它自带如按钮、模态框、导航栏等组件。原始 Bootstrap 依赖 CSS 和 jQuery，而 React Bootstrap 则能访问虚拟 DOM。

React Tailwind

React Tailwind 是一个用于构建网站用户界面的库。相较于 Bootstrap，它的组件更可自定义。虽然不像 Bootstrap 那样自带组件，但你可以通过 npm install 命令将 Tailwind 安装到 React 项目中。

Material UI

Material UI 是一个基于 Google Material Design 的 React UI 组件库，包含 50 多个预建组件。支持自定义主题、响应式设计，并优化了可访问性（适用于屏幕阅读器）。它还自带一个图标库 Material Icons。

Chakra UI

Chakra UI 是一个强调可访问性的 UI 组件库。所有组件遵循 WAI-ARIA 标准，帮助残障人士使用界面。你可以创建主题、支持暗模式、为组件添加样式，提供 useDisclosure Hook 管理状态以及 useToast Hook 显示反馈信息，也可通过 Framer Motion 添加动画。

Ant Design

Ant Design（由蚂蚁集团开发）是一个企业级 React UI 组件库，包含按钮、日历、树形结构、图表等组件，支持 50 多种语言，是构建企业应用的理想选择。

Headless UI

Headless UI 与其他 UI 库不同，它提供完全无样式的组件，让你可以自由使用喜欢的 CSS 库自行定制。它注重可访问性，并支持状态管理。

React 360

此项目已经archived

React 360 是一个用于构建沉浸式 360 度虚拟现实体验的框架。它结合 WebGL 和 WebVR，可在 VR 头戴设备上运行。你可以用它创建 3D 环境和空间界面，添加 360 视频、图片和全景图。内置组件包括 View、Text、Entity 和 VRButton，可用于虚拟旅游、产品演示和培训模拟。

Recharts

Recharts 是基于 D3JS 构建的图表库，用于创建响应式图表、可视化图形。利用 React 的组件结构构建图表、饼图、折线图等，支持动画和交互操作。

Zustand

Zustand 是一个轻量级状态管理库，几乎不需要模板代码，被认为比 Redux 更简单。它不需要 reducer、action 或 provider。

React Hook Form

React Hook Form 是一个用于 React 表单管理的库，可减少不必要的重新渲染。它与 Chakra 和 Material UI 等 UI 库完美集成。你可以使用 useForm Hook 管理状态和验证，编写更少代码构建高效表单。

React Spinner

React Spinner 是一个加载动画的可视化库，用于在加载内容时提供视觉反馈。你可以选择多种加载器，比如 CircleLoader，并自定义颜色、尺寸、速度和样式。

React DnD

React DnD 是一个为 React 项目添加拖放功能的库。支持鼠标、触控、键盘拖放。使用 useDrag Hook 使组件可拖动，useDrop Hook 使组件可以接收拖拽项目。适合用于文件上传器、表单构建器和游戏界面。

React AG Grid

React AG Grid 是一个数据表格库，支持排序、过滤、分页、行选择，能处理大量数据。你可以用 pagination 属性启用分页，用 columnDefs 定义列，还可以将表格导出为 Excel。

Vite

Vite（取自法语“快”）是一个前端构建工具，专为加快开发速度而设计。虽然由 Vue 的作者开发，但也支持 React。你可以在命令行中快速创建 React 项目。与 create-react-app 相比，启动速度更快。它还支持 热模块替换（HMR），可以在不刷新页面的前提下即时反映代码更改。

Styled Components

Styled Components 是一个 React 的 CSS-in-JS 库，允许你将 CSS 写入组件内，避免全局样式冲突。

EmotionJS

EmotionJS 与 Styled Components 类似，也是 CSS-in-JS 库，但更轻量，速度更快，还支持服务端渲染。

Mantine

Mantine 是一个 React UI 组件库，提供 100 多个可自定义组件和 50 多个 Hooks。支持响应式设计、浅色/深色主题，内置表单库，适配 Redux 和 Formik。

SWR

SWR 是一个用于远程数据获取的 React Hooks 库，全称是 “stale while revalidate”（陈旧但验证）。它支持数据获取、变更、缓存、分页、无限滚动和错误处理。

它的工作原理是：首次加载页面时，先显示本地缓存的数据（即使有点旧），确保加载迅速，同时请求服务器上的新数据，一旦新数据返回，就更新缓存并重新渲染页面，整个过程用户无感。

Next.js

Next.js 是一个用于构建服务端渲染页面的 React 框架。它可以帮助开发者创建全栈应用，提升性能、加载速度和 SEO。

React Chart.js 2

React Chart.js 2 是将 Chart.js 集成到 React 中的组件库。提供如柱状图、折线图、饼图等组件，支持事件处理（如点击、悬停），图表高度可自定义。

React Spring

React Spring 是一个专注于物理动画的 React 动画库，模拟现实世界的运动。不同于 CSS 动画，它使用弹簧物理（spring physics）。你可以使用 useSpring Hook 控制动效，比如按钮、div 的过渡、透明度、缓动效果等。

Every Python Concept Explained in 12 Minutes

https://www.youtube.com/watch?v=wfL4o73swZI

本内容是对 Every Python Concept Explained in 12 Minutes 内容的翻译与整理。

Python之禅（The zen of Python）

当你在Python解释器中输入import this时，你会看到19条解释Python设计哲学的格言。

它描述了Python如何优先考虑优雅且富有美感的代码。

它阐明了代码应如何清晰地展示其功能，并避免“魔法”行为。

它提倡扁平优于嵌套，推崇使用空白和清晰的格式，并强调可读性。

它推崇有意处理错误、简单方案即是最佳方案的理念，并指出有时“聪明”的代码可能会导致糟糕的代码。

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Python之禅，作者：蒂姆·彼得斯

优美胜于丑陋。
明确胜于隐晦。
简单胜于复杂。
复杂胜于繁复。
扁平胜于嵌套。
稀疏胜于密集。
可读性很重要。
特殊情况不足以违背这些原则。
尽管实用性胜过纯粹性。
错误绝不应该悄无声息地通过。
除非明确地加以抑制。
面对模糊不清时，拒绝猜测的诱惑。
应该有一种——而且最好只有一种——显而易见的方法来做事。
虽然这种方法一开始可能并不明显，除非你是荷兰人。
现在做胜过永不做。
尽管永不做往往胜过*现在立即*做。
如果实现很难解释，那就是个糟糕的想法。
如果实现很容易解释，那可能是个好想法。
命名空间是个绝妙的想法——让我们多多使用吧！

`if name == "main"`

if __name__ == "__main__" 是一个至关重要的概念，也可能是Python中最广为人知的梗。

这是一个惯用语，用于判断一个程序是直接运行还是被作为模块导入。__name__是一个特殊变量，而"__main__"则代表主Python程序。

简单来说，当你双击并运行你的主程序时，它就是"__main__"。

如果主程序正在被执行，那么名为__name__的这个变量将被设置为等于"__main__"。

然而，如果你正在运行的代码或模块被导入到另一个Python项目中，那么__name__将被设置为你所导入的模块名，也就是不带.py后缀的Python文件名。if __name__ == "__main__"这个惯用语主要用于确保某些代码只在它作为主程序被直接运行时执行，而不是在被导入时执行。

if __name__ == "__main__" 的意思很简单：只有在直接运行这个文件时才执行某些代码，被导入时不执行。

举个简单例子：

假设你有一个文件 my_module.py：

# my_module.py
def say_hello(name):
    print(f"你好，{name}！")

def add_numbers(a, b):
    return a + b

# 这里是关键部分
if __name__ == "__main__":
    # 只有直接运行这个文件时才会执行下面的代码
    print("正在直接运行 my_module.py")
    say_hello("小明")
    result = add_numbers(3, 5)
    print(f"3 + 5 = {result}")

两种运行方式的区别：

方式1：直接运行文件

1	python my_module.py

输出：

1
2
3

正在直接运行 my_module.py
你好，小明！
3 + 5 = 8

方式2：在另一个文件中导入

# main.py
import my_module

my_module.say_hello("小红")  # 只调用函数

运行 python main.py 输出：

你好，小红！

注意：导入时不会打印”正在直接运行 my_module.py”和其他测试代码。

为什么这样做？

这样可以让你的模块既能：

作为独立程序运行（包含测试代码）
被其他程序导入使用（只提供函数，不执行测试）

这就是Python之禅中”实用性胜过纯粹性”的体现！

万物皆对象

“万物皆对象”是Python设计哲学的一个基本方面。这意味着你在Python中使用的每一个实体都是某个类的实例，拥有属性和方法，可以被赋值给变量，可以作为参数传递，也可以从函数中返回。

数据类型是对象，函数是对象，类和模块是对象，甚至代码块也是对象。这就是Python中的对象层级结构。这使得Python极其灵活、一致且简单。

然而，这些对象可能会占用大量内存，从而影响性能。

空白与缩进

Python一个非常特别之处在于使用缩进和空白来定义代码块。

与其他使用花括号（如C或JavaScript）或关键字（如Ruby和Lua中的end）的语言不同，Python的这一设计特性确保了其最大程度的可读性。

在Python中，缩进通常用于if、for、while、def和class代码块。不一致的缩进会导致IndentationError（缩进错误）。具有相同缩进级别的代码被视为在同一个代码块中，而嵌套代码则通过更多的缩进来实现。

循环中的`else`子句

循环中的else子句是一个经常让新用户感到惊讶的特性。这是一种开发者可以放在for和while循环中的语句。它仅在循环正常完成而没有遇到break语句时才会执行。基本上，如果循环正常结束，else块就会执行；但如果循环被break语句终止，那么else块就会被跳过。

不要把它误认为是if-else语句的变体，它与条件逻辑无关，更像是一个“无中断”子句。一些实际用途包括检查质数或创建带有超时的循环。

列表推导式

列表推导式（List comprehensions）是一种独特的方式，可以用一行代码创建循环、列表和条件判断。一个普通的for循环是这样的，但通过Python的列表推导式，你可以把它变成紧凑的一行。

你甚至可以添加条件判断、编辑列表中的元素、执行嵌套循环和多个条件判断。虽然这是Python中一个有用的特性，但在所有情况下它未必是最佳选择。有时它会使事情变得非常复杂且难以阅读，在那些情况下，使用常规的语句会更好。

列表推导式就是用一行代码快速创建列表，比传统for循环更简洁。

基础例子

传统for循环：

# 创建1到5的平方数列表
squares = []
for i in range(1, 6):
    squares.append(i ** 2)
print(squares)  # [1, 4, 9, 16, 25]

列表推导式（一行搞定）：

1 2	squares = [i ** 2 for i in range(1, 6)] print(squares) # [1, 4, 9, 16, 25]

加条件判断

传统方式：

# 只要偶数的平方
even_squares = []
for i in range(1, 11):
    if i % 2 == 0:
        even_squares.append(i ** 2)
print(even_squares)  # [4, 16, 36, 64, 100]

列表推导式：

1 2	even_squares = [i ** 2 for i in range(1, 11) if i % 2 == 0] print(even_squares) # [4, 16, 36, 64, 100]

处理现有列表

names = ["alice", "bob", "charlie"]

# 传统方式
upper_names = []
for name in names:
    upper_names.append(name.upper())

# 列表推导式
upper_names = [name.upper() for name in names]
print(upper_names)  # ['ALICE', 'BOB', 'CHARLIE']

何时不要用？

太复杂时别用：

# 这样太难读了！
result = [x*y for x in range(1,4) for y in range(1,4) if x != y and x+y > 3]

# 还是用传统for循环清晰
result = []
for x in range(1, 4):
    for y in range(1, 4):
        if x != y and x + y > 3:
            result.append(x * y)

简单情况：用列表推导式，代码更pythonic
复杂逻辑：用传统for循环，可读性更好
这体现了Python之禅：“简单胜于复杂”、“可读性很重要”

多重赋值与元组解包

多重赋值与元组解包（Multiple assignment and tuple unpacking）是一种在单行代码中为多个变量赋值的方法。

你看，Python将右侧视为一个没有括号的元组，并按顺序将这些值赋给左侧的变量。顺便说一下，元组（tuple）是一种将多个值赋予一个变量的方式，有点像列表或数组，但一旦创建，就无法编辑或更改。这种赋值方式适用于任何可迭代的对象，比如列表、字符串或循环。

多重赋值与元组解包就是一次性给多个变量赋值，让代码更简洁。

基础例子

传统方式：

# 分别赋值
name = "张三"
age = 25
city = "北京"

多重赋值（一行搞定）：

name, age, city = "张三", 25, "北京"
print(name)  # 张三
print(age)   # 25
print(city)  # 北京

交换变量值

传统方式（需要临时变量）：

a = 10
b = 20
temp = a
a = b
b = temp
print(a, b)  # 20 10

多重赋值（超级简洁）：

a = 10
b = 20
a, b = b, a  # 一行交换！
print(a, b)  # 20 10

解包列表/元组

# 从列表解包
colors = ["红", "绿", "蓝"]
color1, color2, color3 = colors
print(color1)  # 红

# 从元组解包
point = (100, 200)
x, y = point
print(f"坐标：({x}, {y})")  # 坐标：(100, 200)

函数返回多个值

def get_name_age():
    return "李四", 30  # 实际返回一个元组

# 一次接收多个返回值
name, age = get_name_age()
print(f"{name}今年{age}岁")  # 李四今年30岁

忽略不需要的值

# 用下划线忽略不需要的值
data = ("王五", 28, "上海", "工程师")
name, age, _, job = data  # 忽略城市
print(f"{name}是{job}，{age}岁")  # 王五是工程师，28岁

字符串解包

word = "hello"
a, b, c, d, e = word
print(a)  # h
print(b)  # e
print(c)  # l

在循环中使用

students = [("小明", 85), ("小红", 92), ("小刚", 78)]

for name, score in students:
    print(f"{name}的成绩是{score}分")

输出：

1
2
3

小明的成绩是85分
小红的成绩是92分
小刚的成绩是78分

注意事项

# 变量数量必须匹配
a, b = 1, 2, 3  # 错误！左边2个变量，右边3个值

# 可以用星号收集剩余值
a, b, *rest = 1, 2, 3, 4, 5
print(a)     # 1
print(b)     # 2  
print(rest)  # [3, 4, 5]

这体现了Python之禅中的**”优美胜于丑陋”和“简单胜于复杂”**！

动态与强类型

动态与强类型（Dynamic and strong typing）是Python的一个特性，它同时赋予了语言灵活性和安全性。

动态类型指的是在编写代码时无需显式声明变量的类型，变量的类型是在运行时确定的。

强类型指的是在运行时会强制执行严格的类型兼容性检查，类型不匹配将导致TypeError（类型错误）。这一特性使得函数更加灵活，并避免了因自动类型转换而导致的潜在错误。

鸭子类型

鸭子类型（Duck typing）是Python中的一个概念，它关注的是一个对象能做什么（即它的方法或属性），而不是它的类或类型。不需要进行类型检查。

这就像你玩一个游戏，需要猜哪个动物玩具会发出“嘎嘎”声。你首先拿起鸭子玩具，它发出了“嘎嘎”声。但如果你拿起另一个玩具，比如小狗玩具呢？你拿起它，惊讶地发现，它也发出了“嘎嘎”声。你后来发现，原来小狗玩具里放了一个鸭子叫声器。这大概是我能解释它的最好方式了。

基本上就是说，Python不关心这个东西“是什么”，而更关心你希望它执行的“动作”。

`pass`语句

pass语句是一条告诉程序什么都不做的语句。它是“此页有意留白”的编程版本，但它确实有其用途。在开发过程中，你可以用它作为占位符。它也是构建类、头等函数和闭包的骨架的一个很好的构建块。

头等函数与闭包

头等函数（First-class functions，即函数作为头等公民）是一种让函数可以像字符串、变量或列表一样被使用的方式。这允许你在通常是面向对象的Python语言中使用函数式编程范式。函数可以被赋值给变量，用作其他函数的参数，也可以从其他函数中返回。

# 函数可以赋值给变量
def greet(name):
    return f"你好，{name}！"

my_func = greet  # 函数赋值给变量

# 函数可以作为参数传递
def call_twice(func, arg):
    return func(arg) + " " + func(arg)

result = call_twice(greet, "小明")  # 传递函数作为参数

# 函数可以作为返回值
def make_multiplier(n):
    def multiplier(x):
        return x * n
    return multiplier  # 返回函数

double = make_multiplier(2)

闭包（closure）是一个函数对象，它能够使用来自其外层（包围它的）对象或函数的信息。

Dunder方法

Dunder方法（Dunder methods），是“双下划线方法”（double underscore methods）的简称，是一些特殊函数。

当你在Python代码中执行某个常见操作时，它们会自动运行。

Dunder方法的例子有：__init__，它用于初始化一个类的新实例，当你的程序创建一个新对象时它会自动运行；__add__、__sub__和__mul__，每当你使用算术运算符时它们就会被调用；__str__，它定义了当对象被print()函数使用时应显示的字符串。

你通常不会直接使用Dunder方法，它们大多在底层工作。

`*args`与`**kwargs`

*args与**kwargs是Python中的两种特殊语法，它们允许用户在函数中放入任意数量的参数或输入。

*args或任意位置参数（arbitrary positional arguments），允许一个函数接受任意数量的输入。

**kwargs或任意关键字参数（arbitrary keyword arguments），与*args类似，但你可以为你的输入附加一个标签，并以键值对的形式传入它们。

海象运算符

海象运算符（The walrus operator），在Python 3.8中引入，正式名称为赋值表达式（assignment expression），它允许你在一个代码块内部为变量赋值，从而避免了为创建变量而单独写一行的需要。它们非常适合在循环、列表推导式中使用，并且常用于输入验证和数据解析。

海象运算符 := 就是在表达式中同时赋值和使用变量，避免重复计算或多写代码行。

基础例子

传统方式：

# 需要先计算，再判断
text = input("请输入文字: ")
if len(text) > 5:
    print(f"文字长度是 {len(text)}")  # len()计算了两次

海象运算符：

1
2
3

# 一次计算，同时赋值和使用
if (length := len(input("请输入文字: "))) > 5:
    print(f"文字长度是 {length}")  # 只计算一次

在循环中使用

传统方式：

# 读取文件直到遇到空行
line = input("输入一行（空行结束）: ")
while line != "":
    print(f"你输入了: {line}")
    line = input("输入一行（空行结束）: ")  # 重复代码

海象运算符：

1
2
3

# 避免重复代码
while (line := input("输入一行（空行结束）: ")) != "":
    print(f"你输入了: {line}")

在列表推导式中使用

传统方式：

# 处理数字，但要多次调用expensive_function
numbers = [1, 2, 3, 4, 5]

def expensive_function(x):
    print(f"计算 {x}...")  # 模拟耗时操作
    return x * x

# 问题：expensive_function被调用两次
results = [expensive_function(x) for x in numbers if expensive_function(x) > 10]

海象运算符：

1 2	# 只计算一次 results = [result for x in numbers if (result := expensive_function(x)) > 10]

处理正则表达式匹配

传统方式：

import re

text = "我的电话是 138-1234-5678"
pattern = r'\d{3}-\d{4}-\d{4}'

match = re.search(pattern, text)
if match:
    phone = match.group()
    print(f"找到电话号码: {phone}")

海象运算符：

import re

text = "我的电话是 138-1234-5678"
pattern = r'\d{3}-\d{4}-\d{4}'

if (match := re.search(pattern, text)):
    print(f"找到电话号码: {match.group()}")

数据解析示例

传统方式：

data = ["10", "abc", "25", "xyz", "30"]
numbers = []

for item in data:
    try:
        num = int(item)
        if num > 15:  # 需要重复使用num
            numbers.append(num)
    except ValueError:
        continue

海象运算符：

data = ["10", "abc", "25", "xyz", "30"]
numbers = []

for item in data:
    try:
        if (num := int(item)) > 15:  # 赋值和判断一步完成
            numbers.append(num)
    except ValueError:
        continue

print(numbers)  # [25, 30]

实际应用：文件处理

# 逐块读取大文件
with open("large_file.txt", "r") as file:
    while (chunk := file.read(1024)):  # 每次读1024字节
        process(chunk)  # 处理数据块

注意事项

# 需要用括号包围赋值表达式
if (x := 10) > 5:  # 正确
    print(x)

# if x := 10 > 5:  # 错误！语法错误

海象运算符体现了Python之禅中的**”优美胜于丑陋”，让代码更紧凑、避免重复计算，但要注意不要滥用，保持“可读性很重要”**！

装饰器

装饰器（Decorators）是一种在不永久改变函数代码的情况下增强其功能的方式。它们接受函数作为输入，并输出一个功能被修改过的函数。

这是一种让函数们做“融合之舞”并创造出一个新的“超级函数”的酷炫方式。装饰器也适用于类和方法，你甚至可以堆叠使用多个装饰器。它通常用于计时、缓存和验证。

`with`语句与上下文管理器

with语句与上下文管理器（The with statement and context managers）是用于资源管理和文件清理的工具，并且省去了编写try...finally语句的需要。

上下文管理器实现了两个特殊方法：__enter__，它负责设置并返回资源；以及__exit__，它负责处理清理工作。它在文件处理中非常常用。

`slots`优化

__slots__优化是Python中一个用于优化内存使用的独特功能。通常，一个类的属性存储在一个字典中，这是Python中的一种键值对结构。你可以把字典想象成电话簿，名字是键，电话号码是值。

然而，如果你有大量的对象实例，这会占用大量内存。这就是__slots__发挥作用的地方。它使用一种更紧凑的内部结构，比如一个引用数组，来存储属性。它最适合用于内存密集型应用。但要小心，它可能会破坏依赖于字典或vars()函数的其他代码。

错误处理中的`else`语句

错误处理中的else语句是一个帮助开发者编写更具意图性的错误处理代码的特性。它仅在try块中没有发生错误或异常时才会执行。它用于创建一个“成功路径”而非“错误路径”，并使错误处理更加精确。错误处理中的else语句非常适用于API请求和数据库事务。

可变默认参数

可变默认参数（Mutable default arguments）是Python中一个对于初学者来说可能容易混淆的方面，通常被称为一个“坑”（gotcha）。可变默认参数是指你可以将一个可编辑的数据结构（如列表或字典）作为函数的输入或参数。但棘手的部分是，无论你为这个可编辑输入传入什么值，它都会在你每次调用该函数时持续存在，并被设置为其默认值。即使你改变了输入，这个可变默认参数仍将保持不变。对此，一个常见的解决方案是使用None作为默认值，或使用不可编辑的默认值。

全局解释器锁

全局解释器锁（Global Interpreter Lock，简称GIL）是Python设计中一个非常有争议的方面。它基本上是一个互斥锁（mutex或mutual exclusion lock），用于保护对Python对象的访问。互斥锁是Python中的一条规则，规定在同一时间只有一个线程可以访问程序的某个部分。

更简单地说，想象一下你和朋友们一起玩视频游戏。如果多个人共享一个手柄，它可能会被损坏甚至弄坏。互斥锁就是一种规定，即同一时间只有一个人可以使用一个手柄。全局解释器锁则是一条包罗万象的规则，规定在任何单个时刻只有一个CPU线程在运行一段代码。这就像之前的手柄规则一样，但这次是用于一个单人游戏。

表面上看，这似乎效率低下。那么为什么Python要这样设计呢？这在某种程度上是一种安全措施。Python会追踪它的对象——记住，在Python中，几乎所有东西都是对象。它以一种特殊的方式进行追踪，如果允许多个线程同时访问这些对象，就会破坏Python内部的追踪方式。全局解释器锁确保了这种情况不会发生。

Every Programming Concept Explained in 15 Minutes

https://www.youtube.com/watch?v=K9LrtbDdgA4

变量：一种通过在计算机内存中创建并命名一个位置来存储信息的方式。变量提供了存储、检索和操作信息的途径。简单地说，想象你有一个贴有“饼干数量”标签的盒子，它的作用就是记录盒子里有多少块饼干。你也可以改变盒子里饼干的数量，从而改变所记录的饼干数。这就有点像变量的作用。

变量有几个属性：

名称（name）：这是分配给变量的唯一标识符。
类型（type）：即它将要存储的数据的种类。
值（value）：实际存储的信息。
作用域（scope）：决定变量可以被访问的位置，是局部还是全局。
内存地址（memory address）：变量在内存（RAM）中存储的位置。

变量可以用来存储游戏中的玩家分数、计算器中的数字，以及用户输入等。

语法（Syntax）：语法是一组定义正确结构和符号、关键字及运算符组合的规则。它基本上就是编程语言的语法和标点符号。符号和标点包括大括号、括号和分号。关键字的例子有 if、while、return、for 和 case 等。编程语言的语法是区分大小写的，因此一些看似相同的单词其实是不同的。如果代码的语法不正确，程序会在编写时或运行时抛出错误。语法还有助于提升代码的可读性，而且不同的编程语言有不同的语法。

数据类型（Data Types）：定义了变量中可以存储哪类信息。数据类型对于内存分配、错误预防和优化十分重要。数据类型分为基本数据类型和复合数据类型。

常见的基本数据类型：

int：整型，用于存储整数。
float：浮点型，用于存储小数。
char：字符类型，存储单个字符。
string：字符串，存储一组字符或完整的单词。
boolean：布尔类型，只能存储 true 或 false。

常见的复合数据类型：

数组（array）：在一个变量中存储多个相同类型的值。顺便说一句，字符串其实也是一种数组，即字符数组。
列表（list）：类似数组，但可以存储多种不同类型的数据。
类（class）：带有特定属性和方法的代码，比如可以继承其他代码的特性。
结构体（struct）：类似类，但不能继承。
元组（tuple）：类似数组或列表，但其中数据的顺序非常重要，而且一旦创建就不能修改。

编程语言可以分为静态类型语言和动态类型语言。静态类型语言（如 Java）要求开发者在声明变量时明确指定数据类型。动态类型语言（如 Python）则会自动检测数据类型，不需要显式声明。

循环（loops）与递归（recursion）：

循环指的是在编程中重复执行某段代码，直到满足某个条件。常见循环类型有 for 循环、while 循环、do while 循环和嵌套循环。循环可以让程序重复执行特定的任务，可以设定固定次数，也可以无限循环。

递归是一种数学中的重复方式，新元素由前一个元素决定。在编程中，递归是自我调用的函数，常用于在未知数据总量的情况下进行循环或迭代。

函数（Functions）：

函数是一段设计用来完成特定任务的代码模块，具有模块化和可重用性。就像数学中的函数，它接收输入并返回输出。

函数有四个主要部分：

输入（参数 parameters）。
名称。
函数体（具体执行的工作）。
输出（通常称为返回值 return value）。

除了开发者定义的函数，许多语言自带内置函数，如 Python 的 print、JavaScript 的 eval、C++ 的平方根函数。

有一种特殊的无名函数叫做 lambda 函数。

函数可以类比为食谱：

写下食谱（声明函数）。
在厨房中要求厨师开始做菜（调用函数）。
厨师真正烹饪（执行函数）。

函数可以单独运行，也可以放在类（class）中，此时它们称为方法（methods）。

条件语句（Conditionals）：

条件语句根据条件真假来执行不同的代码块。

if 语句：判断某个条件是否为真。
if else：选择在两条路径之间执行。
if-elif-else：处理多个条件。
switch-case：将变量与多个值进行匹配。

条件语句常用于输入验证、错误处理和游戏逻辑。它们通常判断是否相等、不相等、大于、小于、大于等于或小于等于，并使用逻辑运算符，如 and、or、not。

数据结构（Data Structures）：

数据结构是一种特殊的组织、存储和管理数据的方式。选择合适的数据结构能够提升程序性能，更加节省内存，并能很好地抽象现实问题，例如用图表示网络连接、用树表示层级关系。

常见数据结构：

数组（array）：一维列表，元素通常在内存中连续存储。
链表（linked list）：节点序列，通过指针相连，不必连续存储。
栈（stack）：先进后出，如一叠盘子。常用于撤销/重做功能。
队列（queue）：先进先出。元素的加入和移除称为入队和出队。常用于任务调度、打印队列。
哈希表（hash table）：以键值对存储数据，用于高效的插入、删除、查找。可类比为电话簿。
树（tree）：表示层级关系，有父节点和子节点。必须有根节点，不能有循环。常用于文件系统、组织架构、课程先修关系。
图（graph）：由节点和边组成，可以有循环。用于网络布局和 GPS 最短路径。
堆（heap）：特殊的完全二叉树，用于排序和优先队列中，分为大顶堆和小顶堆。

算法（Algorithms）：

算法是为了解决特定问题或计算而设计的逐步过程或指令集，是编程的核心。常见算法有排序、查找、分治、动态规划、贪心算法等。

算法的重要特性之一是 时间复杂度：即运行所需的时间。

大 O 表示上界（最坏情况）。
大 Ω 表示下界（最好情况）。
大 Θ 表示平均情况。

现实中算法的应用非常广泛，如谷歌搜索、GPS 导航。一个著名的算法例子是比特币使用的加密哈希算法 SHA-256。

调试（Debugging）：

调试是识别并修复代码错误的过程，是开发和测试中重要的一环。调试能提升性能并增强安全。

常见错误类型：

语法错误：语法或拼写错误，违反了语言规则。
运行时错误：程序运行时才出现，例如除数为 0。
逻辑错误：没有语法错误，但结果与预期不符，例如循环中忘记写退出条件导致无限循环。
资源错误：程序尝试使用不可用的资源，如内存、磁盘空间不足。

调试方法包括定位错误源、分析原因、打印调试（print debugging）、使用外部调试工具或单元测试等。

面向对象编程（OOP）：

这是一种编程范式，以对象为中心，而非函数和逻辑。对象是带有独特属性和行为的数据单元，由属性（attributes）和方法（methods）组成。

示例：在游戏中，玩家、敌人、武器是对象；在电商中，商品、购物车、用户是对象。类（class）是对象的蓝图。

例如：定义一个 Python 中的皮卡丘类（Pikachu），有一个属性“电系”，有方法 thunderbolt、iron tail、volt tackle、agility。类是蓝图，而实例化对象就是把它放进主程序，然后可以使用其方法。

OOP 的四大特征：

封装（Encapsulation）：将数据和方法捆绑在类中，并通过访问修饰符控制权限。
抽象（Abstraction）：隐藏复杂细节，只暴露必要信息。
继承（Inheritance）：子类可以继承父类属性和方法。
多态（Polymorphism）：不同类的对象可以视为同一父类对象使用。

优点是让软件更加模块化、可重用、可扩展。常见的面向对象语言有 Python、Java、C++、Ruby。

函数式编程（Functional Programming）：

偏重数学函数的编程范式，避免修改状态或数据。输出只依赖于输入，数据一旦创建不会改变（而是生成新的数据结构）。

函数式编程更多依赖递归而非循环。函数还可以接收其他函数作为输入，或者返回函数作为输出。