（Python）Python基础语法介绍（二）（Python基础教学）

前言：

请看上篇：（Python）Python基础语法介绍（一）（Python基础教学）-CSDN博客

常用软件：

市面上有很多写Python的软件，这里博主推荐几个博主认为好用的软件

一、PyCharm

• 地位：Python 开发者首选 IDE 之一，尤其在专业开发、大型项目场景中使用率极高。
• 特点：
  • 智能代码补全、语法检查、错误提示超高效，写代码像 “开了外挂”；
  • 强大调试工具 + 丰富插件生态（支持 Django、Flask 等框架），专业开发必备；
  • 分免费社区版（满足基础开发）和收费专业版（适配复杂项目，如数据库、高级框架）。

二、Visual Studio Code（VS Code）

• 地位：轻量级 “万能编辑器”，Python 开发领域人气爆炸，几乎是必装工具。
• 特点：
  • 开源跨平台（Windows、Linux、Mac 通吃），装个 Python 扩展插件，补全、调试、格式化全搞定；
  • 插件生态无敌丰富（Git 集成、Lint 检查等），从入门脚本到中大型项目都能 hold 住，“新手友好 + 大佬顺手”。

三、IDLE

• 地位：Python 自带的 “极简编辑器”，新手入门专属。
• 特点：
  • 无需额外安装，装 Python 就送；
  • 语法高亮、简单调试功能都有，适合纯小白学基础语法（代码量别太大，复杂项目扛不住）。

基础语法教程 （二）

一.字典{}

字典由两部分组成：keys(键)和values(值)

键必须为不可变数据类型；即字符串、整数、浮点数等，不能为列表。

字典由花括号表示：

a_dict={"苹果":12,"橘子":30}
print(a_dict)
#结果为：{'苹果': 12, '橘子': 30}

添加或更新键值对的方法：字典名[“键”] = “值“

a_dict={"苹果":12,"橘子":30}
print(a_dict)
a_dict["香蕉"]=45
print(a_dict)
#结果为：{'苹果': 12, '橘子': 30, '香蕉': 45}

判断键是否存在字典里面：“键”in 字典名

a_dict={"苹果":12,"橘子":30}
print(a_dict)
a_dict["香蕉"]=45
print(a_dict)
print("苹果" in a_dict)           #结果为：True
print("小苹果" in a_dict)         #结果为：False

删除键与对应的值：del 字典名[“键”]

a_dict={"苹果":12,"橘子":30}
print(a_dict)
a_dict["香蕉"]=45
print(a_dict)
print("苹果" in a_dict)
print("小苹果" in a_dict)
del a_dict["橘子"]
print(a_dict)            #结果为：{'苹果': 12, '香蕉': 45}

和字符串一样，字典可以利用len()函数求键值对数量：len(字典名) 

a_dict={"苹果":12,"橘子":30}
print(a_dict)
print(len(a_dict))            #结果为：2
a_dict["香蕉"]=45
print(a_dict)                 #结果为：3
print(len(a_dict))

返回字典的键、值、键值对的方法：

a_dict={"苹果":12,"橘子":30}

a_dict.keys()                   #返回所有键
a_dict.values()                 #返回所有值
a_dict.items()                  #返回所有键和值

print(a_dict.keys())
print(a_dict.values())
print(a_dict.items())

结果为：

dict_keys(['苹果', '橘子'])
dict_values([12, 30])
dict_items([('苹果', 12), ('橘子', 30)])

二. range()函数

在 Python 中，range() 是一个内置函数，用于生成不可变的整数序列。它在循环结构中特别常用，比如 for 循环，可以帮助你轻松地控制迭代次数和迭代步长。下面我将详细解释 range() 函数的用法、参数和特性。

range() 函数有三种调用形式，每种形式的参数含义不同：

1. range(stop)

• 参数：stop（必需），表示序列结束的整数（不包含该值）。
• 返回：从 0 开始，到 stop-1 结束的整数序列，步长为 1。

示例：

print(list(range(5)))  # 输出: [0, 1, 2, 3, 4]

2. range(start, stop)

• 参数：
  • start（必需），表示序列开始的整数（包含该值）。
  • stop（必需），表示序列结束的整数（不包含该值）。
• 返回：从 start 开始，到 stop-1 结束的整数序列，步长为 1。

示例：

print(list(range(2, 6)))  # 输出: [2, 3, 4, 5]

3. range(start, stop, step)

