Python升级之路 (Lv2 ) Python基本概念

Python系列文章目录

第一章 Python 入门
第二章 Python基本概念

---

---

前言

这一章节, 主要介绍Python的组成和命名规则, 变量和常量的声明, 基本数据类型和运算符详情等内容

一、Python 基础

1. Python组成和缩进

• Python程序由模块组成。一个模块对应python源文件，一般后缀名是：.py
• 模块由语句组成。运行Python程序时，按照模块中语句的顺序依次执行
• 语句是Python程序的构造单元，用于创建对象、变量赋值、调用函数、控制语句等

缩进

通常采用“四个空格”表示一个缩进. 并且避免将“tab制表符”或者tab与空格混合的缩进风格。
目前，常用的编辑器一般设置成：tab制表符就是4个空格

2. 对象

Python中，一切皆对象。 每个对象由： 标识（identity）、类型（type）、值(value) 组成

代码测试: 输出对象的类型, id, 值

a = 1
print(a)  # 查看对象的值(value)
print(id(a))  # 查看对象id
print(type(a))  # 查看对象类型(type)

b = "我是谁"
print(b)
print(id(id(b)))
print(type(b))

运行结果

深入理解对象

• 标识用于唯一标识对象，通常对应于对象在计算机内存中的地址。使用内置函数id(obj)可返回对象obj的标识。

• 类型用于表示对象存储的“数据”的类型。类型可以限制对象的取值范围以及可执行的操作。可以使用type(obj)获得对象的所属类型。

• 值表示对象所存储的数据的信息。使用print(obj)可以直接打印出值。

• 对象的本质就是：一个内存块，拥有特定的值，支持特定类型的相关操作

内存示意图

• 栈是内存中一个连续的空间, 堆是不连续的空间. 每次生成对象时, 都会在内存中开辟空间.
• 栈中存放的是对象名/变量和id / 内存地址, 堆中存放 的是 id, type. value.

2. 引用

• 在Python中，变量也称为：对象的引用(reference)。
• 变量存储的就是对象的地址, 变量通过地址引用了“对象”。
• 变量位于：栈内存; 对象位于：堆内存
• 变量不需要显式声明类型。根据变量引用的对象，Python解释器自动确定数据类型

3. 标识符规则

标识符规则：用于变量、函数、类、模块等的名称。 规则如下:

• 区分大小写
• 不能使用关键字。比如： if 、 or 、 while 等
• 第一个字符必须是字母、下划线。其后的字符是：字母、数字、下划线
• 以双下划线开头和结尾的名称通常有特殊含义，尽量避免这种写法。比如： __init__ 是类的构造函数

---

二、变量和简单赋值语句

1. 变量的声明和赋值

变量的声明和赋值：用于将一个变量绑定到一个对象上，格式： 变量 名 = 表达式
注意: 同Java一样, 变量在使用前必须先被初始化（先被赋值）!

最简单的表达式就是字面量. 比如： a = 3

变量赋值内存变化情况:

运行过程中，解释器先运行右边的表达式，生成一个代表表达式运算结果的对象；
然后，将这个对象地址赋值给左边的变量, 如下图所示:

如果直接调用未赋值的变量, 例如 print(a) 则会报如下错误:

Traceback (most recent call last):
  File "C:\code\python_code\mypro01\mypy08-variable.py", line 6, in <module>
    print(a)
NameError: name 'a' is not defined

2. 删除变量 & 垃圾回收机制

如果对象没有变量引用，就会被垃圾回收器回收，清空内存空间. (这一过程是自动的)
也可以通过del语句删除不再使用的变量

删除变量操作:

a=123
del a
print(a)

3. 常量

Python不支持常量，因为没有语法规则限制改变一个常量的值
我们只能约定常量的命名规则，以及在程序的逻辑上不对常量的值作出修改

MAX_SPEED = 120
print(MAX_SPEED)  # 输出120
MAX_SPEED = 140  # 实际是可以改的。只能逻辑上不做修改。
print(MAX_SPEED)  # 输出140

4. 链式赋值

链式赋值用于同一个对象赋值给多个变量。

x = y = 666

5. 系列解包赋值

系列数据赋值给对应相同个数的变量（个数必须保持一致）

