Python基本数据类型

2019年7月15日17:24:49             地点：武汉

本人小白一枚记录一下学python的一点心得，主要记录python的基本数据类型。

python基本数据类型包括：int（整型），float（浮点型），complex（复数），string（字符串），dict（字典），list（列表），tuple（元祖），set（集合），bool（布尔值）。

记住查看数据类型时用type函数查看即可。

int — 整型

a = 0
print(type(a))
b = 1 ** 8    # **表示乘方的意思，即10的8次方
print(type(b))    

#<class 'int'>
#<class 'int'>

int型简而言之就是整数，没有小数点的数字，包括正数，负数以及零 （0）。

float — 浮点型

a = 1.
print(type(a))
b = -1.1
print(type(b))

#<class 'float'>
#<class 'float'>

那么什么是浮点型的数据呢？以上的代码段显示出来浮点型就相当于小数类型的数字，简而言之就是只要有小数点就是浮点类型的数据，如a变量，它被赋值等于1.  此时编译器会自动默认小数点后面的数据为零，在自动补上。成为一个float类型的数据。

complex  — 复数

complex


# class complex(object):
#     """
#     complex(real[, imag]) -> complex number
# 
#     Create a complex number from a real part and an optional imaginary part.
#     This is equivalent to (real + imag*1j) where imag defaults to 0.
#     """

这上面是pycharm编辑器对于复数的解释，这也是一个高中的数学知识点，如：z=a+bi（a,b均为实数）的数称为复数，其中a称为实部，b称为虚部，i 称为虚数单位。这里不展开讲解，不懂的同学可以自行百度搜索。

这里对多行#开后的字符串解释一下，在对不熟悉的内容操作时，不知道其中包含的内置函数或者不懂字段是什么意思的时候使用一个万能方法，Ctrl + 鼠标左键 点击查询即可。以上的多行#开头的字符串粘贴来自builtins.py对complex的解释。下面使用一下complex：

a = complex(1,2)
print(a, type(a))   # <class 'complex'>
b = complex(1)
print(b, type(b))     # <class 'complex'>
c = complex("1+2j")
print(c, type(c))    # <class 'complex'>
d = complex(0)
print(d, type(d))



#  (1+2j) <class 'complex'>

#  (1+0j) <class 'complex'>

#  (1+2j) <class 'complex'>

#  0j <class 'complex'>

由代码块可以看出来，我们的complex其中可以接受1个数字，2个数字，或者一个字符串（其中包括real + imag*1j这个结构），当complex有且仅有一个数字时，此数字不为0，则被real接收，若此数字等于0，则被imag接收。

 

string — 字符串

对于字符串这种入门级别的数据类型，和C，Java的处理方式，代码如下：

#String 字符串
a = 'hello world!'
print(a , type(a))      # hello world! <class 'str'>
b = "hello world!"
print(b , type(b))      # hello world! <class 'str'>
c = "he'llo' wor'ld!'"
print(c, type(c))       # he'llo' wor'ld!' <class 'str'>
d = 'he"llo",wor"ld!"'
print(d, type(d))       # he"llo",wor"ld!" <class 'str'>
e = """hello world!"""
print(e, type(e))       # hello world! <class 'str'>

由代码块可以看出来，我们的String类型的数据，可以由单引号和双引号两个引号给包括住，但是c和d变量可以看出来，双引号可以在内包含着单引号，同样的单引号也可以包含着双引号。但是print的时候也被输出出来了，当然双引号包含同样的双引号，则被分割成了两个字符串了。当然三个字符串也是可以的哦~

dict — 字典

这一个数据类型，不知道怎么在解释看一下官方解释吧

class dict(object):
    """
    dict() -> new empty dictionary
    dict(mapping) -> new dictionary initialized from a mapping object's
        (key, value) pairs
    dict(iterable) -> new dictionary initialized as if via:
        d = {}
        for k, v in iterable:
            d[k] = v
    dict(**kwargs) -> new dictionary initialized with the name=value pairs
        in the keyword argument list.  For example:  dict(one=1, two=2)
    """

以上是官方的解释，现在我们在pycharm中跑一下这个数据类型

d = {"key1":"value1","key2":"value2"}
print(d,type(d))    # {'key1': 'value1', 'key2': 'value2'} <class 'dict'>

这个key和value是一个对应的关系，它们以键值对的形式存在，对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 。

注意：键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

list — 列表

list的存在就如同字符串的存在，在多数计算机编程语法中都存在的一种基本数据类型。官方的解释如下:

class list(object):
    """
    list() -> new empty list
    list(iterable) -> new list initialized from iterable's items
    """

很简单的一种数据类型，咱们就快点过掉，举个例子，如下：

L = [1, 2, 3]
print(L, type(L))       # [1, 2, 3] <class 'list'>
L = ["1, 2, 3"]
print(L,type(L))        # ['1, 2, 3'] <class 'list'>
L = [{"key1" : "value1"}]
print(L, type(L))       # [{'key1': 'value1'}] <class 'list'>

不管使用int型的数据填写在方括号内，还是“双引号”的字符串填写在方括号内，还是{字典}的键值对填写在方括号内。输出结果都一样，均为list型。以上可以得到无论什么数据类型放置在 [ list ] 中均为 列表。

tuple - 元组

这个是元组，不是元祖（卖蛋糕的那个）。元组与列表类似，不同之处在于元组的元素不能修改。

元组使用（小括号），列表使用 [ 方括号 ]。官方解释如下：

class tuple(object):
    """
    tuple() -> empty tuple
    tuple(iterable) -> tuple initialized from iterable's items
    
    If the argument is a tuple, the return value is the same object.
    """

在实际环境中如下：

