python学习-基础学习2本章主要介绍 python 的基础学习，包括控制结构的条件语句、循环语句、循环控制、列表推导

python学习-基础学习2

本文介绍 python 的基础学习，包括控制结构的条件语句、循环语句、循环控制、列表推导式，数据结构的列表（List）、元组 Tuple、字典 Dictionary、集合 Set。

供自己以后查漏补缺，也欢迎同道朋友交流学习。

引言

本章主要介绍 python 的基础学习，包括控制结构的条件语句、循环语句、循环控制、列表推导式，数据结构的列表（List）、元组 Tuple、字典 Dictionary、集合 Set。

控制结构

条件语句 if, elif, else

if 语句：if 语句用于测试一个条件，如果条件为真（True），则执行if块内的代码。

基本语法：

if 条件:
  # 条件为真时执行的代码

示例：

x = 10
if x > 5:
  print("x比5大")  # 当x大于5时，此行代码会执行

else 语句：else 语句用于在所有 if 和 elif 条件都为假时执行。

基本语法：

if 条件1:
  # 条件1为真时执行的代码
else:
  # 条件1为假时执行的代码

示例：

y = 10
if y > 15:
  print("y大于15")
else:
  print("y小于等于15")

elif 语句：elif（else if的缩写）语句用于在已有的 if 或另一个 elif 语句之后，测试另一个条件。

基本语法：

if 条件1:
  # 条件1为真时执行的代码
elif 条件2:
  # 条件1为假且条件2为真时执行的代码

示例：

score = 75
if score > 90:
  grade = 'A'
elif score > 80:
  grade = 'B'
elif score > 70:
  grade = 'C'
else:
  grade = 'F'
print(grade)  # 输出: C

循环语句 for while

循环语句用于重复执行一段代码，直到满足特定的条件。主要有两种类型的循环语句：for 循环和 while 循环。

for 循环：for 循环用于遍历序列（如列表、元组、字符串）或其他可迭代对象。

基本语法：

for 变量 in 可迭代对象:
  # 循环体代码块

示例：

# 遍历列表
names = ['孙悟空', '猪八戒', '沙和尚']
for name in names:
  print(name)

# 遍历字符串
for char in "Hello":
  print(char)

# 遍历字典（键）
for key in {'a': 1, 'b': 2}:
  print(key)

# 使用循环变量
for i in range(5):  # range生成从0到4的整数
  print(i)

while 循环: while 循环根据给定的条件重复执行代码块，直到条件不再为真。

基本语法：

while 条件:
  # 循环体代码块

示例：

count = 10
while count < 15:
  print(count)
  count += 1  # 更新计数器

循环控制 break continue

循环控制语句允许你改变循环的执行流程。

break 语句: 当 break 被执行时，循环会停止，控制流转移到循环体之外的下一条语句。

for i in range(1, 10):
  if i == 4:
    break  # 当 i 等于 4 时，退出循环
  print(i)
# 输出：
# 1
# 2
# 3

continue 语句: continue 语句用于跳过当前迭代的剩余代码，并立即开始下一次迭代。

for count in range(1, 5):
  if count == 3:
    continue  # 当 count 等于 2 时，跳过当前迭代
  print(count)
# 输出：
# 1
# 2
# 4

列表推导式（List Comprehensions）

列表推导式（List Comprehensions）是 Python 中一种优雅且高效的方法，用于从现有的列表或任何可迭代对象中创建新列表。

它通过一个简洁的语法结构，允许你定义一个列表的元素，而不需要编写传统的循环语句。

基本语法：

[表达式 for 变量 in 可迭代对象 if 条件]

表达式：对每个元素进行的操作或计算。
变量：在可迭代对象中迭代的元素的临时变量。
可迭代对象：一个列表、元组、字符串或任何其他可迭代对象。
条件：（可选）一个布尔表达式，只有满足条件的元素才会被包含在新列表中。

基本列表推导式：

# 创建一个新列表，包含原始列表中每个元素的平方
numbers = [1, 2, 3, 4, 5]
squared_numbers = [x ** 2 for x in numbers]
print(squared_numbers)  
# 输出: [1, 4, 9, 16, 25]

带有条件的列表推导式：

# 创建一个新列表，只包含原始列表中的偶数的平方
numbers = [1, 2, 3, 4, 5]
squared_numbers = [x ** 2 for x in numbers if x % 2 == 0]
print(squared_numbers)  
# 输出: [4, 16]

多变量列表推导式：

