Python基础数据类型以及格式化输出

目录

• 数据类型
  • 数据为何要分类
  • 数据类型的使用
    • 1、整型int（）类
    • 2、浮点型float([x])类
    • 3、复数类型complex([real[, imag]])
    • 4、字符串类型str(object=b'', encoding='utf-8', errors='strict')
    • 5、列表类型list([iterable])
    • 6、字典类型dict（）
    • 7、布尔类型bool
    • 8、集合set([iterable])
    • 9、元组tuple([iterable])
• 可变数据类型
• 不可变数据类型
• 与用户交互
  • 接收用户输入：input（）函数
  • 向屏幕输入：print（）函数
• 格式化输出：
  • 百分号%
  • str.format()
    • 简单替换
    • 对齐
    • 进制。
    • 精度。
  • f-string
    • 简单使用
    • 表达式求值
• 参考文档：

数据类型

数据的种类，不同类型的数据存取机制不一样，用途也不一样。

数据为何要分类

数据是事物的状态，事物的状态是分为多种多样的，对应着就应该用不同类型的数据去记录。

数据类型的使用

1、整型int（）类

返回一个基于数字或字符串 x 构造的整数对象，或者在未给出参数时返回 0。字符串前面可以有符号，之前也可以有空格。可选的符号有 '+' 和 '-' ， '+' 对创建的值没有影响。对于浮点数，它将向零舍入。

x如果为字符串，必须是纯整数数字。如果是小数，int（x）会报错。

age = 18  # 相当于age = int(18),int是工厂函数,造出这个整数。
level = int(10)
print(level,type(level))
10 <class 'int'>

没有参数则返回0，浮点数则只保留整数部分。

print(int())
0
print(int(  +3.9))
3

print(int('1.1'))
# ValueError

整型用来记录年龄、等级、数量等。

2、浮点型float([x])类

返回从数字或字符串 x 生成的浮点数。如果没有实参，则返回 0.0 。

如果实参是字符串，则它必须是包含十进制数字的字符串，字符串前面可以有符号，之前也可以有空格。可选的符号有 '+' 和 '-' ， '+' 对创建的值没有影响。

salary = 3.1 # 相当于salary = float(3.1)
print(type(salary))
3.1 <class 'int'>

