序列：列表和元组

列表list

• 列表中可以存储异构数据

• 访问列表中的元素可以采用元素索引(位置号码)

• 确定列表的长度 len

• python中可以支持从列表末尾开始访问元素
• c[-1] 代表访问列表中的最后一个元素

• 索引必须是整数或者整数表达式

• 列表可变
• 注意python的字符串和元组序列是不可变的

• 列表是动态增长的

• 使用+连接列表
• 使用python内置函数 enumerate 访问元素索引和值
• +操作符的序列操作数必须具有相同的类型
• 如果是列表加上字符串，那么列表中的每个元素是一个字符

• 比较操作符
• 从左到右逐个元素地比较整个列表
• 然后再比较数量

元组

• 将一个元组增加到一个列表中

• 序列解包
• 使用内置函数 enumerate 安全的访问索引和值
• 这个函数接收一个可迭代变量，并创建一个迭代器
• 该函数返回一个包含元素索引和值的元组
• tuple和list

• 序列切片

第三章节

语法

参数说明

• sub：要查找的子字符串。

• start：可选参数，查找的起始位置，默认为字符串的起始位置。

• end：可选参数，查找的结束位置，默认为字符串的末尾。

返回值

• 如果找到子字符串，返回其在原字符串中第一次出现的起始位置索引。

• 如果找不到子字符串，返回 -1。

示例代码

应用场景

1. 子字符串查找：在较长的字符串中快速定位子字符串的位置。

2. 输入验证：检查输入的字符串是否包含特定的子字符串。

• 如果list1 = [1, 2, 3, 4, 5, 4, 3, 2, 1]，那么以下那个是list1[:-1]？
在 Python 中，列表的切片操作可以让你基于索引获取列表的一部分。表达式 list1[:-1] 是一个使用负数索引的切片操作，它的意义是获取从列表开始到倒数第一个元素之前的所有元素。
对于你给定的列表：
使用切片 list1[:-1] 的操作解释如下：
• : 表示从列表的开始处开始切片。
• 1 代表列表中倒数第一个元素的位置（不包含该位置）。
因此，list1[:-1] 会返回从列表第一个元素开始到最后一个元素之前的所有元素，即它不包括列表中的最后一个元素。
所以，list1[:-1] 的结果是：
这是因为切片操作不包括结束索引指定的元素，这里的 -1 索引指的是列表中最后一个元素 1 的位置，但由于结束索引是不包含的，所以结果中不会有这个 1。

• 列表可以用find()函数来搜索数据是否在列表中。
这个说法是错误的。在 Python 中，find() 函数并不用于列表，而是用于字符串，用来查找子字符串在字符串中的位置。如果你想检查某个元素是否存在于列表中，你应该使用 in 关键字。例如：
这段代码会检查变量 element 的值是否在 my_list 列表中，并根据结果打印相应的信息。

• "12 "*3==" ".join(["12","12","12"]) 的输出False
这个表达式 "12 "*3 == " ".join(["12", "12", "12"]) 的结果为 True 的原因可以从两边的字符串生成方式来理解：
1. 左边的 "12 "*3：这部分是将字符串 "12 " 重复三次。因此，重复的结果是 "12 12 12 "。注意，在每个 "12" 后都有一个空格，包括最后一个 "12" 之后也有空格。
2. 右边的 " ".join(["12", "12", "12"])：这部分是将列表 ["12", "12", "12"] 中的字符串用一个空格 " " 连接起来。join 方法在每对字符串之间插入一个空格，结果是 "12 12 12"，注意这里末尾没有空格。

• 字符串和列表都是序列类型。

• 可以通过[]来访问字符串的某个字符，也可以将它修改成其他字符。
这是错误的，
在 Python 中，字符串是不可变的（immutable）。这意味着一旦一个字符串被创建，你不能修改其内部的字符。尽管你可以使用索引 [] 来访问字符串中的特定字符，但你不能通过索引直接修改字符串中的字符。

为什么不可以修改字符串中的字符

不可变性设计有几个原因：
1. 安全性：不可变对象因为不能被修改，所以更加安全，可以防止数据被意外改变。
2. 线程安全：在多线程环境中，不可变对象可以自由地在多个线程之间共享，而不需要进行额外的同步。
3. 优化：不可变对象可以使 Python 内部优化更加有效，例如通过使用字符串常量池来节省内存。

尝试修改字符串的例子

假设你有一个字符串 s = "hello" 并且试图修改第一个字符：
这将导致 Python 抛出一个 TypeError，因为字符串对象不支持赋值。

如何“修改”字符串

由于直接修改字符串是不允许的，你通常需要通过创建一个新的字符串来达到“修改”的效果。可以通过切片和连接来组合新的字符串：
在这个例子中，我们没有修改原始字符串 s，而是创建了一个新的字符串 "Hello" 并重新赋值给变量 s。
这种不可变的特性是 Python 字符串操作的一个基本方面，需要在进行字符串处理时始终记住这一点。

