python变量、运算符、数据类型

python变量、运算符、数据类型
python 学习笔记
目录
- python 学习笔记
  变量、运算符与数据类型
  变量
  运算符
  数据类型
  位运算
  流程控制
  条件语句
  循环语句
  推导式
  异常处理
  容器序列类型
变量、运算符与数据类型

变量
- 在使用变量前，需要现对其赋值
- 变量名可以包括字母、数字、下划线，但不能以字母开头
- python 变量名大小写是敏感的
```
first = 2
second = 3
third = first + second
print(third)  # 5
```
运算符
- 算数运算符
  
  加（+）、减（-）、乘（*）、除（/）、整除（//）、取余（%）、幂（**）
```
print(1 + 1)  # 2
print(2 - 1)  # 1
print(3 * 4)  # 12
print(3 / 4)  # 0.75
print(3 // 4)  # 0
print(3 % 4)  # 3
print(2 ** 3)  # 8
```
- 比较运算符
  
  大于（>）、大于等于（>=）、小于（<）、小于等于（<=）、等于（==）、不等于（!=）
```
print(2 > 1)  # True
print(2 >= 4)  # False
print(1 < 2)  # True
print(5 <= 2)  # False
print(3 == 4)  # False
print(3 != 5)  # True
```
- 逻辑运算符
  
  与（and）、或（or）、非（not）
```
print((3 > 2) and (3 < 5))  # True
print((1 > 3) or (9 < 2))  # False
print(not (2 > 1))  # False
```
- 位运算符
  
  按位取反（~）、按位与（&）、按位或（|）、按位异或（^）、左移（<<）、右移（>>）
```
print(bin(4))  # 0b100
print(bin(5))  # 0b101
print(bin(~4), ~4)  # -0b101 -5
print(bin(4 & 5), 4 & 5)  # 0b100 4
print(bin(4 | 5), 4 | 5)  # 0b101 5
print(bin(4 ^ 5), 4 ^ 5)  # 0b1 1
print(bin(4 << 2), 4 << 2)  # 0b10000 16
print(bin(4 >> 2), 4 >> 2)  # 0b1 1
```
- 三元运算符
```
x, y = 4, 5
small = x if x < y else y
print(small)  # 4
```
- 其他运算符
  
  存在（in）、不存在（not in）
```
letters = ['A', 'B', 'C']
if 'A' in letters:
    print('A' + ' exists')
if 'h' not in letters:
    print('h' + ' not exists')

# A exists
# h not exists
```
  是（is）、不是（not is）
```
# 比较的两个变量均指向可变类型
a = ["hello"]
b = ["hello"]
print(a is b, a == b)  # False True
print(a is not b, a != b)  # True False
'''
- is, is not 对比的是两个变量的内存地址
- ==, != 对比的是两个变量的值
- 比较的两个变量，指向的都是地址不可变的类型（str等），那么is，is not 和 ==，！= 是完全等价的。
- 对比的两个变量，指向的是地址可变的类型（list，dict，tuple等），则两者是有区别的。
'''
```
数据类型

