Python | 试卷刷题and基础笔记

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：

1. 括号和优先级：首先，由于我们没有显式的括号，我们需要知道运算符的优先级。在Python中，not的优先级最高，然后是and，最后是or。此外，乘方（**）的优先级高于乘法和除法，再高于比较运算符，最后才是逻辑运算符。
2. 从左到右求值：在没有括号的情况下，Python从左到右进行求值。

现在，让我们逐步分析这个表达式：

1. 4 > 5：这是False，因为4不大于5。
2. 由于and是短路运算符，如果其左侧为False，则整个and表达式的结果就是False，并且不会求值其右侧的部分。因此，4 > 5 and 4的结果是False。
3. 接下来是or运算符。由于or的左侧（即4 > 5 and 4的结果）是False，or运算符会求值其右侧的部分来确定整个表达式的结果。
4. 5 and 4 * 3 ** 2：首先，我们求值4 * 3 ** 2，得到36（因为乘方的优先级高于乘法）。然后，由于5是真值（在布尔上下文中等于True），and运算符会求值其右侧的部分，即36。因此，5 and 4 * 3 ** 2的结果是36。
5. 由于or运算符的左侧（即4 > 5 and 4的结果）是False，而右侧（即5 and 4 * 3 ** 2的结果）是36（在布尔上下文中也是真值），因此整个or表达式的结果是36。
6. 最后，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() 来实现对象的深度拷贝

深浅拷贝