T = (1, 2, 3)
print(T, type(T))   # (1, 2, 3) <class 'tuple'> 
T = (1,)
print(T, type(T))   # (1,) <class 'tuple'>
T = (1)    
print(T, type(T))    # 1 <class 'int'>
T = (1.)
print(T, type(T))    # 1.0 <class 'float'>

元祖很奇怪，只有数字添加在（小括号）中才为tuple类型，有且仅有一个数字但是要使用元祖类型时，必须在其后面添加一个逗号，否则就是int型或者float型。

那么元祖会不会和列表一样呢？在其中添加String，list，dict会是怎么样呢？运行结果如下：

T = ("1, 2, 3")
print(T, type(T))       # 1, 2, 3 <class 'str'>
T = ({"key1" : "value1"})
print(T, type(T))       # {'key1': 'value1'} <class 'dict'>
T = ([1, 2, 3])
print(T, type(T))       # [1, 2, 3] <class 'list'>

在（小括号）中添加“双引号”string型，结果成了string字符串类型的数据类型

在（小括号）中添加{大括号}dict型，结果成了dict字典类型的数据类型

在（小括号）中添加【方括号】list型，结果成了list列表类型的数据类型

我们的元祖tuple真是个小淘气，里面加了其他的数据类型就变了一个数据类型，外面的（小括号）也没用咯~~

set  — 集合

集合（简称集）是数学中一个基本概念，它是集合论的研究对象，集合论的基本理论直到19世纪才被创立。最简单的说法，即是在最原始的集合论——朴素集合论中的定义，集合就是“一堆东西”。集合里的“东西”，叫作元素。若x是集合A的元素，则记作x∈A。集合是把人们的直观的或思维中的某些确定的能够区分的对象汇合在一起，使之成为一个整体(或称为单体)，这一整体就是集合。组成一集合的那些对象称为这一集合的元素（或简称为元）。现代数学还用“公理”来规定集合。最基本公理例如：外延公理：对于任意的集合S1和S2，S1=S2当且仅当对于任意的对象a，都有若a∈S1，则a∈S2；若a∈S2，则a∈S1。无序对集合存在公理：对于任意的对象a与b，都存在一个集合S，使得S恰有两个元素，一个是对象a，一个是对象b。由外延公理，由它们组成的无序对集合是唯一的，记做{a,b}。 由于a，b是任意两个对象，它们可以相等，也可以不相等。当a=b时，{a,b}，可以记做或，并且称之为单元集合。空集合存在公理：存在一个集合，它没有任何元素。

 

set集合最主要的一个点就是，它可以去重。

 

以上摘抄至百度，也就是一个数学的概念，那么在pycharm中是一个怎么样的解释呢。官方解释如下：

class set(object):
    """
    set() -> new empty set object
    set(iterable) -> new set object
    
    Build an unordered collection of unique elements.
    """

那么在环境中如何创建一个set集合出来呢：

a = set(1,2,3)
print(a, type(a))
# TypeError: set expected at most 1 arguments, got 3
# TyperError:集合最多创建一个参数

a = set(1)
print(a, type(a))
# TypeError: 'int' object is not iterable
# 大致就是说int型也不行

以上错误示范，贴上来是为了提醒我自己的，那么正确的应该如何创建呢？

a = set("hello world!")
print(a, type(a))
# {'o', 'e', 'd', 'l', '!', 'r', 'w', 'h', ' '} <class 'set'>

我们得到了一个由hello world！拆分成的一个个单独字符，并且他们是无序的排列在set中。接着我们来尝试，在set中加上大括号，中括号，及小括号

#小括号的使用如下
b = ("hello world!")
a = set(b)
print(a, type(a))   # {'d', 'h', 'l', '!', ' ', 'r', 'o', 'e', 'w'} <class 'set'>

我们可以发现在set集合中添加上小括号，得到的还是一个set集合，但是有一点需要注意：小括号中包含引号，则成为一个str类型的数据，也就是说和上面的正确示范无区别。

# 中括号的使用
b = ["hello world!"]    # <class 'list'>
a = set(b)
print(a, type(a))   # {'hello world!'} <class 'set'>

在set集合中使用  [  中括号list列表  ]  数据类型，依旧可以得到一个set集合的数据类型，并且输出的为一个有序的字符串类型。

# 大括号的使用
a = {"key" : "value"}       # {'key': 'value'} <class 'dict'>
b = set(a)
print(b ,type(b))       # {'key'} <class 'set'>

在set集合中使用 {  大括号dict字典  }  数据类型，依旧可以得到一个set集合的数据类型，但是只输出了一个key值，并没有输出整的键值对。

 bool  —  布尔值

bool表示布尔型变量，也就是逻辑型变量的定义符，以英国数学家、布尔代数的奠基人乔治·布尔（George Boole）命名。并且处在大多数计算机编程语言中。表示真假，官方解释如下：

class bool(int):
    """
    bool(x) -> bool
    
    Returns True when the argument x is true, False otherwise.
    The builtins True and False are the only two instances of the class bool.
    The class bool is a subclass of the class int, and cannot be subclassed.
    """

那么在实际使用中，应该如何处理呢？

a = 1
print(a == 2)       # False
b = "hello"
print(b == "hello")      # True
print(True + False + 2)     # 3
x = y = (1,2,3)
z = (1,2,3)
print(x == z)        # True
print(id(x) == id(y))       # True
print(id(x) == id(z))       # Flase

任何值都可以作为bool值去使用，所以不需要强转成一个固定的数据类型去鉴定True or Flase，bool不仅可以用来判断正误，也可以用参与计算，顺便一提，即使两个数据类型完全相同并且所含的元素也相同时，但其的id，即开辟的内存地址不同。

第二篇原创的博客~后面会详细的各种数据类型所包含的各种方法。

 

 

竟然看完了，有什么意见可以在下面评论。谢谢观看~~