• 字符串对象和元组对象是不可变对象，列表对象为可变对象。
这是正确的，
这个描述是正确的。在 Python 中，不可变对象和可变对象的区别主要体现在对象的内容是否可以在其生命周期内被改变。下面是对这三种对象的详细解释：
1. 字符串对象（不可变）： 字符串在 Python 中是不可变的。这意味着一旦创建了一个字符串，就不能修改它。如果尝试改变字符串的内容，如尝试更改字符串中的某个字符，将会引发错误。这种设计可以使得字符串操作具有较高的效率和安全性。例如：
2. 元组对象（不可变）： 元组也是不可变的。一旦创建了元组，就不能修改其内容。这包括不能添加或删除元素，也不能修改元素的值（如果元素本身是可变的，如列表，那么可以修改这个列表的内容，但不能改变元组中列表的身份）。不可变性使得元组在多线程环境中使用时更安全，且可以作为字典的键使用。例如：
3. 列表对象（可变）： 列表是可变的。这意味着你可以在列表创建后添加、删除或修改其内容。列表的可变性提供了极大的灵活性，但也意味着在某些情况下它们不是线程安全的，不能用作字典的键。例如：
因此，字符串和元组的不可变性以及列表的可变性是根据它们的设计来提供不同的功能和安全性级别。

• "34" in "1234"==True 是错误的
在 Python 中，表达式 "34" in "1234"==True 的解析可能不是直观的，因为它涉及到运算符的优先级问题。

运算符优先级

在 Python 中，关系运算符（如 ==、!=、<、>）的优先级高于成员测试运算符 in。因此，表达式 "34" in "1234"==True 实际上被解释为：

解析表达式

1. "1234" == True：首先比较字符串 "1234" 是否等于 True。由于 "1234" 是一个字符串，而 True 是一个布尔值，它们不相等，因此结果是 False。
2. "34" in False：接下来，Python 会尝试判断字符串 "34" 是否在 False 中。但是，False 并不是一个可迭代的对象，所以这会导致一个 TypeError（如果真的尝试执行的话）。

正确的表达方式

为了正确评估 "34" 是否是 "1234" 的子字符串，并将结果与 True 比较，你应该使用括号明确表达式的意图：
这样，Python 首先检查 "34" 是否为 "1234" 的子字符串，这是 True。然后，比较这个 True 结果与 True 是否相等，这自然也是 True。
在实际编程中，通常不需要将结果与 True 进行比较，因为 "34" in "1234" 已经是一个布尔表达式，直接返回 True 或 False。你可以简单地写作：
这个表达式足够清晰，直接返回 True。
关系运算符的优先级更高

• 语句print("输出结果是{:8d}".format(1234))的输出是：输出结果是 1234□□□□。 □表示空格。
是错误的，语句 print("输出结果是{:8d}".format(1234)) 的设计是为了将整数 1234 格式化为宽度为 8 个字符的字符串，其中 {:8d} 表示数字应该在总宽度为 8 个字符的字段中右对齐显示。因此，数字左侧将填充空格，直到字符串长度达到 8 个字符。
在这个例子中，数字 1234 本身占用 4 个字符，所以左侧将添加 4 个空格来填充，使总宽度达到 8 个字符。因此，输出应该是四个空格后跟 1234。
如果输出是 输出结果是 1234□□□□，这意味着数字后面有四个空格，这与 {:8d} 的格式化操作（它指示数字右对齐）不符。正常情况下，空格应该在数字前面，而不是后面。正确的输出应该是 输出结果是 1234，其中 表示四个空格。
这里的描述错误可能是因为对格式化字符串的理解有误，即误认为数字后应该有空格而非数字前。

• 语句print("输出结果是{:8s}".format("this"))的输出是：输出结果是 □□□□this。□表示空格。
这个是错误的，语句 print("输出结果是{:8s}".format("this")) 的设计是用来将字符串 "this" 格式化到一个宽度为 8 个字符的字段中，其中 {:8s} 表示字符串应该在总宽度为 8 个字符的字段中左对齐显示。因此，字符串 "this" 会首先出现，然后在其后面填充空格，直到总长度达到 8 个字符。
字符串 "this" 本身占用 4 个字符，所以需要在其右侧添加 4 个空格来达到 8 个字符的宽度。正确的输出应该是 "this" 后跟四个空格，即：
如果输出是 输出结果是 □□□□this，则表示空格在 "this" 的前面，这与 {:8s} 的格式化操作（它指示字符串左对齐）不符。在这种情况下，空格应该在字符串 "this" 的后面，而不是前面。因此，上述描述是错误的。
🦄
字符串是默认左对齐的，而数字是默认右对齐的

• 易错题

• 需要计算空格

• 这道题目很有价值，注意是补0，然后右对齐

• 易错点，c.lower是一个函数，c.lower()是一个字符

• 注意空格

• 下面的程序当输入是 c d e a时，输出是 a c d e。

1. a.sort() 方法的使用：
• .sort() 方法是对列表 a 进行就地排序，即它会直接修改列表 a，而不返回任何值（其返回值是 None）。
• 在循环 for i in a.sort(): 中，由于 a.sort() 没有返回值，相当于在尝试遍历 None，这会导致程序抛出错误。

2. 正确的循环遍历方式：
• 如果想要排序后遍历列表，应该单独调用 .sort() 方法对列表进行排序，然后再遍历已排序的列表，如下：

3. 另一种方法：
• 使用 sorted() 函数可以直接在 for 循环中使用，因为它返回一个新的排序列表，而不是在原地修改：

