Python 从菜鸟到大咖的必经之路_Python_基本数据类型

大家好！
我是小黄，很高兴又跟大家见面啦 ！
拒绝水文，从我做起 ！！！！
如若转载 ，麻烦请注明出处！！！！

今天更新的是：

• 04 TIANCHI_Python_基本数据类型 。
• 往期检索：程序设计学习笔记——目录

---

创建时间：2021年2月10日
重构时间：2021年5月25日
软件： Python 3 、Pycharm

---

1. Python 基本数据类型：

1.1 Python 变量赋值：

• Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
• 在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

1. 等号（=）用来给变量赋值。
2. 等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：

# 变量赋值：
counter = 100          									# 整型变量
miles   = 1000.0       									# 浮点型变量
name    = "runoob"     									# 字符串
list = ['this', 'is', 'list', 2]						# 列表赋值
tuple = ('this', 'is', 'tuple', 3)						# 元组赋值
dict = {1:'this', 2:'is', 3:'dictionary', 4:4}			# 字典赋值

# 两种输出格式：
print (counter);print("{}".format(counter))
print (miles);print("{}".format(miles))
print (name);print("{}".format(name))

# 多个变量赋值：
a, b, c = 1, 2, "runoob"
print(a);print(b);print(c)

# 变量赋值：
teacher = "小马的程序人生"
print(teacher) # 小马的程序人生
teacher = "老马的程序人生"
print(teacher) # 老马的程序人生

first = 2
second = 3
third = first + second
print(third) # 5

myTeacher = "老马的程序人生"
yourTeacher = "小马的程序人生"
ourTeacher = myTeacher + yourTeacher
print(ourTeacher) # 老马的程序人生小马的程序人生

1.2 Python 标准数据类型：

• Python 定义了一些标准类型，用于存储各种类型的数据。
• Python有五个标准的数据类型：Numbers（数字）、 String（字符串）、 List（列表）、 Tuple（元组）、 Dictionary（字典）。
• 数据类型： 分为数字型和非数字型。

• 数字型包括：整型，浮点型，布尔型，复数型；
• 非数字型包括：字符串，列表，元组和字典 ；
• 非数字型的共同点： 都可以使用切片、链接（+）、重复（*）、取值（a[]）等相关运算;
• 非数字型的不同点：
• 列表 可以直接赋值，元组不可以赋值，字典按照 dict[k]=v 的方式赋值。

1.2.1 Python数字类型_数字型：

• 数字数据类型用于存储数值。
• 他们是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。
• Python支持四种不同的数字类型：int（有符号整型）、long（长整型 [ 也可以代表八进制和十六进制 ] ）、float（浮点型）、complex（复数）。
• 在32位机器上，整数的位数为32位，取值范围为-231～231-1，即-2147483648～2147483647
• 在64位系统上，整数的位数为64位，取值范围为-263～263-1，即-9223372036854775808～9223372036854775807
• 数字型分类：

• 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点.
• 长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L。
• 浮点型(floating point real values) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250)
• 复数(complex numbers) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

• 当你指定一个值时，数字类型（Number） 对象就会被创建：

# 创建整型（int）类型：
num1 = 1
num2 = 2

print(num1,num2)
# 打印输出：1 2

# 创建浮点型（float）、复数（comple）类型：
print(1, type(1))
# 1 <class 'int'>

print(1., type(1.))
# 1.0 <class 'float'>

a = 0.00000023
b = 2.3e-7
print(a) # 2.3e-07
print(b) # 2.3e-07

# 创建布尔型（boolean）类型:
print(True + True) # 2
print(True + False) # 1
print(True * False) # 0

• 一些数值类型的实例：

• 长整型也可以使用小写 l，但是还是建议您使用大写 L，避免与数字 1 混淆。Python使用 L 来显示长整型。
• Python 还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。

注意： long 类型只存在于 Python2.X 版本中，在 2.2 以后的版本中，int 类型数据溢出后会自动转为long类型。在 Python3.X 版本中 long 类型被移除，使用 int 替代。

1.2.1 Python数字类型_数字型_整型（int）：

a = 1031
print(a, type(a))

# 打印输出：1031 <class 'int'>
# python 的所有数据类型都是类,可以通过 type() 查看该变量的数据类型
# 通过 print 可看出 a 的值，以及类 (class) 是 int 。

• Python 里面万物皆对象（object），整型也不例外，只要是对象，就有相应的属性 （attributes) 和方法（methods）。

# 查看 int 类型的属性和方法： 

b = dir(int)
print(b)

# 打印输出如下：
# ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__',
# '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__',
# '__float__', '__floor__', '__floordiv__', '__format__', '__ge__',
# '__getattribute__', '__getnewargs__', '__gt__', '__hash__',
# '__index__', '__init__', '__init_subclass__', '__int__', '__invert__',
# '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__',
# '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__',
# '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__',
# '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__',
# '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__',
# '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__',
# '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__',
# 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag',
# 'numerator', 'real', 'to_bytes']

