Python中的基本数据类型讲解-偶像资源网

一、数据类型分类

1、按存值个数区分

单个值：数字，字符串
多个值(容器)：列表，元组，字典，集合

2、按可变不可变区分

可变：列表[]，字典{}，集合{}
不可变：数字，字符串，元组()、bool，None

3、有序无序区分

有序(可按索引取值)：字符串，列表，元组
无序：字典，集合

二、整型(int)

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

我们可以使用二进制、十六进制和八进制来代表整数

number = 0b101011 # 二进制
print(number)
# 43

number = 0xA0F # 十六进制
print(number)
# 2575

number = 0o37  # 八进制
print(number)
# 31

2、int()方法

可将纯数字的字符串转为十进制的整型

int(x):将x变成整数，舍弃小数部分。

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()函数可以用来查询变量所指的对象类型。

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来判断：

a = 111
isinstance(a, int)
# True

type和isinstance的区别在于：

type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。

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对象就会被创建：

var = 2
var_a = 
var_b = 10

您可以通过使用del语句删除单个或多个对象。

del语句的语法是：

del var1[, var2[, var3[…., varN]]]

例如：

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点：// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。

print(7 // 2)
# 3
print(7.0 // 2)
# 3.0
print(7 // 2.0)
# 3.0

三、浮点型(float)

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变成浮点数，增加小数部分。

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()函数辅助

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的绝对值。

print(abs(-10.01))  # 10.01

divmod(x,y)：商余。(x//y, x%y)，同时输出商和余数。

print(divmod(10, 3))  # (3, 1)

pow(x, y[, z]):幂余。(x**y)%z，[..]表示参数z可省略。

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。

print(round(-10.123, 2))  # -10.12

max(x1,x2,⋯,xn):最大值。返回x1,x2,⋯,xnx1,x2,⋯,xn中的最大值，n不限。

print(max(1, 9, 5, 4, 3))  # 9

min(x1,x2,⋯,xn):最小值。返回x1,x2,⋯,xnx1,x2,⋯,xn中的最小值，n不限。

print(min(1, 9, 5, 4, 3))  # 1

以下为数学函数，需要导入math模块

exp(x):返回e的x次幂(ex)

import math
print(math.exp(1))  # 2.718281828459045

fabs(x):返回数字的绝对值

import math
print(math.fabs(-10))  # 10.0

ceil(x):返回数字的上入整数

import math
print(math.ceil(4.1))  # 5

floor(x): 返回数字的下舍整数

import math
print(math.floor(4.9))  # 4

log(x):返回以e为基数的对象

import math

print(math.log(math.e))  # 1.0
print(math.log(100, 10))  # 2.0

log10(x): 返回以10为基数的x的对数

import math

print(math.log10(100))  # 2.0

modf(x):返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。

import math
print(math.modf(-100.1))  # (-0.09999999999999432, -100.0)

sqrt(x):返回数字x的平方根。

import math
print(math.sqrt(81))  # 9.0

四、复数型（complex）

a+bj 被称为复数，其中，a是实部，b是虚部

real 获得实部
imag 获得虚部

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 是数字表达式。

print(complex(4))  # (4+0j)

五、布尔型（Bool）

True、False通常情况不会直接引用，需要使用逻辑运算得到结果。

print(type(True))# <code><class \'bool\'></code>
print(True)# True

注意：Python中所有数据类型的值自带布尔值。

如此多的数据类型中只需要记住只有0、None、空、False的布尔值为False，其余的为True。

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)

字符串就是一串被串起来的字符，在单引号、双引号或三引号内包裹的一串字符。同时使用反斜杠 \\ 转义特殊字符。

name1 = \'nick\'
name2 = \"egon\"
print(id(name1)) # <code>4418849624</code>
print(type(name1))# <class \'str\'>
print(name1)# nick

需要注意的是：三引号内的字符可以换行，而单双引号内的字符不可以。

name3 = \"\"\"nick

egon"""

print(name3)

nick
egon

1、特殊字符串：

u'unicode': unicode编码的字符串
b'101': 二进制编码的字符串

转义符：

Python 使用反斜杠(\\)转义特殊字符。

print(\"这里有个双引号(\\\")\")  # 这里有个双引号(\")

转义符形成一些组合，表达一些不可打印的含义：
\\(在行尾时) ：续行符
\\\\ ：反斜杠符号
\\&; ：单引号
\\&; ：双引号
\\a ：响铃
\\b ：退格(Backspace)
\\000 ：空
\\n ：换行
\\v ：纵向制表符
\\t ：横向制表符
\\r ：回车(光标移动到本行首)
\\f ：换页
\\oyy ：八进制数，yy 代表的字符，例如：\\o12 代表换行，其中 o 是字母，不是数字 0。
\\xyy :十六进制数，yy代表的字符，例如：\\x0a代表换行
\\other :其它的字符以普通格式输出

r'\\n': 原生字符串，也就是说'\\n'这是普通的两个字符，并没有换行的意思。
Python 使用反斜杠(\\)转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

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。如果字符串内有引号，则包裹字符串的引号和字符串内部的引号不能相同。

msg2 = \"my name is \'nick\'\"
msg3 = \'my name is \"nick\"\'

print(msg2 + msg3)  # my name is \'nick\'my name is \"nick\"

3、字符串重复：x * n

只能乘以数字。

name = \'nick \'
print(name * 10)# <code>nick nick nick nick nick nick nick nick nick nick

4、字符串比较大小:x>y

按照ASCII码比较.字符串的比较是字母的顺序。

msg1 = \'hello\'
msg2 = \'z\'
print(msg1 > msg2) #False
print(\'Z\' > \'A\') #True
print(\'Z\' > \'a\') #False

5、可以使用str()、hex()、chr()、ord（）方法转为特殊字符串。

str(x)：任意类型x所对应的字符串形式

print(str(1.23))  # “1.23”
print(str([1, 2]))  # “[1, 2]”

hex(x) 或 oct(x)：整数x的十六进制或八进制小写形式字符串：

print(hex(425))  # \"0x1a9\"
print(oct(425))  # \"0o651\"

chr(u)：x为Unicode编码，返回其对应的字符

ord(x)：x为字符，返回其对应的Unicode编码

print(chr(21704))  # \"哈\"
print(ord(\'哈\'))  # \"21704\"

6、常用函数：

1、str[n]：按索引取值

msg = \'hello nick\'
#      0123456789  # 索引序号
print(msg[6] ) #索引为6: n
print(msg[-3]) # 索引为-3: i

你可以截取字符串的一部分并与其他字段拼接，如下实例：

var1 = \'Hello World!\'
print(\"已更新字符串 : \", var1[:6] + \'Runoob!\')  # 已更新字符串 :  Hello Runoob!

举例：输入整数对应的星期字符串

weekStr = \"一二三四五六日\"
weekId = eval(input(\"请输入星期数字(1-7)：\"))
print(\"星期\" + weekStr[weekId - 1])  # 7  星期日

2、str[x:y:step]：切片（顾头不顾尾，步长） :

遵循左闭右开原则，str[0,2] 是不包含第 3 个字符的。

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:长度

msg = \'hello nick嗯\'
print(len(msg)) # 11

4、in、not in:成员运算

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)

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

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，则保留换行符。

info = \"\"\"aaa
bbb
ccc
\"\"\"
print(info.splitlines())  # [\'aaa\', \'bbb\', \'ccc\']
print(info.splitlines(True))  # [\'aaa\\n\', \'bbb\\n\', \'ccc\\n\']

7、for循环

msg = \'hello nick\'
for i in msg: print(i) # 一个一个字符打印出来

8、大小写，返回字符串的副本

lower：转成小写
upper：转成小写

name = \'Nick Chen\'
print(name.lower())  # nick chen
print(name.upper())  # NICK CHEN

captalize：将字符串的第一个字符转换为大写
swapcase：将字符串中大写转换为小写，小写转换为大写
title：返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())

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：末字符判断

name = \'Nick Chen\'
print(name.startswith(\'Nick\'))  # True
print(name.endswith(\'chen\'))  # False

10、join(seq)：以此字符串作为分隔符，连接字符串。

以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

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 次。

name = \'nick shuai\'
print(name.replace(\'shuai\', \'handsome\'))  # nick handsome

12、is***：数据类型判断

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。

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里分类的类型

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

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 出现的次数

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。

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 。

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类型。

# 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() 来编码返回。

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循环

var=\'菜鸟教程\'
list=[]
list= [i for i in var]

2、列表转化为字符串：使用 join 来实现:

var1=\' ,\'.join(list)

3、字符串转化为元组，使用 tuple() 函数。

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。

分数类型：

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

浮点数与分数的转换：

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 数据类型用于浮点数计算，拥有更高的精度。

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数据类型的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持。

版权声明 1 本网站名称：偶像资源网
2 本站永久网址：https://www.ox520.com
3 本网站的文章部分内容可能来源于网络，仅供大家学习与参考，如有侵权，请联系站长 QQ593098775进行删除处理。
4 本站一切资源不代表本站立场，并不代表本站赞同其观点和对其真实性负责。
5 本站一律禁止以任何方式发布或转载任何违法的相关信息，访客发现请向站长举报
6 本站资源大多存储在云盘，如发现链接失效，请联系我们我们会第一时间更新。

THE END