int整型 <class 'int'>
float浮点型<class 'float'>
bool布尔型<class 'bool'>
1. 整型
```
a = 1031
print(a, type(a))
# 1031 <class 'int'>
```
2. 浮点型
```
print(1, type(1))
# 1 <class 'int'>

print(1., type(1.))
# 1.0 <class 'float'>

a = 0.00000023
b = 2.3e-7
print(a)  # 2.3e-07
print(b)  # 2.3e-07

# 有时候我们想保留浮点型的小数点后 n 位。可以用 decimal 包里的 Decimal 对象和 getcontext() 方法来实现。
decimal.getcontext().prec = 4
c = Decimal(1) / Decimal(3)
print(c)
# 0.3333
```
3. 布尔型
```
# 在布尔（boolean）型变量中只有True和False两个值，在数字运算中分别用1和0表示
print(True + True)  # 2
print(True + False)  # 1
print(True * False)  # 0


# 除了对变量赋值True和False，还可以用bool(X)，X可以是基本类型（int、float、bool）和容器类型（字符串、列表、元组、字典和集合），如果X是空的（数值——0，容器——没有元素），返回也是false
print(type(0), bool(0), bool(1))
# <class 'int'> False True

print(type(10.31), bool(0.00), bool(10.31))
# <class 'float'> False True

print(type(True), bool(False), bool(True))
# <class 'bool'> False True
```
在python中万物皆对象（object），基本数据类型也不例外，只要是对象就有相应的属性（attributes）和方法（methods）。
```
# 举例找一个整数的二进制表示，再返回其长度
a = 1031
print(bin(a))  # 0b10000000111
print(a.bit_length())  # 11
```
获取类型信息
1. type()
```
print(type(1)) # <class 'int'>
print(type(5.2)) # <class 'float'>
print(type(True)) # <class 'bool'>
print(type('5.2')) # <class 'str'>
```
2. isinstance()
```
print(isinstance(1, int))  # True
print(isinstance(5.2, float))  # True
print(isinstance(True, bool))  # True
print(isinstance('5.2', str))  # True
```
3. 区别
  - type() 不会认为子类是一种父类类型，不考虑继承关系。
  - isinstance() 会认为子类是一种父类类型，考虑继承关系。
位运算

1. 原码、反码和补码

二进制的三种表示形式，计算机内部使用补码表示。
- 原码：有一位符号位
```
00 00 00 11 -> 3
10 00 00 11 -> -3
```
- 反码：正数的反码是原码，复数的反码是符号位不变，其余位取反
```
00 00 00 11 -> 3
11 11 11 00 -> -3
```
- 补码：正数的补码就是原码，负数的补码就是反码+1
```
00 00 00 11 -> 3
11 11 11 01 -> -3
```
  符号位：最高位为符号位，0表示正数，1表示负数。在位运算中符号位也参与运算。
2. 按位运算
- 按位非～
  
  把二进制数的0和1全部取反，包括符号位
- 按位与&
  
  只有两个都为1时才为1
- 按位或｜
  
  只要其中一个为1就为1
- 按位异或^
  
  对应位不同时为1
- 按位左移
  
  将数值的二进制表示向左移动i位
- 按位右移
  
  将数值的二进制表示向右移动i位
3. 位运算实现快速计算
- 通过“>>”和“<<”可以实现快速计算2的倍数
- 通过“^”可以快速交换两个数
- 通过a&(-a)可以快速获取a的最后为1位置的整数
```
print(8>>3) # 1

a = 2 
b = 5
a ^= b
b ^= a
a ^= b
print(a) # 5
print(b) # 2

print(a&(-a))
```
4. 位运算实现整数集合

一个数的二进制表示可以看做一个集合（0/1分别表示不在/在集合中）。

eg：集合{1, 3, 4, 8}，可以表示成 01 00 01 10 10 而对应的位运算可就可以看作对集合进行的操作。

元素与集合的操作：
```
# a | (1<<i)  -> 把 i 插入到集合中
# a & ~(1<<i) -> 把 i 从集合中删除
# a & (1<<i)  -> 判断 i 是否属于该集合（零不属于，非零属于）
a = 4
print(bin(a)) #0b100
print(bin(a|(1<<7))) # 0b10000100
print(bin(a&~(1<<2))) # 0b0
print(bin(a&(1<<1))) # 0b0
```
集合之间的操作：
```
# a 补   -> ~a
# a 交 b -> a & b
# a 并 b -> a | b
# a 差 b -> a & (~b)

a = 4
b = 19
print(bin(a)) # 0b100
print(bin(b)) # 0b10011
print(bin(~a)) # -0b101
print(bin(a&b)) # 0b0
print(bin(a|b)) # 0b10111
print(bin(a&(~b))) # 0b100
```
整数在内存中是以补码的形式存在的，输出自然也是按照补码输出。

