py语法基础004_类型与转换

# coding=utf-8
"""
1、数据类型
（1）软件是用于解决生活中实际问题的一种工具，编程语言的基本语法是从生活中抽象出的概念
（2）为便于解决问题，可以抽取出基本的数据，使用适合的数据类型的语法，描述生活中的事物
（3）数据类型就是从现实生活中抽取出来的，描述不同数据的概念，通过规范的语法进行定义的数据格式（4）数据类型：从生活中抽取出来的，用于描述不同事物的概念
（5）变量中可以存储数据，具体变量的类型，是根据变量中存储的数据是什么类型确定
（6）python是弱类型语言：对于变量是什么类型，没有进行强制约束
    A、变量是什么类型，是由变量中存储的具体数据决定的
    B、弱类型：对于数据类型在变量中的存储方式，没有强制的规范
2、数据类型：用于描述不同事物的概念
（1）基本数据类型：数值(整型、浮点型、复数、布尔)、字符串
（2）组合数据类型：列表、元组、字典、集合
（3）对象数据类型：函数对象、类对象
    A、python官方内置的数据类型有6种：数值(整数，浮点数，复数，布尔，空值)、字符串、列表、元组、字典、集合
    B、实际开发中通常把数据类型分为：简单数据类型、组合数据类型和对象数据类型
        简单数据类型：数值(整型、浮点型、复数、布尔)
        组合数据类型：列表、元组、字典、集合
        对象数据类型：函数、类
3、数值类型
（1）整型int：数学中的整数
    A、可以做超大数的计算-适合科学运算
    B、python仅对比较小的整数对象进行缓存[-5, 256]
（2）浮点型float：数学中的小数
    A、结构：数值+浮动的小数点
    B、一般使用科学计数法表示
        >> time.time()：获得当前时间戳(秒)，带微秒精度的浮点数
        >> round(浮点数)：对小数做四舍五入操作
（3）布尔类型bool：只存储True、False两个值之一，表示真假
    A、描述一个事情的结果[正确True|失败False]
    B、本质上还是数值(1-True，0-False)，可与数值相加
（4）复数complex
    A、由实部和虚部构成：a+bj
    B、程序开发过程中复杂数学运算用到(实数+虚数)
（5）空值None：特殊的数据
    A、描述什么都不存在的情况
    B、取值过于简单，当成普通数据处理
4、字符串str：表达一种名词，使用引号包围的对象
（1）描述一段信息的字符，使用引号包含的数据
（2）将数据转换为字符串使用str方法即可
（3）转换成布尔类型时，空字符串转换为False、非空字符串转换为True
（4）转换数据时，内部包含的数据必须有需要转换成为类型数据的特征，否则转换失败
5、组合数据类型--一个变量中用来保存多个数据(一组数据)，可以使用组合数据类型
（1）列表list：中括号[]表示，有序，可修改，可重复
（2）元组tuple：小括号()表示，有序，不可修改，可重复
（3）集合set：大括号{}表示，无序，无索引，不可修改，不可重复
（4）字典dict：大括号{}表示，无序，有索引，可修改，键不可重复
6、对象数据类型：描述生活中的复杂事物
（1）一个变量中可以保存一个对象数据，一个对象数据中可以存储这个对象
（2）编程中又称为引用数据类型、复杂数据类型
（3）用于描述复杂对象，包括内建类型及自定义的类型：关键字class、else
7、数据类型转换：使用数据类型的关键字可以将数据类型转换
（1）type(数据)：查看数据的数据类型
（2）isinstance(数据,类型)：判断数据的数据类型是否是指定的类型
（3）类型(数据)：将数据转换成指定的类型
    >> 数据本身的类型要和要转换的类型间存在一定的关系
    >> 数据类型转换不会改变原有值，而是新产生一个值
    A、转换为整数类型：int方法，浮点型会舍弃小数点取整
    B、转换为布尔类型：bool方法-0转换为False，其他转换为True
    C、转换为浮点数类型：float方法
    D、转换为复数类型：complex方法
    E、转换为字符串类型：str方法
（4）同种类型计算得到类型仍然为该类型(bool除外)
（5）不同类型计算, 首先要转化为同种类型再计算
    A、int+float：会按照浮点数保留数值
    B、int+bool：布尔值True转换为1，False转换为0计算
    C、float+bool：将布尔值转换为数字，根据浮点数保留数值
    D、bool+bool：将布尔值转换为数字计算
（6）python语言规范定义bool类型的转换
    A、整数转换成布尔类型：0-False，非0-True
    B、浮点数转换成布尔类型：0.0-False，非0-True
    C、字符串转换成布尔类型：空字符-False，非空
"""
import types
def myPrint(data):
    return print("~"*30+data+"~"*30)

myPrint("数据类型判断")
# 数据类型
print("5的数据类型：", type(5))
print("2.0的数据类型：", type(2.0))

print("True的数据类型：", type(True))
print("空字符''的数据类型：", type(bool('')))

print("实部+虚部组合5j+8的数据类型：", type(5j + 8))
print("complex转换的complex(5,8)的数据类型：", type(complex(5, 8)))

print("空值None的数据类型：", type(None))

print("字符串'字符'的数据类型：", type("字符"))

