2-程序与用户交互

  • 2020 年 9 月 30 日
  • 笔记

程序用户交互 格式化输出 基本运算

程序交互

当我想让计算像人一样思考的时候，就需要于外界交互，需要输入input输出output

根据用户输入不同的内容，计算机根据输入内容的不同，判断输出相应的内容

如何接收用户的输入

​ 我们通过input变量接收用户的输入 print输出到终端

在python3中input功能中，用户输入任何内容，都存成字符串类型，然后赋值给等号左边的变量名

username = input("请输入用户名: ")
userid = input("请输入用户id: ")
userage = int(input("请输入用户年龄: "))
print(username, type(username))
print(userid, type(userid))
print(userage, type(userage))

请输入用户名: 阿里
请输入用户id: 23.4
请输入用户年龄: 23
阿里 <class ‘str’>
23.4 <class ‘str’>
23 <class ‘int’>

不论我们输入的是字符串 还是整形，浮点型 都是字符串格式 如果需要转换相应的格式

可以在input外键添加相应的格式转换 int()

在python2中：
raw_input():用法与python3的input一模一样
input(): 则要求用户必须输入一个明确的数据类型，输入的是什么类型，就存成什么类型

raw_input

print(type(raw_input(“请输入id号：”)))
请输入id号：23
<type ‘str’>
print(type(raw_input(“请输入id号：”)))
请输入id号：asdc
<type ‘str’>
print(type(raw_input(“请输入id号：”)))
请输入id号：23df.5e
<type ‘str’>

input

print(type(input(“请输入id号：”)))
请输入id号：23
<type ‘int’>
print(type(input(“请输入id号：”)))
请输入id号：”asdc”
<type ‘str’>
print(type(input(“请输入id号：”)))
请输入id号：23df.5e
Traceback (most recent call last):
File ““, line 1, in
File ““, line 1
23df.5e
^
SyntaxError: invalid syntax

格式化输出

我们经常需要格式化输出一些内容，与客户自己相关的内容会变，其余的内容不变

例如：中国移动 ，您的电话### 已欠费，请及时充值

*整个语句中只有电话会变为目标手机 其余不变 这种就是格式化输出

  1. 通过%实现

%s占位符：可以接收任意类型的值
%d占位符：只能接收数字

值按照位置与%s一一对应，少一个不行，多一个也不行

my_info = "My name is %s , I come from %s, I am %s yeasold " % ("阿里", "CHINA", "80")
print(my_info)
print('my name is %d' % abs)  #%d只允许数字，abs会报错
print('my age is %d' % 18)

My name is 阿里 , I come from CHINA, I am 80 yeasold

my age is 18

三个位置一一对应 少一个多一个都会报错

需要注意%()不在“ ” 内

打破位置的限制方法可以通过字典传值的方式把位置的限制打破

my_info = "My name is %(name)s , I come from %(country)s, I am %(age)s yeasold " % {'name': "阿里", 'age': "98",'country': "CHINA"}                                                                             
print(my_info)

My name is 阿里 , I come from CHINA, I am 98 yeasold

需要注意的是 %{} 变量赋值后面改为中括号

  1. .format:兼容性好
my_info = "My name is {} , I come from {}, I am {} yeasold " .format ("阿里", "CHINA", "80")
print(my_info)

My name is 阿里 , I come from CHINA, I am 80 yeasold

my_info = "My name is {0} {0} {0} , I come from {1}, I am {2} yeasold " .format ("阿里", "CHINA", "80")
print(my_info)
my_info = "My name is {1} {1} {1} , I come from {0}, I am {2} yeasold " .format ("阿里", "CHINA", "80") #name是1 所以填充CHINA from 填充的是阿里
print(my_info)

My name is 阿里 阿里 阿里 , I come from CHINA, I am 80 yeasold

My name is CHINA CHINA CHINA , I come from 阿里, I am 80 yeasold

可以通过下标位置 填充不同的内容

同样打破位置仍然是通过字典key-value的形式实现

my_info = "My name is {name} , I come from {country}, I am {age} yeasold ".format(name="阿里", country='CHINA', age='38')
print(my_info)

与%s 不同 占位符是中括号 ，.format() 是小括号，切名字不用引号

python2.3之后推出 f:

name = input('your name: ')
age = input('your age: ')
my_info = f'my name is {name},my age is {age}'
print(my_info)

your name: 阿里
your age: 38
my name is 阿里,my age is 38

name = input('your name: ')
age = input('your age: ')
my_info = f'my name is {{{name}}},my age is {age}'
print(my_info)

your name: 阿里
your age: 23
my name is {阿里},my age is 23 # 最外层的{}解释里层的{}当作普通字符处理

输出文本格式化

print('{0:#<10}'.format('预备'))  # #<10 左对齐 总共10个字符 不够的用#填充 
print('{0:#>10}'.format('预备')) # #>10 右对齐， 总共10个字符 不够的用#填充 
print('{0:#^10}'.format('开始执行')) # #^10居中对齐  总共10个字符 不够的用#填充
print('{1:#<10}'.format('预备','开始')) # 0：对应第一个字符 1：对应第二个字符

预备######## 对应2个汉字 8个字符
########预备

开始执行###

开始######## 把开始文本格式化输出

输出精度

print('{money:.3f}'.format(money=3.145926))  # 精确到小数点后3位，四舍五入
print('{0:b}'.format(8))  # 转成二进制
print('{0:o}'.format(8))  # 转成八进制
print('{0:x}'.format(8))  # 转成十六进制
print('{0:,}'.format(21983483))  # 千分位格式化

