8、Python简单数据类型（int、float、complex、bool、str）

时间：2023-03-10 02:46:59
8、Python简单数据类型（int、float、complex、bool、str）

一、数据类型分类

1、按存值个数区分

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

2、按可变不可变区分

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

3、有序无序区分

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

4、按访问类型区分

  • 直接访问：数字
  • 顺序访问(序列类型)：字符串，列表，元组
  • key值访问(映射类型)：字典

二、整型(int)

age = 18  # age=int(18)

print(id(age))#4530100848

print(type(age))#<class 'int'>

print(age)#18

1、int()方法将纯数字的字符串转为十进制的整型

int(x):将x变成整数，舍弃小数部分。
int(123.45) 结果为123；
int("123") 结果为123 

x = int('')

print(type(x)) #<class 'int'>

x = int('11.1')  # 报错

2、4种进制表示形式

  • 十进制：1010, 99, -217
  • 二进制，以0b或0B开头：0b010, -0B101
  • 八进制，以0o或0O开头：0o123, -0O456
  • 十六进制，以0x或0X开头：0x9a, –0X89

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

number = 0b101011 # 二进制

print(number)

#

number = 0xA0F # 十六进制

print(number)

#

number = 0o37  # 八进制

print(number)

#

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、注意：

  1. Python可以同时为多个变量赋值，如a, b = 1, 2。
  2. 一个变量可以通过赋值指向不同类型的对象。
  3. 数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
  4. Python 可以使用 ** 操作来进行幂运算：5 ** 2 表示 5 的平方
  5. 在混合计算时，Python会把整型转换成为浮点数。

注意：// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。

