【第二节】python编程基础语法

攻城狮7号

已于 2024-07-30 19:58:21 修改

阅读量612

点赞数 12

分类专栏： python零基础入门到实战文章标签： python 开发语言

于 2024-07-30 19:57:07 首次发布

本文链接：https://blog.csdn.net/linshantang/article/details/140802908

版权

python零基础入门到实战专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、运算符介绍

1.1 算术运算符

1.2 比较运算符

1.3 赋值运算符

1.4 位运算符

下表中变量 a 为 60，b 为 13，二进制格式如下：

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

1.5 逻辑运算符

1.6 成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

1.7 身份运算符

身份运算符用于比较两个对象的存储单元

二、python运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：

三、三大流程结构

在Python编程中，三大流程结构是控制程序执行流程的基本方式。它们分别是：

1. **顺序结构**：
- 顺序结构是程序中最基本的执行流程，按照代码书写的顺序依次执行。
- 例如：

     x = 10
     y = 20
     z = x + y
     print(z)  # 输出 30

2. **选择结构（条件结构）**：
   - 选择结构用于根据条件判断来决定执行哪一段代码。
   - 主要通过 `if`、`elif` 和 `else` 语句实现。
   - 例如：

     age = 18
     if age >= 18:
         print("成年人")
     else:
         print("未成年人")

if语句运行过程如下动图：

3. **循环结构**：
   - 循环结构用于重复执行某段代码，直到满足某个条件为止。
   - 主要通过 `while` 和 `for` 语句实现。
   - 例如：

 # while 循环
     count = 0
     while count < 5:
         print(count)
         count += 1

     # for 循环
     for i in range(5):
         print(i)

while循环过程图示：

4. 循环控制语句

循环控制语句可以更改语句执行的顺序。Python支持以下循环控制语句：

在Python中，循环控制语句用于控制循环的执行流程。主要有以下几种：

1）. **`break` 语句**：
   - `break` 语句用于立即终止当前循环，跳出循环体。
   - 常用于在满足某个条件时提前结束循环。
   - 例如：

     for i in range(10):
         if i == 5:
             break
         print(i)  # 输出 0 到 4

2）. **`continue` 语句**：
   - `continue` 语句用于跳过当前循环的剩余语句，并继续下一次循环。
   - 常用于在满足某个条件时跳过当前迭代。
   - 例如：

     for i in range(10):
         if i % 2 == 0:
             continue
         print(i)  # 输出 1, 3, 5, 7, 9

3）. **`pass` 语句**：
   - `pass` 语句是一个空操作语句，用于在语法上需要语句但实际不需要执行任何代码的地方。
   - 常用于占位，表示稍后会添加代码。
   - 例如：

     for i in range(10):
         if i % 2 == 0:
             pass
         else:
             print(i)  # 输出 1, 3, 5, 7, 9

4）. **`else` 子句**：
   - `else` 子句可以与 `for` 和 `while` 循环一起使用，当循环正常结束（即没有遇到 `break` 语句）时执行。
   - 常用于在循环结束后执行某些操作。
   - 例如：

     for i in range(5):
         print(i)
     else:
         print("循环正常结束")  # 输出 0, 1, 2, 3, 4 和 "循环正常结束"

四、列表

在Python中，列表（List）是一种非常灵活且强大的数据结构，用于存储一组有序的元素。列表可以包含不同类型的数据，如整数、字符串、浮点数，甚至是其他列表。以下是一些关于列表的基本操作和特性：

### 创建列表
你可以使用方括号 `[]` 来创建一个列表，并用逗号分隔其中的元素：

my_list = [1, 2, 3, 4, 5]
print(my_list)  # 输出: [1, 2, 3, 4, 5]

### 访问元素
你可以通过索引来访问列表中的元素，索引从0开始：

print(my_list[0])  # 输出: 1
print(my_list[3])  # 输出: 4

### 修改元素
你可以通过索引来修改列表中的元素：

