语法特点

  • 简单性：Python 的语法设计简单，易于阅读和编写。
  • 缩进：Python 使用缩进来区分代码块，增强了代码的可读性。
  • 注释：以 # 开头的语句是注释，解释器会忽略这些内容。
  • 代码块：语句以冒号 : 结尾时，后续的缩进语句被视为代码块。
  • 大小写敏感：Python 是大小写敏感的语言，变量名的大小写会影响其含义。
  • 动态类型：Python 是动态类型语言，变量在声明时不需要指定类型。

实例代码 

# 打印变量实例
a = 100  # 变量 a 声明和赋值
if a >= 0:  # 下面是代码块
    print(a)  # 使用 print 函数打印变量值
else:
    print(-a)
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.

基本数据类型

Python 提供了多种基本数据类型，每种类型都有其特定的用途和特性。

1、整数（int）：表示没有小数点的数字。

a = 10
b = -20
print(a + b)
  • 1.
  • 2.
  • 3.

2、浮点数（float）：表示有小数点的数字。

a = 3.14
b = -0.001
print(a * b)
  • 1.
  • 2.
  • 3.

3、字符串（str）：表示文本数据。

name = "ziyu"
print("Hello, " + name)
  • 1.
  • 2.

4、布尔值（bool）：表示逻辑值，只有 True 或 False。

is_active = True
print(is_active)
  • 1.
  • 2.

5、列表（list）：有序的集合，可以包含不同类型的元素。取值下标从0开始。

fruits = ["apple", "banana", 123]
print(fruits[2])  # 输出 123
  • 1.
  • 2.

6、元组（tuple）：类似于列表，通过 () 定义，但定义后不可变。

point = (10, 20)
point = (10,)  # 只有1个元素的tuple定义时必须加一个逗号
print(point[0])
  • 1.
  • 2.
  • 3.

7、字典（dict）：无序的键值对集合。

person = {"name": "ziyu", "age": 25}
print(person["name"])
  • 1.
  • 2.

8、集合（set）：无序的不重复元素集合。

numbers = {1, 2, 3}
print(numbers)
  • 1.
  • 2.

9、空值（None）：Python 中的特殊值，用 None 表示

d = {}

d.get('name')  # 返回 None，控制台不输出任何东西
  • 1.
  • 2.
  • 3.

10、常量：通常用全部大写的变量名表示常量。

PI = 3.14159265359

PI = 4.13  # 不推荐这样做
  • 1.
  • 2.
  • 3.
  1. bytes对象（二进制对象）
  • 直接使用字节值的序列创建：
byte_array = bytes([72, 101, 108, 108, 111])  # 表示 "Hello" 的 ASCII 码
print(byte_array)  # 输出: b'Hello'
  • 1.
  • 2.
  • 使用字符串创建，字符串中的每个字符都会被转换为相应的字节：
byte_str = b"Hello, World!"  # 直接前缀 b 表示字节字符串
print(byte_str)  # 输出: b'Hello, World!'
  • 1.
  • 2.

变量

变量是存储数据值的容器。在 Python 中，变量在使用前不需要声明数据类型。

命名规则

  • 变量名必须以字母或下划线开头。
  • 变量名只能包含字母、数字和下划线。
  • 变量名是区分大小写的。

赋值

使用 = 操作符将值赋给变量。

x = 5
message = "Hello, World!"
  • 1.
  • 2.

动态类型

Python 是一种动态类型语言，变量的类型在运行时自动确定。

x = 10         # x 是 int 类型
x = "hello"    # x 现在是 str 类型
  • 1.
  • 2.

作用域

变量的作用域决定了变量在程序中的可见性和生命周期。

  • 局部变量：在函数内部定义，只能在该函数内部访问。
  • 全局变量：在函数外部定义，可以在程序的任何地方访问。

示例代码

# 定义变量
name = "ziyu"
age = 25
height = 175.5

# 打印变量
print("Name:", name)
print("Age:", age)
print("Height:", height)

