Python基础之输入,输出与高阶赋值详解-6ren

Python基础之输入,输出与高阶赋值详解

转载作者：qq735679552 更新时间：2022-09-28 22:32:09

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Python基础之输入,输出与高阶赋值详解由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

1. 输入、输出与注释

1.1 获取用户输入

程序常常需要与用户进行交互，以获得用户提交的数据。Python 提供了input 函数，它接受用户输入数据并且返回一个字符串的引用。 input 函数接受一个字符串作为参数，该字符串用于作为提示用户输入的文本，因此也被称为提示字符串:

 
    ? 
   
         >>> number  
         = 
         input 
         ( 
         'Enter the number of students: ' 
         ) 
        
         Enter the number of students:  
         52 
        
         >>> number 
        
         '52'

在交互式解释器中执行第一行 number = input('Enter the number of students: ')，它打印字符串 "Enter the number of students: "，提示用户输入相应的信息。此处输入 52 并按回车，获取用户在提示字符串后的输入后，存储在 number变量中。需要注意的是 input 函数返回的值是字符串类型，如果需要将这个字符串转换成其他类型，必须提供相应的类型转换，以进行所需操作:

 
    ? 
   
         >>> score  
         = 
         input 
         ( 
         'Enter the total score: ' 
         ) 
        
         Enter the total score:  
         4396 
        
         >>> number  
         = 
         input 
         ( 
         'Enter the number of students: ' 
         ) 
        
         Enter the number of students:  
         52 
        
         >>> average_score  
         = 
         int 
         (score)  
         / 
         int 
         (number) 
        
         >>> average_score 
        
         84.53846153846153

1.2 格式化输出

1.2.1 基本方法

我们在以上示例中，已经不止一次看到了 print 函数，其提供了非常简便打印 Python 输出的方法。它接受零个或者多个参数，默认使用单个空格作为分隔符来显示结果，可以通过可选参数 sep 修改分隔符。此外，默认情况下每一次打印都以换行符结尾，可以通过设置参数 end 来改变:

 
    ? 
   
 
     
       
       
         >>>  
         print 
         ( 
         'Data' 
         ,  
         'Structure' 
         ,  
         'and' 
         ,  
         'Algorithms' 
         ) 
        
 
         Data Structure  
         and 
         Algorithms 
        
 
         >>>  
         print 
         ( 
         'Data' 
         ,  
         'Structure' 
         ,  
         'and' 
         ,  
         'Algorithms' 
         , sep 
         = 
         '-' 
         ) 
        
 
         Data 
         - 
         Structure 
         - 
         and 
         - 
         Algorithms 
        
 
         >>>  
         print 
         ( 
         'Data' 
         ,  
         'Structure' 
         ,  
         'and' 
         ,  
         'Algorithms' 
         , sep 
         = 
         '-' 
         , end 
         = 
         '!!!' 
         ) 
        
 
         Data 
         - 
         Structure 
         - 
         and 
         - 
         Algorithms!!!>>> 
        
 
     
 
   

格式化字符串是一个模板，其中包含保持不变的单词或空格，以及用于之后插入的变量的占位符。使用格式化字符串，可以根据运行时变量的值而发生改变:

 
    ? 
   
         print 
         ( 
         "The price of %s is %d yuan." 
         % 
         (fruit, price))

% 是字符串运算符，被称作格式化运算符。表达式的左边部分是模板（也叫格式化字符串），右边部分则是一系列用于格式化字符串的值，右边的值的个数与格式化字符串中 % 的个数一致。这些值将依次从左到右地被换入格式化字符串.

格式化字符串可以包含一个或者多个转换声明。转换字符告诉格式化运算符，什么类型的值会被插入到字符串中的相应位置。在上面的例子中，%s 声明了一个字符串，%d 声明了一个整数.

