Python基础语法(二)

前言
一：顺序语句
二：条件语句
- 1.语法格式
- 2.pass
三：循环语句
四：函数
- 1.函数的本质
- 2.为什么要用函数？
- 3.语法结构
- - 1.定义函数
  - 2.调用函数
- 4.参数传递
- - [1.动态类型：形参不必指定类型。同一个函数可以接收整数、字符串甚至布尔值](#1.动态类型：形参不必指定类型。同一个函数可以接收整数、字符串甚至布尔值)
  - [2. 数量匹配：虽然类型不限，但参数个数必须匹配。如果定义了 3 个参数只传 1 个，Python 会毫不留情地抛出 TypeError 。](#2. 数量匹配：虽然类型不限，但参数个数必须匹配。如果定义了 3 个参数只传 1 个，Python 会毫不留情地抛出 TypeError 。)
  - [3.参数默认值：和 C++ 类似，可以给形参指定默认值。但规则一样：带默认值的参数必须放在最后。](#3.参数默认值：和 C++ 类似，可以给形参指定默认值。但规则一样：带默认值的参数必须放在最后。)
  - [4.关键字参数：调用时可以不按顺序，直接指定"形参名=实参值" 。](#4.关键字参数：调用时可以不按顺序，直接指定“形参名=实参值” 。)
- 5.返回值
- 6.变量作用域：全局与局部
- - [1. 变量作用域：变量不是"到处都能用"的](#1. 变量作用域：变量不是“到处都能用”的)
  - 2.局部变量和全局变量：名字一样，不代表是同一个
  - [3. 函数里能读全局变量，但默认不能直接改](#3. 函数里能读全局变量，但默认不能直接改)
  - [4.Python 里 if / while / for 不会像函数那样形成新作用域](#4.Python 里 if / while / for 不会像函数那样形成新作用域)
  - 5.参数默认值：调用时可以不传的参数
  - 6.关键字参数：传参时可以直接点名
- 7.函数总结

前言

前面我们总结了一部分关于Python的基础语法,并且和C++与之先关的语法进行了对比,我们其实发现一个特点,各个语言的设计是有相似性的...,接下来我们继续学习有关Python的语法.

一：顺序语句

在默认的情况下,Python代码的执行顺序是从上到下的,这样的顺序的语句称为顺序语句

二：条件语句

Python中的条件语句和C++中的条件语句基本是一样的,再语法使用上有点差别

1.语法格式

Python 中使用 if else 关键字表示条件语句.

(1) if

python 复制代码

if expression:
	do_something1
	do_something2
next_something

解释:

1.如果 expression 值为 True, 则执行 do_something1, do_something2, next_something

2.如果 expression 值为 False, 则只执行 next_something, 不执行 do_something1, do_something2

(2) if - else

python 复制代码

if expression:
	do_something1
else:
	do_something2

解释:

1.如果 expression 值为 True, 则执行 do_something1

2.如果 expression 值为 False, 则执行 do_something2

(3) if - elif - else

python 复制代码

if expression1:
	do_something1
elif expression2:
	do_something2
else:
	do_something3

解释:

1.如果 expression1 值为 True, 则执行 do_something1

2.如果 expression1 值为 False, 并且 expression2 为 True 则执行 do_something2

3.如果 expression1 值为 False, 并且 expression2 为 False 则执行 do_something3

注意:

if 后面的条件表达式, 没有 ( ), 使用 : 作为结尾.

if / else 命中条件后要执行的 "语句块", 使用缩进 (通常是 4 个空格或者 1 个 tab)来表示, 而不是 { }

对于多条件分支, 不是写作 else if, 而是 elif (合体了).

2.pass

1.在Python中如果你在判断语句里面的执行代码块不写代码,是会报错的,这时候就需要加上pass.

2.pass 表示空语句, 并不会对程序的执行有任何影响, 只是占个位置

三：循环语句

1.while循环

基本语法格式:

while 条件:

循环体

当条件为真的时候,就继续循环,如果条件是假的,那就停止循环

2.for循环

基本格式:

for 循环变量 in 可迭代对象:

循环体

解释:

1.python 的 for 和其他语言不同, 没有 "初始化语句", "循环条件判定语句", "循环变量更新语句", 而是更加简单

2.可迭代对象指的是内部包含多个元素, 能一个一个把元素取出来的特殊变量

3.continue

在循环语句语句中,进行到这个语句的时候,结束这次循环, 进入下次循环.

4.break

break 表示结束整个循环

四：函数

1.函数的本质

在编程中，函数是一段可以被重复使用的代码片段

2.为什么要用函数？

实际开发中，复制粘贴是最烂的策略。如果一段相似的代码出现了几十次，一旦需要修改，你就得改几十次，这简直是维护噩梦。

所以,把重复逻辑提取出来，封装成函数。这不仅消除了冗余，还让代码逻辑更清晰。

3.语法结构

1.定义函数

使用 def 关键字（这相当于 C++ 中的函数声明+定义）：

python 复制代码

def 函数名(形参列表):
    函数体
    return 返回值

2.调用函数

python 复制代码

result = 函数名(实参列表)

4.参数传递

Python 的参数传递有几点非常"前卫",

1.动态类型：形参不必指定类型。同一个函数可以接收整数、字符串甚至布尔值

python 复制代码

def test(a):
    print(a)

test(10)      
test('hello')

运行结果:

2. 数量匹配：虽然类型不限，但参数个数必须匹配。如果定义了 3 个参数只传 1 个，Python 会毫不留情地抛出 TypeError 。

3.参数默认值：和 C++ 类似，可以给形参指定默认值。但规则一样：带默认值的参数必须放在最后。

4.关键字参数：调用时可以不按顺序，直接指定"形参名=实参值" 。

5.返回值

Python 的 return 比 C++ 灵活得多：

逻辑分离：好的函数应该只负责逻辑计算，不负责用户交互（如 print）。这样你的函数才能被复用到 GUI、网络或文件等各种场景中。

多返回值： Python 支持一次返回多个值，用逗号分隔

python 复制代码

def getPoint():
    return 10, 20  

x, y = getPoint() 
_, b = getPoint()

6.变量作用域：全局与局部

1. 变量作用域：变量不是"到处都能用"的

变量只能在它所属的作用域里生效。

python 复制代码

def getPoint():
    x = 10
    y = 20
    return x, y

getPoint()
print(x, y)   # 报错

如果你这样写：

python 复制代码

x, y = getPoint()
print(x, y)

意思是：
把函数返回的值，交给函数外部的新变量 x 和 y。名字虽然一样，但已经不是函数内部那两个变量了。

2.局部变量和全局变量：名字一样，不代表是同一个

python 复制代码

x = 20
#函数外部

def test():
    x = 10
    #函数内部
    print(f'函数内部 x = {x}')

test()
print(f'函数外部 x = {x}')

说明函数里的 x = 10，并没有把外面的 x = 20 改掉，而是重新创建了一个局部变量 x

注意：这个和C++的语法是有点不同的，需要理解

3. 函数里能读全局变量，但默认不能直接改

如果函数内部找不到某个变量，就会去全局作用域里查找

python 复制代码

x = 20

def test():
    print(f'x = {x}')

test()

这里函数内部没有定义 x，所以就去外面找，最后打印的是全局变量 x = 20

但是需要的注意是，能读，不等于能直接改

python 复制代码

x = 20

def test():
    global x
    x = 10
    print(f'函数内部 x = {x}')

test()
print(f'函数外部 x = {x}')

因为如果不加，Python 会把 x = 10 视为"我在函数内部新建了一个局部变量 x"，而不是"我要修改外面的那个 x"。

函数里读全局变量，通常没问题；函数里改全局变量，默认不行，要 global

4.Python 里 if / while / for 不会像函数那样形成新作用域

和C++不同的是，if / while / for 等语句块不会影响变量作用域。也就是说，你在 for 里写的变量，出去以后通常还能用。

python 复制代码

for i in range(1, 10):
    print(f'函数内部 i = {i}')

print(f'函数外部 i = {i}')

说明：

1.函数是强作用域边界

2.if / while / for 不是

所以：在 Python 里，真正要特别关注的作用域边界，首先是函数。

5.参数默认值：调用时可以不传的参数

python 复制代码

def add(x, y, debug=False):
    if debug:
        print(f'调试信息: x={x}, y={y}')
    return x + y

需要注意的是**：带默认值的参数，要放在没有默认值的参数后面。**

6.关键字参数：传参时可以直接点名

正常调用函数时，实参是按位置一一对应的。

但是，还可以用关键字参数，显式指定这个实参是传给哪个形参的。

python 复制代码

def test(x, y):
    print(f'x = {x}')
    print(f'y = {y}')

test(x=10, y=20)
test(y=100, x=200)

传参顺序可以调整，但意思不会乱

7.函数总结

第一层：变量住在哪

函数里的变量，默认只在函数里活着
函数外面的变量是全局变量
同名变量不一定是同一个变量

第二层：函数怎么跑

函数定义不会执行
调用才执行
执行完会回到调用点
return 相当于"带着结果提前返回"

第三层：一层套一层时怎么理解

链式调用：结果传给别人
嵌套调用：函数里再叫别人
调用栈：谁先进去，谁后出来
递归：自己调用自己，但必须有出口

第四层：参数怎么传

默认参数：不给就用默认值
关键字参数：显式指定传给谁

所以所以：

在 Python 中，函数不仅仅是"把几行代码打包"这么简单，它背后还牵涉到变量作用域、函数执行顺序、参数传递方式以及调用栈等一整套机制。局部变量只在函数内部生效，全局变量虽然能被函数读取，但若要在函数内部修改，通常需要使用 global 声明。函数调用时，程序会进入新的栈帧，执行结束后再返回原位置继续执行。链式调用体现的是"返回值继续参与下一次调用"，嵌套调用体现的是"函数之间层层协作"，而递归则是函数调用自身的特殊情况。掌握了这些内容，后续学习列表、元组、字典时，就能更清楚地理解数据是如何在函数之间流动的。

Python基础语法(二)

目录

前言

一：顺序语句

二：条件语句

1.语法格式

2.pass

三：循环语句

1.while循环

2.for循环

3.continue

4.break

四：函数

1.函数的本质

2.为什么要用函数？

3.语法结构

1.定义函数

2.调用函数

4.参数传递

1.动态类型： 形参不必指定类型 。同一个函数可以接收整数、字符串甚至布尔值

2. 数量匹配： 虽然类型不限，但参数个数必须匹配 。如果定义了 3 个参数只传 1 个，Python 会毫不留情地抛出 TypeError 。

3.参数默认值： 和 C++ 类似，可以给形参指定默认值 。但规则一样：带默认值的参数必须放在最后 。

4.关键字参数： 调用时可以不按顺序，直接指定"形参名=实参值" 。

5.返回值

6.变量作用域：全局与局部

1. 变量作用域：变量不是"到处都能用"的

2.局部变量和全局变量：名字一样，不代表是同一个

3. 函数里能读全局变量，但默认不能直接改

4.Python 里 if / while / for 不会像函数那样形成新作用域

5.参数默认值：调用时可以不传的参数

6.关键字参数：传参时可以直接点名

7.函数总结

1.动态类型：形参不必指定类型。同一个函数可以接收整数、字符串甚至布尔值

2. 数量匹配：虽然类型不限，但参数个数必须匹配。如果定义了 3 个参数只传 1 个，Python 会毫不留情地抛出 TypeError 。

3.参数默认值：和 C++ 类似，可以给形参指定默认值。但规则一样：带默认值的参数必须放在最后。

4.关键字参数：调用时可以不按顺序，直接指定"形参名=实参值" 。