编程小白变身Python大神：从零开始学习Python基础语法的绝佳指南

╰+哭是因爲堅強的太久メ 2024-03-23 17:56 79阅读 0赞

#### 文章目录 ####

*  一 字面量
 *  二 注释
 *  三 变量
 *   *  3.1 练习
 *  四 数据类型
 *   *  4.1 验证数据的类型
     *  4.2 type()语句的使用方式
     *  4.3 变量有类型吗？
 *  五 数据类型转换
 *   *  5.1 常见的转换语句
 *  六 标识符
 *   *  6.1 标识符命名规则
     *  6.2 变量命名规范
     *  6.3 变量名的命名规范：
     *  6.4 类名的命名规范：
     *  6.5 方法名的命名规范：
 *  七 运算符
 *   *  7.1 算术运算符
     *  7.2 赋值运算符&复合赋值运算符
 *  八 字符串扩展
 *   *  8.1 字符串的三种定义方式
     *  8.2 字符串的引号嵌套
     *  8.3 字符串拼接
     *  8.4 字符串格式化
     *   *  8.4.1 \`f\`字符串（Formatted String）
         *  8.4.2 \`%\` 运算符（旧式字符串格式化）：
         *  8.4.3 \`.str.format()\` 方法：
     *  8.5 数字精度控制
     *   *  8.5.1 辅助符号"m.n"
         *  8.5.2 数字精度控制方式
     *  8.6 表达式格式化
 *  九 数据输入
 *   *  9.1 终端输入
     *  9.2 命令行参数
     *  9.3 文件输入
     *  9.4 网络请求

## 一 字面量 ##

*  在Python中，**字面量（Literal）指的是直接表示数据的值，而不是变量或表达式**。Python支持各种类型的字面量。  
    ![在这里插入图片描述][beb482f1b9ad4c0785ed7a783004ce2c.png]
 *  字符串字面量（String Literals）：用于表示文本数据。字符串字面量可以使用单引号或双引号包围，例如，“Hello”、‘World’等。此外，Python还支持多行字符串字面量，可以使用三重引号（“”"或’‘’）包围

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>程序中的写法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>整数</td> 
   <td>666，-89</td> 
   <td>和现实写法一致</td> 
  </tr> 
  <tr> 
   <td>浮点数（小数）</td> 
   <td>13.14，-5.21</td> 
   <td>和现实中的写法一致</td> 
  </tr> 
  <tr> 
   <td>字符串（文本）</td> 
   <td>“罗刹海市”</td> 
   <td>程序中需要加上双引号来表示字符串</td> 
  </tr> 
 </tbody> 
</table>

## 二 注释 ##

*  注释：在程序代码中对程序代码进行解释说明的文字。
 *  作用：注释不是程序，不能被执行，只是对程序代码进行解释说明，让别人可以看懂程序代码的作用，能够大大增强程序的可读性。  
    ![在这里插入图片描述][78d0c2e2f69e4c338c0ed78253e390b2.png_pic_center]
 *  单行注释：以 \#开头，\#右边 的所有文字当作说明，而不是真正要执行的程序，起辅助说明作用
    
     *  **\#号和注释内容一般建议以一个空格隔开**

# 单行注释
    print( "Hello world")

*  多行注释： 以 一对三个双引号 引起来 ( “”"注释)来解释说明一段代码的作用使用方法
    
        """
        多行注释
        诗名:悯农
        作者:李绅
        """
        print("锄禾日当午")
        print("汗滴禾下土")
        print("谁知盘中餐")
        print("粒粒皆辛苦")

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

*  拓展

1.  python单行注释中能否使用多行注释？
    
     *  Python的单行注释以\#符号开头，用于在代码中添加对某行或某段代码的注释。单行注释只能用于一行，并且不能在单行注释中直接使用多行注释。
2.  python多行注释中能否使用单行注释？
    
     *  Python的多行注释使用三个引号(“”"或’‘’)括起来，可以跨越多行，用于注释一段代码或多行的文本。在多行注释中，由于它们被视为字符串字面量，所以可以在其中包含单行注释。但要注意，单行注释只会被视为普通的字符串内容，不会被解释器忽略，因此不会起到注释的作用。
     *  以下是多行注释中包含单行注释的示例：
    
        """
        This is a
        multi-line comment.
        
        # This is a single-line comment inside the multi-line comment.
        
        It spans across multiple lines.
        """
    
     *  注意，`# This is a single-line comment inside the multi-line comment.`只是一个字符串，不是注释。