可以在 % 和格式化字符之间加入一个格式化修改符，用于实现更加复杂的输出格式:

 
    ? 
   
 
     
       
       
         >>>  
         print 
         ( 
         "The price of %s is %d yuan." 
         % 
         ( 
         'apple' 
         , fruits[ 
         'apple' 
         ])) 
        
 
         The price of apple  
         is 
         5 
         yuan. 
        
 
         >>>  
         print 
         ( 
         "The price of %s is %10d yuan." 
         % 
         ( 
         'apple' 
         , fruits[ 
         'apple' 
         ])) 
        
 
         The price of apple  
         is          
         5 
         yuan. 
        
 
         >>>  
         print 
         ( 
         "The price of %s is %+10d yuan." 
         % 
         ( 
         'apple' 
         , fruits[ 
         'apple' 
         ])) 
        
 
         The price of apple  
         is         
         + 
         5 
         yuan. 
        
 
         >>>  
         print 
         ( 
         "The price of %s is %-10d yuan." 
         % 
         ( 
         'apple' 
         , fruits[ 
         'apple' 
         ])) 
        
 
         The price of apple  
         is 
         5          
         yuan. 
        
 
         >>>  
         print 
         ( 
         "The price of %s is %10.3f yuan." 
         % 
         ( 
         'apple' 
         , fruits[ 
         'apple' 
         ])) 
        
 
         The price of apple  
         is      
         5.000 
         yuan. 
        
 
         >>>  
         print 
         ( 
         "The price of apple is %(apple)f yuan." 
         % 
         fruits) 
        
 
         The price of apple  
         is 
         5.000000 
         yuan. 
        
 
     
 
   

1.2.2 format 格式化函数

上述方式虽然依旧可以使用，但是目前推荐到的另一种解决方案是模板字符串 format，其旨在简化基本的格式设置机制，它融合并强化了前一方法的优点。使用 format 格式化函数时，每个替换字段使用花括号括起，其中可以包含变量名，替换字段也可以没有名称或将索引用作名称：:

 
    ? 
   
 
     
       
       
         >>>  
         "The price of {} is {} yuan." 
         . 
         format 
         ( 
         'apple' 
         ,  
         5.0 
         ) 
        
 
         'The price of apple is 5.0 yuan.' 
        
 
         >>>  
         "The price of {fruit} is {price} yuan." 
         . 
         format 
         (fruit 
         = 
         'apple' 
         , price 
         = 
         price) 
        
 
         'The price of apple is 5.0 yuan.' 
        
 
         >>>  
         "The price of {1} is {0} yuan." 
         . 
         format 
         ( 
         5.0 
         ,  
         'apple' 
         ) 
        
 
         'The price of apple is 5.0 yuan.' 
        
 
     
 
   

从上述示例可以看出，索引和变量名的排列顺序无关紧要。除此之外，还通过结合冒号 :，从而利用格式说明符(与 % 运算符类似):

 
    ? 
   
 
     
       
       
         >>> value  
         = 
         2.718281828459045 
        
 
         >>>  
         '{} is approximately {:.2f}' 
         . 
         format 
         ( 
         'e' 
         , value) 
        
 
         'e is approximately 2.72' 
        
 
         >>>  
         '{} is approximately {:+.2f}' 
         . 
         format 
         ( 
         'e' 
         , value) 
        
 
         'e is approximately +2.72' 
        
 
         >>>  
         '{} is approximately {:0>10.2f}' 
         . 
         format 
         ( 
         'e' 
         , value) 
        
 
         'e is approximately 0000002.72' 
        
 
         >>>  
         '{} is approximately {:0<10.2f}' 
         . 
         format 
         ( 
         'e' 
         , value) 
        
 
         'e is approximately 2.72000000' 
        
 
         >>>  
         '{} is approximately {:^10.2f}' 
         . 
         format 
         ( 
         'e' 
         , value) 
        
 
         'e is approximately    2.72   ' 
        
 
         >>>  
         '{:,}' 
         . 
         format 
         ( 
         100000 
         ) 
        
 
         '100,000' 
        
 
         >>>  
         '{} is approximately {:.2%}' 
         . 
         format 
         ( 
         'e' 
         , value) 
        
 
         'e is approximately 271.83%' 
        
 
         >>>  
         '{} is approximately {:.4e}' 
         . 
         format 
         ( 
         'e' 
         , value) 
        
 
         'e is approximately 2.7183e+00' 
        
 
         >>>  
         '{} is approximately {:0=+10.2f}' 
         . 
         format 
         ( 
         'e' 
         , value) 
        
 
         'e is approximately +000002.72' 
        
 
     
 
   

