python格式化输出 xz_4. Python之用户交互, 字符串格式化输出, 基本运算符

1 用户交互

1.1 input()接收用户的输入

计算机接收用户的输入

在Python2中：

raw_input():用法与Python3的input一模一样

input(): 要求用户必须输入一个明确的数据类型，输入的是什么类型，就存成什么类型, 方便了程序开发者, 无需考虑用户输入, 用户需要按照Python的要求去输入数据类型

在Python3中：

input会将用户输入的所有内容都存成字符串类型,方便用户, 由程序员去开发程序识别解释用户输入

username = input("请输入用户名: ")

print(username)

>>

请输入用户名: admin

admin

age = int(input("请输入年龄: ")) # int只能将纯整型的字符串转成整型, '1.1'是无法转换的, 也无法转换字符➕整型混合

print(age,type(age))

>>

请输入年龄: 18

18

1.2 字符串格式化输出

1.2.1 % ()

Python各版本都适用

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

# 单纯的传值

info = '''

用户名是%s, 密码是%s

''' %('david',20)

print(info)

>> 用户名是david, 密码是20

# 可以传变量

username = input("请输入用户名: ")

password = input("请输入密码: ")

info = '''

==============

用户名是%s,密码是%s

==============

''' % (username,password)

print(info)

>>

==============

用户名是admin,密码是admin

==============

# 前两种方式是按照%()中的值的顺序, 给%s一一传值, 需要记住顺序才行, 不方便, 可以利用字典传值, 但是用字典传值也是显得很臃肿

username = input("请输入用户名: ")

password = input("请输入密码: ")

info = '''

==============

用户名是%(name)s,密码是%(password)s # %s改用%()s占位, 括号里写后面字典的key

==============

''' % ({'name':username,'password':password}) # %()中存字典, 字典的key和%()s的key要对应, 也就是%()s中定义的key, 在%()的字典中必须存在, 但是没有顺序关系, 而value的值可以通过变量取

print(info)

>>

请输入用户名: admin

请输入密码: admin

==============

用户名是admin,密码是admin

==============

# %s可以接收任意类型的值

print('my name is %s'%('haha'))

print('my name is %s'%(18))

print('my name is %s'%([11,22,33]))

print('my name is %s'%({'name','admin'}))

>>

my name is haha

my name is 18

my name is [11, 22, 33]

my name is {'name', 'admin'}

# 如果规定必须是数字, 那么可以用%d

print('my name is %d'%('18'))

>>

print('my name is %d'%('18'))

TypeError: %d format: a number is required, not str

print('my name is %d'%(18))

>> my name is 18

1.2.2 string.format()

Python2.6以后引用, 兼容性好

# 按位置传值

print("my name is {} and my age is {}".format('admin',19))

>> print("my name is {} and my age is {}".format('admin',19))

# 按索引编号传值

print("my name is {0} and my age is {1}".format('admin',20))

>> my name is admin and my age is 20

# 按字典传值

print("my name is {name} and my age is {age}".format(name="admin",age=20))

>> my name is admin and my age is 20

1.2.3 f

Python3.5以后才推出, 以变量的形式接收用户的输入

username = 'admin'

password = 'password'

print(f'用户名是{username},密码是{password}')

>> 用户名是admin,密码是password

1.2.4 f 补充功能

f 运行字符串里的功能

f'{print("aaaa")}'

>> aaaa

res = f'{10 + 3}'

print(res)

>> 13

总结:

三种字符串格式化输出的效率

f > str.format > %

1.2.4 填充与格式化

# 先取到值,然后在冒号后设定填充格式：[填充字符][对齐方式][宽度]

*<10：左对齐，总共10个字符，不够的用*号填充

print('{0:*<10}'.format('开始执行')) # 开始执行******

*>10：右对齐，总共10个字符，不够的用*号填充

print('{0:*>10}'.format('开始执行')) # ******开始执行

*^10：居中显示，总共10个字符，不够的用*号填充

print('{0:*^10}'.format('开始执行')) # ***开始执行***

print('{x}=============='.format(x='开始执行')) # 开始执行******

print('{x}==========='.format(x='开始执行')) # 开始执行===========

print('{x:=<10}'.format(x='开始执行')) # 开始执行======, x取到的值居左显示, :=<10表示x取到的值占的字符位置如果不足10, 则用=填充

print('{x:=>10}'.format(x='开始执行')) # ======开始执行, x取到的值居右对齐

print('{x:=^13}'.format(x='开始执行')) # ===开始执行===, x取到的值居中, 左右补等号, 如果剩余位数奇数位, 则右边多补

1.2.5 精度与进制

print('{salary:.3f}'.format(salary=1232132.12351)) #精确到小数点后3位，四舍五入，结果为：1232132.124

print('{0:b}'.format(123)) # 转成二进制，结果为：1111011

print('{0:o}'.format(9)) # 转成八进制，结果为：11

print('{0:x}'.format(15)) # 转成十六进制，结果为：f

print('{0:,}'.format(99812939393931)) # 千分位格式化，结果为：99,812,939,393,931

2 基本运算符

2.1 算术运算符

print(10 + 3.1)

print(10 + 3)

print(10 / 3) # 结果带小数