a, b = 1, 2		# 相当于 a=1, b=2
a, b = b, a  # 变量值互换
print(a, b)

---

三、最基本内置数据类型

1. 基本数据类型和运算符

python中变量没有类型，但是对象都有类型

python中最基本的内置数据类型：

• 整型 int
  整数， 2345 , 10 , 50 2
• 浮点型 float
  小数， 3.14 或者科学计数法 314e-2 3
• 布尔型 bool
  表示真假，仅包含： True 、 False
• 字符串型 str
  由字符组成的序列 “time” , ‘pause’ , ‘the’ , ‘world’

基本运算符说明:

基本运算符演示:

注意区分和Java不同的运算符: / : 浮点数除法, // : 整数除法, ** : 幂

# 加法
print(1 + 1)  # 2
# 减法
print(3 - 1)    # 2
# 乘法
print(5 * 5)    # 25
# 浮点数除法
print(7 / 2)    # 3.5
# 整数除法
print(7 // 3)   # 2
# 取模
print(7 % 3)    # 1
# 幂
print(2 ** 4)   # 16
# 使用 divmod() 函数同时得到商和余数
print(divmod(7, 3))
# print(3 / 0)
print(0 / 3)

整数

1. Python中，除了十进制，还有其他三种进制：

• 0b 或 0B ，二进制 0 1
• 0o 或 0O ，八进制 0 1 2 3 4 5 6 7
• 0x 或 0X ，十六进制0 1 2 3 4 5 6 7 8 9 a b c d e f

测试代码

print("测试不同进制")
print(12)  # 12
print(0b101)  # 5
# print(0o19)  # SyntaxError: invalid digit '9' in octal literal
print(0o10)  # 8
print(0xff)  # 255

2. 使用int()实现类型转换：

• 浮点数直接舍去小数部分. 如： int(9.9) 结果是： 9
• 布尔值 True 转为 1 ， False 转为 0 . 如： int(True) 结果是 1
• 字符串符合整数格式（浮点数格式不行）则直接转成对应整数，否则报错

print("使用int()实现类型转换：")
print(int(9.9))
print(int("456"))
print(int(True))
print(int(False))
print(bool(0))
print(bool(1))

3. 自动转型：整数和浮点数混合运算时，表达式结果自动转型成浮点数. 比如：2+8.0 的结果是 10.0

测试代码

print("字符串符合整数格式（浮点数格式不行）则直接转成对应整数，否则报错")
print(int("456"))
# print(int("456abc"))
# print(int("456.78"))
print("整数和浮点数混合运算时，表达式结果自动转型成浮点数")
print(2+6.8)

4. 整数可以任意大

• Python2中， int 是32位, Long类型是64位
• Python3中， int 可以存储任意大小的整数,long 被取消。
• Python3中可以做超大数的计算，而不会造成“整数溢出”，这也是Python特别适合科学运算的特点

测试代码

# 10的100次冪
googol = 10**100
print(googol)

浮点数 Float

浮点数用科学计数法表示. 比如： 3.14 ，表示成： 314E-2 或者 314e-2 1
这些数字在内存中也是按照科学计数法存储

1. 类型转换和四舍五入

• 类似于 int() ，我们也可以使用 float() 将其他类型转化成浮点数
• 整数和浮点数混合运算时，表达式结果自动转型成浮点数. 比如： 2+8.0 的结果是 10.0
• round(value) 可以返回四舍五入的值. 但不会改变原有值，而是产生新的值

测试代码

print("浮点数用科学计数法表示, 这些数字在内存中也是按照科学计数法存储")
print(float(314E-2))
print(float(314e-2))
print(float("3.1415"))

print("整数和浮点数混合运算时，表达式结果自动转型成浮点数")
print(2+6.8)

print("round(value) 可以返回四舍五入的值. 但不会改变原有值, 而是产生新值")
print(round(4.51))  # 5
print(round(4.50))  # 4
print(round(4.55, 1))  # 4.5

2. 增强型赋值运算符

运算符 + 、 - 、 * ， / 、 // 、 ** 和 % 和赋值符 = 结合可以构成“增强型赋值运算符”。

测试代码

x, y = 1, 2
y *= x + 2 
print(y)   

布尔值

Python2中没有布尔值，直接用数字 0 表示 False , 用数字 1 表示True 。
Python3中，把 True 和 False 定义成了关键字，但他们的本质还是 1 和 0 ，甚至可以和数字相加。

在Python语言中有一些特殊的布尔类型值为False，例如:
False、0、0.0、空值None、空序列对象（空列表、空元祖、空集合、空字典、空字符串）、空range对象、空迭代对象.
其他情况，均为True

测试代码

a = True
b = 3
c = a + b  # c的值是：4
print(c)
print('空字符串的布尔类型的值:', bool(""))  # False
print('空列表布尔类型的值:', bool([]))   # False
print('None布尔类型的值:', bool(None))    # False
print('0布尔类型的值:', bool(0))  # False
print('0.0布尔类型的值:', bool(0.0))  # False
print('字符串True和False转成布尔都是True：', bool("False"))  # True

字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号 ( ' 或 " ) 来创建字符串。

• 创建字符串很简单，只要为变量分配一个值即可. 例如：

  var1 = 'Time Pause'
  var2 = "The World"
  

• Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
  Python 访问子字符串，可以使用方括号来截取字符串，如下实例：

  var1 = 'Time Pause'
  var2 = "The World"
   
  print "var1[0]: ", var1[0]
  print "var2[1:5]: ", var2[1:5]
  

• Python 字符串连接
  我们可以对字符串进行截取并与其他字符串进行连接，如下实例：

  print("String测试. var2[1:5] 类似Java的substring(), 包前不包后 ")    
  var1 = 'Time Pause'                                        
  var2 = "The World"                                         
  print("var1[0]: ", var1[0])  # T                           
  print("var2[1:5]: ", var2[1:5])  # he W                    
                                                             
  var1 = 'Hello World!'                                      
  print("输出 : ", var1[:6] + 'Python!')  # Hello Python!      
  

• Python 转义字符
  在需要在字符中使用特殊字符时，python 用反斜杠 \ 转义字符。如下表：
  

• Python字符串运算符
  下表实例变量 a 值为字符串 “Hello”，b 变量值为 “Python”：
  

• Python 字符串格式化

  Python 支持格式化字符串的输出 。
  尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
  在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。

  
  格式化操作符辅助指令:
  
  测试代码：

  # %s: 格式化字符. %d 格式化整数                                            
  print("My name is %s and weight is %d kg!" % ('TimePause', 77))       
  

• Python 三引号

  Python 中三引号可以将复杂的字符串进行赋值
  Python 三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符
  三引号的语法是一对连续的单引号或者双引号（通常都是成对的用）

  hi = '''hi  
  there'''    
  print(hi)   
  

  

  三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式（即所见即所得）格式的。
  一个典型的用例是，当你需要一块HTML或者SQL时，这时当用三引号标记，使用传统的转义字符体系将十分费神

  sql = '''     
  CREATE TABLE u
  login VARCHAR(
  uid INTEGER,  
  prid INTEGER) 
  '''           
  print(sql)    
  

  

• Unicode 字符串
  Python 中定义一个 Unicode 字符串和定义一个普通字符串一样简单：
  如下, 被替换的 \u0020 标识表示在给定位置插入编码值为 0x0020 的 Unicode 字符（空格符）
  

字符串使用方法详解

1. 字符串基本特点

2. 字符串的编码

3. 字符串的创建(单行)

4. 字符串的创建(多行)

5. 空字符串和len()函数

6. 转移字符 \n: 换行 \r: 回车 \t:横向制表符 \b:退格 \\:输出转义符 \
   

7. 字符串拼接 +

8. 字符串复制 *

9. 不换行打印

10. 从控制台读取输入的字符串 input()

11. 字符串替换 replace()

12. 数字转字符串 str()

13. 使用[]提取指定索引下的字符

14. 字符串切片操作 类似java substring()
    
    

15. split()分割字符串和join()合并字符串

16. 字符串驻留机制和字符串比较

17. 字符串比较和同一性

18. 成员操作符判断子字符串

19. 字符串常用方法汇总

20. 去除首尾信息

21. 大小写转换

22. 格式排版

23. 字符串特征判断方法

24. 字符串的格式化

25. 填充与对齐

26. 数字格式化
    

27. 可变字符串
    

上述介绍配套测试代码

# 1.字符串基本特点
# Python的字符串是不可变的，但可以将字符串的一部分复制到新创建的字符串，达到“看起来修改”的效果。


# 2.字符串的编码
# Python3直接支持Unicode，可以表示世界上任何书面语言的字符。Python3的字符默认就是16位Unicode编码，ASCII码是Unicode编码的子集。
# 使用内置函数ord()可以把字符转换成对应的Unicode码；
print(ord("A"))
print(ord("a"))
print(ord("明"))
# 使用内置函数chr()可以把十进制数字转换成对应的字符。
print(chr(706))

# 3.引号创建字符串
# 我们可以通过单引号或双引号创建字符串。 使用两种引号的好处是可以创建本身就包含引号的字符串，而不用使用转义字符。
a = "I'm a teacher!"
print(a)  # I'm a teacher!
b = 'my_name is "TOM"'
print(b)  # my_name is "TOM"

# 4.连续三个单引号或三个双引号，可以帮助我们创建多行字符串。在长字符串中会保留原始的格式。
c = '''Fake
news
!
'''
print(c)

# 5.空字符串和len()函数
# Python允许空字符串的存在，不包含任何字符且长度为0。
print(len('a'))
print(len(''))
# len()用于计算字符串含有多少字符。
print(len("天子守国门,君王死社稷"))

# 6.转义字符
# \n: 换行  \r: 回车  \t:横向制表符 \b:退格  \\:输出转义符
print("啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊\n惺惺惜惺惺嘻嘻嘻嘻嘻嘻嘻\r惺惺惜惺惺\t想新\b写写嘻嘻嘻惺惺惜惺惺想新写写许许多多的若若若热\\二二")

# 7.字符串拼接
# 可以使用 + 将多个字符串拼接起来
a = '皮尔斯' + '摩根'
print(a)
# 可以将多个字面字符串直接放到一起实现拼接。
b = '皮尔斯''摩根'
print(b)

# 8.字符串复制
# 使用*可以实现字符串复制
c = "MAGA!" * 3
print(c)

# 9.不换行打印
# 我们可以通过参数end = “任意字符串”。实现末尾添加任何内容：
print("唐纳德", end=' ')
print("特朗普", end='##')
print("特离谱")

# 10.从控制台读取字符串
# 我们可以使用input()从控制台读取键盘输入的内容。
# myCash = input("请输入付款金额""(若付款, 概不退换): ")
# print("您的收款金额是: " + myCash)

# 11.replace() 实现字符串替换
# 整个过程中，实际上我们是创建了新的字符串对象，并指向了变量a，而不是修改了以前的字符串。
a = "Mr Trump say: Fake news!"
a = a.replace("Trump", "Trace")
print(a)

# 12.str()实现数字转型字符串
a = str(5.20)  # 结果是：a = ‘5.20’
b = str(3.14e2)  # 结果是：b = ’314.0’
c = str(True)  # 结果是：c = ‘True’
print(a)
print(b)
print(c)

"""
13.使用[]提取字符
字符串的本质就是字符序列，我们可以通过在字符串后面添加[]， 在[]里面指定偏移量，可以提取该位置的单个字符。
正向搜索：
最左侧第一个字符，偏移量是0，第二个偏移量是1，以此类推。直到len(str)-1为止。
反向搜索：
最右侧第一个字符，偏移量是-1，倒数第二个偏移量是-2，以此类推，直到-len(str)为止
"""
a = "Ivanka Trump"
# 字符串开头
print(a[0])
print(a[-len(a)])
# 字符串结尾
print(a[-1])
print(a[len(a) - 1])

# 14.字符串切片slice操作
# 切片slice操作可以让我们快速的提取子字符串。标准格式为 起始偏移量start：终止偏移量end：步长step
# 典型操作(三个量为正数的情况)如下
a = "Donald Trump"
print("[:] 提取整个字符串: ", a[:])
print("[start:] 从start索引开始到结尾: ", a[2:])
print("[:end] 从头开始知道end-1: ", a[:2])
print("[start:end] 从start到end-1: ", a[2:4])
print("[start:end:step] 从start提取到end-1，步长是step: ", a[1:8:2])
# 其他操作（三个量为负数）的情况：
print("倒数三个:", a[-3:])
print("倒数第八个到倒数第三个(包头不包尾): ", a[-3:-1])
print("步长为负，从右到左反向提取: ", a[::-1])
# 切片操作时，起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围，也不会报错。起始偏移量小于0则会当做0，终止偏移量大于“长 度-1”会被当成-1。
print(a[7:100])

# 15. split()分割和join()合并
# split()可以基于指定分隔符将字符串分隔成多个子字符串(存储到列表中)。如果不指定分隔符，则默认使用空白字符
a = "Mr Trump say: Fake news!"
print(a.split())
print(a.split(":"))
# join()的作用和split()作用刚好相反，用于将一系列子字符串连接起来。
b = ['Mr', 'Trump', 'say:', 'Fake', 'news!']
print('-'.join(b))

# 16. 字符串驻留机制和字符串比较
# 字符串驻留：常量字符串只保留一份
c = "dd#"
d = "dd#"
print(c is d)  # True

# 17. 字符串比较和同一性
# 可以直接使用 == != 对字符串进行比较，是否含有相同的字符
# 使用 is not is ，判断两个对象是否同一个对象。比较的是对象的地址，即 id(obj1) 是否和 id(obj2) 相等。
a = "Donald Trump"
b = "Ivanka Trump"
print(a == b)
print(a is not b)

# 18. 成员操作符判断子字符串
# in not in 关键字，判断某个字符(子字符串)是否存在于字符串中。'
print("ab" in "abcdefg")

# 19. 字符串常用方法汇总
a = '''明太祖朱元璋,朱标,建文帝朱允炆
明成祖朱棣,明仁宗朱高炽,明宣宗朱瞻基,明英宗朱祁镇,明代宗朱祁玉
明宪宗朱见深,明孝宗朱佑樘,明武宗朱厚照,明睿宗朱祐杬,
明世宗朱厚熜,明穆宗朱载垕,明神宗朱翊钧,
明光宗朱常洛.明熹宗朱由校,明思宗朱由检
'''
print(len(a))
print(a.startswith("明太祖"))
print(a.endswith("朱由检"))
print("第一次出现指定字符串的位置: ", a.find("朱"))
print("最后一次出现指定字符串的位置", a.rfind("朱"))  # 测试为false, 原因待定位
print("指定字符串出现了几次: ", a.count("宗"))
print("所有字符全是字母或数字: ", a.isalnum())

# 20. 去除首尾信息
# 我们可以通过strip()去除字符串首尾指定信息。通过lstrip()去除字符串左边指定信息，rstrip()去除字符串右边指定信息。
print("-abc-".strip("-"))
print("-abc-".lstrip("-"))
print("-abc-".rstrip("-"))

# 21. 大小写转换
a = "Mr Trump say: Fake news!"
print("产生新的字符串,首字母大写: ", a.capitalize())
print("产生新的字符串,每个单词都首字母大写:", a.title())
print("产生新的字符串,所有字符全转成大写: ", a.upper())
print("产生新的字符串,所有字符全转成小写: ", a.lower())
print("产生新的,所有字母大小写转换: ", a.swapcase())

# 22. 格式排版
# center() 、 ljust() 、 rjust() 这三个函数用于对字符串实现排版。
a = "asd"
print(a.center(100, "*"))
print(a.center(100))
print(a.ljust(100, "*"))
print(a.rjust(100, "*"))

'''
23. 特征判断方法
    isalnum() 是否为字母或数字 
    isalpha() 检测字符串是否只由字母组成(含汉字) 
    isdigit() 检测字符串是否只由数字组成 
    isspace()检测是否为空白符 
    isupper() 是否为大写字母 
    islower() 是否为小写字母
'''
a = "trump拆那"
print(a.isalnum())
print(a.isalpha())
print(a.isdigit())
print(a.isspace())
print(a.isupper())
print(a.islower())
print(a.isdecimal())

# 24. 字符串的格式化
# format() 基本用法基本语法是通过 {
      
      } 和 : 来代替以前的 % 。
# format() 函数可以接受不限个数的参数，位置可以不按顺序。
a = "今年是{0}年, 是农历十二生肖中的{1}年"
print(a.format(2022, "鼠"))
# 我们可以通过{
    
    索引}/{
    
    参数名}，直接映射参数值，实现对字符串的格式化，非常方便。
