Python基础之Python基本构成

【一】注释语法

【1】什么是注释

  • 注释就是就是对代码的解释说明，注释的内容不会被当作代码运行

【2】为什么要注释

  • 增强代码的可读性

【3】如何使用注释

  • 代码注释分单行和多行注释

  • 1、单行注释用#号，可以跟在代码的正上方或者正后方

    # 这是一段通过“# + 注释内容”创造的注释代码

  • 2、多行注释可以用三对双引号""" """

    '''
这是一段通过
“三引号（```）
注释内容1
注释内容2”
创造的多行注释
'''

【4】代码注释的原则

  • 1、不用全部加注释，只需要为自己觉得重要或不好理解的部分加注释即可
  • 2、注释可以用中文或英文，但不要用拼音

【二】常量和变量

【1】常量

（1）什么是常量

  • 常量就是程序运行过程中不变的变量

（2）常量的使用

  • 通常通过大写字母来声明常量，以提醒自己和其他人这个变量的值应该保持不变。

  • 在Python中尽管常量的值是可以修改的，但常量尽可能不要去修改，这样有助于提高程序员在阅读修改代码时，更加方便的理解

  • # 在其他语言中，真正意义上的常量，中间是不能改变的，如果你改变，就报错，但是，在python中，无所谓，你改变也不报错!

# 在JavaScript语言中，就有真正意义的常量，中途不能修改，修改就报错

【2】变量

（1）什么是变量

  • 变量就是程序运行过程中可能会变化的量

（2）为什么要有变量

  • 通过使用变量，程序可以在运行时根据需要存储和修改数据，从而实现动态的状态和行为
  • 变量在程序中扮演着存储和传递信息的角色
    • 程序执行的本质就是一系列状态的变化，变是程序执行的直接体现
    • 所以我们需要有一种机制能够反映或者说是保存下来程序执行时状态，以及状态的变化

（3）变量的定义与调用

1、变量的定义

  • 由 变量名 + “=” + 变量值 三部分组成
  • 变量名相当于门牌号，由此门牌号找到变量值

变量的定义

2、变量的调用

  • 解释器执行到变量定义的代码时会申请内存空间存放变量值
    • 然后将变量值的内存地址绑定给变量名
    • 以变量的定义age=18为例，如下图变量的调用

image-20231127161603364

3、变量的命名规范

  • 原则：变量的命名应该见名知意
  • 变量名只能是 字母、数字或下划线的任意组合
  • 变量名的第一个字符不能是数字
  • 关键字不能声明为变量名，常用关键字如下
['and', 'as', 'assert', 'break', 
'class', 'continue', 'def', 'del', 
'elif', 'else', 'except', 'exec', 
'finally', 'for', 'from','global', 
'if', 'import', 'in', 'is', 'lambda', 
'not', 'or', 'pass', 'print', 
'raise', 'return', 'try', 'while', 
'with', 'yield']
  • 变量名的风格
    1. 驼峰体
      • 大驼峰：每个单词的首字母都大写，其余字母小写
        • AgeOfTony = 56
      • 小驼峰：每个单词的首字母都大写，只有第一个单词的首字母是小写
        • numberOfStudents = 80
    2. 纯小写下划线
      • 所有字母都小写，每个单词之间使用下划线分隔(在python中，变量名的命名推荐使用该风格)
        • age_of_tony = 56
        • number_of_students = 80

4、变量的三大特性

  • （1）id (内存地址 - 内存编号)

    • 反应的是变量在内存中的唯一编号，内存地址不同id肯定不同
    # 可以通过print(id(变量名)) 查看

  • （2）type （数据类型）

    • 变量值的类型
    # 可以通过print(type(变量名)) 查看

  • （3）value （变量值）

    • 变量值

【3】补充-PE8规范

Python注释补充之PE8规范

  • PEP是Python Enhancement Proposal的缩写，代表Python增强提案。其中第8号增强提案（PEP 8）是关于Python代码风格的指南。
  • 每个PEP都是一份技术文档，为Python社区提供指导，促使Python在不断进步。PEP 8着重于统一Python代码的风格，使其更易读、易维护，适用于多人协作开发的场景。