3.  python多行注释中能否使用多行注释？
    
     *  Python的多行注释不能直接包含其他多行注释。在Python中，连续的多行注释被视为单个多行字符串字面量，而不是相互嵌套的多个注释。因此，不能在一个多行注释中添加另一个多行注释。如果想要注释掉多行代码或多行文本，可以使用一个多行注释来实现。

## 三 变量 ##

*  变量：在程序运行时，能储存计算结果或能表示值的抽象概念。简单的说，变量就是在程序运行时，记录数据用的
 *  变量的特征：变量存储的数据，是可以发生改变的。
 *  变量的目的：存储运行过程的数据，存储的目的：是为了重复使用

![在这里插入图片描述][3755a873936b4981bd3debfc0c4cdae6.png]

### 3.1 练习 ###

请在程序中，定义如下变量：

*  钱包余额(变量名：money)，初始余额50  
    请通过程序计算，在购买了：
 *  冰淇淋10元
 *  可乐5元  
    后，钱包余额还剩余多少元。请通过print语句按照下图所示，进行输出：  
    ![在这里插入图片描述][7ef50ba987cb4fa4af15c2532dd7f8bd.png]

# 定义一个变量，用来记录钱包余额
    money = 50
    # 通过print语句，输出变量记录的内容
    print("当前钱包余额：", money)
    
    # 买了一个冰淇淋，花费10元
    money = money - 10
    print("购买冰淇淋，花费：10元")
    money-=5
    print("购买可乐，花费：5元")
    print("最终，钱包剩余：", money ,"元")

## 四 数据类型 ##

### 4.1 验证数据的类型 ###

可以通过type()语句来得到数据的类型：  
语法：

type(被查看类型的数据)

### 4.2 type()语句的使用方式 ###

# 方式1： 使用print直接输出类型信息
    print(type("黑马程序员"))
    print(type(666))
    print(type(11.345))
    
    # 方式2： 使用变量存储type()语句的结果
    string_type = type("黑马程序员")
    int_type = type(666)
    float_type = type(11.345)
    print(string_type)
    print(int_type)
    print(float_type)

*  查看的都是<字面量>的类型，能查看变量中存储的数据类型吗？答案是：**可以**

# 方式3： 使用type()语句，查看变量中存储的数据类型信息
    name = "黑马程序员"
    name_type = type(name)
    print(name_type)

### 4.3 变量有类型吗？ ###

*  通过type(变量)可以输出类型，这是查看变量的类型还是数据的类型？
    
     *  查看的是：变量存储的数据的类型。因为，**变量无类型，但是它存储的数据有。**

## 五 数据类型转换 ##

*  数据类型之间，在特定的场景下，是可以相互转换的，如字符串转数字、数字转字符串等

### 5.1 常见的转换语句 ###

