python成长之路,python中的数字
分类:编程应用

Python成长之路第二篇(1)_数据类型内置函数用法,python成长之路

8.python中的数字,8.python数字

  python中的数字包括了整型 int ,长整型 long , 浮点型 float , 复数 complex ,其差别为:

int(整型)

  也称有符号整数,只有正或负整数,不带小数点。
  其和长整型在于整数有一定的位数限制:

    在32位机器上,整数的位数为32位,取值范围为-2**31~2**31-1,即-2147483648~2147483647
    在64位系统上,整数的位数为64位,取值范围为-2**63~2**63-1,即-9223372036854775808~9223372036854775807   一旦超过位数,则会自动转换为长整型(python2.2以后的版本)   long(长整型)   理论上是无限长的,但数据终究是储存在内存中的,所以实际长度限制取决于内存的大小

float(浮点型)   带有小数的数字都被称为浮点型
  complex(复数)   就是数学中的复数,定义和数学中的一样(z=a+bi,这里a和b是实数,i是虚数单位,例如1+5j)  

一.整型

图片 1  python中的数字包括了整型 int ,长整型 long , 浮点型 float , 复数 complex ,下面就来逐一分析。 1.整型 Help on class int in module __builtin__: class int(object) | int(x=0) -> int or long | int(x, base=10) -> int or long | | Convert a number or string to an integer, or return 0 if no arguments | are given. If x is floating point, the conversion truncates towards zero. | If x is outside the integer range, the function returns a long instead. | | If x is not a number or if base is given, then x must be a string or | Unicode object representing an integer literal in the given base. The | literal can be preceded by '+' or '-' and be surrounded by whitespace. | The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to | interpret the base from the string as an integer literal. | >>> int('0b100', base=0) | 4 | | Methods defined here: | | __abs__(...) | x.__abs__() <==> abs(x) | | __add__(...) | x.__add__(y) <==> x+y | | __and__(...) | x.__and__(y) <==> x&y | | __cmp__(...) | x.__cmp__(y) <==> cmp(x,y) | | __coerce__(...) | x.__coerce__(y) <==> coerce(x, y) | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __format__(...) | | __getattribute__(...) | x.__getattribute__('name') <==> x.name | | __getnewargs__(...) | | __hash__(...) | x.__hash__() <==> hash(x) | | __hex__(...) | x.__hex__() <==> hex(x) | | __index__(...)     '''用于切片,但不接受参数,返回的是整个数字,所以切片对数字而言没有意义''' | x[y:z] <==> x[y.__index__():z.__index__()]   | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(y) <==> x*y | | __neg__(...) | x.__neg__() <==> -x | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __oct__(...) | x.__oct__() <==> oct(x) | | __or__(...) | x.__or__(y) <==> x|y | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rand__(...) | x.__rand__(y) <==> y&x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __repr__(...) | x.__repr__() <==> repr(x) | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __rmul__(...) | x.__rmul__(y) <==> y*x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __str__(...) | x.__str__() <==> str(x) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __trunc__(...) | Truncating an Integral returns itself. | | __xor__(...) | x.__xor__(y) <==> x^y | | bit_length(...) | int.bit_length() -> int | '''返回改数字用二进制要几位来表示''' | Number of bits necessary to represent self in binary. | >>> bin(37)  #得出其二进制表示形式 | '0b100101'  #0b是二进制的标识,用来说明其是二进制形式,其后的100101才是真正的二进制代码 | >>> (37).bit_length() | 6  #37的二进制表示是 100101,一共6位,所以返回6 | | conjugate(...) | Returns self, the complex conjugate of any int. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | denominator | the denominator of a rational number in lowest terms | | imag | the imaginary part of a complex number | | numerator | the numerator of a rational number in lowest terms | | real | the real part of a complex number | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T int

 

可以看出其内置方法分为3种:

  1.普通方法(已经在代码中注释说明)

  2.相当于某些内置函数的方法(内置函数将以后另起一篇介绍)

  3.与运算符相关的方法