常用的规范标准

  • 【1】空格的使用

    • 使用空格表示缩进，不使用制表符（Tab）。
    • 每一层缩进使用4个空格。
    • 每行字符数不超过79个，多行表达式首行除外，其余行缩进4个空格。
    • 函数和类定义之间使用两个空行分隔，类中方法之间使用一个空行分隔。

    【2】标识符的命名

    • 变量、函数和属性使用小写字母，多个单词用下划线连接。
    • 类中受保护的实例属性以一个下划线开头。
    • 类中私有的实例属性以两个下划线开头。
    • 类和异常的命名每个单词首字母大写。
    • 模块级别的常量使用全大写字母，多个单词用下划线连接。
    • 类的实例方法参数命名为self，类方法参数命名为cls。

    【3】表达式和语句

    • 采用内联形式的否定词，如if a is not b。
    • 避免使用检查长度的方式来判断字符串、列表是否为None或没有元素，应该使用if not x形式。
    • 即使在if分支、for循环、except异常捕获中只有一行代码，也不要将代码和关键字写在一起，分开写更清晰。
    • import语句总是放在文件开头。
    • 引入模块时，from math import sqrt优于import math。
    • 多个import语句分为三部分：Python标准模块、第三方模块和自定义模块，每部分按照字母表顺序排列。

【三】基本数据类型

【1、2】数字类型（int / float）

（1）整数类型（int）

1、作用

  • 整数类型用于表示整数，是一种基本的数字类型，广泛用于表示计数、索引等整数值。

2、定义

# 整数类型的定义是直接赋予一个整数值
int_1 = 18
int_2 = 6
print(type(int_1))   # <class 'int'>
print(type(int_2))   # <class 'int'>

3、使用

  • 数字类型【包含整数类型int和浮点数类型float】可以参与各种数学运算，包括加法、减法、乘法、除法等。

（2）浮点类型（float）

1、作用

  • 浮点类型用于表示带有小数部分的数值，适用于需要更精确表示的情况。

2、定义

# 浮点类型的定义是赋予变量值含小数点的数字
float_1 = 18.0
float_2 = 6.0
print(type(float_1))   # <class 'float'>
print(type(float_2))   # <class 'float'>

3、使用

  • 浮点类型同样可以参与各种数学运算，也可以与整数类型进行混合运算
int_1 = 2
float_1 = 2.5
print(int_1 + float_1)   # 4.5
print(int_1 - float_1)   # -0.5
print(int_1 * float_1)   # 5
print(int_1 / float_1)   # 0.8  除法为反斜杠

（3）数字类型的应用

  1. 数字运算，上述作出了举例，不再叙述

  2. 比较大小

    1. 我们可以使用比较运算符（如<、>、<=、>=）来比较数字的大小，得到布尔类型的结果

    2. a = 5
b = 2
compare_result = a > b

# 结果为True
print(compare_result)  # True
print(type(compare_result))  # <class 'bool'>

【3】字符串类型（str）

（1）作用

  • 字符串类型用于表示文本信息，是一种非常重要的数据类型，用于处理文字、字符等信息

（2）定义

1、定义

  • 字符串可以使用单引号、双引号或三引号进行定义用引号引起来的部分就是对应变量的值(字符串类型)，并且对于变量名的值
    • 用单引号、双引号、多引号，都可以定义字符串
    • 本质上是没有区别的(这些引号定义字符串的方式是等价的)
# 定义方式1：
name_1 = 'str'
# 定义方式2：
name_2 = "str"
# 定义方式3：
name_3 = '''str'''
# 定义方式4：
name_4 = """str"""
  • 通过三引号（单引号或双引号）可以定义多行字符串，方便表示包含换行的文本内容
msg_1 = '''
这是
多行
字符串
'''

2、引号嵌套问题

  • 引号需要成对出现，相同的引号与其对应的引号功能需一致
true_msg = '''这是一个测试的'语句'，
三引号作为定义"字符串（str）"的符号，
'单引号'和"双引号"仅仅只是作为引号来使用'''
# 以下为输出内容
'''
这是一个测试的'语句'，
三引号作为定义"字符串（str）"的符号，
'单引号'和"双引号"仅仅只是作为引号来使用
'''

# 以下为错误示范
false_msg = '这是一个错误的示范，'单引号'作为定义字符串（str）的符号，却错误地用在了"引号"上，并且引号也是可以互相出现的'
# SyntaxError: invalid syntax

（3）使用

1、运算

  • 字符串也是可以进行运算的，不过只有“相加”和“相乘”

    • 相加就是简单的字符串拼接

      str_1 = 'nice'
str_2 = 'day'
print(str_1 + str_2)  # niceday 无空格

    • 相乘就是重复字符串

      str_1 = 'nice'
