Python语法基础（条件语句 循环语句 函数 切片及索引）

---

条件语句

关键字

• True False
• not and or
• None
• if else elif

与C++对照

height = int(input())
vip_level = int(input())

if height < 120:
    print("身高下雨120CM，可以免费游玩。")
elif vip_level > 3:
    print("你的VIP等级大于3，可以免费游玩。")
else:
    print("抱歉，所有条件均不满足，需要支付10元。")
1
2
3
4
5
6
7
8
9

注意

Python if 语句中的条件判断默认就包含了逻辑与的语义，所以不需要显式地使用 and 关键字进行与操作。

grade = int(input('输⼊⼩明考试语⽂分：'))
if 90 <= grade <= 100:
    print('A')
elif 75 <= grade < 90:
    print('B')
elif 60 <= grade < 75:
    print('C')
else:
    print('D')
1
2
3
4
5
6
7
8
9

循环语句

注意：Python中没有 ++ 和 --

while 循环语句

count = 0
while count < 9:
    print(f"The count is:> {count}")
    count += 1
print("Good Bye!\n")
1
2
3
4
5

while else 循环语句

while … else 在循环条件为 false 时执行 else 语句块

注意：else块属于与之最近的for或while循环，而不是if条件。在你的代码中，else块确实属于while循环，因此它可以访问在循环中定义的变量。

count = 0
while count < 9:
    print(f"The count is:> {count}")
    s = 999
    count += 1
else:
    print("Good Bye! %d" % s)  # 可以访问在循环中定义的变量
1
2
3
4
5
6
7

for 循环语句

• for、in、range结合，遍历整数序列
• for、in、list、dict结合，遍历容器内的元素

range() 函数

• 当 range() 函数的参数只有一个时，range() 函数生产出的数字是从 0 开始，并且右侧的区间是不包含在内的。

# 求1-100的和
sum_num = 0
for i in range(101):
    sum_num += i
print(sum_num)
1
2
3
4
5

• 当 range() 函数的参数有多个时，以第一个参数作为起点开始遍历到第二个参数，但
  不包含第二个参数。换句话说， range() 函数是一个左闭右开的取值区间。

# 输出100-999的所有水仙花数
for i in range(100, 1000):
    tmp, sum_num = i, 0
    while tmp:
        sum_num += (tmp % 10) ** 3
        tmp //= 10
    if sum_num == i:
        print(i, end=' ')
1
2
3
4
5
6
7
8

• range() 的第三个参数是控制遍历间隔的参数，通过这个参数可以使生产的数字不仅为有序连续数列，还可以生成规定间隔的连续数列。

# 输出1-100的所有奇数
for i in range(1, 101, 2):
    print(i, end=' ')
1
2
3

for else 循环语句

等同于while else

for i in range(1, 100, 2):
    print(i, end=' ')
else:
    print("\n输出完毕！")
1
2
3
4

循环控制语句

• break语句
  break退出for循环或while循环。

• continue语句
  跳过continue下的语句，继续执⾏下⼀次循环。

• pass语句
  Python pass 是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句。（代码块为空，用pass占位。）

for letter in 'Python':
    if letter == 'h':
        pass 
        print('这是 pass 块')
    print('当前字母 :', letter) 
print("Good bye!")
1
2
3
4
5
6

练习：打印乘法表

乘法表

for i in range(1, 10):
    for j in range(1, i + 1):
        print("%d * %d = %d" % (j, i, i * j), end='  ')
    print()
1
2
3
4

函数

函数定义及调用

def 函数名(参数列表):
    //实现特定功能的多行代码
    [return [返回值]]
1
2
3

如果想定义一个没有任何功能的空函数，可以使用 pass 语句作为占位符。

[返回值] = 函数名([形参值])
1

示例：

def is_prime(num):
    if num <= 1:
        return False
    i = 2
    while i <= num // i:
        if not (num % i):
            return False
        i += 1
    return True


for i in range(1, 101):
    if is_prime(i):
        print(i, end=' ')
1
2
3
4
5
6
7
8
9
10
11
12
13
14

函数值传递和引用传递

Python 中，根据实际参数的类型不同，函数参数的传递方式可分为 2 种，分别为值传递和引用（地址）传递：

• 值传递：适用于实参类型为不可变类型（字符串、数字、元组）
• 引用（地址）传递：适用于实参类型为可变类型（列表、字典、类）

多返回值

在Python中，函数可以返回多个值）。实际上，函数返回的多个值是以元组（tuple）的形式进行返回的，可以通过逗号分隔的方式返回多个表达式或变量。

def get_name_and_age():
    name = "John"
    age = 30
    country = "USA"
    return name, age, country

name, _, country = get_name_and_age()
print(name)     # 输出: John
print(country)  # 输出: USA
1
2
3
4
5
6
7
8
9

在上面的示例中，我们只对名字和国家变量感兴趣，而不关心年龄。通过使用下划线 _，我们可以将不需要的返回值忽略掉。

参数类型

在Python中，函数的参数可以有多种类型。

位置参数

这是最常见的参数类型，函数通过位置来匹配参数的值。示例：

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

result = add(3, 5)  # 位置参数 3 和 5 分别传递给 a 和 b
print(result)  # 输出: 8
1
2
3
4
5