b = "爸爸的爸爸叫什么? 爸爸的爸爸叫{grandpa}"
print(b.format(grandpa="爷爷"))

# 25. 填充与对齐
# 填充常跟对齐一起使用
# ^ 、 < 、 > 分别是居中、左对齐、右对齐，后面带宽度
# : 号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充
print("{:*>10}".format("testStr"))  # 在十个字符中将字符串居右对齐, 多出的用*补齐
print("我是{0},{1:w^6}这里你把握不住".format("潘长江", "嘎子"))

# 26. 数字格式化
# 浮点数通过 f ，整数通过 d 进行需要的格式化。
a = "您的支付宝到账{:.2f}元, 需还款{:10d}元"
print(a.format(14138.552673, 6))

# 27. 可变字符串
# Python中，字符串属于不可变对象，不支持原地修改，如果需要修改其中的值，只能创建新的字符串对象。
# 确实需要原地修改字符串，可以使用io.StringIO对象或array模块
import io

s = "hello, EVA"
sio = io.StringIO(s)  # 可变字符串
print(sio)
v1 = sio.getvalue()
print("v1:", v1)
char7 = sio.seek(7)  # 指针知道索引7这个位置
sio.write("OnePiece")
v2 = sio.getvalue()
print("v2:", v2)

# 类型转换总结
# 转换为int
print('int()默认情况下为：', int())
print('str字符型转换为int：', int('010'))
print('float浮点型转换为int：', int(234.23))
# #十进制数10，对应的2进制，8进制，10进制，16进制分别是：1010,12,10,0xa
print('int(\'0xa\', 16) = ', int('0xa', 16))
print('int(\'10\', 10) = ', int('10', 10))
print('int(\'12\', 8) = ', int('12', 8))
print('int(\'1010\', 2) = ', int('1010', 2))
# 转换为float
print('float()默认情况下为：', float())
print('str字符型转换为float：',
      float('123.01'))
