代码收藏家技术教程 2024-06-16

Python期末复习重点知识点解析（hbut 邵光普）

Python 复习具体知识点

1、表达式 not 3 or6 的值:

在Python中，not 3 or 6 这个表达式的含义可以分解为以下步骤来理解：

not 3：not 是一个逻辑运算符，用于对一个布尔值进行取反。但在这里，它作用于一个整数值 3。在Python中，任何非零数值都被视为 True，因此 not 3 会被转换为 False。

False or 6：接下来，or 运算符会检查其左侧的值。如果左侧为 False（或任何被视为 False 的值，如 0、None、空字符串等），则 or 运算符会返回其右侧的值。在这个例子中，False or 6 会返回 6。

所以，整个表达式 not 3 or 6 的结果是 6。

注意：在Python中，布尔运算符 and 和 or 实际上返回的是它们操作数的值，而不仅仅是 True 或 False。这被称为短路行为：

对于 and 运算符，如果左侧为 False，则整个表达式立即返回左侧的值，不再评估右侧。如果左侧为 True，则返回右侧的值。

对于 or 运算符，如果左侧为 True，则整个表达式立即返回左侧的值，不再评估右侧。如果左侧为 False，则返回右侧的值。

这种特性在处理条件逻辑时非常有用，但也需要小心处理，以确保代码的逻辑符合预期。

2、集合推导式:例如用集合推导式生成1到10之间所有的偶数。

# 使用集合推导式生成1到10之间的所有偶数  
even_numbers = {i for i in range(1, 11) if i % 2 == 0}  
  
# 打印结果  
print(even_numbers)

