【python基础教程】2

极致的逆向

已于 2024-03-18 17:33:53 修改

阅读量2.2k

点赞数 40

分类专栏： python教程文章标签： python 数据结构算法

于 2024-03-13 01:18:12 首次发布

本文链接：https://blog.youkuaiyun.com/l202226/article/details/136667052

版权

python教程专栏收录该内容

4 篇文章

订阅专栏

继续上面的那一章，这里给出上面问题的答案，然后再进行教程

Python变量和运算练习题

变量和基本运算

创建两个变量a和b，分别赋值为10和20，打印它们的和。
计算并打印两个变量x和y的乘积，其中x=5, y=3。
创建一个变量c，将a和b的和赋值给它，然后打印c的值。
输入一个数字，将其赋值给变量d，然后打印d的平方。
输入两个数字，比较它们是否相等，并打印结果（True或False）。
使用变量存储你的名字和年龄，然后打印一句自我介绍，如“Hello, my name is Alice, and I am 30 years old.”
创建一个变量temperature，给它赋一个值，用if语句检查温度是否大于30度，如果是，打印“Today is a hot day!”
输入一个数字，判断并打印该数字是正数、负数还是零。
计算并打印半径为5的圆的面积（使用π=3.14）。
创建两个变量，一个存储你的身高（米），另一个存储你的体重（千克），计算并打印你的BMI指数。

循环

使用for循环打印数字1到10。
使用while循环打印数字1到10。
使用for循环打印所有偶数从2到20。
使用while循环，每次循环让用户输入一个新数字，直到用户输入“stop”为止。
编写一个程序，用for循环计算数字1到100的总和。
使用for循环和range函数，打印出所有5的倍数（1-100之间）。
使用while循环创建一个猜数字游戏，直到用户猜对数字（比如42）为止。
创建一个列表，包含数字1到5，使用for循环遍历这个列表，并打印每个数字的平方。
使用for循环，遍历并打印从1到10每个数字的立方。
创建一个变量sum，用while循环计算从1到10的和（包括1和10）。

进阶循环

使用for循环和if语句，打印从1到100之间所有的奇数。
创建一个列表，用for循环添加1到10的所有数字到列表中，然后打印这个列表。
使用嵌套for循环打印一个5x5的星号（*）正方形。
编写一个程序，使用循环计算并打印5的阶乘（5!）。
使用for循环遍历字符串"Python"，并打印每个字符。
使用while循环反向打印数字10到1。
使用for循环和range函数，计算从1到10的所有偶数的和。
编写一个程序，使用for循环找到并打印从1到100内能被7整除的数字。
创建一个列表，包含一些数字，使用for循环计算列表中数字的平均值。
使用for循环，打印出一个3行4列的数字网格（例如，1到12）。

算术和比较运算练习

计算并打印两个变量的差值和商，变量值自选。
创建一个变量存储一个数字，然后使用比较运算符检查是否大于100。
使用模除%运算符检查一个数字是否为偶数，并打印结果。
使用幂运算符**计算并打印2的10次方。
创建两个变量，使用比较运算符比较它们的值，并打印比较结果（大于、小于、等于）。
输入一个年份，检查并打印它是否为闰年（能被4整除但不能被100整除，或能被400整除）。
创建一个变量存储温度值（摄氏度），计算并打印华氏度值。
输入三个数字，使用比较运算符找到并打印最大的数字。
使用算术运算符计算并打印任意两个数字的平均值。
输入一个数字，使用算术运算符计算并打印其立方根的近似值（提示：使用**运算符）。

答案

# 变量和基本运算
# 创建两个变量a和b，分别赋值为10和20，打印它们的和。
a = 10
b = 20
print(a + b)

# 计算并打印两个变量x和y的乘积，其中x=5, y=3。
x = 5
y = 3
print(x * y)

# 创建一个变量c，将a和b的和赋值给它，然后打印c的值。
c = a + b
print(c)

# 输入一个数字，将其赋值给变量d，然后打印d的平方。
d = float(input("Enter a number: "))
print(d ** 2)

# 输入两个数字，比较它们是否相等，并打印结果（True或False）。
num1 = float(input("Enter first number: "))
num2 = float(input("Enter second number: "))
print(num1 == num2)