print('int浮点型转换为float：', float(32))
# 转换为complex
print('创建一个复数(实部+虚部)：', complex(12, 43))
print('创建一个复数(实部+虚部)：', complex(12))
# 转换为str字符串
print('str()默认情况下为：', str())
print('float型转换为str：', str(232.33))
print('int转换为str：', str(32))
lists = ['a', 'b', 'e', 'c', 'd', 'a']
print('列表list转换为str:', ''.join(lists))
# 转换为list
strs = 'hongten'
print('序列strs转换为list:', list(strs))
# 转换为tuple(元组)
print('列表list转换为tuple:', tuple(lists))
# 字符和整数之间的转换
print('整数转换为字符chr:', chr(67))
print('字符chr转换为整数:', ord('C'))
print('整数转16进制数:', hex(12))
print('整数转8进制数:', oct(12))

2. 时间表示

计算机中时间的表示是从“1970年1月1日 00:00:00”开始，以毫秒（1/1000秒）进行计算
我们把1970年这个时刻称为“unix时间点

python中可以通过time.time() 获得当前时刻，返回的位，带微秒（1/1000毫秒）精度的浮点值. 例如下面测试代码：

import time

b = int(time.time())  # 返回从1970到今天的秒数
totalMinutes = b // 60  # // 整数除法
totalHours = totalMinutes // 60
totalDays = totalHours // 24
totalYears = totalDays // 365  # 忽略闰年情况
print(b)
print(totalMinutes)
print(totalHours)
print(totalDays)
print(totalYears)