print(10 // 3) # 只保留整数部分, 不是四舍五入

print(10 % 3) # 取模、取余数

print(10 ** 3) # 次方, 10的3次方

+ 号一般用于数字计算, 不要用来做字符串拼接, 效率很低

2.2 比较运算符

>、>=、

print(10 > 3) # True

print(10 == 10) # True

print(10 >= 10) # True

print(10 >= 3) # True

age = input("age: ")

print(age == 20)

>>

age: 20

False

# Python3中, 用户的输入都被认为是字符串, 因此, 与数字做比较时, 要先把用户输入转成整型或float

age = int(input("age: "))

print(age == 20)

2.3 赋值运算符

2.3.1 变量赋值

=：变量的赋值

x = 10

print(x)

>> 10

2.3.2 增量复制

age = 18

age += 1 # age=age + 1

print(age)

>> 19

age*=3

age/=3

age%=3

age**=3 # age=age**3

2.3.3 链式赋值

把一个值赋值给多个变量名

x=10

y=x

z=y

z = y = x = 10 # 链式赋值

print(x, y, z)

>> 10 10 10

print(id(x), id(y), id(z)) # 链式赋值, 变量都指向相同的内存地址

>> 140731791185856 140731791185856 140731791185856

2.3.4 交叉赋值

m = 10

n = 20

print(m,n)

>> 10 20

m,n = n,m

print(m,n)

>> 20 10

# 第二种方式

m = 10

n = 20

print(m,n)

>> 10 20

Temp = m

m = n

n = Temp

print(m,n)

>> 20 10

2.3.5 解压赋值

2.3.5.1 列表解压

举例:

把五个月的工资取出来分别赋值给不同的变量名

salaries = [111, 222, 333, 444, 555]

mon0=salaries[0]

mon1=salaries[1]

mon2=salaries[2]

mon3=salaries[3]

mon4=salaries[4]

salaries = [111,222,333,444,555]

mon0,mon1,mon2,mon3,mon4=salaries

print(mon0,mon1,mon2,mon3,mon4)

引入*，可以帮助我们取两头的值，也可以取之间的值, 但是一般不用

name = ['name1','name2','name3','name4']

x,y,z,*_=name

print(x,y,z)

>> name1 name2 name3

*_,z=name

print(z)

>> name4

print(_)

>> ['name1', 'name2', 'name3']

# 所有没有被对应到的列表中的值, 都会被*接受, 复制给变量名'_', 所以print(_)的结果就是没有被解压的列表

# '_'就是一个占位符, 用来接收没有对应关系的值, 存成列表

salaries=[111,222,333,444,555]

_,*middle,_=salaries

print(middle)

>> [222, 333, 444]

2.3.5.2 字典解压

解压字典默认解压出来的是字典的key

举例:

dic = {'a': 1, 'b': 2, 'c': 3}

dic = {'a': 1, 'b': 2, 'c': 3}

*_,x = dic

print(x)

>> c # 字典解压, 解出来的是key

3. 可变不可变类型

可不可变看的是修改了变量值后, 变量名的id号码是否发生改变, 如果没有发生改变, 说明变量名所捆绑的内存地址是不变的, 变得只是该内存空间里的内容; 而如果是不可变的, 说明变量名所捆绑的内存地址发生了变化, 因此改变变量值产生了新值, 变量名被捆绑到了新的内存空间, 那么id也就变了

3.1 可变类型

可变类型: 变量值改变, 但是id不变, 证明改的是原值, 原值是可以改变的

简单理解就是, 在变量值所在的内存空间中, 把原值修改, 但是内存地址还是原来的地址, 瓶子没变, 水换了

验证列表类型:

>>> list1 = [111,222,333]

>>> print(id(list1))

1364070899968

>>> list1[0] = 444

>>> print(list1)

[444, 222, 333]

>>> print(id(list1))

1364070899968

修改了列表中的值, 但是id没变,因此列表是可变类型

验证字典类型:

>>> dict = {'name':'admin','age':20}

>>> print(id(dict))

1364070846592

>>> dict['name'] = 'manager'

>>> print(dict)

{'name': 'manager', 'age': 20}

>>> print(id(dict))

1364070846592

修改了字典中的值, 但是id没变, 因此字典是可变类型

原理解析:

图片.png

3.2 不可变类型

不可变类型: 变量值改变了, id也发生改变, 证明原值是没有改的, 而是产生了新的值, 放在了新的内存空间地址. 因此, 原值不可被修改

验证整型:

>>> x = 10

>>> print(id(x))

140731787057088

>>> x = 11

>>> print(id(x))

140731787057120

修改了整型值, id发生了变化, 说明修改了x的值是产生了新的值, 开辟了新的内存空间, 把11放进去, 然后和x进行捆绑, x指向了新的内存地址, 因此id号也就发生了改变

因此, 整型是不可变类型, 所有的赋值都是产生新值, 需要开辟新的内存空间

验证浮点型:

>>> x = 1.1

>>> print(id(x))

1364070527376

>>> x = 2.2

>>> print(id(x))

1364070528080

浮点型也是不可变类型

验证字符串类型:

>>> x = 'aaa'

>>> print(id(x))

1364071217840

>>> x = 'bbb'

>>> print(id(x))

1364071217968

字符串也是不可变类型

原理解析:

图片.png

总结:

整型, 浮点和字符串都是一个整体, 其在内部是不可被分隔的, 无法只修改一个数字或者一个字符, 因此, 修改整型, 浮点, 字符串都是修改了一个整体. 同理, 布尔也是不可变的

列表, 字典, 都是容器类数据类型, 其内部的值是可以更改的, 但是容器本身是不变的