跳转至

表达式

常量

# math库包含了两个数学常量
import math

math.pi  # 3.141592653589793
math.e  # 2.718281828459045

变量

命名规则,大多数编程语言变量命名都只能由英文、下划线(_)、数字(不能作为开头)构成,且不能是系统保留关键字

  • 下划线命名法:用于变量名、函数名、模块名等
  • 驼峰命名法:主要用于类名

大小写敏感,只有少数编程语言大小写敏感,比如C,其它绝大多数都是不敏感的。但是建议始终保持大小写一致,养成良好的编程习惯。

  • 全大写:一般全大写表示这个变量约等于常量

赋值

在Python中,将一个对象赋值给一个变量,并不表示拷贝对象给变量,而是让一个变量指向了一个对象,而一个对象,可以被多个变量所指向。

另外变量可以被删除,但是对象无法被删除,只能被垃圾回收。

动态语言,在运行时才会检查,所以无需声明数据类型,同一变量可以反复赋值不同类型的数据。

x = 1  # 不需要关键字定义
x = None  # 初始值可以赋值为:None

x = y = z = 1  # 同时给多个变量赋相同值
x,y,z = 1,2,3  # 同时给多个变量赋不同值,要一一对应,否则会报错,比如:x,y,z=1 或 x,y=1,2,3 都是不对的

x,y = y,x  # 值交换
// 需要关键字定义
// 未赋值时初始值为:undefined
var x = 1;

静态语言,会在编译时检查数据类型,所以需要提前声明,同一变量只能反复赋值同类型的数据。

// Java
// 未赋值时初始值为:0
int x = 1;

运算符

比较运算符,返回bool值

  • ==
  • !=
  • >
  • >=
  • <
  • <=

判断两个对象的值是否相等

如果需要判断一个单例对象的值,比如是否为None,建议优先使用身份运算符,性能更优

身份运算符,返回bool值

  • is
  • is not

判断两个对象的内存地址(id(x))是否相等

注意:每次创建-5到256的整数对象,其实都只是引用,即id不变,因为出于对性能的考虑,Python内部对这些常用数字做了缓存处理

a = 123
b = 123
a is b  # True
id(a) == id(b)  # False

None is None  # True

成员运算符,返回bool值

  • in
  • not in

判断两个Iterabled对象的包含关系(dict用key值判断)

布尔运算符

  • and
  • or
  • not

not 返回的是bool值,not的优先级比非布尔运算符都要低。

# 常用于if判断语句
not 0  # Ture
not 1  # False

and和or,返回的不是bool值,而是其中的一个变量,从左到右运算,如果如果通过前一个变量就能判断出结果在,则直接返回前一个变量,否则返回后一个变量。即:

如果前一个变量是真

# and,需要知道后一个变量才能知道结果,所以返回后一个
1 and 2  # 2
1 and 0  # 0

# 真 or 一切,都是真,所以直接返回前一个
1 or 2  # 1
1 or 0  # 1

如果前一个变量是假

# 假 and 一切,都是假,所以直接返回前一个
0 and 1  # 0
0 and ""  # 0

# or,需要知道后一个变量才能知道结果,所以返回后一个
0 or 1  # 1
0 or ""  # ""

赋值运算符

x = 2

# 同时给多个变量赋值
x,y,z = 2,3,4
x,y,z = (2,3,4)
x,y,z = [2,3,4]

# x做完算数运算后,再赋值给 x
# 可以合起来写成
x += 2
x -= 2
x *= 2
# 类似其他语言中的自增i++和自减i--等

算术运算符

  • +
1 + 2  # 3

'a' + 'b'  # 'ab'

(1,2) + (3,4)  # (1,2,3,4)
[1,2] + [3,4]  # [1,2,3,4]
  • -
2 - 1  # 1
  • *
1 * 2  # 2

'~' * 2  # '~~'

(1) * 2 = (1,1)
[1] * 2 = [1,1]
# 次方
2**3  # 8
  • /
# 整型相除得到的是浮点型
1/1  # 1.0
10/3  # 3.3333333333333335
# 相除只取整数
10 // 3  # 3
# 相除只取余数
10 % 3  # 1
  • 分组 ()

除了分组,还可以用来代码换行,括号里的都算一行,比用反斜杠\更易读。


算数运算底层会转换为二进制做计算,而浮点数不能完美的转换为二进制,所以浮点数运算会存在精度问题,比如

8.88 - 7.77  # 1.1100000000000012

如果有高精度要求,可以如下,不过性能会有一些损失。

from decimal import Decimal

Decimal("8.88") - Decimal("7.77")  # Decimal('1.11')

更高级的运算可以用mathcmath函数。

位运算符

  • 按位与 &
# 转换为二进制后按位与
1 & 2  # 0
  • 按位或 |
# 转换为二进制后按位与
1 | 2  # 3

关于集合的运算

a = {1,2,3,4}
b = {3,4,5}

# 子集
a < b  # False
a.issubset(b)

# 并集,合并并去重
a | b  # {1,2,3,4,5}
a.union(b)


# 交集,共有元素
a & b  # {3,4}
a.intersection(b)


# 对称集,非共有元素
a ^ b  # # {1,2,5}
a.symmetric_difference(b)


# a相对于b的差集
a - b  # {1,2}
a.difference(b)

# b相对于a的差集
b - a  # {5}
b.difference(a)

属性

  • 获取变量内存地址,id(x)
  • 获取变量所占内存大小,sys.getsizeof(x)(需要先import sys

是否相等

a is b

a == b

hash(a) == hash(b)

id(a) == id(b)


最后更新: 2021-06-26