这里详细介绍一下python的运算符:

1.算数运算符

  以下假设变量a=10,变量b=20

图片 2

 

2.比较运算符

  以下假设变量a=10,变量b=20

图片 3

 

3.赋值运算符

  以下假设变量a=10,变量b=20

图片 4

4.位运算符

  按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下:

  下表中变量 a = 60,b = 13

图片 5

5.逻辑运算符

  以下假设变量 a = 10, b=20

图片 6

 

6.成员运算符

  除了以上的一些运算符之外,Python还支持成员运算符,测试实例中包含了一系列的成员,包括字符串,列表或元组。

图片 7

 

7.身份运算符

  身份运算符用于比较两个对象的存储单元

 图片 8

  这里要讲讲python中的内存池(缓冲池)了,python使用内存池来管理小的整型数和小的字符串等等。
  什么意思呢?

  当我们执行以下赋值运算时

a = 123
b = 123

 

  理论上是要分别在内存中创建两个值,然后赋值给变量的,但是这样做实在是有点浪费,明明是一样的数,却要占用两个内存空间。

  所以python为了节约内存,引入了内存池,当小的整型(-5~257,不包括257)要多次创建时,只创建一次,后面的都将引用指向同一个地方,此时使用身份运算符会出现:

图片 9

  字符串的则以256个ascll码为分界

  有兴趣的可以参考:戳这里

 

8.运算符的优先级

图片 10

  另外,我们也可以像数学一样使用括号() ,来指定某个运算先进行

  更多参考:戳这里

  有别人做好的轮子就是不一样,一路复制粘贴就好了,真轻松。


 

二、长整型

  和整型基本一样,这里就不重复了。自己可以用 help() 函数查看。
  遇事不决喊救命

 


 

三、浮点型

   这里就不全部列举了,只讲讲不同的。

 |  __setformat__(...)
 |      float.__setformat__(typestr, fmt) -> None
 |      
 |      You probably don't want to use this function.  It exists mainly to be
 |      used in Python's test suite.
 |      
 |      typestr must be 'double' or 'float'.  fmt must be one of 'unknown',
 |      'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be
 |      one of the latter two if it appears to match the underlying C reality.
 |      
 |      Override the automatic determination of C-level floating point type.
 |      This affects how floats are converted to and from binary strings.

 

  一个内部方法,用于内部测试的,官方都说了You probably don't want to use this function(你可能不想使用这个函数),而实际上我们也用不到,我也不知道有什么用,一般可以无视。

 

 |  __trunc__(...)
 |      Return the Integral closest to x between 0 and x.

  返回最接近x从0积分和x,貌似和积分运算有关,没用过

 

 

 |  as_integer_ratio(...)
 |      float.as_integer_ratio() -> (int, int)
 |      
 |      Return a pair of integers, whose ratio is exactly equal to the original
 |      float and with a positive denominator.
 |      Raise OverflowError on infinities and a ValueError on NaNs.
 |      
 |      >>> (10.0).as_integer_ratio()
 |      (10, 1)
 |      >>> (0.0).as_integer_ratio()
 |      (0, 1)
 |      >>> (-.25).as_integer_ratio()
 |      (-1, 4)

  返回一个由两个数字组成的元祖,而两个数字相除就等于原浮点数,其实就是返回一个最简分数,分子在前面,分母在后面。

 

 

 |  conjugate(...)
 |      Return self, the complex conjugate of any float.

  返回本身的共轭复数

 

 |  fromhex(...)
 |      float.fromhex(string) -> float
 |      
 |      Create a floating-point number from a hexadecimal string.
 |      >>> float.fromhex('0x1.ffffp10')
 |      2047.984375
 |      >>> float.fromhex('-0x1p-1074')
 |      -4.9406564584124654e-324

  用一个十六进制的字符串来创建一个浮点数

 

 

 |  hex(...)
 |      float.hex() -> string
 |      
 |      Return a hexadecimal representation of a floating-point number.
 |      >>> (-0.1).hex()
 |      '-0x1.999999999999ap-4'
 |      >>> 3.14159.hex()
 |      '0x1.921f9f01b866ep+1'

  上面方法的逆运算,返回一个浮点数的十六进制表示的字符串

 

 

 |  is_integer(...)
 |      Return True if the float is an integer.

  判断一个浮点数是否为整数

