Day2基础语法 2024-02-20 阅读次数：

一、变量

在 Python 中，变量用于存储数据值。变量的命名需要遵循一定的规则：

• 变量名可以包含字母、数字和下划线，但必须以字母或下划线开头。
• 变量名不能是 Python 中的关键字（如 if、for、while 等）。

变量不需要事先声明类型，在赋值时会自动确定其类型。例如：

x = 5  # x 是整数类型
y = 3.14  # y 是浮点数类型
name = "Alice"  # name 是字符串类型
is_valid = True  # is_valid 是布尔类型

您可以随时修改变量的值，并且变量的类型会根据新赋的值自动改变。

二、数据类型

Python 中有以下常见的数据类型：

• 整数（int）：例如 -5、0、100 等，没有小数部分。
• 浮点数（float）：带有小数部分的数值，如 3.14、-2.5 等。
• 字符串（str）：用单引号 ‘ 或双引号 “ “ 括起来的字符序列，例如 “Hello” 、’World’ 。
• 布尔值（bool）：只有两个值，True（真）和 False（假），常用于条件判断。
• 列表（list）：用方括号 [ ] 定义，元素之间用逗号分隔，例如 [1, 2, 3] ，元素可以是不同类型，并且列表的长度可变。
• 元组（tuple）：用小括号 ( ) 定义，元素之间用逗号分隔，例如 (1, 2, 3) ，元组的元素不可修改，长度固定。
• 字典（dict）：由键值对组成，用花括号 { } 定义，键和值之间用冒号 : 分隔，元素之间用逗号分隔，例如 {‘name’: ‘Alice’, ‘age’: 20} 。
• 集合（set）：用花括号 { } 定义，元素无序且不重复，例如 {1, 2, 3} 。

2.1 整数

在 Python 中，整数（int）是一种基本的数据类型，用于表示没有小数部分的数值。

整数可以是正整数、负整数或零，例如：5、-10、0 等。

Python 中的整数具有以下特点：

• 整数的取值范围在理论上是无限的，只受限于计算机的内存。
• 可以进行常见的算术运算，如加法（+）、减法（-）、乘法（*）、除法（/，结果为浮点数）、取模（%）和整除（//）等。

以下是一些关于整数操作的示例代码：

# 整数的加法
a = 5
b = 10
result = a + b
print(result)  # 输出 15

# 整数的乘法
c = 3
d = 4
product = c * d
print(product)  # 输出 12

# 整数的除法（结果为浮点数）
e = 10
f = 3
division = e / f
print(division)  # 输出 3.3333333333333335

# 整数的整除
g = 10
h = 3
integer_division = g // h
print(integer_division)  # 输出 3

# 整数的取模
i = 10
j = 3
modulus = i % j
print(modulus)  # 输出 1

2.2 浮点数

在 Python 中，浮点数（float）用于表示带有小数部分的数值。

浮点数可以用十进制表示，例如 3.14、-0.5、123.456 等。

需要注意的是，由于计算机内部表示浮点数的方式存在一定的精度限制，可能会导致一些微妙的问题。例如，在进行浮点数运算时，可能会出现舍入误差。

以下是一些关于浮点数的操作示例：

# 浮点数的加法
a = 1.5
b = 2.7
result = a + b
print(result)  # 输出 4.2

# 浮点数的乘法
c = 2.5
d = 3.0
product = c * d
print(product)  # 输出 7.5

# 比较两个浮点数是否接近（由于精度问题，不能直接用 == 比较）
import math
def is_close(a, b, tolerance=1e-9):
    return math.isclose(a, b, rel_tol=tolerance)

x = 1.23456789
y = 1.23456788
print(is_close(x, y))  # 输出 True （如果差值在容忍范围内）

2.3 字符串

在 Python 中，字符串（str）是由字符组成的不可变序列。

字符串可以使用单引号 ‘ 、双引号 “ 或三引号 ‘’’（三个单引号）”””（三个双引号）来定义。

以下是一些创建字符串的示例：

s1 = 'Hello'
s2 = "World"
s3 = '''This is a 
multiline string'''
s4 = """Another multiline
string"""

字符串的操作非常丰富，例如：

• 字符串连接：使用 + 运算符。
• 字符串重复：使用 * 运算符。
• 字符串索引和切片：可以通过索引获取单个字符，通过切片获取子字符串。
• 字符串查找和替换：find()、replace() 等方法。
• 字符串大小写转换：lower()、upper() 等方法。

以下是一些示例代码：

s = "Hello, World!"

# 连接字符串
new_s = s + " How are you?"
print(new_s)  

# 重复字符串
repeated_s = s * 3
print(repeated_s)  

# 索引
print(s[0])  

# 切片
print(s[7:12])  

# 查找
print(s.find("World"))  

# 替换
new_s = s.replace("World", "Python")
print(new_s)  

# 转换为小写
lower_s = s.lower()
print(lower_s)  

# 转换为大写
upper_s = s.upper()
print(upper_s)  

2.4 布尔值

在 Python 中，布尔值（bool）只有两个值：True（真）和 False（假）。

在 Python 中，许多对象在特定的上下文中会被解释为布尔值。例如，数值 0、空字符串 ‘’ 、空列表 [] 、空字典 {} 等在条件判断中会被视为 False ，而其他非零数值、非空字符串、非空列表和字典等会被视为 True 。

布尔值常用于条件判断和逻辑运算。以下是一些关于布尔值的示例：