# 定义列表
fruits = ["apple", "banana", "cherry"]

# 访问列表中的元素
print("Fruit at index 1:", fruits[1])

# 定义字典
person = {"name": "ziyu", "age": 25}

# 访问字典中的元素
print("Person's name:", person["name"])

# 定义集合
numbers = {1, 2, 3}

# 打印集合
print("Numbers:", numbers)
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.

运算符

Python 中的运算符用于执行数学和逻辑运算。

  • /：除法，计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数。
  • //：地板除，两个整数的除法结果仍然是整数。
  • %：取余数，结果永远是整数，整数运算结果永远是精确的。
10 / 3  # 3.3333333333333335
9 / 3   # 3.0

10 // 3 # 3

10 % 3  # 1
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.

list、set和dict 数据结构 区别

我们将对每个结构的增（增加）、删（删除）、查（查询）、改（修改）进行练习。

1. list（列表）

有序：元素的插入顺序会被保留。

可重复：元素可以重复。

可索引：可以通过索引访问元素。

可变：可以修改内容。

语法：使用方括号 [] 定义。

示例： 

my_list = [1, 2, 3, 4]
print(my_list[0])  # 获取： 输出 1

my_list.append(5)  # 添加元素，在列表尾部添加 5
print(my_list)     # 输出 [1, 2, 3, 4, 5]

my_list.pop(0)  # 删除索引下标元素，这里就是在0这个位置上删除1
print(my_list)     # 输出 [2, 3, 4, 5]

my_list.insert(0, 1)  # 添加索引下标元素，这里就是在0这个位置上增加1
print(my_list)     # 输出 [1, 2, 3, 4, 5]

my_list[0] = 6  # 修改：这里就是在0这个位置上修改成6
print(my_list)     # 输出 [6, 2, 3, 4, 5]
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
2. set（集合）
  • 无序：元素的插入顺序不会被保留。
  • 不重复：元素是唯一的。
  • 不可索引：不能通过索引访问元素。
  • 可变：可以修改内容。
  • 语法：使用花括号 {} 定义，或使用 set() 函数转换。

示例：

my_set = {1, 2, 3, 4}
my_set.add(5)  # 添加元素 5
print(my_set)  # 输出 {1, 2, 3, 4, 5}，但元素顺序可能不同

my_set.remove(3)  # 删除元素 3
print(my_set)  # 输出 {1, 2, 4, 5}

# 获取集合的长度
len(my_set)  # 4

# 清空集合
my_set.clear()

# 判断元素是否在集合中存在
'x' in my_set  # False
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
3. dict（字典）
  • 无序：元素的插入顺序不会被保留。
  • 键值对：由键值对组成，键是唯一的。
  • 可索引：可以通过键访问值。
  • 可变：可以修改内容。
  • 语法：使用花括号 {} 定义，键和值之间用冒号 : 分隔。

示例：

my_dict = {"name": "ziyu", "age": 25}
print(my_dict["name"])  # 输出 ziyu
my_dict["age"] = 26  # 修改键 "age" 对应的值
print(my_dict)  # 输出 {"name": "ziyu",
"age": 26}
my_dict["gender"] = "Male"  # 添加新的键值对
print(my_dict)  # 输出 {"name": "ziyu", "age": 26, "gender": "Male"}

my_dict.pop('name')  # 删除键 "name"
print(my_dict)
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.

总结

有序性：list 是有序的，set 和 dict 是无序的。

重复性：list 可以包含重复元素，set 不能包含重复元素，dict 的键不能重复，但值可以。

索引：list 和 dict 可以通过索引访问元素，set 不能。

元素组成：list 由元素组成，set 由元素组成，dict 由键值对组成。

这些特性使得这三种数据结构在不同的场景下有不同的应用。例如，当你需要保持元素顺序并可能需要索引时，可以使用 list；当你需要一个不包含重复元素的集合时，可以使用 set；当你需要通过键来快速访问数据时，可以使用 dict。