以上就是给各位分享Python整型：布尔型、标准整型、长整型操作实例，其中也会对整型python进行解释，同时本文还将给你拓展(五)python3整型int、2014.12.26整型，字符型，布尔型，
以上就是给各位分享Python整型：布尔型、标准整型、长整型操作实例，其中也会对整型 python进行解释，同时本文还将给你拓展(五)python3 整型int、2014.12.26 整型，字符型，布尔型，浮点型、C++ 无符号整型和整型的区别、C++整型、浮点型与字符串型相互转换等相关知识，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：- Python整型：布尔型、标准整型、长整型操作实例（整型 python）
- (五)python3 整型int
- 2014.12.26 整型，字符型，布尔型，浮点型
- C++ 无符号整型和整型的区别
- C++整型、浮点型与字符串型相互转换
Python整型：布尔型、标准整型、长整型操作实例（整型 python）
#coding=utf8
def integerType():
''''''
布尔型：
该值的取值范围只有两个值：True(1)、False(0)
''''''
Tbool=True
Fbool=False
print "The True is stand for %d" %(Tbool)
print "The False is stand for %d" %(Fbool)
print
''''''
python标准整数类型：
Python标准整数类型是最通用的数字类型。
在大多数32位机器上，标准整数类型的取值范围：-2147483648 到 2147483647
Python标准整数类型等价于C的有符号长整型。
八进制整数以数字“0”开始。
十六进制整数以“0x”或“0X”开始
''''''
bInt=010101
dInt=84455555
oInt=075
hInt=0xabc
print "The binary of the standard integer:",bInt
print "The decimal of the standard integer:",dInt
print "The octal of the standard integer:",oInt
print "The hexadecimal of the standard integer:",hInt
print
''''''
python长整型：
Python长整型能表达的数值仅仅与机器值的(虚拟)内存大小有关。
长整数类型是标准整数类型的超集。
在一个整数值后面加上个L(大写或小写都可以，推荐使用大写，避免和数字1混淆)，表示这个整数时长整数。
这个整数可以是十进制、八进制、十六进制。
只有对长整数调用repr()才有机会看到L，对长整数调用str()看不到L。
整型和长整型正在统一为一种。
''''''
bLong=0111111111111111111111111111111111111111111111L
dLong=8888888888888888888888888888888888888888888888L
oLong=0777777777777777777777777777777777777777777777L
hLong=0XFFFFFFFFFFFFFFFFFAAAAAAAAAAAAABBBBBBBBBB78L
print "The binary of the long integer:",repr(bLong)
print "The decimal of the long integer:",repr(dLong)
print "The octal of the long integer:",repr(oLong)
print "The hexadecimal of the long integer:",repr(hLong)
print
''''''call the function : integerType()''''''
integerType()
(五)python3 整型int
int() Python 内置函数，用于将一个字符串或数字转换为整型。
int(x, base=10)#以十进制转换x为整型（默认）>>>int() # 不传入参数时，得到结果0
0
>>> int(3)
3
>>> int(3.6)
3
>>> int(''12'',16) # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制
18
>>> int(''0xa'',16)
10
>>> int(''10'',8)
8bit_length(返回二进制的最小长度)>>> bin(37)
''0b100101''
>>> (37).bit_length()
6__abs__(返回绝对值)
n = -5
print(n.__abs__())
#输出：5__add__(相加，运算符：+)
n = 3
print(n.__add__(5))
#输出：8__and__（按位与运算，运算符：&）
n = 5
print(n.__and__(7))
#输出：5
# 00000110
#与运算
# 00000111
#等于 00000110
__bool__
#占位__ceil__（返回自身）
n = 1234
print(n.__ceil__())
#输出：1234__divmod__(返回除数和余数)
n = 13
print(n.__divmod__(5))
#输出：(2, 3)__eq__（判断两数是否相等，运算符：==）
n = 5
print(n.__eq__(3))
#输出：False__float__（转换成浮点型）
n = 5
print(n.__float__())
#输出：5.0__floordiv__（取整除，返回商的整数部分，运算符：//）
n = 9
print(n.__floordiv__(4))
#输出：2__floor__
#占位__format__
#占位__getattribute__
#占位__getnewargs__
#占位__ge__(判断是否 >=)
n = 5
print(n.__ge__(3))
#输出：True__gt__(判断是否 > )
n = 5
print(n.__gt__(3))
#输出：True__hash__
#占位__index__
#占位__invert__（二进制按位取反，运算符：~）
n = 11
print(n.__invert__())
#输出：-12
#ps:二进制的负数表示方法：正数按位取反再加1__le__（判断是否 <=）
n = 5
print(n.__le__(3))
#输出：False__lshift__(二进制左移运算，运算符：<<)
n = 12
print(n.__lshift__(2))
#输出：48
#ps:二进制左移1位等于十进制乘2，右移一位等于十进制除2__lt__(判断是否 <)
n = 5
print(n.__lt__(3))
# #输出：False__mod__(取模-返回除法的余数，运算符：%)
n = 14
print(n.__mod__(3))
#输出：2__mul__(相乘，运算符：*)
n = 3
print(n.__mul__(6))
#输出：18__neg__(取反，正数变负数，负数变正数，运算符：-)
n = 5
print(n.__neg__())
#输出：-5__new__
#占位__ne__(判断两值是否不相等，运算符：!= )
n = 5
print(n.__ne__(3))
#输出：True__or__(按位或运算，运算符：|)
n = 3
print(n.__or__(5))
#输出：7
# # 00000011
# #或
# # 00000110
# # 00000111
__pos__
# """ +self """ （不知道有啥意义）__pow__(返回 xy [x的y次方] 的值)
n = 2
print(n.__pow__(3))
#输出：8__radd__(相加，运算符：+)
n = 5
print(n.__radd__(3))
#输出：8__rand__
#""" Return value&self. """__rdivmod__
#""" Return divmod(value, self). """__repr__（返回自身）
#""" Return repr(self). """__rfloordiv__（取整除，返回商的整数部分，运算符：//）
#""" Return value//self. """__rlshift__(二进制左移运算，运算符：<<)
#""" Return value<<self. """__rmod__(取模-返回除法的余数，运算符：%)
#""" Return value%self. """__rmul__(相乘，运算符：*)
#""" Return value*self. """__ror__
#""" Return value|self. """__round__
#占位__rpow__(返回 yx [y的x次方] 的值)
n = 3
print(n.__rpow__(2))
#输出：8__rrshift__
#""" Return value>>self. """__rshift__
#""" Return self>>value. """__rsub__
#""" Return value-self. """__rtruediv__
#""" Return value/self. """__rxor__
#""" Return value^self. """__sizeof__
#""" Returns size in memory, in bytes """__str__
#""" Return str(self). """sub(相减)
#""" Return self-value. """__truediv__（相除）
#""" Return self/value. """__trunc__
#占位__xor__（按位异或，运算符：^）
#""" Return self^value. """conjugate
#占位from_bytes
#占位to_bytes
#占位
2014.12.26 整型，字符型，布尔型，浮点型
<p> 最小的存储单元是 byte (字节)，但是在 C++ 中并没有这样的类型，只有 char</p> <h4 > 有符号整型 </h4> <ul> <ul> <li>short  <ul> <li>16 位 能表示范围   -2^15 到 2^15 – 1   = –32768 到 32767</li> </ul> </li> </ul> </ul> <p> </p> <ul> <ul> <li>int      <ul> <li>32 位   -2^31  到 -2^31 – 1</li> </ul> </li> </ul> </ul> <p> </p> <ul> <ul> <li>long <ul> <li > 可变的，如果在 32 位系统下 long = 32 位，如果在 64 位系统下 long = 64</li> </ul> </li> </ul> </ul> <p> </p> <ul> <ul> <li>long long <ul> <li > 永远 64 位   -2^63  到 -2^63 – 1     </li> </ul> </li> </ul> </ul> <h4 > 无符号整型 (不能表示负数了)</h4> <ul> <ul> <li>unsigned short  0 - 2^16 – 1   = 0 到 65535 </li> </ul> </ul> <h4> </h4> <h4 > 获取数据类型尺寸 </h4> <blockquote> <p > 获取数据类型尺寸的结果是字节数 </p> <pre><pre><span>// 结果为字节 byte</span> </pre><pre> cout << "<span>size of (short) = </span>" << <span>sizeof</span>(<span>short</span>) <<"<span> byte</span>" << endl; </pre><pre> cout << "<span>size of (int) = </span>" << <span>sizeof</span>(<span>int</span>) << "<span> byte</span>" << endl; </pre><pre> cout << "<span>size of (long) = </span>" << <span>sizeof</span>(<span>long</span>) << "<span> byte</span>" << endl; </pre><pre> cout << "<span>size of (long long) = </span>" << <span>sizeof</span>(_Longlong) << "<span> byte</span>" << endl; </pre><pre></pre><pre> <span>// 还可以输出最大值和最小值 不用 sizeof 方法 </span> </pre><pre> cout << LONG_MAX << endl; </pre><pre> cout << ULLONG_MAX << endl;</pre></pre> </blockquote>
<p> </p>
<h4> 整型溢出 </h4>
<blockquote> <p > 大多数语言是允许整型溢出的 </p> </blockquote>
<p> </p>
<h4> 字符类型 </h4>
<blockquote> <p>c++ 里面是没有 byte 类型的，一个字符类型兼两个作用 </p> </blockquote>
<ul> <ul> <li > 存储标准 ascll 码 0 到 127 共 128 个字符 </li>
<li>当作有符号的字节类型</li>
</ul> </ul>
<h4> 宽字符类型 </h4>
<ul> <ul> <li > 宽字符类型 wchar_t 以 32 位来存储字符 </li>
<li>c++11里面新出的两个宽字符类型 char16_t (16位) char32_t(32位)</li>
</ul> </ul>
<blockquote> <pre><pre>wchar_t c1 = L'' 中 ''; <span>// 前面加 L</span> </pre><pre> <span>char</span>16_t c2 = L'' 中 ''; </pre><pre> <span>char</span>32_t c3 = L'' 中 '';</pre></pre>
<h5> 宽字节的输入输出 </h5>
<pre><pre>wcout << "<span>c1 = </span>"<<c1<<endl; <span>// 输出是字符 这边不一定输出的是 & quot; 中 & quot; 字，因为 wcout 指的是宽字节不一定是 unicode</span> </pre><pre></pre><pre> wcout << L"<span> 中 </span>" << endl;<span>// 这里标明了 L 一定是输出 & quot; 中 & quot; 字 </span>
</pre><pre></pre><pre> cout << "<span>c1 的编码是 : </span>" << c1 << endl;<span>// 输出的是十进制编码是 20013 转成十六进制是 4E2D</span> </pre><pre> </pre><pre> cout << "<span>\u4e2d</span>" << endl;<span>// 通过 unicode 编码输出字符 这边输出的肯定是 "中" 字 \u 代表了 unicode</span></pre></pre>
</blockquote>
<h4> 布尔类型 </h4>
<blockquote> <pre><pre><span>bool</span> flag1 = <span>true</span>; </pre><pre><p> <span>bool</span> flag2 = <span>false</span>;</p> <p> </p></pre><pre> flag1 = 100;<span>// 布尔类型可以赋值整型 非 0 的为真 0 为假 </span></pre></pre> </blockquote>
<pre> </pre>
<h4> 浮点类型 </h4>
<ul> <ul> <li>float 单精度 占用 4byte</li> </ul> </ul>
<p> </p>
<ul> <ul> <li>double 双精度 占用 8byte</li> </ul> </ul>
<p> </p>
<ul> <ul> <li>long double 长双精度占用 16byte</li> </ul> </ul>
<blockquote> <h5></h5> </blockquote>
<h5> 科学计数法 <pre><pre><span>float</span> val1 = 12.34; </pre><pre> <span>double</span> val2 = 12.56; </pre><pre> <span>// 如果数字比较大的时候可以用科学计数法 比如 12300000 后面有 5 个 0 那么多 </span> </pre><pre> <span>// 科学计数法 1 尾数 2e/E 3 指数 </span> </pre><pre> <span>double</span> val3 = 1.23E7;</pre></pre>
<p>  float 最大能表示指数为   +38 – 37   </p>
<p>double +308 –307 </p></h5>
C++ 无符号整型和整型的区别
在Win 7系统中，short 表示的范围为 - 32767到 32767，而无符号的short表示的范围为0 到 65535，其他类型的同理可推导出来，当然，仅当数字不为负的时候才使用无符号类型。
有些事情，当时接触的时候模模糊糊，可是，当你在过些时间慢慢的回头看他时，觉得顿然开悟。
下面的程序显示了如何使用无符号类型，并说明了程序试图超越整型的限制时所产生的后果。在编写程序时切记不要超越这些类型所限制的范围，否则很难找出问题。
#include<iostream>
#define ZERO 0
using namespace std;
#include<climits>
int main()
{
short nu1 = SHRT_MAX;
unsigned short nu2 = nu1;
cout << "nu1 has " << nu1 << " and nu2 has " << nu2 << endl;
cout << "如果每个数都加一呢？" << endl;
nu1 = nu1 + 1;
nu2 = nu2 + 1;
cout << "Now nu1 has " << nu1 << " and nu2 has " << nu2 << endl<<endl;
nu1 = ZERO;
nu2 = ZERO;
cout << "nu1 has " << nu1 << " and nu2 has " << nu2 << endl;
cout << "如果每个数减一呢？" << endl;
nu1 = nu1 - 1;
nu2 = nu2 - 1;
cout << "Now nu1 has " << nu1 << " and nu2 has " << nu2 << endl;
cin.get();
return 0;
} 程序运行结果：
nu1 has 32767 and nu2 has 32767
如果每个数都加一呢？
Now nu1 has -32768 and nu2 has 32768
nu1 has 0 and nu2 has 0
如果每个数减一呢？
Now nu1 has -1 and nu2 has 65535
C++整型、浮点型与字符串型相互转换
更多内容请访问 www.uusystem.com
前言
整型、浮点型与字符串的相互转换可以用自带的函数来实现，本人使用的是vs2015，所以下面有些函数需要改变一下，请看下面的总结。
正文
一、整型转字符串型
1. int转为字符串
itoa(int _Value, char *_Buffer, int _Radix);
需改为_itos_s(int _Value, char *_Buffer, size_t _BufferCount, int _Radix);
_Radix：表示进制，若十进制则Radix为10
_BufferCount：存储的大小，不可以比Buffer的长度大
#include <iostream>
using namespace std;
void main()
{
int num = 10;
char str[3]; // str的长度最少为3，因为10虽然两位，但还有一个结束符
_itoa_s(num, str, sizeof(str), 10); // int转为字符串
cout << str << endl; // 输出结果为10
}
2. long int转为字符串
ltoa(long _Value, char *_Buffer, int _Radix);
改为_ltoa_s(long _Value, char *_Buffer, size_t _BufferCount, int _Radix);
3. 无符号长整型转为字符串
ultoa(unsigned long _Value, char *_Buffer, int _Radix);
改为_ultoa_s(unsigned long _Value, char *_Buffer, size_t _BufferCount, int _Radix);
4. int型转为宽字符串型
_itow(int _Value, wchar_t *_Buffer, int _Radix);
改为_itow_s(int _Value, wchar_t *_Buffer, size_t _BufferCount, int _Radix);
二、浮点型转字符串型
1. double型转为字符串
gcvt(double _Value, int _DigitCount, char* _DstBuf);
改为_gcvt_s(char* _Buffer, size_t _BufferCount, double _Value, int _DigitCount);
说明：显示正负号、小数点
_Digitcount：显示的位数，如1.25，显示两位是1.3（四舍五入），显示三位是1.25
#include <iostream>
using namespace std;
void main()
{
double num = -1.235;
char str[7]; // 在字符串中，正负号、小数点、结束符各占一位
_gcvt_s(str, sizeof(str), num, 3); // double转为字符串，显示三位，1.235四舍五入为1.24
cout << str << endl; // 输出结果为-1.24
}
2. double转换为字符串
ecvt(double _Value, int _DigitCount, int *_PtDec, int *_PtSign);
改为_ecvt_s(char *_Buffer, size_t _BufferCount, double _Value, int _DigitCount, int *_PtDec, int *_PtSign);
说明：不显示小数点和正负号
_PtDec：表示小数点位置，若_PtDec为1，说明小数点左边有一个数
_PtSign：表示正负号，0为正数，1为负数
#include <iostream>
using namespace std;
void main()
{
double num = -1.235;
int Dec, Sign; // Dec:小数点位置，Sign:正负号
char str[5]; // ？至少5位
_ecvt_s(str, sizeof(str), num, 3, &Dec, &Sign); // double转str，剔除正负号和小数点，显示三位，1235四舍五入为124
cout << str << endl; // 输出结果为124
cout << Dec << endl; // 输出结果为1，小数点左面有一个数
cout << Sign << endl; // 输出结果为1，是负数
}
3. double转换为字符串
fcvt(double _Value, int _FractionalDigitCount, int *_PtDec, int *_PtSign);
改为_fcvt(char *_Buffer, size_t _BufferCount, double _Value, int _FractionalDigitCount, int *_PtDec, int *_PtSign);
说明：转换结果中不包含小数点和正负号
_FractionalDigitCount：取小数位数，若_FractionalDigitCount为1，则取一位小数，要四舍五入
#include <iostream>
using namespace std;
void main()
{
double num = -1.235;
int Dec, Sign; // Dec:小数点位置，Sign:正负号
char str[5]; // ？至少5位
_fcvt_s(str, sizeof(str), num, 2, &Dec, &Sign); // double转str，剔除正负号和小数点，取两位小数，1235四舍五入为124
cout << str << endl; // 输出结果为124
cout << Dec << endl; // 输出结果为1，小数点左面有一个数
cout << Sign << endl; // 输出结果为1，是负数
}
三、字符串型转整型
1.将字符串转为int型
int atoi(const char *_String);
2. 将字符串转为long型
long atol(const char *_String);
3. 将字符串转为long型，并报告不能被转换的所有剩余部分
long strtol(const char *_String, char **_EndPtr, int _Radix);
_Radix：表示进制，范围为2~36和0
_EndPtr：指向字符串中不合法的部分
说明：若_Radix为2，则‘0’、‘1’合法，若_Radix为10，则‘0’、‘1’……‘9’合法，若_Radix为16，则‘0’，‘1’……‘f’合法
#include <iostream>
using namespace std;
void main()
{
long num_2, num_8, num_10, num_16;
char str[20] = "1079aeg";
char *str1;
num_2 = strtol(str, &str1, 2); // 二进制，10合法
cout << num_2 << endl; // 输出2，二进制10在十进制中为2
cout << str1 << endl; // 输出不合法的79aeg
num_8 = strtol(str, &str1, 8); // 8进制，107合法
cout << num_8 << endl; // 输出71,八进制107在十进制中为71
cout << str1 << endl; // 输出不合法的9aeg
num_10 = strtol(str, &str1, 10); // 10进制，1079合法
cout << num_10 << endl; // 输出1079
cout << str1 << endl; // 输出不合法的aef
num_16 = strtol(str, &str1, 16); // 十六进制，1079ae合法
cout << num_16 << endl; // 输出1079726，十六进制1079ae在十进制中为1079726
cout << str1 << endl; // 输出不合法的g
}
------
如若想详细了解该函数，请看strtol()详解
4. 将字符串转为无符号长整型值，并报告不能被转换的所有剩余部分
unsigned long strtoul(const char *_String, char **_EndPtr, int _Radix);
四、字符串型转浮点型
1. 将字符串转换为双精度浮点型值
double atof(const char *_String);
2. 将字符串转换为双精度浮点型值，并报告不能被转换的所有剩余数字
double strtod(const char *_String, char **_EndPtr);
参考资料
C语言itoa()函数和atoi()函数详解(整数转字符C实现) 有关int,float，double型与字符串char*类型的相互转换 Strtol()详解 转在于：https://www.cnblogs.com/onycea/p/5400681.html关于Python整型：布尔型、标准整型、长整型操作实例和整型 python的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于(五)python3 整型int、2014.12.26 整型，字符型，布尔型，浮点型、C++ 无符号整型和整型的区别、C++整型、浮点型与字符串型相互转换的相关知识，请在本站寻找。
本文标签：
![[转帖]Ubuntu 安装 Wine方法（ubuntu如何安装wine）](https://www.gvkun.com/zb_users/cache/thumbs/4c83df0e2303284d68480d1b1378581d-180-120-1.jpg)
