python复习题资料

先看大题:

练习题 动物园管理系统 

动物园管理系统

步骤 1: 定义抽象基类 Animal 首先,我们定义一个抽象基类 Animal,它 包含抽象方法 make_sound 和普通方法 get_name。

步骤 2: 创建子类 Lion, Snake 和 Parrot 这些子类继承自 Animal 类,并实现了 make_sound 方法,展示多态和继承的概念。

步骤 3: 动物园类 Zoo Zoo 类包含一个动物列表,并提供添加动物 add_animal 和展示动物 叫声的方法 make_all_sounds。测试代码 现在,我们创建一些动物对象和一个动物园对象, 并展示它们是如何工作

#定义一个动物类
class Animal:
#定义一个构造函数
 def __init__(self, name):
   self.name = name
 def make_sound(self):
    #空语句不做任何事情
    pass
 def get_name(self):
      return self.name
#定义一个狮子类继承动物类
class Lion(Animal):
  def make_sound(self):
     return "Roar!"
#定义一个蛇类继承动物类
class Snake(Animal):
   def make_sound(self):
     return "Hiss!"
#定义一个鹦鹉类继承动物类
class Parrot(Animal):
   def make_sound(self):
       return "Chirp!"
#定义一个动物园类
class Zoo:
#定义一个数组接收数据
 def __init__(self):
       self.animals = []
#接收animal实类
 def add_animal(self, animal):
       self.animals.append(animal)
#遍历接收到的动物的声音
 def make_all_sounds(self):
        for animal in self.animals:
            print(animal.make_sound())
if __name__ == "__main__":
        #类的实例化
     lion = Lion("Lion")
     snake = Snake("Snake")
     parrot = Parrot("Parrot")
     zoo = Zoo()
     zoo.add_animal(lion)
     zoo.add_animal(snake)
     zoo.add_animal(parrot)
     zoo.make_all_sounds()
     print("Lion sound:", lion.make_sound())
     print("Snake sound:", snake.make_sound())
     print("Parrot sound:", parrot.make_sound())

练习题2: 创建和使用一个简单的包

目标:创建一个名为 geometry 的包。

在 geometry 包中, 创建两个模块:area 和 perimeter。

在 area 模块中,编写函数计算不同形状(如圆形、正 方形和矩形)的面积。

在 perimeter 模块中,编写函数计算这些形状的周长。

创建一个主 程序文件,在其中使用 geometry 包来计算不同形状的面积和周长。

#定义一个area.py的文件
geometry/area.py:
import math
def circle_area(radius):
     return math.pi * radius ** 2
def square_area(side_length):
     return side_length ** 2
def rectangle_area(width, height):
     return width * height

#定义一个perimeter.py的文件
geometry/perimeter.py:
def circle_perimeter(radius):
     return 2 * math.pi * radius
def square_perimeter(side_length):
     return 4 * side_length
def rectangle_perimeter(width, height):
     return 2 * (width + height)

#定义一个测试主文件
geometry/main.py:
from geometry.area import circle_area, square_area, rectangle_area
from geometry.perimeter import circle_perimeter, square_perimeter, rectangle_perimeter
def main():
     circle_radius = 5
     square_side_length = 4
     rectangle_width = 3
     rectangle_height = 4
     print("Circle area:", circle_area(circle_radius))
     print("Circle perimeter:", circle_perimeter(circle_radius))
     print("Square area:", square_area(square_side_length))
     print("Square perimeter:", square_perimeter(square_side_length))
     print("Rectangle area:", rectangle_area(rectangle_width, rectangle_height))
     print("Rectangle perimeter:", rectangle_perimeter(rectangle_width,rectangle_height))
if __name__ == "__main__":
     main()

练习题三

用递归的方式实现二叉树的先序遍历

class TreeNode:
     def __init__(self, x):
     self.val = x
     self.left = None
     self.right = None
def pre_order_traversal(root):
     if not root:
         return
 # 访问根节点
 print(root.val, end=' ')
 # 遍历左子树
 pre_order_traversal(root.left)
 # 遍历右子树
 pre_order_traversal(root.right)

if __name__ == '__main__':
     # 创建一个简单的二叉树
     root = TreeNode(1)
     root.left = TreeNode(2)
     root.right = TreeNode(3)
     root.left.left = TreeNode(4)
     root.left.right = TreeNode(5)
     root.right.right = TreeNode(6)
     # 进行先序遍历
     pre_order_traversal(root)

1.python是什么