---

四、运算符

1. 逻辑运算符

逻辑运算符总结:

测试代码

a, b, c = 1, 2, 3
print((a < b) and (b < c))
print((a > b) or (a < b))
print(not (a < b))

2. 比较运算符

所有比较运算符返回 1 表示真，返回 0 表示假. 这分别与特殊变量True 和 False 等价

测试代码

a = 5
if a <= 30:
    print("a<30")
if 4 <= a <= 30:
    print("1<=a<=10")
if 4 <= a & a <= 30:
    print("4 <= a & a <= 30")

3. 位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如图所示:

测试代码

a = 0b11001
b = 0b01000
print(bin(a | b))  # bin()可以将数字转成二进制表示 '0b11001'
print(bin(a & b))  # 与
print(bin(a ^ b))  # 异或
print(3 << 2)  # 左移1位相当于乘以2.左移两位相当于：3*(2*2)
print(20 >> 1)  # 右移移位相当于除以2

4. 加法操作, 乘法操作补充

加法操作补充

• 数字相加 3+2 结果是 5
• 字符串拼接 “3”+“2” 结果是 “32”
• 列表、元组等合并 [10,20,30]+[5,10,100] 结果是 [10,20,30,5,10,100]

乘法操作补充

• 数字相乘 3*2 结果是 6
• 字符串复制 “abc”*3 结果是 ”abcabcabc”
• 列表、元组等复制 [10,20,30]*3 结果是 [10,20,30,10,20,30,10,20,30]