print(str_1 * 3)   #nicenicenice

2、索引取值

  • 字符串属于序列类型，所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。

    字符串正索引

  • Python 还支持索引值是负数，此类索引是从右向左计数，换句话说，从最后一个元素开始计数，从索引值 -1 开始，如图 所示。

    字符串负索引

  • 字符串解压赋值

    x, y = '12'
print(x)    # 1
print(y)    # 2

3、格式化输出

%输出

  • 使用 % 运算符进行格式化输出，可以在字符串中插入占位符，然后通过 % 运算符传入相应的值

    print("this is a %s day." % 'nice')   # this is a nice day.

  • 补充：%s 和 %d 是占位符，分别表示字符串和整数，%s包含了%d，所以常用%s就可以了

format输出

  • 使用 format 方法进行格式化输出，通过花括号 {} 表示占位符，然后调用 format 方法传入实际值，它会按顺序依次填充传入 format 方法的值

    print("this is a {} day.".format('nice'))   # this is a nice day. 
# 直接输入值
print("this is a {} day. Let's {} !".format('nice','go'))   # this is a nice day. Let's go !
# 多个值，按顺序输入
print("this is a {1} file. Let's {2}.".format(0,'text','go'))
# this is a text file. Let's go.
# 根据索引输入值
print("this is a {a} file. Let's {b}.".format(a='text', b='go'))   # this is a text file. Let's go.
#根据键（key）索引输入
f + {} 输出

  • 通过在字符串前加上 f 或 F 前缀，然后在字符串中使用 {} 表示占位符，并在 {} 中直接引用变量

    str_1 = 'nice'
str_2 = 'go'
print(f"this is a {str_1}. Let's {str_2}.")
# this is a nice. Let's go.
补充：
  • 在字符串中，转义字符用于表示一些特殊字符或执行一些特殊操作，常用的转义字符如下：
转义字符 说明
\n 换行符，将光标位置移到下一行开头。
\r 回车符，将光标位置移到本行开头。
\t 水平制表符，也即 Tab 键，一般相当于四个空格。
\a 蜂鸣器响铃。注意不是喇叭发声，现在的计算机很多都不带蜂鸣器了，所以响铃不一定有效。
\b 退格（Backspace），将光标位置移到前一列。
\ 反斜线
' 单引号
" 双引号
\ 在字符串行尾的续行符，即一行未完，转到下一行继续写。 
# 换行符
print("Hello\nWorld")
# Hello
# World

# 制表符
print("Name\tAge")
# Name    Age

# 反斜线
print("This is a backslash: \\")
# This is a backslash: \

# 单引号
print("I'm a programmer.")
# I'm a programmer.

# 双引号
print("He said, \"Hello.\"")
# He said, "Hello."

# 回车符与退格符
print("One\rTwo\bThree")
# Two Three

【4】列表类型（list）

（1）定义

  • 列表类型就是专门用来记录多个同种属性的值（比如同一个班级多个学生的姓名、同一个人的多个爱好等），并且存取都十分方便
list_1 = [1, 2, 3]  # 可以存放整数类型
list_2 = ['a', 'b', 'c']  # 可以存放字符串类型
list_3 = [1, '2', 3, 'abc']  # 可以存放多种类型
list_4 = [1, 2, 3[4, 5]]  # 可以多层列表嵌套
list_5 = [1, 2, 3, [4, 5],{'a':1,'b':2}]   # 可以嵌套字典

（2）索引

  • 列表类型是用索引来对应值，索引代表的是数据的位置，从0开始计数
list_5 = [1, 2, 3, [4, 5],{'a':'good','b':'cool'}]
# 输出为1
print(list_5[0])
# 输出为5
print(list_5[3][1])
# 输出为good
print(list_5[4]['a'])

（3）切片、截取

  • 冒号左边空，就要从偏移量为0的元素开始取；右边空，就要取到列表的最后一个元素。冒号左边数字对应的元素要拿，右边的不动

  • 示例list1=[1,2,3,'a','b']

    Python 表达式 结果 描述
    list1[1] 2 读取第二个元素
    list1[-2] a 反向读取，读取倒数第二个元素
    list1[1:] [2,3,'a','b'] 截取元素，从第二个开始后的所有元素。
    tlist1[1:3] [2,3] 截取元素，从第二个开始到第四个元素（索引为 3）。

  • 列表也是可以解包赋值的

    list1 = [1,2,3]