# 使用变量存储你的名字和年龄，然后打印一句自我介绍，如“Hello, my name is Alice, and I am 30 years old.”
name = "Alice"
age = 30
print(f"Hello, my name is {name}, and I am {age} years old.")

# 创建一个变量temperature，给它赋一个值，用if语句检查温度是否大于30度，如果是，打印“Today is a hot day!”
temperature = 31
if temperature > 30:
    print("Today is a hot day!")

# 输入一个数字，判断并打印该数字是正数、负数还是零。
number = float(input("Enter a number: "))
if number > 0:
    print("Positive")
elif number < 0:
    print("Negative")
else:
    print("Zero")

# 计算并打印半径为5的圆的面积（使用π=3.14）。
radius = 5
pi = 3.14
area = pi * (radius ** 2)
print(area)

# 创建两个变量，一个存储你的身高（米），另一个存储你的体重（千克），计算并打印你的BMI指数。
height = 1.75
weight = 70
bmi = weight / (height ** 2)
print(bmi)

# 循环
# 使用for循环打印数字1到10。
for i in range(1, 11):
    print(i)

# 使用while循环打印数字1到10。
i = 1
while i <= 10:
    print(i)
    i += 1

# 使用for循环打印所有偶数从2到20。
for i in range(2, 21, 2):
    print(i)

# 使用while循环，每次循环让用户输入一个新数字，直到用户输入“stop”为止。
while True:
    user_input = input("Enter a number or 'stop' to end: ")
    if user_input.lower() == "stop":
        break
    print(user_input)

# 编写一个程序，用for循环计算数字1到100的总和。
sum = 0
for i in range(1, 101):
    sum += i
print(sum)

# 使用for循环和range函数，打印出所有5的倍数（1-100之间）。
for i in range(5, 101, 5):
    print(i)

# 使用while循环创建一个猜数字游戏，直到用户猜对数字（比如42）为止。
secret_number = 42
while True:
    guess = int(input("Guess the number: "))
    if guess == secret_number:
        print("Congratulations! You guessed the number.")
        break

# 创建一个列表，包含数字1到5，使用for循环遍历这个列表，并打印每个数字的平方。
numbers = [1, 2, 3, 4, 5]
for number in numbers:
    print(number ** 2)

# 使用for循环，遍历并打印从1到10每个数字的立方。
for i in range(1, 11):
    print(i ** 3)

# 创建一个变量sum，用while循环计算从1到10的和（包括1和10）。
sum = 0
i = 1
while i <= 10:
    sum += i
    i += 1
print(sum)

# 进阶循环
# 使用for循环和if语句，打印从1到100之间所有的奇数。
for i in range(1, 101):
    if i % 2 != 0:
        print(i)

# 创建一个列表，用for循环添加1到10的所有数字到列表中，然后打印这个列表。
numbers = []
for i in range(1, 11):
    numbers.append(i)
print(numbers)

# 使用嵌套for循环打印一个5x5的星号（*）正方形。
for i in range(5):
    for j in range(5):
        print("*", end="")
    print()

# 编写一个程序，使用循环计算并打印5的阶乘（5!）。
factorial = 1
for i in range(1, 6):
    factorial *= i
print(factorial)

# 使用for循环遍历字符串"Python"，并打印每个字符。
for char in "Python":
    print(char)

# 使用while循环反向打印数字10到1。
i = 10
while i > 0:
    print(i)
    i -= 1

# 使用for循环和range函数，计算从1到10的所有偶数的和。
sum = 0
for i in range(2, 11, 2):
    sum += i
print(sum)

# 编写一个程序，使用for循环找到并打印从1到100内能被7整除的数字。
for i in range(1, 101):
    if i % 7 == 0:
        print(i)

# 创建一个列表，包含一些数字，使用for循环计算列表中数字的平均值。
numbers = [1, 2, 3, 4, 5]
sum = 0
for number in numbers:
    sum += number
average = sum / len(numbers)
print(average)

# 使用for循环，打印出一个3行4列的数字网格（例如，1到12）。
number = 1
for i in range(3):
    for j in range(4):
        print(number, end=" ")
        number += 1
    print()

接下来继续我们的教程