5. 增强赋值运算符补充

复合赋值可以让程序更加精炼，提高效率
与 C 和 JAVA 不一样， Python 不支持自增(++)和自减(--)

测试代码

str_a = "Time"
str_b = "Pause"
str_c = "The"
str_d = "WorldWorld"
str_a += "e"
# str_b -= "e"
str_c *= 3
# str_d /= 2
print(str_a)    # 加法支持字符串拼接
print(str_b)  # 减法不支持字符串裁剪
print(str_c)  # 乘法支持字符串拼接
print(str_d)  # 除法也不支持字符串操作
a = 1 << 2
a <<= 2
print("1左移2位", 1 << 2, "a左移赋值", a)

注意:
增强赋值运算符左右需要空格, 但组成增强赋值运算符的运算符之间不需要空格

6. 同一运算符

同一运算符用于比较两个对象的存储单元，实际比较的是对象的地址

is 与 == 区别：

• is 用于判断两个变量引用对象是否为同一个，即比较对象的地址。
• == 用于判断引用变量引用对象的值是否相等，默认调用对象__eq__() 方法。

测试代码

a = 2
b = 2
c = 3
print("a和b是同一个对象", a is b)  # 执行结果:True, is比较的是id, 即对象的引用地址/内存地址
print("a和c是同一个对象", a is c)  # 执行结果False
print("a和c不是同一个对象", a is not c)  # 执行结果True

