python基础

一、注释

Python 中有三种注释方式，以下是示例代码及说明：

# 这是单行注释，用 # 开头，单独一行对代码进行简单说明

'''
这是多行注释
可以跨越多行内容
使用三个单引号包裹起来
常用于对函数、类等进行详细功能说明
'''

"""
这也是多行注释
和单引号形式的多行注释功能一样
使用三个双引号包裹
在实际编码中，单双引号多行注释可根据个人习惯选用
"""

# 注意：当字符串没有被赋值给变量时，也会被 Python 解释器忽略，可变相当作注释，但不推荐这么用
"这种形式能临时当注释，但不符合规范，尽量别用"

二、变量命名规则

Python 里变量命名有这些规则和建议，下面是文字说明和示例代码：

规则说明

• 只能包含字母（区分大小写，比如 Age 和 age 是不同变量 ）、数字和下划线（_）
• 不能以数字开头
• 不能使用 Python 关键字（像 if、for、while 这些具有特殊含义的单词 ）

命名风格建议

• 变量和函数：一般用小写字母 + 下划线的形式，也就是 snake_case 风格，例如 user_name、calculate_sum
• 类名：采用每个单词首字母大写的 CamelCase 风格，例如 StudentInfo、OrderSystem

# 合法的变量命名示例
name = "Python"  # 纯字母
user_age = 18    # 字母 + 下划线 + 数字
count_1 = 100    # 符合命名规则

# 不合法的变量命名（写了会报错，实际编码别这么用）
# 2nd_name = "Test"  # 不能以数字开头，Python 解释器会识别出错
# user-age = 20      # 不能包含连字符，不符合命名规则
# if = 5             # 不能使用 Python 关键字，会造成语法冲突

三、数据类型

Python 的数据类型分为基本数据类型和复合数据类型，分别来看：

3.1 基本数据类型

基本数据类型用于存储简单的值，常见的有下面这些，示例代码演示：

# 整数（int），可正可负
integer_num = 10  
negative_int = -5  

# 浮点数（float），表示带有小数部分的数
float_num = 3.14  
negative_float = -0.5  

# 字符串（str），用单引号、双引号或三引号包裹文本内容
single_quote_str = "hello"  
double_quote_str = 'world'  
triple_quote_str = """这是
多行的
字符串"""  

# 布尔值（bool），只有 True 和 False 两个取值，用于表示真假情况
bool_true = True  
bool_false = False  

3.2 复合数据类型

复合数据类型可以存储多个值，常用的有以下几种，代码示例：

# 列表（list）—— 有序、内容可变，能存不同类型的数据，用方括号 [] 包裹
list_demo = [1, 2, 3, "apple"]  

# 元组（tuple）—— 有序、内容不可变，同样可存多种类型，用圆括号 () 包裹
tuple_demo = (1, 2, 3, "banana")  

# 集合（set）—— 无序、自动去重，存储不重复的元素，用大括号 {} 包裹（注意和字典区分）
set_demo = {1, 2, 3, "cherry"}  

# 字典（dict）—— 无序的键值对集合，通过键来查找值，用大括号 {} 包裹，形式是 {键: 值}
dict_demo = {"name": "David", "age": 20}  

四、输出与输入

Python 中 print 用于输出内容，input 用于获取用户输入，具体用法如下：

4.1 输出操作（print 函数）

print 能把字符串、变量等内容显示在控制台，还有多种格式化输出方式，代码示例：

# 直接输出字符串
print("Hello World")  

# 输出变量的值
x = 100
print(x)  

# 同时输出多个内容，用逗号隔开，输出时会用空格分隔
print("x 的值是", x)  

# 格式化输出方式一：f-字符串（推荐，Python3.6+ 支持），方便嵌入变量
name = "Python"
version = 3.11
print(f"编程语言: {name}, 版本: {version}")  

# 格式化输出方式二：% 占位符，类似其他语言的格式化输出风格
print("编程语言: %s, 版本: %.2f" % (name, version))  

# 格式化输出方式三：format 方法，通过 {} 和数字指定替换位置
print("编程语言: {0}, 版本: {1}".format(name, version))  