• 列表lst=[12, -5, -22, -10, -26, 35, 0, 49, 3, -21],lst[100]的结果是运行错误。这个是正确的
这个说法是正确的。
在 Python 中，当你尝试访问列表中不存在的索引时，Python 会抛出一个 IndexError。列表的索引从 0 开始，直到列表长度减一（len(lst) - 1）。如果访问的索引超出这个范围，即表示你正在尝试访问列表不存在的位置。
对于给定的列表 lst：
这个列表有 10 个元素，有效的索引范围是从 0 到 9。当你尝试访问 lst[100]，索引 100 明显超出了列表的索引范围，因此 Python 会抛出 IndexError。

示例

尝试以下代码会导致运行时错误：
这将抛出一个错误消息，如：
这说明你的访问越界了。这个机制防止了程序意外访问内存中未被该列表分配的部分，是一种保护程序安全性和稳定性的措施。

• 列表lst=[12, -5, -22, -10, -26, 35, 0, 49, 3, -21],lst[100:]的结果是[]。这个是正确的
这个说法是正确的。
在 Python 中，当你使用切片操作访问列表，并且切片的起始索引超过了列表的实际长度时，结果将返回一个空列表 []。这是因为切片操作在处理越界的起始索引时是容错的，不会抛出 IndexError，与直接通过单个索引访问列表的行为不同。
对于给定的列表 lst：
尝试访问 lst[100:] 实际上是尝试获取从索引 100 开始到列表结束的所有元素。由于索引 100 超出了列表的长度（此列表的有效索引是 0 到 9），切片操作会返回一个空列表 []。

切片操作的灵活性

Python 的切片操作非常灵活，允许指定超出实际索引范围的值，而不会引起错误。这使得切片操作在很多情况下更加便利和安全。例如：
这种行为使得你不需要在使用切片之前检查索引是否有效，从而简化了代码。在编写处理不同长度数据的函数时，这种特性尤其有用。



这个会把所有的元素列举出来
其实，表达式 lst[0:100] 在 Python 中并不是错误的。在 Python 中，当你使用切片操作访问列表时，如果指定的结束索引超过了列表的实际长度，Python 不会抛出错误，而是简单地返回从开始索引到列表末尾的所有元素。
在你给出的例子中，列表 lst 包含10个元素，索引从0到9。当你执行 lst[0:100] 时，尽管100远远超出了列表的最大索引，Python 会处理这种情况，只返回列表中存在的所有元素，从索引0开始到列表结束。
因此，lst[0:100] 的结果是整个列表：
这是 Python 列表切片的一个特性，它可以让代码更加简洁和健壮，因为你不需要事先检查索引是否超出了列表的长度。

• shuffle是random中的一个函数
这个说法是错误的，原因是 shuffle() 确实是 random 模块中的一个函数。

解释

在 Python 的标准库中，random.shuffle() 函数用来将列表中的元素顺序随机打乱。这是 random 模块提供的一种方法，用于原地重排序列的元素，因此不返回任何值（返回 None），而是直接修改传入的列表。

示例使用 random.shuffle()

以下是如何使用 random.shuffle() 来打乱列表中元素的一个例子：
每次执行这段代码时，列表 lst 中的元素顺序都会被随机打乱，展示了 shuffle() 方法的作用和效果。

总结

因此，random.shuffle() 是 random 模块的有效函数，用于打乱列表中元素的顺序。这个功能在很多情况下非常有用，例如在创建随机数据集或游戏中洗牌时。

• print(sum((1,3,5,7,9))/len((1,3,5,7,9)))的输出是5.0
一定要注意这个坑点！
除法/，拥有小数位置，所以是5.0，不是5！

• 一道什么有用的题目



在 Python 中，字符串的 strip(), rstrip(), 和 lstrip() 函数用来移除字符串中的特定字符。默认情况下，这些函数移除字符串的开头和结尾的空白字符，但是也可以指定其他字符来移除。下面是这三个函数的具体作用和区别：
1. strip() - 移除字符串两端的指定字符（默认为空白字符）。
2. rstrip() - 仅移除字符串右侧末尾的指定字符。
3. lstrip() - 仅移除字符串左侧开头的指定字符。
对于给定的表达式：
这里的字符串 "□□□xyz□□" 含有特殊字符 □，我们分析每个函数的行为：

分析和输出

• "□□□xyz□□".strip()：因为没有指定要移除的字符，默认情况下 strip() 移除空白字符。由于字符串中并没有空白字符，因此 strip() 在这种用法中不会改变字符串，返回 "□□□xyz□□"。
• "□□□xyz□□".rstrip()：同样，rstrip() 也是默认移除空白字符。因为没有空白字符在字符串的末尾，它同样不会改变字符串，返回 "□□□xyz□□"。
• "□□□xyz□□".lstrip()：lstrip() 默认移除左侧的空白字符。没有空白字符在字符串的开头，它也不会改变字符串，返回 "□□□xyz□□"。

修正用法

如果你的目的是移除 □ 这个特殊字符，你需要在调用这些函数时明确指定这个字符：
这时的输出将是：
• strip("□")：从两端移除所有的 □，输出 "xyz".
• rstrip("□")：从右端移除所有的 □，输出 "□□□xyz".
• lstrip("□")：从左端移除所有的 □，输出 "xyz□□".
这些函数非常有用于处理从外部来源如文件或网络获取的数据时，清理不需要的字符。
也是一道比较有启发性的题目