<table> 
 <thead> 
  <tr> 
   <th>转换语句</th> 
   <th>说明</th> 
   <th>返回值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>int(x)</td> 
   <td>将x转换为整数类型。</td> 
   <td>转换后的整数</td> 
  </tr> 
  <tr> 
   <td>float(x)</td> 
   <td>将x转换为浮点数类型。</td> 
   <td>转换后的浮点数</td> 
  </tr> 
  <tr> 
   <td>str(x)</td> 
   <td>将x转换为字符串类型。</td> 
   <td>转换后的字符串</td> 
  </tr> 
  <tr> 
   <td>list(x)</td> 
   <td>将x转换为列表类型。</td> 
   <td>转换后的列表</td> 
  </tr> 
  <tr> 
   <td>tuple(x)</td> 
   <td>将x转换为元组类型。</td> 
   <td>转换后的元组</td> 
  </tr> 
  <tr> 
   <td>set(x)</td> 
   <td>将x转换为集合类型。</td> 
   <td>转换后的集合</td> 
  </tr> 
  <tr> 
   <td>dict(x)</td> 
   <td>将x转换为字典类型。</td> 
   <td>转换后的字典</td> 
  </tr> 
  <tr> 
   <td>bool(x)</td> 
   <td>将x转换为布尔类型。</td> 
   <td>转换后的布尔值</td> 
  </tr> 
  <tr> 
   <td>chr(x)</td> 
   <td>将Unicode编码x转换为相应的字符。</td> 
   <td>转换后的字符</td> 
  </tr> 
  <tr> 
   <td>ord(x)</td> 
   <td>将字符x转换为对应的Unicode编码。</td> 
   <td>转换后的Unicode编码</td> 
  </tr> 
  <tr> 
   <td>hex(x)</td> 
   <td>将整数x转换为十六进制字符串。</td> 
   <td>转换后的十六进制字符串</td> 
  </tr> 
  <tr> 
   <td>oct(x)</td> 
   <td>将整数x转换为八进制字符串。</td> 
   <td>转换后的八进制字符串</td> 
  </tr> 
  <tr> 
   <td>bin(x)</td> 
   <td>将整数x转换为二进制字符串。</td> 
   <td>转换后的二进制字符串</td> 
  </tr> 
  <tr> 
   <td>eval(x)</td> 
   <td>将字符串x作为表达式进行求值并返回结果。</td> 
   <td>求值结果</td> 
  </tr> 
  <tr> 
   <td>type(x)</td> 
   <td>返回参数x的数据类型。</td> 
   <td>类型对象</td> 
  </tr> 
  <tr> 
   <td>isinstance(x, t)</td> 
   <td>检查x是否属于类型t的实例。</td> 
   <td>布尔值</td> 
  </tr> 
  <tr> 
   <td>str(x).encode(encoding)</td> 
   <td>将字符串x按指定的编码方式进行编码。</td> 
   <td>编码后的字节对象</td> 
  </tr> 
  <tr> 
   <td>bytes(x, encoding)</td> 
   <td>将字符串x按指定的编码方式编码为字节对象。</td> 
   <td>编码后的字节对象</td> 
  </tr> 
  <tr> 
   <td>bytes(x)</td> 
   <td>将整数列表x转换为字节对象。</td> 
   <td>字节对象</td> 
  </tr> 
  <tr> 
   <td>bytearray(x)</td> 
   <td>将字节、整数列表或可迭代对象x转换为可变的字节数组。</td> 
   <td>可变的字节数组</td> 
  </tr> 
  <tr> 
   <td>ord©</td> 
   <td>返回字符c的ASCII或Unicode编码值。</td> 
   <td>ASCII或Unicode编码值</td> 
  </tr> 
  <tr> 
   <td>chr(i)</td> 
   <td>返回整数i对应的字符。</td> 
   <td>字符</td> 
  </tr> 
  <tr> 
   <td>format(x, format_spec)</td> 
   <td>格式化输出x，根据format_spec指定的格式进行转换。</td> 
   <td>格式化后的字符串</td> 
  </tr> 
 </tbody> 
</table>

*  其中，返回值的列指示了每个转换语句的返回结果类型。请注意，这些返回值仅是一般情况下的返回类型，具体返回值还可能受到输入参数的影响。

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

类型转换不是万能的，毕竟强扭的瓜不会甜，需要注意：

1.  任何类型，都可以通过`str()`，转换成字符串
    
        # 将数字类型转换成字符串
        num_str = str(11)
        print(type(num_str), num_str)
        
        float_str = str(11.345)
        print(type(float_str), float_str)
2.  字符串内必须真的是数字，才可以将字符串转换为数字
    
        # 将字符串转换成数字
        num = int("11")
        print(type(num), num)
        
        num2 = float("11.345")
        print(type(num2), num2)
        # 错误示例，想要将字符串转换成数字，必须要求字符串内的内容都是数字
        # num3 = int("黑马程序员")
        # print(type(num3), num3)

## 六 标识符 ##

*  标识符：用户在编程的时候所使用的一系列名字，用于给变量、类、方法等命名。

### 6.1 标识符命名规则 ###

