第二讲|Python数字类型和运算符

版权声明：转载请注明出处 https://blog.csdn.net/Booboochen/article/details/80637448

数字类型

Python 提供了三种数字类型，即 int（整型），float（浮点型），complex（复数）。

    1. int：整型，如5、10、100、1000都属于整型；
    2. float：（表示实数）浮点数包含整数和小数部分，如6.0，6.09，10.003等；
    3. complex：复数包含实数部分和虚数部分，形如 a+bj，其实部和虚部都是浮点类型。

    需要注意的是，Python3 已经废弃了 Python2 的 Long（长整型），在 Python3 中，int的大小没有限制，可以作为 Long 使用。数字类型转换Python 的三种数字类型可以进行相互转换，转换方式为：数字类型+圆括号：int（b），

如下实例：

     a = 123
    b = 3.14
    print("int(b)=",int(b))
    print("float(a)=",float(a))
    print("complex(a)=",complex(a))
    print("complex(a,b)=",complex(a,b))

执行结果：

     int(b)= 3    #实数转整数直接把小数点后面的小数部分去掉就可以了
    float(a)= 123.0
    complex(a)= (123+0j)
    complex(a,b)= (123+3.14j)

运算符

计算机的三大用途之一就是执行运算，作为一门计算机语言，Python 也提供了一套丰富的运算符来满足各种运算需求。
Python 运算符大致可分为 7种，即：

     算术运算符、比较运算符、赋值运算符、逻辑运算符、位运算符、成员运算符以及身份运算符。

   // 算术运算符。对算术运算，大家并不陌生，常用的加减乘除就是算术运算。

     加（+）、减（-）、乘（*）、除（/）、取模（%）、幂运算（**）和取整预算（//）。

如下实例：

     X = 28
    Y = 6
    Z = 0
    #分别进行7种算术运算
    Z = X + Y
    print("X + Y =", Z)
    Z = X - Y
    print("X - Y =", Z)
    Z = X * Y
    print("X * Y =", Z)
    Z = X / Y
    print("X / Y =", Z)
    Z = X % Y
    print("X % Y =", Z)
    Z = X ** Y
    print("X ** Y =", Z)
    Z = X // Y
    print("X // Y =", Z)

执行结果：

     X + Y = 34
    X - Y = 22
    X * Y = 168
    X / Y = 4.666666666666667    #直接保留实数的运算结果了，虽然x和y都是整型，可以说Python已经很人性化了
    X % Y = 4
    X ** Y = 481890304
    X // Y = 4

比较运算符

//比较无处不在，大于、小于、等于、不等于……和 C/C++、Java 等编程语言一样。
Python 也提供了 6种比较运算符：

    >（大于），<（小于），==（等于），！=（不等于)，>=（大于等于），<=（小于等于）。比较运算的结果是一个布尔值， True 或者False

如下实例：

    X = 28
    Y = 6
    #分别进行7种比较运算
    print("X == Y:", X == Y)
    print("X != Y:", X != Y)
    print("X > Y:", X > Y)
    print("X < Y:", X < Y)
    print("X >= Y:", X >= Y)
    print("X <= Y:", X <= Y)

执行结果：
     X == Y: False
    X != Y: True
    X > Y: True
    X < Y: False
    X >= Y: True
    X <= Y: False

赋值运算

//在前文的实例中已经用到赋值运算，如 X = 28，就是一个最简单的赋值运算，“=”就是最简单的赋值运算符。将简单的赋值运算与算术运算结合.

Python 提供了 7种赋值运算符： +=、-=、*=、/=、%=、**=、//=。

实例如下：

    X = 5
    Y = 10
    #分别进行7种赋值运算
    Y = X
    print("Y = X, Y =", Y)
    Y += X
    print("Y += X, Y =", Y)
    Y -= X
    print("Y -= X, Y =", Y)
    Y *= X
    print("Y *= X, Y =", Y)
    Y /= X
    print("Y /= X, Y =", Y)
    Y **= X
    print("Y **= X, Y =", Y)
    Y //= X
    print("Y //= X, Y =", Y)

执行结果：
     Y = X, Y = 5
    Y += X, Y = 10
    Y -= X, Y = 5
    Y *= X, Y = 25
    Y /= X, Y = 5.0
    Y **= X, Y = 3125.0
    Y //= X, Y = 625.0

逻辑运算

//所谓逻辑运算，就是：与、或、非。

Python 中 3种逻辑运算符分别为： and（与），or（或），not（非），逻辑运算的结果是布尔值：True 或者 False。
    1. A and B：当 A 为 False 时，运算结果为 False；否则返回 B 的值；
    2. A or B：当 A 为 True 时，运算结果为 A 的值，否则返回 B 的值；
    3. not A：当 A 为 True 时，返回 False，否则返回 True。