# 输出时添加特殊字符，\t 是制表符（类似按 Tab 键），\n 是换行
print("a\tb")  # 输出后，a 和 b 之间有制表符的空格间隔
print("a\nb")  # 输出后，a 换行显示 b
# 改变 end 参数，让 print 输出后不默认换行（默认 end 是 '\n' 换行符）
print("a", end="")  
print("b")  # 这行和上面的 print 会连起来输出成 "ab"

4.2 输入操作（input 函数）

input 用于从控制台获取用户输入的内容，获取的默认是字符串类型，如需其他类型要进行转换，示例：

# 基本输入，获取用户输入的字符串，存到 name 变量
name = input("请输入你的名字: ")
print(f"你好呀，{name}！")  

# 输入后转换为整数类型，用于处理年龄等整数数据
age = int(input("请输入你的年龄: "))
print(f"明年你就 {age + 1} 岁啦")  

# 输入后转换为浮点数类型，处理身高、体重等小数数据
height = float(input("请输入你的身高(单位：米): "))
print(f"你的身高换算成厘米是 {height * 100} 厘米")  

五、类型转换

Python 支持不同数据类型之间相互转换，常用的转换方式有这些，代码示例：

# 字符串转整数，前提是字符串内容符合整数格式
num_str = "123"
num_int = int(num_str)  # num_int 变为 123  

# 浮点数转整数，会向下取整（丢弃小数部分）
float_num = 3.9
int_from_float = int(float_num)  # 结果是 3  

# 整数转浮点数，给整数加上小数部分（.0 形式）
int_num = 10
float_from_int = float(int_num)  # 结果是 10.0  

# 字符串转浮点数，要求字符串是合法浮点数格式
float_str = "3.14"
float_num = float(float_str)  # 结果是 3.14  

# 任意类型转字符串，把数据转成可显示的字符串形式
num = 123
str_from_num = str(num)  # 结果是 "123"  
float_val = 3.14
str_from_float = str(float_val)  # 结果是 "3.14"  

# 转布尔值，0、空字符串等“空”“无”的情况转成 False，非 0、非空等转成 True
zero_num = 0
bool_from_zero = bool(zero_num)  # 结果是 False  
non_zero_num = 1
bool_from_non_zero = bool(non_zero_num)  # 结果是 True  
empty_str = ""
bool_from_empty = bool(empty_str)  # 结果是 False  
non_empty_str = "abc"
bool_from_non_empty = bool(non_empty_str)  # 结果是 True  

六、随机数

Python 借助 random 模块生成随机数，可用于生成随机整数、浮点数，或者从序列里随机选元素，示例：

# 先导入 random 模块，才能使用里面的随机函数
import random  

# 生成 1 到 100（包含 1 和 100）的随机整数
random_int = random.randint(1, 100)
print("生成的随机整数:", random_int)  

# 生成 1 到 100（包含 1，不包含 100）的随机浮点数
random_float = random.uniform(1, 100)
print("生成的随机浮点数:", random_float)  

# 生成 0 到 1（包含 0，不包含 1）的随机浮点数
random_0_1 = random.random()
print("0 到 1 之间的随机浮点数:", random_0_1)  

# 从列表里随机选一个元素，模拟随机选水果场景
fruits = ["苹果", "香蕉", "橙子"]
random_fruit = random.choice(fruits)
print("随机选中的水果:", random_fruit)  

七、布尔类型与逻辑运算

布尔类型用于表示真假，逻辑运算用于组合或判断布尔值，具体操作示例：

# 定义布尔值变量
a = True
b = False  

# 逻辑非运算（not），取反
print(not a)  # 结果是 False
print(not b)  # 结果是 True  

# 逻辑与运算（and），两边都为 True 时结果才是 True，否则为 False
print(a and b)  # 结果是 False
print(a and a)  # 结果是 True  

# 逻辑或运算（or），只要有一边为 True 结果就是 True，两边都为 False 才是 False
print(a or b)  # 结果是 True
print(b or b)  # 结果是 False  

# 比较运算，结果是布尔值，用于判断大小、是否相等之类的关系
print(5 > 3)    # 结果是 True，5 大于 3
print(5 == 3)   # 结果是 False，5 不等于 3
print(5 != 3)   # 结果是 True，5 和 3 不相等  

八、条件语句

条件语句根据条件判断结果，决定执行不同的代码块，if、elif、else 是常用关键字，示例：

# 基本 if-else 结构，判断数字是奇数还是偶数
num = 7
if num % 2 == 0:
    print(f"{num} 是偶数")