• 对它们有个大概印象就可以了，具体怎么用，需要哪些参数 （argument），还需要查文档。看个 bit_length 的例子。

# 找到一个整数的二进制表示，再返回其长度：

a = 1031
print(bin(a))
print(a.bit_length())

# 打印输出的结果如下：
# 0b10000000111
# 11

1.2.1 Python数字类型_数字型_浮点型（float）：

print(1, type(1))

# 1 <class 'int'>

print(1., type(1.))

# 1.0 <class 'float'>

a = 0.00000023
b = 2.3e-7
print(a) # 2.3e-07
print(b) # 2.3e-07

• 当我们想保留浮点型的小数点后 n 位。可以用 decimal 包里的 Decimal 对象和 getcontext() 方法来实现。
• Python 里面有很多用途广泛的包 (package)，用什么你就引进 (import) 什么。包也是对象，也可以用上面提到的 dir(decimal) 来看其属性和方法。比如 getcontext() 显示了Decimal 对象的默认精度值是 28 位 ( prec=28 )，
• 展示如下：

import decimal
from decimal import Decimal
a = decimal.getcontext()
print(a)

# Context(prec=28, rounding=ROUND_HALF_EVEN, 
# Emin=-999999, Emax=999999, capitals=1, clamp=0, 
# flags=[],traps=[InvalidOperation, DivisionByZero, Overflow])

# 让我们看看 1/3 的保留 28 位长什么样？

import decimal
from decimal import Decimal
b = Decimal(1) / Decimal(3)
print(b)

# 0.3333333333333333333333333333

# 保留 4 位呢？用 getcontext().prec 来调整精度：

import decimal
from decimal import Decimal
decimal.getcontext().prec = 4
c = Decimal(1) / Decimal(3)
print(c)

# 0.3333

1.2.1 Python数字类型_数字型_布尔型（Boolean）：

• 布尔 (boolean) 型变量只能取两个值， True 和 False 。当把布尔变量用在数字运算中，用 1 和 0 代表 True 和False 。

print(True + True) # 2
print(True + False) # 1
print(True * False) # 0

• 除了直接给变量赋值 True 和 False ，还可以用 bool(X) 来创建变量，其中 X 可以是

1. 基本类型：整型、浮点型、布尔型
2. 容器类型：字符、元组、列表、字典和集合

• bool 作用在基本类型变量： X 只要不是整型 0 、浮点型 0.0 ， bool(X) 就是 True ，其余就是 False 。

print(type(0), bool(0), bool(1))
# <class 'int'> False True

print(type(10.31), bool(0.00), bool(10.31))
# <class 'float'> False True

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

• bool 作用在容器类型变量： X 只要不是空的变量， bool(X) 就是 True ，其余就是 False 。

print(type(''), bool(''), bool('python'))
# <class 'str'> False True

print(type(()), bool(()), bool((10,)))
# <class 'tuple'> False True

print(type([]), bool([]), bool([1, 2]))
# <class 'list'> False True

print(type({}), bool({}), bool({'a': 1, 'b': 2}))
# <class 'dict'> False True

print(type(set()), bool(set()), bool({1, 2}))
# <class 'set'> False True

• 确定 bool(X) 的值是 True 还是 False ，就看 X 是不是空，空的话就是 False ，不空的话就是 True 。

1. 对于数值变量， 0 , 0.0 都可认为是空的。
2. 对于容器变量，里面没元素就是空的。

1.2.1 Python数字类型_数字型_复数（complex）：

• Python语言中有关负数的概念：

1. 虚数不能单独存在，它们总是和一个值为0.0的实数部分一起构成一个复数
2. 复数由实数部分和虚数部分构成
3. 表示虚数的语法：real+imagej
4. 实数部分和虚数部分都是浮点数
5. 虚数部分必须有后缀j或J

• 复数的内建属性：

1. 复数对象拥有数据属性，分别为该复数的实部和虚部。
2. 复数还拥有conjugate方法，调用它可以返回该复数的共轭复数对象。
3. 复数属性：real(复数的实部)、imag(复数的虚部)、conjugate()（返回复数的共轭复数）

class Complex(object):
    '''''创建一个静态属性用来记录类版本号'''
    version = 1.0
    '''''创建个复数类，用于操作和初始化复数'''

    def __init__(self, rel=15, img=15j):
        self.realPart = rel
        self.imagPart = img

        # 创建复数

    def creatComplex(self):
        return self.realPart + self.imagPart
        # 获取输入数字部分的虚部

    def getImg(self):
        # 把虚部转换成字符串
        img = str(self.imagPart)
        # 对字符串进行切片操作获取数字部分
        img = img[:-1]
        return float(img)