python函数

Python的函数是组织好的，可重复使用的，用来实现单一或相关联功能的代码段。函数可以提高应用的模块性和代码的重用率。下面是关于Python函数的详细介绍：

函数的定义

在Python中，使用def关键字来定义函数，后跟函数名称和圆括号()。任何传入参数和自变量必须放在圆括号中，圆括号之间可以用于定义参数。函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。函数内容以冒号起始，并且缩进。return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回None。

函数的作用

代码复用：定义一次，多处调用，避免代码重复。
模块化设计：将复杂的问题分解成多个简单的模块，提高代码的可读性和可维护性。
隐藏实现细节：用户只需要知道函数的名称、需要的参数以及返回值的类型，而无需了解其内部实现。

函数的调用

一旦定义了函数，就可以通过函数名来调用它。如果函数定义了参数，调用时需传递相同数量的参数。

def printme(str):
    "打印传入的字符串到标准显示设备上"
    print(str)
    return

# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

函数的参数

函数的参数类型有以下几种：

必需参数：必须以正确的顺序传入函数。
关键字参数：调用函数时，使用参数名。
默认参数：调用函数时，默认参数的值如果没有传递，则被认为是默认值。
不定长参数：你可能需要一个函数能处理比当初声明时更多的参数。

函数的使用例子

简单函数

def greet(name):
    """向用户显示问候语"""
    print(f"Hello, {name}!")
    
greet("Alice")

带有默认参数的函数

def info(article, author="Unknown"):
    print(f"Article: {article}")
    print(f"Author: {author}")

info("Python Functions")
info("Advanced Python Functions", "Alice")

使用关键字参数

def student(firstname, lastname):
    print(firstname, lastname)

# 调用时使用参数名
student(firstname="John", lastname="Doe")

可变参数

def add_numbers(*args):
    sum = 0
    for n in args:
        sum += n
    print(sum)

add_numbers(1, 2, 3, 4, 5) # 输出15

python系统函数

Python提供了许多内置的系统函数，这些函数可用于执行各种任务，如类型转换、数学运算、输入输出操作等。下面我将介绍一些常用的Python系统函数，包括它们的使用方法和简单讲解。

1. print()

功能：将信息输出到标准输出设备（通常是屏幕）。

使用示例：

print("Hello, World!")

讲解：print()函数用于打印输出指定的消息。可以输出字符串、数字或其他对象，这些对象会被转换为字符串然后输出。

2. input()

功能：从标准输入设备（通常是键盘）读取输入的字符串。

使用示例：

name = input("Enter your name: ")

print(f"Hello, {name}!")

讲解：input()函数允许用户输入字符串并将其返回。在括号内可以提供一个字符串作为提示语。

3. int(), float(), str()

功能：数据类型转换。

使用示例：

number = int(input("Enter a number: "))

print(f"You entered: {number}")

讲解：int()函数用于将输入转换为整数。类似地，float()转换为浮点数，str()转换为字符串。

4. len()

功能：返回对象（字符、列表、元组等）的长度或元素个数。

使用示例：

message = "Hello, World!"

print(len(message))

讲解：len()函数返回对象的长度。在上面的例子中，它返回字符串"Hello, World!"的字符数。

5. range()

功能：生成一个数字序列。

使用示例：

for i in range(5):

print(i)

讲解：range()函数返回一个序列的数，从0开始，以指定的间隔增加，并在指定的数字前停止。

6. abs()

功能：返回数的绝对值。

使用示例：

print(abs(-5))

讲解：abs()函数返回指定数字的绝对值。在上面的例子中，它返回5。

7. sum()

功能：计算序列中所有元素的总和。

使用示例：

numbers = [1, 2, 3, 4, 5]

print(sum(numbers))

讲解：sum()函数接受一个序列，如列表或元组，并返回序列中所有元素的和。

8. round()

功能：四舍五入数到指定的小数位数。

使用示例：

print(round(3.14159, 2))

讲解：round()函数四舍五入数到指定的小数位数。在这个例子中，它返回3.14。

9. max() 和 min()

功能：分别找出序列中的最大值和最小值。

使用示例：

numbers = [1, 2, 3, 4, 5]