# 创建一个新列表，包含对应元素的和
list1 = [1, 2, 3]
list2 = [4, 5, 6]
sum_list = [x + y for x, y in zip(list1, list2)]
print(sum_list)
# 输出: [5, 7, 9]

嵌套列表推导式：

# 创建一个二维列表，其中每个子列表包含原始列表中每个元素的平方和立方
original_list = [1, 2, 3]
nested_list = [[x**2, x**3] for x in original_list]
print(nested_list)  # 输出: [[1, 1], [4, 8], [9, 27]]

数据结构

列表 List

列表（List）是一种非常灵活的数据结构，它允许存储一系列的元素，这些元素可以是不同的数据类型。下面是关于列表的一些基本操作：

# 创建列表非常简单，只需要将一系列值用逗号分隔，并用方括号括起来即可。
my_list = ['a', 'b', 'c', 'd', 'e']

# 访问列表元素
print('@@@@ 访问第一个元素', my_list[0]) 
# 输出：@@@@ 访问第一个元素 a
print('@@@@ 访问最后一个元素', my_list[-1]) 
# 输出：@@@@ 访问最后一个元素 e

# 修改列表元素
my_list[0] = 'a0'
print('@@@@ 修改后的第一个元素', my_list[0]) 
# 输出： @@@@ 修改后的第一个元素 a0

# 切片是获取列表的一部分元素的一种方式。
print('@@@@ 获取前三个元素', my_list[:3])
# 输出：@@@@ 获取前三个元素 ['a0', 'b', 'c']
print('@@@@ 获取从第二个元素到倒数第二个元素', my_list[1:-1])
# 输出：@@@@ 获取从第二个元素到倒数第二个元素 ['b', 'c', 'd']
print('@@@@ 获取所有元素，步长为2', my_list[::2])
# 输出：@@@@ 获取所有元素，步长为2 ['a0', 'c', 'e']

# 在列表末尾添加元素
my_list.append('f')
print('@@@@ 在列表末尾添加元素', my_list)
# 输出：@@@@ 在列表末尾添加元素 ['a0', 'b', 'c', 'd', 'e', 'f']

# 移除列表中第一个匹配的元素
my_list.remove('f')
print('@@@@ 移除列表中第一个匹配的元素', my_list)
# 输出：@@@@ 移除列表中第一个匹配的元素 ['a0', 'b', 'c', 'd', 'e']

# 对列表中的元素进行排序
my_list.sort()
print('@@@@ 对列表中的元素进行排序', my_list)
# 输出：@@@@ 对列表中的元素进行排序 ['a0', 'b', 'c', 'd', 'e']

# 将列表中的元素顺序颠倒
my_list.reverse()
print('@@@@ 将列表中的元素顺序颠倒', my_list)
# 输出：@@@@ 将列表中的元素顺序颠倒 ['e', 'd', 'c', 'b', 'a0']

# 返回列表中第一个匹配元素的索引
print('@@@@ 返回列表中第一个匹配元素的索引', my_list.index('c'))
# 输出：@@@@ 返回列表中第一个匹配元素的索引 2

# 统计某个元素在列表中出现的次数
print('@@@@ 统计某个元素在列表中出现的次数', my_list.count('f'))
# 输出：@@@@ 统计某个元素在列表中出现的次数 0

# 将一个列表中的所有元素添加到另一个列表的末尾
my_list.extend([4, 5, 6])
print('@@@@ 将一个列表中的所有元素添加到另一个列表的末尾', my_list)
# 输出：@@@@ 将一个列表中的所有元素添加到另一个列表的末尾 ['e', 'd', 'c', 'b', 'a0', 4, 5, 6]

# 在指定位置插入一个元素
my_list.insert(1, 'b2')
print('@@@@ 在指定位置插入一个元素', my_list)
# 输出：@@@@ 在指定位置插入一个元素 ['e', 'b2', 'd', 'c', 'b', 'a0', 4, 5, 6]

# 移除列表中的一个元素（默认是最后一个），并且返回该元素
element = my_list.pop()
print('@@@@ 移除列表的元素', element)
# 输出：@@@@ 移除列表的元素 6
print('@@@@ 移除列表的元素后，该列表数据为', my_list)
# 输出：@@@@ 移除列表的元素后，该列表数据为 ['e', 'b2', 'd', 'c', 'b', 'a0', 4, 5]

# 清空列表中的所有元素
my_list.clear()
print('@@@@ 移除列表的元素后，该列表数据为', my_list)
# 输出：@@@@ 移除列表的元素后，该列表数据为 []

元组 Tuple

元组（Tuple）是一种不可变的序列类型，一旦元组被创建，就不能修改它的内容。