Python 是一种高级的编程语言,以其强大的功能和简洁易读的代码而闻名。以下是 Python 的一些核心特征和信息:

  1. 高级语言:Python 被设计为一种高级编程语言,这意味着它提供了较高层次的抽象,使得编程更加容易和直观。程序员可以用更少的代码行来表达复杂的想法。

  2. 解释型语言:与编译型语言(如 C 或 Java)不同,Python 是一种解释型语言。这意味着 Python 代码在运行时由解释器逐行读取和执行,而不是预先编译成机器语言。

  3. 动态类型:Python 是动态类型的,这意味着变量在声明时不需要显式指定数据类型。数据类型在运行时会自动确定。

  4. 跨平台兼容性:Python 可以在多种操作系统上运行,包括 Windows、MacOS 和 Linux,这使得它成为开发跨平台应用的理想选择。

  5. 易读性:Python 以其清晰、直观和几乎类似英语的语法而闻名,这使得代码易于理解和维护。

  6. 丰富的库和框架:Python 拥有庞大的标准库,以及丰富的第三方库和框架,覆盖了从网络编程到数据科学、机器学习、Web开发等广泛的应用领域。

  7. 广泛的应用:Python 在多个领域都有广泛的应用,包括 Web 开发、数据分析和科学计算、人工智能、自动化脚本、软件测试等。

  8. 社区支持:Python 拥有一个庞大而活跃的开发者社区,提供了大量的资源、文档、教程和支持,这对于初学者来说是一个巨大的优势。

2.3操作符

  1)算术运算符:加 (+), 减 (-), 乘 (*), 除 (/), 取余 (%), 整除 (//), 指数 (**)

a = 10

b = 3

add = a + b  # 加 (+)

subtract = a - b  # 减 (-)

multiply = a * b  # 乘 (*)

divide = a / b  # 除 (/)

modulo = a % b  # 取余

(%) floor_divide = a // b  # 整除

(//) exponent = a ** b  # 指数 (**)

2)比较运算符:等于 (==), 不等于 (!=), 大于 (>), 小于 (<), 大于等于 (>=), 小于等于 (<=)

x = 5

y = 10

equal = x == y  # 等于 (==)

not_equal = x != y  # 不等于

(!=) greater_than = x > y  # 大于 (>)

less_than = x < y  # 小于 (<)

greater_than_or_equal = x >= y  # 大于等于 (>=)

less_than_or_equal = x <= y  # 小于等于 (<=)

3)逻辑运算符:与 (and), 或 (or), 非 (not)

a = True

b = False

logical_and = a and b  # 与

(and) logical_or = a or b  # 或 (or)

logical_not = not a  # 非 (not)

4)赋值运算符:赋值 (=), 加赋值 (+=), 减赋值 (-=), 乘赋值 (*=), 除赋值 (/=), 等等

x = 10

x += 3  # 加赋值 (+=)

x -= 2  # 减赋值 (-=)

x *= 2  # 乘赋值 (*=)

x /= 4  # 除赋值 (/=)

2.5注释 斐波那契数列

使用 # 符号来添加注释,解释代码的功能或目的。

# 这是一个注释 print("Hello, World!")

"""

这是一个多行注释的示例。 你可以在这里写很多行文字,

而 Python 解释器会忽略它们。

"""

3.1字符串链接重复 切片

1)连接(Concatenation)

使用+将字符串连接在一起。

str1 = "Hello" str2 = "World" combined = str1 + " " + str2  # "Hello World"

2)重复(Repetition):

使用*重复字符串。

repeat_str = "Python!" * 3  # "Python!Python!Python!"

3)索引(Indexing):

使用索引访问特定位置的字符。

char = "Hello"[1]  # 'e'

4)切片(Slicing):

使用切片来获取字符串的子串。

substring = "Hello World"[1:5]  # "ello"

3.4 2.2字典

字典(dict)是一种可变的容器,可以存储任意类型对象,其中每个元素都是一个键值对。

定义和用法

person = {"name": "Alice", "age": 25} capitals = {"France": "Paris", "Italy": "Rome"}

特点

1. 键必须是不可变类型,如字符串或元组

# 使用字符串作为键

my_dict = {     "name": "Alice",  

                           "age": 30,    

                         "email": "[email protected]"

} # 使用元组作为键

coordinates = {(0, 0): "原点", (1, 1): "点(1,1)"}

# 尝试使用可变类型(如列表)作为键将引发错误

try:     invalid_dict = {[1, 2, 3]: "List as a key"}

except TypeError as e:  

  print("Error:", e)