*  Python中，标识符命名的规则主要有3类：

1.  内容限定
2.  大小写敏感
3.  不可使用关键字

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

**标识符命名规则 - 内容限定**

*  标识符命名中，只允许出现：
    
     *  英文
     *  中文
     *  数字
     *  下划线（\_）  
        其余任何内容都不被允许。

![在这里插入图片描述][5334b5a2cdcd4b5695893ab42bce5495.png]

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

**标识符命名规则 - 大小写敏感**  
以定义变量为例：  
Andy = “安迪1”  
andy = “安迪2”  
字母a的大写和小写，是完全能够区分的。

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

**标识符命名规则 - 不可使用关键字**

*  Python中有一系列单词，称之为关键字。关键字在Python中都有特定用途，不可以使用它们作为标识符。  
    ![在这里插入图片描述][04c9f9f1ff9c462788e0554f4e382fd7.png]

### 6.2 变量命名规范 ###

在Python中，有一些命名规范和约定适用于变量名、类名和方法名。以下是这些规范的概述：

### 6.3 变量名的命名规范： ###

1.  变量名应该使用小写字母，并且可以包含下划线（`_`）以分隔单词，以提高可读性。例如：`my_variable, count, total_amount`.
2.  避免使用单个字符或不具有描述性的名称，而要选择能够清晰表示变量用途的名称。例如，`x, a` 不是好的变量名。
3.  如果变量名需要包含多个单词，可以使用下划线分隔，例如`total_amount, is_valid`.
4.  在某些情况下，可以根据需要使用缩写，但它们应该是常见且易于理解的。例如，`num_items`代表数量，`avg_temp`代表平均温度。

### 6.4 类名的命名规范： ###

1.  类名应该使用驼峰命名法，即每个单词的首字母大写，并且没有下划线。例如：`MyClass, Car, Person`
2.  类名应该具有描述性，能够清楚地表示该类的作用。
3.  避免使用与`Python`内置类名冲突的命名，例如不要将类名命名为`list`或`dict`等。

### 6.5 方法名的命名规范： ###

1.  方法名应该使用小写字母，并且可以包含下划线以提高可读性。例如：`calculate_total, get_name`
2.  方法名应该描述方法的功能或操作，可以使用动词或动词短语。例如：`calculate_total, get_name, print_info`
3.  如果方法名包含多个单词，可以使用下划线分隔。例如：`calculate_average, get_user_info`

请注意，这些是一般的命名约定，可以提高代码的可读性和一致性。在实际的编程中，建议根据项目和团队的约定进行命名，以确保代码的一致性和可维护性。

## 七 运算符 ##

### 7.1 算术运算符 ###

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>+</td> 
   <td>加法</td> 
   <td>2 + 3 结果为 5</td> 
  </tr> 
  <tr> 
   <td>-</td> 
   <td>减法</td> 
   <td>5 - 2 结果为 3</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>乘法</td> 
   <td>4 * 3 结果为 12</td> 
  </tr> 
  <tr> 
   <td>/</td> 
   <td>除法</td> 
   <td>10 / 2 结果为 5.0（返回浮点数）</td> 
  </tr> 
  <tr> 
   <td>//</td> 
   <td>整除</td> 
   <td>10 // 3 结果为 3（返回整数部分）</td> 
  </tr> 
  <tr> 
   <td>%</td> 
   <td>取余</td> 
   <td>10 % 3 结果为 1</td> 
  </tr> 
  <tr> 
   <td>**</td> 
   <td>幂运算</td> 
   <td>2 ** 3 结果为 8（2的3次方）</td> 
  </tr> 
 </tbody> 
</table>

