Python-基础数据类型概述

Python3 中有六个标准的数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Python3 的六个标准数据类型中：

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）
• 内置的 type() 函数可以用来查询变量所指的对象类型，也可用isinstance(object, classinfo)来判断（返回布尔值）；

• isinstance 和 type 的区别在于：type()不会认为子类是一种父类类型，isinstance()会认为子类是一种父类类型，如：

  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

  另外，如果实例对象（object）的类型与参数二的类型（classinfo）相同，或可以是直接或间接类名、基本类型或者有它们组成的元组，则返回 True，否则返回 False，如：

  a = 2
  print(isinstance(a, int))  # True
  print(isinstance(a, str))  # False
  print(isinstance(a, (str, int, list)))  # True

   

数据类型转换函数：

1.int(x [,base])      整型

x -- 字符串或数字
base -- 进制数，默认是10，表示十进制 

注：若base不为空，x必须是字符串形式

print(int()) #0
print(int(3)) #3
print(int(3.2)) #3
print(int("12",16)) #18
print(int("0xa",16)) #10
print(int("11", 10)) #11

2.float([x])     浮点型

x--字符串或数字

若x为字符串，则必须由【“十进制数字”/“nan”/“inf”/“Infinity”/“字符串前后可有空格”/“字符串前后可有换行符\n”/“字符串前后可有 \t ”/“字符串前可加符号+or-”/“用‘_’将代码文字中的数字进行分组”】组成其中“nan”/“inf”/“Infinity”不区分大小写

若x为 整数 或 浮点数 或 使用"_"将数字进行分组，则返回相同值（在 Python 浮点精度范围内）的浮点数，如果实参在 Python 浮点精度范围外，则会触发 OverflowError

若x无值，则返回 0.0

print(float(1))  # 1.0
print(float(1.123451234512346783451234512345678901))  # 1.1234512345123469
print(float(12.))  # 12.0
print(float(.25))  # 0.25
print(float(1e100))  # 1e+100
print(float(3.14e-10))  # 3.14e-10
print(float(0e0))  # 0.0
print(float(3.14_15_93))  # 3.141593
print(float("nan"))  # nan
print(float("NaN"))  # nan
print(float("inf"))  # inf
print(float("infinity"))  # inf
print(float("Infinity"))  # inf
print(float("+1.23"))  # 1.23
print(float("  -123\n"))  # -123.0
print(float("1e-003"))  # 0.001
print(float("+1E6"))  # 1000000.0
print(float("   +1E6   "))  # 1000000.0
print(float("   \n+1E6"))  # 1000000.0
print(float("\t+1E6\t"))  # 1000000.0
print(float(1_22_333_4444_55555))  # 122333444455555.0
print(float("1_22_333_4444_55555"))  # 122333444455555.0
print(float())  # 0.0

3.complex([real[, imag]])      复数

real---int、float、long、字符串

imag---int、float、long

当real为int、float、long时，imag可缺省或同样为int、float、long

当real为字符串时，则imag必须为能表示复数的字符串形式，如“1+2j”、“1-3j”，但是中间的“+”或“-”号两边不能有空格，并且imag必须缺省

当real和imag都缺省，返回0j

print(complex())  # 0j
print(complex(1, 2))  # (1+2j)
print(complex(3))  # (3+0j)
print(complex("4"))  # (4+0j)
print(complex(5 + 3j))  # (5+3j)
print(complex("6+5j"))  # (6+5j)
print(complex("6-5j"))  # (6-5j)
print(complex("6.1+5.2j"))  # (6.1+5.2j)
print(complex("6.1"))  # (6.1+0j)

4.eval(expression, globals=None, locals=None)

expression：字符串，只能是单个表达式，不支持复杂的代码逻辑，例如赋值操作、循环语句等等；python会使用globals字典和locals字典作为全局和局部的命名空间，将expression当做一个加了字符串标识（即引号）的python表达式，也是一个条件列表，进行解析和计算
globals：一个全局的命名空间，也就是我们在计算表达式的时候可以使用全局的命名空间中的函数，如果这个参数被提供了，并且没有提供自定义的__builtins__，那么会将当前环境中的__builtins__拷贝到自己提供的globals里，然后才会进行计算。关于__builtins__，它是python的内建模块，也就是python自带的模块，不需要我们import就可以使用的，例如我们平时使用的int、str、abs等都在这个模块中
locals：一个局部的命名空间，和globals类似，不过当它和globals中有重复的部分时，locals里的定义会覆盖掉globals中的，以locals的为准。如果locals没有被 提供的话，则默认为globals。