3、字典的 get 方法:x=dict(name='wang',age=23)，x.get('name',"i')的值

在Python中，字典（dict）的 get 方法是一个非常有用的方法，用于从字典中获取指定键的值。如果键不存在于字典中，get 方法允许你提供一个默认值作为替代。

基本语法
dict.get(key, default=None)
key：需要获取的值的键。

default（可选）：如果键不存在于字典中，则返回此默认值。默认为 None。

示例
# 创建一个字典 
my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'} 


# 使用 get 方法获取键 'name' 的值 
print(my_dict.get('name')) # 输出：'Alice' 


# 尝试获取不存在的键 'phone' 的值，但不提供默认值 
print(my_dict.get('phone')) # 输出：None 


# 尝试获取不存在的键 'phone' 的值，并提供默认值 'Unknown' 
print(my_dict.get('phone', 'Unknown')) # 输出：'Unknown'
优点

使用 get 方法的好处之一是，当你尝试访问字典中不存在的键时，它不会引发 KeyError 异常，而是返回一个默认值。这可以让你的代码更加健壮，尤其是在你不确定某个键是否存在于字典中的情况下。

4、内置函数 zip、eval、filter、enumerate等

zip(iterable) 将元素打包成元组，返回一个zip对象

Python中zip函数的使用方法

eval函数：去掉字符串的“ ”

filter(function,iterable) function应该返回一个bool值,iterable是可迭代对象,如列表，元组等

留下来的是使得funtion为True的

Python中的filter函数用法详解

enumerate（iterable,指定的开始索引值）:对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值

python enumerate用法总结

list1=["I","am","happy","cat"]
for index,k in enumerate(list1,1):
    print(index,k)

1 I
2 am
3 happy
4 cat

5、匿名函数 lambda:x= [lambda x,y:x+y],x[0](3,2)的值

# 正确的构造应该是分两步的  
# 第一步：定义一个包含 lambda 函数的列表  
lambdas = [lambda x, y: x + y]  
  
# 第二步：调用列表中的 lambda 函数  
result = lambdas[0](3, 2)  
  
print(result)  # 输出应该是 5

6、列表推导式:x=[ch for chin'abcdcab'],len(x)的值

x=[ch for ch in 'abcdcab']
print(x)
print(len(x))

['a', 'b', 'c', 'd', 'c', 'a', 'b']
7

7、字符串数据类型的 jion方法与split 方法

" ".join(iterable) 可迭代对象的元素必须是字符类型！

Python中的join函数

Python join()函数使用详解

s.split(",",2) #2是分割次数

Python中超好用的split()函数

82. Python split方法-分割字符串_split python-CSDN博客

8、实参前面一个*是序列解包

使用 * 获取值，默认为列表list

【Python小知识】：什么是序列解包

Python基础12-序列解包_python序列解包

persons_list = [{'name': 'John', 'age': 30}, {'name': 'Alice', 'age': 25}]

for person in persons_list:
    name, age = person.items()#name  输出: ('name', 'John')  age 输出: ('age', 30)
    print(f"Name: {name[1]}, Age: {age[1]}")

person = {'name': 'John', 'age': 30}
name, age = person.items()
print(name)  # 输出: ('name', 'John')
print(age)   # 输出: ('age', 30)

Name: John, Age: 30
Name: Alice, Age: 25
('name', 'John')
('age', 30)

person = {'name': 'John', 'age': 30}
keys = person.keys()
values = person.values()

print(keys)   # 输出: dict_keys(['name', 'age'])
print(values) # 输出: dict_values(['John', 30])
为什么输出前面有 dict_keys

在Python中，当你调用字典的.keys()或.values()方法时，你得到的并不是一个普通的列表，而是一个视图对象（view object）。这些视图对象分别是dict_keys和dict_values的实例，它们提供了字典键或值的动态视图，这意味着它们会反映字典的任何后续更改。

这些视图对象并不是为了直接打印给用户设计的，但它们具有一些与列表相似的特性，比如你可以迭代它们。然而，当你尝试直接打印这些视图对象时，Python会告诉你它们的类型，这就是为什么你看到了dict_keys和dict_values这样的输出。

如果你想要一个普通的列表，以便可以打印它或者对它进行其他列表特有的操作，你可以使用list()函数来转换这些视图对象：
person = {'name': 'John', 'age': 30} 
keys = list(person.keys()) 
values = list(person.values()) 


print(keys) # 输出: ['name', 'age'] 
print(values) # 输出: ['John', 30]
现在，keys和values都是普通的列表，所以当你打印它们时，你会看到列表的内容，而不是它们的类型。

9、字符串数据的 replace 方法、find 方法、isdigit 方法

replace方法(不会改变原string的内容)：

msg="Hello Hello I'm Jay"
# msg2=msg.replace("Hello","Hi")
msg2=str.replace(msg,"Hello","Hi")
print(msg2)

data="1,2,3,4"
data1=data.replace(",","\n",3)
print(data1)

替换最后一次出现的Hello

msg="Hello Hello !Hello i'm Jay"
ind=msg.rfind("Hello")
print(ind)
msg2=msg[:ind]+msg[ind:].replace("Hello","Hi")
print(msg2)

maketrans和translate

trantable=str.maketrans(in,out) 将in转换成out

msg2=msg.translate(trantable)

msg = "Hello world! Hello Python!"
# intab中的字符与outtab中的字符一一对应
intab = "aeiou"
outtab = "12345"
trantable=str.maketrans(intab,outtab)#将intab 换成 outtab
msg2=msg.translate(trantable)
print(msg2)
#H2ll4 w4rld! H2ll4 Pyth4n!

re.sub替换

import re

msg = "Hello world! Hello Python!"
# 设置要替换的字符
namesRegex = re.compile(r'Hello')
# 用'Hi'替换msg中已经设置好要替换的字符
msg2=namesRegex.sub('Hi', msg)
print(msg2)
# 输出
# 'Hi world! Hi Python!'

Python字符串替换的3种方法

find函数

string.find( str, start, end)

如果是负数，就是从右边第几个数开始找

find找不到返回-1，index找不到报错

Python find()函数使用详解_find函数

isdigit() 判断是否由数字构成

注意：负数的情况！从[1:]开始

Python 内置函数isdigit()

10、列表的insert、append

insert方法:直接修改原来的值

list.insert(index, element)

Python列表中的insert功能及用法举例

列表append函数

在列表中，append函数用于向列表的末尾添加一个元素。例如：

my_list = [1, 2, 3]
my_list.append(4)
print(my_list) # [1, 2, 3, 4]

需要注意的是，append函数只能添加一个元素，如果要添加多个元素，可以使用extend函数或者使用加号运算符：

my_list = [1, 2, 3]
my_list.extend([4, 5])
print(my_list) # [1, 2, 3, 4, 5]

my_list = [1, 2, 3]
my_list += [4, 5]
print(my_list) # [1, 2, 3, 4, 5]

集合add函数：

在集合中，append函数并不存在。如果要向集合中添加元素，可以使用add函数：

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

需要注意的是，集合中的元素是无序且不重复的。如果要添加多个元素，可以使用update函数：

my_set = {1, 2, 3}
my_set.update([3, 4])
print(my_set) # {1, 2, 3, 4}

字典下标运算符：

在字典中，也不存在append函数。如果要向字典中添加键值对，可以直接使用下标运算符：

my_dict = {'a': 1, 'b': 2}
my_dict['c'] = 3
print(my_dict) # {'a': 1, 'b': 2, 'c': 3}

11、列表对象的浅复制与深复制

Python 深拷贝和浅拷贝详解_python深浅拷贝-CSDN博客

12、正则表达式以及 re.findall

python正则表达式re模块之findall函数_re.findall-CSDN博客

Python re.findall中正则表达式(.*?)和参数re.S使用_re.findall()用法 re.s-CSDN博客

re.findall(pattern,string,flags=0)

import re
str_1 = "Hello World"
str_list = re.findall("\w+",str_1)
print(str_list)

返回一个列表，存储匹配到的值

str_list = re.findall("e\w+",str_1)

匹配e开头的字母

import re

str_1 = "Hello World"

str_list = re.findall("[eo]\w+",str_1,flags=re.I)

print(str_list)

匹配e、o开头的单词

13、包含语句的函数可以用来创建生成器

yield语句与return语句的作用相似，都是用来从函数中返回值。与return语句不同的是，
return语句一旦执行会立刻结束函数的运行，而每次执行到yield语句并返回一个值之
后会暂停或挂起后面代码的执行，下次通过生成器对象的__next__()方法、内置函数
next()、for循环遍历生成器对象元素或其他方式显式“索要”数据时恢复执行。

python之生成器_python 生成器-CSDN博客

14、函数中 continue 的作用

在Python中，continue语句用于控制循环（如for循环或while循环）的流程。当在循环体内部遇到continue语句时，它将跳过当前迭代中的剩余代码，并立即开始下一次迭代。这意味着循环不会终止，而是继续执行，但是会跳过当前迭代中continue语句之后的任何代码。

15、列表的切片操作

Python 深拷贝和浅拷贝详解_python深浅拷贝-CSDN博客

16、面向对象的三大特征

Python面向对象三大特征_python变量对象三大特征-CSDN博客

大题:

1、考察选择与循环，例如教材的第 81 页习题 9。

def k(x):
    if x < 0 or x >= 20:
        y = 0
    elif x >= 0 and x < 5:
        y = x
    elif x >= 5 and x < 10:
        y = 3 * x - 5
    else:
        y = 0.5 * x - 2
    return y
x=3
print(k(19))

2、考察设计函数并且调用函数，例如教材第 126 页例题 5-2.

def demo(*p):
    avg=sum(p)/len(p)
    g=[i for i in p if i>avg]
    return (avg,)+tuple(g)
list1=[1,2,3,4,5,6,7,8,9]
print(demo(*list1))#第一个数是平均数，第二个数大于平均数

3、考察面向对象程序设计，能够独立实现一个数据类型，例如第 157 页习题5

class Vecter3:
    def __init__(self,x = 0,y = 0,z = 0):
        self.X=x
        self.Y=y
        self.Z=z
    def add(self, n):
        r = Vecter3()
        r.X=self.X+n.X
        r.Y=self.Y+n.Y
        r.Z=self.Z+n.Z
        return r
    def __add__(self,n):
        r=Vecter3()
        r.X=self.X+n.X
        r.Y=self.Y+n.Y
        r.Z=self.Z+n.Z
        return r
    def __sub__(self,n):
        r=Vecter3()
        r.X=self.X-n.X
        r.Y=self.Y-n.Y
        r.Z=self.Z-n.Z
        return r
    def __mul__(self,n):
        r=Vecter3(0)
        r.X = self.X * n
        r.Y = self.Y * n
        r.Z = self.Z * n
        return r
    def __truediv__(self,n):
        r=Vecter3()
        r.X=self.X/n
        r.Y=self.Y/n
        r.Z=self.Z/n
        return r
    def __floordiv__(self,n):
        r=Vecter3(0,0,0)
        r.X=self.X//n
        r.Y=self.Y//n
        r.Z=self.Z//n
        return r
    def show(self):
        print((self.X,self.Y,self.Z))
def main():
    v1 = Vecter3(1,2,3)
    v2 = Vecter3(3,4,5)
    v3 = v1 + v2
    v3.show()
    v3 = v1.add(v2)
    v3.show()
    v4 = v1 - v2
    v4.show()
    v5 = v1 * 3
    v5.show()
    v6 = v2/2
    v6.show()
    v7 = v2//2
    v7.show()
main()

4、考察面向对象程序设计，能够按要求设计类，并且通过类的单继承产生派生
类

编程题 4: 员工类与经理类

设计一个Employee类，包含name、salary属性和introduce方法。然后设计一个Manager类，继承自Employee类，并添加一个give_bonus方法用于给员工发放奖金。

class Employee:  
    def __init__(self, name, salary):  
        self.name = name  
        self.salary = salary  
  
    def introduce(self):  
        print(f"Hello, I'm {self.name} and I earn {self.salary} per month.")  
  
class Manager(Employee):  
    def __init__(self, name, salary, bonus):  
        super().__init__(name, salary)  
        self.bonus = bonus  
  
    def give_bonus(self, employee, amount):  
        employee.salary += amount  
        print(f"{self.name} gives {amount} to {employee.name}.")  
  
# 示例使用  
manager = Manager("John Doe", 5000, 1000)  
employee = Employee("Jane Smith", 3000)  
manager.give_bonus(employee, 500)  
employee.introduce()

编程题 5: 账户类与储蓄账户类

设计一个Account类，包含balance属性和deposit、withdraw两个方法。然后设计一个SavingsAccount类，继承自Account类，并添加一个calculate_interest方法用于计算利息。

class Account:  
    def __init__(self, balance=0):  
        self.balance = balance  
  
    def deposit(self, amount):  
        self.balance += amount  
        print(f"Deposited {amount}. New balance is {self.balance}.")  
  
    def withdraw(self, amount):  
        if amount > self.balance:  
            print("Insufficient funds.")  
            return  
        self.balance -= amount  
        print(f"Withdrawn {amount}. New balance is {self.balance}.")  
  
class SavingsAccount(Account):  
    def __init__(self, balance=0, interest_rate=0.01):  
        super().__init__(balance)  
        self.interest_rate = interest_

作者：我推是大富翁