在上述 Python 程序中，我们可以逐行分析每个语句以及对应的输出：
1. a = [1, 2, 3, 4]
• 这行代码创建了一个包含四个元素的列表 [1, 2, 3, 4] 并将其赋值给变量 a。
2. b = a
• 这行代码将变量 b 指向变量 a 指向的同一个列表对象。因此，a 和 b 指向的是内存中的同一个对象。
3. print(id(a) == id(b))
• id() 函数返回对象的唯一标识符，用于判断两个变量是否指向同一对象。由于 b 被赋值为 a，两者指向同一个列表，因此 id(a) 等于 id(b)，这个表达式的值为 True。
4. c = a.copy()
• 这行代码使用 .copy() 方法创建了列表 a 的一个浅拷贝，并将其赋值给变量 c。这意味着 c 是一个新的列表对象，其内容与 a 相同，但它们在内存中是两个独立的对象。
5. print(id(a) == id(c))
• 由于 c 是 a 的一个拷贝，它们是不同的对象，因此 id(a) 不等于 id(c)，这个表达式的值为 False。
6. d = a[:]
• 这行代码使用切片操作 [:] 创建了列表 a 的一个新拷贝，并将其赋值给变量 d。这个操作同样创建了一个新的列表对象，其内容与 a 相同，但它们是两个不同的对象。
7. print(id(a) == id(d))
• 与 c 类似，d 是通过切片方式从 a 创建的一个新的列表，因此 id(a) 不等于 id(d)，这个表达式的值也为 False。
综上所述，程序的输出依次是：
因此直接赋值是指向同一个对象，.copy()和切片[:]操作都是通过切片的方式来进行拷贝

第二章节

• 虚部的后缀可以大写J

• chr函数，可以将数值转换为字母

• \0 是作为一个字符进行存储的，并不会标志字符串的结束

关于 Python 字符串的说法

• A. 字符即长度为 1 的字符串
• 正确：在 Python 中没有专门的字符类型。字符就是长度为 1 的字符串，例如 'a' 或 "b"。

• B. 字符串以 \\0 标志字符串的结束
• 错误：Python 的字符串并不使用 \\0（空字符）作为字符串的结束标志。在 Python 中，字符串的长度是直接存储的，并且可以包含任何字符，包括空字符 \\0 本身。空字符不会标志字符串的结束，而只是字符串中的一个普通字符。

• C. 既可以用单引号，也可以用双引号创建字符串
• 正确：在 Python 中，字符串可以用单引号 '...' 或双引号 "..." 创建。例如，'hello' 和 "hello" 都是合法的字符串。