my_list[1] = 10
print(my_list)  # 输出: [1, 10, 3, 4, 5]

### 列表切片
你可以使用切片操作来获取列表的子集：

print(my_list[1:4])  # 输出: [10, 3, 4]
print(my_list[:3])   # 输出: [1, 10, 3]
print(my_list[2:])   # 输出: [3, 4, 5]

### 列表方法
Python提供了许多内置方法来操作列表：

- `append(item)`：在列表末尾添加一个元素。

  my_list.append(6)
  print(my_list)  # 输出: [1, 10, 3, 4, 5, 6]

- `insert(index, item)`：在指定位置插入一个元素。

  my_list.insert(2, 20)
  print(my_list)  # 输出: [1, 10, 20, 3, 4, 5, 6]

- `remove(item)`：移除列表中第一个匹配的元素。

  my_list.remove(10)
  print(my_list)  # 输出: [1, 20, 3, 4, 5, 6]

- `pop(index)`：移除并返回指定位置的元素，如果不指定索引，则移除并返回最后一个元素。

  popped_item = my_list.pop(2)
  print(popped_item)  # 输出: 3
  print(my_list)      # 输出: [1, 20, 4, 5, 6]

- `index(item)`：返回第一个匹配元素的索引。

  index = my_list.index(4)
  print(index)  # 输出: 2

- `count(item)`：返回元素在列表中出现的次数。

  count = my_list.count(5)
  print(count)  # 输出: 1

- `sort()`：对列表进行排序。

  my_list.sort()
  print(my_list)  # 输出: [1, 4, 5, 6, 20]

- `reverse()`：反转列表中的元素。

  my_list.reverse()
  print(my_list)  # 输出: [20, 6, 5, 4, 1]

### 列表推导式
列表推导式是一种简洁的创建列表的方式：

squares = [x**2 for x in range(5)]
print(squares)  # 输出: [0, 1, 4, 9, 16]

五、元组

在Python中，元组（Tuple）是一种有序且不可变的数据类型，用于存储一组元素。元组与列表类似，但元组一旦创建，其内容就不能被修改。以下是一些关于元组的基本操作和特性：

### 创建元组
你可以使用圆括号 `()` 来创建一个元组，并用逗号分隔其中的元素：

my_tuple = (1, 2, 3, 4, 5)
print(my_tuple)  # 输出: (1, 2, 3, 4, 5)

### 访问元素
你可以通过索引来访问元组中的元素，索引从0开始：

print(my_tuple[0])  # 输出: 1
print(my_tuple[3])  # 输出: 4

### 元组切片
你可以使用切片操作来获取元组的子集：

print(my_tuple[1:4])  # 输出: (2, 3, 4)
print(my_tuple[:3])   # 输出: (1, 2, 3)
print(my_tuple[2:])   # 输出: (3, 4, 5)

### 元组的不可变性
元组一旦创建，其内容就不能被修改。这意味着你不能添加、删除或修改元组中的元素：

# 尝试修改元组中的元素会引发 TypeError
# my_tuple[1] = 10  # 这行代码会引发 TypeError

### 元组方法
虽然元组是不可变的，但Python提供了一些内置方法来操作元组：

- `count(item)`：返回元素在元组中出现的次数。

  count = my_tuple.count(3)
  print(count)  # 输出: 1

- `index(item)`：返回第一个匹配元素的索引。

  index = my_tuple.index(4)
  print(index)  # 输出: 3

### 元组的优点
- **不可变性**：元组的不可变性使得它们在某些情况下比列表更安全，特别是在需要确保数据不被意外修改的场景中。
- **性能**：由于元组是不可变的，它们的访问速度通常比列表更快，占用的内存也更少。

### 元组的使用场景
- 当你需要一个不可变的数据集合时，可以使用元组。
- 元组常用于函数返回多个值的场景。
### 示例

def get_user_info():
    name = "Alice"
    age = 30
    city = "New York"
    return name, age, city  # 返回一个元组

