精华内容
下载资源
问答
  • Python数据类型

    千次阅读 2021-08-15 15:23:20
    数据类型 整数型:int型,正、负整数 浮点型:float型,由小数和整数构成 字符串:文本的数据类型 布尔型:True或者False 复数:由实部和虚部构成,数据分析中很少用 可以通过相关函数进行数据类型转换。 字符...

    数据类型

    • 整数型:int型,正、负整数
    • 浮点型:float型,由小数和整数构成
    • 字符串:文本的数据类型
    • 布尔型:True或者False
    • 复数:由实部和虚部构成,数据分析中很少用

     可以通过相关函数进行数据类型转换。

    字符串

    • 字符串用str函数或者引号来进行创建
    • 字符串通过[]来进行访问
    • 字符串中的元素是不可变的
    • 字符串的使用
    abc='I like python very much'  # 字符串的创建
    abc[1]  # 访问第二个字符
    abc[2:3]  # 访问第三个字符,注意:在python中,切片区间是左闭右开的
    abc*3  # 字符串复制3次
    abc[0]='u'  # 会报错

    展开全文
  • Python 数据类型

    千次阅读 2017-04-08 14:55:49
    Python 中的每个值都有一个数据类型。 在 Python 编程中,一切(万物)皆对象,数据类型实际上是类,变量是这些类的实例(对象)。

    简述

    Python 中的每个值都有一个数据类型。

    在 Python 编程中,一切(万物)皆对象,数据类型实际上是类,变量是这些类的实例(对象)。

    | 版权声明:一去、二三里,未经博主允许不得转载。

    数据类型

    Python 中有各种数据类型,下面列出了一些重要类型:

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

    Number(数字)

    Python 支持三种不同的数字类型:

    • int(整型)
    • float(浮点型)
    • complex(复数)

    注意: Py3.x 去除了 long 类型,现在只有一种整型 - int,表示为长整型。

    可以使用 type() 函数获取变量或值的类型,使用 isinstance() 函数来检查一个对象是否属于一个特定的类。

    >>> i = 5  # 整型
    >>> type(i)
    <class 'int'>
    >>> 
    >>> f = 2.5  # 浮点型
    >>> type(f)
    <class 'float'>
    >>> 
    >>> c = 1+2j  # 复数
    >>> type(c)
    <class 'complex'>
    >>> 
    >>> isinstance(c, complex)
    True

    整数可以是任何长度,只受到可用内存的限制。

    浮点数精确到 15 位小数。

    复数以 x + yj 的形式写成,其中 x 是实部,y 是虚部。

    >>> i = 2 ** 500  # 2 的 500 次幂
    >>> i
    3273390607896141870013189696827599152216642046043064789483291368096133796404674554883270092325904157150886684127560071009217256545885393053328527589376
    >>> 
    >>> f = 0.12345678901234567890
    >>> f
    0.12345678901234568  # 值被截断
    >>> 
    >>> c = 5+6j
    >>> c
    (5+6j)

    String(字符串)

    字符串是 Unicode 字符的序列。

    可以使用单引号('')或双引号("")来表示字符串,多行字符串可以使用三重引号 '''""" 来表示。

    >>> s = 'Hello, Python!'
    >>> type(s)
    <class 'str'>

    各种表示方式:

    >>> s = 'Hello, Python!'  # 单引号
    >>> s
    'Hello, Python!'
    >>> 
    >>> s = "Hello, World!"  # 双引号
    >>> s
    'Hello, World!'
    >>> 
    >>> s = '''Hello,  # 三重单引号
    ... Python!'''
    >>> s
    'Hello,\nPython!'
    >>> 
    >>> s = """  # 三重双引号
    ... Hello,
    ... World!
    ... """
    >>> s
    '\nHello,\nWorld!\n'

    字符串可以被索引和截取,截取的语法格式如下:

    变量[头下标:尾下标]

    索引值以 0 开始,-1 为从末尾的开始位置。

    >>> s = "Hello, World!"
    >>>
    >>> s[4]  # 第五个字符
    'o'
    >>>
    >>> s[7:10]  # 第八个开始到第十个的字符
    'Wor'
    >>>
    >>> s[-4:-1]  # 倒数第四个开始到倒数第一个的字符
    'rld'
    >>>
    >>> s[5] = 'p'  # 生成错误,字符串是不可变的
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'str' object does not support item assignment

    加号(+)是字符串的连接符, 星号(*) 表示复制当前字符串,紧跟的数字为复制的次数。

    >>> s1 = "Hello,"
    >>> s2 = " World!"
    >>>
    >>> s1 + s2  # 连接字符串
    'Hello, World!'
    >>>
    >>> (s1 + s2) * 3  # 复制 3 次字符串
    'Hello, World!Hello, World!Hello, World!'

    List(列表)

    列表是有序的元素序列,它是 Python 中使用最频繁的数据类型,非常灵活。

    列表中元素的类型可以不同,支持数字、字符串,甚至可以包含列表(所谓的嵌套)。

    列表用 [] 标识,内部元素用逗号分隔。

    >>> l = [1, 5.5, 'Python']
    >>> type(l)
    <class 'list'>

    和字符串一样,列表同样可以被索引和截取,列表被截取后返回一个包含所需元素的新列表。

    >>> l = [3, 2, 5, 4, 1]
    >>> l
    [3, 2, 5, 4, 1]  # 有序
    >>> 
    >>> l[2]  # 第三个元素
    5
    >>> 
    >>> l[0:3] # 从第一个元素到第三个元素
    [3, 2, 5]
    >>> 
    >>> l[3:] # 从第三个元素开始的所有元素
    [4, 1]

    列表是可变的,意思是说,列表中元素的值可以被改变。

    >>> l = [1, 2, 3]
    >>> l[2] = 5  # 将第三个元素 3 变为 5
    >>> l
    [1, 2, 5]

    Tuple(元组)

    元组与列表相同,也是有序序列,唯一的区别是元组是不可变的。

    元组适用于保护性的数据,通常比列表快,因为它不能动态更改。

    元组用 () 标识,内部元素用逗号分隔。

    >>> t = (5, 'Python', 1+2j)
    >>> type(t)
    <class 'tuple'>

    元组也可以被索引和截取,但是不能被更改。

    >>> t = (3, 2, 5, 4, 1)
    >>> t
    (3, 2, 5, 4, 1)  # 有序
    >>> 
    >>> t[1]  # 第二个元素
    2
    >>> 
    >>> t[0:2] # 从第一个元素到第二个元素
    (3, 2)
    >>> 
    >>> t[0] = 10  # 生成错误,元组是不可变的
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'tuple' object does not support item assignment

    虽然元组中的元素不可变,但它可以包含可变的对象,例如:List(列表)。

    构造一个空的或者包含一个元素的元组比较特殊,所以要采用一些额外的语法规则:

    >>> tup1 = ()  # 空元组
    >>> tup2 = (5, )  # 一个元素,需要在元素后添加逗号

    Set(集合)

    集合是一个无序不重复元素集。

    集合用 {} 标识,内部元素用逗号分隔。

    可以使用大括号 {} 或者 set() 函数创建集合,注意: 要创建一个空集合,必须使用 set() 而不是 {},因为 {} 用于创建一个空字典。

    >>> s = {5, 'Python', 1+2j}
    >>> type(s)
    <class 'set'>

    既然集合是无序的,那么索引就没有任何意义,也就是说,切片操作符 [] 不起作用。

    >>> s = {"Java", "Python", "PHP"}
    >>> s
    {'PHP', 'Python', 'Java'}  # 无序
    >>> 
    >>> s[1]  # 生成错误,不支持索引
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'set' object does not support indexing

    不重复,是指集合中相同的元素会被自动过滤掉,只保留一份。

    >>> s = {"PHP", "Python", "Java", "Python", "PHP"}
    >>> s
    {'PHP', 'Python', 'Java'}  # 去重

    除了去重之外,还常用于成员关系的测试。

    >>> if ('Python' in s) :
    ...      print('Python 在集合中')
    ... else :
    ...      print('Python 不在集合中')
    ... 
    Python 在集合中

    集合之间也可执行运算,例如:并集、差集、交集。

    >>> a = set('abcdefg')
    >>> b = set('abghijk')
    >>> 
    >>> a
    {'b', 'f', 'e', 'd', 'a', 'c', 'g'}
    >>> b
    {'b', 'k', 'h', 'i', 'j', 'a', 'g'}
    >>> 
    >>> a - b  # 差集
    {'f', 'c', 'd', 'e'}
    >>> 
    >>> a | b  # 并集
    {'b', 'k', 'f', 'h', 'i', 'e', 'j', 'd', 'a', 'c', 'g'}
    >>> 
    >>> a & b  # 交集
    {'b', 'a', 'g'}
    >>> 
    >>> a ^ b  # 对称差 - 不同时存在的元素
    {'e', 'c', 'k', 'f', 'h', 'i', 'j', 'd'}

    对称差公式:A Δ B = (A − B) ∪(B − A)。也可表示为两个集合的并集减去它们的交集:A Δ B = (A ∪B) − (A ∩B)

    Dictionary(字典)

    字典是键值对的无序集合。

    通常在有大量的数据时会使用,在检索数据时字典做了优化,必须知道要检索的 value 所对应的 key。

    字典用 {} 标识,其中的每个元素都以 key:value 对的形式出现,key 和 value 可以是任何类型。

    注意: 字典中的 key 必须是唯一的。

    >>> d = {1:'value', 'key':2}
    >>> type(d)
    <class 'dict'>

    可以用 key 来检索相应的 value,但相反则不行。

    >>> d = {}  # 创建空字典
    >>> d['name'] = 'Python'  # 增加新的键/值对
    >>> d['site'] = 'www.python.org'
    >>> 
    >>> d
    {'name': 'Python', 'site': 'www.python.org'}
    >>> 
    >>> d['site']  # 键为 'site' 的值
    'www.python.org'
    >>> 
    >>> d['Python']  # 生成错误,不能用 value 检索 key
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    KeyError: 'Python'

    字典有一些内置的函数,例如:keys()、values()、clear() 等。

    >>> d.keys()  # 所有键
    dict_keys(['name', 'site'])
    >>> 
    >>> d.values()  # 所有值
    dict_values(['Python', 'www.python.org'])
    >>> 
    >>> d.clear()  # 清空字典
    >>> d
    {}

    数据类型之间的转换

    可以使用不同的类型转换函数来转换不同的数据类型,例如:int()、float()、str() 等。

    从 int 转换为 float:

    >>> float(5)
    5.0

    从 float 到 int 的转换,值将会被截断(使其接近零):

    >>> int(10.8)
    10
    >>> 
    >>> int(-10.8)
    -10

    字符串的转换必须包含兼容的值:

    >>> float('2.5')
    2.5
    >>> 
    >>> str(25)
    '25'
    >>> 
    >>> int('str')
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ValueError: invalid literal for int() with base 10: 'str'

    甚至可以将一个序列转换为另一个序列:

    >>> set([1, 2, 3])
    {1, 2, 3}
    >>> 
    >>> tuple({4, 5, 6})
    (4, 5, 6)
    >>> 
    >>> list('hello')
    ['h', 'e', 'l', 'l', 'o']

    要转换为字典,每个元素必须是一对:

    >>> dict([[1, 'value'], ['key', 2]])
    {1: 'value', 'key': 2}
    展开全文
  • python数据类型

    千次阅读 2016-04-08 21:00:38
    1. 数据类型分类python大约有以下8种数据类型,分别是: Number(数字) String(字符串) List(列表) Tuple(元组) Sets(集合) Dictionary(字典) None(空类型) Object(对象类型) Number类型: Python3 ...

    1. 数据类型分类

    python大约有以下8种数据类型,分别是:

    1. Number(数字)
    2. String(字符串)
    3. List(列表)
    4. Tuple(元组)
    5. Sets(集合)
    6. Dictionary(字典)
    7. None(空类型)
    8. Object(对象类型)

    (1)Number(数字)类型:

     Python3 中支持 int、float、bool、complex(复数),在Python 3里,只有一种整数类型 int,表示为长整型,没有 python2 中的 Long。

    1. Python可以同时为多个变量赋值,如a, b = 1, 2。
    2. 一个变量可以通过赋值指向不同类型的对象。
    3. 数值的除法(/)总是返回一个浮点数,要获取整数使用//操作符。
    4. 在混合计算时,Python会把整型转换成为浮点数。

    (2)String(字符串)类型:

     Python中的字符串用单引号(‘)或双引号(“)括起来,同时使用反斜杠(\)转义特殊字符。

    1. 反斜杠可以用来转义,使用r可以让反斜杠不发生转义,如r’\tbc’就显示成’\tbc’而不会解析\t为制表符。
    2. 字符串可以用+运算符连接在一起(和java一样,php用.运算符),用*运算符重复。
    3. Python中的字符串有两种索引方式,从左往右以0开始,从右往左以-1开始。如:

      str = 'abcdef'
      s1 = str[2] # s1值为'c'
      s2 = str[-2] # s2值为'e'
    4. Python中的字符串不能改变,即`str[2] = ‘g’是错的,不能改变str的组成字符。

    5. Python中也提供了许多字符串操作方法,如split()截取字符串,encode(),decode()编码解码方法等等。
    6. Python中没有java/c/c++中的字符char类型,只包含一个字符的字符串就是Python中的字符类型。
    7. 字符串的截取可以用split()方法,也可以通过下面的语法进行截取:

      str = 'abcdef'
      s = str[:3] # 值为'abc'
      s = str[1:3] # 值为'bc'
      s = str[3] # 值为'd'
      s = str[1:6:2] # 值为'bdf'
      s = str[3:] # 值为'def'

    (3)List(列表)类型:

     Python中的List的学习其实可以类比java的List的学习。Python中的列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同,它支持数字,字符串甚至可以包含列(所谓嵌套)。列表是写在方括号([])之间、用逗号分隔开的元素列表。和字符串一样,列表同样可以被索引和截取,列表被截取后返回一个包含所需元素的新列表。

    • 创建空列表(使用list()或[]):

      l = list() # 也可以通过[]创建空列表,即list = []
    • 创建普通列表(使用[])

      l = ['a',10,'b',1 + 3j,5.5]
    • List提供了许多操作方法,如append(),pop(),remove(),sort(),extend(),count(),index(),insert()等等

    注意:

    1. List写在方括号之间,元素用逗号隔开,可以包含重复元素(和java一样)。
    2. 和字符串一样,list可以被索引和切片,即取元素和截取。
    3. List可以使用+操作符进行拼接,也可以使用*进行重复操作,如:

      l = ['a',10,'b',1 + 3j,5.5]
      l2 = l + l # l2的值为:['a', 10, 'b', (1+3j), 5.5, 'a', 10, 'b', (1+3j), 5.5]
      l3 = l * 2 # l3的值为:['a', 10, 'b', (1+3j), 5.5, 'a', 10, 'b', (1+3j), 5.5]
    4. List中的元素是可以改变的。

    (4)Tuple(元组)类型:

     元组(tuple)与列表类似,不同之处在于元组的元素不能修改。元组写在小括号(())里,元素之间用逗号隔开。元组中的元素类型也可以不相同,也可以包含相同的元素。

    • 创建空列表(使用[]):

      t =() 
    • 创建普通列表(使用())

      t = ('a',10,'b',1 + 3j,5.5)

    说明,读操作基本和List列表一样,需要注意的是Tuple中的元素是不能改的(只读),而List中的元素是可以改的,所以Tuple自然也就没了insert(),append(),pop(),reverse(),remove(),extend(),sort()等可能改变元组元素结构的方法了,也不能通过tuple[index] = value赋值

    注意:

    1. 虽然tuple的元素不可改变,但它可以包含可变的对象,比如list列表。
    2. 可以将tuple当成一个只读的List。
    3. 构造空元组可以用(),需要注意的是tuple没有tuple()方法来构建空元组,同时需要注意只包含一个元素的元组的创建规则:

      nullTuple = () # 构建空元组
      t = (10,) # 一个元素的元组,一定要在元素后添加逗号,否则表示一个整数

    (5)Set(集合)类型:

     集合(set)是一个无序不重复元素的序列。基本功能是进行成员关系测试和删除重复元素。可以使用大括号({})或者 set()函数创建集合。

    • 创建空集合(使用set()):

      s = set()
    • 创建普通集合(使用{})

      s = {'a',10,'b',1 + 3j,5.5}
    • 进行成员测试(使用in关键字)

      s = {'a',10,'b',1 + 3j,5.5}
      if( 'b' in s):
          print('b在集合中')
      else:
          print('b不在集合中')
    • 进行集合运算

      s1 = {'a','b','c'}
      s2 = {'b','c','e'}
      print(s1 - s2)     # a和b的差集,结果为{'b'}
      print(s1 | s2)     # a和b的并集,结果为{'a','b','c','e'}
      print(s1 & s2)     # a和b的交集,结果为{'b','c'}
      print(s1 ^ s2)     # a和b中不同时存在的元素,结果为{'a','e'}

    (6)Dictionary(字典)类型:

     字典(dictionary)是Python中另一个非常有用的内置数据类型。列表是有序的对象结合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。字典是一种映射类型,字典用”{ }”标识,它是一个无序的键(key) : 值(value)对集合。键(key)必须使用不可变类型。

    在同一个字典中,键(key)必须是唯一的。可以类比java的Map来学习。

    • 创建空字典(使用dict()或{}):

      d = dict() # 创建空字典,也可以用{}创建,如d = {}
    • 创建普通字典(使用{})

      d = {1:'a','a':10,'c':'b',5.6:1 + 3j,100:5.5}
    • 字典的内置函数

      1. keys():返回字典中所有的键构成的一个序列
      2. values():返回字典中所有的值构成的一个序列
      3. clear():清空字典
      4. items():返回由(key,value)组成的一个序列,可用于同时遍历出字典的键和值
      5. pop():
      6. popitem():
      7. update():
      8. copy:

    注意:

    1. 字典是一种映射类型,它的元素是键值对 ,类似java的Map。
    2. 字典的键必须为不可变类型,且不能重复。
    3. 创建空字典使用 { }。

    (7)None(空类型):

     有点类似java中的null,c/c++中的NULL,但None类型不能用于计算,因为它不像True,Flase一样代表一个数字。

    (8)Object(对象类型):

     Python中的所有数据类型都是Object类型,还可以自己自定义类型,也就是创建类。

    2. 类型转换

     由于Python的类型检查没那么严格,也没有变量类型声明,同一个变量可以指向不同的数据类型,我们只管给变量赋值然后使用就行了,但,有时候,我们需要对数据内置的类型进行转换,数据类型的转换,Python给我们提供了相应的函数,如:int(),str(),float(),set(),list(),tuple(),dict()等等,使用都很简单,可以参考Python手册。

    一点技巧:可以使用内置的type()函数得到变量的类型,这对于变量类型的把握很有帮助

    总结:

     使用标识符名名会发生一些意向不到的错误,尽量不要用标识符命名,因为Python的灵活性会导致一些意想不到的错误,如下图所示:

    这里写图片描述

     这个错误的原因很简单,因为list这个标识符在Python中和int,str,float一样代表一种类型,这里list = [‘a’,’b’,’c’]改变了list这个关键字的含义。这里我猜想的原因是list关键字是一个指向type类型的对象变量,这时如果我们使用list()者会调用list指向的对象的__call__方法,然后__call__中给我们返回了一个List。而如果我们给list这个变量赋别的值后,list不再指向原来的那个type类型对象了,也就不会调用那个对象的__call__方法返回一个列表了,这里由于我没看过源码,只是个人猜测,等以后再去看Python的源码来补充了。

    展开全文
  • Python数据类型有哪些,哪些是可变类型,哪些是不可变类型? 类型: 整数int 字符串str 浮点数float 布尔型bool 列表list 字典dict 集合set 元组tuple 可变类型:就是这个数据类型的值在不改变这一块内存空间,而去...

    Python数据类型有哪些,哪些是可变类型,哪些是不可变类型?

    类型:

    整数int 字符串str 浮点数float 布尔型bool 列表list 字典dict 集合set 元组tuple

    可变类型:就是这个数据类型的值在不改变这一块内存空间,而去改变这个数据类型的值。

    1.列表
    2.字典
    3.集合

    不可变类型:当改变值得时候,会申请一块新的内存空间,不再是原来的那一块内存空间了。

    1. 整数
    2. 字符串
    3. 浮点数
    4. 布尔型
    5. 元组
    展开全文
  • Python数据类型——逻辑值详解

    千次阅读 多人点赞 2020-05-17 17:57:44
    在上一篇博客:Python数据类型——数值型详解 中介绍了Python数据类型中数值型部分。本篇我们来一块学习一下Python数值类型的逻辑值与字符串部分。
  • c++与python 数据类型对应

    千次阅读 2017-11-14 23:30:09
    c++与python 数据类型对应
  • python数据类型总结

    千次阅读 多人点赞 2019-04-01 19:57:48
    一、python数据类型分类思维导图 二、值得注意的是: 1、Python中的变量都是指针,因此是没有类型限制的,且指针的内存空间大小是与类型无关的,其内存空间只是保存了所指向数据的内存地址。 2、值类型是不可变的...
  • Python数据类型——数值型详解

    千次阅读 多人点赞 2020-05-14 00:52:54
    上一篇博客:Python的变量和数据类型 简单的写了一下Python中的数据类型有哪些,本篇我们来详细的学习一下Python中的数据类型以及其应用。
  • Python数据类型有哪些?

    千次阅读 2018-10-30 13:39:52
    只有给数据赋予明确的数据类型,计算机才能对数据进行处理运算,因此,正确使用数据类型是十分必要的,不同的语言,数据类型类似,但具体表示方法有所不同,以下是Python编程常用的数据类型: 1. 数字类型 Python...
  • Python数据类型,变量,进制,常见函数 通过type()函数查看数据的类型 print ( 10 )----------#10 print ( type ( 10 ) )----------#<class ‘int’> 整数 print(12.32)----------#12.32 print ( type ( 12.32...
  • list和dict是python数据类型;series是pandas的一种数据类型,Series是一个定长的,有序的字典,因为它把索引和值映射起来了。通过以下例子,可以更加清楚它们的数据表示。1、list to others# list data = [[2000...
  • Python数据类型有几种

    万次阅读 2019-01-22 18:14:01
    只有给数据赋予明确的数据类型,计算机才能对数据进行处理运算,因此,正确使用数据类型是十分必要的,不同的语言,数据类型类似,但具体表示方法有所不同,以下是Python编程常用的数据类型:1. 数字类型Python数字...
  • python数据类型complex

    千次阅读 2019-07-02 15:45:47
    很久以来,在使用Python语言的时候尽管知道存在这个6大基本数据类型之一的complex复数类型,但是一直没有使用过,也不知道怎么打出一个complex数据,直到在学在学矩阵共轭转置时,才初步了解了复数这个数据类型,...
  • 1.键的遍历 for 变量i in 字典: 使用i遍历所有的键,有键就可以通过变量访问其值 2.键值遍历 for 变量i,变量j in 字典.items(): 使用变量i遍历所有键,通过变量j遍历所有值

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 744,642
精华内容 297,856
关键字:

python数据类型

python 订阅