• D. 在三引号字符串中可以包含换行、回车等特殊字符
• 正确：三引号（''' 或 """）字符串可以跨多行，并包含换行符 \\n、回车符 \\r 等特殊字符。例如：

为什么选项 B 是错误的

• 浮点数做//整除操作，最后的结果仍然还是浮点数





列表的 insert 方法是 Python 中的一个非常有用的功能，它允许你在列表的指定位置插入一个元素。使用这个方法可以动态地修改列表的内容，而不仅仅是在列表的末尾添加元素。这是 insert 方法的基本用法和一些特性：

基本语法

insert 方法的基本语法如下：
• index：这是你希望插入元素的位置的索引。列表的索引从 0 开始。如果指定的索引超过了列表的当前长度，元素将被添加到列表的末尾。
• element：这是你希望插入到列表中的对象。

使用示例

假设我们有一个初始列表如下：
如果我们想在索引为 2 的位置插入数字 3，我们可以这样做：
现在 my_list 将变为：

特性和注意事项

1. 负索引：
• 你也可以使用负数索引，这将从列表的末尾开始计数。例如，my_list.insert(-1, 'a') 将在倒数第二个元素前插入 'a'。
2. 插入任何类型：
• insert 方法不限于插入数字，你可以插入任何类型的对象，包括字符串、列表、字典甚至是另一个列表。
3. 性能考虑：
• insert 在列表中间插入元素时需要移动插入点之后的所有元素，这可能导致较大的性能开销，尤其是在大型列表中。如果需要频繁插入，可能需要考虑其他数据结构，如链表。
4. 插入到末尾或开头：
• 虽然可以使用 insert 在列表的开头或末尾插入元素（例如，my_list.insert(0, x) 或 my_list.insert(len(my_list), x)），但推荐使用专门的方法，如 append() 和 insert(0, x)，因为它们的意图更明确。
这些是 insert 方法的基础知识和一些高级用法。这个方法为列表操作提供了很大的灵活性，是 Python 编程中常用的一个工具。

1. 7 & 5 的结果是 1
• & 是位与运算符。它对数字的二进制表示进行逐位与操作。
• 首先，看看 7 和 5 的二进制表示。Python 中负数使用补码形式表示：
• 5 的二进制是 000...0101 (在32位或64位系统中前面的零比较多)
• 7 的二进制补码是 111...1001
• 逐位与操作的结果是 000...0001，即十进制中的 1。

2. 7 | 9 的结果是 7
• | 是位或运算符。它对数字的二进制表示进行逐位或操作。
• 9 的二进制是 000...1001。
• 7 的二进制补码是 111...1001。
• 逐位或操作的结果是 111...1001，即 7。

3. 7 ^ 9 的结果是 16
• ^ 是位异或运算符。它对数字的二进制表示进行逐位异或操作。
• 9 的二进制是 000...1001。
• 7 的二进制补码是 111...1001。
• 逐位异或操作的结果是 111...0000，即十进制中的 16。

4. ~9 的结果是 10
• ~ 是位取反运算符。它对数字的二进制表示进行逐位取反操作。
• 9 的二进制是 000...1001。
• 取反后的结果是 111...0110，即十进制中的 10。

• 注意坑题！！！

解释 ++i 在 Python 中的行为：

如何正确增加变量的值：

回到原问题：

• 汉字张的unicode编码是 \u5f20

1. 直接使用 Unicode 字符串：

2. 使用字符的 Unicode 名称：

3. 从编码获取字符：

• 显然是错误的

错误分析

• int('a', b) 的问题： 这行代码尝试将字符串 'a' 解析为以 b 为进制的整数。然而，这里的 'a' 被误用为字面量字符串 'a'，而不是变量 a 的值。在 Python 中，字符串 'a' 在大多数进制下都不是一个有效的数值（除非进制大于10，并且a表示10）。正确的做法应该是使用变量 a 而不是字符串 'a'。

修正代码

验证

• "45" 是一个 8 进制的数。

• 按 8 进制解析，"45" 等于十进制的 37（4\*8 + 5 = 37）。

• 因此，此修正后的代码将正确输出 37。

• 字母A的ASCII编码值和Unicode编码值相同。 正确的
是的，ASCII编码和Unicode编码在特定的范围内是相同的，包括字母A。ASCII（American Standard Code for Information Interchange）是一种用于表示文本字符的标准编码系统，它使用7位二进制数字（0到127）来表示128个字符，包括字母、数字、标点符号和一些控制字符。
Unicode是一种更加全面的字符编码标准，它为世界上几乎所有的字符集提供了唯一的数字标识。Unicode编码使用16位、32位甚至更多位的二进制数字来表示字符，其中ASCII字符集是Unicode的一部分，从0到127的范围内，ASCII字符的Unicode编码与ASCII编码是相同的。因此，字母A的ASCII编码值（65）和Unicode编码值相同。

• 表达式 -2**4 等于16

• 输入浮点数，只能使用浮点数进行类型的转换，字符串直接用int会报错

• 这样的输出是错误的，因为第二个 print 语句试图使用变量 m 作为字段宽度的动态值，但这样做是不正确的，因为格式化字符串中的字段宽度必须是一个常量表达式，而不是一个变量。Python 的 format 方法不支持直接在格式化字符串中使用变量来指定字段宽度。

• 算术运算符的优先级会小于比较运算符
因此会先进行算术运算，然后再进行逻辑判断

• 变量赋值id会变化

1. 最初 x=3时,Python会为整数3创建一个对象,假设其内存地址为1000,id(x)会返回1000。

2. 执行 x=7 后,Python会为新的整数7创建一个新的对象,假设其内存地址为2000。然后让变量x指向这个新对象。

3. 因此,在执行x=7之后,id(x)会返回2000,与原来不同。

• 注意短路，结果是0！

• z已赋值，x=(y=z+1)语句是错误语句

1. 计算 z + 1 的结果。

2. 将这个结果赋值给 y（此时 y 获得了新值）。

3. 因为赋值操作本身不返回任何值（在Python的普通赋值语句中），所以 (y = z + 1) 这部分表达式的值实际上是 None（在Python中，赋值表达式在顶层上下文中不产生任何值，但如果在某些表达式上下文中，如列表推导式或生成器表达式，它们会返回被赋的值）。

4. 接下来，Python尝试将这个 None 值赋给 x，这本身在语法上是允许的，但可能不是你想要的结果。

• 表达式((2>=2) or (2<2)) and 2的值为多少？
表达式 ((2>=2) or (2<2)) and 2 的值为 2。
让我们来分解计算这个表达式:
1. 2>=2 计算结果为 True (2 等于 2)
2. 2<2 计算结果为 False (2 不小于 2)
3. (2>=2) or (2<2) 根据或运算的短路规则,只要有一个为 True,整个结果就为 True。这里 2>=2 为 True,所以 (2>=2) or (2<2) 的结果为 True。
4. True and 2 根据与运算的规则,如果左操作数为 True,则返回右操作数的值。所以 True and 2 的结果就是 2。
因此,整个表达式 ((2>=2) or (2<2)) and 2 的值为 2。
解释原因如下:
• and 和 or 都是逻辑运算符,它们的运算顺序是:先计算括号内的子表达式,再计算 and,最后计算 or。
• and 和 or 都有短路行为,即一旦能确定最终结果就不再继续计算后面的部分。
• 对于 and 运算,如果左操作数为 False,最终结果就是 False,不再计算右操作数。如果左操作数为 True,则取决于右操作数的真值。
• 对于 or 运算,如果左操作数为 True,最终结果就是 True,不再计算右操作数。如果左操作数为 False,则取决于右操作数的真值。
• 在这个表达式中,(2>=2) or (2<2) 的结果为 True,所以 True and 2 的结果就是 2。
因此,综合这些运算规则,表达式的最终结果就是 2。
比较运算符的优先级高于逻辑运算符。



注意整数可以浮点数比较大小并且相等



注意二分查找，一定是left==right才行
在Python中，字符串的 rfind() 方法用来从右向左查找子字符串在字符串中的最后一次出现的位置，如果找到了子字符串，它返回子字符串最后一次出现的索引（从0开始计数）。如果没有找到子字符串，则返回-1。
这里是如何使用 rfind() 方法的一些细节：

基本使用

• 语法：str.rfind(sub[, start[, end]])
• sub 是要搜索的子字符串。
• start 和 end 是可选的参数，用来指定搜索的开始和结束位置。

示例

假设有一个字符串 s = "hello world"，你可以使用 rfind() 来查找子字符串 "o" 的最后一个出现位置：
这里，"o" 在字符串 "hello world" 中最后一次出现在索引7的位置。

与 find() 的比较

find() 方法也用来查找子字符串的位置，但它从左向右进行搜索，并返回子字符串第一次出现的位置。如果使用 find() 在上面的例子中查找 "o"，结果将是：
这是因为 "o" 第一次出现在索引4的位置。

应用场景

你在代码中使用的 max_index = s.rfind(max_char) 可能是为了找到某个字符（max_char）在字符串 s 中最后一次出现的位置。这在处理字符串时特别有用，例如当你需要从字符串的末尾开始处理或提取特定数据时。
rfind 是能否找对最后一个元素，但是find是找到第一个出现的元素

python 第五章

字典使用 update 来插入和更新键-值对
集合可以遍历，但是不是序列，不支持索引和方括号的切片
集合的重要的一个用途就是去除重复值
集合是没有顺序的
如果需要创建空集合，需要使用带有小括号的set函数，而不是使用空的大括号{}，因为{}表示一个空字典
空集合表示为 set()
集合是可以改变的，能够添加和移除所有元素，但是集合的元素是不可以改变的
 
集合是唯一值构成的无序集，包含不可改变的对象
在Python中，set 和 tuple 是两种不同的数据结构，它们有几个关键的区别和不同点：
1. 可变性：
• set 是可变的，意味着你可以向其中添加、删除或更新元素。
• tuple 是不可变的，一旦创建就不能被修改。
2. 重复元素：
• set 不允许重复元素，如果你试图向一个 set 中添加一个已经存在的元素，它会被忽略。
• tuple 可以包含重复的元素，每个元素在 tuple 中的位置由它的值和其在 tuple 中的索引位置共同决定。
3. 索引访问：
• set 不支持通过索引来访问元素，因为 set 是无序的，其中的元素没有固定的位置。
• tuple 支持通过索引来访问元素，因为 tuple 是有序的，其中的元素按照它们在 tuple 中的顺序存储。
4. 可哈希性：
• set 中的元素必须是可哈希的，因为 set 内部使用哈希表实现。
• tuple 中的元素可以是任意类型，包括不可哈希的类型，因为 tuple 本身是不可变的，它的哈希值由其内容决定。
5. 语法：
• set 使用大括号 {} 来定义，元素之间使用逗号 , 分隔。
• tuple 使用小括号 () 来定义，元素之间使用逗号 , 分隔。
下面是一个简单的示例来展示这些区别：
上述示例展示了set 和 tuple 的区别和不同点：
• set 自动去除重复元素，而 tuple 保留了重复的元素。
• 尝试修改 set 或 tuple 中的元素会引发 TypeError，因为 tuple 是不可变的，而 set 中的元素是不可哈希的。
• tuple 可以通过索引来访问元素，而 set 不支持通过索引访问元素。
• tuple 可以包含不可哈希的元素，而 set 中的元素必须是可哈希的。

join函数的使用方法

join() 函数是一个非常有用的字符串方法，用于将可迭代对象中的元素连接成一个字符串。它是Python标准库中的字符串方法，适用于字符串对象。

基本语法

• str：表示一个字符串分隔符。
• iterable：一个可迭代对象（如列表、元组或字符串）。

功能

join() 方法将 iterable 中的元素用 str 分隔符连接成一个新的字符串。

详细说明和例子

1. 连接列表中的字符串
在这个例子中，separator 是一个空格字符串 " ", 它将 words 列表中的元素连接成一个句子。
2. 连接元组中的字符串
在这个例子中，separator 是一个逗号和空格字符串 ", ", 它将 items 元组中的元素连接成一个字符串。
3. 连接字符串中的字符
在这个例子中，separator 是一个短横线字符串 "-", 它将 letters 字符串中的字符连接成一个新的字符串。
4. 连接生成器中的元素
在这个例子中，separator 是一个竖线和空格字符串 " | ", 它将生成器表达式 numbers 中生成的元素连接成一个字符串。
5. 空字符串连接
在这个例子中，separator 是一个空字符串 "", 它将 words 列表中的元素直接连接在一起，没有任何分隔符。

常见错误

• 非字符串元素
join() 方法要求 iterable 中的所有元素必须是字符串类型。如果 iterable 中包含非字符串元素，将会引发 TypeError。
在这个例子中，items 列表包含一个整数 3，导致 TypeError。所有元素必须是字符串才能使用 join() 方法。

应用场景

• 生成复杂字符串：join() 方法非常适合生成需要特定分隔符的复杂字符串。
• 格式化输出：将列表或元组中的元素格式化为字符串，以便于输出或日志记录。
• 生成CSV格式：将数据列表格式化为逗号分隔值 (CSV) 格式。

进一步示例

从用户输入生成字符串
在这个例子中，从用户输入的逗号分隔字符串生成列表 words，然后用 join() 方法将其格式化为一个逗号和空格分隔的字符串。
通过这些示例和解释，你应该能够理解并有效地使用 join() 方法来处理字符串和可迭代对象。

map函数的使用方法

items() 是 Python 字典 (dict) 的一个方法。它返回一个包含字典所有键值对的视图对象。视图对象是一个动态的视图，它反映字典的实时变化。

用法

返回值

items() 方法返回一个 dict_items 对象，它是一个可迭代的视图对象，其中包含字典中的所有键值对。每个键值对都表示为一个元组 (key, value)。

示例

基本用法

迭代字典的键值对

你可以使用 items() 来迭代字典中的键值对：
输出：

动态视图对象

dict_items 对象是动态的，这意味着如果字典改变，dict_items 对象会反映这些变化：

使用 items() 进行字典合并

可以用 items() 方法来合并两个字典：

典型应用

1. 遍历字典：items() 使得遍历键值对更加方便和直观。
2. 字典合并和更新：通过 items() 可以方便地处理多个字典的数据合并和更新。
3. 调试和展示：使用 items() 可以快速查看字典的内容。

注意事项

• items() 方法返回的视图对象是可迭代的，但不是一个列表或集合，如果需要使用列表或集合的功能，可以将其转换为 list 或 set：
• 视图对象反映字典的实时变化，如果字典在视图创建后被修改，视图对象也会相应更新。
通过这些用法和示例，你可以更好地理解和使用 items() 方法在你的 Python 编程中。
dic.get("张军", None) 是 Python 字典 (dict) 的 get 方法。这个方法用于根据指定的键获取字典中的值。如果该键存在于字典中，返回对应的值；如果该键不存在，则返回一个默认值（这里是 None）。

具体解释

• dic 是一个字典，包含了一些键值对。
• dic.get("张军", None) 尝试获取键 "张军" 对应的值。

语法

• key：要查找的键。
• default_value：如果键不存在时返回的默认值。这个参数是可选的，如果不提供，默认值为 None。

示例解释

给定字典：
执行：
1. "张军" 这个键不存在于字典 dic 中。
2. 因此，dic.get("张军", None) 返回默认值 None。
输出结果为：

使用 get 方法的好处

1. 避免 KeyError：直接使用 dic["张军"] 如果键不存在会抛出 KeyError 异常，而 get 方法则不会。
2. 返回默认值：可以自定义返回的默认值（如示例中的 None），使代码更加灵活。

示例：

1. 键存在时返回对应值：
1. 键不存在时返回默认值：
使用 get 方法可以让你的代码更加健壮和易读，特别是在不确定键是否存在的情况下。
在 Python 中，sort() 和 sorted() 函数都用于排序列表或其他可迭代对象，但它们的使用方式和行为有一些不同。以下是详细介绍：

1. sort() 方法

sort() 是列表对象的一个方法，用于对列表中的元素进行原地排序（即直接修改原列表），不会返回新的列表。它只适用于列表。

使用方法：

参数：

• key：指定一个函数，该函数会作用于列表中的每个元素，并根据该函数的返回值进行排序。默认为 None，表示直接对列表元素进行比较。
• reverse：布尔值。如果为 True，则列表按降序排列。默认为 False。

示例：

2. sorted() 函数

sorted() 是一个内置函数，可以对任意可迭代对象进行排序，并返回一个新的列表，而不修改原对象。

使用方法：

参数：

• iterable：任何可迭代对象，如列表、元组、字符串等。
• key：与 sort() 方法中的 key 参数相同，用于指定排序依据的函数。默认为 None。
• reverse：布尔值。如果为 True，则按降序排序。默认为 False。

示例：

总结

• sort() 方法只能用于列表，并且会原地修改列表。
• sorted() 函数可以用于任何可迭代对象，并返回一个新的列表，不会修改原对象。
选择 sort() 还是 sorted() 取决于具体需求。如果需要对原列表进行排序且不需要保留原顺序，使用 sort() 更为直接。如果需要保留原列表不变并获取一个新的排序结果，则使用 sorted()。
在 Python 的 sort() 方法和 sorted() 函数中，key 参数用于指定一个函数，这个函数会作用于每个元素，并根据该函数的返回值进行排序。这种方式允许我们自定义排序规则，而不仅仅是按元素的默认顺序排序。

key 参数的使用方法

基本语法

或

使用示例

示例 1: 按字符串长度排序

假设我们有一个字符串列表，希望按每个字符串的长度进行排序：
在这个示例中，key=len 表示我们要按字符串的长度排序。

示例 2: 按字典的特定键排序

假设我们有一个字典列表，希望按字典中某个键的值进行排序：
在这个示例中，key=lambda student: student["age"] 表示我们要按字典中 age 键的值进行排序。

示例 3: 复合排序（多个条件）

假设我们有一个元组列表，希望先按第一个元素升序，再按第二个元素降序排序：
在这个示例中，key=lambda x: (x[0], -x[1]) 表示我们要先按元组的第一个元素升序排序，再按第二个元素降序排序。

key 参数的实际应用

• 字符串排序：可以按字母顺序、长度、甚至是某个字符在字符串中的出现次数等进行排序。
• 字典排序：可以按字典的某个或某几个键的值进行排序。
• 复合排序：可以结合多个排序条件，例如按主键排序后再按次键排序。
• 自定义排序规则：通过编写自定义函数，可以实现几乎任何复杂的排序逻辑。

总结

key 参数是一个非常强大的工具，它允许我们在排序时使用自定义的排序规则，而不仅仅依赖于元素的默认顺序。通过结合使用 lambda 表达式或自定义函数，我们可以实现复杂的排序需求。

期末总复习版本

一、高级语言程序的执行方式 高级语言程序要被机器执行，有以下几种常见的执行方式：

解释执行：通过解释器逐行解释并执行源代码。 编译执行：通过编译器将源代码编译成机器代码，然后由计算机执行。 即时编译（JIT）：在运行时将部分或全部代码编译为机器代码，提高执行效率。 虚拟机执行：在虚拟机上运行，通过虚拟机将字节码解释或编译为机器代码。 ---例题：高级语言程序要被机器执行,只有用解释器来解释执行。False

二、变量赋值与内存地址

变量赋值是将一个值存储到一个变量中。 内存地址是计算机内存中的一个位置，每个变量的值都存储在内存中的某个地址上。 当变量被重新赋值时，它会引用一个新的内存地址。 ---例题：已知 x=3, 则执行“ x=7”后，id(x)的返回值与原来没有变化。 False
• 标识符规范：由数字，字母，下划线组成；不能以数字开头；区分大小写；不能使用关键字（标识符不能是 Python 的关键字或保留字，例如 if、for、while 等）
数据结构
• 列表（List）：有序、可变的集合，如 [1, 2, 3]。
• 元组（Tuple）：有序、不可变的集合，如 (1, 2, 3)。
• 字典（Dictionary）：键值对的集合，如 {'key': 'value'}。
• 集合（Set）：无序、唯一元素的集合，如 {1, 2, 3}。 ————————————————

三、python中的进制转换(二进制)

1. 整数部分的进制转换
2. 小数部分的进制转换
🦄
总结来说就是整数部分是逆序顺序，小树部分是顺序顺序
其中字符串需要进行格式化，然后居中处理
🦄
输入5第二个print这里不支持{：^m}在格式化指令中直接使用变量作为字段宽度或其他限制参数的值
布尔运算顺序是先比较运算再逻辑运算，逻辑运算中如果没有括号，优先级默认是not>and>or
🦄
and运算符会返回第一个False的值 and会返回最后一个and的值
typeError只能是一个相应的数据类型
ValueError 可能会是各种各样的错误的
str_list = ["hello", "world"] result = " ".join(str_list) print(result) # 输出 hello world
注意最后没有空格

实部real    虚部imag     共轭复数conjugate

在 Python 中，字符串不以 \0 结束，这是在 C 或 C++ 中的做法

第三章题目

🦄
解释器会将"34" in "1234"==True理解成'34' in '1234' and '1234' == True,因为True视为1，所以 '1234' == True的结果是False，而'34' in '1234'的结果是True，相当于True and False，输出False
其中字符串会默认左对齐
- 正确输出是 `输出结果是this    `（右侧四个空格）。这里格式化字符串 `{8s}` 表示字符串至少有8个字符，（文本默认）左对齐。
- 正确输出是 `输出结果是    1234`（左侧四个空格）。这里格式化字符串 `{8d}` 表示数字至少有8位，（数据默认）右对齐。
🦄
其中会默认字符串是左对齐，整数数字是右对齐
🧘‍♂️
请注意如果出现了0，那么必须要进行补充0的操作 如果没有出现左对齐或者是右对齐的选项，那么程序会自动报错
例子：列表 `lst=[12, -5, -22, -10, -26, 35, 0, 49, 3, -21]` 的切片操作：
其中a.sort()不会返回任何东西
• 内存地质和引用
copy()和[:]操作都是浅拷贝，这种切片操作本质和.copy()是一样的
引用相同对象（如上，都是'hello'或者100） 或者两个变量被赋予同一个对象的引用的时候，内存地址相同
补充说明：a="hello"; b="hello"时a和b的id相等，a=100; b=100时a和b的id也相等，其本质原因是Python中存在的【驻留】现象（intern），满足下面两种情况的对象会被驻留：
①介于[-5, 256]的整数（称为【小整数池驻留】，解释器一启动立即生成小整数池，所以这些较小的整数id一般都比较小）； ②只含有大小写字母、数字和下划线且长度不超过4096字节的字符串（Python 3.7版本及以后，称为【字符串驻留】，只有遇到了或声明了才会被驻留）； 因此在这里100和"hello"分别满足第1和第2个条件，即被驻留，内存中只保存1份这样的整数或字符串对象，其余均为贴标签引用，所以两种情况下都满足id(a)==id(b)
a不是3，因为先运算等号右边，此时t值为1
右边的值都会率先计算出来，然后赋值给左边，不存在立即赋值的情况

在循环中continue语句的作用是（结束本次循环）退出循环的当前迭代  √

分析：第一次移除原索引为3的‘0’ 然后原索引为456分别变为345
刚刚查过3这个索引 接下来查4即查原索引为5的‘0’并移除
后面查不到0了所以总共移除了两个0
故输出应该为2，而不是3。
🧘‍♂️
注：Python 在比较两个不同类型的数值时会进行类型转换，这种转换称为“隐式类型转换”或“类型强制”。在这种情况下，Python 会将整数 x 转换为浮点数（如果需要的话），或者将浮点数 y 转换为整数（如果需要的话），以便进行比较。由于 2 和 2.0 的数值相同

• 集合运算

• 字典合并