总结

• is 比较两个对象的 id 值是否相等，是否指向同一个内存地址
• == 比较的是两个对象的内容是否相等，值是否相等
• is 运算符比 == 效率高，在变量和 None 进行比较时，应该使用 is

7.整数缓存问题

• 命令行模式下，Python仅仅对比较小的整数对象进行缓存（范围为[-5, 256]）
  语言底层用数组实现，连续分配空间，便于查找 ，而并非是所有整数对象
• 文件模式下，所有数字都会被缓存，范围是：[-无穷大,+无穷大])
  缓存实现：[-5,256]仍然底层用数组实现 ；不在[-5,256]出现的数，缓存到链表中，不连续分配空间

8. 成员运算符

成员运算符测试实例中包含了一系列的成员，包括字符串，列表或元组

测试代码

a = "python"
b = "py"
print(b in a)  # True
c = [10, 20, 30]
print(10 not in c)  # False

9. 运算符优先级问题

运算符优先级如下图，从高到低依次为:

测试代码

# 测试运算符优先级
a, b, c, d = 20, 10, 15, 5
e = (a + b) * c / d  # 30*15/5
print('(a+b)*c/d的执行结果:', e)
e = (a + b) * (c / d)  # 30*(15/5)
print('(a+b)*(c/d)的执行结果：', e)
e = a + (b * c) / d  # 20+150/5
print('a+(b*c)/d的执行结果：', e)

注意:

• 实际使用中，记住如下简单的规则即可，复杂的表达式一定要使用小括号组织
• 乘除优先加减
• 位运算和算术运算>比较运算符>赋值运算符>逻辑运算符

10. 基本运算符总结

基本运算符注意包括以下几类:

• 逻辑运算符 (not , or , and)
• 比较运算符 ( > , <, =, >= , <= )
• 位运算符( &, | , >> , << 等 )
• 增强运算符 ( += , -= , *= , /+ 等 )
• 同一运算符 ( is , is not )
• 成员运算符 ( in , not in )

---