x ,y ,z = list1
print(x,y,z)
# 1 2 3

【5】字典类型（dict）

（1）概念

  • 字典类型通过key : value形式来存储数据

    • 其中key可以对value有描述性功能（类似变量名指变量值）

    • 大括号{}括起来，内部可以存放多个元素，元素与元素之间使用逗号隔开，是以 K:V 键值对（成对出现）的形式存储

  • 字典不能通过索引取值，只能通过字典的K取值

（2）实例

dict_1 = {'a': 1 ,'b': 2, 'c':3 }
print(dict_1['a']) # 1
print(dict_1[1])   # KeyError: 1 无法通过索引值来查找

（3）嵌套练习

info = {
    'name': 'Lea4ning',
    'addr': {
        '国家': '中国',
        'info': [666, 999, {'编号': 466722, 'hobby': ['read', 'badminton', 'music']}]
    }
}

# lea4ning
print(info['name'])
# 中国
print(info['addr']['国家'])
# 幸运数字666
print(info['addr']['info'][0])
# 编号
print(info['addr']['info'][2]['编号'])
# badminton
print(info['addr']['info'][2]['hobby'][1])

# Lea4ning
# 中国
# 666
# 466722
# badminton

【6】布尔类型（bool）

（1）概念

  • 布尔类型用于表示逻辑值，只有两个取值：True(真) 和 False(假)。在 Python 中，首字母必须大写。
  • 在编程中，布尔类型经常用于控制程序的流程，例如条件判断、循环等。
  • 布尔值的命名规范：结果可能是布尔值的情况，我们都采用 is 开头 命名

（2）实例

is_true = True
if is_true:
    print('Have a nice day!')
else:
    print('Cheer up!')
# Have a nice day!


is_false = False
if is_false:
    print('Have a nice day!')
else:
    print('Cheer up!')
# Cheer up!

补充

  1. “假”的情况（False）

    • 数字零：数字类型中，整数或浮点数中的零被视为假

      is_false = 0   # 0 or 0.0 均为假
if is_false:
    print('Have a nice day!')
else:
    print('Cheer up!')
# Cheer up!

    • 空字符串：''

      is_false = ''
if is_false:
    print('Have a nice day!')
else:
    print('Cheer up!')
# Cheer up!

    • 空列表、空字典、空集合等：对于容器类型，如果它们为空，则视为假（False）

  2. “真”的情况（True）

    • 非零的数字类型（int/float）
    • 非空字符串' '，此处含一个空格也为真（True）
    • 非空列表、非空字典、非空集合等

【7】元祖类型（tuple）

（1）概念

  • 元组（tuple）是一种不可变的序列类型，类似于列表，用于存储多个有序元素。
  • 元组与列表的主要区别在于元组的元素不能被修改、删除或添加，是不可变的数据类型。
  • 元组通过小括号 () 定义，其中的元素可以是不同的数据类型，用逗号 , 分隔。
  • 可以使用索引访问元组的元素。

（2）使用

1、元组的不可变性

  • 元组是不可变的，不能对元素进行修改、删除或添加。

    tup_1 = (1,2,3)
tup_1[2] = 4
# 此处为修改`tup_1[2]`也就是3的值改为4,因为不可修改，故报错
# TypeError: 'tuple' object does not support item assignment
del tup_1[0]
# 此处为删除`tup_1[0]`也就是1的值，不可修改，故报错
# TypeError: 'tuple' object does not support item assignment

2、元组的基本操作

  • 元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等

    tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')

# 组合

## 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)    # (12, 34.56, 'abc', 'xyz')

  • 截取

    • 冒号左边空，就要从偏移量为0的元素开始取；右边空，就要取到列表的最后一个元素。冒号左边数字对应的元素要拿，右边的不动
    • tup3 =(12, 34.56, 'abc', 'xyz')
Python 表达式 结果 描述
tup3[1] 34.56 读取第二个元素
tup3[-2] abc 反向读取，读取倒数第二个元素
tup3[1:] (34.56, 'abc', 'xyz') 截取元素，从第二个开始后的所有元素。
tup3[1:3] (34.56, 'abc') 截取元素，从第二个开始到第四个元素（索引为 3）。

元组补充

  • 元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：
tup1 = 'lea4ning'
tup2 = ('lea4ning')
tup3 = 'lea4ning' ,
print(type(tup1))   # <class 'str'>
print(type(tup2))   # <class 'str'>
print(type(tup3))   # <class 'tuple'>

  • 元组解包

    tup1 = ('a', 'b', 3, 4, 5)
