1.下列转义字符中， 属于“回车”含义的是
\n 换行\r 回车
2.for循环遍历字典
在Python中，你可以使用for循环来遍历字典的键（keys）、值（values）或者键-值对（items）。下面是三种遍历字典的方法：
遍历字典的键（keys）
my_dict = {'a': 1, 'b': 2, 'c': 3}
for key in my_dict:
print(key)遍历字典的值（values）
my_dict = {'a': 1, 'b': 2, 'c': 3}
for value in my_dict.values():
print(value)遍历字典的键-值对（items）
my_dict = {'a': 1, 'b': 2, 'c': 3}
for key, value in my_dict.items():
print(key, value)3.切片操作
c1="HelloWorld"
print(c1[:5])#指的是从[0,5)
print(c1[5:])#指的是 从[5,end]
print(c1[::5]) #指的是步长是5
4.True==1
print(2==True and 0==False)结果是False 因为2不等于1
5.
print(4>5 and 4 or 5 and 4*3**2 or not 8>6)
在Python中，逻辑运算符（如
and和or）的优先级低于比较运算符（如>），但是它们仍然遵循一定的规则进行求值。同时，Python使用“短路”行为，即当确定整个逻辑表达式的结果时，它会停止进一步的求值。让我们逐步分析表达式
4 > 5 and 4 or 5 and 4 * 3 ** 2 or not 8 > 6：
- 括号和优先级：首先，由于我们没有显式的括号，我们需要知道运算符的优先级。在Python中，
not的优先级最高，然后是and，最后是or。此外，乘方（**）的优先级高于乘法和除法，再高于比较运算符，最后才是逻辑运算符。- 从左到右求值：在没有括号的情况下，Python从左到右进行求值。
现在，让我们逐步分析这个表达式：
4 > 5：这是False，因为4不大于5。- 由于
and是短路运算符，如果其左侧为False，则整个and表达式的结果就是False，并且不会求值其右侧的部分。因此，4 > 5 and 4的结果是False。- 接下来是
or运算符。由于or的左侧（即4 > 5 and 4的结果）是False，or运算符会求值其右侧的部分来确定整个表达式的结果。5 and 4 * 3 ** 2：首先，我们求值4 * 3 ** 2，得到36（因为乘方的优先级高于乘法）。然后，由于5是真值（在布尔上下文中等于True），and运算符会求值其右侧的部分，即36。因此，5 and 4 * 3 ** 2的结果是36。- 由于
or运算符的左侧（即4 > 5 and 4的结果）是False，而右侧（即5 and 4 * 3 ** 2的结果）是36（在布尔上下文中也是真值），因此整个or表达式的结果是36。- 最后，
not 8 > 6：这部分是not True，因为8确实大于6，所以结果是False。但是，由于我们已经确定了整个表达式的结果是36（在前面的or运算中），所以这部分的值不会影响最终的结果。综上所述，
print(4 > 5 and 4 or 5 and 4 * 3 ** 2 or not 8 > 6)的结果是36。
6.
extend()函数和'+='运算符
list.extend(iterable)
(1)添加列表
demo_list = [1,2,3]
demo_list.extend([4,5]) # 等效写法demo_list += [4,5]
#list结果为 [1, 2, 3, 4, 5]
(2)添加字符串
demo_list = [1,2,3]
demo_list.extend("ab")
#list结果为 [1, 2, 3, 'a', 'b']
(3)添加字典
demo_list = [1,2,3]
demo_list.extend({"apple":1,"banana":2})
#list结果 [1, 2, 3, 'apple', 'banana']list.pop(index)
这里是索引，删除第几个
pop的用法
list.remove(element)
这里是删除值
remove的用法
7.冒泡排序
# 使用 Python 冒泡排序算法对[23,56,34,12,78,6]进行由大到小
# 排序
a=[23,56,34,12,78,6]
end=len(a)
while end!=0:
flag = 0
for i in range(0,end-1):
if a[i+1]<a[i]:
temp=a[i+1]
a[i+1]=a[i]
a[i]=temp
flag=1
if flag==0:
break
end=end-1
print(a)8.类的属性
1. obj.__dict__
__dict__ 是一个存储对象属性的字典。对于自定义对象，__dict__ 会包含所有实例变量（不包括继承自类的属性，除非它们被重写）。
class MyClass:
def __init__(self):
self.a = 1
self.b = 2
obj = MyClass()
print(obj.__dict__) # 输出: {'a': 1, 'b': 2}2. obj.__class__
__class__ 属性引用对象所属的类。
class MyClass:
pass
obj = MyClass()
print(obj.__class__) # 输出: <class '__main__.MyClass'>3. class.__bases__
__bases__ 是一个元组，包含了类继承的所有父类。对于单一继承，这个元组只包含一个类；对于多重继承，它会包含多个类。
class Base1:
pass
class Base2:
pass
class MyClass(Base1, Base2):
pass
print(MyClass.__bases__) # 输出: (<class '__main__.Base1'>, <class '__main__.Base2'>)4. class.__base__
注意：__base__ 属性并不是Python官方支持的。但在单继承的情况下，它通常指向类的直接父类（与 __bases__[0] 相同）。在多继承的情况下，使用 __base__ 可能会导致混淆，因为它可能不指向你期望的父类。因此，通常建议使用 __bases__。
但是，为了示例，这里是如何在单继承的情况下使用 __base__ 的：
class Base:
pass
class MyClass(Base):
pass
print(MyClass.__base__) # 输出: <class '__main__.Base'>5. class.__mro__
类的层次结构
class Base1:
def method(self):
return "Base1"
class Base2:
def method(self):
return "Base2"
class MyClass(Base1, Base2):
pass
print(MyClass.__mro__) # 输出类似: (<class '__main__.MyClass'>, <class '__main__.Base1'>, <class '__main__.Base2'>, <class 'object'>)
# 当我们调用 MyClass().method() 时，Python 会首先查找 MyClass 是否定义了 method，如果没有，它会查找 Base1，然后是 Base2，最后是 object（所有类的基类）9.深拷贝 v.s 浅拷贝
Python 中以 copy.deepcopy() 来实现对象的深度拷贝
深浅拷贝
