写中文数字，最直接的办法就是专门查表，这就好比查字典一样。咱们把数字一个个拆开，比如个位的 3 就是“三”，十位的 3 就是“三十”，百位的 3 就是“三百”。先把这步弄明白，后面的那些花活就顺理成章了。 有些数字特别绕，比如“一亿一千万”，看着吓人，实际上拆开来就挺好办。亿位上一个，千万位上两个，那不就是“一百”加“一千零”吗？不对，得再仔细算一下。亿位上是 1，那就是“一亿”，千万位上是 1，那就是“一千万”，加起来就是“一亿一千万”。
这种大数，有时候比小数字还难数，出于中间隔得忒远，好办让人晕头转向。 实际上写大数，最核心就两点：一是数字本身要数对，二是位数要对齐。
比如一千零八万，千位是 1，百位是 8，万位是 0，那一千零八万就出来了。写的时候得把每一段读过的内容都写出来，不能漏掉。 不过，中文数字的写法里有一块是特别讲究格式规范的，那就是“逗号”。
这在那会儿国家统一的时候用得比较多，目前别看不那么普遍了，但看老文档要么老一辈人的习惯还是能看出来的。
比如在“一二三四五六七八九十百千万”这几十个字里，每七个字加一个逗号，这样读起来就特别顺口。你拿去和《千字文》里的句子对照一下，那个节奏感就出来了。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有一个特别有意思的例子，就是"1000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数字，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有啊，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 再比如"10000000000000"，也就是一个万亿。
这个数在中文里叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有一个特别有意思的例子，就是"10000000000000000000"，也就是一个兆（million）。
这个数特别大，读的时候得叫“兆”。
不过，有些怪的数字，比如"2000000000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"11"如何读？要是是"11"，那得读作“十一”。
要是是"101"，那得读作“一百零一”。
这里有个规律，个位上的数要读出来，十位上的数要是前面是 10 到 90 之间，那十位要读出来，个位要读出来。但要是各位都是 1，那就读作“十一”。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万零”，而是“一百”。 再比如，"1000000000"，也就是一个十亿。
这个数在中文里叫“十亿”。但要是是"100000000000"，那就是一个千亿，得叫“千亿”。
这里面的区别在于，每增添一个"0"，代表的基数就乘以 10，故此在中文里，基数也要跟着变。 比如"2000000000"，也就是两个十亿，读作“两千亿”。而"20000000000"，也就是两个百亿，读作“两千百亿”。
你看，每多一个"0"，那一串数字就往后移一位，基数也跟着往后移一位。 还有一个特别有意思的例子，就是"100000000000000"，也就是一个万亿。
这个数特别大，读的时候得叫“万亿”。
不过，有些怪的数，比如"2000000000000001"，这种庞大的数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 还有个例子，比如"2000000000000000000001"，这种数，按照数学写法，中间那个"1"能够省略，直接叫"200000000000000000000"。但这在中文数字里就不中了，出于中文数字对每一段都要有明确的划分，不能省略中间的"1"。 实际上，写大数的时候，最忌讳的就是把“零”当没写，要么把不该写的“零”给删了。
比如"1010"，要是是直接写"1010"，那得读作“一千零一十”。但要是写成"1010"，那得读作“一千零十”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有个地方好办乱，就是“零”字的处理。大量人看到数字里有零，就会认定后面跟着“零”字，结局就把“零”字给删了。
实际上不然，中文数字里要分“循环零”和“连续零”。“循环零”是固定的，比如“一零一亿”这种，中间的零不能省；但要是是“一零零”，那不是连续的零，得写成“一零零”。
这就好比开车，车是轮子，轮子不能少，但要是车是两轮的，那就不需求轮子。 还有一个细节，就是数字本身的读音。我们说的“三”和“三”一样，但在数字里，"1"读“一”，"2"读“二”，"3"读“三”，"4"读“四”，什么的。并且，"10"读作“十”，"100"读作“一百”，"1000"读作“一千”，"10000"读作“一万”，"100000"读作“十万”，"1000000"读作“百万”。
这些读法在写数字的时候也得跟着来。
比如写一百万，不是“一百万