print(max(numbers)) print(min(numbers))

讲解：max() 函数返回给定序列或参数中的最大值，而 min() 函数返回最小值。这些函数不仅适用于数字，还可以用于字母表顺序中的字符串比较。

10. sorted()

功能：返回序列的排序列表。

使用示例：

numbers = [5, 1, 4, 3, 2]

print(sorted(numbers))

讲解：sorted() 函数返回序列排序后的新列表，原序列不会被修改。默认情况下，排序是升序的，但可以通过 reverse=True 参数指定降序排序。

11. type()

功能：返回对象的类型。

使用示例：

print(type(5)) print(type("Hello"))

讲解：type() 函数返回任何对象的类型信息，例如，是否为整数、浮点数、字符串等。

12. isinstance()

功能：检查对象是否为给定类型。

使用示例：

print(isinstance(5, int)) print(isinstance("Hello", str))

讲解：isinstance() 函数用于检查对象是否是指定的类型。它用于类型检查并返回布尔值。

13. help()

功能：显示对象的文档字符串。

使用示例：

help(print)

讲解：help() 函数用于显示任何对象的帮助信息，包括模块、函数、类、方法等的详细说明。

14. id()

功能：返回对象的唯一标识符。

使用示例：

a = "Hello"

print(id(a))

讲解：id() 函数返回对象的内存地址，这是对象的唯一标识符。

15. eval()

功能：执行字符串表达式，并返回表达式的值。

使用示例：

result = eval("3 + 5")

print(result)

讲解：eval() 函数解析并执行表达式中的Python代码，并返回结果。这个函数非常强大，但也要小心使用，因为它可以执行任意代码。

16. zip()

功能：将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

使用示例：

names = ["Alice", "Bob", "Charlie"]

ages = [25, 30, 35]

for name, age in zip(names, ages):

print(f"{name} is {age} years old.")

这些只是Python中许多内置函数的一小部分。理解和熟练使用这些函数可以帮助你更有效地编写Python代码

python面向对象

类和对象

问题: Python中的类和对象是什么？

解释: 在Python中，类是创建对象的蓝图或模板，而对象是类的实例。类定义了对象的属性和可以对这些属性进行操作的方法。

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def bark(self):
        return f"{self.name} says woof!"

# 创建Dog类的一个实例
my_dog = Dog("Rex", 2)
print(my_dog.bark())

继承

问题: 继承是什么？

解释: 继承是一个类（称为子类）可以继承另一个类（称为父类）的属性和方法的过程。继承允许我们定义一个通用的类，然后扩展或修改这个类来创建更专用的类，而不必重新编写共享代码。

示例代码:

class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        raise NotImplementedError("Subclass must implement abstract method")

class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} says Meow!"

dog = Dog("Max")
cat = Cat("Felix")
print(dog.speak())
print(cat.speak())

封装

问题: 封装是什么？

解释: 封装是OOP(面向对象)的一个核心概念，它指的是将对象的数据（属性）和代码（方法）包装在单个单元中，并对对象的实现细节进行隐藏和保护。这样，对象的内部表示对外部是不可见的，只能通过定义好的接口进行访问。

class Account:
    def __init__(self, owner, amount=0):
        self.owner = owner
        self.__amount = amount  # 私有属性

    def deposit(self, amount):
        if amount > 0:
            self.__amount += amount
            print(f"Deposited: {amount}")

    def get_balance(self):
        return self.__amount

account = Account("Alice", 100)
account.deposit(50)
print(account.get_balance())

多态

问题: 多态是什么？

解释: 多态是指同一操作作用于不同的对象，可以有不同的解释和不同的执行结果。多态性意味着不同类的对象可以使用相同的接口，但各自实现这个接口的方式可以不同。

class Document:
    def show(self):
        raise NotImplementedError("Subclass must implement abstract method")

class Pdf(Document):
    def show(self):
        return "Display PDF content"

class Word(Document):
    def show(self):
        return "Display Word content"

documents = [Pdf(), Word()]
for document in documents:
    print(document.show())

通过这些模块，我们可以看到Python面向对象编程的力量和灵活性，以及如何通过类和对象的使用来构建更有效、更易于管理和维护的代码。

