python基础——运算符

python基础

运算符

算数运算符

+

• int: 两数相加
• float: 直接相加时需要注意精度问题，例如0.3+0.6=0.8999999999999999
• bool: True为1，False为0，对应的数值相加
• complex: 实部与实部相加，虚部与虚部相加，如果有浮点数注意精度问题
• str:字符串拼接
• list: 集合拼接
• tuple: 元组拼接
• set: 不支持
• dict: 不支持

    print(1 + 1)  # 2
    print(True + True, True + False, False + False)  # 2 1 0
    print(0.3 + 0.6)  # 0.8999999999999999
    print(3.0 + 4.6j + 2.0 + 4.8j)  # (5+9.399999999999999j)
    print(3 + 4j + 2 + 4j)  # (5+8j)
    print('123' + 'bdk')  # 123bdk
    print([1, 2, 4, 6, 9] + ['a', 'b', 'k'])  # [1, 2, 4, 6, 9, 'a', 'b', 'k']
    print((1, 2, 4, 6, 9) + ('a', 'b', 'k'))  # (1, 2, 4, 6, 9, 'a', 'b', 'k')
    print({1, 2, 4, 6, 9} + {'a', 'b', 'k'})  # unsupported operand type(s) for +: 'set' and 'set'
    print({'name': 'jack', 'age': 23} + {'addr': 'beijing'})  # TypeError: unsupported operand type(s) for +: 'dict' and 'dict'

-

• int: 两数相减
• float: 两数相减，需要注意精度问题
• bool: True为1，False为0，对应的数值相减
• complex: 实部与实部相减，虚部与虚部相减，如果有浮点数注意精度问题
• str: 不支持
• list: 不支持
• tuple: 不支持
• set: 不支持
• dict: 不支持

print(1 - 1)  # 0
    print(True - True, True - False, False - False)  # 0 1 0
    print(0.3 - 0.6)  # -0.3
    print(3.0 + 4.6j - (2.0 + 4.8j))  # (1-0.20000000000000018j)
    print(3 + 4j - (2 + 4j))  # (1+0j)
    print('123' - 'bdk')  # TypeError: unsupported operand type(s) for -: 'str' and 'str'
    print([1, 2, 4, 6, 9] - ['a', 'b', 'k'])  # TypeError: unsupported operand type(s) for -: 'list' and 'list'
    print((1, 2, 4, 6, 9) - ('a', 'b', 'k'))  # TypeError: unsupported operand type(s) for -: 'tuple' and 'tuple'
    print({1, 2, 4, 6, 9} - {'a', 'b', 'k'})  # TypeError: unsupported operand type(s) for -: 'set' and 'set'
    print({'name': 'jack', 'age': 23} - {'addr': 'beijing'})  # TypeError: unsupported operand type(s) for -: 'dict' and 'dict'

*

• int: 两数相乘
• float: 两数相乘
• bool: True为1，False为0，对应的数值相乘
• complex: (a+bj)(c+dj)=ac+adj+bjc+bjdj. jj=-1
• str: str*整数n，代表重复n次
• list: list*整数n，代表重复n次
• tuple: tuple*整数n，代表重复n次
• set: 不支持
• dict: 不支持

    print(1 * 1)  # 1
    print(True * True, True * False, False * False)  # 1 0 0
    print(0.3 * 0.6)  # 0.18
    print((3.0 + 4.6j) * (2.0 + 4.8j))  # (-16.08+23.599999999999998j)
    print((3 + 4j) * (2 + 4j))  # (-10+20j)
    print('123' * 3)  # 123123123
    print([1, 2, 4, 6, 9] * 3)  # [1, 2, 4, 6, 9, 1, 2, 4, 6, 9, 1, 2, 4, 6, 9]
    print((1, 2, 4, 6, 9) * 3)  # (1, 2, 4, 6, 9, 1, 2, 4, 6, 9, 1, 2, 4, 6, 9)
    print({1, 2, 4, 6, 9} * 1)  # TypeError: unsupported operand type(s) for *: 'set' and 'int'
    print({'name': 'jack', 'age': 23} * 3)  # TypeError: unsupported operand type(s) for *: 'dict' and 'int'

/