### 7.2 赋值运算符&复合赋值运算符 ###

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>=</td> 
   <td>赋值运算符</td> 
   <td>x = 5 将值 5 赋给变量 x</td> 
  </tr> 
  <tr> 
   <td>==</td> 
   <td>相等运算符</td> 
   <td>x == y 检查 x 是否等于 y</td> 
  </tr> 
  <tr> 
   <td>!=</td> 
   <td>不等运算符</td> 
   <td>x != y 检查 x 是否不等于 y</td> 
  </tr> 
  <tr> 
   <td>+=</td> 
   <td>加法赋值运算符</td> 
   <td>x += 3 相当于 x = x + 3</td> 
  </tr> 
  <tr> 
   <td>-=</td> 
   <td>减法赋值运算符</td> 
   <td>x -= 2 相当于 x = x - 2</td> 
  </tr> 
  <tr> 
   <td>*=</td> 
   <td>乘法赋值运算符</td> 
   <td>x *= 4 相当于 x = x * 4</td> 
  </tr> 
  <tr> 
   <td>/=</td> 
   <td>除法赋值运算符</td> 
   <td>x /= 2 相当于 x = x / 2</td> 
  </tr> 
  <tr> 
   <td>//=</td> 
   <td>整除赋值运算符</td> 
   <td>x //= 3 相当于 x = x // 3</td> 
  </tr> 
  <tr> 
   <td>%=</td> 
   <td>取余赋值运算符</td> 
   <td>x %= 5 相当于 x = x % 5</td> 
  </tr> 
  <tr> 
   <td>**=</td> 
   <td>幂赋值运算符</td> 
   <td>x **= 2 相当于 x = x ** 2</td> 
  </tr> 
  <tr> 
   <td>&amp;=</td> 
   <td>与赋值运算符</td> 
   <td>x &amp;= y 相当于 x = x &amp; y</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>=</td> 
   <td>或赋值运算符</td> 
  </tr> 
  <tr> 
   <td>^=</td> 
   <td>异或赋值运算符</td> 
   <td>x ^= y 相当于 x = x ^ y</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;=</td> 
   <td>右移赋值运算符</td> 
   <td>x &gt;&gt;= 2 相当于 x = x &gt;&gt; 2</td> 
  </tr> 
  <tr> 
   <td>&lt;&lt;=</td> 
   <td>左移赋值运算符</td> 
   <td>x &lt;&lt;= 3 相当于 x = x &lt;&lt; 3</td> 
  </tr> 
 </tbody> 
</table>

## 八 字符串扩展 ##

### 8.1 字符串的三种定义方式 ###

![在这里插入图片描述][1f00b6041b3a41068e68418115550f2a.png]  
![在这里插入图片描述][d301ce359fa34c1b9913160c7d82e513.png]  
![在这里插入图片描述][fcbecfbc32b24dd8afaa623dc352602c.png]

*  要注意的是，包含范围是：从三个引号开始，到下一个三个引号结束

### 8.2 字符串的引号嵌套 ###

*  要定义的字符串本身，是包含：单引号、双引号自身呢？如何写？
 *  单引号定义法，可以内含双引号
 *  双引号定义法，可以内含单引号
 *  可以使用转移字符（\\）来将引号解除效用，变成普通字符串

### 8.3 字符串拼接 ###

*  在Python中，有多种方式可以进行字符串拼接。以下是常见的字符串拼接方式及其示例：

1.  使用加号运算符 (+) 进行字符串拼接：

first_name = "John"
    last_name = "Doe"
    full_name = first_name + " " + last_name
    print(full_name)  # 输出：John Doe

1.  使用 `.join()`方法进行字符串拼接：

words = ["Hello", "world", "!"]
    sentence = " ".join(words)
    print(sentence)  # 输出：Hello world !

3.使用`f` 字符串（Formatted String）进行字符串插值：

name = "Alice"
    age = 25
    greeting = f"My name is {
          name} and I'm {
          age} years old."
    print(greeting)  # 输出：My name is Alice and I'm 25 years old.

4.使用 `%` 运算符进行字符串格式化拼接（旧式字符串格式化）：

name = "Bob"
    age = 30
    greeting = "My name is %s and I'm %d years old." % (name, age)
    print(greeting)  # 输出：My name is Bob and I'm 30 years old.

5.使用 `str.format()` 方法进行字符串格式化拼接：

name = "Eve"
    age = 35
    greeting = "My name is {} and I'm {} years old.".format(name, age)
    print(greeting)  # 输出：My name is Eve and I'm 35 years old.

这些是常见的字符串拼接方式，每种方式在不同场景下都有其优劣和适用性。

