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

目录

  • 条件语句
    • 关键字
    • 与C++对照
    • 注意
  • 循环语句
    • while 循环语句
    • while else 循环语句
    • for 循环语句
      • range() 函数
    • for else 循环语句
    • 循环控制语句
    • 练习:打印乘法表
  • 函数
    • 函数定义及调用
    • 函数值传递和引用传递
    • 多返回值
    • 参数类型
      • 位置参数
      • 默认参数
      • 关键字参数
      • 可变数量的参数
        • 可变数量的位置参数
        • 可变数量的关键字参数
    • lambda函数
    • 练习:实现斐波那契数列序列函数
  • 切片及索引
    • 下标索引
    • 切片提取子序列
    • 使用步长提取间隔子序列
    • 切片对可变序列的影响
    • 易错点


条件语句

关键字

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

与C++对照

Python C++
True true
False false
not ! (逻辑非)
and && (逻辑与)
or || (逻辑或)
None nullptr (空指针)
if if
else else
elif else if
height = int(input())
vip_level = int(input())

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

注意

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')

循环语句

注意:Python中没有 ++--


while 循环语句

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

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)  # 可以访问在循环中定义的变量

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)
  • 当 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=' ')
  • range() 的第三个参数是控制遍历间隔的参数,通过这个参数可以使生产的数字不仅为有序连续数列,还可以生成规定间隔的连续数列。
# 输出1-100的所有奇数
for i in range(1, 101, 2):
    print(i, end=' ')

for else 循环语句

等同于while else

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

循环控制语句

  • 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!")

练习:打印乘法表

乘法表

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

函数

函数定义及调用

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

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

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

示例:

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=' ')

函数值传递和引用传递

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

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


参数类型

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

位置参数

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

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

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

默认参数

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

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

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

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


关键字参数

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

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

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


可变数量的参数

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

可变数量的位置参数

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

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

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

可变数量的关键字参数

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

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

print_info(name="Alice", age=25)  # 传递任意数量的关键字参数
# 输出:
# name : Alice
# age : 25

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)

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

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)

切片及索引

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

sequence[start:stop:step]


下标索引

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

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

切片提取子序列

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!

使用步长提取间隔子序列

sequence = "Hello, World!"

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

# 提取整个序列的逆序
slice6 = sequence[::-1]
print(slice6)  # 输出: !dlroW ,olleH

切片对可变序列的影响

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

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

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

易错点

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

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

你可能感兴趣的:(Python从入土到入土,python,windows,开发语言)