• 参数：
  • start（必需），表示序列开始的整数（包含该值）。
  • stop（必需），表示序列结束的整数（不包含该值）。
  • step（必需），表示序列中相邻两个数的差值（步长），可以为正或负（不能为 0）。
• 返回：从 start 开始，按照 step 递增或递减，直到不超过 stop（但不包含 stop）的整数序列。

示例：

print(list(range(0, 10, 2)))  # 步长为 2，输出: [0, 2, 4, 6, 8]
print(list(range(10, 0, -2)))  # 步长为 -2，输出: [10, 8, 6, 4, 2]

 三.for循环

表达式：for 变量名 in 可迭代对象：

for i in range(5):
    print(i)
#结果为:0 1 2 3 4,共循环5次
#其中i是变量名；range(5)是可迭代对象

1. range(5)生成一个从 0 到 4 的整数序列（共 5 个数字）
2. 循环变量i依次被赋值为序列中的每个数字
3. 每次循环执行print(i)输出当前值

break 终止当前循环，,使程序跳出循环体。

for i in range(0,6):
    if i==4:
        break
    print(i)
#结果为：0 1 2 3

当i=4时跳出循环，后续循环不在执行 

continue 结束当前循环剩余语句，继续下一轮循环

for i in range(0,6):
    if i==4:
        continue
    print(i)
#结果为：0 1 2 3 5

只跳过i=4的时候，后续循环依旧执行

变量名也可以是两个，只要对应可迭代对象即可，如：

a_dict={"苹果":12,"橘子":30}

for name,num in a_dict.items():
    print(name)
    print(num)
#结果为：
苹果
12
橘子
30

四.格式化字符

1.format方法：

format内的参数起始编号以0开始，即花括号引用的0表示第一个参数，1表示第二个参数。

format方法调到用字符串可以直接调用数字，不需要额外进行数字转字符串的操作。

a_dict={"苹果":12.1,"橘子":30.589}

for name,num in a_dict.items():
    print("{0}的单价是：{1}".format(name,num))
#结果：
苹果的单价是：12.1
橘子的单价是：30.589

还可以使用 冒号+点+数字（决定保留几位小数）+f 来指定浮点数在格式化是保留几位小数。

a_dict={"苹果":12.1,"橘子":30.589}

for name,num in a_dict.items():
    print("{0}的单价是：{1:.2f}".format(name,num))
#结果：
苹果的单价是：12.10
橘子的单价是：30.59

 2.f-字符串

f字符串引用已定义的字符串变量。使用后不需要使用format方法，如：

a_dict={"苹果":12.1,"橘子":30.589}

for name,num in a_dict.items():
    print(f"{name}的单价是：{num}")

for name,num in a_dict.items():
    print(f"{name}的单价是：{num:.2f}")

结果为：

苹果的单价是：12.1
橘子的单价是：30.589
苹果的单价是：12.10
橘子的单价是：30.59

五.函数

1.内置函数

上面说过Python有很多的内置函数，如range(),sum()等等

2.自定义函数

定义函数

使用 def 关键字定义函数，语法如下：

def 函数名(参数列表):
    """函数文档字符串（可选）"""
    函数体
    return 返回值  # 可选

• 函数名：遵循标识符命名规则（字母、数字、下划线，不能以数字开头，不与内置函数重名）。
• 参数列表：函数接收的输入值，多个参数用逗号分隔，也可以没有参数。
• 文档字符串（Docstring）：用于描述函数的功能、参数和返回值，可选但推荐添加。
• 函数体：实现函数功能的代码块。
• return 语句：结束函数并返回值，可选；若不使用，函数默认返回 None。

调用函数

定义后的函数需通过函数名加括号（并传入必要参数）来调用：

函数名(参数值)

示例：

def greet(name):
    """向指定名字的人打招呼"""
    return f"Hello, {name}!"

# 调用函数
message = greet("Alice")
print(message)  # 输出: Hello, Alice!

3.函数参数的类型

Python 函数的参数非常灵活，支持多种类型：

1. 位置参数（Positional Arguments）

最常见的参数类型，调用时需按定义顺序传入对应的值。

示例：

def add(a, b):
    return a + b

result = add(3, 5)  # 3 对应 a，5 对应 b
print(result)  # 输出: 8

2. 默认参数（Default Arguments）

定义时为参数指定默认值，调用时若未传入该参数，则使用默认值。

注意：默认参数必须放在位置参数之后。

示例：

def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

print(greet("Bob"))  # 未传入 greeting，使用默认值
print(greet("Bob", "Hi"))  # 传入 greeting，覆盖默认值