<table> 
 <thead> 
  <tr> 
   <th>拼接方法</th> 
   <th>优势</th> 
   <th>劣势</th> 
   <th>适用场景</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>加号运算符 (+)</td> 
   <td>- 简单直观<br>- 直接在代码中拼接字符串</td> 
   <td>- 大量拼接时性能较差<br>- 频繁拼接时创建多个临时对象</td> 
   <td>简单的字符串拼接，拼接数量较少的情况</td> 
  </tr> 
  <tr> 
   <td>.join() 方法</td> 
   <td>- 最高效的拼接方法<br>- 适用于大量拼接</td> 
   <td>- 需要将待拼接的内容存储在一个列表中</td> 
   <td>大量字符串拼接，特别是在循环中进行拼接的场景</td> 
  </tr> 
  <tr> 
   <td>f 字符串（Formatted String）</td> 
   <td>- 灵活的插值方式<br>- 直接嵌入变量和表达式</td> 
   <td>- 只适用于较新的 Python 版本（Python 3.6+）</td> 
   <td>动态插入变量和动态生成格式的字符串</td> 
  </tr> 
  <tr> 
   <td>% 运算符</td> 
   <td>- 可定制的格式化方式<br>- 支持较老的 Python 版本</td> 
   <td>- 需要使用特定的占位符和格式化规则<br>- 不如 f 字符串灵活</td> 
   <td>在需要特定格式化的字符串拼接，或需要兼容较老的 Python 版本的场景</td> 
  </tr> 
  <tr> 
   <td>str.format() 方法</td> 
   <td>- 灵活的插值方式<br>- 可定制的格式化方式</td> 
   <td>- 语法相对复杂</td> 
   <td>动态插入变量和灵活的格式化需求</td> 
  </tr> 
 </tbody> 
</table>

### 8.4 字符串格式化 ###

*  在Python中，有几种方式可以进行字符串格式化，包括使用 f 字符串（Formatted String），使用 `%` 运算符和使用 `str.format()` 方法。
    
     *  f 字符串提供了最简洁和直观的插值方式，并且适用于动态插入变量和表达式的场景。
     *  % 运算符适用于需要较简单格式化规则的情况，同时也保持了对较旧版本 `Python` 的兼容性。
     *  `str.format()` 方法则提供了更多的自定义选项，可以对变量进行格式化，并且适用于对格式化要求更复杂的场景。

#### 8.4.1 `f`字符串（Formatted String） ####

*  f 字符串是在Python 3.6引入的一种字符串格式化方式，它允许直接嵌入变量和表达式到字符串中。在字符串前加上 f 或 F，然后使用大括号 \{\} 包围要插入的变量或表达式。

name = "Alice"
       age = 25
       greeting = f"My name is {
          name} and I'm {
          age} years old."
       print(greeting)  # 输出：My name is Alice and I'm 25 years old.

#### 8.4.2 `%` 运算符（旧式字符串格式化）： ####

% 运算符是一种旧的字符串格式化方式，在Python 3.6之前是主要的格式化方法。它使用特定的占位符和格式化规则来插入变量值。

name = "Bob"
       age = 30
       greeting = "My name is %s and I'm %d years old." % (name, age)
       print(greeting)  # 输出：My name is Bob and I'm 30 years old.

*  % 运算符的字符串格式化使用占位符来指示变量值在字符串中的位置和格式。以下是一些常用的占位符：
    
    1.  `%s`：字符串占位符
    2.  `%d`：整数占位符
    3.  `%f`：浮点数占位符
    4.  `%x`：十六进制整数占位符
    5.  `%o`：八进制整数占位符
 *  这些占位符可以在字符串中使用，并通过 % 运算符与对应的变量值进行替换。

name = "Alice"
    age = 25
    greeting = "My name is %s and I'm %d years old." % (name, age)
    print(greeting)  # 输出：My name is Alice and I'm 25 years old.

*  字符串 “My name is %s and I’m %d years old.” 中的 %s 和 %d 是占位符，分别用于插入字符串和整数变量的值。通过 % 运算符，将 name 和 age 变量的值传递给字符串，得到最终的格式化字符串。
 *  此外，还可以使用格式控制指令来控制变量值的输出格式，如控制浮点数位数或填充字符等。