user_info = get_user_info()
print(user_info)  # 输出: ('Alice', 30, 'New York')

六、字典

在Python中，字典（Dictionary）是一种无序、可变且可嵌套的数据类型，用于存储键值对（key-value pairs）。字典中的每个键（key）必须是唯一的，而值（value）可以是任意类型的数据。以下是一些关于字典的基本操作和特性：

### 创建字典
你可以使用花括号 `{}` 来创建一个字典，并用冒号 `:` 分隔键和值，用逗号分隔键值对：

my_dict = {"name": "Alice", "age": 30, "city": "New York"}
print(my_dict)  # 输出: {'name': 'Alice', 'age': 30, 'city': 'New York'}

### 访问元素
你可以通过键来访问字典中的值：

print(my_dict["name"])  # 输出: Alice
print(my_dict["age"])   # 输出: 30

### 修改元素
你可以通过键来修改字典中的值：

my_dict["age"] = 31
print(my_dict)  # 输出: {'name': 'Alice', 'age': 31, 'city': 'New York'}

### 添加元素
你可以通过新的键来添加新的键值对：

my_dict["country"] = "USA"
print(my_dict)  # 输出: {'name': 'Alice', 'age': 31, 'city': 'New York', 'country': 'USA'}

### 删除元素
你可以使用 `del` 语句或 `pop` 方法来删除字典中的键值对：

del my_dict["city"]
print(my_dict)  # 输出: {'name': 'Alice', 'age': 31, 'country': 'USA'}

popped_value = my_dict.pop("age")
print(popped_value)  # 输出: 31
print(my_dict)       # 输出: {'name': 'Alice', 'country': 'USA'}

### 字典方法
Python提供了许多内置方法来操作字典：

- `keys()`：返回字典中所有键的视图对象。

  keys = my_dict.keys()
  print(keys)  # 输出: dict_keys(['name', 'country'])

- `values()`：返回字典中所有值的视图对象。

  values = my_dict.values()
  print(values)  # 输出: dict_values(['Alice', 'USA'])

- `items()`：返回字典中所有键值对的视图对象。

  items = my_dict.items()
  print(items)  # 输出: dict_items([('name', 'Alice'), ('country', 'USA')])

- `get(key, default)`：返回指定键的值，如果键不存在，则返回默认值。

  value = my_dict.get("name", "Unknown")
  print(value)  # 输出: Alice

  value = my_dict.get("age", "Unknown")
  print(value)  # 输出: Unknown

- `update(other_dict)`：将另一个字典的键值对更新到当前字典中。

  other_dict = {"age": 31, "city": "New York"}
  my_dict.update(other_dict)
  print(my_dict)  # 输出: {'name': 'Alice', 'country': 'USA', 'age': 31, 'city': 'New York'}

### 字典推导式
字典推导式是一种简洁的创建字典的方式：

squares = {x: x**2 for x in range(5)}
print(squares)  # 输出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

字典的特性：

键的唯一性：字典中的键是唯一的，重复的键会覆盖之前的值。
访问不存在的键：访问不存在的键会引发 KeyError，可以使用 get 方法避免。
键的限制：字典的键必须是不可变的类型，如数字、字符串、元组，不能是列表或其他可变类型。

攻城狮7号

关注

12
点赞
踩
11

收藏

觉得还不错? 一键收藏
打赏
0
评论
【第二节】python编程基础语法

目录一、运算符介绍1.1 算术运算符1.2 比较运算符1.3 赋值运算符1.4 位运算符1.5 逻辑运算符1.6 成员运算符1.7 身份运算符二、python运算符优先级三、三大流程结构四、列表五、元组六、字典下表中变量 a 为 60，b 为 13，二进制格式如下：a = 0011 1100b = 0000 1101-----------------a&b = 0000 1100a|b = 0011 1101a^b = 0011 0001~a = 1100 0011
复制链接

扫一扫