print(float('-1.1')
-1.1
print(float())
0.0

float用来记录身高、体重、薪资等。

3、复数类型complex([real[, imag]])

返回值为 real + *imag**1j 的复数，或将字符串或数字转换为复数。如果第一个形参是字符串，则它被解释为一个复数，并且函数调用时必须没有第二个形参。第二个形参不能是字符串。每个实参都可以是任意的数值类型（包括复数）。如果省略了 imag，则默认值为零，构造函数会像 int 和 float 一样进行数值转换。如果两个实参都省略，则返回 0j。

print(complex(10))
(10+0j)

当从字符串转换时，字符串在 + 或 - 的周围必须不能有空格。例如 complex('1+2j') 是合法的，但 complex('1 + 2j') 会触发 ValueError 异常。

4、字符串类型str(object=b'', encoding='utf-8', errors='strict')

字符串是由 Unicode 码位构成的不可变序列。如果未提供 object 则返回空字符串。 在其他情况下 str() 的行为取决于 encoding 或 errors 是否有给出。所有数据类型都能转换为str类型。

定义：在""或者''或者""" """或者''' '''中间包含一系列字符。

msg1="你he xxx"  # 相当于msg1=str("xxx")
msg2="""
111
222
333
"""
print(msg3)
print(type(msg3))
'''
# 外层用双引号，内层就需要用单引号
print("my name is 'egon'")

# 字符串可以用+号拼接，用*号重复n次。
x="abc"
y="ddd"
print(x+y)
print("abc"*3)
print('='*50)
print("hello")
print('='*50)

作用：记录一些描述性质的内容，比如名字、国籍、一段话

5、列表类型list([iterable])

定义：在[ ]内用逗号分隔开多个元素，元素可以是任意数据类型。列表是有序的。

l = [111,3.1,"abc123",['xxx','yyy',[333,444]]]  # 相当于l=list(...)
# 取到333
print(l[-1][-1][0])

作用: 按照索引/顺序存放多个值。存储大量信息。

6、字典类型dict（）

定义：在{}内用逗号分隔开多个key：value，其中value可以是任意类型，而key是不可变类型。通常是字符串。

• 字典在3.5版本之前（包括3.5）是无序的

• 字典在3.6版本会按照初次建立字典的顺序排列，在学术上不认为是有序的

• 字典在3.7以后都是有序的。

info = {
     "name":"egon",
     "age":18,
     "gender":"male",
     "annual_salary":18,
     "level":10
}
print(info)
print(info["age"])

作用：按照属性名存放多个值，key：value组合。也能记录大量信息，效率比列表更高，以空间换时间。

字典类型和列表类型都支持嵌套。

7、布尔类型bool

定义：总共就两个值True、False。用来表示逻辑上的真假。

显式布尔值：直接能看到的bool值

x = True
print(type(x))
# <class 'bool'>

print(10 > 9)
# True

隐式bool值，所有的数据类型都可以转换成bool值，都可以当做隐式的布尔值去用。

# 只有以下数据转换bool值为False，其他都为True
'', 0, {}, (), [], set(), None
''引号里面什么都没有,哪怕有个空格都为True

作用：通常会作为条件。

8、集合set([iterable])

set 对象是由具有唯一性的不可变数据类型对象所组成的无序多项集。

常见的用途包括成员检测、从序列中去除重复项以及数学中的集合类计算，例如交集、并集、差集与对称差集等等。集合也支持 x in set, len(set) 和 for x in set。

作为一种无序的多项集，集合并不记录元素位置或插入顺序。集合不支持索引、切片或其他序列类的操作。

常用作去重：

s = {2, 5, 6, 3, 'a', 5, 'b', 'a'}
print(s)
{'b', 2, 3, 5, 6, 'a'}

创建空集合：

# 不能直接写s = {}，这样创建的是一个字典。
# 可以使用set()函数制造空集合。
s = set()

9、元组tuple([iterable])

构造器将构造一个元组，其中的项与 iterable 中的项具有相同的值与顺序。 iterable 可以是序列、支持迭代的容器或其他可迭代对象。 如果 iterable 已经是一个元组，会不加改变地将其返回。 例如，tuple('abc') 返回 ('a', 'b', 'c') 而 tuple( [1, 2, 3] ) 返回 (1, 2, 3)。 如果没有给出参数，构造器将创建一个空元组 ()。

• 使用一对圆括号来表示空元组: ()

  t = ()
  print(t, type(t))
  () <class 'tuple'>
  

• 使用一个后缀的逗号来表示单元组: a, 或 (a,)

  t = 'abc',
  print(t, type(t))
  ('abc',) <class 'tuple'>
  

• 使用以逗号分隔的多个项: a, b, c or (a, b, c)

  t = 'a', 'b', 'c'
  print(t, type(t))
  ('a', 'b', 'c') <class 'tuple'>
  

• 使用内置的 tuple(): tuple() 或 tuple(iterable)

  t = tuple('abc')
  print(t, type(t))
  ('a', 'b', 'c') <class 'tuple'>
  
  t = tuple(range(5))
  (0, 1, 2, 3, 4) <class 'tuple'>
  

决定生成元组的其实是逗号而不是圆括号。 圆括号只是可选的，生成空元组或需要避免语法歧义的情况除外。 例如，f(a, b, c) 是在调用函数时附带三个参数，而 f((a, b, c)) 则是在调用函数时附带一个三元组。

可变数据类型

值改变的情况下，内存地址/id不变，证明改变的是原值，即可变类型。也称不可哈希hash类型。内置可变数据类型有：

list、dict、set、

l = list('abc')
print(id(l))
l.append('d')
print(id(l))
41519232
41519232

不可变数据类型

值改变的情况下，内存地址也变，证明产生了新的值，即原值不可变。也称可哈希hash类型。内置不可变数据类型有：

str、int、float、tuple、bool、None

s = 'abc'
print(id(s))
s = 'abc' + 'bcd'
print(id(s))
38778928
38860592

i = 123456
print(id(i))
i = 123456 + 789
print(id(i))
32221872
32221936

与用户交互

接收用户输入：input（）函数

# 格式
var = input("用户提示信息")

input（）会将接收的输入内容都转换为字符串赋值给变量名。

向屏幕输入：print（）函数

# print函数默认结束符为换行符\n,打印完一行就会换行,可以指定为其他结束符
print(self, *args, sep=' ', end='\n', file=None)
print("输出内容1",end='哈哈哈')
print("输出内容2")
# 输出内容1哈哈哈输出内容2

input()和print()就是接收用户输入和向用户输出信息的两个函数，它俩配合能起到一个与用户交互的目的。

格式化输出：

当字符串中想让某些位置变成可动态传入的，首先要考虑到格式化输出。

百分号%

使用%进行格式化输出是Python一直都存在的，但效率不高，还有另外的格式化方法。

#例：制作一个公共的模板，让一个字符串的某些位置变成动态可传入的
name = 'libai'
age = 18.8
job = 'worker'
hobby = 'drink'

msg = '''---------- info of %s ----------
Name  : %s
Age   : %d
Job   : %s
Hobbie: %s
---------- END ----------''' % (name,name,age,job,hobby)

print(msg)

---------- info of libai ----------
Name  : libai
Age   : 18				# 接收的浮点型,会去尾转成整型.
Job   : worker
Hobbie: drink
---------- END ----------

% 表示占位符， d 表示接收的数据类型只能为整型，s 接收的数据类型既可以是字符串也可以是数字。

若仅显示百分号%：使用两个%%

str.format()

执行字符串格式化操作。 调用此方法的字符串可以包含字符串字面值或者以花括号 {} 括起来的替换域。 每个替换域可以包含一个位置参数的数字索引，或者一个关键字参数的名称。

简单替换

# 使用空{}输入位置参数
s = 'my name is {},my age is {}'.format('libai',18)
print(s)
my name is libai,my age is 18

# 按位置使用参数
s = 'my name is {1},my age is {0}'.format('libai',18)
print(s)
my name is 18,my age is libai

# 使用{var}关键字参数
s = 'my name is {name},my age is {age}'.format(age='libai', name=18)
print(s)
my name is 18,my age is libai

对齐

符号	含义
<	左对齐
>	右对齐
^	居中对齐
*	指定填充字符，不指定则为空白

左对齐。

1表示位置参数。*表示填充符，默认为空白字符，可以使用其他字符。10表示格式化字符串长度，不够则用填充符填充。

print('my name is {1:*<10}'.format('libai'，18))
my name is libai*****

居中对齐。

print('my name is {2:=^20}'.format('libai',18,'sushi'))
my name is =======sushi========

*列表解压为位置参数。

l = ['libai', 18]
print('my name is {},my age is {}'.format(*l))
my name is libai,my age is 18

**字典解压为关键字参数。

info = {'age': 18,'name':'libai'}
print('my name is {name},my age is {age}'.format(**info))
my name is libai,my age is 18

进制。

# b表示2进制
s = 'my age is {:b}'.format(18)
print(s)
my age is 10010

# o表示8进制
s = 'my age is {:o}'.format(18)
print(s)
my age is 22

# x表示十六进制,小写a-f。大写X表示大写A-F。
s = 'my age is {:x}'.format(30)
print(s)
my age is 1e

# d表示十进制。
s = 'my age is {:d}'.format(0b1010)
print(s)
my age is 10

精度。

# 千分制显示
s = 'my age is {:,}'.format(188132456)
print(s)
my age is 188,132,456

# 四舍五入保留3位小数
s = 'my age is {:.3f}'.format(18.8135)
print(s)

# 对于字符串，精度指定最大字段宽度。
s = 'my age is {:.3}'.format('啊啊啊啊啊啊')
print(s)
my age is 啊啊啊

f-string

f-string，亦称为格式化字符串常量（formatted string literals），是Python3.6新引入的一种字符串格式化方法，该方法源于PEP 498 – Literal String Interpolation，主要目的是使格式化字符串的操作更加简便。f-string在形式上是以 f 或 F 修饰符引领的字符串（f'xxx' 或 F'xxx'），以大括号 {} 标明被替换的字段；f-string在本质上并不是字符串常量，而是一个在运行时运算求值的表达式：

While other string literals always have a constant value, formatted strings are really expressions evaluated at run time.
（与具有恒定值的其它字符串常量不同，格式化字符串实际上是运行时运算求值的表达式。）
—— Python Documentation

f-string在功能方面不逊于传统的%-formatting语句和str.format()函数，同时性能又优于二者，且使用起来也更加简洁明了，因此对于Python3.6及以后的版本，推荐使用f-string进行字符串格式化。

简单使用

f-string用大括号 {} 表示被替换字段，其中直接填入替换内容：

name = 'libai'
s = f'my name is {name}'
print(s)
my name is libai

表达式求值

花括号 {}内 可以填入表达式或调用函数，Python会求出其结果并填入返回的字符串内：

s = f'my age is {(10 * 2) - (1 + 1)}'
print(s)
my age is 18

大括号外的引号还可以使用 \ 转义，但大括号内不能使用 \ 转义：

s = f'libai say {"I\'m libai"}'
print(s)
SyntaxError: f-string expression part cannot include a backslash

f-string大括号外如果需要显示大括号，则应输入连续两个大括号 {{ 和 }}：

s = f'my name is {{name}}'
print(s)
my name is {name}

参考文档：

https://docs.python.org/zh-cn/3/library/stdtypes.html#textseq

https://blog.csdn.net/sunxb10/article/details/81036693