Python基础知识入门
1、认识python
- python 是一种高级编程语言，具有简单易学、代码可读性高、功能强大的特点
- 应用场景：Web 开发、数据分析、人工智能、自动化脚本、网络爬虫等
2、python基础知识
2.1 变量
变量就是用来存储数据的容器，变量是存储在内存中的值，这就意味着在创建变量时会在内存中开辟一个空间，用于存放该变量的值。
简单来说，变量就是在程序运行时，用于存储数据值
定义变量
举例如下：
python
x = 10 # 整数
y = 3.14 # 浮点数
name = "Alice" # 字符串
finish= True # 布尔值变量名命名规则
- 由数字、字母、下划线组成
- 不能由数字开头
- 不能使用python中的关键字
- 严格区分大小写
2.2 关键字
关键字是python中已使用的、不允许开发人员重复定义的标识符，python中的常见关键字如下表格：
2.3 注释
- 单行注释：以 #开头，#右边的所有文字当作说明，而不是真正要执行的程序，起辅助说明作用
- 多行注释：以
一对三个引号(单双)起来
python
#我是单行注释
'''
我是多行注释
我是多行注释
我是多行注释
'''
"""
我是多行注释
我是多行注释
我是多行注释
"""注：需要将一整段代码注释掉时，可以选中该段代码，ctrl+/即可全部注释
2.4 print（）和input（）
- print()：向屏幕输出内容（文字、数字、变量等）
python
print("Hello") #输出字符串
print(100) #输出数字
print(3.14,"π") #输出多个值，默认用空格分隔- input() 从用户输入获取数据，返回字符串类型
python
name=input("请输入你的名字：")
print("你的名字是：",name)
2.5 代码格式规范化
在python 中，良好的代码格式是保证代码可读性、可维护性和团队协作效率的关键。
- 缩进
python强制使用缩进来标识代码块（如if、for、def），使用4个空格或一个tab键同一代码块必须对齐缩进
python
if x > 0:
print("正数")#4个空格缩进
y = x + 1 #同级对齐3、 数据类型
3.1 数字类型和布尔类型
-
字符串
字符串（string），又称文本，是由任意数量的字符如中文、英文、各类符号、数字等组成，所以叫做字符串如："abcde"
"世界真美好"
"123456大揭秘"
#都是字符串
python中，字符串需要用双引号（"字符串内容"）包围起来
实际使用字符串时，无论是单引号，还是双引号都可以
字符串支持索引和切片操作，例如：
python
s = "Hello, World!"
print(s[0]) # 输出 'H'
print(s[7:12]) # 输出 'World'3.2 列表（list）
list(列表) 是专门用于存储一串有序的数据的数据类型。
语法：列表名 = 元素1, 元素2, 元素3
列表名也需要满足命名规则
- \[\] 中包含的是列表元素，可以是整型、浮点型、字符串等基本类型，也可以是元组、列表、字典等组合。
- 列表元素的类型可以相同也可以不相同。
python
list_two = ['p', 'y', 't', 'h', 'o', 'n']
list_three = [1, 'a', '&', 2.3]
list_four = [1, 'a', '&', 2.3, list_three]
name1_list = ['伽罗', '上官婉儿', 'tom', 'black']
# 列表还可以嵌套
name2_list = [['red', 'green'], ['bule', 'white'], name1_list]- 列表的索引
如图，列表中的每一个元素，都有其位置下标索引。从前向后的方向，从 0 开始，依次递增。
只需要按照下标索引得到对应的值。
python
name1_list = ['伽罗', '上官婉儿', 'tom', 'black']
print(name1_list[0]) # 结果：伽罗
print(name1_list[3]) # 结果：black- 列表的反向索引（负索引）
除了正向索引，Python 列表还支持反向索引（也称为负索引）。反向索引从列表的末尾开始计数，最后一个元素的索引为 -1，倒数第二个为 -2，依此类推。
反向索引的规则如下：
- 最后一个元素：索引为
-1 - 倒数第二个元素：索引为
-2 - ...
- 第一个元素：索引为
-len(list)
使用反向索引可以方便地从列表末尾访问元素，无需计算列表长度。
示例：
python
name1_list = ['伽罗', '上官婉儿', 'tom', 'black']
print(name1_list[-1]) # 结果：black（最后一个元素）
print(name1_list[-2]) # 结果：tom（倒数第二个元素）
print(name1_list[-4]) # 结果：伽罗（第一个元素，等同于 name1_list[0]）反向索引同样适用于切片操作：
python
numbers = [10, 20, 30, 40, 50]
print(numbers[-3:]) # 结果：[30, 40, 50]（获取最后三个元素）
print(numbers[:-2]) # 结果：[10, 20, 30]（获取除最后两个元素外的所有元素）-
列表的常用操作
-
列表的常用操作
追加元素：
语法：列表.append(元素)，将指定元素追加到列表的尾部。
python
# 追加元素示例
fruits = ['苹果', '香蕉', '橙子']
print("原始列表:", fruits)
# 追加一个元素
fruits.append('葡萄')
print("追加后:", fruits) # 输出: ['苹果', '香蕉', '橙子', '葡萄']
# 追加多个元素（使用extend或循环）
fruits.extend(['西瓜', '芒果'])
print("追加多个后:", fruits) # 输出: ['苹果', '香蕉', '橙子', '葡萄', '西瓜', '芒果']删除元素：
语法：列表.pop(索引)，删除指定索引位置的元素。
python
# 删除元素示例
fruits = ['苹果', '香蕉', '橙子', '葡萄', '西瓜']
print("原始列表:", fruits)
# 删除索引为2的元素（橙子）
removed_fruit = fruits.pop(2)
print(f"删除的元素: {removed_fruit}")
print("删除后列表:", fruits) # 输出: ['苹果', '香蕉', '葡萄', '西瓜']
# 如果不指定索引，pop()默认删除最后一个元素
last_fruit = fruits.pop()
print(f"删除的最后一个元素: {last_fruit}")
print("删除后列表:", fruits) # 输出: ['苹果', '香蕉', '葡萄']清空元素：
语法：列表.clear()，清空列表。
python
# 清空元素示例
fruits = ['苹果', '香蕉', '橙子', '葡萄', '西瓜']
print("清空前列表:", fruits) # 输出: ['苹果', '香蕉', '橙子', '葡萄', '西瓜']
fruits.clear()
print("清空后列表:", fruits) # 输出: []
print("列表长度:", len(fruits)) # 输出: 0列表常用操作总结：
python
# 列表常用操作综合示例
numbers = [1, 2, 3, 4, 5]
# 1. 追加元素
numbers.append(6)
print("追加后:", numbers) # [1, 2, 3, 4, 5, 6]
# 2. 插入元素
numbers.insert(2, 99) # 在索引2处插入99
print("插入后:", numbers) # [1, 2, 99, 3, 4, 5, 6]
# 3. 删除元素
numbers.pop(2) # 删除索引2处的元素
print("删除后:", numbers) # [1, 2, 3, 4, 5, 6]
# 4. 删除指定值
numbers.remove(4) # 删除值为4的元素
print("删除4后:", numbers) # [1, 2, 3, 5, 6]
# 5. 查找元素索引
index = numbers.index(3)
print("元素3的索引:", index) # 2
# 6. 统计元素出现次数
count = numbers.count(2)
print("元素2出现次数:", count) # 1
# 7. 排序
numbers.sort()
print("排序后:", numbers) # [1, 2, 3, 5, 6]
# 8. 反转
numbers.reverse()
print("反转后:", numbers) # [6, 5, 3, 2, 1]
# 9. 清空
numbers.clear()
print("清空后:", numbers) # []3.3 字典dict
字典就像现实中的字典，你查某个词条就会有相应的解释。
python的字典也一样："键（key）"对应"值（value）"，键就是"词条"，值就是"解释"。
字典定义：字典名 = {key1:value1, key2:value2, key3:value3}
python
# 字典定义示例
student = {"名字": "张三", "年龄": 18, "职业": "学生"}
print(student) # 输出: {'名字': '张三', '年龄': 18, '职业': '学生'}- 每个字典由一堆 键:值 组成，就像：{"名字": "张三", "年龄": 18, "职业": "学生"}
- 键（key）：唯一且不可变（通常用字符串、数字、元组）
- 值（value）：可以是任意类型（字符串、数字、列表、甚至另一个字典！）
python
# 键值对示例
person = {
"name": "李四", # 字符串键，字符串值
"age": 25, # 字符串键，整数值
"scores": [85, 90, 78], # 字符串键，列表值
"address": { # 字符串键，字典值
"city": "北京",
"street": "朝阳路"
}
}
print(person)- 键不能重复，值可以重复
python
# 键不能重复示例
dict1 = {"a": 1, "b": 2, "a": 3} # 键'a'重复，后面的会覆盖前面的
print(dict1) # 输出: {'a': 3, 'b': 2}
# 值可以重复示例
dict2 = {"name1": "张三", "name2": "张三", "age1": 20, "age2": 20}
print(dict2) # 输出: {'name1': '张三', 'name2': '张三', 'age1': 20, 'age2': 20}- 字典的常用操作
查字典：访问key对应的value值
语法：字典"key名称" 或 字典.get("key名称")
python
# 查字典示例
student = {"名字": "张三", "年龄": 18, "成绩": 85}
# 方法1：使用方括号
print(student["名字"]) # 输出: 张三
print(student["年龄"]) # 输出: 18
# 方法2：使用get()方法（更安全，键不存在时返回None或默认值）
print(student.get("成绩")) # 输出: 85
print(student.get("地址")) # 输出: None（键不存在）
print(student.get("地址", "未知")) # 输出: 未知（指定默认值）
# 遍历字典
for key in student:
print(f"{key}: {student[key]}")增/改字典：
python
# 增/改字典示例
person = {"name": "王五", "age": 30}
# 1. 增加新键值对
person["city"] = "上海"
print("增加后:", person) # 输出: {'name': '王五', 'age': 30, 'city': '上海'}
# 2. 修改已有键的值
person["age"] = 31
print("修改后:", person) # 输出: {'name': '王五', 'age': 31, 'city': '上海'}
# 3. 使用update()方法批量更新
person.update({"job": "工程师", "salary": 15000})
print("批量更新后:", person) # 输出: {'name': '王五', 'age': 31, 'city': '上海', 'job': '工程师', 'salary': 15000}
# 4. 使用setdefault()方法（如果键不存在则添加）
person.setdefault("hobby", "篮球")
print("setdefault后:", person) # 输出: hobby被添加删字典：
python
# 删字典示例
student = {"名字": "张三", "年龄": 18, "成绩": 85, "班级": "一班", "爱好": "篮球"}
# 1. 删除指定键值对 - del语句
del student["班级"]
print("删除班级后:", student) # 输出: {'名字': '张三', '年龄': 18, '成绩': 85, '爱好': '篮球'}
# 2. 删除指定键值对并返回值 - pop()方法
age = student.pop("年龄")
print(f"删除的年龄值: {age}") # 输出: 18
print("pop后:", student) # 输出: {'名字': '张三', '成绩': 85, '爱好': '篮球'}
# 3. 删除最后一个键值对 - popitem()方法（Python 3.7+有序）
last_item = student.popitem()
print(f"删除的最后一项: {last_item}") # 输出: ('爱好', '篮球')
print("popitem后:", student) # 输出: {'名字': '张三', '成绩': 85}
# 4. 清空字典 - clear()方法
student.clear()
print("清空后:", student) # 输出: {}字典常用方法：
python
# 字典常用方法综合示例
student = {"name": "张三", "age": 20, "score": 85, "class": "一班"}
# 1. 获取所有键
keys = student.keys()
print("所有键:", list(keys)) # 输出: ['name', 'age', 'score', 'class']
# 2. 获取所有值
values = student.values()
print("所有值:", list(values)) # 输出: ['张三', 20, 85, '一班']
# 3. 获取所有键值对
items = student.items()
print("所有键值对:", list(items)) # 输出: [('name', '张三'), ('age', 20), ('score', 85), ('class', '一班')]
# 4. 检查键是否存在
print("name是否存在:", "name" in student) # 输出: True
print("address是否存在:", "address" in student) # 输出: False
# 5. 获取字典长度（键值对数量）
print("字典长度:", len(student)) # 输出: 4
# 6. 复制字典
student_copy = student.copy()
print("复制后的字典:", student_copy)
# 7. 合并字典（Python 3.9+）
info = {"hobby": "篮球", "city": "北京"}
merged = student | info # 或使用 student.update(info)
print("合并后:", merged)
# 8. 遍历字典
print("\n遍历字典:")
for key, value in student.items():
print(f"{key}: {value}")4、常用的运算符
4.1 算术运算符
4.2 比较运算
4.3 赋值运算
4.4 逻辑运算
逻辑运算结果只有布尔值
5、流程控制
流程控制指的是代码的运行逻辑、分支走向、循环控制，体现程序执行的顺序
在python中一般分为顺序执行、条件判断和循环控制
5.1 顺序执行
顾名思义就是按照程序编写的顺序执行，从上到下，不重复执行代码任何代码，也不跳过任何代码
5.2 条件分支
- 条件分支（单分支、双分支以及多分支）
条件分支结构就是通过一条或多条判断语句的执行结果（True或False）来决定执行的代码块
单分支结构（if语句）：
单分支结构只有一个条件判断，如果条件为True，则执行相应的代码块。
python
# 单分支结构示例
age = 18
if age >= 18:
print("您已成年，可以进入！")
print("欢迎光临！")
# 另一个示例
score = 85
if score >= 60:
print("恭喜，您及格了！")
print("成绩为:", score)双分支结构（if-else语句）：
双分支结构有两个分支，如果条件为True执行一个代码块，否则执行另一个代码块。
python
# 双分支结构示例
age = 16
if age >= 18:
print("您已成年，可以进入！")
else:
print("对不起，您未成年，禁止进入！")
print("请年满18岁后再来。")
# 判断奇偶数示例
num = 7
if num % 2 == 0:
print(f"{num} 是偶数")
else:
print(f"{num} 是奇数")多分支结构（if-elif-else语句）：
多分支结构有多个条件判断，从上到下依次检查条件，第一个为True的条件对应的代码块会被执行。
python
# 多分支结构示例
score = float(input("请输入你的成绩(0-100): "))
if score >= 90:
grade = 'A'
print("优秀！你的等级是", grade)
elif score >= 80:
grade = 'B'
print("良好！你的等级是", grade)
elif score >= 70:
grade = 'C'
print("中等！你的等级是", grade)
elif score >= 60:
grade = 'D'
print("及格！你的等级是", grade)
else:
grade = 'F'
print("不及格！你的等级是", grade)
print("程序结束")
# 另一个多分支示例：判断星期几
day = 3
if day == 1:
print("星期一")
elif day == 2:
print("星期二")
elif day == 3:
print("星期三")
elif day == 4:
print("星期四")
elif day == 5:
print("星期五")
elif day == 6:
print("星期六")
elif day == 7:
print("星期日")
else:
print("输入错误，请输入1-7之间的数字")嵌套条件分支：
条件分支还可以嵌套使用，形成更复杂的逻辑判断。
python
# 嵌套条件分支示例
age = 20
has_id = True
if age >= 18:
if has_id:
print("年龄合格且持有身份证，可以进入！")
else:
print("年龄合格但未带身份证，请出示其他证件。")
else:
print("年龄未满18岁，禁止进入！")条件表达式（三元运算符）：
Python还提供了简洁的条件表达式，适用于简单的条件判断。
python
# 条件表达式示例（三元运算符）
age = 20
status = "成年" if age >= 18 else "未成年"
print(f"年龄{age}岁，状态：{status}")
# 另一个示例：求最大值
a = 10
b = 20
max_value = a if a > b else b
print(f"a={a}, b={b}, 最大值是：{max_value}")5.3 循环结构
循环结构就是做同一件事情，在Python中，循环得使用循环结构来完成
循环结构就是重复执行同一段代码块。我们常用的循环分为for循环和while循环
for循环一般用于完成指定次数的循环
for循环的基本语法：
python
for 变量 in 可迭代对象:
# 循环体代码块1、循环列可以是列表、字符串等
python
# 遍历列表
fruits = ['苹果', '香蕉', '橙子', '葡萄']
for fruit in fruits:
print(f"我喜欢吃{fruit}")
# 遍历字符串
text = "Python"
for char in text:
print(char)
# 遍历字典
student = {"name": "张三", "age": 18, "score": 85}
for key in student:
print(f"{key}: {student[key]}")
# 遍历字典的键值对
for key, value in student.items():
print(f"{key}: {value}")2、使用range()函数控制循环次数
range() 是 Python 中用于生成整数序列的内置函数，常用于 for 循环中控制循环次数，range()函数的参数必须是整数，它有三种使用形式：
python
# range(stop)：生成从 0 开始到 stop-1 的整数序列
for i in range(5):
print(i) # 输出: 0, 1, 2, 3, 4
# range(start, stop)：生成从start开始到stop-1的整数序列
for i in range(2, 7):
print(i) # 输出: 2, 3, 4, 5, 6
# range(start, stop, step)：生成从 start 开始到 stop-1，以 step 为步长的整数序列
for i in range(1, 10, 2):
print(i) # 输出: 1, 3, 5, 7, 9
# 反向循环
for i in range(10, 0, -1):
print(i) # 输出: 10, 9, 8, ..., 1
# 实际应用：计算1到100的和
total = 0
for i in range(1, 101):
total += i
print(f"1到100的和是: {total}")
# 实际应用：打印乘法表
print("九九乘法表:")
for i in range(1, 10):
for j in range(1, i + 1):
print(f"{j}×{i}={i*j}", end="\t")
print()while循环用于不知道具体循环多少次的循环结构，只要条件满足就会一直执行
while循环的基本语法：
python
while 条件表达式:
# 循环体代码块
python
# 基本while循环示例
count = 0
while count < 5:
print(f"当前计数: {count}")
count += 1
# 无限循环与break
print("\n猜数字游戏:")
import random
secret_number = random.randint(1, 10)
guess_count = 0
while True:
guess = int(input("猜一个1-10的数字: "))
guess_count += 1
if guess < secret_number:
print("猜小了！")
elif guess > secret_number:
print("猜大了！")
else:
print(f"恭喜你，猜对了！数字是{secret_number}")
print(f"你一共猜了{guess_count}次")
break
# 计算1到100的和（while版本）
total = 0
i = 1
while i <= 100:
total += i
i += 1
print(f"\n1到100的和是: {total}")
# 遍历列表（while版本）
fruits = ['苹果', '香蕉', '橙子', '葡萄']
index = 0
print("\n使用while遍历列表:")
while index < len(fruits):
print(fruits[index])
index += 1循环控制
break：立即退出整个循环
continue：跳过当前循环，进入下一次循环
python
# break和continue示例
num = 0
while num < 10:
num += 1
if num % 2 == 0:
continue # 跳过偶数
if num > 7:
break # 当num大于7时退出循环
print(num)
# 运行结果
# 1 3 5 7
# 更多break和continue示例
print("break示例：找到第一个能被7整除的数")
for i in range(1, 20):
if i % 7 == 0:
print(f"找到第一个能被7整除的数: {i}")
break
print(f"检查 {i}...")
print("continue示例：打印1-10中的奇数")
for i in range(1, 11):
if i % 2 == 0:
continue # 跳过偶数
print(i)
# 嵌套循环中的break和continue
print("嵌套循环中的break:")
for i in range(3):
for j in range(3):
if i == 1 and j == 1:
print("遇到(1,1)，跳出内层循环")
break
print(f"({i}, {j})")for循环与while循环的选择
- 对于已知循环次数的情况，通常for循环更合适
- while循环提供了灵活的条件控制，特别适合处理不确定循环次数的情况
- 复杂的while循环条件可能会降低代码可读性，需要谨慎使用以避免无限循环
python
# 对比示例：计算1-10的和
# 使用for循环（推荐，因为循环次数明确）
total_for = 0
for i in range(1, 11):
total_for += i
print(f"for循环结果: {total_for}")
# 使用while循环
total_while = 0
i = 1
while i <= 10:
total_while += i
i += 1
print(f"while循环结果: {total_while}")
# 无限循环的危险示例（不要在实际代码中使用）
# count = 0
# while True: # 这是一个无限循环
# count += 1
# print(count)
# # 没有break语句，程序会一直运行下去注意：对于已知循环次数的情况，通常for循环更合适，复杂的while循环条件可能会降低代码可读性，while循环提供了灵活的条件控制，特别适合处理不确定循环次数的情况，但需要谨慎使用以避免无限循环
6、函数
python 中的函数是一种封装代码块的方式，用于执行特定任务。通过使用函数，可以提高代码的可读性、可维护性和复用性
常用的input()，print()，type()等都是Python的内置函数
以下是对 python 函数的详细解释：
- 函数定义
函数的定义使用 def 关键字，后跟函数名、参数列表和冒号，然后是函数体。函数体通常是缩进的代码块
python
# 语法结构如下
# def 函数名(参数): # 参数可以有也可以没有
# 函数体
# 执行一些操作
# return value # 返回值（可有可无）
# 例如
def greet(name):
print(f"Hello, {name}!")
# 无参数函数
def say_hello():
print("Hello, World!")
# 多个参数函数
def add_numbers(a, b):
result = a + b
return result
# 带默认参数的函数
def greet_person(name="Guest", greeting="Hello"):
print(f"{greeting}, {name}!")-
函数名
应全部使用小写字母,可以包含数字，如test1
单词间下划线分隔，如snake_case
不能以数字开头，不能出现中文，函数名应见名知义，清晰表达函数功能，
不能使用python关键字，如def，class，import，return等来命名。
-
参数
形参：类似于变量名，函数定义时括号中声明的变量，接收函数调用时传递的值，出现在函数定义中
实参：函数调用时实际传递给函数的值，为形参提供具体的值，出现在函数调用中
python
# 形参和实参示例
# 函数定义中的 name 是形参（形式参数）
def greet(name):
print(f"Hello, {name}!")
# 函数调用中的 "Alice" 是实参（实际参数）
greet("Alice") # 输出: Hello, Alice!
# 多个形参和实参示例
def calculate_sum(x, y): # x, y 是形参
result = x + y
return result
# 调用时传递实参
sum_result = calculate_sum(10, 20) # 10, 20 是实参
print(f"10 + 20 = {sum_result}") # 输出: 10 + 20 = 30- 函数的调用
定义函数后可以通过函数名和参数列表来调用它。调用时，将实际参数传递给函数的参数
python
# 函数调用示例
# 1. 无参数函数调用
def say_hello():
print("Hello, World!")
say_hello() # 调用函数，输出: Hello, World!
# 2. 带参数函数调用
def greet_person(name):
print(f"Hello, {name}!")
greet_person("Alice") # 调用函数，输出: Hello, Alice!
greet_person("Bob") # 调用函数，输出: Hello, Bob!
# 3. 带返回值函数调用
def add(a, b):
return a + b
result = add(5, 3) # 调用函数并将返回值赋给result
print(f"5 + 3 = {result}") # 输出: 5 + 3 = 8- 返回值（return）
函数可以通过return语句返回一个值给调用者。返回值可以是任何数据类型：数字、字符串、列表、字典等。
return 语句的作用：
- 结束函数的执行
- 将指定的值返回给函数调用者
- 如果没有指定返回值，函数默认返回
None
python
# 返回值示例
# 1. 返回单个值
def add(a, b):
"""计算两个数的和"""
result = a + b
return result # 返回计算结果
sum_result = add(5, 3)
print(f"5 + 3 = {sum_result}") # 输出: 5 + 3 = 8
# 2. 返回多个值（实际上返回一个元组）
def get_user_info():
"""获取用户信息"""
name = "张三"
age = 25
city = "北京"
return name, age, city # 返回多个值，实际上是一个元组
name, age, city = get_user_info()
print(f"姓名: {name}, 年龄: {age}, 城市: {city}") # 输出: 姓名: 张三, 年龄: 25, 城市: 北京
# 3. return 与 print 的区别
def calculate_and_print(a, b):
"""计算并打印结果，但不返回值"""
result = a + b
print(f"{a} + {b} = {result}") # 只是打印，不返回
def calculate_and_return(a, b):
"""计算并返回结果"""
result = a + b
return result # 返回结果，可以在其他地方使用
# 4.使用 print 的函数
calculate_and_print(5, 3) # 输出: 5 + 3 = 8
# 但无法获取计算结果进行进一步处理
# 5.使用 return 的函数
sum_result = calculate_and_return(5, 3)
double_result = sum_result * 2
print(f"两倍的和是: {double_result}") # 输出: 两倍的和是: 16
**return 语句的重要注意事项：**
1. `return` 语句一旦执行，函数立即结束，后面的代码不会执行
2. 一个函数可以有多个 `return` 语句，但只会执行其中一个
3. 如果没有 `return` 语句，函数默认返回 `None`
4. `return` 可以返回任何数据类型
5. 使用 `return` 可以让函数的结果被其他代码复用