如下实例：

     X = 4
    Y = 7
    Z = 3
    #分别执行3种逻辑运算
    print("X>Y and X<Z :", X>Y and X<Z)
    print("X<Y and Z :", X<Y and Z)
    print("X>Y or Z :", X>Y or X<Z)
    print("X<Y or Z :", X<Y or Z)
    print("X or X<Z :", X or X<Z)
    print("not X :", not X)
    print("not X<Y :", not X<Y)

执行结果：
     X>Y and X<Z : False
    X<Y and Z : 3
    X>Y or Z : False
    X<Y or Z : True
    X or X<Z : 4
    not X : False
    not X<Y : False

位运算

//程序中的所有数在计算机内存中都是以二进制的形式储存的。位运算就是直接对整数在内存中的二进制位进行操作。

Python 中有 6种位运算符：
    1. &：按位与运算符，参与运算的两个值，如果两个相应位都为1，则该位的结果为1，否则为0；
    2. |：按位或运算符，只要对应的二个二进位有一个为1时，结果位就为1；
    3. ^：按位异或运算符，当两对应的二进位相异时，结果为1；
    4. ~：按位取反运算符，对数据的每个二进制位取反，即把1变为0，把0变为1；
    5.  >> ：右移动运算符，把  >> 左边的运算数的各二进位全部右移若干位， >> 右边的数指定移动的位数；
    6.  << ：左移动运算符，运算数的各二进位全部左移若干位，由  << 右边的数指定移动的位数，高位丢弃，低位补0。
如下实例：

     a = 0001 0101    # a=21   十进制
    b = 0000 0110    # b=6    十进制
    a&b = 0000 0100
    a|b = 0001 0111
    a^b = 0001 0011
    ~a = 1110 1010
    a<<2 = 01010100
    a>>2 = 0000 0101

成员运算

//除了上文介绍的5种运算符，Python 还支持成员运算符。介绍成员运算符之前，我们需要提前了解一个概念：

    如： 数据结构 ，如字符串、列表、元组、字典。在接下来的章节中我们将详细介绍这些基础的数据结构。字符串、列表、字典，它们就像一个集合，其中包含若干元素，这些元素就是集合的成员；对于一个给定的元素，它有可能在一个给定的集合中，也可能不在，Python 中采用成员运算符来判断元素是否属于成员，成员运算的结果为布尔值，True 或者 False。
如下实例：

     temp1 = "ABCDEFGKLMN"
    temp2 = [2,3,4,5,8,9]
    a = "CDE"
    b = 10
    c = "CDF"
    print("a in temp1?", a in temp1)
    print("b in temp2?", b in temp2)
    print("c in temp1?", c in temp1)

执行结果：
     a in temp1? True
    b in temp2? False
    c in temp1? False

身份运算符

//身份运算符用于比较两个标识符所引用对象的存储单元，计算结果为布尔值，包含两个运算符：is 和 is not，分别用于判断两个标识符是否引用自一个对象。

is	如果运算符任一侧的变量指向相同的对象，则返回True，否则返回False。
is not	如果运算符任一侧的变量指向相同的对象，则返回True，否则返回False。

如下实例：

a = 20

b = 20
print ('Line 1','a=',a,':',id(a), 'b=',b,':',id(b))

if ( a is b ):
   print ("Line 2 - a and b have same identity")
else:
   print ("Line 2 - a and b do not have same identity")

if ( id(a) == id(b) ):
   print ("Line 3 - a and b have same identity")
else:
   print ("Line 3 - a and b do not have same identity")

b = 30
print ('Line 4','a=',a,':',id(a), 'b=',b,':',id(b))

if ( a is not b ):
   print ("Line 5 - a and b do not have same identity")
else:
   print ("Line 5 - a and b have same identity")

执行结果：

    Line 1 a= 20 : 1574137920 b= 20 : 1574137920
    Line 2 - a and b have same identity
    Line 3 - a and b have same identity
    Line 4 a= 20 : 1574137920 b= 30 : 1574138240
    Line 5 - a and b do not have same identity

常用的数学函数

//Python 提供了丰富的数学函数以降低编程实现的难度，本节将介绍一些常用的函数。

如下实例：

import math

#求绝对值:abs(x)

print("abs(-12)=",abs(-12))

#向上取整:ceil(x)
print("ceil(3.1415)=",math.ceil(3.1415))
#向下取整:floor(x)
print("floor(3.678)=",math.floor(3.678))
#四舍五入:round(x)
print("round(3.678)=",round(3.678))
#乘方运算:pow(x,y),x的y次方
print("pow(3,4)=",pow(3,4))
#求平方根:sqrt(x)
print("sqrt(144)=",math.sqrt(144))

执行结果：
    abs(-12)= 12
    ceil(3.1415)= 4
    floor(3.678)= 3
    round(3.678)= 4
    pow(3,4)= 81
    sqrt(144)= 12.0

好了，睡觉了，感谢看到这里，duduuduud

//顺便附上我的 GitHub：https:// github.com/Booboochen，点进去了，别忘了star奥