在Python中，类与对象的概念是通过一系列的特殊方法和关键字来支持的，这些都是面向对象编程（OOP）的核心部分。下面是对这些关键概念的连贯描述。

首先，self关键字在类的方法定义中非常重要。它代表类实例本身，使得实例能够访问类中的属性和方法。当你定义一个对象的方法时，self是自动传入的第一个参数，但在调用这个方法时，你不需要显式传递它。

__init__方法是一个特殊的方法，被称为类的构造器。当一个类被实例化时，__init__方法自动被调用。它可以接受参数，这些参数在创建类的实例时传递，主要用于初始化对象。例如，你可以在这个方法中设置对象的初始状态或者对一些属性赋初值。

与__init__相对的是__del__方法，它是类的析构器。当对象被销毁时，__del__方法被自动调用。尽管在Python中，垃圾回收机制会自动处理内存管理，但有时你需要在对象销毁前执行一些清理工作，这时就可以使用__del__方法。

__len__是另一个特殊方法，它应返回容器中元素的数量。例如，如果你定义了一个代表一组元素的类，__len__可以使得len()函数返回这个容器中元素的数量。

__str__方法用于定义对象的“非正式”或可打印的字符串表示。当你使用print()函数打印一个对象，或者在字符串格式化中使用str()时，Python会调用这个方法。

super()函数在继承体系中扮演重要角色，它用于调用父类的方法。这在重写父类方法的时候非常有用，特别是当你想要在子类中扩展而不是完全替换父类方法的功能时。

@classmethod装饰器用于标记一个方法为类方法，这意味着这个方法属于类而不是类的实例。类方法的第一个参数是类本身，通常命名为cls。类方法可以被类直接调用，也可以被类的所有实例调用，而不依赖于具体的实例。

@staticmethod装饰器将方法标记为静态方法。静态方法不接受self或cls参数，这意味着它们既不需要类实例也不需要类本身的引用就可以被调用。静态方法主要用于放置属于类的逻辑，但是这个逻辑不依赖于类的具体实例。

python常见系统对象的使用方法

# 列表 List
my_list = [1, 2, 3, 4, 5]
my_list.append(6)  # 添加元素
my_list.remove(2)  # 移除元素
print(f"List: {my_list}")

# 字典 Dictionary
my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
my_dict['age'] = 31  # 更新键值
print(f"Dictionary: {my_dict}")

# 元组 Tuple
my_tuple = (1, 2, 3)
print(f"Tuple: {my_tuple}")

# 集合 Set
my_set = {1, 2, 3, 4, 5}
my_set.add(6)  # 添加元素
my_set.discard(2)  # 移除元素
print(f"Set: {my_set}")

# 字符串 String
my_string = "Hello, Python!"
print(f"String: {my_string.upper()}")  # 转大写

# 整数 Integer
my_int = 10
print(f"Integer: {my_int ** 2}")  # 幂运算

# 浮点数 Float
my_float = 3.14
print(f"Float: {my_float * 2}")  # 乘法

# 列表推导式 List Comprehension
squares = [x**2 for x in range(10)]
print(f"List Comprehension: {squares}")

# 字典推导式 Dictionary Comprehension
square_dict = {x: x**2 for x in range(5)}
print(f"Dictionary Comprehension: {square_dict}")

# 集合推导式 Set Comprehension
square_set = {x**2 for x in [1, 2, 3, 2]}
print(f"Set Comprehension: {square_set}")

# 元组解包 Tuple Unpacking
a, b, c = my_tuple
print(f"Tuple Unpacking: a={a}, b={b}, c={c}")

# 多重赋值 Chained Assignment
x = y = z = 0
print(f"Chained Assignment: x={x}, y={y}, z={z}")

# 使用enumerate遍历列表和索引
for index, value in enumerate(my_list):
    print(f"Enumerate: index={index}, value={value}")

# 使用zip并行遍历两个列表
names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
for name, age in zip(names, ages):
    print(f"Zip: name={name}, age={age}")

# 使用filter和map
even_numbers = list(filter(lambda x: x % 2 == 0, my_list))
squared_numbers = list(map(lambda x: x**2, my_list))
print(f"Filter: {even_numbers}")
print(f"Map: {squared_numbers}")