a, b, c, d, e = tup1
for x in [a, b, c, d, e]:    # for循环，遍历上述几个变量，读取赋值
    print(x)
# a b 3 4 5

【8】集合类型（set）

（1）概念

  • 集合（set）是一个无序的不重复元素序列。

  • 集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。

  • 可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合。

    set1 = {1,2,3,4,5}
set2 = set([1,2,3])
print(set2)    # {1, 2, 3}
print(type(set1))    # <class 'set'>
print(type(set2))    # <class 'set'>

（2）使用

1、基本操作

  • 集合支持基本的操作，如添加元素、删除元素等

    # 添加元素
# 【1】集合.add(添加的内容)    .add只能添加单个元素
set1 = {1,2,3,'a','b'}
set1.add('c',5)
print(set1)    # TypeError: set.add() takes exactly one argument (2 given)
# 【2】集合.update(添加的内容)    .update可以同时添加多个元素
set1 = {1,'a'}
set1.update("b",'c',[2,3],{'e','f'})
print(set1)    # {1, 2, 3, 'b', 'f', 'a', 'e', 'c'}
'''貌似不可以添加数字类型
TypeError: 'int' object is not iterable'''

  • 集合运算，如并集∪，交集∩，差集等

    set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}

# 并集
union_set = set_a.union(set_b)
print(union_set)    # {1, 2, 3, 4, 5, 6}
# 交集
intersection_set = set_a.intersection(set_b)
print(intersection_set)    # {3, 4}
# 差集
difference_set = set_a.difference(set_b)
print(difference_set)    # {1, 2}

  • 集合中的元素是不可重复的，即相同的元素不会重复存储。

set1 = {1,2,3,4}
set1.add(2)
print(set1)    # {1, 2, 3, 4}

【四】Python语句如何与用户交互

【1】什么是与用户交互

  • 交互的本质就是输入、输出
  • 用户交互就是人往计算机中input/输入数据，计算机print/输出结果

【2】输入(input)

  • input函数
    • 用户输入一些内容，用户按下回车键后，input 函数会返回用户输入的内容
    • 并且传输回来的数据均为字符串类型（str）
userName = input('请输入用户名:>>>')

【3】输出(print)

（1）简单字符串

print('内容')

（2）多个变量输出

str1 = 内容打印
print('内容1'，2，str1)
# 输出：内容1 2 内容打印

（3）end参数

  • end 参数用于指定输出的结尾字符，默认为换行符"\n"(代表换行)。
  • 可以替换为任意字符
# 默认为换行
print('nice')
print('nice')
print('nice')
'''
nice
nice
nice
'''

print('nice', end='')
print('nice',end =',')
print('nice',end='!')
# nicenice,nice!
# 第一个将结束字符替换为空，故紧贴着下一个输出的值
# 第二个将结束字符替换为逗号（，）
# 第三个将结束字符替换为感叹号（！）

【五】基本运算符

【1】算数运算符(+；-；*；/等)

  • 加+

  • 减-

  • 乘*

  • 除/

  • 取整//

    • 数字相除，只取整数，舍弃小数点后的内容

      x=4.8
y=6
print(x/y)   # 0.79···