#1.只有expression
#（1）打印数据类型
a = "[[1,2],[2,3],[3,4],[4,5]]"
b = eval(a)
print(b)  # [[1, 2], [2, 3], [3, 4], [4, 5]]
print(type(b))  # <class 'list'>

a = "{1:'a',2:'b',3:'c'}"
b = eval(a)
print(b)  # {1: 'a', 2: 'b', 3: 'c'}
print(type(b))  # <class 'dict'>

a = "([1,2],[2,3],[3,4],[4,5])"
b = eval(a)
print(b)  # ([1, 2], [2, 3], [3, 4], [4, 5])
print(type(b))  # <class 'tuple'>

#（2）字符串的3种打印方式
abck = "abck"
s = "abck"
print(eval(s)) #abck

s = "abck"
print(eval("s")) #abck

s = '"abck"'
print(eval(s)) #abck

print(eval("__import__('os').system('dir')"))
print(eval("open('test.txt').read() "))

#2.指定了globals
a = 10
g = {"a": 5}
print(eval("a+1", g)) #6

# 2.指定了locals
a = 10
b = 20
c = 30
g = {"a": 5, "b": 6}
t = {"a": 100, "c": 200}
print(eval("a+b+c", g, t))  # 306

5.tuple(seq) 转换为元组

seq -- 要转换为元组的序列，包括字符串、列表、字典、集合

list1 = [1, 2, 3]
tuple1 = tuple(list1)
print(tuple1)  # (1, 2, 3)

str1 = "abc"
tuple1 = tuple(str1)
print(tuple1)  # ('a', 'b', 'c')

dict1 = {"a": 1, "b": 2, "c": 3}
tuple1 = tuple(dict1)  #---只保留集合的键
print(tuple1)  # ('a', 'b', 'c')

set1 = set("aabbccddee")
print(set1)  #{'e', 'a', 'd', 'c', 'b'}
tuple1 = tuple(set1)
print(tuple1)  # ('a', 'b', 'd', 'e', 'c')

6.list(seq) 转换为列表
seq -- 要转换为列表的元组或字符串

aTuple = (123, 'Google', 'Runoob', 'Taobao')
list1 = list(aTuple)
print("列表元素 : ", list1)  # 列表元素 :  [123, 'Google', 'Runoob', 'Taobao']

str = "Hello World"
list2 = list(str)
# 列表元素 :  ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'] --字符串被按照字母分开
print("列表元素 : ", list2)

list3 = list([123, 11])
# 列表元素 :  [123, 11]
print("列表元素 : ", list3)

list4 = list({"a": 1, "b": 2})
print("列表元素 : ", list4)  # 列表元素 :  ['a', 'b'] --仅仅展示字典的键

list5 = list(set([1, 2, 2, 3, 3, 3, 4, 5]))
print("列表元素 : ", list5)  # 列表元素 : [1, 2, 3, 4, 5]

7.set([iterable]) 转换为集合

iterable -- 可迭代对象对象

x = set('runoob')
y = set('google')
print(x)  # {'n', 'b', 'r', 'o', 'u'}  --字符串被按照字母分开
print(y)  # {'g', 'o', 'l', 'e'}
print(x & y)  # {'o'}
print(x | y)  # {'n', 'e', 'b', 'r', 'o', 'g', 'l', 'u'}
print(x - y)  # {'b', 'r', 'n', 'u'}

x = set([11, 22, 33, 23, 44, 11, 22, 33])
print(x)  # {33, 11, 44, 22, 23}

x = set(['runoob', 'google'])
y = set(['google'])
print(x)  # {'google', 'runoob'} --列表的方括号被脱去
print(y)  # {'google'}
print(x & y)  # {'google'}
print(x | y)  # {'google', 'runoob'}
print(x - y)  # {'runoob'}