• int: 两数相除，注意结果是浮点型
• float: 两数相除
• bool: True为1，False为0，对应的数值相除，注意结果是浮点型
• complex: 计算公式如下$\frac{a+bj}{c+dj}=\frac{(a+bj)\ast (c-dj)}{(c+dj)\ast (c-dj)}=\frac{a\ast c-a\ast dj+bj\ast c-bj\ast dj}{c^2+d^2}=\frac{ac+bd-adj+bcj}{c^2+d^2}=\frac{ac+bd}{c^2+d^2}+\frac{bc-ad}{c^2+d^2}j$
• str: 不支持
• list: 不支持
• tuple: 不支持
• set: 不支持
• dict: 不支持

    print(1 / 1)  # 1.0
    print(True / True)  # 1.0
    print(0.3 / 0.6)  # 0.5
    print((3.0 + 4.6j) / (2.0 + 4.8j))  # (1.0384615384615385-0.19230769230769235j)
    print((3 + 4j) / (2 + 4j))  # (1.1-0.2j)

//

【也即相当于取商的整数】
$a=b\ast c+d$ d为a除以b的余数，c等于a整除b

• int: 对应数值整除，结果为整数 例如-6 = 4*(-2)+2
• float: 对应数值整除，结果为浮点型
• bool: True为1，False为0，对应的数值相整除，结果为整数
• complex: 不支持
• str: 不支持
• list: 不支持
• tuple: 不支持
• set: 不支持
• dict: 不支持

    print(-6 // 4)  # -2
    print(True // True)  # 1
    print(0.3 // 0.6)  # 0.0
    print((3.0 + 4.6j) // (2.0 + 4.8j))  # TypeError: can't take floor of complex number.
    print((3 + 4j) // (2 + 4j))  # TypeError: can't take floor of complex number.

%

• int: 对应数取余，结果为整型
• float: 对应数取余，结果为浮点型
• bool: True为1，False为0，对应的数值取余，结果为整型
• complex: 不支持
• str: 不支持
• list: 不支持
• tuple: 不支持
• set: 不支持
• dict: 不支持

    print(-6 % 4)  # 2
    print(True % True)  # 0
    print(0.3 % 0.6)  # 0.3

**

• int: a*b求a的b次方，结果为整数
• float: a*b求a的b次方，结果为浮点数
• bool: True为1，False为0，结果为1
• complex: (a+bj)^i=(a+bj)*(a+bj)……(a+bj)
• str: 不支持
• list: 不支持
• tuple: 不支持
• set: 不支持
• dict: 不支持

    print((-6)** 4)  # 1296
    print(True ** 4)  # 1
    print(0.3 ** 3)  # 0.026999999999999996
    print((3.0 + 4.6j) ** (2.0 + 4.8j)) # (-0.190233089287701-0.17253498057883887j)
    print((3 + 4j) ** 2)  # (-7+24j)

()

优先级:()高于**高于* / // % 高于+ -【注意这里是减号不是负号】

赋值运算符

= 将右侧结果赋值给左侧变量

• 单变量赋值：
  变量 = 值
• 多变量赋值：
  变量1，变量2…变量n = 值1，值2…值n
• 多变量赋相同值：
  变量1，变量2…变量n = 值

变量的赋值并不是变量名直接指向值。变量中存储的是数据内存地址的引用，python解释器会根据变量中存储的地址找到真实的数据。

复合赋值运算符

相当于算数运算符与赋值运算符的结合。先做运算后重新赋值
+=、-=、*=、/=、//=、%=、**=

比较运算符

== !=比较的是值而不是引用地址,数据类型都支持

    print(1 == 1)  # True
    print(1.0 == 1.0)  # True
    print(True == True)  # True
    print((3 + 4j) == (3 + 4j))  # True
    print([1, 2, 5, 8] == [1, 2, 5, 8])  # True
    print((1, 2, 5, 8) == (1, 2, 5, 8))  # True
    print({1, 2, 5, 8} == {1, 2, 5, 8})  # True
    print({'name':'zhangsan','age':20} == {'name':'zhangsan','age':20})  # True
    print('————————————————')
    print(1 != 1)  # False
    print(1.0 != 1.0)  # False
    print(True != True)  # False
    print((3 + 4j) != (3 + 4j))  # False
    print([1, 2, 5, 8] != [1, 2, 5, 8])  # False
    print((1, 2, 5, 8) != (1, 2, 5, 8))  # False
    print({1, 2, 5, 8} != {1, 2, 5, 8})  # False
    print({'name':'zhangsan','age':20} != {'name':'zhangsan','age':20})  # False

>、<、>=、<=在对列表、集合、元组进行比较运算时，从第一位开始比较，如果相等比较第二位，以此类推，比较到第n位都想等的话就是长的那个大

逻辑运算符

and也称与，同True则True，否则为False、or也称或同False为False，其他为，True、not