- A+
这篇文章介绍了Python中的基本数据类型,文中通过示例代码介绍的非常详细。对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
一、数据类型分类
1、按存值个数区分
- 单个值:数字,字符串
- 多个值(容器):列表,元组,字典,集合
2、按可变不可变区分
- 可变:列表[],字典{},集合{}
- 不可变:数字,字符串,元组()、bool,None
3、有序无序区分
- 有序(可按索引取值):字符串,列表,元组
- 无序:字典,集合
二、整型(int)
1
2
3
4
|
age = 18 # age=int(18) print ( id (age)) #<code>4530100848</code> print ( type (age)) #<class 'int'> print (age) #18 |
1、四种进制表示形式
- 十进制:1010, 99, -217
- 二进制,以0b或0B开头:0b010, -0B101
- 八进制,以0o或0O开头:0o123, -0O456
- 十六进制,以0x或0X开头:0x9a, –0X89
我们可以使用二进制、十六进制和八进制来代表整数
1
2
3
4
5
6
7
8
9
10
11
|
number = 0b101011 # 二进制 print (number) # 43 number = 0xA0F # 十六进制 print (number) # 2575 number = 0o37 # 八进制 print (number) # 31 |
2、int()方法
可将纯数字的字符串转为十进制的整型
int(x):将x变成整数,舍弃小数部分。
1
2
3
4
5
|
print ( int ( "123" )) # 123 x = int ( '111' ) print ( type (x)) # <class 'int'> # print( int('11.1') ) # 报错 print ( int ( 123.45 )) # 123 |
3、type和isinstance
内置的type()函数可以用来查询变量所指的对象类型。
1
2
3
|
a, b, c, d = 20 , 5.5 , True , 4 + 3j print ( type (a), type (b), type (c), type (d)) # <class 'int'> <class 'float'> <class 'bool'> <class 'complex'> |
此外还可以用isinstance来判断:
1
2
3
|
a = 111 isinstance (a, int ) # True |
type和isinstance的区别在于:
- type()不会认为子类是一种父类类型。
- isinstance()会认为子类是一种父类类型。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class A: pass class B(A): pass isinstance (A(), A) # True type (A()) = = A # True isinstance (B(), A) # True type (B()) = = A # False |
4、对象的创建和删除
当你指定一个值时,Number对象就会被创建:
1
2
3
|
var = 2 var_a = var_b = 10 |
您可以通过使用del语句删除单个或多个对象。
del语句的语法是:
del var1[, var2[, var3[...., varN]]]
例如:
1
2
3
|
del var del var_a, var_b print (var) # name 'var' is not defined |
4、在交互模式中,最后被输出的表达式结果被赋值给变量 _
例如:
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06
此处, _ 变量应被用户视为只读变量。
5、注意:
- Python可以同时为多个变量赋值,如a, b = 1, 2。
- 一个变量可以通过赋值指向不同类型的对象。
- 数值的除法包含两个运算符:/ 返回一个浮点数,// 返回一个整数。
- Python 可以使用 ** 操作来进行幂运算:5 ** 2 表示 5 的平方
- 在混合计算时,Python会把整型转换成为浮点数。
注意第3点:// 得到的并不一定是整数类型的数,它与分母分子的数据类型有关系。
1
2
3
4
5
6
|
print ( 7 / / 2 ) # 3 print ( 7.0 / / 2 ) # 3.0 print ( 7 / / 2.0 ) # 3.0 |
三、浮点型(float)
1
2
3
4
5
|
salary = 2.1 # salary=float(2.1) print ( id (salary)) #<code>4569240656 </code> print ( type (salary)) #<code><class 'float'> </code> print (salary) # <code>2.1 |
1、float()方法
将纯数字的字符串转为浮点型数字。
float(x):将x变成浮点数,增加小数部分。
1
2
3
4
5
6
7
8
9
10
11
|
print ( float ( "1.23" )) # 1.23 x = float ( '111' ) print (x) # 111.0 print ( type (x)) # <class 'float'> x = float ( '11.1' ) print (x) # 11.1 print ( type (x)) # <class 'float'> print ( float ( 12 )) # 12.0; |
2、round()函数
1.浮点数间运算存在不确定尾数,一般发生在10的16次幂左右
2.round(x, d)函数:对x四舍五入,d是小数截取位数
3.浮点数间运算及比较,用round()函数辅助
1
|
0.1 + 0.2 = = 0.3 # False |
round(0.1+0.2, 1) == 0.3 # True
3、科学计数法
- 使用字母e或E作为幂的符号,以10为基数,
格式如下:<a>e<b>
,表示a*10b
- 例如:
4.3e-3
值为0.0043
,9.6E5
值为960000.0
4、数字运算函数
abs(x):绝对值。x的绝对值。
1
|
print ( abs ( - 10.01 )) # 10.01 |
divmod(x,y):商余。(x//y, x%y),同时输出商和余数。
1
|
print ( divmod ( 10 , 3 )) # (3, 1) |
pow(x, y[, z]):幂余。(x**y)%z,[..]表示参数z可省略。
1
2
3
4
|
print ( pow ( 3 , 2 )) # 9 print ( pow ( 3 , 2 , 2 )) # 1 print ( pow ( 3 , pow ( 3 , 2 ))) # 19683 print ( pow ( 3 , pow ( 3 , 2 ), 10000 )) # 9683 |
round(x[, d]):四舍五入。d是保留小数位数,默认值为0。
1
|
print ( round ( - 10.123 , 2 )) # -10.12 |
max(x1,x2,⋯,xn):最大值。返回x1,x2,⋯,xnx1,x2,⋯,xn中的最大值,n不限。
1
|
print ( max ( 1 , 9 , 5 , 4 , 3 )) # 9 |
min(x1,x2,⋯,xn):最小值。返回x1,x2,⋯,xnx1,x2,⋯,xn中的最小值,n不限。
1
|
print ( min ( 1 , 9 , 5 , 4 , 3 )) # 1 |
以下为数学函数,需要导入math模块
exp(x):返回e的x次幂(ex)
1
2
|
import math print (math.exp( 1 )) # 2.718281828459045 |
fabs(x):返回数字的绝对值
1
2
|
import math print (math.fabs( - 10 )) # 10.0 |
ceil(x):返回数字的上入整数
1
2
|
import math print (math.ceil( 4.1 )) # 5 |
floor(x): 返回数字的下舍整数
1
2
|
import math print (math.floor( 4.9 )) # 4 |
log(x):返回以e为基数的对象
1
2
3
4
|
import math print (math.log(math.e)) # 1.0 print (math.log( 100 , 10 )) # 2.0 |
log10(x): 返回以10为基数的x的对数
1
2
3
|
import math print (math.log10( 100 )) # 2.0 |
modf(x):返回x的整数部分与小数部分,两部分的数值符号与x相同,整数部分以浮点型表示。
1
2
|
import math print (math.modf( - 100.1 )) # (-0.09999999999999432, -100.0) |
sqrt(x):返回数字x的平方根。
1
2
|
import math print (math.sqrt( 81 )) # 9.0 |
四、复数型(complex)
a+bj
被称为复数,其中,a是实部,b是虚部
- real 获得实部
- imag 获得虚部
1
2
3
|
z = 1.23e - 4 + 5.6e + 89j print (z.real) # 0.000123 print (z.imag) # 5.6e+89 |
1、complex(x):将x变成复数
- complex(x) 将x转换到一个复数,实数部分为 x,虚数部分为 0。
- complex(x, y) 将 x 和 y 转换到一个复数,实数部分为 x,虚数部分为 y。x 和 y 是数字表达式。
1
|
print ( complex ( 4 )) # (4+0j) |
五、布尔型(Bool)
True、False通常情况不会直接引用,需要使用逻辑运算得到结果。
1
2
|
print ( type ( True )) # <code><class 'bool'></code> print ( True ) # True |
注意:Python中所有数据类型的值自带布尔值。
如此多的数据类型中只需要记住只有0、None、空、False的布尔值为False,其余的为True。
1
2
3
4
5
6
7
8
|
print ( bool ( 0 )) # False print ( bool ( None )) # False print ( bool ('')) # False print ( bool ( False )) # False print ( bool ( 'nick' )) # True print ( bool ( 1 > 2 )) # False print ( bool ( 1 = = 1 )) # True |
六、字符串(str)
字符串就是一串被串起来的字符,在单引号、双引号或三引号内包裹的一串字符。同时使用反斜杠 \ 转义特殊字符。
1
2
3
4
5
|
name1 = 'nick' name2 = "egon" print ( id (name1)) # <code>4418849624</code> print ( type (name1)) # <class 'str'> print (name1) # nick |
需要注意的是:三引号内的字符可以换行,而单双引号内的字符不可以。
1
|
name3 = """nick |
egon"""
1
|
print (name3) |
1
2
|
nick egon |
1、特殊字符串:
- u'unicode': unicode编码的字符串
- b'101': 二进制编码的字符串
转义符:
Python 使用反斜杠(\)转义特殊字符。
1
|
print ( "这里有个双引号(\")" ) # 这里有个双引号(") |
转义符形成一些组合,表达一些不可打印的含义:
\(在行尾时) :续行符
\\ :反斜杠符号
\' :单引号
\" :双引号
\a :响铃
\b :退格(Backspace)
\000 :空
\n :换行
\v :纵向制表符
\t :横向制表符
\r :回车(光标移动到本行首)
\f :换页
\oyy :八进制数,yy 代表的字符,例如:\o12 代表换行,其中 o 是字母,不是数字 0。
\xyy :十六进制数,yy代表的字符,例如:\x0a代表换行
\other :其它的字符以普通格式输出
- r'\n': 原生字符串,也就是说'\n'这是普通的两个字符,并没有换行的意思。
Python 使用反斜杠(\)转义特殊字符,如果你不想让反斜杠发生转义,可以在字符串前面添加一个 r,表示原始字符串:
1
2
3
4
5
6
|
print ( 'Ru\noob' ) # Ru # oob print (r 'Ru\noob' ) # Ru\noob |
注意:
- Python 没有单独的字符类型,一个字符就是长度为1的字符串。
- 反斜杠(\)可以作为续行符,表示下一行是上一行的延续。
- Python中的字符串有两种索引方式,从左往右以0开始,从右往左以-1开始。
- Python中的字符串不能改变,向一个索引位置赋值,比如word[0] = 'm'会导致错误。
2、字符串连接:x+y
连接两个字符串x和y。如果字符串内有引号,则包裹字符串的引号和字符串内部的引号不能相同。
1
2
3
4
|
msg2 = "my name is 'nick'" msg3 = 'my name is "nick"' print (msg2 + msg3) # my name is 'nick'my name is "nick" |
3、字符串重复:x * n
只能乘以数字。
1
2
|
name = 'nick ' print (name * 10 ) # <code>nick nick nick nick nick nick nick nick nick nick |
4、字符串比较大小:x>y
按照ASCII码比较.字符串的比较是字母的顺序。
1
2
3
4
5
|
msg1 = 'hello' msg2 = 'z' print (msg1 > msg2) #False print ( 'Z' > 'A' ) #True print ( 'Z' > 'a' ) #False |
5、可以使用str()、hex()、chr()、ord()方法转为特殊字符串。
str(x):任意类型x所对应的字符串形式
1
2
|
print ( str ( 1.23 )) # “1.23” print ( str ([ 1 , 2 ])) # “[1, 2]” |
hex(x) 或 oct(x):整数x的十六进制或八进制小写形式字符串:
1
2
|
print ( hex ( 425 )) # "0x1a9" print ( oct ( 425 )) # "0o651" |
chr(u):x为Unicode编码,返回其对应的字符
ord(x):x为字符,返回其对应的Unicode编码
1
2
|
print ( chr ( 21704 )) # "哈" print ( ord ( '哈' )) # "21704" |
6、常用函数:
1、str[n]:按索引取值
1
2
3
4
|
你可以截取字符串的一部分并与其他字段拼接,如下实例:
1
2
|
var1 = 'Hello World!' print ( "已更新字符串 : " , var1[: 6 ] + 'Runoob!' ) # 已更新字符串 : Hello Runoob! |
举例:输入整数对应的星期字符串
1
2
3
|
weekStr = "一二三四五六日" weekId = eval ( input ( "请输入星期数字(1-7):" )) print ( "星期" + weekStr[weekId - 1 ]) # 7 星期日 |
2、str[x:y:step]:切片(顾头不顾尾,步长) :
遵循左闭右开原则,str[0,2] 是不包含第 3 个字符的。
1
2
3
4
5
6
7
8
9
10
11
12
|
msg = 'hello_nick' # 0123456789 # 索引序号 print (msg[ 3 :] ) # 切片3-最后: lo_nick print (msg[ 3 : 8 ]) # 切片3-8: lo_ni print (msg[ 3 : 8 : 2 ] ) # 切片3-8,步长为2: l_i print (msg[ 3 :: 2 ]) # 切片3-最后,步长为2: l_ik # 了解,步长为正,从左到右;步长为负,从右到左 print (msg[:]) # 切片所有: hello_nick print (msg[:: - 1 ] ) # 反转所有: kcin_olleh print (msg[ - 5 : - 2 : 1 ] ) # 切片-5--2: _ni print (msg[ - 2 : - 5 : - 1 ] ) # 切片-2--5: cin |
3、len:长度
1
2
|
msg = 'hello nick嗯' print ( len (msg)) # 11 |
4、in、not in:成员运算
1
2
3
4
5
|
msg = 'my name is nick, nick handsome' print ( 'nick' in msg) # True print ( 'jason' not in msg) # True print ( not 'jason' in msg) # True |
5、移除空白
- 移除左右空白:strip(chars)
- 移除左空白: lstrip(chars)
- 移除右空白:rstrip(chars)
1
2
3
4
5
|
name = '&&&n ick ' print (name.strip()) # &&&n ick,注意 strip()默认为‘ ' print (name.strip( '&' )) # n ick ,strip并且不修改原值,新创建空间 print (name) # name: &&&n ick , print ( '*-& nick+' .strip( '*-& +' )) # nick |
6、拆分,split,返回一个列表
- 拆分:split(str="", num=string.count(str)):以 str 为分隔符截取字符串,如果 num 有指定值,则仅截取 num+1 个子字符串,返回一个列表;
- 右拆分:rsplit
1
2
3
4
|
info = 'nick:male:19' info_list1 = info.split( ':' ) # ['nick', 'male', '19'] info_list2 = info.split( ':' , 1 ) # ['nick', 'male:19'] print (info.rsplit( ':' , 1 )) # ['nick:male', '19']。 从右开始切割 |
- 拆分行:splitlines([keepends]):按照行('\r', '\r\n', \n')分隔,返回一个包含各行作为元素的列表,如果参数 keepends 为 False,不包含换行符,如果为 True,则保留换行符。
1
2
3
4
5
6
|
info = """aaa bbb ccc """ print (info.splitlines()) # ['aaa', 'bbb', 'ccc'] print (info.splitlines( True )) # ['aaa\n', 'bbb\n', 'ccc\n'] |
7、for循环
1
2
|
msg = 'hello nick' for i in msg: print (i) # 一个一个字符打印出来 |
8、大小写,返回字符串的副本
- lower:转成小写
- upper:转成小写
1
2
3
|
name = 'Nick Chen' print (name.lower()) # nick chen print (name.upper()) # NICK CHEN |
- captalize:将字符串的第一个字符转换为大写
- swapcase:将字符串中大写转换为小写,小写转换为大写
- title:返回"标题化"的字符串,就是说所有单词都是以大写开始,其余字母均为小写(见 istitle())
1
2
3
4
|
name = 'nick handsome sWAPCASE' print (name.capitalize()) # Nick handsome swapcase print (name.swapcase()) # NICK HANDSOME Swapcase 大小写互转 print (name.title()) # Nick Handsome Swapcase |
9、首末字符判断
- startswith:首字符判断
- endswith:末字符判断
1
2
3
|
name = 'Nick Chen' print (name.startswith( 'Nick' )) # True print (name.endswith( 'chen' )) # False |
10、join(seq):以此字符串作为分隔符,连接字符串。
以指定字符串作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
1
2
3
4
5
6
7
|
lis = [ 'nick' , 'male' , '19' ] print ( ':' .join(lis)) # nick:male:19 print ( "," .join( "12345" )) # 1,2,3,4,5 str = "-" seq = ( "a" , "b" , "c" ) # 字符串元组 print ( str .join(seq)) # a-b-c |
11、替换:replace
replace(old, new [, max]):把 将字符串中的 str1 替换成 str2,如果 max 指定,则替换不超过 max 次。
12、is***:数据类型判断
1
2
|
salary = '111.1' print (salary.isdigit()) # False |
- isdecimal(): 检查字符串是否值包含十进制字符,如果是返回True,否则返回False。
- isdigit(): 如果字符串只包含数字则返回True,否则返回False。
- isnumeric(): 如果字符串中只包含数字字符,则返回True,否则返回False。
- isalnum(): 如果字符串所有字符都是字母或数字则返回True,否则返回False。
- isalpha(): 如果字符串所有字符都是字母则返回True,否则返回False。
- isupper(): 如果字符串中(区分大小写的)字符都是大写,则返回True,否则返回False。
- islower(): 如果字符串中(区分大小写的)字符都是小写,则返回True,否则返回False。
- isspace(): 如果字符串中只包含空白,则返回True,否则返回False
- istitle(): 如果字符串是标题类型的(见title()),则返回True,否则返回False。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
num = "1" # unicode num.isdigit() # True num.isdecimal() # True num.isnumeric() # True num = "1" # 全角 num.isdigit() # True num.isdecimal() # True num.isnumeric() # True num = b "1" # byte num.isdigit() # True num.isdecimal() # 属性错误 'bytes' object has no attribute 'isdecimal' num.isnumeric() # 属性错误 'bytes' object has no attribute 'isnumeric' num = "IV" # 罗马数字 num.isdigit() # True num.isdecimal() # False num.isnumeric() # True num = "四" # 汉字 num.isdigit() # False num.isdecimal() # False num.isnumeric() # True |
13、unicodeData
- 1.unicodedata.lookup():通过索引中的名称查找相应的字符
- 2.unicodedata.name():通过字符查找名称,与unicodedata.lookup()相反
- 4.unicodedata.digit():把一个合法的数字字符串转换为数字值
- 3.unicodedata.decimal():返回表示数字字符的数值
- 5.unicodedata.numeric():把一个表示数字的字符串转换为浮点数返回,与unicodedata.digit()不同的是:它可以任意表示数值的字符都可以,不仅仅限于0到9的字符
- 6.unicodedata.category():把一个字符返回它在UNICODE里分类的类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
import unicodedata unicodedata.digit( "2" ) # 2 unicodedata.decimal( "2" ) # 2 unicodedata.numeric( "2" ) # 2.0 unicodedata.digit( "2" ) # 2 unicodedata.decimal( "2" ) # 2 unicodedata.numeric( "2" ) # 2.0 unicodedata.digit(b "3" ) # TypeError: must be str, not bytes unicodedata.decimal(b "3" ) # TypeError: must be str, not bytes unicodedata.numeric(b "3" ) # TypeError: must be str, not bytes unicodedata.digit( "Ⅷ" ) # ValueError: not a digit unicodedata.decimal( "Ⅷ" ) # ValueError: not a decimal |
unicodedata.numeric("Ⅷ") # 8.0
1
2
|
unicodedata.digit( "四" ) # ValueError: not a digit unicodedata.decimal( "四" ) # ValueError: not a decimal |
unicodedata.numeric("四") # 4.0
14、查找:find、 index
- find(str, beg=0, end=len(string)):检测 str 是否包含在字符串中。如果指定范围 beg 和 end ,则检查是否包含在指定范围内,如果包含返回开始的索引值,否则返回-1。
- rfind(str, beg=0,end=len(string)):类似于 find()函数,不过是从右边开始查找
- index(str, beg=0, end=len(string)):跟find()方法一样,只不过如果str不在字符串中会报一个异常
- rindex:类似于 index(),不过是从右边开始
- count(str, beg= 0,end=len(string)):返回 str 在 string 里面出现的次数,如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
1
2
3
4
5
6
7
|
msg = 'my name is tank, tank shi sb, hha' print (msg.find( 'tank' )) # 11 print (msg.find( 'tank' , 0 , 3 )) # -1,找不到返回-1 print (msg.rfind( 'tank' )) # 17,找不到返回-1 print (msg.index( 'tank' )) # 11.找不到报错 print (msg.rindex( 'tank' )) # 17 找不到报错 print (msg.count( 'tank' )) # 2 |
15、填充
- center(width[, fillchar]):返回一个原字符串居中对齐,并使用 fillchar 填充至长度。width 的新字符串,fillchar 默认为空格。
- ljust(width[, fillchar]):返回一个原字符串左对齐,并使用 fillchar 填充至长度。
- rjust(width[, fillchar]):返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。
- zfill(width):返回长度为 width 的字符串,原字符串 string 右对齐,前面填充0。
1
2
3
4
|
print ( 'info nick' .center( 20 , '*' )) # *****info nick****** print ( 'info nick' .ljust( 20 , '*' )) # info nick*********** print ( 'info nick' .rjust( 20 , '*' )) # ***********info nick print ( 'info nick' .zfill( 20 )) # 00000000000info nick, 默认用0填充 |
16、expandtabs(tabsize=8):把字符串中的 tab 符号转为空格
tab 符号默认的空格数是 8 。
1
2
|
print ( 'a\tb\tc\t' ) # a b c ,默认制表符8个空格 print ( 'a\tb\tc\t' .expandtabs( 10 )) # a b c . |
17、encode、decode:字符编码解码
Python3中字符串默认为Unicode编码。
str类型的数据可以编码成其他字符编码的格式,编码的结果为bytes类型。
1
2
3
4
5
6
7
|
# coding:gbk x = '上' # 当程序执行时,无需加u,'上'也会被以Unicode形式保存新的内存空间中, print ( type (x)) # <class 'str'> # x可以直接encode成任意编码格式 print (x.encode( 'gbk' )) # b'\xc9\xcf' print ( type (x.encode( 'gbk' ))) # <class 'bytes'> |
- str.encode(encoding='UTF-8',errors='strict'):以 encoding 指定的编码格式编码字符串,如果出错默认报一个ValueError 的异常,除非 errors 指定的是'ignore'或者'replace'
- bytes.decode(encoding="utf-8", errors="strict"):解码给定的 bytes 对象,这个 bytes 对象可以由 str.encode() 来编码返回。
1
2
3
4
5
6
7
8
|
a = "asdfasdfffsa师德师风的" b = a.encode(encoding = 'UTF-8' , errors = 'strict' ) print ( type (b)) # <class 'bytes'> print (b) # b'asdfasdfffsa\xe5\xb8\x88\xe5\xbe\xb7\xe5\xb8\x88\xe9\xa3\x8e\xe7\x9a\x84' c = b.decode(encoding = "utf-8" , errors = "strict" ) print ( type (c)) # <class 'str'> print (c) # asdfasdfffsa师德师风的 |
18、字符串与列表,元组的互相转换。
1、字符串转换为列表:for循环
1
2
3
|
2、列表转化为字符串:使用 join 来实现:
1
|
var1 = ' ,' .join( list ) |
3、字符串转化为元组,使用 tuple() 函数。
1
|
tup = tuple (var) |
七、其他数据类型
1、分数类型:Fraction
构造函数:
- class fractions.Fraction(numerator=0, denominator=1)
- class fractions.Fraction(int|float|str|Decimal|Fraction)
可以同时提供分子(numerator)和分母(denominator)给构造函数用于实例化Fraction类,但两者必须同时是int类型或者numbers.Rational类型,否则会抛出类型错误。当分母为0,初始化的时候会导致抛出异常ZeroDivisionError。
分数类型:
1
2
3
4
5
6
7
8
|
from fractions import Fraction x = Fraction( 1 , 3 ) y = Fraction( 4 , 6 ) print (x + y) # 1 print ( 1 / 3 + 4 / 6 ) # 1.0 print (Fraction( '.25' )) # 1/4 |
浮点数与分数的转换:
1
2
3
4
5
6
7
8
|
from fractions import Fraction f = 2.5 z = Fraction( * f.as_integer_ratio()) print (z) # 5/2 x = Fraction( 1 , 3 ) print ( float (x)) # 0.3333333333333333 |
2、小数:Decimal类型
decimal 模块提供了一个 Decimal 数据类型用于浮点数计算,拥有更高的精度。
1
2
3
4
5
6
7
8
|
import decimal decimal.localcontext().prec = 4 # 指定精度(4位小数) print (decimal.Decimal( 1 ) / decimal.Decimal( 7 )) # 0.1429 with decimal.localcontext() as ctx: # 小数上下文管理器 ctx.prec = 2 print (decimal.Decimal( '1.00' ) / decimal.Decimal( '3.00' )) # 0.33 |
到此这篇关于Python数据类型的文章就介绍到这了。希望对大家的学习有所帮助
历史上的今天:
- 2023: ps厚涂笔刷怎么设置?
- 2023: ps修补工具拖动没反应怎么解决?
- 2023: 如何把证件照使用ps白底换蓝底
- 2023: ps调色预设步骤有哪些?
- 2023: ps色彩平衡在哪?怎么使用?
- 优惠折扣福利
- 这是我的微信扫一扫
-
- 我的微信公众号
- 我的微信公众号扫一扫
-