x = set({"a": 1, "b": 2, "c": 3})
y = set({"a": 2, "b": 2, "d": 4})
print(x)  # {'b', 'c', 'a'} --仅仅比较字典的键
print(y)  # {'b', 'd', 'a'}
print(x & y)  # {'b', 'a'}
print(x | y)  # {'b', 'd', 'c', 'a'}
print(x - y)  # {'c'}

x = set(('a', 'c', 'b'))
y = set(('a', 'b', 'e'))
print(x)  # {'b', 'a', 'c'} --元祖的圆括号被脱去
print(y)  # {'b', 'a', 'e'}
print(x & y)  # {'b', 'a'}
print(x | y)  # {'b', 'a', 'e', 'c'}
print(x - y)  # {'c'}

8.dict(**kwarg) / dict(mapping, **kwarg) / dict(iterable, **kwarg)  转换为字典

**kwargs -- 关键字
mapping -- 元素的容器
iterable -- 可迭代对象

dict_a = dict()
dict_a = dict(a=1, b=2, c=3)
print(dict_a)  # {'a': 1, 'b': 2, 'c': 3}

dict_a = dict(a="1", b="2", c="3")
print(dict_a)  # {'a': '1', 'b': '2', 'c': '3'} --传入关键字

dict_a = dict(zip(["one", "two", "three"], [1, 2, 3]))
print(dict_a)  # {'one': 1, 'two': 2, 'three': 3} --用映射函数来构造字典

dict_a = dict((("aon", 1), ("atw", 2)))
print(dict_a)  # {'aon': 1, 'atw': 2}

dict_a = dict([("on", 1), ("tw", 2)])
print(dict_a)  # {'on': 1, 'tw': 2}

dict_a = dict((["aa", 1], ["bb", 2]))
print(dict_a)  # {'aa': 1, 'bb': 2}

dict_a = dict([["aaa", 1], ["bbb", 2]])
print(dict_a)  # {'aaa': 1, 'bbb': 2}

9.frozenset([iterable])  返回一个不可更改的集合，不能再添加或删除任何元素

iterable -- 可迭代的对象，比如列表、字典、元组等等

aset = frozenset("hello everyone")
print(aset)  # frozenset({'r', ' ', 'v', 'y', 'e', 'o', 'n', 'h', 'l'})

10.chr(i)  将一个整数转化为字符

i -- 可以是10进制也可以是16进制的形式的数字

i = 10000
print(chr(i))  # ✐
i = 0x30
print(chr(i))  # 0
i = 0x31
print(chr(i))  # 1
i = 0x61
print(chr(i))  # a
i = 48
print(chr(i))  # 0
i = 49
print(chr(i))  # 1
i = 97
print(chr(i))  # a

11.ord(c)  将一个字符转换为它的整数值

Ps：（1）ord() 函数是 chr() 函数（对于8位的ASCII字符串）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常；

（2）Python2中使用的chr()将Ascii的值转换成对应字符，unichr()将Unicode的值转换成对应字符 ；而在Python3中内置函数unichr()消失了，实际上是Python3中的chr()不仅仅支持Ascii的转换，直接支持了更为适用的Unicode转换；

a = "a"
print(ord(a)) #97
a = "b"
print(ord(a)) #98
a = " "
print(ord(a)) #32
a = "7"
print(ord(a)) #55
a = "A"
print(ord(a)) #65

12.hex(x)  用于将10进制整数转换成16进制，以字符串形式表示

x -- 10进制整数

a = 12
print(hex(a))  # 0xc
a = 255
print(hex(a))  # 0xff
a = -42
print(hex(a))  # -0x2a
print(type(hex(a)))  # <class 'str'>
a = 0x31
print(hex(a))  # 0x31

13.oct(x)  用于将整数转换成8进制，以字符串形式表示

x -- 整数

a = 10
print(oct(a))  # 0o12
a = 255
print(oct(a))  # 0o377
a = -42
print(oct(a))  # -0o52
print(type(hex(a)))  # <class 'str'>
a = 0x31
print(oct(a))  # 0o61