else:
    print(f"{num} 是奇数")  

# if-elif-else 多条件判断，根据分数输出不同评价
score = int(input("请输入分数: "))
if score < 0 or score > 100:
    print("分数不合法，要在 0 到 100 之间呀")
elif score < 60:
    print("不及格，要加油啦")
elif score < 80:
    print("良好，继续努力能更好")
else:
    print("优秀，太厉害啦")  

# 条件语句嵌套，判断年龄和是否有身份证，决定能否进入
age = 17
has_id = True
if age >= 18:
    print("已成年")
    if has_id:
        print("可以进入场所")
    else:
        print("请出示身份证才能进入")
else:
    print("未成年，暂时不能进入哦")  

九、循环语句

循环语句用于重复执行一段代码，Python 里常用 while 和 for 循环，用法如下：

9.1 while 循环

while 循环在条件为真时，重复执行代码块，要注意避免无限循环，示例：

# 基本 while 循环，输出计数，从 0 到 4
count = 0
while count < 5:
    print(f"当前计数: {count}")
    count += 1  # 每次循环让计数加 1，否则会一直循环下去  

# while 循环结合 break，满足条件时跳出循环
num = 0
while True:
    num += 1
    if num > 5:
        break  # 当 num 大于 5 时，跳出这个无限循环
    print(num)  

# while 循环结合 continue，满足条件时跳过本次循环剩余内容
num = 0
while num < 5:
    num += 1
    if num % 2 == 0:
        continue  # 当 num 是偶数时，跳过下面的 print，直接进入下次循环
    print(num)  # 只会打印奇数：1、3、5  

9.2 for 循环

for 循环常用于遍历序列（如列表、字符串等），或配合 range 生成序列来循环，示例：

# 遍历 range 生成的序列，range(5) 是 0 到 4
for i in range(5):
    print(i)  

# 遍历字符串，逐个输出字符
for char in "Python":
    print(char)  

# 遍历列表，逐个输出列表里的元素
fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
    print(fruit)  

# for-else 结构，当 for 循环正常结束（不是通过 break 跳出）时，执行 else 里的代码
for i in range(3):
    print(i)
else:
    print("for 循环正常结束啦")  

十、字符串操作

字符串有很多常用操作，比如索引、切片、替换、分割等，示例：

# 定义一个字符串，用于演示操作
s = "Hello, Python World!"  

# 索引和切片，Python 中字符串索引从 0 开始，切片是左闭右开
print(s[0])       # 取第一个字符 'H'
print(s[-1])      # 取最后一个字符 '!'
print(s[7:13])    # 切片，取索引 7 到 12 的字符，即 'Python'
print(s[:5])      # 取从开头到索引 4 的字符，即 'Hello'
print(s[13:])     # 取从索引 13 到结尾的字符，即 ' World!'
print(s[::-1])    # 反转字符串，得到 '!dlroW nohtyP ,olleH'  

# 获取字符串长度
print(len(s))     # 输出字符串长度，这里是 19  

# 替换字符串里的内容，把 'Python' 换成 'Java'
new_s = s.replace("Python", "Java")
print(new_s)  # 输出 'Hello, Java World!'  

# 分割与拼接，按空格分割成列表，再用 '-' 拼接起来
words = s.split(" ")
print(words)  # 输出 ['Hello,', 'Python', 'World!']
joined = "-".join(words)
print(joined)  # 输出 'Hello,-Python-World!'  

# 大小写转换
print(s.lower())   # 转成全小写 'hello, python world!'
print(s.upper())   # 转成全大写 'HELLO, PYTHON WORLD!'
print(s.title())   # 每个单词首字母大写 'Hello, Python World!'  

# 去除空格，strip 去除两端空格，lstrip 去除左端，rstrip 去除右端
s2 = "   Hello   "
print(s2.strip())  # 输出 'Hello'
print(s2.lstrip()) # 输出 'Hello   '
print(s2.rstrip()) # 输出 '   Hello'  

十一、列表操作

列表是 Python 常用的数据结构，支持增删改查等操作，示例：

# 创建一个列表，存储整数
arr = [1, 2, 3, 4, 5]  

# 访问列表元素，通过索引（从 0 开始）
print(arr[0])   # 取第一个元素 1
print(arr[-1])  # 取最后一个元素 5  

