一篇文章带入门Python：从零基础到写出第一个程序

原创

小白的大数据之旅

发布于 2025-07-19 17:55:59

3.4K0

一篇文章带入门 Python：从零基础到写出第一个程序

你是不是总觉得编程很难，全是看不懂的符号和英文？其实完全不是这样！Python 就是一门让普通人也能轻松学会的编程语言。今天这篇文章，我就用大白话带你从零开始，一步步写出你的第一个 Python 程序，看完你会发现：原来编程这么简单！

准备工作：安装 Python 和编辑器

在开始之前，我们需要准备两个工具：Python 解释器和一个编辑器。这就好比我们要写字，需要有笔（Python 解释器）和纸（编辑器）。

安装 Python

打开浏览器，访问 Python 官网：https://www.python .org/downl oads/
网站会自动推荐适合你电脑系统的版本，点击 "Download Python x.x.x" 按钮（x.x.x 是版本号）
下载完成后，双击安装文件
重要：安装时一定要勾选 "Add Python to PATH"，然后点击 "Install Now"
等待安装完成，点击 "Close"

安装完成后，我们可以检查一下是否安装成功：

按下 Win+R，输入 "cmd"，回车打开命令提示符
输入 "python --version"，如果显示类似 "Python 3.11.4" 的信息，就说明安装成功了

安装编辑器

推荐使用 PyCharm 社区版，免费又好用：

访问官网：PyCharm
选择 "Community" 版本下载（免费）
安装时按照默认选项即可，中间可以勾选 "Add launchers dir to PATH"

安装完成后，我们就可以开始学习 Python 了！

一、核心语法：打好编程地基

1. 第一个程序：Hello World

让我们从最简单的程序开始，打印 "Hello World"。这就像学英语先学 "Hello" 一样，是编程的入门第一课。

打开 PyCharm，点击 "New Project"，选择一个文件夹作为项目位置，然后点击 "Create"。右键项目文件夹，选择 "New" -> "Python File"，文件名输入 "hello"，然后在打开的编辑区输入：

print("Hello World")

右键编辑区，选择 "Run 'hello'"，你会在下方看到输出：

Hello World

恭喜！你已经写出了第一个 Python 程序！

print 函数的作用就是把括号里的内容显示在屏幕上。除了文字，它还能打印数字、计算结果等：

print(123)  # 打印数字


print(1 + 2)  # 打印计算结果


print("1 + 2 =", 3)  # 同时打印文字和数字

运行结果：

2. 变量：给数据起个名字

变量就像一个盒子，我们可以把数据放进去，以后需要的时候直接用盒子的名字就行了。比如：

# 定义变量


name = "小明"

age = 18

height = 1.75

# 使用变量


print(name)


print(age)


print(name + "今年" + str(age) + "岁")  # str()是把数字转换成字符串才能拼接

运行结果：

小明

18

小明今年18岁

变量名的命名规则：

只能包含字母、数字和下划线
不能以数字开头
不能用 Python 的关键字（比如 if、for、while 等）
区分大小写（name 和 Name 是两个不同的变量）
最好起有意义的名字，让人一看就知道这个变量存的是什么

3. 数据类型：不同的数据有不同的类型

Python 中有多种数据类型，就像现实中有整数、小数、文字等不同类型的数据一样。

基本数据类型

类型	说明	例子
整数 (int)	没有小数部分的数字	1, 200, -30
浮点数 (float)	带小数点的数字	3.14, -0.5, 2.0
字符串 (str)	文本，用单引号或双引号包围	"Hello", 'Python', "123"
布尔值 (bool)	只有两个值：True（真）和 False（假）	True, False
列表 (list)	有序的集合，可以包含不同类型的数据	1, "apple", 3.14
字典 (dict)	键值对的集合，类似现实中的字典	{"name": "小明", "age": 18}
元组 (tuple)	类似列表，但内容不能修改	(1, 2, 3)
集合 (set)	无序的不重复元素集合	{1, 2, 3}

我们可以用 type () 函数查看变量的类型：

name = "小明"

age = 18

height = 1.75

is_student = True

print(type(name))    # 输出：<class 'str'>


print(type(age))     # 输出：<class 'int'>


print(type(height))  # 输出：<class 'float'>


print(type(is_student))  # 输出：<class 'bool'>

字符串 (str)

字符串是用单引号或双引号包围的文本。单引号和双引号在 Python 中没有区别，选一种用就好。

# 字符串的两种表示方式


message1 = "I love Python"

message2 = 'Python is easy'

# 如果字符串里包含引号，可以混合使用


message3 = "He said 'Hello'"

message4 = 'She said "Hi"'

字符串常用操作：

# 字符串拼接


first_name = "张"

last_name = "三"

full_name = first_name + last_name  # 结果是"张三"

