Python 基本运算符、可变与不可变类型

已注销
56 阅读5分钟

一、基本运算符

  1. 算数运算符

    print(10 + 3.1)  # 13.1
print(10 + 3)  # 13
print(10 / 3)  # 结果带小数 3.3333333333333335
print(10 // 3)  # 只保留整数部分 3
print(10 % 3) # 取模、取余数 1
print(10 ** 3) # 次方 10的3次方 1000

  2. 赋值运算符

    =：变量的赋值
    age = 18
    增量赋值
    age = 18
# age += 1  # age=age + 1
# print(age)

age *= 3  # age=age * 3
age /= 3  # age=age / 1
age %= 3  # age=age % 1
age **= 3 # age=age ** 3
    链式赋值
    # x=10
# y=x
# z=y
z = y = x = 10 # 链式赋值
print(x, y, z) # 10 10 10
print(id(x), id(y), id(z))
# 140708543928256 140708543928256 140708543928256
    交叉赋值/交换两个值
    m=10
n=20
print(m,n)  # 10 20
#交换值
temp=m
m=n
n=temp
print(m,n)  # 20 10

    m=10
n=20
print(m,n)  # 10 20

m,n=n,m  # 交叉赋值

print(m,n)  # 20 10
    解压赋值
    messages = [111, 222, 333, 444, 555]
#把列表里的元素取出来分别赋值给不同的变量名
mes0 = messages[0]
mes1 = messages[1]
mes2 = messages[2]
mes3 = messages[3]
mes4 = messages[4]

    #解压赋值
mes0,mes1,mes2,mes3,mes4 = messages
# 对应的变量名数量不能多也不能少
print(mes0)  # 111
print(mes1)  # 222
print(mes2)  # 333
print(mes3)  # 444
print(mes4)  # 555

    # 引入*，可以帮助我们取两头的值，无法取中间的值

# 取前三个值
x, y, z, *_ = messages = [111, 222, 333, 444, 555]
# *会将没有对应关系的值存成列表然后赋值给紧跟其后的那个变量名，此处为_
print(x,y,z)  # 111 222 333
print(_)  # [444, 555]

# 取后三个值
*_, x, y, z = messages = [111, 222, 333, 444, 555]
print(x,y,z)  # 333 444 555

# 取第一个值和最后两个值
x, *_, y, z = messages = [111, 222, 333, 444, 555]
print(x, y, z)  # 111 444 555

    #无赖大法,不建议用
_, *x, _, _ = messages = [111, 222, 333, 444, 555]
print(x)  # [222, 333]
print(x[1])  # 333

    #解压字典默认解压出来的是字典的key
x, y, z = dic = {'a': 1, 'b': 2, 'c': 3}
print(x, y, z)  # a b c

  3. 比较运算符

    >、>=、<、<=、==、!= 
print(10 > 3)  # True
print(10 == 10)  # True

print(10 >= 10)  # True
print(10 >= 3)  # True

name=input('your name: ')
print(name == 'Python')

  4. 逻辑运算符

    not、and、or
    not：就是把紧跟其后的那个条件结果取反。（not与紧跟其后的那个条件是一个不可分割的整体）
    print(not 16 > 13)  # False
print(not True)  # False
print(not False)  # True
print(not 10)  # False
print(not 0)  # True
print(not None)  # True
print(not '')  # True
    and：逻辑与，and用来链接左右两个条件，两个条件同时为True，最终结果才为真。全真则真，一假为假。
    or：逻辑或，or用来连接左右两个条件，两个条件但凡有一个为True，最终结果就为True，两个条件都为False的情况下，最终结果才为False。一真则真，全假为假。
    区分优先级：not > and > or

    如果单独就只是一串and链接，或者说单独就只是一串or链接，按照从左到右的顺讯依次运算即可，如果是混用，则需要考虑优先级了。

    res = 3 > 4 and not 4 > 3 or 1 == 3 and 'x' == 'x' or 3 > 3
print(res)  # False
# 根据优先级整理
res = (3 > 4 and (not 4 > 3)) or (1 == 3 and 'x' == 'x') or 3 > 3
print(res)  # False

    短路运算

    Python把0、空字符串”和None看成 False，其他数值和非空字符串都看成 True，所以：

    1. 在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。

    2. 在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。 所以Python解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。

    x = 1 and 2
print(x) # 2

y = 1 or 2
print(y) # 1

z = 1 and [1, 2, 3]
print(z) # [1, 2, 3]

  5. 成员运算符

    in
    # 判断一个字符串是否存在于一个大字符串中
print("python" in "hello python")  # True
print("e" in "hello")  # True

# 判断元素是否存在于列表
print(111 in [111, 222, 33])  # True

# 判断key是否存在于字典
print(111 in {"k1": 111, 'k2': 222})  # False
print("k1" in {"k1": 111, 'k2': 222})  # True

# not in
print("python" not in "hello python")  # False 
# 推荐使用
print(not "python" in "hello python")  # False
# 逻辑同上，但语义不明确，不推荐

  6. 身份运算符

    is：判断的是id是否相等

二、可变与不可变类型

可变类型：值改变，id不变，证明改的是原值，证明原值是可以被改变的。
不可变类型：值改变，id也变了，证明是产生新的值，压根没有改变原值，证明原值是不可以被修改的。
#int是不可变类型

x = 10
print(id(x))
x = 11  # 产生新值
print(id(x))
# id发生了改变

#float是不可变类型

x = 3.1
print(id(x))
x = 3.2
print(id(x))
# id发生了改变

#str是不可变类型

x = "abc"
print(id(x))
x = 'gggg'
print(id(x))
# id发生了改变

小结：int、float、str都被设计成了 不可分割 的整体，不能够被改变。

#list是可变类型

l = ['aaa', 'bbb', 'ccc']
print(id(l))
l[0] = 'AAA'
print(l)
print(id(l))
# id没有发生改变

#dict是可变类型

dic = {'k1': 111, 'k2': 222}
print(id(dic))
dic['k1'] = 3333333333
# print(dic)
print(id(dic))
# id没有发生改变

# bool不可变
关于字典的补充：

定义：{ }内用逗号分隔开多 key: value ，其中value可以是任意类型，但是key必须是不可变类型。

avatar
文章
阅读
粉丝