pi = 3.14159
    formatted_pi = "The value of pi is approximately %.2f." % pi
    # %.2f 指定浮点数的格式，表示要保留两位小数。
    print(formatted_pi)  # 输出：The value of pi is approximately 3.14.

#### 8.4.3 `.str.format()` 方法： ####

*  `str.format()` 是另一种常用的字符串格式化方法，它通过大括号 \{\} 指定要插入的变量，并可以使用更灵活的格式化选项。

name = "Eve"
       age = 35
       greeting = "My name is {} and I'm {} years old.".format(name, age)
       print(greeting)  # 输出：My name is Eve and I'm 35 years old.

### 8.5 数字精度控制 ###

#### 8.5.1 辅助符号"m.n" ####

**使用辅助符号"m.n"来控制数据的宽度和精度**

*  m表示字段的最小宽度，而n表示小数部分的精度（对于浮点数）或最大字符数（对于字符串）。

1.  控制数字宽度和精度

number = 3.14159
    formatted_number = "{:7.3f}".format(number)
    print(formatted_number)  # 输出：  3.142  （宽度为7，精度为3）

1.  控制字符串宽度

text = "Hello"
    formatted_text = "{:10}".format(text)
    print("'" + formatted_text + "'")  # 输出：'Hello     '  （宽度为10）

1.  结合宽度和精度

value = 42.123456789
    formatted_value = "{:10.3f}".format(value)
    print(formatted_value)  # 输出：    42.123  （宽度为10，精度为3）

*  请注意，在较新的Python版本（Python 3.6及以后），使用f字符串和f-string字面量也可以轻松实现相同的效果。

number = 3.14159
    formatted_number = f"{
          number:7.3f}"
    print(formatted_number)  # 输出：  3.142
    
    text = "Hello"
    formatted_text = f"{
          text:10}"
    print("'" + formatted_text + "'")  # 输出：'Hello     '
    
    value = 42.123456789
    formatted_value = f"{
          value:10.3f}"
    print(formatted_value)  # 输出：    42.123

使用f字符串的方式更简洁、直观，并且提供了更好的可读性。

#### 8.5.2 数字精度控制方式 ####

*  在Python中，可以使用一些方法来控制数字的精度，包括四舍五入、精确小数位数和格式化输出。以下是一些常用的数字精度控制方法：

1.  四舍五入：  
    使用内置的round()函数可以进行四舍五入操作。该函数接受两个参数：要进行四舍五入的数字和要保留的小数位数。

number = 3.14159
       # round(number, 2)将数字number保留两位小数并进行四舍五入
       rounded_number = round(number, 2)
       print(rounded_number)  # 输出：3.14

1.  精确小数位数：  
    如果需要对浮点数进行精确的小数位数控制，可以使用decimal模块。该模块提供了更精确的十进制运算。

from decimal import Decimal
    
       number = Decimal('3.14159')
       # 通过将浮点数转换为Decimal类型并使用round()函数对其进行四舍五入来实现精确的小数位数控制
       rounded_number = round(number, 2)
       print(rounded_number)  # 输出：3.14

1.  格式化输出：
    
     *  使用字符串的格式化操作符或格式化方法，可以控制数字的精度并以特定格式进行输出。
2.  字符串格式化操作符（%）：
    
        number = 3.14159
         # "%.2f" % number使用%运算符将数字格式化为保留两位小数的浮点数
         formatted_number = "%.2f" % number
         print(formatted_number)  # 输出：3.14
    
     *  %5d：表示将整数的宽度控制在5位，如数字11，被设置为5d，就会变成：\[空格\]\[空格\]\[空格\]11，用三个空格补足宽度。
     *  %5.2f：表示将宽度控制为5，将小数点精度设置为2。如，对11.345设置了%7.2f 后，结果是：\[空格\]\[空格\]11.35。2个空格补足宽度，小数部分限制2位精度后，四舍五入为 .35
     *  %.2f：表示不限制宽度，只设置小数点精度为2，如11.345设置%.2f后，结果是11.35
3.  字符串的format()方法：

