Python入门基础知识总结

一子二木生三火

于 2024-08-14 16:02:16 发布

阅读量556

点赞数 9

分类专栏： Python学习文章标签： python microsoft javascript 青少年编程开发语言

本文链接：https://blog.csdn.net/m0_73969414/article/details/141180301

版权

Python学习专栏收录该内容

1 篇文章 0 订阅

订阅专栏

这篇文章总结了Python入门的一些基础的知识点，如果你从未接触过编程，这篇文章可以帮助你很好地了解相关的内容；如果已经学过至少一门编程语言，你可以借此快速地上手Python。

总体框架

输入输出函数
注释和缩进
变量与常量
基本数据类型
控制结构：条件、循环
数据结构：列表、元组、字典和集合

1. 输入输出函数

在Python中，输入和输出是与用户进行交互的基础操作。通过输入，程序可以接收用户的数据；通过输出，程序可以将结果展示给用户。

input() 函数用于从用户那里获取输入。用户输入的内容会被当作字符串处理，除非进行类型转换。
print() 函数用于在控制台输出信息，可以输出字符串、变量以及表达式的结果。
基本使用：
```
name = input("请输入你的名字: ")
print("你好，" + name + "!")
```
在这段代码中，程序会显示提示信息“请输入你的名字: ”，然后等待用户输入。当用户输入内容并按下回车键后，这些内容会被存储在变量 name 中，并以字符串的形式显示在接下来的输出中。
输出多个值：
- print() 函数可以接收多个参数，并用逗号分隔。这些参数会依次输出，默认用空格分隔。
```
name = "Alice"
age = 25
print("Name:", name, "Age:", age)
```
这行代码将输出 “Name: Alice Age: 25”。
字符串格式化输出：
- 使用f-string（推荐方法，Python 3.6及以上版本）：
  - f-string 是在字符串前加上 f，然后在字符串中使用 {} 来插入变量或表达式的值。
```
name = "Alice"
age = 25
print(f"名字: {name}, 年龄: {age}")
```
  这段代码将输出 “名字: Alice, 年龄: 25”。
- 使用format()方法：
  - format() 方法通过 {} 占位符来插入变量或表达式的值。
```
name = "Alice"
age = 25
print("名字: {}, 年龄: {}".format(name, age))
```
  这段代码将输出 “名字: Alice, 年龄: 25”。
- 使用旧式的 % 格式化（不推荐）：
  - 这种方式类似于C语言中的printf，使用 % 来格式化字符串。
```
name = "Alice"
age = 25
print("名字: %s, 年龄: %d" % (name, age))
```
  这段代码将输出 “名字: Alice, 年龄: 25”。
控制输出的结尾：
- print() 函数默认在输出末尾添加换行符。如果不想换行，可以使用 end 参数。
```
print("Hello", end=" ")
print("World")
```
这段代码将输出 “Hello World” 在同一行。
控制输出的分隔符：
- 默认情况下，print() 使用空格作为多个参数之间的分隔符。你可以使用 sep 参数自定义分隔符。
```
print("Hello", "World", sep=", ")
```
这段代码将输出 “Hello, World”。

2. 注释和缩进

好的，我们来详细讲解一下Python的基础语法，包括注释、缩进、变量与常量、以及基本数据类型。

a. 注释