元组可以用来存储不同的数据类型，它们通常用于保护数据不被改变，或者当你需要确保序列的元素顺序时。

# 创建元组非常简单，只需要将一系列值用逗号分隔，并用圆括号括起来即可。
# 如果元组只包含一个元素，那么这个元素后面必须跟一个逗号。
my_tuple = (1, 2, 3, 'a', 'b', 'c')

# 访问第一个元素
print('@@@@ 访问第一个元素', my_tuple[0]) 
# 输出：@@@@ 访问第一个元素 1
print('@@@@ 访问最后一个元素', my_tuple[-1]) 
# 输出：@@@@ 访问最后一个元素 c

# 切片
print('@@@@ 获取前三个元素', my_tuple[:3])
# 输出：@@@@ 获取前三个元素 (1, 2, 3)
print('@@@@ 获取从第二个元素到倒数第二个元素', my_tuple[1:-1])
# 输出：@@@@ 获取从第二个元素到倒数第二个元素 (2, 3, 'a', 'b')

# 统计某个元素在元组中出现的次数
print('@@@@ 统计某个元素在元组中出现的次数', my_tuple.count(2))
# 输出：@@@@ 统计某个元素在元组中出现的次数 1

# 返回列表中第一个匹配元素的索引
print('@@@@ 返回列表中第一个匹配元素的索引', my_tuple.index('a'))
# 输出：@@@@ 返回列表中第一个匹配元素的索引 3

字典 Dictionary

字典（Dictionary）是一种内置的数据结构，它存储键值对（key-value pairs）。

字典是可变的，可以在创建后修改它们。以下是字典的一些基本操作：

# 使用花括号创建字典
my_dict = {
  'name': 'NiuNai',
  'age': 33,
  'city': 'Shang Hai'
}

# 使用 dict() 函数创建字典
my_dict = dict(name='NiuNai', age=33, city='Shang Hai')

# 访问字典元素
print('@@@@ 通过键来访问字典中的值', my_dict['name'])
# 输出：@@@@ 通过键来访问字典中的值 NiuNai

# 修改字典元素
my_dict['age'] = 26
print('@@@@ 修改字典元素', my_dict)
# 输出：@@@@ 修改字典元素 {'name': 'NiuNai', 'age': 26, 'city': 'Shang Hai'}

# 返回字典所有键
print('@@@@ 返回字典所有键', my_dict.keys())
# 输出：@@@@ 返回字典所有键 dict_keys(['name', 'age', 'city'])

# 返回字典所有值
print('@@@@ 返回字典所有值', my_dict.values())
# 输出：@@@@ 返回字典所有值 dict_values(['NiuNai', 26, 'Shang Hai'])

# 返回字典所有键值对
print('@@@@ 返回字典所有键值对', my_dict.items())
# 输出：@@@@ 返回字典所有键值对 dict_items([('name', 'NiuNai'), ('age', 26), ('city', 'Shang Hai')])

# 返回指定键的值，如果键不存在于字典中，则返回默认值（None）。
print('@@@@ 返回指定键的值', my_dict.get('age'))
# 输出：@@@@ 返回指定键的值 26

# 更新字典，添加新的键值对或更新现有的键值对。
my_dict.update({'age': 27, 'gender': 'male'})
print('@@@@ 更新字典', my_dict)
# 输出：@@@@ 更新字典 {'name': 'NiuNai', 'age': 27, 'city': 'Shang Hai', 'gender': 'male'}

# 返回字典的一个浅拷贝
new_dict = my_dict.copy()
new_dict.update({
  'job': 'software engineer'
})
print('@@@@ my_dict', my_dict)
# 输出：@@@@ my_dict {'name': 'NiuNai', 'age': 27, 'city': 'Shang Hai', 'gender': 'male'}
print('@@@@ new_dict', new_dict)
# 输出：@@@@ new_dict {'name': 'NiuNai', 'age': 27, 'city': 'Shang Hai', 'gender': 'male', 'job': 'software engineer'}

# 检查键是否存在于字典中，返回布尔值
print("@@@@ 检查键是否存在于字典中，返回布尔值", 'name' in my_dict)
# 输出：@@@@ 检查键是否存在于字典中，返回布尔值 True

# 删除字典中的一个键值对
del my_dict['name']
print("@@@@ 删除字典中的一个键值对", my_dict)
# 输出：@@@@ 删除字典中的一个键值对 {'age': 27, 'city': 'Shang Hai', 'gender': 'male'}