3.146 保留三位 四舍五入一位
1000 二进制 8 4 2 0
10 八进制
8 16进制

21,983,483 两千一百 九十八万三千 四百八十三

基本运算

算数运算符

常见的算数运算

print(10 + 3.1)
print(10 + 3)
print(10 / 3)  # 结果带小数
print(10 // 3)  # 只保留整数部分
print(10 % 3)  # 取模、取余数
print(10 ** 3)  # 取模、 等于 print(10 * 10 * 10) 10的三次幂

13.1
13
3.3333333333333335
3

1
1000

比较运算符

比较运算符: >、>=、<、<=、==、!= 大于 大于等于 小于 小于等于 等于 == ！=不等于

print(10 > 3)
print(10 == 10)
print(10 >= 10)
print(10 >= 3)

赋值运算符

普通赋值

= ：变量的赋值

a = 10 把10赋值给a这个变量

  1. 增量赋值 +=
a = 10
a += 1  #等于10+1
print(a)
a *= 3  #等于11*3
print(a)
a /= 3  #等于33/3
print(a)
a %= 3  #等于11/3 取余数
print(a)
a **= 3  #等于2*2*2
print(a)

11
33
11.0
2.0
8.0

  1. 链式赋值
a = 10
b = a
c = b
c = b = a = 10  # 链式赋值
print(a, b, c)
print(id(a), id(b), id(c))

10 10 10
140711050594240 140711050594240 140711050594240

  1. 交叉赋值

    a = 10
b = 20
print(id(a), id(b))
a, b = b, a
print(a, b, id(a), id(b))

140711050594240 140711050594560
20 10 140711050594560 140711050594240

  1. 解压赋值

    money = [123, 456, 789, 12315]
money_1, money_2, money_3, money_4 = money
print(money_1, money_2, money_3, money_4)

    123 456 789 12315 把money解压同时赋值给四个不同的变量。

    解压复制个数上要一一对应，多一个少一个都会报错

    取值变量两侧的值，不适合取中间的值

当变量的值很多的时候，我们需要取两边的值可以通过引入*，

a, b, c, *_ = money = [123, 456, 678, 4443, 5435, 3424, 243, 53243, 432]
print(a, b, c) # *_  表示把后面所有的值赋值给变量_     *表示所有
print(_)
*_, a, b, c = money = [123, 456, 678, 4443, 5435, 3424, 243, 53243, 432]
print(a, b, c)

123 456 678

[4443, 5435, 3424, 243, 53243, 432]

243 53243 432

字典解压出来默认是key

a, b, c = money = {"money_1": 123, "money_2": 456, "money_3": 789}
print(a, b, c)

money_1 money_2 money_3

逻辑运算符

逻辑运算用于连接多个条件进行判断，会返回布尔值 False 或True

and 所有条件都成立为真 True 否则为假False

or 其中一个条件成立就是真True 否则为假False

not 取反

print(10 > 3 and 10 > 9)
print(10 > 3 and 10 < 9)
print(10 > 3 or 10 < 9)
print(not 10 > 3)

True
False
True
False

当and or not 同时出现而又没有括号的时候 优先级为not>and>or

not于紧跟其后面的判断是不可分离的

and和or同时存在，先把and左右两边的计算完成，然后在计算or

print( 10 > 3 and 10 < 9 or not 10 > 12)

True

not 10>12 是false 10 > 3 and 10 < 9 是true true or false 是 true

偷懒原则 逻辑计算一旦可以确定，就一当前计算的值作为最终结果

print(3 > 4 or False or 3 != 2 or 3 > 2 or True) # 偷懒原则

True

当都是or的时候 只要有一个结果是真就都是真 3>4位真 所有返回的true为3>4的判断 也是整个结果的判断

print(10 > 3 and 10 and 3 != 3 and 4 == 4)

False

到and 3 ！=3 这里就可以判断为 false了

成员运算符

一个对象是否包含另外一个对象 包含为真 True 不包含为假False

print(not'ali' in ['ali', 'zero', 'pakaa'])
print('ali' not in ['ali', 'zero', 'pakaa'])  #推荐这种 语义更明确

False
False

推荐尽量使用not in 语义更加明确

同样可以判断 元素是否在列表中，key是否在字典中。

print(111 in [111, 222, 333, 444])
print("alin" in {"alin": 22, "alix": 33})
print(22 in {"alin": 22, "alix": 33})

True
True
False

身份运算符

is not is

判断两个变量是否相同

== 判断是变量的值是否相同，可以想想为通过人脸识别判断是不是一个人（双胞胎会判断为一个人）

is 判断的是在内存的位置是否相同 可以想想为判断身份证号是不是一个人

所以 is 相同的 ==值一定相同 ==相同的 is可以不一定

>>> a=1237890
>>> b=1237890
>>> c=b
>>> print(a==b)
True
>>> print(a is b)
False
>>> print(b is c)
True
>>> print(b == c)
True
>>> print(id(a))
1689037339568
>>> print(id(b))
1689037339632
>>> print(id(c))

a 于b 是值value相同 内存中的地址不同id 所以 == 不会是 is

b 于 c 内存中的地址相同id 所以 即使 == 也是 is

== 相同 value则相同 同时type 值的类型也相同

当然 id 相同的话 value值也会相同 type 值的类型也相同

VirMach 便宜 VPS

QNews

QNews