def test():
    print("run test...........")
    com = Complex()
    Cplex = com.creatComplex()
    if Cplex.imag == com.getImg():
        print(com.getImg())
    else:
        pass
    if Cplex.real == com.realPart:
        print(com.realPart)
    else:
        pass
        # 原复数
    print("the religion complex is :", Cplex)
    # 求取共轭复数
    print("the conjugate complex is :", Cplex.conjugate())


if __name__ == "__main__":
    test()
    
# run test...........
# 15.0
# 15
# the religion complex is : (15+15j)
# the conjugate complex is : (15-15j)

1.3 Python获取数据信息：

1.3.1 Python获取信息类型：

• 获取类型信息： type(object) / isinstance(object, classinfo)

print(type(1)) # <class 'int'>
print(type(5.2)) # <class 'float'>
print(type(True)) # <class 'bool'>
print(type('5.2')) # <class 'str'>

print(isinstance(1, int)) # True
print(isinstance(5.2, float)) # True
print(isinstance(True, bool)) # True
print(isinstance('5.2', str)) # True

1.3.2 isinstance 和 type 的区别在于：

class A:
    pass
class B(A):
    pass

print(isinstance(A(),A))	# True
print(type(A()) == A)		# True

print(isinstance(B(),A))	# True
print(type(B()) == A)		# False

注：

1. type() 不会认为子类是一种父类类型，不考虑继承关系。
2. isinstance() 会认为子类是一种父类类型，考虑继承关系。

1.3.3 不推荐使用 type(instance) == class 来判断数据类型：

class A:
    pass
    
# class A(object):
#    pass

class C(A):
    pass

a = A()
c = C()

print (type(a) == A, end=' ')
print (type(c) == C, end=' ')
print (type(A()) == A, end=' ')
print (type(C()) == C, end=' ')

# True True True True

print(a.__class__ is A, end=' ')
print(c.__class__ is A, end=' ')
print(a.__class__ is C, end=' ')
print(c.__class__ is C,end=' ')

# True False False True

print(isinstance(a, A), end=' ')
print(isinstance(c, A), end=' ')
print(isinstance(a, C), end=' ')
print(isinstance(c, C),end=' ')

# True True False True

• 为什么不用 isinstance 或者 class is 这种更快的方式呢，地址比较总是快于值比较。

补充：

• type 是用于求一个未知数据类型对象，而 isinstance 是用于判断一个对象是否是已知类型。
• type 不认为子类是父类的一种类型，而isinstance会认为子类是父类的一种类型。
• 可以用 isinstance 判断子类对象是否继承于父类，type 不行。
• 综合以上几点，type 与 isinstance 虽然都与数据类型相关，但两者其实用法不同，type 主要用于判断未知数据类型，isinstance 主要用于判断 A 类是否继承于 B 类：

# 判断子类对象是否继承于父类
class father(object):
    pass
class son(father):
    pass
if __name__ == '__main__':
    print (type(son())==father)
    print (isinstance(son(),father))
    print (type(son()))
    print (type(son))
    
# False
# True
# <class '__main__.son'>
# <class 'type'>

1.4 Python 强制类型转换：

int(x [,base ])         将x转换为一个整数  
long(x [,base ])        将x转换为一个长整数  
float(x )               将x转换到一个浮点数  
complex(real [,imag ])  创建一个复数  
str(x )                 将对象 x 转换为字符串  
repr(x )                将对象 x 转换为表达式字符串  
eval(str )              用来计算在字符串中的有效Python表达式,并返回一个对象  
tuple(s )               将序列 s 转换为一个元组  
list(s )                将序列 s 转换为一个列表  
chr(x )                 将一个整数转换为一个字符  
unichr(x )              将一个整数转换为Unicode字符  
ord(x )                 将一个字符转换为它的整数值  
hex(x )                 将一个整数转换为一个十六进制字符串  
oct(x )                 将一个整数转换为一个八进制字符串  

# 举个例子：

print(int('520')) # 520
print(int(520.52)) # 520
print(float('520.52')) # 520.52
print(float(520)) # 520.0
print(str(10 + 10)) # 20
print(str(10.1 + 5.2)) # 15.3

下期预告：

• 将更新关于 05 TIANCHI_Python_运算符及位运算

---

各位路过的朋友，如果觉得可以学到些什么的话，点个赞 再走吧，欢迎各位路过的大佬评论，指正错误，也欢迎有问题的小伙伴评论留言，私信。

每个小伙伴的关注都是本人更新博客的动力！！！
请微信搜索【 在下小黄 】文章更新将在第一时间阅读 ！

博客中若有不恰当的地方，请您一定要告诉我。前路崎岖，望我们可以互相帮助，并肩前行！

---