# if语句中判断，比较两个变量类型是否相同：
print("判断字符abc与字符123是否类型相同：", type('abc') == type('123'))
print("判断字符abc与关键字str是否类型相同：", type('abc') == str)
print("判断字符abc与整数123是否类型相同：", type('abc') == type(123))

# 判断变量指向函数或类
def function():
    pass
print("使用def自定义的数据类型：", type(function))
# 判断对象是否是函数，使用types模块常量：
print("判断def自定义是否是一个函数：", type(function) == types.FunctionType)
print("判断abs内置是否是一个函数：", type(abs) == types.BuiltinFunctionType)
print("判断lambda是否是匿名函数：", type(lambda x: x) == types.LambdaType)
print("判断range是否是一个可迭代对象：", type((x for x in range(10))) == types.GeneratorType)

# 判断数据类型
print("判断1是否是int类型：", isinstance(1, int))
print("判断1是否是bool类型：", isinstance(1, bool))
print("判断bool支持转换的类型：", bool.__mro__)

# 判断单一数据
print("判断数值123是否是整数类型：", isinstance(123, int))
print("判断b'a'是否是bytes类型：", isinstance(b'a', bytes))
# 判断组合数据
print("判断[1,2]的类型是否存在list/tuple中：", isinstance([1, 2, 3], (list, tuple)))
print("判断{'数':'1'}的类型是否存在list/tuple/set中：", isinstance({'数':'1'}, (list, tuple, set)))

myPrint("数据类型转换")
# 类型转换：整数类型转换
print(f"整数123的数据类型：{type(123)}--->浮点数据{float(123)}的数据类型：{type(float(123))}")
print(f"整数123的数据类型：{type(123)}--->布尔类型{bool(123)}的数据类型：{type(bool(123))}")
print(f"整数123的数据类型：{type(123)}--->复数类型{complex(123)}的数据类型：{type(complex(123))}")
print(f"整数123的数据类型：{type(123)}--->字符类型{str(123)}的数据类型：{type(str(123))}")

# 类型转换：浮点数类型转换
print(f"浮点123.0的数据类型：{type(123.0)}--->整数数据{int(123.0)}的数据类型：{type(int(123.0))}")
print(f"浮点123.0的数据类型：{type(123.0)}--->布尔类型{bool(123.0)}的数据类型：{type(bool(123.0))}")
print(f"浮点123.0的数据类型：{type(123.0)}--->复数类型{complex(123.0)}的数据类型:{type(complex(123.0))}")
print(f"浮点123.0的数据类型：{type(123.0)}--->字符类型{str(123.0)}的数据类型：{type(str(123.0))}")

# 类型转换：布尔类型转换
print(f"布尔True的数据类型：{type(True)}--->整数数据{int(True)}的数据类型：{type(int(True))}")
print(f"布尔True的数据类型：{type(True)}--->浮点类型{bool(True)}的数据类型：{type(bool(True))}")
print(f"布尔True的数据类型：{type(True)}--->复数类型{complex(True)}的数据类型：{type(complex(True))}")
print(f"布尔True的数据类型：{type(True)}--->字符类型{str(True)}的数据类型：{type(str(True))}")

# 类型转换：复数类型转换
# print(f"复数4j+6的数据类型：{type(4j+6)}--->整数数据{int(4j+6)}的数据类型：{type(int(4j+6))}")
# print(f"复数4j+6的数据类型：{type(4j+6)}--->浮点类型{float(4j+6)}的数据类型：{type(float(4j+6))}")
print(f"复数4j+6的数据类型：{type(4j + 6)}--->布尔类型{bool(4j + 6)}的数据类型：{type(bool(4j + 6))}")
print(f"复数4j+6的数据类型：{type(4j + 6)}--->字符类型{str(4j + 6)}的数据类型：{type(str(4j + 6))}")

# 类型转换：字符串类型转换--内部是字符
# print(f"字符'a'的数据类型：{type('a')}--->整数数据{int('a')}的数据类型：{type(int('a'))}")
print(f"字符'a'的数据类型：{type('a')}--->浮点类型{bool('a')}的数据类型：{type(bool('a'))}")
print(f"字符'a'的数据类型：{type('a')}--->布尔类型{bool('a')}的数据类型：{type(bool('a'))}")
# print(f"字符'a'的数据类型：{type('a')}--->复数类型{complex('a')}的数据类型：{type(complex('a'))}")
print(f"字符'a'的数据类型：{type('a')}--->字符类型{str('a')}的数据类型：{type(str('a'))}")

# 类型转换：字符串类型转换--内部是数值
print(f"字符'123'的数据类型：{type('123')}--->整数数据{int('123')}的数据类型：{type(int('123'))}")
print(f"字符'123'的数据类型：{type('123')}--->浮点类型{bool('123')}的数据类型：{type(bool('123'))}")
print(f"字符'123'的数据类型：{type('123')}--->布尔类型{bool('123')}的数据类型：{type(bool('123'))}")
print(f"字符'123'的数据类型：{type('123')}--->复数类型{complex('123')}的数据类型：{type(complex('123'))}")
print(f"字符'123'的数据类型：{type('123')}--->字符类型{str('123')}的数据类型：{type(str('123'))}")