# 字符串重复


star = "*"

line = star * 10  # 结果是"**********"

# 字符串长度


length = len(full_name)  # 结果是2

# 字符串索引（获取单个字符）


# 注意：Python中索引从0开始


first_char = full_name[0]  # 结果是"张"

second_char = full_name[1]  # 结果是"三"

# 字符串切片（获取子串）


text = "Hello Python"

sub_text = text[0:5]  # 从索引0到4（不包含5）的字符，结果是"Hello"

sub_text2 = text[6:]  # 从索引6到结尾，结果是"Python"

f - 字符串：轻松拼接复杂文本

Python 3.6 以上版本支持 f - 字符串，让字符串拼接变得非常简单：

name = "小明"

age = 18

height = 1.75

# 以前的拼接方式


message1 = name + "今年" + str(age) + "岁，身高" + str(height) + "米"

# f-字符串方式


message2 = f"{name}今年{age}岁，身高{height}米"

print(message1)


print(message2)

两种方式输出结果相同，但 f - 字符串更简洁直观。在 f - 字符串中，{ } 里可以放变量、表达式甚至函数调用：

a = 10

b = 20

print(f"{a} + {b} = {a + b}")  # 输出：10 + 20 = 30

print(f"半斤八两：{500}克 + {500}克 = {500 + 500}克")  # 输出：半斤八两：500克 + 500克 = 1000克

数字 (int, float)

数字类型包括整数 (int) 和浮点数 (float)。Python 支持各种数学运算：

a = 10

b = 3

# 基本运算


print(a + b)  # 加法：13

print(a - b)  # 减法：7

print(a * b)  # 乘法：30

print(a / b)  # 除法：3.3333333333333335