图片 11

  其实就是看小数位是否都为0

 


 

四、复数

  都是一些运算和内置函数相关的,唯一特别的是

 |  conjugate(...)
 |      complex.conjugate() -> complex
 |      
 |      Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.

   返回一个原复数的共轭复数

 

python中的数字包括了整型 int ,长整型 long , 浮点型 float , 复数 complex ,其差别为: int(整型) 也称有符号整...

数据类型内置函数用法int

关于内置方法是非常的多这里呢做了一下总结

(1)__abs__(...)返回x的绝对值
#返回x的绝对值!!!都是双下划线
x.__abs__() <==> abs(x)
例如:
#!/usr/bin/python
print "abs(-45) : ", abs(-45)
print "abs(100.12) : ", abs(100.12)
print "abs(119L) : ", abs(119L)
这将产生以下结果:
abs(-45) : 45
abs(100.12) : 100.12
abs(119L) : 119
(2)__add__(...) 加法

a = 12

b = 1

s = a+b

print s

13

x.__add__(y) <==> x+y

(3)__and__(...)&操作符

x.__and__(y) <==> x&y #按位与;&操作符

比如:1010 0011

&        0000 1111


  0000 0011

也就是与上0相当于把那位数清0,与上1相当于把那位保留

(4)__cmp__(self, obj) 对象比较;内建 cmp()

x.__cmp__(y) <==> cmp(x,y)

Python的cmp函数可以比较同类型之间,或者不同数据类型之间。然后根据Python的cmp比较函数的返回值来判定比较大小。

(5)__coerce__(...)压缩成同样的数值类型内建强制生成元祖

x.__coerce__(y) <==> coerce(x, y)

(6)def bit_length(self)用二进制表示数字最少占了多少位
(7)def_divmod_(self,y)相除,得到商和余数组成的元组

x.__divmod__(y) <==> divmod(x, y)

用于分页

(8)_div_除法取商

x.__div__(y) <==> x/y

(9)_float_(转换成浮点型)

x.__float__() <==> float(x)

(10)__floordiv__ //操作符

x.__floordiv__(y) <==> x//y

(11)format #格式化显示

x._format_(“”)

(12)_getattribute__定义可以用.xxx调用函数

x.__getattribute__('name') <==> x.name

获取属性;内建 getattr();总是被调用

(13)__getnewargs__(...)

当读取对象的某个属性时,python会自动调用__getattr__()方法.例如,fruit.color将转换为fruit.__getattr__(color).当使用赋值语句对属性进行设置时,python会自动调用__setattr__()方法.__getattribute__()的功能与__getattr__()类似,用于获取属性的值.但是__getattribute__()能提供更好的控制,代码更健壮.注意,python中并不存在__setattribute__()方法.

 

(14)_hash_ (哈希)函数值

x.__hash__() <==> hash(x)

(15)__hex__()十六进制表示

x.__hex__() <==> hex(x)

(16)__index__用于切片索引功能

 

(17)_int_用于将数字或字符串转换成整数

x.__int__() <==> int(x)

将一个字符串或数字转换成一个整数,如果可能的话。一个浮点参数将被截断为零(这不包括一个字符串表示的浮点数!)转换为一个字符串,使用可选的基础。这是一个错误当转换提供一个基础non-string。如果基础是零,猜测基于适当的基地字符串内容。如果参数是在整数范围内长对象将被返回。

(18)__init__是在类实例创建的时候自动会被执行的
(19)_invert_()按位求反;~操作符

