<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	
	>
<channel>
	<title>
	Comments for Huahua&#8217;s Tech Road	</title>
	<atom:link href="https://zxi.mytechroad.com/blog/comments/feed/" rel="self" type="application/rss+xml" />
	<link>https://zxi.mytechroad.com/blog</link>
	<description></description>
	<lastBuildDate>Sun, 11 Jan 2026 18:11:25 +0000</lastBuildDate>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=6.7.5</generator>
	<item>
		<title>
		Comment on 天下苦 Windows 久矣：一个 Mac 老用户的二十年回眸与叹息 by 逃离通用计算的牢笼：当 Windows 沦为昂贵的启动器，SteamOS 指向了何方？ &#8211; Huahua&#8217;s Tech Road		</title>
		<link>https://zxi.mytechroad.com/blog/os/%e5%a4%a9%e4%b8%8b%e8%8b%a6-windows-%e4%b9%85%e7%9f%a3%ef%bc%9a%e4%b8%80%e4%b8%aa-mac-%e8%80%81%e7%94%a8%e6%88%b7%e7%9a%84%e4%ba%8c%e5%8d%81%e5%b9%b4%e5%9b%9e%e7%9c%b8%e4%b8%8e%e5%8f%b9%e6%81%af/#comment-205</link>

		<dc:creator><![CDATA[逃离通用计算的牢笼：当 Windows 沦为昂贵的启动器，SteamOS 指向了何方？ &#8211; Huahua&#8217;s Tech Road]]></dc:creator>
		<pubDate>Sun, 11 Jan 2026 18:11:25 +0000</pubDate>
		<guid isPermaLink="false">https://zxi.mytechroad.com/blog/?p=10547#comment-205</guid>

					<description><![CDATA[[&#8230;] 这也是为什么我们之前聊《天下苦 Windows 久矣》。对于绝大多数纯粹的游戏玩家而言，Windows 的身份早已发生了质的坍塌：它不再是一个服务于我们的操作系统，它只是一个臃肿、傲慢、不得不忍受的“Steam 高级启动器”。 [&#8230;]]]></description>
			<content:encoded><![CDATA[<p>[&#8230;] 这也是为什么我们之前聊《天下苦 Windows 久矣》。对于绝大多数纯粹的游戏玩家而言，Windows 的身份早已发生了质的坍塌：它不再是一个服务于我们的操作系统，它只是一个臃肿、傲慢、不得不忍受的“Steam 高级启动器”。 [&#8230;]</p>
]]></content:encoded>
		
			</item>
		<item>
		<title>
		Comment on 再谈苹果XDR显示器与HDR之殇 by Nikon Z8/Z9 HLG Deepdive &#124; HLG 详解 VS N-LOG &#8211; Huahua&#8217;s Tech Road		</title>
		<link>https://zxi.mytechroad.com/blog/hdr/%e5%86%8d%e8%b0%88%e8%8b%b9%e6%9e%9cxdr%e6%98%be%e7%a4%ba%e5%99%a8%e4%b8%8ehdr%e4%b9%8b%e6%ae%87/#comment-204</link>

		<dc:creator><![CDATA[Nikon Z8/Z9 HLG Deepdive &#124; HLG 详解 VS N-LOG &#8211; Huahua&#8217;s Tech Road]]></dc:creator>
		<pubDate>Sun, 04 May 2025 04:45:56 +0000</pubDate>
		<guid isPermaLink="false">https://zxi.mytechroad.com/blog/?p=10387#comment-204</guid>

					<description><![CDATA[[&#8230;] 首先HLG是一条用于交付的Gamma曲线，向下兼容SDR内容，这也就注定了它的上限比较低。动态范围(尤其高光)比不过N-LOG，更别说Slog3了。暗部表现比其他LOG曲线要好一些。它最大的优点就是所见即所得，不需要LUT还原，也(基本)不需要额外的向右曝光，特别适合HDR直出。不过如果你只做SDR的话，还是选N-LOG吧。只是2025年了，拍N-LOG/NRAW获得12+档动态范围，然后再压缩到8档，我只能说历史的包袱太沉重了。可以参见：再谈苹果XDR显示器与HDR之殇 [&#8230;]]]></description>
			<content:encoded><![CDATA[<p>[&#8230;] 首先HLG是一条用于交付的Gamma曲线，向下兼容SDR内容，这也就注定了它的上限比较低。动态范围(尤其高光)比不过N-LOG，更别说Slog3了。暗部表现比其他LOG曲线要好一些。它最大的优点就是所见即所得，不需要LUT还原，也(基本)不需要额外的向右曝光，特别适合HDR直出。不过如果你只做SDR的话，还是选N-LOG吧。只是2025年了，拍N-LOG/NRAW获得12+档动态范围，然后再压缩到8档，我只能说历史的包袱太沉重了。可以参见：再谈苹果XDR显示器与HDR之殇 [&#8230;]</p>
]]></content:encoded>
		
			</item>
		<item>
		<title>
		Comment on Python中的整型占多少个字节？ by Python自学笔记（三）深入理解Python变量的数据类型和存储 - 内存网		</title>
		<link>https://zxi.mytechroad.com/blog/desgin/python%e4%b8%ad%e7%9a%84%e6%95%b4%e5%9e%8b%e5%8d%a0%e5%a4%9a%e5%b0%91%e4%b8%aa%e5%ad%97%e8%8a%82%ef%bc%9f/#comment-173</link>

		<dc:creator><![CDATA[Python自学笔记（三）深入理解Python变量的数据类型和存储 - 内存网]]></dc:creator>
		<pubDate>Sun, 23 Oct 2022 14:39:37 +0000</pubDate>
		<guid isPermaLink="false">https://zxi.mytechroad.com/blog/?p=5853#comment-173</guid>

					<description><![CDATA[[&#8230;]   看到输出结果，属实让人震惊，一个int型的数值，居然用高达24个字节来存储，而且在电脑存储大小居然是不限定的，是自增长的。喝口水压压惊后，让我想到c++的STL容器，可以使用栈顶指针，当检测到容量超出时，则删除旧内存而去开辟一块新的内存，确实可以实现这种效果。   扯完犊子，那么这里首先先解决第一个问题，int类型这个变量什么时候内存会变大？我在这篇博客中提到的文章找到了答案: 点此处跳转。重点就是下面这张图，简单来说就是int类型每多2^30（1073741824 ）就会增加四个字节。这也验证了上面例子getsizeof(2**30)是32字节，而比它小的是28个字节的原因，当然零除外。其他类型也可以在下面找到答案。    那么它的自增长问题呢，这个可能要去看python的源码才能解决，还好有大佬已经提前给我们铺了下路，这里我就没这个能力去了解太深入了，直接引用大佬的结论就可以了。具体可以参考这篇文章：点此处跳转。在64位python的解释器中，int类型的定义是通过一个结构体来定义的，简化后的结构体如下所示： [&#8230;]]]></description>
			<content:encoded><![CDATA[<p>[&#8230;]   看到输出结果，属实让人震惊，一个int型的数值，居然用高达24个字节来存储，而且在电脑存储大小居然是不限定的，是自增长的。喝口水压压惊后，让我想到c++的STL容器，可以使用栈顶指针，当检测到容量超出时，则删除旧内存而去开辟一块新的内存，确实可以实现这种效果。   扯完犊子，那么这里首先先解决第一个问题，int类型这个变量什么时候内存会变大？我在这篇博客中提到的文章找到了答案: 点此处跳转。重点就是下面这张图，简单来说就是int类型每多2^30（1073741824 ）就会增加四个字节。这也验证了上面例子getsizeof(2**30)是32字节，而比它小的是28个字节的原因，当然零除外。其他类型也可以在下面找到答案。    那么它的自增长问题呢，这个可能要去看python的源码才能解决，还好有大佬已经提前给我们铺了下路，这里我就没这个能力去了解太深入了，直接引用大佬的结论就可以了。具体可以参考这篇文章：点此处跳转。在64位python的解释器中，int类型的定义是通过一个结构体来定义的，简化后的结构体如下所示： [&#8230;]</p>
]]></content:encoded>
		
			</item>
		<item>
		<title>
		Comment on 花花酱 LeetCode 879. Profitable Schemes by 花花酱 LeetCode 879. Profitable Schemes - 刷题找工作 EP212 - AskField		</title>
		<link>https://zxi.mytechroad.com/blog/dynamic-programming/leetcode-879-profitable-schemes/#comment-171</link>

		<dc:creator><![CDATA[花花酱 LeetCode 879. Profitable Schemes - 刷题找工作 EP212 - AskField]]></dc:creator>
		<pubDate>Wed, 12 Oct 2022 20:41:45 +0000</pubDate>
		<guid isPermaLink="false">http://zxi.mytechroad.com/blog/?p=3364#comment-171</guid>

					<description><![CDATA[[&#8230;] (Solution) : http://zxi.mytechroad.com/blog/dynamic-programming/leetcode-879-profitable-schemes/ 题目分类: [&#8230;]]]></description>
			<content:encoded><![CDATA[<p>[&#8230;] (Solution) : <a href="http://zxi.mytechroad.com/blog/dynamic-programming/leetcode-879-profitable-schemes/" rel="ugc">http://zxi.mytechroad.com/blog/dynamic-programming/leetcode-879-profitable-schemes/</a> 题目分类: [&#8230;]</p>
]]></content:encoded>
		
			</item>
		<item>
		<title>
		Comment on Python中的整型占多少个字节？ by Python自学笔记（三）深入理解Python变量的数据类型和存储 - 算法网		</title>
		<link>https://zxi.mytechroad.com/blog/desgin/python%e4%b8%ad%e7%9a%84%e6%95%b4%e5%9e%8b%e5%8d%a0%e5%a4%9a%e5%b0%91%e4%b8%aa%e5%ad%97%e8%8a%82%ef%bc%9f/#comment-125</link>

		<dc:creator><![CDATA[Python自学笔记（三）深入理解Python变量的数据类型和存储 - 算法网]]></dc:creator>
		<pubDate>Sun, 13 Feb 2022 15:24:36 +0000</pubDate>
		<guid isPermaLink="false">https://zxi.mytechroad.com/blog/?p=5853#comment-125</guid>

					<description><![CDATA[[&#8230;]   看到输出结果，属实让人震惊，一个int型的数值，居然用高达24个字节来存储，而且在电脑存储大小居然是不限定的，是自增长的。喝口水压压惊后，让我想到c++的STL容器，可以使用栈顶指针，当检测到容量超出时，则删除旧内存而去开辟一块新的内存，确实可以实现这种效果。   扯完犊子，那么这里首先先解决第一个问题，int类型这个变量什么时候内存会变大？我在这篇博客中提到的文章找到了答案: 点此处跳转。重点就是下面这张图，简单来说就是int类型每多2^30（1073741824 ）就会增加四个字节。这也验证了上面例子getsizeof(2**30)是32字节，而比它小的是28个字节的原因，当然零除外。其他类型也可以在下面找到答案。    那么它的自增长问题呢，这个可能要去看python的源码才能解决，还好有大佬已经提前给我们铺了下路，这里我就没这个能力去了解太深入了，直接引用大佬的结论就可以了。具体可以参考这篇文章：点此处跳转。在64位python的解释器中，int类型的定义是通过一个结构体来定义的，简化后的结构体如下所示： [&#8230;]]]></description>
			<content:encoded><![CDATA[<p>[&#8230;]   看到输出结果，属实让人震惊，一个int型的数值，居然用高达24个字节来存储，而且在电脑存储大小居然是不限定的，是自增长的。喝口水压压惊后，让我想到c++的STL容器，可以使用栈顶指针，当检测到容量超出时，则删除旧内存而去开辟一块新的内存，确实可以实现这种效果。   扯完犊子，那么这里首先先解决第一个问题，int类型这个变量什么时候内存会变大？我在这篇博客中提到的文章找到了答案: 点此处跳转。重点就是下面这张图，简单来说就是int类型每多2^30（1073741824 ）就会增加四个字节。这也验证了上面例子getsizeof(2**30)是32字节，而比它小的是28个字节的原因，当然零除外。其他类型也可以在下面找到答案。    那么它的自增长问题呢，这个可能要去看python的源码才能解决，还好有大佬已经提前给我们铺了下路，这里我就没这个能力去了解太深入了，直接引用大佬的结论就可以了。具体可以参考这篇文章：点此处跳转。在64位python的解释器中，int类型的定义是通过一个结构体来定义的，简化后的结构体如下所示： [&#8230;]</p>
]]></content:encoded>
		
			</item>
		<item>
		<title>
		Comment on 花花酱 LeetCode 171. Excel Sheet Column Number by 花花酱 LeetCode 168. Excel Sheet Column Title &#8211; Huahua&#8217;s Tech Road		</title>
		<link>https://zxi.mytechroad.com/blog/math/leetcode-171-excel-sheet-column-number/#comment-123</link>

		<dc:creator><![CDATA[花花酱 LeetCode 168. Excel Sheet Column Title &#8211; Huahua&#8217;s Tech Road]]></dc:creator>
		<pubDate>Sun, 28 Nov 2021 22:36:12 +0000</pubDate>
		<guid isPermaLink="false">https://zxi.mytechroad.com/blog/?p=8884#comment-123</guid>

					<description><![CDATA[[&#8230;] 花花酱 LeetCode 171. Excel Sheet Column Number [&#8230;]]]></description>
			<content:encoded><![CDATA[<p>[&#8230;] 花花酱 LeetCode 171. Excel Sheet Column Number [&#8230;]</p>
]]></content:encoded>
		
			</item>
		<item>
		<title>
		Comment on 花花酱 LeetCode 168. Excel Sheet Column Title by LeetCode 171. Excel Sheet Column Number &#8211; Huahua&#8217;s Tech Road		</title>
		<link>https://zxi.mytechroad.com/blog/math/leetcode-168-excel-sheet-column-title/#comment-122</link>

		<dc:creator><![CDATA[LeetCode 171. Excel Sheet Column Number &#8211; Huahua&#8217;s Tech Road]]></dc:creator>
		<pubDate>Sun, 28 Nov 2021 22:35:10 +0000</pubDate>
		<guid isPermaLink="false">https://zxi.mytechroad.com/blog/?p=8880#comment-122</guid>

					<description><![CDATA[[&#8230;] 花花酱 LeetCode 168. Excel Sheet Column Title [&#8230;]]]></description>
			<content:encoded><![CDATA[<p>[&#8230;] 花花酱 LeetCode 168. Excel Sheet Column Title [&#8230;]</p>
]]></content:encoded>
		
			</item>
		<item>
		<title>
		Comment on 花花酱 LeetCode 136. Single Number by 花花酱 LeetCode 137. Single Number II &#8211; Huahua&#8217;s Tech Road		</title>
		<link>https://zxi.mytechroad.com/blog/bit/leetcode-136-single-number/#comment-121</link>

		<dc:creator><![CDATA[花花酱 LeetCode 137. Single Number II &#8211; Huahua&#8217;s Tech Road]]></dc:creator>
		<pubDate>Sun, 28 Nov 2021 05:12:28 +0000</pubDate>
		<guid isPermaLink="false">https://zxi.mytechroad.com/blog/?p=8843#comment-121</guid>

					<description><![CDATA[[&#8230;] 花花酱 LeetCode 136. Single Number [&#8230;]]]></description>
			<content:encoded><![CDATA[<p>[&#8230;] 花花酱 LeetCode 136. Single Number [&#8230;]</p>
]]></content:encoded>
		
			</item>
		<item>
		<title>
		Comment on 花花酱 LeetCode 118. Pascal&#8217;s Triangle by 花花酱 LeetCode 119. Pascal&#8217;s Triangle II &#8211; Huahua&#8217;s Tech Road		</title>
		<link>https://zxi.mytechroad.com/blog/simulation/leetcode-118-pascals-triangle/#comment-120</link>

		<dc:creator><![CDATA[花花酱 LeetCode 119. Pascal&#8217;s Triangle II &#8211; Huahua&#8217;s Tech Road]]></dc:creator>
		<pubDate>Sun, 28 Nov 2021 04:50:57 +0000</pubDate>
		<guid isPermaLink="false">https://zxi.mytechroad.com/blog/?p=8833#comment-120</guid>

					<description><![CDATA[[&#8230;] 花花酱 LeetCode 118. Pascal’s Triangle [&#8230;]]]></description>
			<content:encoded><![CDATA[<p>[&#8230;] 花花酱 LeetCode 118. Pascal’s Triangle [&#8230;]</p>
]]></content:encoded>
		
			</item>
		<item>
		<title>
		Comment on 花花酱 LeetCode 2. Add Two Numbers by 花花酱 LeetCode 445. Add Two Numbers II &#8211; Huahua&#8217;s Tech Road		</title>
		<link>https://zxi.mytechroad.com/blog/list/leetcode-2-add-two-numbers/#comment-119</link>

		<dc:creator><![CDATA[花花酱 LeetCode 445. Add Two Numbers II &#8211; Huahua&#8217;s Tech Road]]></dc:creator>
		<pubDate>Thu, 08 Apr 2021 06:55:18 +0000</pubDate>
		<guid isPermaLink="false">http://zxi.mytechroad.com/blog/?p=3293#comment-119</guid>

					<description><![CDATA[[&#8230;] 花花酱 LeetCode 2. Add Two Numbers [&#8230;]]]></description>
			<content:encoded><![CDATA[<p>[&#8230;] 花花酱 LeetCode 2. Add Two Numbers [&#8230;]</p>
]]></content:encoded>
		
			</item>
		<item>
		<title>
		Comment on Python中的整型占多少个字节？ by Python自学笔记（三）深入理解Python变量的数据类型和存储		</title>
		<link>https://zxi.mytechroad.com/blog/desgin/python%e4%b8%ad%e7%9a%84%e6%95%b4%e5%9e%8b%e5%8d%a0%e5%a4%9a%e5%b0%91%e4%b8%aa%e5%ad%97%e8%8a%82%ef%bc%9f/#comment-118</link>

		<dc:creator><![CDATA[Python自学笔记（三）深入理解Python变量的数据类型和存储]]></dc:creator>
		<pubDate>Tue, 06 Apr 2021 03:13:08 +0000</pubDate>
		<guid isPermaLink="false">https://zxi.mytechroad.com/blog/?p=5853#comment-118</guid>

					<description><![CDATA[[&#8230;]   看到输出结果，属实让人震惊，一个int型的数值，居然用高达24个字节来存储，而且在电脑存储大小居然是不限定的，是自增长的。喝口水压压惊后，让我想到c++的STL容器，可以使用栈顶指针，当检测到容量超出时，则删除旧内存而去开辟一块新的内存，确实可以实现这种效果。   扯完犊子，那么这里首先先解决第一个问题，int类型这个变量什么时候内存会变大？我在这篇博客中提到的文章找到了答案: 点此处跳转。重点就是下面这张图，简单来说就是int类型每多2^30（1073741824 ）就会增加四个字节。这也验证了上面例子getsizeof(2**30)是32字节，而比它小的是28个字节的原因，当然零除外。其他类型也可以在下面找到答案。    那么它的自增长问题呢，这个可能要去看python的源码才能解决，还好有大佬已经提前给我们铺了下路，这里我就没这个能力去了解太深入了，直接引用大佬的结论就可以了。具体可以参考这篇文章：点此处跳转。在64位python的解释器中，int类型的定义是通过一个结构体来定义的，简化后的结构体如下所示： [&#8230;]]]></description>
			<content:encoded><![CDATA[<p>[&#8230;]   看到输出结果，属实让人震惊，一个int型的数值，居然用高达24个字节来存储，而且在电脑存储大小居然是不限定的，是自增长的。喝口水压压惊后，让我想到c++的STL容器，可以使用栈顶指针，当检测到容量超出时，则删除旧内存而去开辟一块新的内存，确实可以实现这种效果。   扯完犊子，那么这里首先先解决第一个问题，int类型这个变量什么时候内存会变大？我在这篇博客中提到的文章找到了答案: 点此处跳转。重点就是下面这张图，简单来说就是int类型每多2^30（1073741824 ）就会增加四个字节。这也验证了上面例子getsizeof(2**30)是32字节，而比它小的是28个字节的原因，当然零除外。其他类型也可以在下面找到答案。    那么它的自增长问题呢，这个可能要去看python的源码才能解决，还好有大佬已经提前给我们铺了下路，这里我就没这个能力去了解太深入了，直接引用大佬的结论就可以了。具体可以参考这篇文章：点此处跳转。在64位python的解释器中，int类型的定义是通过一个结构体来定义的，简化后的结构体如下所示： [&#8230;]</p>
]]></content:encoded>
		
			</item>
		<item>
		<title>
		Comment on 花花酱 LeetCode 488. Zuma Game by 花花酱 LeetCode 488. Zuma Game - 刷题找工作 EP84 - ZumZuma		</title>
		<link>https://zxi.mytechroad.com/blog/searching/leetcode-488-zuma-game/#comment-117</link>

		<dc:creator><![CDATA[花花酱 LeetCode 488. Zuma Game - 刷题找工作 EP84 - ZumZuma]]></dc:creator>
		<pubDate>Sat, 27 Mar 2021 05:42:16 +0000</pubDate>
		<guid isPermaLink="false">http://zxi.mytechroad.com/blog/?p=570#comment-117</guid>

					<description><![CDATA[[&#8230;] (Solution) : http://zxi.mytechroad.com/blog/searching/leetcode-488-zuma-game/ 题目列表: * 动态规划 (Dynamic programming) [&#8230;]]]></description>
			<content:encoded><![CDATA[<p>[&#8230;] (Solution) : <a href="http://zxi.mytechroad.com/blog/searching/leetcode-488-zuma-game/" rel="ugc">http://zxi.mytechroad.com/blog/searching/leetcode-488-zuma-game/</a> 题目列表: * 动态规划 (Dynamic programming) [&#8230;]</p>
]]></content:encoded>
		
			</item>
		<item>
		<title>
		Comment on 花花酱 LeetCode 1. Two Sum by 花花酱 LeetCode 15. 3Sum &#8211; Huahua&#8217;s Tech Road		</title>
		<link>https://zxi.mytechroad.com/blog/hashtable/leetcode-1-two-sum/#comment-116</link>

		<dc:creator><![CDATA[花花酱 LeetCode 15. 3Sum &#8211; Huahua&#8217;s Tech Road]]></dc:creator>
		<pubDate>Sat, 20 Feb 2021 23:06:19 +0000</pubDate>
		<guid isPermaLink="false">http://zxi.mytechroad.com/blog/?p=903#comment-116</guid>

					<description><![CDATA[[&#8230;] [解题报告] LeetCode 1. Two Sum 花花酱 [&#8230;]]]></description>
			<content:encoded><![CDATA[<p>[&#8230;] [解题报告] LeetCode 1. Two Sum 花花酱 [&#8230;]</p>
]]></content:encoded>
		
			</item>
		<item>
		<title>
		Comment on Python中的整型占多少个字节？ by Python自学笔记（三）深入理解Python变量的数据类型和存储 - bilibili的blog		</title>
		<link>https://zxi.mytechroad.com/blog/desgin/python%e4%b8%ad%e7%9a%84%e6%95%b4%e5%9e%8b%e5%8d%a0%e5%a4%9a%e5%b0%91%e4%b8%aa%e5%ad%97%e8%8a%82%ef%bc%9f/#comment-115</link>

		<dc:creator><![CDATA[Python自学笔记（三）深入理解Python变量的数据类型和存储 - bilibili的blog]]></dc:creator>
		<pubDate>Thu, 18 Feb 2021 03:28:46 +0000</pubDate>
		<guid isPermaLink="false">https://zxi.mytechroad.com/blog/?p=5853#comment-115</guid>

					<description><![CDATA[[&#8230;]   看到输出结果，属实让人震惊，一个int型的数值，居然用高达24个字节来存储，而且在电脑存储大小居然是不限定的，是自增长的。喝口水压压惊后，让我想到c++的STL容器，可以使用栈顶指针，当检测到容量超出时，则删除旧内存而去开辟一块新的内存，确实可以实现这种效果。   扯完犊子，那么这里首先先解决第一个问题，int类型这个变量什么时候内存会变大？我在这篇博客中提到的文章找到了答案: 点此处跳转。重点就是下面这张图，简单来说就是int类型每多2^30（1073741824 ）就会增加四个字节。这也验证了上面例子getsizeof(2**30)是32字节，而比它小的是28个字节的原因，当然零除外。其他类型也可以在下面找到答案。    那么它的自增长问题呢，这个可能要去看python的源码才能解决，还好有大佬已经提前给我们铺了下路，这里我就没这个能力去了解太深入了，直接引用大佬的结论就可以了。具体可以参考这篇文章：点此处跳转。在64位python的解释器中，int类型的定义是通过一个结构体来定义的，简化后的结构体如下所示： [&#8230;]]]></description>
			<content:encoded><![CDATA[<p>[&#8230;]   看到输出结果，属实让人震惊，一个int型的数值，居然用高达24个字节来存储，而且在电脑存储大小居然是不限定的，是自增长的。喝口水压压惊后，让我想到c++的STL容器，可以使用栈顶指针，当检测到容量超出时，则删除旧内存而去开辟一块新的内存，确实可以实现这种效果。   扯完犊子，那么这里首先先解决第一个问题，int类型这个变量什么时候内存会变大？我在这篇博客中提到的文章找到了答案: 点此处跳转。重点就是下面这张图，简单来说就是int类型每多2^30（1073741824 ）就会增加四个字节。这也验证了上面例子getsizeof(2**30)是32字节，而比它小的是28个字节的原因，当然零除外。其他类型也可以在下面找到答案。    那么它的自增长问题呢，这个可能要去看python的源码才能解决，还好有大佬已经提前给我们铺了下路，这里我就没这个能力去了解太深入了，直接引用大佬的结论就可以了。具体可以参考这篇文章：点此处跳转。在64位python的解释器中，int类型的定义是通过一个结构体来定义的，简化后的结构体如下所示： [&#8230;]</p>
]]></content:encoded>
		
			</item>
		<item>
		<title>
		Comment on 花花酱 LeetCode 454. 4Sum II by 花花酱 LeetCode 15. 3Sum &#8211; Huahua&#8217;s Tech Road		</title>
		<link>https://zxi.mytechroad.com/blog/hashtable/leetcode-454-4sum-ii/#comment-114</link>

		<dc:creator><![CDATA[花花酱 LeetCode 15. 3Sum &#8211; Huahua&#8217;s Tech Road]]></dc:creator>
		<pubDate>Mon, 15 Feb 2021 20:53:45 +0000</pubDate>
		<guid isPermaLink="false">http://zxi.mytechroad.com/blog/?p=1986#comment-114</guid>

					<description><![CDATA[[&#8230;] 花花酱 LeetCode 454. 4Sum II [&#8230;]]]></description>
			<content:encoded><![CDATA[<p>[&#8230;] 花花酱 LeetCode 454. 4Sum II [&#8230;]</p>
]]></content:encoded>
		
			</item>
	</channel>
</rss>