print(7 // 2)

#

print(7.0 // 2)

# 3.0

print(7 // 2.0)

# 3.0

三、浮点型(float)

salary = 2.1  # salary=float(2.1)

print(id(salary))#4569240656 

print(type(salary))#<class 'float'> 

print(salary)# 2.1

1、可以使用float()方法将纯数字的字符串转为浮点型数字。

float(x):将x变成浮点数，增加小数部分。
float(12) 结果为12.0；
float("1.23") 结果为1.23 

x = float(111')

print(x) #111.0

print(type(x)) #<class 'float'>

x = float('11.1')

print(type(x)) #<class 'float'>

2、浮点数间运算存在不确定尾数及round（）函数

  • 不确定尾数一般发生在10的16次幂左右

  • round(x, d)：对x四舍五入，d是小数截取位数
  • 浮点数间运算及比较用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的绝对值。
    abs(-10.01) 结果为 10.01
  • divmod(x,y)：商余。(x//y, x%y)，同时输出商和余数。
    divmod(10, 3) 结果为 (3, 1)
  • pow(x, y[, z]):幂余。(x**y)%z，[..]表示参数z可省略。 
    print(pow(3, 2))  #
    
print(pow(3, pow(3, 2)))  #
    
print(pow(3, pow(3, 2), 10000))  #
  • round(x[, d]):四舍五入。d是保留小数位数，默认值为0。
    round(-10.123, 2) 结果为 -10.12
  • max(x1,x2,⋯,xn):最大值。返回x1,x2,⋯,xnx1,x2,⋯,xn中的最大值，n不限。
    max(1, 9, 5, 4 3) 结果为 9
  • min(x1,x2,⋯,xn):最小值。返回x1,x2,⋯,xnx1,x2,⋯,xn中的最小值，n不限。
    min(1, 9, 5, 4 3) 结果为 1
  • exp(x):    返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
  • fabs(x):    返回数字的绝对值，如math.fabs(-10) 返回10.0
  • ceil(x):    返回数字的上入整数，如math.ceil(4.1) 返回 5。
  • floor(x):    返回数字的下舍整数，如math.floor(4.9)返回 4
  • log(x):    如math.log(math.e)返回1.0,math.log(100,10)返回2.0
  • log10(x):    返回以10为基数的x的对数，如math.log10(100)返回 2.0
  • modf(x):    返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
  • sqrt(x):    返回数字x的平方根。

四、复数型（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变成复数

  1. complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
  2. complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

complex(4) 结果为 4 + 0j

五、布尔型（Bool）

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

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

print(True)# True

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

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

print(bool(0)) #False

print(bool('nick')) #True

print(bool(1 > 2)) #False

print(bool(1 == 1)) #True

六、字符串(str)

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

name1 = 'nick'

name2 = "egon"

print(id(name1)) #4418849624

print(type(name1))#<class 'str'>

print(name1)# nick

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

name3 = """nick

egon"""

print(name3) 
nick

egon

1、特殊字符串：

  • u'unicode': unicode编码的字符串
  • b'101': 二进制编码的字符串
  • \转义符:表达特定字符的本意："这里有个双引号(\" )" 结果为 这里有个双引号(")。转义符形成一些组合，表达一些不可打印的含义：
    \(在行尾时)    ：续行符
    \\    ：反斜杠符号
    \'    ：单引号
    \"    ：双引号
    \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

注意:

  1. Python 没有单独的字符类型，一个字符就是长度为1的字符串。
  2. 反斜杠(\)可以作为续行符，表示下一行是上一行的延续。
  3. Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
  4. 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)#
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所对应的字符串形式
    str(1.23)结果为"1.23"
    str([1,2])结果为"[1,2]"
  • hex(x) 或 oct(x)：整数x的十六进制或八进制小写形式字符串：
    hex(425)结果为"0x1a9" oct(425)结果为"0o651"
  • chr(u)：x为Unicode编码，返回其对应的字符
  • ord(x)：x为字符，返回其对应的Unicode编码
s1 = str(1.1)

s2 = str([1, 2, 3])

print(f's1:{s1}, type:{type(s1)}') #s1:1.1, type:<class 'str'>

print(f's2:{s2}, type:{type(s2)}') #s2:[1, 2, 3], type:<class 'str'>

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!')

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

weekStr = "一二三四五六日"

weekId = eval(input("请输入星期数字(1-7)："))

print("星期" + weekStr[weekId-1] )

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)) #

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(str="", num=string.count(str))：拆分：以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串，返回一个列表；

右拆分：rsplit

splitlines([keepends])：按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

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']。 从右开始切割

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

9、startswith、endswith：首末字符判断

name = 'Nick Chen'

print(name.startswith('Nick'))  # True

print(name.endswith('chen'))  # False

10、join(seq)：连接成字符串。以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

lis = ['nick', 'male', '']

print(':'.join(lis))  # nick:male:19
print(",".join("12345"))  # 1,2,3,4,5

11、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 = ""  # unicode

num.isdigit()  # True

num.isdecimal()  # True

num.isnumeric()  # True

num = ""  # 全角

num.isdigit()  # True

num.isdecimal()  # True

num.isnumeric()  # True

num = b""  # 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

import unicodedata

unicodedata.digit("")  #

unicodedata.decimal("")  #

unicodedata.numeric("")  # 2.0

unicodedata.digit("")  #

unicodedata.decimal("")  #

unicodedata.numeric("")  # 2.0

unicodedata.digit(b"")  # TypeError: must be str, not bytes

unicodedata.decimal(b"")  # TypeError: must be str, not bytes

unicodedata.numeric(b"")  # 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(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'))  #

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'))  #

15、center、ljust、rjust、zfill(width[,fillchar])：根据宽度width居中,居左、居右，fillchar为填充的字符，默认为空格。ljust(width[, fillchar])：返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。

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、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

18、encode(encoding='UTF-8',errors='strict')：以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'

bytes.decode(encoding="utf-8", errors="strict")：Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。code() 方法来解码给定的 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师德师风的

19、字符串与列表，元组的互相转换。

1、字符串转换为列表，for循环

var='菜鸟教程'

list=[]

list=[i for i in var]

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

var1=' ,'.join(list)

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

tup=tuple(var)

七、其他数据类型

1、分数类型：Fraction

构造函数：

  1. class fractions.Fraction(numerator=0, denominator=1)
  2. 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)

 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.getcontext().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

相关文章