x.__invert__() <==> ~x

(20)__long__()转换成长整形

x.__long__() <==> long(x)

(21)__lshift__往左移动左移位;<<操作符

X.__lshift__(y) <==> x<<y

(22)__mod__(...)取模/取余;%操作符

x.__mod__(y) <==> x%y

(23)__mul__(...)乘;*操作符

x.__mul__(y) <==> x*y

(24)__neg__(...)负数

x.__neg__() <==> -x

(25)__nonzero__不等于0

x.__nonzero__() <==> x != 0为 object 定义 False 值

(26)__oct__表示八进制

x.__oct__() <==> oct(x)

(27)__or__(...)按位或;|操作符

x.__or__(y) <==> x|y

(28)__pos__(...)一元正

x.__pos__() <==> +x

(29)__pow__(...)乘幂;内建 pow();**操作符

x.__pow__(y[, z]) <==> pow(x, y[, z])

(30)__radd__(...)X+Y→Y+X

x.__radd__(y) <==> y+x

(31)__rand__(...)与操作X&Y→Y&X

x.__rand__(y) <==> y&x

(32)__rdiv__(...)X/Y→Y/X

x.__rdiv__(y) <==> y/x

(34)__rdivmod__除和取模反向

x.__rdivmod__(y) <==> divmod(y, x)

(35)_repr__(...)运行时的字符串输出转换编译器可读

x.__repr__() <==> repr(x)

(36)__str__可打印的字符输出,人识别的

. x.__repr__() <==> repr(x)

(37)__rfloordiv__//操作符X//Y→Y//X

x.__rfloordiv__(y) <==> y//x

(38)其它反向操作
__rlshift__(...)左移位;<<操作符原本x移动到y的左面现在反过来

| x.__rlshift__(y) <==> y<<x

|

| __rmod__(...)取模/取余;%操作符X%Y→Y%X

| x.__rmod__(y) <==> y%x

|

| __rmul__(...)乘;*操作符X*Y→Y*X

| x.__rmul__(y) <==> y*x

|

| __ror__(...)按位或;|操作符X|Y→Y|X

| x.__ror__(y) <==> y|x

|

| __rpow__(...)乘幂;内建 pow();**操作符

| y.__rpow__(x[, z]) <==> pow(x, y[, z])

|

| __rrshift__(...)右移;>>操作符X>>Y →Y>>X

| x.__rrshift__(y) <==> y>>x

|

| __rshift__(...)右移;>>操作符

| x.__rshift__(y) <==> x>>y

|

| __rsub__(...)减;-操作符X-Y→Y-X

| x.__rsub__(y) <==> y-x

|

| __rtruediv__(...)True 除;/操作符X/Y→Y/X

| x.__rtruediv__(y) <==> y/x

|

| __rxor__(...)按位与或;^操作符X^Y→Y^X

| x.__rxor__(y) <==> y^x

|

| __str__(...)可打印的字符输出;内建 str()及 print 语句

| x.__str__() <==> str(x)

|

| __sub__(...)减;-操作符

| x.__sub__(y) <==> x-y

(39)_truediv__ ( True 除;/操作符)

x.__truediv__(y) <==> x/y

(40)__trunc__浮点型数字截取整形

Truncating an Integral returns itself.

(41)__xor__按位与或;^操作符

x.__xor__(y) <==> x^y

(42)denominator分母有理数的最低条件

the denominator of a rational number in lowest terms

(43)imag一个复数的虚部

the imaginary part of a complex number

(44)numerator分子有理数的最低条件

the numerator of a rational number in lowest terms

(45)real一个复数的实部

the real part of a complex number

数据类型内置函数用法 int 关于内置方法是非常的多这里呢做了一下总结...

本文由正版必中一肖图发布于编程应用,转载请注明出处:python成长之路,python中的数字

上一篇:没有了 下一篇:深入解读Python解析XML的几种方式
猜你喜欢
热门排行
精彩图文