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

    2019-07-15 22:59:47
    python基本数据类型包括:int(整型),float(浮点型),complex(复数),string(字符串),dict(字典),list(列表),tuple(元祖),set(集合),bool(布尔值)。 记住查看数据类型时用typ...

    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,即开辟的内存地址不同。

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

     

     

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

    展开全文
  • Python 基本数据类型

    2021-04-18 19:12:45
    Python3 中有六个标准的数据类型: Number(数字) String(字符串) List(列表) Tuple(元组) Set(集合) Dictionary(字典) Python3 的六个标准数据类型中: 不可变数据(3 个):Number(数字)、String...

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

    Number(数字)
    String(字符串)
    List(列表)
    Tuple(元组)
    Set(集合)
    Dictionary(字典)
    Python3 的六个标准数据类型中:

    不可变数据(3 个):Number(数字)、String(字符串)、Tuple(元组);
    可变数据(3 个):List(列表)、Dictionary(字典)、Set(集合)。

    1. 数字类型
    Python数字类型主要包括int(整型)、long(长整型)和float(浮点型),但是在Python3中就不再有long类型了。
    int(整型)
    在32位机器上,整数的位数是32位,取值范围是-231231-1,即-2147483648214748364;在64位系统上,整数的位数为64位,取值范围为-263263-1,即92233720368547758089223372036854775807。
    long(长整型)
    Python长整型没有指定位宽,但是由于机器内存有限,使用长的长整数数值也不可能无限大。
    float(浮点型)
    浮点型也就是带有小数点的数,其精度和机器有关。
    complex(复数)
    Python还支持复数,复数由实数部分和虚数部分构成,可以用 a + bj,或者 complex(a,b) 表示, 复数的实部 a 和虚部 b 都是浮点型。

    2. 字符串
    在Python中,加了引号的字符都被认为是字符串,其声明有三种方式,分别是:单引号、双引号和三引号;Python中的字符串有两种数据类型,分别是str类型和unicode类型,str类型采用的ASCII编码,无法表示中文,unicode类型采用unicode编码,能够表示任意字符,包括中文和其他语言。

    3. 布尔型
    和其他编程语言一样,Python布尔类型也是用于逻辑运算,有两个值:True(真)和False(假)。

    4. 列表
    列表是Python中使用最频繁的数据类型,集合中可以放任何数据类型,可对集合进行创建、查找、切片、增加、修改、删除、循环和排序操作。

    5. 元组
    元组和列表一样,也是一种序列,与列表不同的是,元组是不可修改的,元组用”()”标识,内部元素用逗号隔开。

    6. 字典
    字典是一种键值对的集合,是除列表以外Python之中最灵活的内置数据结构类型,列表是有序的对象集合,字典是无序的对象集合。

    7. 集合
    集合是一个无序的、不重复的数据组合,它的主要作用有两个,分别是去重和关系测试。

    展开全文
  • 本文内容包括三个部分,第一部分简单介绍python中基本数据类型,第二部分讨论数字的常见处理方法,第三部份讨论字符串的常见处理方法 一.python基本数据类型 ...

     

    本文内容包括三个部分,第一部分简单介绍python中基本数据类型,第二部分讨论数字的常见处理方法,第三部份讨论字符串的常见处理方法

     一.python基本数据类型                                                                                                                                                                                                                                                      python中基本数据类型包括数字(int),字符串(str),列表(list),元组(tuple),字典(dict)。在python中需要注意一点就是对于数字来说,不像其他语言有int和double之分,所有的数字都统称为int.在python中有许多内置的方法来处理这些基本的数据类型。本文和后续几篇文章将陆续总结出python3中的这些内置方法。本文剩下的部分主要讨论数字和字符串的内置方法。

    二.数字(int)的处理方法

    1.int()函数:

    1 a='123'
    2 b=int(a)

     

    int()函数可以将字符串转化为数字,对字符串的要求是字符串全部由数字组成。

    2.bit_length():

    1 a=123
    2 b=a.bit_length()
    3 print(b)

     

    该函数表示用二进制来表示该数据至少需要几位二进制数。

    三.字符串的处理方法:

    1.capitalize():

    s='hello'
    s.capitalize()

     

    capitalize()函数作用是将字符串的第一个字母变成大写,其他字母全部小写 (注意是字符串的第一个字母,不是单词的第一个字母)

    2,casefold()和lower():

    s='HsewaaAS'
    s.casefold()
    s.lower()

     

    这两个函数都是将字符串全部变为小写,两个函数不同之处在于,lower只能用于把英文字母全部转化为小写,而cassfold则还可以把其他语言(如法语)的字母全部转为小写。

    3.center(width,fillchar=None):

    1 s='hello'
    2 s1=s.center(30)
    3 s2=s.center(30,'*')

       center函数的作用是指定字符串的宽度,并将字符串居中。该函数有两个参数第一个width表示字符串的宽度,第二个参数是一个缺省参数,用来指定该字符串剩下的位置用什么符号来填充,默认是用空格填充。

      上面找这段代码的执行效果如下:

     4.ljust(width,str=' ')和rjust(width,str='  '):

    s='hello'
    s1=s.ljust(20,'*')
    s2=s.rjust(20,'*')
    print(s1)
    print(s2)

       这两个函数和ceter函数类似,ljust表示将字符串变为指定宽度,其中字符串居左,剩下的位置用指定符号填充,默认用空格,rjust表示将字符串变为指定宽度,其中字符串居右,其他位置用指定字符填充,默认为空格。

    5.count(sub,start=None,end=None):

    1 s='hello nihaoya'
    2 s1=s.count('h')
    3 s2=s.count('h',6,10)
    4 print(s1)
    5 print(s2)

      该函数计算指定字符串在目标字符串中出现的次数,相当于求子序列在原序列中出现的次数。count有三个参数,第一个参数用来指定需要求次数的子序列,第二个和第三个参数是缺省参数,用来指定原字符串序列的开始结束位置。也就是说,既可以在整个字符串中寻找子序列出现的次数,也可以计算字符串中指定序列中子序列出现的次数。

    6.endswith(sub,start=None,end=None),startswith(sub,start=None,end=None):

    1 s='hello nihaoya'
    2 s1=s.endswith('ya')
    3 s2=s.startswith('h')
    4 print(s1)
    5 print(s2)

         这两个函数用来判断字符串是否以指定的子序列结尾和开始。这两个函数都有三个参数,第一个参数用来指定子序列,第二个和第三个参数是缺省参数,用来指定原字符串序列的开始结束位置。如果是以指定序列结尾或开始,则返回True,否则返回False。

    7.expandtabs(width):

    s="hell\tdhehde\ndhienwden\tndiwen\n"
    s1=s.expandtabs(20)
    print(s1)

    代码执行效果:

    该函数的作用是将每一个tab键之前的字符串扩展到指定的宽度.该函数可以让字符串像表格那样输出.

    8.find(sub,start=None,end=None),index(sub,start=None,end=None):

    s="hell\tdhehde\ndhienwden\tndiwen\n"
    s1=s.find('de')
    print(s1)

      find函数查找指定子序列在目标序列中第一次出现的位置,若目标序列中没有该子序列,返回-1。该函数第一个参数是需要查找的子序列,第二个和第三个参数是缺省参数,用来指定原序列的起止位置。index函数与find函数用法功能一致,但是与find函数没有找到子序列返回-1不同,若index没有找到子序列,会直接报错。因此不建议使用该函数。

    9.format(),format_map(): 

    s='your {name},age{age}'
    s1=s.format(name='ahah',age=19)
    print(s1)

    format()函数是将字符串中占位符的内容格式化。在字符串中,用{key}表示占位符,通过foramt函数可以将占位符中内容格式化为指定内容。foramt_map()函数功能与format函数相同,只是format_map函数可以传入一个字典。而format则不能。

    10.isalnum(),

    s='123dsds'
    print(s.isalnum())

    该函数用来判断字符串中是否只包含字母(中文)和数字,如果是,返回True,否则返回False

    11.isalpha():

    该函数用来判断字符串中是否只包含字母(中文),如果是,返回True,否则返回False

    12.isdecimal(),isdigit(),isnumeric():

    这三个函数都是用来判断输入的字符串是否只包含数字,但是三个函数的验证范围不一致,isdecimal()函数只能判断是否是普通数字(自然数),isdigit()函数可以除了可以验证自然数,还可以验证一些特殊的数字,比如②这样的数字。isnumeric()则还可以验证如二这样的汉字。

    13.isprintable():

    s='123\tsdsds'
    print(s.isprintable())

    该函数判断字符串中的字符能否全部打印出来,即字符串中是否存在诸如\t,\n等特殊字符。如果存在,则表示该字符串不能将其全部打印出来,函数将返回False,如果字符串中字符全部都能打印出来,则返回True.

    14.isspace():

    该函数判断给的的字符串是否全是空格,如果是,则返回true,否则返回False

    15.istitle(),tltle():

    istitle()判断给定的字符串是否是标题,即每一个单词的首字母是否是大写,如果是,返回true,否则返回false.tilte()函数则是将字符串转化为标题格式。

    16.join(s):

    s='hello world'
    s1='_'.join(s)
    print(s1)

    代码执行结果:

    join函数可以以指定的字符插入到字符串中,以此来分隔字符串。

    17.islower(),lower,isupper(),upper():

    这几个函数用来判断字符串是否全是大小写以及把字符串全部转为大小写。

    18.strip(st=None),lstrip(st=Node),rstrip(st=None)

    s='xa'
    s.strip('91exxe')
    s.lstrip('91exxe')
    s.rstrip('91exxe')

    这几个函数都是去掉字符串中指定的字符,其中strip是既可以从左边匹配,也可以从右边匹配,lstrip从左边匹配,rstrip从右边开始匹配。函数可以设置参数,用来指定匹配的字符序列,默认是去掉空格(包括\t\n).

    19.maketrans(str1,str2),translate(str):

    1 m=str.maketrans("aeiou","12345")
    2 v="axbduewbidbw9triuebcqyeeqicbwq"
    3 new_v=v.translate(m)
    4 print(new_v)

    naketrans(str1,str2)用来创建字符串之间的对应关系,该函数一般与translate(str)函数配合使用。translate(str)函数的参数就是maketrans(str1,str2)函数所创建的对应关系,在translate函数中,会使用该对应关系进行转换,即在字符串中出现了str1中的字符,那么通过translate函数将会转化成str2中的对应的字符。需要注意,str1和str2的长度必须一致才能转化。

    20.partition(str),rpartition(str)

    1 s='testadsddfg'
    2 v=s.partition('s')
    3 print(v)
    4 s1=s.rpartition('s')
    5 print(s1)

    代码效果:

    这两个函数会把字符串分成三部分,分隔方式是根据str来分隔partition(str)会从字符串的第一个位置开始找字符str,如果找到了第一个字符str,则以该字符作为分隔点,字符前面的内容作为第一部分,str作为第二部门,后面的内容作为第三部分,rpartition则是从字符串的最后一个位置开始向前找,找到第一个字符str,然后跟据str作为分隔符,将字符串分为3部分。如果遍历字符串都没有字符str,自函数返回的三部分包括字符串本身和两个空格。

    21.split(str ,int),rsplit(str,int)

    s='testadsddfg'
    v=s.split('s',2)
    print(v)

    该函数是指定分隔次数。partition函数会找到第一个出现str字符就停止,但是split会根据int值在字符串中搜索出Int个str,再根据这些str将字符串分隔,如果整个字符串的str出现的次数少于int则按照str出现的最大次数进行分隔。同理,rsplit()是从字符串的末尾向前搜索。

    22.splitlines(bool)

    1 v1=s.splitlines(False)
    2 v2=s.splitlines(True)
    3 print(v1)
    4 print(v2)

    代码执行结果:

    根据\n来分隔字符串,若参数为False,则去掉\n,若参数是True,则保留\n.

    23.swapcase():

    1 s='Hello'
    2 s1=s.swapcase()
    3 print(s1)

    该函数用来转换字符串的大小写,将字符串中的大写转为小写,小写转为大写。

    24.isidentifier():

    s='def'
    s1=s.isidentifier()
    print(s1)

    判断字符串是否符合变量命名规则或者字符串是否是python关键字。如果符合命名规则或者是关键字,则返回true,否则返回False。

    25.replace(str1,str2,int=Node):

    1 s="alexalexalexalex"
    2 s1=s.replace('ex','bbb')
    3 s2=s.replace('ex','bbb',2)
    4 print(s1)
    5 print(s2)

    该函数用str2替换字符串中的str1序列,默认是替换掉所有的str1序列,但可以通过增加参数来指定替换的次数。

    转载于:https://www.cnblogs.com/jiachuantang/p/8352818.html

    展开全文
  • python基本数据类型计算 1.值,类型,对象 数据类型 数据类型规定了这种类型的值的内容是什么、能进行什么样的操作(运算)、占用多大的内存空间,取值范围是多少。比如int类型的值可以是任意值任意大的整数。而...

    python基本数据类型计算

    1.值,类型,对象

    1. 数据类型
      数据类型规定了这种类型的值的内容是什么、能进行什么样的操作(运算)、占用多大的内存空间,取值范围是多少。比如int类型的值可以是任意值任意大的整数。而None 表示一个没有值的对象。
      主要数据类型包括数值(number)、字符串(str)、列表(list)、元组(tuple)、集合(set)、字典(dict)。
      数值类型不是一个单独的类型,而可分为int(整型)、float(浮点型)、complex(复数类型)、bool(布尔类型)。bool型用于表示一个逻辑量,即一个命题的真和假,因此只有表示真和假的两个值True、False。
    2. 对象
      值都是以对象的形式存在的,一个对象包括值、数据类型和ID。ID实际上就是对象的内存地址。可以用Python的内置函数type()和id()查询一个对象的数据类型的ID。对于每一个对象,可以定义一个变量引用这个对象。变量名只能包括字母,数字,下划线,且不能以数字开头,同时不能
      格式:变量名=对象
      不是说给这个变量一个值,而是仅仅说明这个变量引用哪个对象,仅仅是这个对象的一个名字而已。
      例如
      Python中有两个运算符 == 和is,前者用于比较对象的值是否相等,后者用于判断两个对象是否为同一个。
      a=1000
      b=1000
      print(a==b)
      print(a is b)

      输出:
      True
      False
    3. 基本数据类型的计算
      print(5+2) #加
      print(2-5) #减
      print(5*2) #乘
      print(5/2) #除,产生的是一个浮点数
      print(5//2) #运算符//表示整数除
      print(5 ** 3) #指数运算,计算5的3次方
      print(3.14//2.5) #整数除
      print(3.14%2) #求余数
      print((50-5*6)/ 4)

    4.字符串可以用置于首尾的单引号或双引号包围一个字符序列来表示字符串。但是单引号包围的字符串里不能再包含单引号(双引号同理)。
    转义字符

        如果要在单引号表示的字符串中包含单引号,则可以在其前面添加反斜杠符号\构成一个单独的字符。例如,用\’表示单引号字符这种前面加反斜杠字符表示字符’的 \’称为“转义字符”。转义字符表示的是一个字符而不是两个字符。
    

    print('hello \'li ping\'') print(len('hello \'li ping\'')) ``#打印字符串的长度,\’表示的是一个字符代码片

    输出:

    hello 'li ping'

    字符串对象可用加法运算;
    print (“hello,”+“world”)
    输出:hello,world
    一个字符串可以与一个整数相乘
    print(3*“world”)
    print(“world”*3)

    输出
    worldworldworld
    worldworldworld

    但字符串之间不能进行减法,除法,乘法等运算。
    5. ● list对象是可以修改的,而str和tuple等对象是不可修改的。
    ● 对于有序序列数据类型,如str、list、tuple,可以通过下标访问其中的一个或多个元素,而无序的set则不能用下标访问其中的元素。
    6.类型转换
    30既可能表示一个数也可能表示一个字符串
    ● 隐式类型转换:表达式中混合int、float类型的值时,Python会自动将int类型的值转为float类型的值。
    ● 显式类型转换:可以用内置函数str()将其他类型的值转为字符串str类型,也可以用内置函数int()或float()将其他类型的值转为int或float类型。
    ● 内置函数input()从键盘输入的永远是一个字符串str类型的值,需要用内置函数int()或float()转为数值类型才能参与算术计算。
    7.基本运算
    基本数据运算

    8.可变对象与不可变对象

    ● 数据类型分为可变类型和不可变类型,可变类型的对象的值是可修改的,而不可变类型的对象的值是不可修改的,数值类型、str类型、tuple类型都是不可变类型,而list类型、set类型、dict类型等都是可变类型。
    ● 无论变量指向的是一个可修改的对象,还是一个不可修改的对象,给这个变量赋值都会使这个变量引用其他的对象(如创建的新对象)。对变量指向的可变对象的值进行修改不会使变量引用新对象,只是● 数据类型分为可变类型和不可变类型,可变类型的对象的值是可修改的,而不可变类型的对象的值是不可修改的。
    ● 无论变量指向的是一个可修改的对象,还是一个不可修改的对象,给这个变量赋值都会使这个变量引用其他的对象(如创建的新对象)。对变量指向的可变对象的值进行修改不会使变量引用新对象,只是修改变量引用的对象的值。

    展开全文
  • python基本数据类型

    2020-12-17 17:44:43
    基本数据类型:整数类型、浮点数类型、复数类型(仅能表示一个数据) 组合数据类型:序列类型、集合类型、映射类型(大量同时处理多个数据 ,可将同类型和不同类型数据组织起来)序列类型:一维元素向量,元素之间...
  • 在了解基本数据类型的时候,我们需要了解基本数据类型有哪些?数字int、布尔值bool、字符串str、列表list、元组tuple、字典dict等,其中包括他们的基本用法和其常用的方法,这里会一一列举出来,以便参考。然后我们...
  • python 基本数据类型

    2019-07-02 00:35:43
    不可变类型包括,整数,浮点数复数, 2.字符串类型(str) 不可变类型,就是一些文字和字符 var1 = 'Hello World!' var2 = "Python Runoob" 3.元祖(tuple) 不可变类型 使用小括号包起来的 tup1 = ('physics', '...
  • 这篇文章主要是对Python中的基本数据类型包括列表,元组,字典,字符串的简单总结 1.字符串 1.1字符串的创建 创建字符串只需要为变量分配一个字符串类型的值即可 s1='hello world!' s2='Python' 1.2字符串的索引 ...
  • Python基本数据类型有整数、浮点数和字符串,由于其是一种面向对象的动态语言,所以其变量的数据类型使用起来比较灵活,相比C语言,省事不是一点半点。 1.整数类型 包括正数和负数,举例子:-10,-1,0,1,10...,...
  • python基本数据类型

    2019-09-27 21:45:47
    01.python数据类型之字典 字典的初识 容器类数据类型 dict 可变数据类型 因为列表查询速度较慢且数据之间关联性不强,出现了字典 字典 {} 键值对形式存储 键必须是不可变的数据类型:int,str,bool,tuple 字典...
  • 在了解基本数据类型的时候,我们需要了解基本数据类型有哪些?数字int、布尔值bool、字符串str、列表list、元组tuple、字典dict等,其中包括他们的基本用法和其常用的方法,这里会一一列举出来,以便参考。然后我们...
  • 前言 学习任何编程语言都很类似, 大概都需要从最基础... 在后面的几篇中, 我将逐步学习 Python 的基础知识, 主要包括: 基本数据类型、流程控制语句、函数以及类的学习. 大致学习完了这些内容后, 就马马虎虎算是...
  • 本文主要向大家介绍了Python语言数据类型,通过具体的内容向大家展示,希望对大家学习Python语言有所帮助。Python中常用的数据类型:数据的组成:数据是由三部分组成的,分别是身份(即内存地址,可以使用id函数查看...
  • Python 有8个标准的数据类型: Number(数字) Bool(布尔值) String(字符串) None(空值) List(列表) Tuple(元组) Set(集合) Dictionary(字典) 小提示:可以使用python内置的 type() 函数查询变量所...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,488
精华内容 595
关键字:

python基本数据类型包括

python 订阅