注意：
- python中bin一个负数，是原码的二进制加上一个负号
- python中整型是不限制程度的，不会超范围溢出，普通32位，超过会自动当长整型处理，几乎没有限制
流程控制

条件语句
1. if语句
```
# if expression:
#     expr_true_suite

if 2 > 1 and not 2 > 3:
    print('Correct Judgement!')
# Correct Judgement!
```
  expression为真才执行expr_true_suite
2. if - else语句
```
# if expression:
#     expr_true_suite
# else:
#     expr_false_suite
```
3. if - elif - else语句
```
if expression1:
    expr1_true_suite
elif expression2:
    expr2_true_suite
    ·
    ·
elif expressionN:
    exprN_true_suite
else:
    expr_false_suite
```
4. assert关键词
  
  assert这个关键词我们称之为“断言”，当这个关键词后边的条件为 False 时，程序自动崩溃并抛出AssertionError的异常。
```
my_list = ['lsgogroup']
my_list.pop(0)
assert len(my_list) > 0

# AssertionError
```
循环语句
1. while循环
```
while 布尔表达式:
    代码块
```
2. while - else循环
```
while 布尔表达式:
    代码块
else:
    代码块
```
  当while循环正常执行完的情况下，执行else输出，如果while循环中执行了跳出循环的语句，比如 break，将不执行else代码块的内容。
3. for循环
```
for 迭代变量 in 可迭代对象:
    代码块
```
4. for - else循环
```
for 迭代变量 in 可迭代对象:
    代码块
else:
    代码块
```
  与while - else类似
5. range函数
```
# range([start,] stop[, step=1])

for i in range(2, 9):  # 不包含9
    print(i)

# 2
# 3
# 4
# 5
# 6
# 7
# 8
```
6. enumerate()函数
```
enumerate(sequence, [start=0])
```
  - sequence：一个序列、迭代器或其他支持迭代对象。
  - start：下标起始位置。
  - 返回 enumerate(枚举) 对象
```
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
lst = list(enumerate(seasons))
print(lst)
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
lst = list(enumerate(seasons, start=1))  # 下标从 1 开始
print(lst)
# [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]p
```
7. break语句
  
  可以跳出当前所在层的循环
8. continue语句
  
  提前终止本轮循环，进入下一轮
9. pass语句
  
  pass 语句的意思是“不做任何事”，如果你在需要有语句的地方不写任何语句，那么解释器会提示出错，而 pass 语句就是用来解决这些问题的。
推导式
1. 列表推导式
```
# [ expr for value in collection [if condition] ]

x = [(i, i ** 2) for i in range(100) if (i % 2) != 0 and (i % 3) == 0]
print(x)

# [(3, 9), (9, 81), (15, 225), (21, 441), (27, 729), (33, 1089), (39, 1521), (45, 2025), (51, 2601), (57, 3249), (63, 3969), (69, 4761), (75, 5625), (81, 6561), (87, 7569), (93, 8649), (99, 9801)]
```
2. 元组推导式
```
# ( expr for value in collection [if condition] )

a = (x for x in range(10))
print(a)
# <generator object <genexpr> at 0x0000025BE511CC48>

print(tuple(a))
# (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
```
3. 字典推导式
```
# { key_expr: value_expr for value in collection [if condition] }

b = {i: i % 2 == 0 for i in range(10) if i % 3 == 0}
print(b)
# {0: True, 3: False, 6: True, 9: False}
```
4. 集合推导式
```
# { expr for value in collection [if condition] }

c = {i for i in [1, 2, 3, 4, 5, 5, 6, 4, 3, 2, 1]}
print(c)
# {1, 2, 3, 4, 5, 6}
```
异常处理
1. Python 标准异常总结
  - BaseException：所有异常的基类
  - Exception：常规异常的基类
  - StandardError：所有的内建标准异常的基类
  - ArithmeticError：所有数值计算异常的基类
  - FloatingPointError：浮点计算异常
  - OverflowError：数值运算超出最大限制
  - ZeroDivisionError：除数为零
  - AssertionError：断言语句（assert）失败
  - AttributeError：尝试访问未知的对象属性
  - EOFError：没有内建输入，到达EOF标记
  - EnvironmentError：操作系统异常的基类
  - IOError：输入/输出操作失败
  - OSError：操作系统产生的异常（例如打开一个不存在的文件）
  - WindowsError：系统调用失败
  - ImportError：导入模块失败的时候
  - KeyboardInterrupt：用户中断执行
  - LookupError：无效数据查询的基类
  - IndexError：索引超出序列的范围
  - KeyError：字典中查找一个不存在的关键字
  - MemoryError：内存溢出（可通过删除对象释放内存）
  - NameError：尝试访问一个不存在的变量
  - UnboundLocalError：访问未初始化的本地变量
  - ReferenceError：弱引用试图访问已经垃圾回收了的对象
  - RuntimeError：一般的运行时异常
  - NotImplementedError：尚未实现的方法
  - SyntaxError：语法错误导致的异常
  - IndentationError：缩进错误导致的异常
  - TabError：Tab和空格混用
  - SystemError：一般的解释器系统异常
  - TypeError：不同类型间的无效操作
  - ValueError：传入无效的参数
  - UnicodeError：Unicode相关的异常
  - UnicodeDecodeError：Unicode解码时的异常
  - UnicodeEncodeError：Unicode编码错误导致的异常
  - UnicodeTranslateError：Unicode转换错误导致的异常