从上述示例中，很容易总结出，使用 : 号可以指定宽度、精度以及千位分隔符等，^、<、> 分别用于居中、左对齐、右对齐，并且其后可以指定宽度，并可以使用指定单个字符进行填充，默认情况下用空格填充，也可以使用说明符 =，指定将填充字符放在符号和数字之间。同样我们可以使用 b、d、o、x 进行数据类型转换，分别是二进制、十进制、八进制、十六进制，c 用于将数据转换为 Unicode 码:

 
    ? 
   
 
     
       
       
         >>>  
         "The number is {num:b}" 
         . 
         format 
         (num 
         = 
         1024 
         ) 
        
 
         'The number is 10000000000' 
        
 
         >>>  
         "The number is {num:d}" 
         . 
         format 
         (num 
         = 
         1024 
         ) 
        
 
         'The number is 1024' 
        
 
         >>>  
         "The number is {num:o}" 
         . 
         format 
         (num 
         = 
         1024 
         ) 
        
 
         'The number is 2000' 
        
 
         >>>  
         "The number is {num:x}" 
         . 
         format 
         (num 
         = 
         1024 
         ) 
        
 
         'The number is 400' 
        
 
         >>>  
         "The number is {num:c}" 
         . 
         format 
         (num 
         = 
         1024 
         ) 
        
 
         'The number is Ѐ' 
        
 
     
 
   

1.3 注释

是时候介绍下注释了，注释是提高程序可读性的一个绝佳方法，也是大家容易忽视的点。Python 不解释紧跟在 # 符号后面的文本:

 
    ? 
   
         radius  
         = 
         5.0 
         # 圆的半径 
        
         side  
         = 
         2.0 
         # 正方形边长 
        
         # 正方形面积与圆形面积的差 
        
         area_c  
         = 
         3.14 
         * 
         radius  
         * 
         * 
         2 
        
         area_s  
         = 
         side  
         * 
         * 
         2 
        
         diff  
         = 
         area_s  
         - 
         area_c