3. *可变位置参数（args）

用于处理不确定数量的位置参数，参数会被封装成元组（tuple）。

示例：

def sum_all(*args):
    total = 0
    for num in args:
        total += num
    return total

print(sum_all(1, 2, 3))  # 输出: 6
print(sum_all(1, 2, 3, 4, 5))  # 输出: 15

4. ** 可变关键字参数（kwargs）

用于处理不确定数量的关键字参数，参数会被封装成字典（dict）。

示例：

def describe_person(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

describe_person(name="Alice", age=30, city="Beijing")
# 输出:
# name: Alice
# age: 30
# city: Beijing

5. 关键字参数（Keyword Arguments）

调用时通过参数名指定值，可打破位置参数的顺序限制。

示例：

def subtract(a, b):
    return a - b

print(subtract(5, 3))  # 位置参数：5-3=2
print(subtract(b=3, a=5))  # 关键字参数：5-3=2

参数组合规则

多种参数类型可混合使用，但需遵循固定顺序：
位置参数 → 默认参数 → *args → 关键字参数 → **kwargs。

示例：

def complex_func(a, b, c=3, *args, d, **kwargs):
    print(f"a={a}, b={b}, c={c}, args={args}, d={d}, kwargs={kwargs}")

complex_func(1, 2, 4, 5, 6, d=7, e=8, f=9)
# 输出:
# a=1, b=2, c=4, args=(5, 6), d=7, kwargs={'e': 8, 'f': 9}

5.函数的返回值

基本返回值

使用 return 语句返回函数的结果，函数执行到 return 时立即结束，后续代码不会执行。

示例：

def is_even(num):
    if num % 2 == 0:
        return True
    return False  # 也可简化为：return num % 2 == 0

print(is_even(4))  # 输出: True
print(is_even(5))  # 输出: False

返回多个值

Python 允许函数返回多个值，实际会被打包成元组（tuple）。

示例：

def get_name_and_age():
    return "Bob", 25  # 等价于: return ("Bob", 25)

result = get_name_and_age()
print(result)  # 输出: ('Bob', 25)

# 解包赋值
name, age = get_name_and_age()
print(name, age)  # 输出: Bob 25

6.函数的作用域（Scope）

函数内部定义的变量（局部变量）和外部定义的变量（全局变量）有不同的作用域：

局部变量

在函数内部定义的变量，只能在函数内部访问，函数执行结束后变量销毁。

示例：

def test():
    x = 10  # 局部变量
    print(x)  # 函数内部可访问

test()  # 输出: 10
# print(x)  # 报错：NameError: name 'x' is not defined

全局变量

在函数外部定义的变量，可在函数内部访问，但默认无法修改。

示例：

y = 20  # 全局变量

def modify_y():
    # y += 1  # 报错：UnboundLocalError: local variable 'y' referenced before assignment
    print(y)  # 可访问全局变量

modify_y()  # 输出: 20

修改全局变量

若需在函数内部修改全局变量，需使用 global 关键字声明。

示例：

z = 30

def update_z():
    global z  # 声明 z 为全局变量
    z += 1
    print(z)

update_z()  # 输出: 31
print(z)    # 输出: 31（全局变量已被修改）

7.函数的嵌套与闭包

嵌套函数

在函数内部定义的函数，只能在外部函数内部调用。

示例：

def outer():
    x = 10
    def inner():  # 嵌套函数
        print(x)  # 可访问外部函数的变量
    inner()  # 外部函数内部调用嵌套函数

outer()  # 输出: 10
# inner()  # 报错：NameError: name 'inner' is not defined

闭包（Closure）

嵌套函数若引用了外部函数的变量，并被外部函数返回，则形成闭包。闭包可保留外部函数的变量状态。

示例：

def make_adder(n):
    def adder(x):
        return x + n  # 引用外部函数的变量 n
    return adder  # 返回嵌套函数

add5 = make_adder(5)  # n=5 被保留在闭包中
print(add5(3))  # 输出: 8（3+5）
print(add5(7))  # 输出: 12（7+5）

注：该代码是本人自己所写，可能不够好，不够简便，欢迎大家指出我的不足之处。如果遇见看不懂的地方，可以在评论区打出来，进行讨论，或者联系我。上述内容全是我自己理解的，如果你有别的想法，或者认为我的理解不对，欢迎指出！！！如果可以，可以点一个免费的赞支持一下吗？谢谢各位彦祖亦菲！！！！