# 移除字典中的一个键值对，并返回该键对应的值
city = my_dict.pop('city')
print('@@@@ 移除city的值', my_dict)
# 输出：@@@@ 移除city的值 {'age': 27, 'gender': 'male'}
print('@@@@ 移除city后的字典', my_dict)
# 输出：@@@@ 移除city后的字典 {'age': 27, 'gender': 'male'}

# 移除字典中的最后一个插入的键值对，并返回它
key, value = my_dict.popitem()
print('@@@@ key', key)
# 输出：@@@@ key gender
print('@@@@ value', value)
# 输出：@@@@ value male
print('@@@@ 移除最后一个键值对的字典', my_dict)
# 输出：@@@@ 移除最后一个键值对的字典 {'age': 27}

# 清空字典中的所有元素
my_dict.clear()
print('@@@@ 清空字典中的所有元素', my_dict)
# 输出：@@@@ 清空字典中的所有元素 {}

集合 Set

集合（Set）是一种无序的、不包含重复元素的数据结构。

集合可以用来存储一组不需要重复的元素，并且提供了数学上的集合操作，如并集、交集、差集等。

# 使用花括号创建集合
my_set = {1, 2, 3, 4}

# 使用 set() 函数创建集合
my_set = set([1, 2, 3, 4])

# in 检查元素是否存在于集合中，返回布尔值
print("@@@@ 检查元素是否存在于集合中，返回布尔值", 1 in my_set)
# 输出：@@@@ 检查元素是否存在于集合中，返回布尔值 True

# len 获取集合中元素的数量
print("@@@@ 获取集合中元素的数量", len(my_set))
# 输出：@@@@ 获取集合中元素的数量 4

# 访问集合元素
# 由于集合是无序的，不能通过索引来访问集合中的元素。
# 但是，可以遍历集合来访问每个元素。
for element in my_set:
  print(element, end = '\n' if element == 4 else ' ')
# 输出：1 2 3 4

# add 向集合中添加一个元素
my_set.add(5)
print('@@@@ 向集合中添加一个元素', my_set)
# 输出： @@@@ 向集合中添加一个元素 {1, 2, 3, 4, 5}

# remove 移除集合中的一个元素，如果元素不存在，则会抛出 KeyError
my_set.remove(2)
print('@@@@ remove移除', my_set)
# 输出： @@@@ remove移除 {1, 3, 4, 5}

# discard 移除集合中的一个元素，如果元素不存在，不会抛出错误
my_set.discard(5)
print('@@@@ discard移除', my_set)
# 输出： @@@@ discard移除 {1, 3, 4}

# pop 随机移除并返回集合中的一个元素
element = my_set.pop()
print('@@@@ element', element)
# 输出： @@@@ element 1
print('@@@@ my_set', my_set)
# 输出： @@@@ my_set {3, 4}

set1 = {1, 2, 3}
set2 = {3, 4, 5}

# union 返回两个集合的并集
union_set = set1.union(set2)  
# 或者 set1 | set2
print('@@@@ 返回两个集合的并集', union_set)
# 输出： @@@@ 返回两个集合的并集 {1, 2, 3, 4, 5}

# intersection 返回两个集合的交集
intersection_set = set1.intersection(set2)  
# 或者 set1 & set2
print('@@@@ 返回两个集合的交集', intersection_set)
# 输出： @@@@ 返回两个集合的交集 {3}

# 返回两个集合的差集（即存在于第一个集合中但不在第二个集合中的元素）
difference_set = set1.difference(set2)  
# 或者 set1 - set2
print('@@@@ 返回两个集合的差集', difference_set)
# 输出： @@@@ 返回两个集合的差集 {1, 2}

# issubset 判断一个集合是否是另一个集合的子集
print('@@@@ 判断一个集合是否是另一个集合的子集', set1.issubset(set2))
# 输出：@@@@ 判断一个集合是否是另一个集合的子集 False

# issuperset 判断一个集合是否是另一个集合的超集
print('@@@@ 判断一个集合是否是另一个集合的超集', set1.issuperset(set2))
# 输出：@@@@ 判断一个集合是否是另一个集合的超集 False

# copy 返回集合的一个浅拷贝
new_set = my_set.copy()
new_set.add(7)
print('@@@@ my_set', my_set)
# 输出：@@@@ my_set {3, 4}
print('@@@@ new_set', new_set)
# 输出：@@@@ new_set {3, 4, 7}

# clear 清空集合中的所有元素。
my_set.clear()
print('@@@@ 清空集合中的所有元素', my_set)
# 输出：@@@@ 清空集合中的所有元素 set()

python学习专栏系列

练习代码库地址

python-study