<?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 on: Python中的整型占多少个字节？	</title>
	<atom:link href="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/feed/" rel="self" type="application/rss+xml" />
	<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/</link>
	<description></description>
	<lastBuildDate>Sun, 23 Oct 2022 14:39:37 +0000</lastBuildDate>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=6.0.8</generator>
	<item>
		<title>
		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>
		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>
		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>
		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>
		By: Python自学条记（三）深入明白Python变量的数据类型和存储 – bilibilifaka		</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-113</link>

		<dc:creator><![CDATA[Python自学条记（三）深入明白Python变量的数据类型和存储 – bilibilifaka]]></dc:creator>
		<pubDate>Sun, 31 Jan 2021 03:08:43 +0000</pubDate>
		<guid isPermaLink="false">https://zxi.mytechroad.com/blog/?p=5853#comment-113</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>
	</channel>
</rss>