单行注释：使用井号（#）来标记单行注释，注释内容不会被Python解释器执行。
```
# 这是一个单行注释
print("Hello, World!")
```
多行注释：使用三个单引号或双引号（''' 或 """）包围注释内容，适用于长篇注释或文档说明。
```
"""
这是一个多行注释
可以用于文档说明
"""
print("Hello, World!")
```

b. 缩进

Python使用缩进来表示代码块的层次结构，不像其他语言使用花括号 {}。

通常使用四个空格或一个Tab作为缩进，统一使用一个风格很重要。

if True:
    print("条件为真")  # 缩进四个空格表示属于if语句块

3. 变量与常量

变量：用于存储数据，可以在程序运行期间更改。
- 变量的命名：可以包含字母、数字和下划线，但不能以数字开头。变量名区分大小写。
- 变量赋值：使用等号 = 进行赋值。
```
name = "Alice"   # 字符串类型的变量
age = 25         # 整数类型的变量
is_student = True  # 布尔类型的变量
```
常量：通常约定使用全大写字母表示常量，Python中没有真正的常量机制，但通过这种方式提示不应该改变它的值。
```
PI = 3.14159
GRAVITY = 9.8
```

4. 基本数据类型

整数（int）：整数类型，用于表示没有小数部分的数值。
```
x = 10
y = -5
```
浮点数（float）：用于表示有小数部分的数值。
```
pi = 3.14
temperature = -273.15
```
字符串（str）：用于表示文本，字符串可以用单引号或双引号括起来。
```
greeting = "Hello"
response = 'Hi'
```
布尔值（bool）：只有两个值：True 或 False，用于逻辑判断。注意F和T是大写。
```
is_raining = False
```

类型转换：可以通过内置函数将一种类型转换为另一种类型。

num_str = "123"
num = int(num_str)  # 将字符串转换为整数
height = 5.9
height_str = str(height)  # 将浮点数转换为字符串

变量类型检测与转换

类型检测：使用type()函数来检测变量的类型。
```
x = 10
print(type(x))  # 输出：<class 'int'>
```

类型转换：常见的转换函数有int()、float()、str()等。

num = "123"
num_int = int(num)  # 将字符串转换为整数

了解并掌握这些基础语法是学习Python的第一步，随着对这些概念的熟悉，你会更容易理解后续的编程概念和技巧。

5. 控制结构

在编程中，控制结构用于管理代码的执行流程，如果之前学过其他的编程语言，这块可以快速看一下就好了。Python中常见的控制结构包括条件语句和循环语句。通过这些结构，程序可以根据不同的条件执行不同的代码块，或者重复执行某段代码。

1. 条件语句

条件语句根据表达式的真假，决定是否执行某段代码。

1.1 `if` 语句

if 语句用于判断一个条件是否为真。如果条件为真，则执行其下缩进的代码块。

语法：

if condition:
    # 当 condition 为 True 时执行的代码块

例子：
```
age = 20
if age >= 18:
    print("你已成年。")
```
这段代码会检查 age 是否大于或等于 18，如果条件为真，则输出“你已成年”。

1.2 `if-else` 语句

if-else 语句用于处理两种情况：如果条件为真，执行 if 代码块；如果条件为假，执行 else 代码块。

语法：

if condition:
    # 当 condition 为 True 时执行的代码块
else:
    # 当 condition 为 False 时执行的代码块

例子：

age = 16
if age >= 18:
    print("你已成年。")
else:
    print("你未成年。")

这段代码根据年龄判断并输出相应的信息。

1.3 `if-elif-else` 语句

当有多个条件需要判断时，可以使用 if-elif-else 结构。程序会从上到下依次检查每个条件，直到某个条件为真时执行相应的代码块。如果所有条件都为假，则执行 else 代码块（如果有的话）。

语法：

if condition1:
    # 当 condition1 为 True 时执行的代码块
elif condition2:
    # 当 condition1 为 False 且 condition2 为 True 时执行的代码块
else:
    # 当上述条件都为 False 时执行的代码块

例子：

score = 85
if score >= 90:
    print("优秀")
elif score >= 75:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")

这段代码根据分数输出相应的成绩评定。

2. 循环语句

循环语句用于重复执行某段代码，直到满足某个条件为止。

2.1 `while` 循环

while 循环会在条件为真时，反复执行循环体内的代码。条件每次循环结束后都会被重新评估。

语法：

while condition:
    # 当 condition 为 True 时执行的代码块

例子：

count = 0
while count < 5:
    print(f"计数: {count}")
    count += 1

这段代码会从0开始计数，直到 count 达到 5。

2.2 `for` 循环

for 循环用于遍历一个序列（如列表、元组、字符串）中的每一项。（有的专有名词后面会有解释）

语法：

for variable in sequence:
    # 对于 sequence 中的每一个元素，执行一次代码块

例子：
```
fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
    print(f"我喜欢吃{fruit}")
```
这段代码会依次输出“我喜欢吃苹果”、“我喜欢吃香蕉”和“我喜欢吃橙子”。

2.3 循环控制语句

break 语句：立即终止循环，不再执行循环体中剩余的代码，直接跳出循环。
```
for i in range(10):
    if i == 5:
        break
    print(i)
```
这段代码会输出0到4，当 i 等于5时，循环终止。
continue 语句：跳过本次循环中剩余的代码，直接进入下一次循环的判断。
```
for i in range(10):
    if i % 2 == 0:
        continue
    print(i)
```
这段代码只会输出奇数，因为遇到偶数时会跳过输出。

pass 语句：pass 是一个空操作，通常用作占位符，使得代码结构合法但不执行任何操作。

for i in range(5):
    if i == 3:
        pass  # 暂时不处理 i == 3 的情况
    else:
        print(i)

3. 嵌套控制结构

控制结构可以嵌套使用，例如在一个循环内包含另一个循环，或在条件语句内包含循环。

例子：

for i in range(3):
    for j in range(2):
        print(f"i={i}, j={j}")

这段代码演示了一个嵌套循环，输出 i 和 j 的所有组合。

4. 理解控制结构的执行流程

顺序执行：程序按照从上到下的顺序依次执行每一行代码，直到遇到控制结构。
分支执行：条件语句根据条件选择性地执行某些代码块，分支之间是互斥的。
循环执行：循环结构会重复执行代码块，直到满足退出条件。

通过理解和掌握这些控制结构，你可以编写出更复杂、更智能的程序来解决各种问题。

6. 数据结构

Python 提供了几种强大且常用的数据结构，用于存储和操作数据。这些数据结构在其他语言中都有相关的对应，所以有一定基础的小伙伴也可以很快就掌握了。这些数据结构包括列表、元组、字典和集合。每种数据结构都有其独特的特性和适用场景。让我们详细讲解一下这些数据结构的基本概念和用法。

a. 列表（List）

定义：列表是Python中最常用的数据结构之一，用于存储有序的元素集合。列表中的元素可以是任何类型，且列表是可变的（元素可以增删改）。类似Java和C++中的数组，支持下标访问。

创建列表：

fruits = ["apple", "banana", "orange"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True]

访问元素：通过索引访问列表中的元素，索引从0开始。

print(fruits[0])  # 输出: "apple"
print(mixed[2])   # 输出: 3.14

修改元素：可以直接通过索引修改列表中的元素。

fruits[1] = "blueberry"
print(fruits)  # 输出: ["apple", "blueberry", "orange"]

添加元素：

append() 方法在列表末尾添加一个元素。
insert() 方法在指定位置插入一个元素。

fruits.append("grape")
fruits.insert(1, "mango")
print(fruits)  # 输出: ["apple", "mango", "blueberry", "orange", "grape"]

删除元素：
- remove() 方法删除指定元素。
- pop() 方法删除指定索引处的元素，并返回该元素。如果不指定索引，pop() 会删除并返回最后一个元素。
- del 语句删除指定索引的元素或整个列表。
```
fruits.remove("mango")
last_fruit = fruits.pop()
print(fruits)  # 输出: ["apple", "blueberry", "orange"]
print(last_fruit)  # 输出: "grape"
del fruits[0]
print(fruits)  # 输出: ["blueberry", "orange"]
```
列表切片：可以使用切片操作符 [start:stop:step] 提取列表中的子集。step表示步长，默认为1。注意此处的区间是左开右闭的。
```
numbers = [1, 2, 3, 4, 5]
sub_list = numbers[1:4]  # 提取索引1到3的元素
print(sub_list)  # 输出: [2, 3, 4]
```

b. 元组（Tuple）

定义：元组是类似于列表的有序集合，但元组是不可变的（元素不能增删改）。元组通常用于存储一组不应更改的数据。

创建元组：

fruits = ("apple", "banana", "orange")
numbers = (1, 2, 3, 4, 5)
mixed = (1, "hello", 3.14, True)

访问元素：与列表类似，通过索引访问元组中的元素。
```
print(fruits[0])  # 输出: "apple"
```

不可变性：不能修改元组中的元素。如果需要修改，可以将元组转换为列表，修改后再转换回元组。

fruits = list(fruits)  # 转换为列表
fruits[0] = "mango"
fruits = tuple(fruits)  # 转换回元组
print(fruits)  # 输出: ("mango", "banana", "orange")

单元素元组：创建单元素元组时，需要在元素后面加一个逗号。
```
single = (5,)
print(type(single))  # 输出: <class 'tuple'>
```

c. 字典（Dictionary）

定义：字典是Python中用于存储键值对的无序集合。每个键（Key）是唯一的，键用于标识对应的值（Value）。字典是可变的，属于哈希结构。

创建字典：

student = {"name": "Alice", "age": 20, "courses": ["Math", "CompSci"]}

访问值：通过键访问字典中的值。

print(student["name"])  # 输出: "Alice"
print(student["courses"])  # 输出: ["Math", "CompSci"]

添加或修改键值对：直接使用键进行赋值操作即可添加或修改键值对。

student["age"] = 21  # 修改年龄
student["grade"] = "A"  # 添加新的键值对
print(student)  # 输出: {"name": "Alice", "age": 21, "courses": ["Math", "CompSci"], "grade": "A"}

删除键值对：

使用 del 语句删除指定键的键值对。
使用 pop() 方法删除指定键并返回该键的值。

del student["grade"]
print(student)  # 输出: {"name": "Alice", "age": 21, "courses": ["Math", "CompSci"]}
courses = student.pop("courses")
print(courses)  # 输出: ["Math", "CompSci"]

字典方法：

keys() 返回字典中所有键的列表。
values() 返回字典中所有值的列表。
items() 返回字典中所有键值对的列表。

keys = student.keys()
values = student.values()
items = student.items()
print(keys)   # 输出: dict_keys(['name', 'age'])
print(values) # 输出: dict_values(['Alice', 21])
print(items)  # 输出: dict_items([('name', 'Alice'), ('age', 21)])

d. 集合（Set）

定义：集合是一个无序、不重复的元素集合。集合常用于去重、关系测试以及数学集合运算。

创建集合：

fruits = {"apple", "banana", "orange", "apple"}  # 重复的 "apple" 将自动去除
print(fruits)  # 输出: {"apple", "banana", "orange"}

添加元素：使用 add() 方法添加新元素。

fruits.add("grape")
print(fruits)  # 输出: {"apple", "banana", "orange", "grape"}

删除元素：使用 remove() 方法删除指定元素。如果元素不存在会抛出 KeyError 异常。使用 discard() 方法删除元素，如果元素不存在不会抛异常。
```
fruits.remove("banana")
fruits.discard("pineapple")  # 不会抛异常
print(fruits)  # 输出: {"apple", "orange", "grape"}
```

集合运算：

交集：使用 & 或 intersection() 方法，返回两个集合的交集。
并集：使用 | 或 union() 方法，返回两个集合的并集。
差集：使用 - 或 difference() 方法，返回只存在于第一个集合的元素。
对称差：使用 ^ 或 symmetric_difference() 方法，返回只存在于其中一个集合的元素。

set1 = {"apple", "banana", "orange"}
set2 = {"banana", "grape", "apple"}

print(set1 & set2)  # 输出: {"apple", "banana"} (交集)
print(set1 | set2)  # 输出: {"apple", "banana", "orange", "grape"} (并集)
print(set1 - set2)  # 输出: {"orange"} (差集)
print(set1 ^ set2)  # 输出: {"orange", "grape"} (对称差)