2. python标准警告总结
  - Warning：警告的基类
  - DeprecationWarning：关于被弃用的特征的警告
  - FutureWarning：关于构造将来语义会有改变的警告
  - UserWarning：用户代码生成的警告
  - PendingDeprecationWarning：关于特性将会被废弃的警告
  - RuntimeWarning：可疑的运行时行为(runtime behavior)的警告
  - SyntaxWarning：可疑语法的警告
  - ImportWarning：用于在导入模块过程中触发的警告
  - UnicodeWarning：与Unicode相关的警告
  - BytesWarning：与字节或字节码相关的警告
  - ResourceWarning：与资源使用相关的警告
3. try - except语句
```
try:
    检测范围
except Exception[as reason]:
    出现异常后的处理代码
```
  try 语句按照如下方式工作：
  - 首先，执行try子句（在关键字try和关键字except之间的语句）
  - 如果没有异常发生，忽略except子句，try子句执行后结束。
  - 如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和except之后的名称相符，那么对应的except子句将被执行。最后执行try - except语句之后的代码。
  - 如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中。
4. try - except - finally语句
  
  try: 检测范围 except Exceptionas reason: 出现异常后的处理代码 finally: 无论如何都会被执行的代码
  
  不管try子句里面有没有发生异常，finally子句都会执行。
5. try - except - else语句
  
  如果在try子句执行时没有发生异常，Python将执行else语句后的语句。
```
try:
    检测范围
except:
    出现异常后的处理代码
else:
    如果没有异常执行这块代码
```
6. raise语句
  
  Python 使用raise语句抛出一个指定的异常。
```
try:
    raise NameError('HiThere')
except NameError:
    print('An exception flew by!')
# An exception flew by!
```
容器序列类型

点击标题进行跳转
成本最低的事情是学习，性价比最高的事情也是学习！
相关阅读:
leetcode -- 4Sum
leetcode -- 3Sum Closest
leetcode -- 3Sum
leetcode -- Longest Common Prefix
leetcode -- Container With Most Water
leetcode -- Palindrome Number
rep stos 指令(Intel汇编)
利用反汇编手段解析C语言函数
 C语言反汇编入门实例
 系统栈的工作原理
原文地址：https://www.cnblogs.com/qiaofutu/p/16205165.html

python变量、运算符、数据类型

python 学习笔记

变量、运算符与数据类型

变量

运算符

数据类型

位运算

流程控制

条件语句

循环语句

推导式

异常处理

容器序列类型