简单介绍python中的数据类型,python常用的基本数据类型

　　本文介绍了Python中的基本数据类型，通过示例代码非常详细。对大家的学习或者工作都有一定的参考价值，有需要的朋友可以参考一下。

一、数据类型分类

1、按存值个数区分

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

2、按可变不可变区分

　　可变:列表[]，字典{}，集合{ }不可变:数，字符串，元组()，布尔值，无

3、有序无序区分

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

二、整型(int)

　　age=18 # age=int(18)

　　打印(身份证(年龄))#代码4530100848/代码

　　print(type(age))#class int

　　印刷(年龄)#18

1、四种进制表示形式

　　十进制：1010，99，-217二进制，以0b或0B开头：0b010，-0B101八进制，以0o或0O开头：0o123，-0O456十六进制，以0x或0X开头：0x9a，-0X89我们可以用二进制，十六进制和八进制来

　　Number=0b101011 #二进制

　　打印(数字)

　　# 43

　　Number=0xA0F #十六进制

　　打印(数字)

　　# 2575

　　Number=0o37 #八进制

　　打印(数字)

　　# 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，真，4 3j

　　打印(类型(a)，类型(b)，类型(c)，类型(d))

　　# class int class float class bool class complex

　　另外，也可以通过isinstance来判断：

　　a=111

　　isinstance(a，int)

　　#真的

　　type和isinstance的区别在于：

　　Type()不认为子类是父类类型。Isinstance()将子类视为父类类型。A:级

　　及格

　　B(A)类：

　　及格

　　isinstance(A()，A)

　　#真的

　　type(A())==A

　　#真的

　　isinstance(B()，A)

　　#真的

　　type(B())==A

　　#错误

4、对象的创建和删除

　　当您指定一个值时，将创建数字对象：

　　var=2

　　var_a=

　　var_b=10

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

　　del语句的语法是：

　　删除变量1[，变量2[，变量3[.varN]]]

　　例如：

　　德尔瓦尔

　　德尔var_a，var_b

　　print(var) # name var 未定义

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(rRu\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 nickmy 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) # basdfasdfffsa\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(intfloatstrDecimalFraction)

　　可以同时提供分子（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数据类型的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持盛行IT软件开发工作室。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。