x=4.8
y=6
print(x//y)   # 0.0

  • 求余数%

    x=5
y=2
print(x%y)
# 1
# 5/2 = 2余1，余数为1

  • 幂运算**

    x=2
y=10
print(x**y)
# 1024
# 2的10次方=1024

【2】比较运算符(>;<;>=;<=等)

  • 比较运算用来对两个值进行比较，返回的是布尔值True或False
    1. 相等运算符 = =
      1. 值value相等返回True
      2. 错误返回False
    2. 不等运算符 ! =
      1. 描述正确返回True
      2. 描述错误返回False
    3. 大于运算符 >
    4. 小于运算符 <
    5. 大于等于运算符 > =
    6. 小于等于运算符 < =

【3】赋值运算符(=)

（1）增量赋值

x = 1
y = 2
x += y      # x += y 相当于 x = x+y
print(x)    # 3

（2）链式赋值

x = y = z = 5
print(x,y,z)    
# 输出均为5
# 可以多个 = 号 共同赋值，形似链子

（3）交叉赋值

  • 交叉赋值允许在不使用临时变量的情况下，交换两个变量的值。

    x = 1
y = 2
x, y = y, x
print(x)    # 2
print(y)    # 1

（4）解压赋值

  • 解压赋值允许将一个可迭代对象（如列表、元组等）的值解压到多个变量中，以便进一步使用。

    list1 = [1, 2, 3]
tup1 = ('a', 'b', 'c')
x, y, z = list1
a, b, c = tup1
print(x, y, z)    # 1 2 3
print(a, b, c)   # a b c

  • 注：解压赋值数量必须一致，否则将报错

    # ValueError: too many values to unpack (expected 2)

【4】逻辑运算符(与and或or非not)

  • 逻辑运算符用于连接多个条件，进行关联判断，并返回布尔值 True 或 False。
  • 常用的逻辑运算符包括与（and）、或（or）、非（not）。

（1）与（and）

  • and连接多个条件时，所有条件必须均为True，如果其中有一个为False，则返回布尔值False

    print(1 == 1 and 1 < 2 and 3 > 1)
# True
print(1 > 1 and 1 < 2 and 3 > 1)
# False

（2）或（or）

  • or连接多个条件时，至少有一个条件为True时，返回布尔值True；若多个条件均为False，则返回布尔值False

    print(1 > 1 or 1 < 2 or 3 > 1)
# True

（3）非（not）

  • not用于对一个条件取反，如果条件为True，则返回False；如果条件为False，则返回True

    print(not(1 > 1 or 1 < 2 or 3 > 1))
# False

（4）优先级问题

not>and>or

  1. not的优先级最高，就是把紧跟其后的那个条件结果取反，所以not与紧跟其后的条件不可分割
  2. 如果语句中全部是用and连接，或者全部用or连接，那么按照从左到右的顺序依次计算即可
  3. 如果语句中既有and也有or，那么先用括号把and的左右两个条件给括起来，然后再进行运算
print((3 > 4 and 4 > 3) or (1 == 3 and 'x' == 'x') or 3 > 3)

（5）短路运算

  • 逻辑运算的结果一旦可以确定
  • 那么就以当前处计算到的值作为最终结果返回
1 or 3
1
# 1是真，而or运算中，只要有一个真就可以输出了
1 and 3
3
# and运算中，需要比较所有的条件，最后计算到的为最后一位3
0 and 2 and 1
0
# and运算中，只要有一个假就可以输出结果了，所以是假
0 and 2 or 1
1
# （0 and 2）or 1
# 多个运算符中，需要计算到最后一步跟or比较，所以是最后一位
0 and 2 or 1 or 4
1
# （0 and 2) or 1 or 4
# 此处and运算为假，or运算为真，or运算中只有有一个真就可以输出
0 or False and 1
False
# 0 or （False and 1）
# 先比较and运算，and运算输出为False，再由0与False比较，最后计算到的为False

【5】成员运算符(in;not in)

  • 这两个运算符可以用于字符串、列表、元组等序列类型

  • in

    • 如果在指定的序列中找到值返回 True，否则返回 False。

      list1 = [1, 2, 3]
print(1 in list1)
# True

  • not in

    • 如果在指定的序列中没有找到值返回 True，否则返回 False。

      list1 = [1, 2, 3]
print(1 not in list1)
# False

【6】身份运算符(is;is not)

  • is

    • 如果两个变量引用同一个对象，则返回 True，否则返回 False。

      a = 1
b = a
c = 2
print(a is b)    # True
print(a is c)    # False

  • is not

    • 如果两个变量引用的不是同一个对象，则返回 True，否则返回 False。

      a = 1
b = a
c = 2
print(a is not  b)    # False
print(a is not  c)    # True

  • 这两个运算符主要用于检查对象的标识，即它们是否指向相同的内存地址。

【补充】==与is的区别

  • == 双等号比较的是value是否相等，在同类型之间进行比较
  • is用于比较两个对象的标识id（内存地址）是否相同
  • 在实际应用中，特别是对于可变对象，==通常更适合用于比较值，而is更适合用于比较对象的身份。
  • id相同，内存地址必定相同，意味着type和value必定相同
  • value相同type肯定相同（必须是同类型比较），但id可能不同
x = [1, 2, 3]
y = [1, 2, 3]

print(id(x))    # 1748918684992
print(id(y))    # 1748921904064

print(x is y)    # False
# 当x和y是不可变的量时，指向的内存地址是相同的，如字符串、元组等
print(x == y)    # True
posted @ 2023-12-06 14:44  Lea4ning  阅读(17)  评论(0)  编辑  收藏  举报