精华内容
下载资源
问答
  • 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学习之路】Python 数据类型

    万次阅读 2019-12-15 20:58:06
    Python 数据类型 常用数据类型 Common Data Types 类型 例子 整数 -100 浮点数 3.1416 字符串 'hello' 列表 [1, 1.2, 'hello'] 字典 {'dogs': 5, 'pigs': 3} Numpy数组 array([1, 2, 3]) 其他...

    Python 数据类型

    常用数据类型 Common Data Types

    类型 例子
    整数 -100
    浮点数 3.1416
    字符串 'hello'
    列表 [1, 1.2, 'hello']
    字典 {'dogs': 5, 'pigs': 3}
    Numpy数组 array([1, 2, 3])

    其他类型 Others

    类型 例子
    长整型 1000000000000L
    布尔型 True, False
    元组 ('ring', 1000)
    集合 {1, 2, 3}
    Pandas类型 DataFrame, Series
    自定义 Object Oriented Classes
    展开全文
  • Python数据类型 1、 数字类型,int ,float,long,complex 整形、浮点型、长整形、复合类型 2、字符串类型 string 3、字符串索引,切片 数据类型间的转换 格式化字符串 字符串格式化符号

    Python数据类型之数字类型、字符串类型

    在讲Python基本数据类型前,我们先来看一下Python中有3个基本函数,对我们以后的学习会有很大的帮助。

    type()

    判断类型的方法

    >>> a = 1
    >>> type(a)
    <type 'int'>
    >>> list1 = []
    >>> st = 'sdf'
    >>> type(st)
    <type 'str'>
    >>> type(list1)
    <type 'list'>
    dir()

    列出某个类型或模块中所有的方法,参数可以是类型type或类型的对象!

    实例:

    列出字符串数据类型所有的方法

    >>> str1 = 'ad'
    >>> dir(str1) 或 dir("")
    ['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__
    format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__get
    slice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mo
    d__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
     '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook
    __', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center',
     'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index
    ', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper',
    'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', '
    rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', '
    strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
    列出列表类型所有的方法
    >>> list1 = []
    >>> dir(list1) 或 dir([])
    ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delsli
    ce__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getit
    em__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__',
     '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__r
    educe__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__'
    , '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'a
    ppend', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'
    ]
    对于列出的这些方法中,我们主要关注的就是没有用下划线定义的方法。

    help()
    help函数是python的一个内置函数,无需import,任何时候都可以直接被使用。
    在使用python来编写代码时,会经常使用python自带函数或模块,但是有时候会对一些函数或是模块的用途不是很清楚,这时候就可以使用help函数来查看帮助。
    这里要注意下,help()函数是查看函数或模块用途的详细说明,而dir()函数是查看函数或模块内的操作方法都有什么,输出的是方法列表。
    实例:

    查看dir函数的具体用法

    >>> help(dir)
    Help on built-in function dir in module __builtin__:
    
    dir(...)
        dir([object]) -> list of strings
    
        If called without an argument, return the names in the current scope.
        Else, return an alphabetized list of names comprising (some of) the attribut
    es
        of the given object, and of attributes reachable from it.
        If the object supplies a method named __dir__, it will be used; otherwise
        the default dir() logic is used and returns:
          for a module object: the module's attributes.
          for a class object:  its attributes, and recursively the attributes
            of its bases.
          for any other object: its attributes, its class's attributes, and
            recursively the attributes of its class's base classes.
    
    查看list模块中count函数的用法

    >>> help(list.count)
    Help on method_descriptor:
    
    count(...)
        L.count(value) -> integer -- return number of occurrences of value
    
    查看字符串模块中的index函数的用法

    >>> str1 = 'asd'
    >>> help(str1.index)
    Help on built-in function index:
    
    index(...)
        S.index(sub [,start [,end]]) -> int
    
        Like S.find() but raise ValueError when the substring is not found.

    1、 数字类型

    python中数字类型有分为如下几种类型:

    • 整型 - int
    • 长整型 - long
    • 浮点型 - float
    • 复数型 - complex

             Python是一种弱类型语言,所以变量都是不需要提前声明,可以直接拿来使用。

    1)整型int表示的范围是-2147483648到2147483647,如12,600,-120等。

          int范围的示例:

    >>>num = 567
    >>>print num
    567
    >>>type(num)  #查看num的数据类型
    <type'int'>
    #当num变量的值超过int能表示的范围后,num的数据类型就自动被切换成长整形。
    >>>num = 1234567891234567897890678956789
    >>>type(num)
    <type'long'>    
    #直接定义一个长整形,后面要以L或l标示
    >>>num1 = 123L
    >>>type(num1)
    <type'long'>

    2)浮点型

             比如:1.2,   12342.56, 0.0等。

             变量在定义赋值时,只要给赋值小数,该变量就被定义成浮点型。        

    >>>type(f)
    <type'float'>
    >>>f / 2
    6.25

    3)复数类型

           Python对复数提供内嵌支持,这也是python的亮点。如1.26j,8.1e-21j

           Python中复数的虚部用字母j表示。示例如下:     

    >>>cc = 1.56j
    >>>type(cc)
    <type'complex'>

          Python的复数类型可以用在抛物线的计算中。

    2、字符串String

     字符串是由数字、字母、下划线组成的一串字符。

    字符串的字符串的定义:

    #普通字符串的定义
    >>> s1 = 'adf\nsd'
    >>> print s1
    adf
    sd
    >>> type(s1)
    <type 'str'>
    
    #原生字符串的定义
    >>> s2 = r'asd\n23'
    >>> print s2
    asd\n23
    >>> type(s2)
    <type 'str'>
    
    #Unicode字符串的定义(只需在定义字符串时前面加一个字母 u)
    >>> s3 = u'aer23'
    >>> print s3
    aer23
    >>> type(s3)
    <type 'unicode'>

    原始字符串:所有的字符串都是直接按照字面的意思来使用,没有转义特殊或不能打印的字符。原始字符串除在字符串的第一个引号前加上字母“ r ”(不区分大小写)以外,与普通字符串有着几乎完全相同的语法。

    python接收单引号(')、双引号(")、三引号(''' / """)来表示字符串,引号的开始与结束类型必须一致,也就是说前面是单引号,后面也必须是单引号。其中三引号可以由多行组成,这也是编写多行文本的常用语法,经常用于处理文档字符串,但在文件的特定地点,会被当做注释来处理。示例如下:         

    >>>str = "This is the first python program!"
    >>>print str
    Thisis the first python program!
    >>>type(str)
    <type'str'>
    >>>str1 = 'first'
    >>>type(str1)
    <type'str'>
    >>>str2 = '''三引号'''
    >>>print str2
    三引号
    >>>type(str2)
    <type'str'>

             但会出现这种情况,字符串中本身就含有单引号或者双引号或者三引号时,那么我们定义字符串的时候,就必须避免使用跟字符串本身一样的引号类型来定义字符变量,或者用反斜杠(\)将字符串中的引号进行转义,否则就会报错。示例如下:       

    >>>st = "this is 'ss'"
    >>>print st
    thisis 'ss'
    >>>st1 = 'this is "bb"'
    >>>print st1
    thisis "bb"
    >>>st2 = "this is \"cc\""
    >>>print st2
    thisis "cc"
    #当我们想进行换行打印时,又该怎么做呢?
    >>>st2 = "this\nis\ncc"
    >>>print st2
    this
    is
    cc

             在定义变量时,在字符串中间加一换行符(\n),print在打印时,加了\n处就会被折行打印。但是这样的格式打印,有时候编写起来会比较费劲,此时我们的三引号就派上用场了。如:       

    >>>st3 = ''' this
    ...             is
    ...             the
    ...             last
    ...   one
    ...'''
    >>>print st3
    this
                      is
                      the
                      last
    one

             看到打印的结果了吗?查看一下st3变量的内容       

    >>>st3
    'this \n\t\tis \n\t\tthe\n\t\tlast\n one\n'

             它会自动在字符串中记录我们编写的格式,并添加相应的表示格式的符号。

             字符串、列表、元组都被称为序列类型的数据。什么叫序列类型的数据呢?后续将会介绍。

             作为一个字符串,其实它里面的每一个字符都有自己独立的空间,那就是说我们可以直接取出单个的字母或者某一个子串。每一个字母都会有一个相应的索引(所谓索引就是指向该字母存放空间的地址,这个值是唯一的),并且这个索引值是从0开始的,类似于java语言中的数组。     

    #取单个的字符
    >>>str = "abcdefg"
    >>>str[0]  #输出字符串中的第一个字符
    'a'
    >>>str[1]  #输出字符串中的第二个字符
    'b'

             python的字符串还支持一次取多个字符,这就涉及到从字符串列表中取值顺序的问题了,常见的有两种取值顺序:

             1、从左到右取,最大范围是字符串的长度减1,默认的索引从0开始。

             2、从右到左取,最大的范围字符串开头,默认索引从-1开始。

             取子串时,可以通过[头下标:尾下标],就可以截取相应的字符串(也叫字符串的切片),下标可以为整数或负数,可以为空表示取到头或尾(注:这种取法只包括左边界,不包括右边界)。比如:  

    >>>str = "abcdefg"
    >>>len(str)  #计算一下字符串的长度
    7
    >>>str[2:4]  #取下标为2到4但不包括下标为4的子串
    'cd'
    >>>str[1:]  #从下标1开始取到尾
    'bcdefg'
    >>>str[:5]  #从开头,也就是下标为0开始,取到下标为5的子串,但不包括5
    'abcde'
    >>>str[::2]  #从头开始到结尾以步长为2开始取值
    'aceg'
    >>>str[-1]  #取最后一个字符
    'g'
    >>>str[-4:-2] #从倒数第4个开始取到倒数第2个,但不包括倒数第二个位置的元素
    'de'
    >>>str[-4:-2:1] #从左往右,-4开始以步长为1取到-2,,最后一个数的正负是来控制方向的
    'de'
    >>>str[-2:-5:-1]  #从右往左,-2开始以步长为1取到-5,,最后一个数的正负是来控制方向的
    'fed'
    
    
    加号(+)是字符串的连接运算符,星号(*)是重复操作。比如:
    
    
    >>>str = "abcdefg"
    >>>print str * 2  #将字符串输出两次
    abcdefgabcdefg
    >>>print str[2] + str[0]  #输出连接后的字符串
    ca
    >>>print str + "python"  #输出连接后的字符串
    abcdefgpython

    数据类型转换

    float():变浮点型 
    >>> float('12')
    12.0
    int():变成整型
    >>> int(1.6)
    1
    int(str,base) :变成base进制整型数
    >>> int('11',2)
    3
    long(str) :变成长整型
    >>> long(123)
    123L
    >>> long('123')
    123L
    
    long(str,base) :变成base进制长整型
    >>> long('23',8)
    19L
    <pre name="code" class="python">tuple(s) :将序列 s 转换成一个元组
    >>> s = 'asdf'
    >>> tuple(s)
    ('a', 's', 'd', 'f')
    >>> list1 = [1,2,3]
    >>> tuple(list1)
    (1, 2, 3)
    
    
    <pre name="code" class="python">list(seq):将序列seq转换成一个列表
    >>> s = 'asdf'
    >>> list(s)
    ['a', 's', 'd', 'f']
    >>> tuple1 = (1,2,3)
    >>> list(tuple1)
    [1, 2, 3]
    
    
    <pre name="code" class="python">dict(seq):创建一个字典,seq必须是一个序列(key,value)元组。
    >>> list1 = [(1,2),(2,3)]
    >>> dict(list1)
    {1: 2, 2: 3}
    
    
    字符串的格式化(注意其转义字符,大多如C语言的)
    str_format % (参数列表) :参数列表是以tuple的形式定义的,即不可运行中改变
    >>> num = 'aa'
    >>> print "this is %s" %(num)
    this is aa
    

    Python字符串格式化符号:

    %c 格式化字符及其ASCII码
    %s 格式化字符串
    %d 格式化整数
    %u 格式化无符号整型
    %o 格式化无符号八进制数
    %x 格式化无符号十六进制数
    %X 格式化无符号十六进制数(大写)
    %f 格式化浮点数,可指定小数点后的位数
    %e 用科学计数法格式化浮点数
    %E 作用同%e,用科学计数法格式化浮点数
    %g %f 和%e的简写
    %G %f 和 %E的简写
    %p 用十六进制数格式化变量的地址


      

     

     

     

     

     

     

    展开全文
  • 1.4 Python数据类型

    万次阅读 2019-05-18 12:03:50
    1.4 Python的数据类型1.4 Python数据类型(1) Number(数字)(2) String(字符串)(3) List(列表)(4) Tuple(元组)(5) Set(集合)(6) Dictionary(字典)Python数据类型转换数据类型转换分类:自动数据类型转换/...
  • JSON数据类型和Python数据类型的对应关系 JSON Python object dict array list string str number(int/real) int/float true/false True/False null None Python JSON dict object ...
  • http://blog.csdn.net/pipisorry/article/details/23624041?locationNum=5&fps=1Python中基本数据类型占的字节数下面的测试都是64位系统,python3输出的结果Python 对象内存占用sys.getsizeof()或者i.__sizeof__()...
  • list和dict是python数据类型;series是pandas的一种数据类型,Series是一个定长的,有序的字典,因为它把索引和值映射起来了。通过以下例子,可以更加清楚它们的数据表示。1、list to others# list data = [[2000...
  • Python 数据类型及其用法

    万次阅读 2013-08-21 18:54:17
    本文总结一下Python中用到的各种数据类型,以及如何使用可以使得我们的代码变得简洁。 基本结构 我们首先要看的是几乎任何语言都具有的数据类型,包括字符串、整型、浮点型以及布尔类型。这些基本数据类型组成了...
  • Python基本数据类型

    千次阅读 2015-09-12 08:12:40
    目录目录 前言 软件环境 基本数据类型 数值型 整型Integral 浮点型Float 复数 布尔型Bool 变量的命名规则 组合数据类型 ...最后前言Python作为一种弱类型编程语言,其数据类型较之于C/...下面一起来学习Python数据类型
  • python pandas如何转换‘object’成其他数据类型transfer the type of pvt_mean_rt transfer the type of pvt_mean_rt 老版本表达(失效) df = df.convert_objects(convert_numeric=True) 新的语法表达 df[‘pvt_...
  • python基本数据类型的特点

    千次阅读 2019-04-30 17:57:57
    Python基本数据类型的特点 Python整型和浮点型 一,python整数类型所表示的数据。 1,一般用以表示一类数值:所有正整数,0和负整数; 2,整型作为最常用的,频繁参与计算的数据类型,在pyt...
  • 导入微信服务商的数据后,想要进行data[‘申请退款金额’]-data[‘订单金额’] 发现几个坑 1.数据都带有单引号,而直接用替换data.replace(" ’ “,” ")不能解决问题 2.替换后 还是不能直接将两项相减 主要原因...
  • python中用pd.read_excel()读取数据,有时候会因为表格中含有空格而导致某一列的数据类型object类型,此时有两种方法查找空格 1 用excel表格查询,较麻烦,有的是空表格,而有的是含有空格,含有空格的左上角有...
  • Python之pandas:数据类型变换之object、category、bool、int32、int64、float64以及数据类型标准化之详细攻略 目录 数据类型变换之object、category、bool、int32、int64、float64以及数据类型标准化 ...
  • python六大数据类型详解

    万次阅读 多人点赞 2019-10-13 21:07:18
    史上最全数据类型详解,详细介绍了Python3 中六个标准的数据类型:Number(数值)、String(字符串)、List(列表)、Tuple(元组)、Set(集合)、Dictionary(字典)。六大数据类型的方法和常规操作。
  • python 数据类型:列表和元组

    千次阅读 2010-04-04 21:57:00
    列表中可以包含任何数据类型,也可以包括另一个列表。列表页可以通过序号来访问其中的成员。在脚本中可以对列表中的数据进行排序、添加、删除等操作,改变列表中的中某一成员。 元组是以圆括号()包围的数据集合。与...
  • python数据类型(int,str)转换

    万次阅读 2018-08-09 16:10:16
    input读进来是str类型; &amp;amp;lt;变量&amp;amp;gt;=&amp;amp;lt;整数&amp;amp;gt;,变量为int类型; &amp;amp;lt;变量&amp;amp;gt;=&amp;amp;lt;浮点数&amp;amp;gt;,变量为...
  • python 判断数据类型

    千次阅读 2017-12-01 15:32:39
    Python 判断数据类型有type和isinstance 基本区别在于: type():不会认为子类是父类 isinstance():会认为子类是父类类型 1 2 3 4 5 6 7 8 9 class ...
  • 初学 Python,对 object 和 type 的理解

    千次阅读 2018-04-14 22:25:50
    初学Python,关于object和type的理解 object(类)是一个类。 type(类)也是一个类。 object类是所有的类的父类的父类的父类… 即,其它所有的类都是object类的子类,(而并非它的实例(类变量))。 type类是...
  • Python判断数据类型

    千次阅读 2019-10-28 17:16:36
    判断数据类型方法 有type和isinstance 基本区别在于: type():不会认为子类是父类 isinstance():会认为子类是父类类型 class Color(object): pass class Red(Color): pass print type(Color()) == Color # ...
  • python-Object数据处理

    2020-04-15 14:51:38
    数据来源 https://towardsdatascience.com/encoding-categorical-features-21a2651a065c https://github.com/liuy14/Kidney_Disease_Detection LabelEncoder LabelEncoder可以自己处理缺失值 missing_values_table(X...
  • >>> a = 'Javier Ji' >>> a 'Javier Ji' >>> a[0] 'J' ...TypeError: 'str' object does not support item assignment >>> a = 'Chica' >>> a 'Chica'
  • Python组合数据类型四大类型总结

    千次阅读 2019-01-22 22:00:25
    (Python组合数据类型) #组合数据应用基础 Python组合数据,包含四中类型:列表(list),元组(tuple),集合(set),字典(dict)。 1. 列表 ** 列表是一种可存放多个数据,数据可以重复,有顺序,可以修改的...
  • Python数据访问模型:直接存取 ,序列 ,映射 对非容器类都可以直接存取,所有的数值类型归为此类。 序列类型是指容器内的元素从0开始的索引顺序访问,一次可以访问一个或者多个元素。 字符串列表元组归到次类 ...
  • 后来发现插入的数据为元组类型,需要转换为列表,才能直接插入,直接上代码如下: from urllib import request import csv import time import re import random class MaoyanSpider(object): def init(self): self...
  • Python基本语法_强制数据类型转换

    万次阅读 2015-11-08 19:04:16
    Python数据类型的显式转换 显式转换的多种类型 Non-String转换为String str函数 repr str和repr的区别 eval Non-int转换为int Long转换为Int使用自定义函数 Float转换为Int String转换为Int Non-long转化为long类型 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 160,863
精华内容 64,345
关键字:

python数据类型object

python 订阅