PS:可以作为Key的类型:

  1. 字符串(String):

    • 例子:"name", "id", "email"

  2. 整数(Integer):

    • 例子:1, 100, -20

  3. 浮点数(Float):

    • 注意:尽管可以使用,但由于浮点数精度的问题,通常不建议将其作为键。

    • 例子:3.14, 0.001, -5.76

  4. 元组(Tuple):

    • 条件:元组中的所有元素也必须是不可变类型。

    • 例子:(1, 2, 3), ("a", "b", "c")

  5. 布尔值(Boolean):

    • 例子:True, False

  6. 冻结集合(Frozenset):

    • 条件:类似于集合,但是不可变。

    • 例子:frozenset([1, 2, 3]), frozenset(["apple", "banana"])

3.4 字典(Dictionary)

字典是可变的,存储键值对的无序集合。

# 创建字典

my_dict = {"name": "Alice", "age": 25, "city": "New York"}

# 添加或修改元素

my_dict["country"] = "USA"  # 添加新键值对

my_dict["age"] = 26  # 修改现有键的值

# 访问

name = my_dict.get("name")  # 安全地访问元素

age = my_dict.pop("age")  # 删除键值对并返回值

# 遍历字典

or key, value in my_dict.items():  

  print(key, value)

# 删除元素

del my_dict["city"]  # 删除键值对

# 注意:此时 "age" 键已经被 pop 方法删除,再次调用 pop 将引发 KeyError

# 若要避免错误,可以使用 pop 方法的第二个参数,提供默认返回值

# 这样,如果键不存在,将返回默认值而不是引发异常

age_removed = my_dict.pop("age", None)

# 打印结果

print(f"Name: {name}")

print(f"Age: {age} (removed)")

print(f"Age removed again: {age_removed} (default None if not found)")

3.6  操作符

运算符

描述

支持的容器类型

+

合并

字符串、列表、元组

*

复制

字符串、列表、元组

in

元素是否存在

字符串、列表、元组、字典

not in

元素是否不存在

字符串、列表、元组、字典

# 字符串操作示例

str1 = "Hello"

str2 = "World"

str_concat = str1 + " " + str2# 合并

str_repeat = str1 * 3  # 复制

str_in = "H" in str1  # 元素是否存在

str_not_in = "Z" not in str1  # 元素是否不存在

# 列表操作示例

list1 = [1, 2, 3]

list2 = [4, 5, 6]

list_concat = list1 + list2  # 合并

list_repeat = list1 * 2  # 复制

list_in = 1 in list1  # 元素是否存在

list_not_in = 7 not in list1  # 元素是否不存在

# 元组操作示例

tuple1 = (1, 2, 3)

tuple2 = (4, 5, 6) t

uple_concat = tuple1 + tuple2  # 合并

tuple_repeat = tuple1 * 2  # 复制

tuple_in = 1 in tuple1  # 元素是否存在

tuple_not_in = 7 not in tuple1  # 元素是否不存在

# 字典操作示例(只适用于 in 和 not in 运算符)

dict1 = {"name": "Alice", "age": 25}

dict_in = "name" in dict1  # 元素(键)是否存在

dict_not_in = "salary" not in dict1  # 元素(键)是否不存在

# 打印所有结果

print(f"String Concatenation: {str_concat}")

print(f"String Repetition: {str_repeat}")

print(f"String In: {str_in}, String Not In: {str_not_in}")

(f"List Concatenation: {list_concat}")

print(f"List Repetition: {list_repeat}")

print(f"List In: {list_in}, List Not In: {list_not_in}")

print(f"Tuple Concatenation: {tuple_concat}")

print(f"Tuple Repetition: {tuple_repeat}")

print(f"Tuple In: {tuple_in}, Tuple Not In: {tuple_not_in}")

print(f"Dictionary In: {dict_in}, Dictionary Not In: {dict_not_in}")

1.3作用域和命名空间1 2 3 4(背)

3. 作用域和命名空间

  • 局部变量:在函数内部定义的变量是局部的,它们只在函数内部可见。

  • 全局变量:在函数外定义的变量是全局的,它们在程序的任何地方都可见。

  • 作用域规则:Python 使用 LEGB(Local, Enclosing, Global, Built-in)规则来解析变量名。

变量的可见性和生命周期取决于它们被定义的地方,这就是所谓的作用域。Python 的作用域规则遵循 LEGB 规则,这个规则决定了在任何给定的点在你的代码中使用变量时,Python 如何查找该变量的值。LEGB 代表 Local, Enclosing, Global, Built-in:

1. Local(局部)

  • 局部作用域指的是在函数内部定义的变量。

  • 这些变量只能在其定义的函数内部访问。

def my_function():  

          local_var = 10  # 局部变量    

          print(local_var)

my_function()

# print(local_var) # 这将引发错误,因为 local_var 在函数外部不可见

2. Enclosing(封闭)

  • 封闭作用域涉及嵌套函数,即一个函数包裹着另一个函数。

  • 在外层函数中定义的变量对内层函数来说是可见的,但不适用于相反的情况。