number = 3.14159
     # "{:.2f}".format(number)使用format()方法将数字格式化为保留两位小数的浮点数
     formatted_number = "{:.2f}".format(number)
     print(formatted_number)  # 输出：3.14

### 8.6 表达式格式化 ###

*  对于字符串格式化，可以直接格式化一个表达式。
 *  Python提供了一种简洁的方式，可以在字符串中直接嵌入表达式，并在运行时计算并格式化其值。
 *  这种方式使用的是f字符串（Formatted String），在Python 3.6及更高版本中引入的。它允许在字符串中使用大括号\{\}来嵌入表达式，并在前面添加f或F，表示这是一个f字符串。
 *  使用f字符串可以使代码更加简洁和易读，直接在字符串中插入表达式，减少了繁琐的占位符和参数传递过程。

# 表达式a + b被嵌入到f字符串中，通过大括号{}包围。当字符串被打印时，表达式会被计算并替换为其结果。
    a = 10
    b = 5
    result = f"The sum of {
          a} and {
          b} is {
          a + b}."
    print(result)  # 输出：The sum of 10 and 5 is 15.

*  可以在大括号中嵌入复杂的表达式，包括数学运算、函数调用、变量引用等，只要这些表达式在当前作用域可用。
 *  注意：**f字符串只在Python 3.6及更高版本中可用。在旧版本的Python中，可以使用其他字符串格式化方式（如%运算符或str.format()方法）来实现类似的效果。**

## 九 数据输入 ##

*  在Python中，可以使用多种方法进行数据输入，包括从终端读取用户输入、读取文件内容、接收网络请求等。下面介绍几种常用的数据输入方式：

### 9.1 终端输入 ###

*  使用input()函数从终端读取用户输入的数据。input()函数会将用户输入的数据作为字符串返回。

name = input("Enter your name: ")
      print("Hello, " + name)

### 9.2 命令行参数 ###

*  通过命令行参数传递数据给Python脚本。在命令行中，使用python script.py arg1 arg2的形式，将数据作为命令行参数传递给脚本。在Python脚本中，可以通过sys.argv访问命令行参数。

import sys
    
       arg1 = sys.argv[1]
       arg2 = sys.argv[2]
    
       print(arg1, arg2)

*  在命令行中执行脚本时，将参数作为命令行参数传递给脚本。

### 9.3 文件输入 ###

*  使用文件读取操作从文件中获取数据。可以使用open()函数打开文件，并使用不同的方法（如read()、readline()或readlines()）读取文件中的内容。

# 打开名为"data.txt"的文件，并将文件内容读取到变量"data"中。
      with open("data.txt", "r") as file:
          data = file.read()
          print(data)

### 9.4 网络请求 ###

*  使用适当的库（如requests）发送网络请求，从网络服务或API获取数据。通过执行HTTP请求，可以获得来自网络上的各种数据。

# 发送GET请求到"https://api.example.com/data"，获取返回的JSON数据
      import requests
    
      response = requests.get("https://api.example.com/data")
      data = response.json()
      print(data)

[beb482f1b9ad4c0785ed7a783004ce2c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/5e209a45de4747c7afeaa4d7c667d67b.png
[78d0c2e2f69e4c338c0ed78253e390b2.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/79d04a68d700409fafc38ef37790ffb1.png
[3755a873936b4981bd3debfc0c4cdae6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/8223c0913fee41cda23cc97abed73271.png
[7ef50ba987cb4fa4af15c2532dd7f8bd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/9d5f24a6413f483d9a49c20ebad3a633.png
[5334b5a2cdcd4b5695893ab42bce5495.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/75f3419055df4a8a9b9880d03724a0e4.png
[04c9f9f1ff9c462788e0554f4e382fd7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/700bd91fe54c46b7868da7d1dc198d77.png
[1f00b6041b3a41068e68418115550f2a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/cfc6b608a3ac4dd3b4b763e37c4b11ee.png
[d301ce359fa34c1b9913160c7d82e513.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/25c1498cd82649988cc2e4939db24916.png
[fcbecfbc32b24dd8afaa623dc352602c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/1f5ca701d87d4a18a5f264eb2640e7bf.png