如果要使用多行注释，可以将注释语句放在一对三双引号 (""") 或一对三单引号 (''') 之间:

2. 高阶赋值语句

我们已经学习了如何给变量赋值，或者给数据结构的数据元素赋值，但还有其他类型的赋值语句，可以用于简化代码，增加代码的可读性.

2.1 赋值运算符

除了最基础的 = 赋值运算符外，也可以将右边表达式中的标准运算符移到赋值运算符 = 的前，构成新的运算符，如 +=、-=、*=、/=、%=等:

 
    ? 
   
         >>> number  
         = 
         1 
        
         >>> number  
         + 
         = 
         4 
        
         >>>  
         print 
         (number) 
        
         5 
        
         >>> number  
         / 
         / 
         = 
         2 
        
         >>>  
         print 
         (number) 
        
         2 
        
         >>> number  
         * 
         * 
         = 
         2 
        
         >>>  
         print 
         (number) 
        
         4 
        
         >>> string_1  
         = 
         'Hello!' 
        
         >>> string_1  
         * 
         = 
         2 
        
         >>>  
         print 
         (string_1) 
        
         'Hello!Hello!'

可以这种赋值方式不仅可以用于数值数据，也可以用于其他数据类型(只要数据类型支持所使用的双目运算符).

2.2 并行赋值

除了一个一个进行赋值外，可以同时(并行)为多个变量赋值:

 
    ? 
   
         >>> a, b, c, d  
         = 
         0 
         ,  
         1 
         ,  
         2 
         ,  
         3 
        
         >>>  
         print 
         (a, b, c, d) 
        
         0 
         1 
         2 
         3

通过这种方式，可以简单的交换多个变量的值:

 
    ? 
   
         >>> b, c  
         = 
         c, b 
        
         >>>  
         print 
         (a, b, c, d) 
        
         0 
         2 
         1 
         3

2.3 序列解包

序列解包是将一个可迭代对象解包，并将得到的值存储到一系列变量中，但要解包的序列包含的元素个数必须与等号左边列出的变量个数相同，否则将引发异常:

 
    ? 
   
 
     
       
       
         >>> fruit, price  
         = 
         [ 
         'apple' 
         ,  
         5.0 
         ] 
        
 
         >>>  
         print 
         (fruit) 
        
 
         apple 
        
 
         >>>  
         print 
         (price) 
        
 
         5.0 
        
 
         >>> fruit, price, date  
         = 
         ( 
         'apple' 
         ,  
         5.0 
         ) 
        
 
         Traceback (most recent call last): 
        
 
            
         File 
         "<stdin>" 
         , line  
         1 
         ,  
         in 
         <module> 
        
 
         ValueError:  
         not 
         enough values to unpack (expected  
         3 
         , got  
         2 
         ) 
        
 
         >>> fruit, price  
         = 
         ( 
         'apple' 
         ,  
         5.0 
         ,  
         '2021-11-11' 
         ) 
        
 
         Traceback (most recent call last): 
        
 
            
         File 
         "<stdin>" 
         , line  
         1 
         ,  
         in 
         <module> 
        
 
         ValueError: too many values to unpack (expected  
         2 
         ) 
        
 
     
 
   

为了避免异常触发，可以使用星号运算符 * 来收集多余的值，这样便不需要确保值和变量的个数相同，赋值语句的右边可以是任何类型的序列，但带星号的变量最终得到的总是一个列表:

 
    ? 
   
 
     
       
       
         >>> fruits  
         = 
         [ 
         'apple' 
         ,  
         'orange' 
         ,  
         'lemon' 
         ] 
        
 
         >>> fruit_a,  
         * 
         rest  
         = 
         fruits 
        
 
         >>>  
         print 
         (rest) 
        
 
         [ 
         'orange' 
         ,  
         'lemon' 
         ] 
        
 
         >>> fruits_a,  
         * 
         rest, fruits_b  
         = 
         fruits 
        
 
         >>>  
         print 
         (rest) 
        
 
         [ 
         'orange' 
         ] 
        
 
         >>> fruits_a, fruits_b, fruits_c,  
         * 
         rest  
         = 
         fruits 
        
 
         >>>  
         print 
         (rest) 
        
 
         [] 
        
 
     
 
   

2.4 链式赋值

链式赋值可以将多个变量关联到同一个值:

等价于:

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注我的更多内容.

原文链接：https://blog.csdn.net/LOVEmy134611/article/details/121464739 。

最后此篇关于Python基础之输入,输出与高阶赋值详解的文章就讲到这里了,如果你想了解更多关于Python基础之输入,输出与高阶赋值详解的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！。

文章推荐： Python Pillow Image.save 保存为jpg图片压缩问题

文章推荐： Python标准库calendar的使用方法

文章推荐： Python Type Hints 学习之从入门到实践

文章推荐： Python的Pillow库进行图像文件处理（图文详解）

JavaScript 赋值
你能解释一下这个作业是如何完成的吗， var fe, f = document.forms[0], h; 哪个等于哪个。最佳答案以上等同于 var fe; var f = document.for
JavaScript 赋值()
据我测试，这两种方法都有效，但我不知道哪一种最好，也不知道它们之间的区别，这就是我想知道的。以下是两种方法: window.location = 'http://www.google.com'; w
python - Numpy字符串数组，赋值
我正在处理用字符串填充的 numpy 数组。我的目标是分配给第一个数组 a 的切片，值包含在较小尺寸的第二个数组 b 中。我想到的实现如下: import numpy as np a = np.em
带有虚拟占位符的 Perl 赋值
在我使用过的其他语言(如 Erlang 和 Python)中，如果我正在拆分字符串并且不关心其中一个字段，我可以使用下划线占位符。我在 Perl 中试过这个: (_,$id) = split('
javascript - 如何在没有构造函数的情况下为 "this"赋值
我认为这似乎很简单，但我对调用、应用、绑定(bind)感到困惑。等等我有一个事件监听器 red.addEventListener("click", function() { j = 0;
python - With-As 语句与 "="赋值？
这个问题在这里已经有了答案: What is the python "with" statement designed for? (11 个答案) 关闭 7 年前。使用有什么区别: iFile =
python - With-As 语句与 "="赋值？
这个问题在这里已经有了答案: What is the python "with" statement designed for? (11 个答案) 关闭 7 年前。使用有什么区别: iFile =
Haskell 赋值 - 将字符串拆分为单词所需的方向
几周前我们开始写一篇关于 Haskell 的论文，刚刚接到我们的第一个任务。我知道 SO 不喜欢家庭作业问题，所以我不会问怎么做。相反，如果有人能将我推向正确的方向，我将不胜感激。鉴于它可能不是一个特
c - 指针问题，赋值
我正在尝试为我的函数的变量根分配一个值，但似乎不起作用。我不明白这个问题。 hw7.c:155:7:警告:赋值使指针来自整数而不进行强制转换[默认启用] root = 负载(&fp, 大小); 此代码
c 赋值，对整数求平均值
我昨天花了大约 5 个小时来完成这个工作，并使用这个网站的帮助让代码可以工作，但我认为我这样做的方式是一种作弊方式，我使用了 scanf 命令。无论如何，我想以正确的方式解决这个问题。多谢你们!哦，代
c - 赋值，关于二维数组
我需要一些帮助来解决问题。我有这个文本文件: 我将文本内容输入到字符串二维数组中，并将其转换为整数二维数组。当我转换为 int 数组时，nan 被替换为零。现在，我继续查找二维数组中每行的最大值和最
c++ - 模板是否应该为仅移动不同类型的参数创建非右值引用构造函数/赋值？
假设我有一个只能移动的类型。我们停止现有的默认提供的构造函数，但 Rvalue 引用引入了一种新的“ flavor ”，我们可以将其用于签名的移动版本: class CantCopyMe { priv
javascript - 减少和对象解构/赋值
假设我有两个简单的对象，我想创建第三个对象来连接它们的属性。这非常有效: (()=>{ const a1 = {a: 2, b: 3} const b1 = {a: 100, c: 5}
Swift VAR 赋值
我想知道我是否可以稍后在这样的代码中为 VAR 赋值 var myView: UIView func createView() { myView = UIView() { let _view =
Javascript/HTML 赋值
我遇到了一些 Javascript/HTML/CSS 代码的问题。我对创建网站还很陌生，所以请多多包涵。我最终想做的是从 javascript 中提取一个动态值并使用它对一些 div(在容器中)进行
c++ - 为什么在设置对象等于另一个函数的返回值时调用移动构造函数/赋值
#include class Box{ public: int x; Box(){ x=0; std::cout No move construction thanks to RV
JavaScript bool 赋值
我发现在javascript中&=运算符是按位赋值: var test=true; test&=true; //here test is an int variable javascript中是否存在
c++ - 赋值=运算符重载
请帮助完成赋值重载函数的执行。这是指令: 赋值运算符 (=)，它将源字符串复制到目标字符串中。请注意，目标的大小需要调整为与源相同。加法 (+) 和赋值 (=) 运算符都需要能够进行级联运算。这意
c++ - 如何防止用继承的运算符[]赋值？
我有一个名为 SortedArrayList 的自定义结构它根据比较器对其元素进行排序，我想防止使用 operator[] 进行分配. 示例: 数组列表.h template class Array
只需一行 Python 赋值
我是 python 的新手，我看到了这种为列表赋值的形式 color= ['red' if v == 0 else 'green' for v in y] 但是如果我尝试用 3 个数字来做，例如 co

qq735679552

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城