print(a // b) # 整除（取商）：3

print(a % b)  # 取余：1

print(a **b) # 幂运算（a的b次方）：1000

# 赋值运算


x = 5

x += 3  # 相当于 x = x + 3，结果是8

x *= 2  # 相当于 x = x * 2，结果是16

print(x)

列表 (list)

列表就像一个有序的容器，可以存放多个数据，数据类型可以不同。

# 创建列表


fruits = ["apple", "banana", "orange"]


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


mixed = [1, "apple", 3.14, True]


# 访问列表元素（索引从0开始）


print(fruits[0])  # 输出：apple


print(numbers[2])  # 输出：3

# 修改元素


fruits[1] = "grape"

print(fruits)  # 输出：['apple', 'grape', 'orange']


# 列表长度


print(len(fruits))  # 输出：3

# 添加元素


fruits.append("banana")  # 在末尾添加


print(fruits)  # 输出：['apple', 'grape', 'orange', 'banana']


# 插入元素


fruits.insert(1, "pear")  # 在索引1的位置插入


print(fruits)  # 输出：['apple', 'pear', 'grape', 'orange', 'banana']


# 删除元素


del fruits[2]  # 删除索引2的元素


print(fruits)  # 输出：['apple', 'pear', 'orange', 'banana']


# 切片操作（获取子列表）


print(numbers[1:4])  # 从索引1到3的元素：[2, 3, 4]


print(numbers[:3])   # 从开头到索引2的元素：[1, 2, 3]


print(numbers[2:])   # 从索引2到结尾的元素：[3, 4, 5]

字典 (dict)

字典是键值对的集合，就像现实中的字典，通过 "键"（关键词）可以快速找到 "值"（解释）。

# 创建字典


person = {


   "name": "小明",


   "age": 18,


   "height": 1.75,


   "is_student": True

}


# 访问值


print(person["name"])  # 输出：小明


print(person["age"])   # 输出：18

# 修改值


person["age"] = 19

print(person["age"])   # 输出：19

# 添加新的键值对


person["gender"] = "男"

print(person)  # 输出中会包含'gender': '男'

# 删除键值对


del person["height"]


print(person)  # 输出中不会再有'height'

# 获取所有键


print(person.keys())  # 输出：dict_keys(['name', 'age', 'is_student', 'gender'])


# 获取所有值


print(person.values())  # 输出：dict_values(['小明', 19, True, '男'])


# 检查键是否存在


print("name" in person)  # 输出：True

print("weight" in person)  # 输出：False

4. 类型注解：让代码更清晰

类型注解是 Python 3.5 引入的功能，它可以标注变量、函数参数和返回值的类型，让代码更易读，也方便 IDE 提供更好的提示。

# 变量的类型注解


name: str = "小明"

age: int = 18

height: float = 1.75

is_student: bool = True

fruits: list[str] = ["apple", "banana"]


person: dict[str, str | int] = {"name": "小明", "age": 18}


# 函数的类型注解


def add(a: int, b: int) -> int:


   return a + b


def greet(name: str) -> str:


   return f"Hello, {name}!"

类型注解不会影响程序的运行，Python 解释器会忽略这些注解。它的主要作用是：

提高代码的可读性，让人一看就知道变量和函数的类型
帮助 IDE 提供更好的自动补全和错误提示
方便进行静态类型检查（使用 mypy 等工具）

二、流程控制与函数：让程序更智能

1. 条件判断：if-elif-else

条件判断让程序可以根据不同情况做出不同的反应，就像我们日常生活中的选择一样。

age = 18

if age >= 18:


   print("你已成年，可以观看R级电影")


else:


   print("你未成年，不能观看R级电影")

如果有多个条件，可以使用 elif（else if 的缩写）：

score = 85

if score >= 90:


   print("优秀")


elif score >= 80:


   print("良好")


elif score >= 60:


   print("及格")


else:


   print("不及格")

条件判断可以嵌套：

age = 17

has_id = True

if age >= 18:


   print("年龄符合要求")


   if has_id:


       print("可以进入")


   else:


       print("请出示身份证")


else:


   print("年龄不符合要求，不能进入")

常见的比较运算符：

运算符	说明
==	等于
!=	不等于
	大于
<	小于
=	大于等于
<=	小于等于

逻辑运算符：

运算符	说明	例子
and	与（两个条件都为真才为真）	a > 0 and b > 0
or	或（至少一个条件为真就为真）	a > 0 or b > 0
not	非（取反）	not a > 0

# 逻辑运算符的例子


a = 10

b = -5

print(a > 0 and b > 0)  # 输出：False（因为b不大于0）


print(a > 0 or b > 0)   # 输出：True（因为a大于0）


print(not a > 0)        # 输出：False（因为a大于0）

2. 循环：重复做一件事

循环可以让程序重复执行一段代码，避免重复编写相同的代码。Python 中有两种循环：for 循环和 while 循环。

for 循环

for 循环通常用于遍历序列（如列表、字符串等）：

# 遍历列表


fruits = ["apple", "banana", "orange"]


for fruit in fruits:


   print(fruit)


# 遍历字符串


message = "Hello"

for char in message:


   print(char)


# 使用range函数生成数字序列


for i in range(5):  # range(5)生成0,1,2,3,4

   print(i)


for i in range(2, 7):  # range(2,7)生成2,3,4,5,6

   print(i)


for i in range(1, 10, 2):  # range(1,10,2)生成1,3,5,7,9（步长为2）


   print(i)

while 循环

while 循环在条件为真时重复执行代码块：

# 基本用法


count = 0

while count < 5:


   print(count)


   count += 1  # 不要忘记更新条件，否则会无限循环


# 无限循环（需要手动中断）


# 注意：运行这个代码会导致程序一直运行，需要按Ctrl+C中断


"""


while True:


   print("这是一个无限循环")


"""

循环控制：break 和 continue

break 用于跳出整个循环，continue 用于跳过当前循环中的剩余语句，直接开始下一次循环。

# 使用break

for i in range(10):


   if i == 5:


       break  # 当i等于5时，跳出循环


   print(i)  # 只会打印0,1,2,3,4

# 使用continue

for i in range(10):


   if i % 2 == 0:


       continue  # 当i是偶数时，跳过当前循环的剩余部分


   print(i)  # 只会打印1,3,5,7,9

3. 函数：封装重复代码

函数是一段可以重复使用的代码块，它可以接收输入参数，处理后返回结果。使用函数可以让代码更简洁、更易维护。

函数的定义和调用

# 定义一个简单的函数


def greet():


   print("Hello, World!")


# 调用函数


greet()  # 输出：Hello, World!


# 带参数的函数


def greet_person(name):


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


greet_person("小明")  # 输出：Hello, 小明!


greet_person("小红")  # 输出：Hello, 小红!


# 带返回值的函数


def add(a, b):


   result = a + b


   return result  # 返回计算结果


sum_result = add(3, 5)


print(sum_result)  # 输出：8

print(add(10, 20))  # 输出：30

# 带默认参数的函数


def greet_time(name, time="morning"):


   print(f"Good {time}, {name}!")


greet_time("小明")  # 输出：Good morning, 小明!（使用默认参数）


greet_time("小红", "afternoon")  # 输出：Good afternoon, 小红!（指定参数）

函数的参数类型

Python 函数的参数有多种形式：

位置参数：必须按照顺序传递的参数
关键字参数：通过参数名指定的参数，可以不按顺序
可变参数：可以接收任意数量的参数

# 位置参数和关键字参数


def introduce(name, age, city):


   print(f"我叫{name}，今年{age}岁，来自{city}。")


# 位置参数调用（必须按顺序）


introduce("小明", 18, "北京")


# 关键字参数调用（可以不按顺序）


introduce(name="小红", city="上海", age=19)


# 混合使用（位置参数必须在关键字参数前面）


introduce("小刚", city="广州", age=20)


# 可变参数


def sum_numbers(*args):  # *args表示接收任意数量的位置参数，会被包装成一个元组


   total = 0

   for num in args:


       total += num


   return total


print(sum_numbers(1, 2, 3))  # 输出：6

print(sum_numbers(10, 20, 30, 40))  # 输出：100

def print_info(**kwargs):  # **kwargs表示接收任意数量的关键字参数，会被包装成一个字典


   for key, value in kwargs.items():


       print(f"{key}: {value}")


print_info(name="小明", age=18, city="北京")


# 输出：


# name: 小明


# age: 18

# city: 北京

函数的嵌套

函数内部可以定义其他函数，这就是函数的嵌套。

def outer_function():


   print("这是外部函数")


  


   def inner_function():


       print("这是内部函数")


  


   inner_function()  # 在外部函数内部调用内部函数


outer_function()


# 输出：


# 这是外部函数


# 这是内部函数


# 注意：内部函数不能在外部函数外面直接调用


# inner_function()  # 这行代码会报错

三、多态：面向对象编程的核心概念

多态是面向对象编程（OOP）的三大特性之一（另外两个是封装和继承）。简单来说，多态就是 "同一接口，多种实现"，也就是说，不同的对象可以对同一消息做出不同的响应。

在讲多态之前，我们需要先了解一些面向对象的基本概念。

1. 类和对象：面向对象的基础

类是对象的模板，对象是类的实例。比如，"人" 是一个类，而 "小明"、"小红" 就是这个类的对象。

# 定义一个简单的类


class Person:


   # 初始化方法，创建对象时会自动调用


   def __init__(self, name, age):


       self.name = name  # 实例属性


       self.age = age    # 实例属性


  


   # 实例方法


   def introduce(self):


       print(f"我叫{self.name}，今年{self.age}岁。")


# 创建对象（实例化）


person1 = Person("小明", 18)


person2 = Person("小红", 19)


# 访问对象的属性


print(person1.name)  # 输出：小明


print(person2.age)   # 输出：19

# 调用对象的方法


person1.introduce()  # 输出：我叫小明，今年18岁。


person2.introduce()  # 输出：我叫小红，今年19岁。

2. 继承：代码复用的利器

继承允许我们定义一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码复用。

# 父类


class Animal:


   def __init__(self, name):


       self.name = name


  


   def eat(self):


       print(f"{self.name}在吃东西")


  


   def sleep(self):


       print(f"{self.name}在睡觉")


# 子类继承父类


class Dog(Animal):


   # 子类可以有自己的方法


   def bark(self):


       print(f"{self.name}在汪汪叫")


class Cat(Animal):


   # 子类可以重写父类的方法


   def sleep(self):


       print(f"{self.name}在懒洋洋地睡觉")


  


   def meow(self):


       print(f"{self.name}在喵喵叫")


# 创建子类对象


dog = Dog("旺财")


cat = Cat("咪咪")


# 子类对象可以调用父类的方法


dog.eat()  # 输出：旺财在吃东西


cat.sleep()  # 输出：咪咪在懒洋洋地睡觉（调用的是重写后的方法）


# 子类对象可以调用自己的方法


dog.bark()  # 输出：旺财在汪汪叫


cat.meow()  # 输出：咪咪在喵喵叫

3. 多态：同一接口，多种实现

多态是指不同的对象对同一消息（方法调用）可以做出不同的响应。在 Python 中，多态是通过方法重写和动态类型实现的。

# 定义父类


class Shape:


   def area(self):


       # 父类方法，可以留空或抛出异常


       raise NotImplementedError("子类必须实现area方法")


# 子类1：圆形


class Circle(Shape):


   def __init__(self, radius):


       self.radius = radius


  


   def area(self):


       # 重写父类的area方法


       import math


       return math.pi * self.radius** 2

# 子类2：矩形


class Rectangle(Shape):


   def __init__(self, width, height):


       self.width = width


       self.height = height


  


   def area(self):


       # 重写父类的area方法


       return self.width * self.height

# 子类3：三角形


class Triangle(Shape):


   def __init__(self, base, height):


       self.base = base


       self.height = height


  


   def area(self):


       # 重写父类的area方法


       return 0.5 * self.base * self.height

# 多态的体现：同一接口（调用area方法），不同实现


def print_area(shape):


   # 只要对象有area方法，就可以调用，不管它具体是什么类型


   print(f"面积是：{shape.area()}")


# 创建不同的形状对象


circle = Circle(5)


rectangle = Rectangle(4, 6)


triangle = Triangle(3, 8)


# 调用同一个函数，传入不同的对象


print_area(circle)    # 输出：面积是：78.53981633974483

print_area(rectangle) # 输出：面积是：24

print_area(triangle)  # 输出：面积是：12.0

在这个例子中，Circle、Rectangle 和 Triangle 都是 Shape 的子类，它们都重写了 area 方法。print_area 函数接收一个 shape 参数，调用它的 area 方法。不管传入的是哪种形状的对象，print_area 函数都能正确计算并打印面积，这就是多态的体现。

多态的好处：

提高代码的灵活性和可扩展性
简化代码，减少条件判断
使代码更容易维护和理解

4. 多态的常见问题和错误

常见问题

没有重写父类方法：如果子类没有重写父类的方法，调用时会使用父类的方法，可能不符合预期。

class Shape:


   def area(self):


       return 0

class Square(Shape):


   # 忘记重写area方法


   def __init__(self, side):


       self.side = side


square = Square(5)


print(square.area())  # 输出：0（使用了父类的方法，而不是我们期望的25）

解决方法：确保子类重写了父类中需要定制的方法。

方法签名不一致：子类重写的方法与父类方法的参数不一致，可能导致调用时出错。

class Animal:


   def make_sound(self):


       print("动物发出声音")


class Dog(Animal):


   # 重写的方法增加了参数，与父类不一致


   def make_sound(self, volume):


       print(f"狗汪汪叫，音量：{volume}")


animal = Dog()


# 这样调用会出错，因为我们习惯了父类的调用方式


# animal.make_sound()  # 报错：TypeError: Dog.make_sound() missing 1 required positional argument: 'volume'

解决方法：重写方法时尽量保持与父类方法的签名一致，可以使用默认参数来保持兼容性。

class Animal:


   def make_sound(self):


       print("动物发出声音")


class Dog(Animal):


   # 使用默认参数保持兼容性


   def make_sound(self, volume="中等"):


       print(f"狗汪汪叫，音量：{volume}")


animal = Dog()


animal.make_sound()  # 输出：狗汪汪叫，音量：中等（可以像调用父类方法一样调用）


animal.make_sound("大声")  # 输出：狗汪汪叫，音量：大声（也可以传入参数）

过度使用多态：有时候简单的条件判断可能比复杂的多态结构更清晰，不要为了使用多态而过度设计。

常见错误

调用不存在的方法：如果传入的对象没有实现预期的方法，会导致 AttributeError。

def print_area(shape):


   print(shape.area())  # 期望对象有area方法


class Line:


   # Line类没有area方法


   def __init__(self, length):


       self.length = length


line = Line(10)


# print_area(line)  # 报错：AttributeError: 'Line' object has no attribute 'area'

解决方法：可以使用抽象基类（ABC）来强制子类实现特定方法，或者在调用前检查方法是否存在。

from abc import ABC, abstractmethod


# 使用抽象基类强制子类实现area方法


class Shape(ABC):


   @abstractmethod

   def area(self):


       pass


# class Line(Shape):  # 这样定义会报错，因为Line没有实现area方法


#     pass


# 检查方法是否存在


def print_area(shape):


   if hasattr(shape, 'area') and callable(shape.area):


       print(shape.area())


   else:


       print("对象没有area方法")


class Line:


   def __init__(self, length):


       self.length = length


line = Line(10)


print_area(line)  # 输出：对象没有area方法（不会报错）

类型判断破坏多态：使用 type () 或 isinstance () 进行类型判断，然后根据类型执行不同操作，这会破坏多态的灵活性。

# 不推荐的做法：使用类型判断


def print_info(shape):


   if isinstance(shape, Circle):


       print(f"圆形，半径：{shape.radius}，面积：{shape.area()}")


   elif isinstance(shape, Rectangle):


       print(f"矩形，宽：{shape.width}，高：{shape.height}，面积：{shape.area()}")


   elif isinstance(shape, Triangle):


       print(f"三角形，底：{shape.base}，高：{shape.height}，面积：{shape.area()}")


# 推荐的做法：使用多态


class Shape:


   def area(self):


       raise NotImplementedError("子类必须实现area方法")


  


   def info(self):


       raise NotImplementedError("子类必须实现info方法")


class Circle(Shape):


   # ... 省略其他代码 ...


   def info(self):


       return f"圆形，半径：{self.radius}，面积：{self.area()}"

# 其他类类似实现info方法...


def print_info(shape):


   print(shape.info())  # 只需要调用info方法，不用关心具体类型

5. 多态相关的面试题及参考答案

面试题 1：什么是多态？Python 中如何实现多态？

参考答案：

多态是面向对象编程的三大特性之一，指的是不同的对象对同一消息（方法调用）可以做出不同的响应。简单来说，就是同一接口，多种实现。

在 Python 中，多态的实现主要依靠两个机制：

方法重写：子类可以重写父类的方法，实现自己的逻辑
动态类型：Python 是动态类型语言，不需要像 Java 等静态类型语言那样显式声明接口，只要对象有对应的方法，就可以调用，而不关心它的具体类型

例如，我们可以定义一个 Shape 类，然后让 Circle、Rectangle 等子类继承它并实现自己的 area 方法。当我们调用一个接收 Shape 对象的函数时，不管传入的是 Circle 还是 Rectangle，都能正确计算面积，这就是多态的体现。

面试题 2：多态有什么好处？

参考答案：

多态的主要好处有：

提高代码的灵活性和可扩展性：当需要添加新的功能时，只需要添加新的子类并实现相应的方法，不需要修改已有的代码
简化代码，减少条件判断：不需要使用大量的 if-elif-else 来判断对象类型，而是通过多态让不同对象自己处理
使代码更容易维护和理解：多态遵循 "开闭原则"（对扩展开放，对修改关闭），使代码结构更清晰

面试题 3：Python 中的多态与其他语言（如 Java）有什么区别？

参考答案：

Python 中的多态与 Java 等静态类型语言相比，主要区别在于：

动态类型 vs 静态类型：

Python 是动态类型语言，不需要显式声明接口或使用关键字（如 Java 的 implements）
Java 是静态类型语言，需要显式声明类实现了哪个接口

"鸭子类型"：

Python 遵循 "鸭子类型"："如果它走起来像鸭子，叫起来像鸭子，那么它就是鸭子"
这意味着在 Python 中，只要对象有需要的方法，就可以被使用，不需要严格的继承关系
而 Java 等语言需要严格的类型检查

例如，在 Python 中，我们可以定义一个函数接收任何有 fly () 方法的对象，不管它是否继承自某个特定的类；而在 Java 中，必须显式声明这些类实现了一个有 fly () 方法的接口。

面试题 4：如何确保子类实现了父类的某个方法？

参考答案：

在 Python 中，可以使用抽象基类（ABC）来确保子类实现了父类的特定方法。具体做法是：

导入 abc 模块中的 ABC 和 abstractmethod
让父类继承 ABC
用 @abstractmethod 装饰需要子类实现的方法

这样，如果子类没有实现被 @abstractmethod 装饰的方法，在实例化子类时就会报错，从而确保子类一定实现了这些方法。

示例代码：

from abc import ABC, abstractmethod


class Shape(ABC):


   @abstractmethod

   def area(self):


       pass


class Circle(Shape):


   # 如果不实现area方法，实例化时会报错


   def __init__(self, radius):


       self.radius = radius


  


   def area(self):


       return 3.14 * self.radius **2

四、实战项目：编写第一个聊天机器人

现在，我们已经学习了 Python 的基本语法、流程控制、函数和面向对象编程的基础知识。接下来，让我们动手编写一个简单的聊天机器人，巩固所学的知识。

这个聊天机器人将实现以下功能：

问候用户
回应简单的对话
进行数学计算
处理用户输入错误

1. 基本框架

首先，我们来搭建聊天机器人的基本框架：

def chat_bot():


   print("你好！我是你的聊天机器人。有什么我可以帮助你的吗？")


   print("输入'再见'可以结束聊天。")


  


   while True:


       # 获取用户输入


       user_input = input("你：")


      


       # 检查是否要结束聊天


       if user_input == "再见":


           print("机器人：再见！祝你有个愉快的一天！")


           break

      


       # 处理用户输入并生成回应


       response = get_response(user_input)


       print(f"机器人：{response}")


def get_response(user_input):


   # 这里将实现生成回应的逻辑


   return "我不太明白你的意思。"

# 启动聊天机器人


if __name__ == "__main__":


   chat_bot()

运行这段代码，你会看到一个简单的聊天界面，但它还不能理解你的输入，只会回复 "我不太明白你的意思。"

2. 添加基本对话功能

让我们完善 get_response 函数，添加一些基本的对话功能：

def get_response(user_input):


   # 转换为小写，使匹配不区分大小写


   user_input = user_input.lower()


  


   # 问候语


   if "你好" in user_input or "hello" in user_input or "hi" in user_input:


       return "你好！很高兴见到你！"

  


   # 询问名字


   if "名字" in user_input or "叫什么" in user_input:


       return "我是一个聊天机器人，你可以叫我小P。"

  


   # 询问天气


   if "天气" in user_input:


       return "抱歉，我现在还不能查询天气。"

  


   # 询问年龄


   if "年龄" in user_input or "多大" in user_input:


       return "我是一个机器人，没有年龄哦。"

  


   # 默认回应


   return "我不太明白你的意思。你可以问我一些其他问题试试？"

现在，聊天机器人可以回应一些基本的问题了。

3. 添加数学计算功能

让我们给机器人添加数学计算功能，它可以计算加减乘除等基本运算：

def calculate(expression):


   """计算数学表达式并返回结果"""

   try:


       # 使用eval函数计算表达式


       # 注意：在实际应用中，使用eval有安全风险，这里仅作为示例


       result = eval(expression)


       return f"计算结果是：{result}"

   except Exception as e:


       return f"计算错误：{str(e)}"

def get_response(user_input):


   # 保留之前的代码...


  


   # 数学计算


   # 检查输入是否包含数学运算符


   operators = ["+", "-", "*", "/", "=", ">", "<"]


   if any(op in user_input for op in operators):


       # 尝试提取表达式（简单处理，实际应用中可能需要更复杂的解析）


       # 这里假设整个输入都是表达式


       return calculate(user_input)


  


   # 默认回应


   return "我不太明白你的意思。你可以问我一些其他问题试试？或者让我帮你做数学计算？"

现在，你可以输入 "1+2"、"5*6" 等数学表达式，机器人会帮你计算结果。

4. 添加异常处理

我们已经在 calculate 函数中使用了 try-except 来处理计算错误。让我们在整个程序中添加更多的异常处理，使程序更健壮：

def chat_bot():


   print("你好！我是你的聊天机器人。有什么我可以帮助你的吗？")


   print("输入'再见'可以结束聊天。我还可以帮你做数学计算哦！")


  


   while True:


       try:


           # 获取用户输入


           user_input = input("你：")


          


           # 检查是否为空输入


           if not user_input.strip():


               print("机器人：请输入一些内容哦！")


               continue

          


           # 检查是否要结束聊天


           if user_input == "再见":


               print("机器人：再见！祝你有个愉快的一天！")


               break

          


           # 处理用户输入并生成回应


           response = get_response(user_input)


           print(f"机器人：{response}")


          


       except KeyboardInterrupt:


           # 处理用户按Ctrl+C中断


           print("n机器人：聊天被中断，再见！")


           break

       except Exception as e:


           # 处理其他未知错误


           print(f"机器人：发生错误：{str(e)}。我们继续聊天吧！")

现在，即使程序出现一些意外情况，也不会直接崩溃，而是会给出友好的提示。

5. 完整的聊天机器人代码

def calculate(expression):


   """计算数学表达式并返回结果"""

   try:


       # 使用eval函数计算表达式


       # 注意：在实际应用中，使用eval有安全风险，这里仅作为示例


       result = eval(expression)


       return f"计算结果是：{result}"

   except Exception as e:


       return f"计算错误：{str(e)}"

def get_response(user_input):


   """根据用户输入生成回应"""

   # 转换为小写，使匹配不区分大小写


   user_input_lower = user_input.lower()


  


   # 问候语


   if "你好" in user_input_lower or "hello" in user_input_lower or "hi" in user_input_lower:


       return "你好！很高兴见到你！"

  


   # 询问名字


   if "名字" in user_input_lower or "叫什么" in user_input_lower:


       return "我是一个聊天机器人，你可以叫我小P。"

  


   # 询问天气


   if "天气" in user_input_lower:


       return "抱歉，我现在还不能查询天气。"

  


   # 询问年龄


   if "年龄" in user_input_lower or "多大" in user_input_lower:


       return "我是一个机器人，没有年龄哦。"

  


   # 数学计算


   operators = ["+", "-", "*", "/", "=", ">", "<"]


   if any(op in user_input for op in operators):


       return calculate(user_input)


  


   # 默认回应


   return "我不太明白你的意思。你可以问我一些其他问题试试？或者让我帮你做数学计算？"

def chat_bot():


   print("你好！我是你的聊天机器人。有什么我可以帮助你的吗？")


   print("输入'再见'可以结束聊天。我还可以帮你做数学计算哦！")


  


   while True:


       try:


           # 获取用户输入


           user_input = input("你：")


          


           # 检查是否为空输入


           if not user_input.strip():


               print("机器人：请输入一些内容哦！")


               continue

          


           # 检查是否要结束聊天


           if user_input == "再见":


               print("机器人：再见！祝你有个愉快的一天！")


               break

          


           # 处理用户输入并生成回应


           response = get_response(user_input)


           print(f"机器人：{response}")


          


       except KeyboardInterrupt:


           # 处理用户按Ctrl+C中断


           print("n机器人：聊天被中断，再见！")


           break

       except Exception as e:


           # 处理其他未知错误


           print(f"机器人：发生错误：{str(e)}。我们继续聊天吧！")


# 启动聊天机器人


if __name__ == "__main__":


   chat_bot()

运行这个程序，你可以和机器人进行简单的对话，还可以让它帮你做数学计算。例如：

你好！我是你的聊天机器人。有什么我可以帮助你吗？


输入'再见'可以结束聊天。我还可以帮你做数学计算哦！


你：你好


机器人：你好！很高兴见到你！


你：你叫什么名字


机器人：我是一个聊天机器人，你可以叫我小P。


你：3 + 5 * 2

机器人：计算结果是：13

你：(10 + 20) / 3

机器人：计算结果是：10.0

你：再见


机器人：再见！祝你有个愉快的一天！

恭喜！你已经完成了第一个 Python 实战项目 —— 聊天机器人！

五、实用工具与思维：提升编程效率

1. 模块导入：使用别人写好的代码

Python 有丰富的标准库和第三方库，我们可以通过导入模块来使用这些库中的功能，避免重复造轮子。

# 导入整个模块


import math


print(math.pi)  # 输出：3.141592653589793

print(math.sqrt(16))  # 输出：4.0（计算平方根）


# 导入模块中的特定函数


from math import pi, sqrt


print(pi)  # 输出：3.141592653589793

print(sqrt(25))  # 输出：5.0

# 给模块或函数起别名


import math as m


print(m.sin(m.pi / 2))  # 输出：1.0（计算正弦值）


from math import pow as power


print(power(2, 3))  # 输出：8.0（计算2的3次方）


# 导入模块中的所有函数（不推荐，可能导致命名冲突）


from math import *


print(cos(0))  # 输出：1.0

常用的标准库模块：

math：数学运算
random：随机数生成
datetime：日期和时间处理
os：操作系统相关功能
sys：Python 解释器相关功能
json：JSON 数据处理

安装第三方库：

使用 pip 命令可以安装第三方库，例如安装用于数据分析的 pandas 库：

pip install pandas

安装完成后，就可以在代码中导入使用了：

import pandas as pd


# 使用pandas的功能...

2. PyCharm 的实用技巧

PyCharm 是一个功能强大的 Python 编辑器，掌握一些实用技巧可以提高编程效率：

代码补全：输入代码时，PyCharm 会自动提示可能的选项，按 Tab 或 Enter 可以快速补全。
快速运行：按 Ctrl+Shift+F10 可以快速运行当前文件，不需要右键选择。
代码格式化：按 Ctrl+Alt+L 可以自动格式化代码，使代码风格统一。
重命名：右键变量或函数名，选择 "Refactor" -> "Rename"，可以批量重命名，比手动修改更安全。
注释代码：选中代码后按 Ctrl+/ 可以快速注释或取消注释。
查找和替换：按 Ctrl+F 查找，按 Ctrl+R 替换。
查看文档：将光标放在函数或类上，按 Ctrl+Q 可以查看文档说明。
自动导入：当使用未导入的模块或函数时，PyCharm 会提示，按 Alt+Enter 可以自动导入。

3. 培养程序员思维

学习编程不仅仅是学习语法，更重要的是培养程序员思维，也就是 "遇到问题 - 分析问题 - 解决问题" 的能力。

程序员思维的几个关键点：

1. 分解问题：将复杂的问题分解成小问题，逐个解决。例如，我们在编写聊天机器人时，先实现基本框架，再添加对话功能，最后添加计算功能。

2. 抽象思维：找出问题的本质，忽略无关细节。例如，在实现多态时，我们只关心对象是否有 area 方法，而不关心它具体是什么形状。

3. 逻辑思维：按照逻辑顺序思考问题，一步一步解决。例如，在实现条件判断时，要考虑各种可能的情况。

4. 调试能力：学会发现并解决错误。当程序出错时，不要害怕，应该：

仔细阅读错误信息，定位错误位置
分析可能的原因
逐步排查，找到问题所在
修复错误并测试

5. 持续学习：编程技术在不断发展，要保持学习的热情，不断更新自己的知识。

六、总结与下一步学习

恭喜你！通过这篇文章，你已经学习了 Python 的基本语法、流程控制、函数、面向对象编程（包括多态）等知识，还完成了一个简单的聊天机器人项目。

现在，你已经跨过了 Python 入门的门槛，具备了编写简单程序的能力。接下来，你可以：

1. 巩固基础：多写代码，熟练掌握所学的知识点。

2. 学习更多库：根据自己的兴趣，学习一些实用的第三方库，如：

数据分析：pandas, numpy
网页爬虫：requests, beautifulsoup
图形界面：tkinter, PyQt
游戏开发：pygame
人工智能：tensorflow, pytorch

3. 做小项目：通过实际项目练习，例如：

制作一个待办事项管理器
编写一个简单的计算器
开发一个小游戏
爬取网站数据并分析

4. 阅读别人的代码：在 GitHub 等平台上阅读优秀的开源项目代码，学习别人的编程思路和风格。

记住，编程是一门实践性很强的技能，只有多写多练，才能真正掌握。遇到问题不要怕，每解决一个问题，你的编程能力就会提高一分。

祝你在 Python 的学习道路上取得更多进步！

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

腾讯技术创作特训营S14#红城堡

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。