# 修改列表元素，通过索引赋值
arr[0] = 10
print(arr)  # 输出 [10, 2, 3, 4, 5]  

# 添加元素，append 是在末尾添加，insert 是在指定索引位置插入
arr.append(6)          # 末尾添加 6，列表变成 [10, 2, 3, 4, 5, 6]
arr.insert(1, 99)      # 在索引 1 的位置插入 99，列表变成 [10, 99, 2, 3, 4, 5, 6]
print(arr)  

# 删除元素，pop 可按索引删（默认删最后一个），remove 按值删
arr.pop()              # 删除最后一个元素 6，列表变成 [10, 99, 2, 3, 4, 5]
arr.pop(1)             # 删除索引 1 的元素 99，列表变成 [10, 2, 3, 4, 5

十二、元组操作

# 创建元组
t1 = (1, 2, 3)
t2 = "a", "b", "c"  # 可以省略括号
t3 = (5,)           # 单个元素的元组需要加逗号

# 访问元素
print(t1[0])  # 1
print(t2[-1]) # 'c'

# 元组不可修改（以下代码会报错）
# t1[0] = 10  

# 元组常用操作
print(len(t1))          # 长度: 3
print(t1 + t2)          # 拼接: (1, 2, 3, 'a', 'b', 'c')
print(t1 * 2)           # 重复: (1, 2, 3, 1, 2, 3)
print(2 in t1)          # 成员检查: True

# 元组拆包
a, b, c = t1
print(a, b, c)  # 1 2 3

十三、集合操作

# 创建集合
s1 = {1, 2, 3, 4}
s2 = set([3, 4, 5, 6])  # 从列表创建

# 集合自动去重
s3 = {1, 2, 2, 3, 3, 3}
print(s3)  # {1, 2, 3}

# 集合操作
s1.add(5)               # 添加元素
s1.remove(1)            # 删除元素
print(s1.union(s2))     # 并集: {2, 3, 4, 5, 6}
print(s1.intersection(s2))  # 交集: {3, 4}
print(s1.difference(s2))    # 差集: {2}

# 成员检查
print(3 in s1)  # True

十四、字典操作

# 创建字典
d = {
    "name": "张三",
    "age": 20,
    "gender": "男"
}

# 访问值
print(d["name"])    # '张三'
print(d.get("age")) # 20
print(d.get("score", 0))  # 获取不存在的键，返回默认值0

# 修改值
d["age"] = 21
print(d)  # {'name': '张三', 'age': 21, 'gender': '男'}

# 添加新键值对
d["score"] = 90
print(d)  # 新增了 'score': 90

# 删除键值对
del d["gender"]
print(d)  # {'name': '张三', 'age': 21, 'score': 90}

# 字典常用方法
print(d.keys())     # 所有键: dict_keys(['name', 'age', 'score'])
print(d.values())   # 所有值: dict_values(['张三', 21, 90])
print(d.items())    # 所有键值对: dict_items([('name', '张三'), ('age', 21), ('score', 90)])

# 遍历字典
for key, value in d.items():
    print(f"{key}: {value}")

十五、函数

# 基本函数定义与调用
def greet():
    """这是一个打招呼的函数"""
    print("Hello, World!")

greet()  # 调用函数

# 带参数的函数
def add(a, b):
    """计算两个数的和"""
    return a + b

result = add(3, 5)
print(result)  # 8

# 带默认参数的函数
def power(base, exponent=2):
    """计算base的exponent次方，默认平方"""
    return base ** exponent

print(power(3))    # 9（使用默认参数）
print(power(3, 3)) # 27（指定参数）

# 函数返回多个值
def get_user():
    name = "张三"
    age = 20
    return name, age  # 实际返回一个元组

username, userage = get_user()
print(username, userage)  # 张三 20

十六、不定长参数

# *args 接收任意数量的位置参数（元组形式）
def sum_numbers(*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

# **kwargs 接收任意数量的关键字参数（字典形式）
def show_info(** kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

show_info(name="张三", age=20, gender="男")

# 混合使用
def func(a, b, *args, **kwargs):
    print(f"a: {a}, b: {b}")
    print(f"args: {args}")
    print(f"kwargs: {kwargs}")

func(1, 2, 3, 4, 5, name="Python", version=3.11)