默认参数

与C++的缺省参数相似
默认参数允许在函数定义时为参数提供默认值。如果在函数调用时没有传递对应的参数值，将使用默认值。

def greet(name, message="Hello"):
    print(message, name)

greet("Alice")  # 使用默认参数值 "Hello"
greet("Bob", "Hi")  # 使用指定的参数值 "Hi"
1
2
3
4
5

注意：默认参数必须跟在非默认参数的后面。

关键字参数

使用关键字参数，可以通过参数名指定传递的参数值，而不必按照定义的顺序传递参数。

def greet(name, message):
    print(f"{message}, {name}!")

greet(message="Hello", name="John")

1
2
3
4
5

可变数量的参数

有时候函数需要接受可变数量的参数，Python提供了两种方式来实现这个功能。

可变数量的位置参数

在函数定义时，在参数名前加上星号(*)，表示该参数可以接受任意数量的位置参数，这些参数将作为一个元组传递给函数。

def add(*numbers):
    result = 0
    for num in numbers:
        result += num
    return result

total = add(1, 2, 3, 4)  # 传递任意数量的位置参数
print(total)  # 输出: 10
1
2
3
4
5
6
7
8

可变数量的关键字参数

在函数定义时，在参数名前加上两个星号(**)，表示该参数可以接受任意数量的关键字参数，这些参数将作为一个字典传递给函数。

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(key, ":", value)

print_info(name="Alice", age=25)  # 传递任意数量的关键字参数
# 输出:
# name : Alice
# age : 25
1
2
3
4
5
6
7
8

lambda函数

lambda arguments: expression

• arguments是函数的参数列表
• expression是函数体的表达式

Python 的 lambda函数的特点如下：

匿名性：lambda函数没有函数名，因此被称为匿名函数。它通常用于需要一个简短的函数定义的场景，不需要为函数命名。

简洁性：lambda函数以一种非常简洁的方式定义函数，将函数体限制在一个表达式中。

函数对象：lambda函数本质上是一个函数对象，可以像普通函数一样调用和使用。

Lambda函数通常用于需要一个简单函数的地方，而不必为这个函数专门定义一个完整的函数。例如，在map、filter、sorted等函数中，可以使用lambda表达式来定义临时的小函数。

示例：

my_lambda = lambda x, y: (x + y, x - y) if x > y else (x - y, x + y)
result = my_lambda(5, 3)
print(result)  # 输出 (8, 2)
1
2
3

练习：实现斐波那契数列序列函数

def fibo(n):
    fibo_list = []
    if n >= 1:
        fibo_list.append(1)
    if n >= 2:
        fibo_list.append(1)
    for i in range(2, n):
        fibo_list.append(fibo_list[i - 1] + fibo_list[i - 2])
    return fibo_list


n = int(input())
ans = fibo(n)
print(ans)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

切片及索引

在Python中，切片（slicing）是一种用于访问序列对象（如字符串、列表、元组等）的子序列的方法。切片操作使用索引来指定要提取的子序列的起始位置、结束位置和步长。

sequence[start:stop:step]

切片是Python中一种常用的浅拷贝方式，可以通过 [:] 实现。以列表为例：

a = [1, 2, 3, [4, 5]]
b = a[:]
1
2

这里b就是a的浅拷贝。我们可以尝试改变a中的子列表：

a[3][0] = 6
1

然后查看b：

print(b)   # [1, 2, 3, [6, 5]]
1

可以看到，b中的子列表也被改变了，说明b只是拷贝了a中的元素引用，而非新创建了一个对象。

下标索引

从前向后，下标从0开始。
从后向前，下标从-1开始。

name = "Hello World"
print(name[0])  # 输出H
print(name[-1])  # 输出d
1
2
3

切片提取子序列

sequence = "Hello, World!"

# 提取从索引2到索引5（不包含）的子序列
slice1 = sequence[2:5]
print(slice1)  # 输出: llo

# 提取从索引0到索引6（不包含）的子序列
slice2 = sequence[:6]
print(slice2)  # 输出: Hello,

# 提取从索引7到末尾的子序列
slice3 = sequence[7:]
print(slice3)  # 输出: World!

# 提取整个序列的副本
slice4 = sequence[:]
print(slice4)  # 输出: Hello, World!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

使用步长提取间隔子序列

sequence = "Hello, World!"

# 提取从索引1到索引末尾的字符，步长为2（每隔一个字符取一个）
slice5 = sequence[1::2]
print(slice5)  # 输出: el,Wr!

# 提取整个序列的逆序
slice6 = sequence[::-1]
print(slice6)  # 输出: !dlroW ,olleH
1
2
3
4
5
6
7
8
9

切片对可变序列的影响

切片操作返回一个新的序列对象，对原始序列没有直接影响。但是，如果切片用于可变序列（如列表），则可以通过切片修改原始序列的值。

numbers = [1, 2, 3, 4, 5]

# 修改切片的值
numbers[1:4] = [10, 20, 30]
print(numbers)  # 输出: [1, 10, 20, 30, 5]
1
2
3
4
5

易错点

步长为负时候，start 与 end 也要满足步长负方向的性质，start 取闭，end 取开依旧满足此性质。

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
s = a[7:2:-1]
print(s)
1
2
3