def outer_function():

    enclosing_var = "I'm outside the nested function."

    def inner_function():

        print(enclosing_var)  # 访问封闭作用域中的变量

    inner_function()

outer_function()

3. Global(全局)

  • 全局变量是在函数外部定义的,它们在整个代码文件中都是可见的。

  • 如果需要在函数内修改全局变量,需要使用 global 关键字。

# 定义一个全局变量

global_var = 10 def update_var():

    global_var = 20

    print(f"Inside function update var: global_var = {global_var}")

def update_global_var():

    # 在函数内部声明要使用的全局变量

    global global_va

r     # 修改全局变量的值

    global_var = 20

    print(f"Inside function use global update var: global_var = {global_var}")

print(f"Before update_var call: global_var = {global_var}") update_var()

print(f"After update_var call: global_var = {global_var}")

print(f"Before update_global_var call: global_var = {global_var}") update_global_var() print(f"After update_global_var call: global_var = {global_var}")

4. Built-in(内建)

  • Python 自带了一些内置函数和变量,它们在任何地方都是可访问的。

  • 这些内置函数包括 print(), len() 等,不建议覆盖这些内置函数。

print(len("hello"))  # 使用内置函数 len()

LEGB 规则

当你在代码中引用一个变量时,Python 会按照 LEGB 的顺序搜索:

  1. 首先查看 Local 层,看变量是否在函数内部定义。

  2. 然后是 Enclosing 层,检查任何外层函数是否定义了变量。

  3. 接着是 Global 层,搜索代码文件的顶层。

  4. 最后是 Built-in 层,检查变量名是否是 Python 的内置名称。

2.3 类方法 静态方法(背)

类方法

  • 需要用装饰器@classmethod来标识其为类方法,对于类方法,第一个参数必须是类对象,一般以cls作为第一个参数。

  • 当方法中 需要使用类对象 (如访问私有类属性等)时,定义类方法

  • 类方法一般和类属性配合使用

class Dog:

    __tooth = 10

        @classmethod

           def get_tooth(cls):

                return cls.__tooth

  ......

print(Dog.get_tooth())

print(my_dog.get_tooth())

静态方法

  • 需要通过装饰器@staticmethod来进行修饰,静态方法既不需要传递类对象也不需要传递实例对象(形参没有self/cls)

  • 静态方法 也能够通过 实例对象类对象 去访问。

  • 当方法中 既不需要使用实例对象(如实例对象,实例属性),也不需要使用类对象 (如类属性、类方法、创建实例等)时,定义静态方法

  • 取消不需要的参数传递,有利于 减少不必要的内存占用和性能消耗

class Dog:

    ......

    @staticmethod

    def info_print():

        print('这是一个狗类,用于创建狗实例....')

.....

# 静态方法既可以使用对象访问又可以使用类访问

my_dog.info_print()

Dog.info_print()

定义私有属性

在Python中,以双下划线 __ 开始的属性或方法被视为私有的。

私有属性不能从类的外部直接访问,只能在类的内部使用。

私有属性的目的是为了封装和隐藏类的内部实现细节。

尽管Python的私有化是通过名称改写(Name Mangling)实现的(例如 __max_price 会被改写为 _Computer__max_price),这并不是强制性的,仍可以通过特定的语法访问它们,但这种做法不被推荐,因为它违反了封装原则。

2.5抽象基类

在 Python 中,与传统意义上的“接口”(如在 Java 或 C# 中所见)不同,没有专门的接口(Interface)类或关键字。然而,Python 支持接口编程的概念,通常是通过抽象基类(Abstract Base Classes, ABCs)来实现的。

这些类可以包含一个或多个抽象方法或属性,这些方法或属性需要在子类中实现。抽象基类本身不能被实例化。在这方面,抽象基类的作用类似于传统的接口,它们定义了一个接口契约,该契约必须由任何非抽象的子类实现。

from abc import ABC, abstractmethod

class MyInterface(ABC):

    @abstractmethod

    def do_something(self):

        pass

    @abstractmethod

    def do_something_else(self):

        pass

class ConcreteClass(MyInterface):

    def do_something(self):

        return "Doing something!"    

def do_something_else(self):

        return "Doing something else!"

# my_interface = MyInterface()  # 这会引发错误,因为不能实例化抽象类

concrete = ConcreteClass()

print(concrete.do_something())

在这个例子中,MyInterface 是一个抽象基类,它定义了两个抽象方法:do_something 和 do_something_else。ConcreteClass 继承自 MyInterface 并实现了这些方法。尝试直接实例化 MyInterface 会引发错误,因为它是抽象的

你可能感兴趣的:(java,开发语言)