# 直接赋值
is_valid = True
is_not_valid = False

# 比较运算的结果为布尔值
num1 = 5
num2 = 10
print(num1 < num2)  # 输出 True
print(num1 == num2)  # 输出 False

# 逻辑运算
and_result = True and False  # 输出 False
or_result = True or False  # 输出 True
not_result = not True  # 输出 False

2.5 列表（list）

在 Python 中，list（列表）是一种有序且可变的数据结构，可以存储不同类型的元素。

列表使用方括号 [] 来创建，元素之间用逗号 , 分隔。

以下是一些创建和操作列表的示例：

# 创建列表
my_list = [1, 2, 3, "four", 5.5]

# 访问列表元素
print(my_list[0])  # 输出 1
print(my_list[3])  # 输出 "four"

# 列表切片
print(my_list[1:3])  # 输出 [2, 3]

# 修改列表元素
my_list[2] = 10
print(my_list)  # 输出 [1, 2, 10, "four", 5.5]

# 添加元素到列表末尾
my_list.append(6)
print(my_list)  # 输出 [1, 2, 10, "four", 5.5, 6]

# 在指定位置插入元素
my_list.insert(1, 7)
print(my_list)  # 输出 [1, 7, 2, 10, "four", 5.5, 6]

# 删除指定元素
my_list.remove("four")
print(my_list)  # 输出 [1, 7, 2, 10, 5.5, 6]

# 删除指定位置的元素
del my_list[0]
print(my_list)  # 输出 [7, 2, 10, 5.5, 6]

# 列表排序
another_list = [5, 2, 8, 1, 3]
another_list.sort()
print(another_list)  # 输出 [1, 2, 3, 5, 8]

# 列表反转
another_list.reverse()
print(another_list)  # 输出 [8, 5, 3, 2, 1]

2.6 元组（tuple）

在 Python 中，tuple（元组）是一种有序且不可变的数据结构。

元组通常用于存储一组不可更改的数据，或者在需要保证数据不被意外修改的情况下使用。

元组使用小括号 () 来创建，元素之间用逗号 , 分隔。

以下是一些关于元组的示例：

# 创建元组
my_tuple = (1, 2, 3, "four", 5.5)

# 访问元组元素
print(my_tuple[0])  # 输出 1
print(my_tuple[3])  # 输出 "four"

# 元组切片
print(my_tuple[1:3])  # 输出 (2, 3)

# 但不能修改元组元素（因为元组不可变）
# my_tuple[2] = 10  # 会报错

# 可以对元组进行拼接
new_tuple = my_tuple + (6, 7)
print(new_tuple)  # 输出 (1, 2, 3, 'four', 5.5, 6, 7)

2.7 字典（dict）

在 Python 中，dict（字典）是一种无序的键值对数据结构。

字典使用花括号 {} 来创建，键和值之间用冒号 : 分隔，键值对之间用逗号 , 分隔。

以下是一些关于字典的示例：

# 创建字典
my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}

# 访问字典中的值
print(my_dict['name'])  # 输出 'Alice'

# 添加新的键值对
my_dict['job'] = 'Engineer'

# 修改字典中的值
my_dict['age'] = 26

# 删除键值对
del my_dict['city']

# 检查键是否存在
if 'name' in my_dict:
    print('Key "name" exists')

# 获取字典的所有键
keys = my_dict.keys()
print(keys)  # 输出 dict_keys(['name', 'age', 'job'])

# 获取字典的所有值
values = my_dict.values()
print(values)  # 输出 dict_values(['Alice', 26, 'Engineer'])

# 获取字典的所有键值对
items = my_dict.items()
print(items)  # 输出 dict_items([('name', 'Alice'), ('age', 26), ('job', 'Engineer')])

# 遍历字典
for key, value in my_dict.items():
    print(f'Key: {key}, Value: {value}')

2.8 集合（set）

在 Python 中，set（集合）是一种无序且不包含重复元素的数据结构。

集合常用于需要快速判断元素是否存在、去除重复元素以及进行集合运算的场景。

集合使用花括号 {} 来创建，或者可以使用 set() 函数将其他可迭代对象转换为集合。

以下是一些关于集合的示例：

# 创建集合
my_set = {1, 2, 3, 4, 5}

# 从列表创建集合，去除重复元素
my_list = [1, 2, 2, 3, 3, 3]
my_set_from_list = set(my_list)
print(my_set_from_list)  # 输出 {1, 2, 3}

# 集合的基本操作
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# 并集（包含两个集合中的所有元素）
union_set = set1.union(set2)
print(union_set)  # 输出 {1, 2, 3, 4, 5, 6, 7, 8}

# 交集（两个集合中共同的元素）
intersection_set = set1.intersection(set2)
print(intersection_set)  # 输出 {4, 5}

# 差集（在第一个集合中但不在第二个集合中的元素）
difference_set = set1.difference(set2)
print(difference_set)  # 输出 {1, 2, 3}

# 对称差集（只在其中一个集合中出现的元素）
symmetric_difference_set = set1.symmetric_difference(set2)
print(symmetric_difference_set)  # 输出 {1, 2, 3, 6, 7, 8}

# 添加元素
my_set.add(6)

# 删除元素
my_set.remove(3)  # 如果元素不存在会抛出错误
my_set.discard(7)  # 如果元素不存在不会抛出错误

# 检查元素是否在集合中
if 2 in my_set:
    print("2 is in the set")