Python 的基础语法
1. 代码注释
代码注释是程序中不可少的部分，但注释不是程序，不能被执行，只是对程序代码进行解释说明，既可以作为程序员之间交流的主要途径，也能方便作者自己以后阅读代码与维护代码，大大增强程序的可读性。
Python 中的注释有两种形式：
- 单行注释，以 “#” 字符开始，同一行中其后的所有内容都视为注释，不论是什么都不会执行；
- 多行注释，用三个单引号'''或三个双引号"""将注释到内容包围起来。
以下代码同时包含有这两种注释：
"""
该程序段的功能是：
判断变量a是奇数还是偶数
"""
# 要求用户输入一个整数
a = int(input('输入一个整数：'))
# 对变量 a 进行判断
if a % 2 == 0:
# 如果 a 对 2 取余值为 0，则输出偶数
print('偶数')
else:
print('奇数') # 如果 a % 2 不等于 0， 则输出偶数
# print('结束') # 此行为注释语句，不会执行
注：为了保证代码的可读性，#后面建议先添加一个空格，然后再编写相应的说明文字
2. 变量
变量是存放数据值的容器，简单点说，就是在程序运行时，记录数据用的。
2.1. 变量的定义方式
变量名称 = 变量的值
等号 "=" 在这里的意义，与数学里面的 "=" 不同，在这里是赋值运算符的意思，即将等号右侧的值，赋予左侧的变量名。
从形式上看，每个变量都拥有独一无二的名字，例如
a = 1 # a 为变量名，1为变量值。
从底层看，程序中的数据都要放在内存中，变量就是这块内存的名字。
Python 允许您在一行中为多个变量赋值：
# 一行声明多个变量
x, y, z = 'a', 1, '23'
# 打印结果
print('x的值是' + x)
print('y的值是' + y)
print('z的值是' + z)
2.2. 变量命名规则
Python 变量命名规则有以下几种：
- 变量名必须以字母或下划线字符开头
- 变量名称不能以数字开头
- 变量名只能包含字母数字字符和下划线（A-z、0-9 和 _）
- 变量名称区分大小写（age、Age 和 AGE 是三个不同的变量）
Python 有三种常用的命名方法：
下划线命名法
逻辑断点（单词）用的是下划线隔开，例如：
lihua_name = '梨花' ruhua_name = '如花'小驼峰命名法
除第一个单词之外，其他单词首字母大写，例如：
lihuaName = '梨花' ruhuaName = '如花'大驼峰命名法
相比小驼峰法，大驼峰法（即帕斯卡命名法）把第一个单词的首字母也大写了。常用于类名, 例如:
class Animal()
2.3. 变量名称不可使用关键字
Python中有一系列单词，称之为关键字。关键字在Python中都有特定用途，因此，我们不可以使用它们作为标识符。
3. Python 输入/输出
对于所有的程序，输入和输出是用户与程序进行交互的主要途径，也是 Python 中的内置函数（函数的概念，我们等到后面再讲）。通过输入程序能够获取程序运行所需的原始数据，通过输出程序能够将数据的处理结果输出，让用户了解运行结果。
3.1. 输出函数 print()
在前面的内容中，我们一直都在使用输出函数 print()，我们也知道，Python 程序如果需要输出，就必须调用 print() 函数，基本形式如下：
print(value, ..., sep='', end='\n')
其中参数的意义如下：
- value 是用户要输出的信息，后面的省略号表示可以有多个要输出的信息；
- sep 是多个要输出信息之间的分隔符，其默认值为一个空格；
- end 是一个 print() 函数中所有要输出信息之后添加的符号，默认值为换行符。
还记得我们之前写的第一行代码吗？只有一句 print('你好，PyCharm')
我们也可以写成，以下几种形式：
print('你好'，',', 'PyCharm')
print('你好', 'PyCharm', sep=',')
3.2. 输入函数 input()
Python 程序如果需要输入，就必须调用其 input() 函数，基本形式如下：
input([提示语])
其中的参数是可选的，即可以使用，也可以不使用。参数是用来提供用户输入的提示信息字符串。当用户输入程序所需要的数据时，就会以字符串的形式返回。
但是，我们应该输入存储用户输入的数据呢？这时候就需要用到上一小节学习的变量。
我们把 input()中的内容赋值给一个变量，然后打印即可，如下：
# 输入名字
name = input('请输入你的名字')
# 打印用户输入的值
print(name)
注意：input() 函数获取的数据，都会转换成字符串的格式，因此，当我们输入数字或其他类型数据的时候，需要进行转换。这里你可能有疑问了，什么是字符串？什么是数据类型？请继续往下看。
4. 数值类型
数据类型
在编程中，数据类型是一个重要的概念。
变量可以存储不同类型的数据，并且不同类型可以执行不同的操作。
在这些类别中，Python 默认拥有以下内置数据类型：
| 类型 | 说明 |
|---|---|
| 文本类型 | str |
| 数值类型 | int（整数）, float（浮点数）, complex（复数） |
| 序列类型 | list(列表), tuple(元组) |
| 映射类型 | dict(字典) |
| 集合类型 | set（集合） |
| 布尔类型 | bool(布尔) |
你可以使用 type() 函数获取任何对象的数据类型：
# 整数型 int
var_int = 10
print(type(var_int))
# 浮点型 float
var_float = 1.1
print(type(var_float))
# 文本类型 str
var_str = '你好'
print(type(var_str))
# 列表 list
var_list = [1, 2, '这是啥']
print(type(var_list))
# 元组 tuple
var_tuple = (1, 2, '这是啥')
print(type(var_tuple))
# 字典 dict
var_dict = {'a': 1, 'b': 2, 'c': 3}
print(type(var_dict))
# 集合 set
var_set = {1, 2, '这是啥'}
print(type(var_set))
# 布尔值 bool
var_bool = True
print(type(var_bool))
首先要讲的是数值类型，数值类型包括int（整数）, float（浮点数）, complex（复数）
4.1. int(整型)
整数当然包括正整数，负数和零。Python 中整数还可以以几种不同的进制进行书写。
0+进制标志+数字代表不同进制的数。进制标志有以下几种：
| 进制 | 说明 |
|---|---|
| 八进制整数 | 0o[0O]数字, 例如：0o24, 0O24 |
| 十六进制整数 | 0x[0X]数字, 例如：0x3F, 0X3F |
| 二进制整数 | 0b[0B]数字, 例如：0b101, 0B101 |
| 十进制 | 不带进制标志, 例如：1, 2, 3 |
# 二进制
int_bin = 0b100
print(int_bin, type(int_bin))
# 八进制
int_oct = 0o24
print(int_oct, type(int_oct))
# 十六进制
int_hex = 0x3f
print(int_hex, type(int_hex))
注意：Python 默认会转换为十进制打印。
4.2. float(浮点型)
浮点数就是常用的带小数的数。浮点数的书写除了一般形式(形如 1.23)，还有以下几种表示方法：
| 表示方法 | 示例 |
|---|---|
| 小数部分为 0，可以不写 | 23. |
| 整数部分为 0，可以不写 | .098 |
示例：
# 一般形式
float_1 = 1.23
print(float_1, type(float_1))
# 小数部分为零，省略
float_2 = 23.
print(float_2, type(float_2))
# 整数部分为 0，省略
float_3 = .36
print(float_3, type(float_3))
4.3. 算术运算符
讲完数值类型了，接下来就需要了解一下，数值参与的运算符
| 算术运算符 | 描述 |
|---|---|
| ** | 乘方运算符 |
| * | 乘法 |
| / | 除法 |
| // | 地板除(整除) |
| % | 取余 |
| + | 加法 |
| - | 减法 |
| | | 位或 |
| ^ | 位异或 |
| & | 位与 |
| << | 左移 |
| >> | 右移 |
|,^,&,<<,>>都是位运算符，要依据其二进制形式进行运算。
当同一个算式中含有多个运算符时，Python 会按照优先级进行运算，即先计算优先级高的，后计算优先级低的，同级的运算符则从左向右计算。
运算符优先级从高到低排列如下：
- **
- *，/，%
- +，-
- |，^，&，<<，>>
在同一个算式中，你也可以使用括号()来修改运算符的优先级，即括号内的具有高优先级。因此，你不必强记运算符的优先级，在没有把握的情况下可以使用括号()。
5. 字符串
在前面的内容中，我们已经不止一次的使用过字符串了。字符串主要用于存储和表示文本。Python 中的字符串通常由单引号，双引号，三个单引号或三个双引号包围的一串字符组成。
注意：单引号和双引号都应当是英文字符中的符号。
字符串中的字符可以包含数字，字母，中文字符，特殊符号，以及一些不可见的控制字符，如换行符，制表符等。例如以下都是字符串：
'abd'
'''abc'''
"2fd3.0+"
"""124"""
既然都是字符串，那么这四种表示方法有什么区别与联系呢？
单引号字符串与双引号字符串本质上是相同的。但当字符串内含有单引号时，如果单引号字符串就会导致无法区分字符串内的单引号与字符串标志的单引号，就要使用转移字符串，如果用双引号字符串就可以在字符串中直接书写单引号即可。比如'abc"124"ef'。
三引号字符串可以由多行组成，单引号或双引号字符串则不行，当需要使用大段多行的字符串时就可以使用它。比如：
'''
This is a cat.
This is a dog.
'''
5.1. 字符串运算
在 Python 中字符串是可以使用+，*运算符进行运算的，
+的作用是连接字符串；*就是单个字符串的多次连接，例如：
# 打印 'aaa' 与 '123' 相加的结果
print('aaa' + '123')
# 结果为 'aaa123'
# 打印 'hello' * 4 的结果
print('hello' * 4)
# 结果为 'hello hello hello'
5.2. 转义字符串
刚才我们提到了字符串中的字符可以包含数字，字母，中文字符，特殊符号，以及一些不可见的控制字符，如换行符，制表符等。那么什么是转义字符串呢？
Python中\代表转义，在 Python 中如果要在字符串中包含控制字符或特殊含义的符号，就需要使用转义字符。常见的转义字符如下：
| 转义字符 | 说明 |
|---|---|
| \n | 换行符 |
| \t | 制表符(Tab) |
| \r | 回车（Enter） |
\\ | \字符 |
\' | '单引号 |
\" | "双引号 |
例如：
'abc\n124' # 包含一个换行符的字符串
'abc\'2\'abc' # 字符串中包含一个被单引号引起来的 2
5.3. 原始字符串
在上一小节中提到字符串中可以包含有一些转义字符，但他们都是以\开头，而当字符串中需要\字符时就必须写成\\的形式，如果需要两个\\时，就必须写成\\\\的形式。Python 中有一种解决办法，可以不用写这么多个\字符，那就要使用原始字符串。原始字符串就是在字符串前以 r 或 R 作为标志，如下：
print(r'c:\windows\system')
但是，在原始字符串中存在一个问题，原始字符串的末尾不能以\结尾，如下：
print(r'c:\windows\system\')
5.4. 格式化字符串
在 Python 中，所有字符串中的字符顺序是不可变的，但是在某些情况下，比如输出时，可能又要根据不同的需要修改字符串的内容，这时，可使用 Python 的格式化字符串功能。Python 中有 3 种格式化字符串的方法
- 使用占位符
在 Python 中，可以在字符串中使用以 % 开头的字符，在程序中改变字符串中的内容，常用的格式化字符如下：
| 占位符 | 说明 |
|---|---|
| %c | 格式化字符及ASCII码 |
| %f | 格式化浮点数，可以指定小数点后面的精度，默认是小数点后 6 位 |
| %d | 格式化整数，也比较常用 |
| %o | 格式化无符号八进制数 |
| %s | 字符串的格式化，也是最常用的 |
| %x | 格式化无符号十六进制数，其中的字母小写 |
| %X | 格式化无符号十六进制数，其中的字母大写 |
| %e | 将整数、浮点数转换成科学计数法 |
| %% | 当字符串中存在格式化标志时，需要用 %% 表示一个百分号 |
占位符 %s %c %% 的使用:
# 最常用的占位符
name='小明'
print('%s的使用:')
print('我的名字叫%s！'%(name))
print('我的名字叫%4s！'%(name)) #右对齐
print('我的名字叫%-4s！'%(name)) #左对应
# 由于在python中只有字符串这种类型，使用在这里%c只能表示ASCII码，并不能表示字符
character=56
print('c的使用:')
print('%d在ASCII码中表示字母%c'%(character,character))
# %%
schedule=99
print('%%的使用:')
print('当前下载进度为%d%%！'%(character))
由于在 Python 中只有字符串这种类型，所以在 Python 中 %c 只能表示 ASCII 码，并不能表示字符.
占位符 %d %o %x 的使用：
number=18
print('%d使用十进制为:%d'%(number,number)) #十进制
print('%d使用八进制为:%o'%(number,number)) #八进制
print('%d使用十六进制为:%x'%(number,number)) #十六进制
如果在表示八进制或者十六进制时想显示各进制的前缀时，在%后面加一个 # 就好：
number=200
print('%d使用八进制为:%#o'%(number,number))
print('%d使用十六进制为:%#x'%(number,number))
占位符 %f %e 的使用：
height=143.5
print('我的身高有%f米'%(height)) #默认情况
print('我的身高有%.1f米'%(height)) #小数点保留1位
print('%f使用科学记数法为：%e'%(height,height))
使用 format 方法格式化输出:
不设置指定位置
name = "{}在{}玩了一天的{}" data = name.format("小明", "网吧", "LOL") print(data)设置指定名称
name = "{name}在{Location}玩了一天的{game}" data = name.format(Location="网吧",game="LOL",name="小明") print(data)设置指定位置
name = "{2}在{0}玩了一天的{1}" data = name.format("网吧","LOL","小明",) print(data)注意: 指定位置是从 0 开始算起,而不是 1!
使用 f-string 格式化
f-string是 python3.6 之后版本添加的，称之为字面量格式化字符串，用起来较前两种简单，形式也更简洁name = '小明' place = '网吧' game = 'LOL' print(f'{name}在{place}玩了一天的{game}')
5.5. 字符串处理函数
除了用运算符对字符串进行运算外，Python还提供了很多对字符串操作的函数，其中常用的字符串操作函数如下：
| 字符串操作 | 描述 |
|---|---|
| string.capitalize() | 将字符串的第一个字母大写，其余字母小写 |
| string.count() | 获得字符串中某一子字符串的数目 |
| string.find() | 获得字符串中某一子字符串的起始位置，无则返回-1 |
| string.isalnum() | 检测字符串是否仅包含数字与字母 |
| string.isalpha() | 检测字符串是否仅包含字母 |
| string.isdigit() | 检测字符串是否仅包含数字 |
| string.islower() | 检测字符串是否仅包含字母小写 |
| string.istitle() | 检测字符串中的单词是否首字母大写 |
| string.isupper() | 检测字符串是否仅包含大写字母 |
| string.join() | 拼接字符串 |
| string.lower() | 将字符串全部转换为小写 |
| string.split() | 分割字符串 |
| string.swapcase() | 将字符串中大写字母转换为小写，小写字母转换为大写 |
| string.title() | 将字符串中的单词首字母大写 |
| string.upper() | 将字符串中全部字母转换为大写 |
| len(string) | 获取字符串长度 |
示例代码：
# 声明变量 string_a 并赋值为 'python'
string_a = 'hello, worlD!'
print(string_a)
# 获取 string_a 的长度
print(len(string_a))
# 将 string_a 的首字母大写
new_string_a = string_a.capitalize()
print(new_string_a)
print(string_a)
# 获得字符串中 'o' 的数目
print(string_a.count('o'))
# 获得字符串中 'lo' 的起始位置
print(string_a.find('lo'))
# 将字符串中全部字母转换为大写
string_a_upper = string_a.upper()
print(string_a_upper)
# 检测字符串是否仅包含大写字母
print(string_a.isupper())
print(string_a_upper.isupper())
# 用 ',' 分割字符串, 并用两个新变量来接收
string_1, string_2 = string_a_upper.split(',')
print(string_1, string_2)
6. 列表
列表是最常见的一种数据形式，它可以把大量的数据放在一起，可以对其进行集中处理。不仅可以方便地进行数据处理，还可以减少声明很多变量。
列表是以 [] 包围的数据集合，不同成员间以 , (半角符号)分隔。列表中可以包含任何数据类型，也可包含另一个列表。列表也可以通过序号来访问其中的成员。
列表的创建和基本使用如下：
# 创建一个空列表的两种表达方式
list_a = list()
list_b = []
print(list_a, list_b)
# 创建一个只有一个元素的列表
list_c = [1]
print(list_c)
# 创建一个有三个元素的列表
list_d = [1, 2, 3, 4, 5]
print(list_d)
# 访问列表 list_d 的第三个元素（序号为2）
print(list_d[2])
# 访问列表 list_d 的最后一个元素
print(list_d[-1])
print(list_d(len(list_d)-1))
# 访问列表 list_d 的第 2 到第 4 个元素
print(list_d[1:3])
# 列表支持加法运算
list_ = list_c + list_d
print(list_e)
# 列表也支持乘法运算
list_f = list_c * 3
print(list_f)
# 创建一个包含列表元素的列表
list_g = [1, 2, 3, [2,3,4]]
print(list_g)
# 创建一个二维列表
list_h = [[1,4], [2,5], [3,6]]
print(list_h)
列表的操作函数
| 列表操作 | 描述 |
|---|---|
| list.append(x) | 列表尾部追加成员 x |
| list.count(x) | 返回列表中的参数出现的次数 |
| list.extend(L) | 向列表中追加另一个列表 L |
| list.index(x) | 返回参数 x 在列表中的序号（x 不存在则报错） |
| list.insert(index, object) | 向列表中指定位置(index)插入数据（object） |
| list.pop() | 删除列表中尾部的成员并返回删除的成员 |
| list.remove(x) | 删除列表中的指定成员（有多个则只删除第一个），指定成员不存在则报错 |
| list.reverse() | 将列表中成员的顺序颠倒 |
| list.sort() | 将列表中成员排序（要求其成员可排序，否则报错） |
注意：列表元素的序号从 0 开始计数，即第一个元素的序号为 0。
示例代码：
# 创建一个列表
list_a = [1, 2, 3, 4, 5]
print(list_a)
# 列表尾部追加元素 1
list_a.append(1)
print(list_a)
# 统计 1 在列表中出现的次数
print(list_a.count(1))
# 列表后追加另一个列表所有元素
list_a.extend([3, 'Python'])
print(list_a)
# 元素 2 在列表中首次出现的序号
print(list_a.index(2))
# 在序号 3 处插入元素 0
list_a.insert(3, 0)
print(list_a)
# 返回并删除列表最后一个元素
print(list_a.pop())
# 删除列表中的元素 1（仅删除第一个）
list_a.remove(1)
print(list_a)
# 列表内元素顺序颠倒
list_a.reverse()
print(list_a)
# 对列表元素排序
list_a.sort()
print(list_a)
7. 元组
元组可以看成是一种特殊的列表，与列表不同的元组一旦建立就不能改变。既不能改变其中的数据项，也不能添加和删除数据项。因此，想让一组数据不能被改变就把他们放到一个元组中即可，并且任何企图修改元组的操作都会发生错误的。
元组的基本形式是以括号 () 括起来的数据元素，他可以通过序号来引用其中的元素。
示例代码：
# 创建一个空元组的两种表达方式
tuple_a = ()
tuple_b = tuple()
print(tuple_a, tuple_b)
# 创建只有一个元素的数组, 一定要加逗号, 否则会被认为是一个数值
tuple_c = (1,)
tuple_d = (1)
print(tuple_c)
print(tuple_d)
# 访问元组中第二个元素
tuple_e = (1, 2, 3, 4, 5)
print(tuple_e[1])
# 获取元组长度
print(len(tuple_e))
8. 字典
字典是 Python 中比较特别的一类数据类型, 字典中每个成员是以键(key) : 值(value)对的形式存在。
字典用大括号{}包围, 以键值对的形式声明和存在的数据集合。与列表最大的不同在于字典是无序的，其成员位置只是象征性的，在字典中通过键来访问成员，而不能通过其位置来访问该成员。
示例代码：
# 建立一个空字典的两种方式
dict_a = {}
dict_b = dict()
# 创建一个正常的字典
dict_c = {'a': 1, 'b': 2, 'c': 3}
# 用键名查询对应的值
print(dict_c['a'])
print(dict_c['b'])
print(dict_c['c'])
字典操作函数
| 字典操作 | 描述 |
|---|---|
| dict.clear() | 清空字典 |
| dict.copy() | 复制字典 |
| dict.get(key, [default]) | 获得键 key 对应的值，不存在则返回default |
| dict.items() | 获得由键和值组成的迭代器 |
| dict.keys() | 获得键的迭代器 |
| dict.pop(k) | 删除 k:v键值对 |
| dict.update(dict_1) | 从另一个字典更新成员，不存在则创建，存在则覆盖 |
| dict.values() | 获得值的迭代器 |
| dict.fromkeys(iter, value) | 以列表或元组中给定的键建立字典，默认值为value |
| dict.popitem() | 从键盘中删除任一键值对并返回它 |
| dict.setdefault(k, default) | 若字典中存在 key 值为 k 的，则返回其对应的值；否则，在字典中建立一个k:default字典成员。 |
示例如下：
# 创建一个字典
dict_d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(dict_d)
# 复制字典
dict_e = dict_d.copy()
print(dict_e)
# 获取 'e' 键对应的值
print(dict_d.get('e', '不存在')) # 如果不存在则返回默认值
# print(dict_d['e']) # 如果不存在则报错
# 获取所有的 key
print(dict_d.keys())
# 删除 'a': 1 键值对
dict_d.pop('a')
print(dict_d)
# 使用关键字 del 删除键值对
del dict_e['a']
print(dict_e)
# 更新 'b': 2
dict_d.update({'b': 3})
print(dict_d)
dict_d['b'] = 4
print(dict_d)
# 清空字典
dict_d.clear()
print(dict_d)
9. 集合
集合是无序，无索引且不重复的集合。在 Python 中，集合用花括号 {} 编写。
| 方法 | 描述 |
|---|---|
| add() | 向集合添加元素。 |
| clear() | 删除集合中的所有元素。 |
| copy() | 返回集合的副本。 |
| difference() | 返回包含两个或更多集合之间差异的集合。 |
| difference_update() | 删除此集合中也包含在另一个指定集合中的项目。 |
| discard() | 删除指定项目。 |
| intersection() | 返回为两个其他集合的交集的集合。 |
| intersection_update() | 删除此集合中不存在于其他指定集合中的项目。 |
| isdisjoint() | 返回两个集合是否有交集。 |
| issubset() | 返回另一个集合是否包含此集合。 |
| issuperset() | 返回此集合是否包含另一个集合。 |
| pop() | 从集合中删除一个元素。 |
| remove() | 删除指定元素。 |
| symmetric_difference() | 返回具有两组集合的对称差集的集合。 |
| symmetric_difference_update() | 插入此集合和另一个集合的对称差集。 |
| union() | 返回包含集合并集的集合。 |
| update() | 用此集合和其他集合的并集来更新集合。 |
示例代码：
# 创建一个空集合, 注意：创建空集合时不能使用 {}，会被认为是字典
set_a = set()
print(set_a)
# 访问集合元素, 这里你会发现，集合中的元素不能重复
set_b = {1, 2, 3, 4, 4}
print(set_b)
# 添加元素
set_b.add(5)
print(set_b)
# 将另一个集合中的内容添加, 即合并两个集合
set_c = {6, 7, 8}
set_b.update(set_c)
set_b.union(set_c)
print(set_b)
# 删除集合中的元素, 注释：如果要删除的项目不存在，则 remove() 将引发错误。
set_b.remove(8)
print(set_b)
# 注释：如果要删除的项目不存在，则 discard() 不会引发错误
set_b.discard(8)
print(set_b)
# 获取集合的长度
print(len(set_b))
10. 内置常量与运算符
在 Python 中，除了以上介绍的各种数据类型和数值运算符外，还有一些常用的内置常量与逻辑运算符，比较运算符
10.1. 常用内置常量
None 的意义即字面意义 '无'，常用来表示没有值的对象。
True(真) 与 False(假)，是 Python中的布尔数据类型，逻辑型数据
Python 中的逻辑假包括 False, None, 0, "", {}, (), []，其余任何值都视为真
print(None, type(None))
10.2. 逻辑运算符
我们在中学时学习过命题的逻辑运算：与、或、非，在计算机科学中，其运算规则也是类似的（基本原理相同，但操作数与返回结果有所不同），Python也不例外。
Python 中逻辑运算符包括与 and，或 or，非 not, is, in。
not 的运算对象只有一个，一般也称为一元运算符，其规则是非假即真。例如：
print(not False)
print(not True)
print(not 1)
print(not 0)
or 或运算符，两个参与运算的对象有一个的逻辑值为真则返回真，两个都为假才返回假。
a = 1
b = 0
print(a or b)
c = False
d = 0
print(c or d)
and 与运算符，与 or 相反，两个参与运算的对象有一个的逻辑值为假则返回假，两个都为真才返回真。
a = 1
b = 0
print(a and b)
c = False
d = 0
print(c and d)
is 与 is not，又称为身份操作符，用于判断左右两侧对象是否为同一对象，相同则返回 True，不同则返回 False。
a = 1
b = 1
print(a is b)
print(a is not b)
in 与 not in，又称为成员操作符，用于判断左侧对象是否存在与右侧对象中。
# 判断字符串中是否存在某个字符
a = 'a'
b = 'abcd'
print(a in b)
# 判断列表，元组，集合中是否存在某个元素
c = 1
d = [1, 3, 5, 3]
print(c in d)
# 判断字典的键中是否存在某个元素
e = 'a'
f = {'a': 1, 'b': 2, 'c': 3}
print(e in f)
10.3. 比较运算符
| 运算符 | 意义 |
|---|---|
| == | 相等 |
| > | 大于 |
| >= | 大于等于 |
| < | 小于 |
| <= | 小于等于 |
| != | 不等于 |
这些运算符的意义与数学上相同，而且，Python 允许连续使用这些比较运算符，表示两个比较运算都成立结果才为真。
print(1 < 2)
print(1 < 2 < 3)
# 字符也是可以比较大小的，比较依据是ascii码
print('a' < 'b' < 'c')