精华内容
下载资源
问答
  • 首先我们先来python的几种数据类型python有五个标准的数据类型: number(数字) string(字符串) list(列表) tuple(元组) dictionary(字典) 具体这几种类型怎么用,怎么定义,大家...

    今天我们主要来学习下python的几种数据类型的取值方式!

    首先我们先来看下python的几种数据类型,python有五个标准的数据类型:

    • number(数字)

    string(字符串)

    • list(列表)
    • tuple(元组)
    • dictionary(字典)

    具体的这几种类型怎么用,怎么定义,大家自己查下哈~,我们主要是说下取值的方式,以及这几种方式的优缺点

    1.字典

    我们先看下字典的吧,python中字典是通过键来取值的,取值方式有两种:

    dictNum={'name':'abc','age':17,'sex':'women' }

    • name = dictNum["name"],用这种方式得到的值name为abc,但是会有一种问题,如果取一个不存在的key就会抛出异常,如 dictNum["time"],就会抛出异常

    • name = dict.get("name"),这种方式得到的值,即使是get了一个不存在的key,得到的值为None,也不会抛出异常

     2.列表

    •  list = ['a','b','c','d','e','f'] 遍历列表

                for i in listNum :

                         print ("%s:%s" % (listNum.index(i) + 1,i))

              

    • for i in range(len(listNum)):
          print ("%s:%s")%(i+1,listNum[i])

             

    • for i,val in enumerate(listNum):
            print ("%s:%s")%(i + 1,val)

             

     

    转载于:https://www.cnblogs.com/cczyx/p/9662177.html

    展开全文
  • 第一次写博客完全不知道怎么下笔啊。。。本着对自己和对读者负责态度,我查阅了很多大佬博客,尽可能写详细和准确。废话不多说,上干货。 一、什么是可变数据类型,什么是不可变数据类型。 用一句话概括:可...

    第一次写博客完全不知道怎么下笔啊。。。本着对自己和对读者负责的态度,我查阅了很多大佬的博客,尽可能写的详细和准确。废话不多说,上干货。

    一、什么是可变数据类型,什么是不可变数据类型。

    用一句话概括:可变数据类型:value改变,id不变;不可变数据类型:value改变,id也随之改变。

    (一)不可变数据类型:整型,字符串,元组

    我们先看整型:

    >>> a = 3
    >>> b = a
    >>> id(a)  # 输出对象a的地址
    4468094080
    >>> id(b)  # 输出对象b的地址 
    4468094080  # 可以看到a,b的地址是相同的
    >>> a = 4  # 改变a的值
    >>> id(a)
    4468094112  # 可以发现a的地址也变了
    >>> print(b)
    3
    >>> id(b)  # 但是b的地址没有变化
    4468094080
    

     字符串和元组情况类似,这里顺便提一下元组使用上可能出现的错误,请看下面的代码:

    >>> Tuple = (1,2,3)  # 声明一个元组并赋值
    >>> Tuple[0]  # 访问元组第1个元素
    1
    >>> Tuple[0] = 4  # 尝试修改第一个元素
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'tuple' object does not support item assignment   # 报错,提示元组对象不支持元素赋值,
    

    (二)可变数据类型:列表,字典,集合

     还是用最简单的列表举个例子吧:

    >>> list = [1,2,3,4,5]  # 声明一个列表list
    >>> id(a)
    4410425608
    >>> list[0] = 'x'  # 修改列表的value
    >>> print(list)
    ['x', 2, 3, 4, 5]  # 修改成功
    >>> id(list)  
    4410425608  # 可以看到列表的地址并未改变,所以列表是可变数据类型。

    详情请参照大佬博客 https://www.cnblogs.com/lfpython/p/7207747.html

    转载于:https://www.cnblogs.com/Infinite-bing/p/10582333.html

    展开全文
  • 一起扒拉一下python的数据类型python3中, 一共有4种基本容器类型, list,tuple,dict,set 一:list list相当于js中array. array能做事情, 差不多list都可以做到, 比如什么可变性,删除,添加,转变为字符串等...

    一起扒拉一下python中的数据类型

    在python3中, 一共有4种基本的容器类型, list,tuple,dict,set


    一:list

    list相当于js中的array. array能做的事情, 差不多list都可以做到, 比如什么可变性,删除,添加,转变为字符串等基本操作

    (一):我们来看一下,怎么声明一个list

    name = ['sam','jimmy'] 
    复制代码

    (二):在python中也是很有用的三个函数 len,max,min.

    1,len(): 用来获取list的长度

    >>> len(lists)
    5
    复制代码

    2,max(list|Numbers): 用来判断list中,最大的数字.

    >>> max(lists)
    5
    >>> max(1,2,3,4,5)
    5
    复制代码

    3,min(list|Numbers): 用来判断list中,最小的数字

    另外, 这里补充一个生成有序list最快捷的方式, 使用list comprehension.即,在括号里面使用 for statement. 实际上, 就是一个list 派生出另外一个list. 看一个demo

    >>> lists = [x for x in range(10)]
    >>> lists
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    复制代码

    range就是用来生成一个iterable

    补充: range(start, stop[, step]) -> range object 具体含义就是born 一定范围的值. 比如range(10): 0~10. 回到 list comprehension, 这个表达式x for x in range(10) 实际上, 就相当于

    lists = []
    for x in range(10):
       lists.append(x)
    复制代码

    了解了LC 之后,我们就可以脱离手码lists的困扰了. python 很方便有木有

    (三): python中的两个特性 切片, 迭代

    1,切片

    通常,我们想要获取list中的某个元素,直接使用下标即可.但是,如果你想要取出list中间连续的几个,那么就会用到切片这一神奇的功能.

    >>> my_list = ['p','r','o','g','r','a','m']
    >>> my_list[2:5]    # elements 3rd to 5th
    ['o', 'g', 'r']
    >>> my_list[:-5]    # 可以使用负数的index
    ['p', 'r', 'o', 'g']
    >>> my_list[5:]     # 从5一直到最末
    ['a', 'm', 'i', 'z']
    >>> my_list[:]      # 获取所有的ele
    ['p', 'r', 'o', 'g', 'r', 'a', 'm']
    复制代码

    关于切片,值得补充一下就是colon两边的数字代表的意义特么还不一样:比如: my_list[2:5]实际表现的意义是,获取list中[2,5-1]的元素,Ps: 下标从0开始)实际上, 关于切片,还有一个隐藏的parameter.

    >>> len[0:5:2]
    [1, 3, 5]
    复制代码

    第三个的参数的相当于设置步长,x+step,比如,你可以获得,奇数元素或者偶数元素等等.

    2,迭代

    实际上,这里的迭代,我们理解为for...in...循环就好.如下格式

    >>> for v in len:
            print(v)
    复制代码

    v就代表len中的每一个元素,然后你就可以执行相关的操作即可。另外, 如果你的list是这样的

    >>> lists = [[1,2],[2,3]]
    >>> for [a,b] in lists:
             print(a,b)
    复制代码

    套用同样的格式即可

    (四):关于python里相关操作list的方法.

    list方法

    1,添加

    在python中, 常有append,extend,insert 3个方法用来进行添加. 不过,在介绍这3个方法之前,我们先要体会一下python flexibility--+,*,切片. 利用这3个trick来进行添加.

    + 我们使用+, 来对list进行扩展.但实际上,他并不会修改原始的list。 所以这就有点尴尬了

    >>> lists+[1]
    [1, 2, 3, 4, 5, 1]
    复制代码

    * 使用*进行翻倍扩展.但,同样不会改变原值

    >>> lists * 2
    [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
    复制代码

    (1),append 这里就是向list中,尾加一个ele.

    >>> lists.append(1)
    复制代码

    (2),extend 用来向list中,添加多个ele.

    >>> lists.extend([1,2,3,4])
    复制代码

    他和+操作的区别就是, +不会改变原始的list,而extend会!

    (3),insert 用来往指定index后添加一个ele.

    >>> lists.insert(0,123)
    >>> lists.insert(0,[1,23])
    复制代码

    2,切片

    使用切片,来对list直接修改.

    >>> lists[1:3]=[1,2,3]  //只能使用另外一个list进行替代
    >>> lists
    [1, 1, 2, 3, 4, 5]
    复制代码

    这里简要说一下分片的原理吧. 分片实际上是,内部创建一个list,然后进行替换, 所以,对应的类型只能是list. 比如下面, 就会报错

    >>> lists[1:3]=1
    TypeError: can only assign an iterable
    复制代码

    3,删除

    list里面的移除也是有很多讲究的, 常用的方法有pop,remove,del,clear

    (1),pop 这里,我们就要将list理解为一个栈(Ps:一种数据结果). 他的结果就是先进后出(FILO). 相当于一个瓶子,你最后放的,会被最先拿出来. 实际上, 他和append是完全相反的. append->入栈 pop->出栈 使用pop时, 他会返回被删除的元素

    >>> lists = [1,2,3,4]
    >>> lists.pop()
    4
    >>> lists
    [1, 2, 3]
    复制代码

    我们对比看一下,append

    >>> lists.append(4)
    >>> lists
    [1, 2, 3, 4]
    复制代码

    另外, pop还可以用来删除指定index的ele.

    //删除第一个元素
    >>> lists.pop(0)
    复制代码

    (2),remove remove是用来移除指定值. 并且,一次只会移除一个

    >>> lists = [1,2,3,1,1,1]
    >>> lists.remove(1)
    >>> lists
    [2, 3, 1, 1, 1]
    复制代码

    (3),del && clear 前面说了pop,用来删除最新的栈元素, 但是我怎么删除list中最先放入, 也就是 list[0]的元素呢? 一个是用remove()造一个trick. 或者上面的pop例子

    >>> lists.remove(lists[0])
    >>> lists.pop(0)
    复制代码

    不过使用remove的可读性超级差(pop的还可以), 所以, 我们可以使用 python中的内置函数, del 进行删除

    del lists[0]
    复制代码

    这里,我们来对比一下,3者的复杂度

    del O(n - i)
    
    pop O(n - i)
    
    remove O(n)
    复制代码

    很容器看出, del和pop的复杂度,比remove小, 所以,如果你想删除以下标开始的list的话,pop和del都行.

    最后,我们如果想删除list的所有元素的话, 直接刚他. 使用clear()即可.

    >>> lists.clear()
    >>> lists
    []
    复制代码

    4,排序操作

    实际上, 这应该算是一切算法的根源了, 算法做的工作就是筛选和排序. 在list中,提供了两个方法供我们选择 sort, reverse.

    (1),reverse() 实际上就是倒叙, 将你现在的list的顺序,逆向一遍

    >>> lists
    [1, 2, 3, 4]
    >>> lists.reverse()
    >>> lists
    [4, 3, 2, 1]
    sort([fn])
    复制代码

    (2),sort 他根据fn的返回值来判断你原来顺序中的大小. fn接受两个参数fn(pre,next). 代表按照顺序的list的相邻两个元素.

    fn>0: 则保持现在的顺序

    fn<0: 交换两者顺序继续比较

    fn=0: 保留两者的顺序

    你可以自定义函数, 也可以直接使用默认的从小到大的排列. 即:

    >>> lists = [1,3,2,4,2,3]
    >>> lists.sort()
    >>> lists
    [1, 2, 2, 3, 3, 4]
    复制代码

    注: sort本身自带了两个参数,可以用来决定排列的顺序: key,reverse

    >>> lists=['ss','sss','s','ss']
    >>> lists.sort(key=len)
    >>> lists
    ['s', 'ss', 'ss', 'sss']
    复制代码

    或者指明使用reverse=True

    >>> lists=['ss','sss','s','ss']
    >>> lists.sort(reverse=True)
    >>> lists
    ['sss', 'ss', 'ss', 's']
    复制代码

    当然, 如果你不想对原来的list进行改变, 可以使用sorted方法,返回一个新的list进行相关操作. 我们使用,help(sorted)来看一下具体用法

    sorted(iterable, key=None, reverse=False)
        Return a new list containing all items from the iterable in ascending order.
    复制代码

    同样, 他默认情况下也是升序表示

    >>> lists
    [5, 4, 3, 2, 1]
    >>> sorted(lists)
    [1, 2, 3, 4, 5]
    复制代码

    同样,你也可以使用reverse和key进行相关指定. 同,list这里就不赘述了.

    5,查询

    在list 查询中, python也提供了我们两个方法, index,count.

    (1),index(ele): 用来查找具体ele,在list中的序号,没有则会出现ValueError的错误.具体表达式为:

    L.index(value, [start, [stop]])
    复制代码

    看到这个表示之后,我们大概就可以猜到index的基本用法了, 限定范围查找, 也是很重要的一个feature

    (2),count(ele):
    用来统计具体ele在list中出现的次数.

    >>> lists.count(2)
    1
    复制代码

    当然, 如果有同学相到, in 关键字能否实现这个查询的功能呢?答案 is yes!!! 即, 我们判断一个ele 是否存在于list 可以使用in 来判断

    >>> if 1 in lists:
    ...     print(1)
    ... 
    1
    //或者使用index
    >>> if lists.index(1):
         print(1)
    1
    复制代码

    这都是完全行得通的

    6,复制

    (1),分片 如果你想复制一个list最快的方法就是使用分片. 即

    >>> lists
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> newOne = lists[0:3]
    >>> newOne
    [0, 1, 2]
    复制代码

    (2),copy()

    newOne = lists.copy();
    //或者使用
    newOne = lists[:]
    复制代码

    这样,就避免了 内存地址重叠的problem了.

    7,额外方法

    除了上面说了的max,min,list等转换方法外, python 内置的还有sum,all,any.

    (1),sum() 返回 list中所有元素之和

    sum(lists)
    复制代码

    (2),all() 是为了判断, lists中所有元素通过bool(ele)之后都为True,则返回True,所以,当list元素中有'',0,[]的话,则会返回False。另外,如果list为空的话,返回的也是True

    (3),any() 使用bool(ele) 判断list中的每一个元素, 如果有一个为ture的话, 返回True, 相当于或的意思. 如果list为空的话返回的是False

    >>> lists
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> any(lists)
    True
    >>> all(lists)  //存在0
    False
    >>> lists = []
    >>> any(lists) //没有元素,不通过
    False
    >>> all(lists)  //没有元素,通过
    True
    复制代码

    二:Tuple

    另外, 还有一个和list 很像的数据tuple.中文叫元组.他和list的主要区别就是, tuple是一开始就定义好的, 即, assign first,之后就永远不能被改变了. 所以, 一般全局比较重要的数据,我们都是使用tuple进行存放的.

    (一)我们来创建一个Tuple

    创建一个Tuple 通常来说,Tuple是放在parentheses 即, 圆括号() 内部.

    >>> tub = (1,2,3)
    >>> type(tub)
    <class 'tuple'>
    复制代码

    不过, 最近很流行的是 without parentheses. 即, 不加括号的方式. show:

    >>> tub = 1,2,3
    >>> type(tub)
    <class 'tuple'>
    复制代码

    这个名叫, tuple packing. 个人翻译为元组包. 不过在, 使用tuple的时候,需要注意,只有一个元素的tuple的创建(md,一个元素你还创建tuple干嘛,浪费内存?)一个元素的tuple创建, 需要在末尾+, 进行相关标识

    >>> tub = 1,
    // 或者
    >>> tub = (1,)
    >>> type(tub)
    <class 'tuple'>
    复制代码

    如果,你想访问tuple的话, 和访问list 是一个道理

    >>> tub = (1,2,3,4,5,6,7)
    >>> tub[0]
    1
    //当然,你也可以取负值
    >>> tub[-1]
    7
    复制代码

    所以,这里我们也可以使用for...in...进行 遍历.

    (二):不变的Tuple

    一般创建了一个tuple, 之后你就用于无法改变他的值了, 也就是你不能删除,或者添加。不过,如果你的tuple里面放一些可变的内容的话, 比如,list的话,那情况就不一样了。基于这一点,我们理解tuple 应该说为 shallow不变形。即,不能改变值类型,但可以改变引用类型.

    >>> tup
    (1, 2, 3, [2, 3], 5)
    >>> tup[3]
    [2, 3]
    >>> tup[3].append(1)
    >>> tup
    (1, 2, 3, [2, 3, 1], 5)
    //删除tup, 会报错
    >>> del tup[0]
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'tuple' object doesn't support item deletion
    复制代码

    虽然,我们不能对tuple执行CD操作, 但相关的查询方法我们还是可以使用的

    (三):Tuple 查询

    在tuple里面有两个查询方法, index和count, 另外你使用in也是没有问题的

    >>> my_tuple = ('a','p','p','l','e',)
    >>> my_tuple.count('p')
    2
    >>> my_tuple.index('l')
    3
    >>> 'a' in my_tuple
    True
    复制代码

    同样, 关于list的一些built-in methond. 在tuple身上也是使用的, 有 max,min,sum,all,any,len,sorted. 这几个, 都是木有问题的

    总结一下: tuple方法什么时候我们用Tuple? tuple就是用来放不变的数据,并且tuple在内部中有遍历加速(因为不变).


    三:dict

    (一):dict的特性

      dict是python中的一个可变的数据类型,用{}表示,dict的key必须是不可变的数据类型,而value的数据类型可以任意。   格式:{key:value,key:value,key:value} 注: 键值对如果是字符串使用单引号,最后一个键值对没有逗号 dict的优点:     ①:查询速度快,可以二分查找     ②:key是不可以重复的 注:        不可变数据类型: 元组,bool,int , str 可以hash     可变数据类型: dict ,list, set

    (二),dict的方法:

    1,增加的方法:dict有两种增加的方法

     (1),如果没有的键值对,则进行添加,如果有,则将值进行覆盖

    dict1={'name':'jinxin','age':18,'male':'男'}
    print(dict1)
    dict1['high']=185
    print(dict1)  # {'name': 'jinxin', 'age': 18, 'male': '男', 'high': 185}
    dict1['age']=16
    print(dict1) #  {'name': 'jinxin', 'age': 16, 'male': '男', 'high': 185}
    复制代码

     (2),如果有键值对,不做任何改变,没有键值对,才进行添加

    dict1.setdefault("weight")
    print(dict1)  #{'name': 'jinxin', 'age': 16, 'male': '男', 'high': 185, 'weight': None}
    dict1.setdefault('weight','65kg')
    print(dict1)  #{'name': 'jinxin', 'age': 16, 'male': '男', 'high': 185, 'weight': None}
    dict1.setdefault('address','北京')
    print(dict1)  #{'name': 'jinxin', 'age': 16, 'male': '男', 'high': 185, 'weight': None, 'address': '北京'}
    复制代码

    2,dict的删除方法

     (1),使用pop()删除,如果有键,则删除,如果没有则会报错,如果不希望出现报错信息,可以在删除的后面添加信息

    delDict={'name': 'jinxin', 'age': 16, 'male': '男', 'high': 185, 'weight': None, 'address': '北京'}
    # delDict.pop('age')  #dict的删除操作是有返回值的
    print(delDict.pop('age'))  # 16
    print(delDict)  #{'name': 'jinxin', 'male': '男', 'high': 185, 'weight': None, 'address': '北京'}
    print(delDict.pop('职业','没有此键'))  #没有此键
    复制代码

     (2),使用popitem()删除,随机删除,返回的是一个元组,元组里面存储的删除的键值,推荐使用pop()方法进行删除

    print(delDict.popitem())  # ('address', '北京')
    复制代码

    随机删除,返回值是删除的键值对

    print(delDict)  #{'name': 'jinxin', 'male': '男', 'high': 185, 'weight': None}
    复制代码

     (3),使用del()删除,del()可以删除整个字典,也可以删除字典的某个键,如果删除的键不存在,则会出现报错

    del delDict['name']
    print(delDict)  #{'male': '男', 'high': 185, 'weight': None}
    #使用del清空列表
    del delDict
    print(delDict)  #delDict已经删除,报错
    复制代码

     (4),清空列表也可以使用clear() 4,dict的修改

    #直接修改
    updateDict={'name':'jinxin','age':18,'male':'男'}
    updateDict['name']='Jordan'
    print(updateDict['name']) #Jordan
    
    #调用update()修改
    dictDemo={'name':"Jordan",'age':18}
    dictDemo1={'address':'北京海淀','age':22}
    dictDemo.update(dictDemo1)
    print(dictDemo)
    复制代码

    4,字典的查询

      (1)查询字典的键:调用keys()方法    查询字典的值:调用values()方法

    # 字典的查
    dict1={'name':'jinxin','age':18,'male':'男'}
    print(dict1.keys()) #dict_keys(['name', 'age', 'male'])
    print(dict1.values()) #dict_values(['jinxin', 18, '男'])
    print(dict1.items())# dict_items([('name', 'jinxin'), ('age', 18), ('male', '男')])
    
    #打印dict1的键
    for i in dict1.keys():
        print(i )  # name age value
    
    #打印dict的值
    for v  in dict1.values():
        print(v) #jinxin 18 男
    
    #打印字典的键值:
    
    dict1={'name':'jinxin','age':18,'male':'男'}
    
    for i in dict1.items():
        print(i)  # ('name', 'jinxin') ('age', 18) ('male', '男')
        
    for k,v in dict1.items():
        print(k,v)  # name jinxin  age 18   male 男
    复制代码

     (2),字典的get()方法:使用get()方法可以查询某个键是否存在,如果不存在此键,则会返回None,但是可以在get()方法中添加信息避免出现None

    dict1={'name':'jinxin','age':18,'male':'男'}
    print(dict1.get('name')) #jinxin
    print(dict1.get('address')) # None
    print(dict1.get('address','没有此键'))  #没有此键
    复制代码

    四:set

    python的set和其他语言类似,是一个无序不重复元素集,基本功能包括关系测试和消除重复元素.集合对象还支持union(联合),intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算,sets 支持 x in set, len(set),和 for x in set。作为一个无序的集合,sets不记录元素位置或者插入点。因此,sets不支持indexing,slicing,或其它类序列(sequence-like)的操作。

    下面来点简单的小例子说明吧。

    >>> x = set('spam')
    >>> y = set(['h','a','m'])
    >>> x, y
    (set(['a', 'p', 's', 'm']), set(['a', 'h', 'm']))
    复制代码

    再来些小应用。

    >>> x & y # 交集
    set(['a', 'm'])
    >>> x | y # 并集
    set(['a', 'p', 's', 'h', 'm'])
    >>> x - y # 差集
    set(['p', 's'])
    复制代码

    去除列表里重复元素,用hash来解决也行,只不过感觉在性能上不是很高,用set解决还是很不错的,示例如下:

    >>> a = [11,22,33,44,11,22]
    >>> b = set(a)
    >>> b
    set([33, 11, 44, 22])
    >>> c = [i for i in b]
    >>> c
    [33, 11, 44, 22]
    复制代码

    一:集合

    集合用于包含一组无序的对象。要创建集合,可使用set()函数并像下面这样提供一系列的项:

    s = set([3,5,9,10])      #创建一个数值集合
    t = set("Hello")         #创建一个唯一字符的集合
    复制代码

    注: 与列表和元组不同,集合是无序的,也无法通过数字进行索引。此外,集合中的元素不能重复。例如,如果检查前面代码中t集合的值,结果会是:

    >>> t
    set(['H', 'e', 'l', 'o'])
    复制代码

    注意: 只出现了一个'l'。

    二:集合操作

    集合支持一系列标准操作,包括并集、交集、差集和对称差集,例如:

    a = t | s          # t 和 s的并集
    b = t & s          # t 和 s的交集
    c = t – s          # 求差集(项在t中,但不在s中)
    d = t ^ s          #对称差集(项在t或s中,但不会同时出现在二者中)
    复制代码

    基本操作:

    (1),add() 使用add()可以添加一项:

    t.add('x')            # 添加一项
    s.update([10,37,42])  # 在s中添加多项
    复制代码

    (2),remove() 使用remove()可以删除一项:

    t.remove('H')
    复制代码

    (3),len()

    len(s)#s的长度
    复制代码

    (4),in

    x in s #测试 x 是否是 s 的成员
    复制代码

    (5),not in x not in s 测试 x 是否不是 s 的成员

    (6),<= >=

    s.issubset(t)
    s <= t # 测试是否 s 中的每一个元素都在 t 中
    s.issuperset(t)
    s >= t # 测试是否 t 中的每一个元素都在 s 中
    复制代码

    (7),|

    s.union(t)
    s | t # 返回一个新的 set 包含 s 和 t 中的每一个元素
    复制代码

    (8),&

    s.intersection(t)
    s & t #返回一个新的 set 包含 s 和 t 中的公共元素
    复制代码

    (9),-

    s.difference(t)
    s - t #返回一个新的 set 包含 s 中有但是 t 中没有的元素
    复制代码

    (10),^

    s.symmetric_difference(t)
    s ^ t #返回一个新的 set 包含 s 和 t 中不重复的元素
    复制代码

    (11),copy()

    s.copy() #返回 set “s”的一个浅复制
    复制代码

    请注意: union(), intersection(), difference() 和 symmetric_difference() 的非运算符(non-operator,就是形如 s.union()这样的)版本将会接受任何 iterable 作为参数。相反,它们的运算符版本(operator based counterparts)要求参数必须是sets。这样可以避免潜在的错误,如:为了更可读而使用set('abc')&'cbs'来替代set('abc').intersection('cbs')。从 2.3.1 版本中做的更改:以前所有参数都必须是 sets。 另外,Set 和 ImmutableSet 两者都支持 set 与 set之间的比较。两个 sets 在也只有在这种情况下是相等的:每一个set中的元素都是另一个中的元素(二者互为subset)。一个set比另一个set小,只有在第一个et 是第二个 set 的subset时(是一个subset,但是并不相等)。一个set 比另一个set打,只有在第一个set是第二个set的superset时(是一个superset,但是并不相等)。子set和相等比较并不产生完整的排序功能。例如:任意两个sets都不相等也不互为子set,因此以下的运算都会返回 False:a<b, a==b, 或者a>b。因此,sets 不提供 cmp 方法。 因为 sets 只定义了部分排序功能(subset 关系),list.sort() 方法的输出对于 sets 的列表没有定义。

    运算符 运算结果

    hash(s) #返回 s 的 hash 值
    复制代码

    下面这个表列出了对于 Set 可用二对于 ImmutableSet 不可用的运算:

    运算符(voperator) 等价于 运算结果

    s.update(t)
    s |= t
    返回增加了 set “t”中元素后的 set “s”
    
    s.intersection_update(t)
    s &= t
    返回只保留含有 set “t”中元素的 set “s”
    
    s.difference_update(t)
    s -= t
    返回删除了 set “t”中含有的元素后的 set “s”
    
    s.symmetric_difference_update(t)
    s ^= t
    返回含有 set “t”或者 set “s”中有而不是两者都有的元素的 set “s”
    
    s.add(x)
    
    向 set “s”中增加元素 x
    
    s.remove(x)
    
    从 set “s”中删除元素 x, 如果不存在则引发 KeyError
    
    s.discard(x)
    
    如果在 set “s”中存在元素 x, 则删除
    
    s.pop()
    
    删除并且返回 set “s”中的一个不确定的元素, 如果为空则引发 KeyError
    
    s.clear()
    
    删除 set “s”中的所有元素
    复制代码

    请注意: 非运算符版本的 update(), intersection_update(), difference_update()和symmetric_difference_update()将会接受任意 iterable 作为参数。从 2.3.1 版本做的更改:以前所有参数都必须是 sets。这个模块还包含一个 union_update() 方法,它是 update() 方法的一个别名。包含这个方法是为了向后兼容。程序员们应该多使用 update() 方法,因为这个方法也被内置的 set() 和 frozenset() 类型支持。


    五:list,tuple,dict,set特点对比总结:

    1 .list

    1),list是一个使用方括号括起来的有序元素集合;

    2),List 可以作为以 0 下标开始的数组,任何一个非空 list 的第一个元素总是 L[0],负数索引从 list 的尾部开始向前计数来存取元素。任何一个非空的 list 最后一个元素总是 L[-1];

    3),有分片功能,两个list可以相加;

    4),append 向 list 的末尾追加单个元素;

    5),insert 将单个元素插入到 list 中;

    6),extend 用来连接 list,使用一个 list 参数进行调用;

    7),append 接受一个参数,这个参数可以是任何数据类型,并且简单地追加到 list 的尾部;

    8),index 在 list 中查找一个值的首次出现并返回索引值;

    9),要测试一个值是否在 list 内, 使用 in, 如果值存在, 它返回 True, 否则返为 False ;

    10),remove 从 list 中删除一个值的首次出现;

    11),pop 可以删除list的最后一个元素,然后返回删除元素的值,用索引删除制定位置的值;

    2.tuple

    1),tuple是不可变的list,创建了一个tuple就不能以任何方式改变它;

    2),定义tuple是将整个元素集是用小括号括起来,是有序集合;

    3),tuple的索引与list一样从0开始,所以一个非空的tuple的第一个元素总是t[0];

    4),负数索引与 list 一样从 tuple 的尾部开始计数;

    5),与 list 一样分片 (slice) 也可以使用。分割一个 tuple 时, 会得到一个新的 tuple;

    6),没有 append、extend、remove或pop方法以及index方法;

    7),可以使用in来查看一个元素是否存在于tuple 中。

    3.dict

    1),dict定义了键和值之间的一一对应关系,每个元素都是一个key-value对;

    2),整个元素集合用大括号括起来,有序集合;可以通过 key 得到value, 但不能通过vaule获取 key;在一个 dict中不能有重复的 key, 并且 key 是大小写敏感的;

    3),键可以是数字、字符串或者是元组等不可变类型;

    4),用del使用key可以删除dict中的独立元素;

    5),用clear可以清除dict中的所有元素。

    4.set

    1),set是建立一系列无序的,不重复的元素;

    2),创建set的方式是调用set()并传入一个list,list的元素将作为set的元素;

    3),set和dict的唯一区别仅在于没有存储对应的value。

    转载于:https://juejin.im/post/5cacb4706fb9a0686a223300

    展开全文
  • python3中, 一共有4种基本容器类型, list,tuple,dict,set list list相当于js中array. array能做事情, 差不多list都可以做到, 比如什么可变性,删除,添加,转变为字符串等基本操作,都是木有问题滴.我们来一下...
        

    本文系转载于本人博客前端小吉米

    在python3中, 一共有4种基本的容器类型, list,tuple,dict,set

    list

    list相当于js中的array. array能做的事情, 差不多list都可以做到, 比如什么可变性,删除,添加,转变为字符串等基本操作,都是木有问题滴.
    我们来看一下,怎么声明一个list.

    name = ['sam','jimmy'] //就酱

    在说之前,安利一下,3个函数,也是python中, 很有用的. len,max,min.

    • len(): 用来获取list的长度

    >>> len(lists)
    5
    • max(list|Numbers): 用来判断list中,最大的数字.

    >>> max(lists)
    5
    >>> max(1,2,3,4,5)
    5
    • min(list|Numbers): 用来判断list中,最小的数字

    另外, 这里补充一个生成有序list最快捷的方式, 使用list comprehension.
    即, 在括号里面使用 for statement. 实际上, 就是一个list 派生出另外一个list. 看一个demo

    >>> lists = [x for x in range(10)]
    >>> lists
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

    range就是用来生成一个iterable

    //help 一下
    range(start, stop[, step]) -> range object

    具体含义就是born 一定范围的值. 比如range(10): 0~10.
    回到 list comprehension, 这个表达式x for x in range(10) 实际上, 就相当于

    lists = []
    for x in range(10):
       lists.append(x)

    了解了LC 之后,我们就可以脱离手码lists的困扰了. python 很方便有木有

    接下来我们来look python中的两个特性 切片, 迭代

    切片

    通常,我们想要获取list中的某个元素,直接使用下标即可. 但是,如果你想要取出list中间连续的几个,那么就会用到切片这一神奇的功能.

    >>> my_list = ['p','r','o','g','r','a','m']
    >>> my_list[2:5]    # elements 3rd to 5th
    ['o', 'g', 'r']
    >>> my_list[:-5]    # 可以使用负数的index
    ['p', 'r', 'o', 'g']
    >>> my_list[5:]     # 从5一直到最末
    ['a', 'm', 'i', 'z']
    >>> my_list[:]      # 获取所有的ele
    ['p', 'r', 'o', 'g', 'r', 'a', 'm']

    关于切片,想吐槽一下,就是colon两边的数字代表的意义特么还不一样.
    比如: my_list[2:5] 实际表现的意义是, 获取list中[2,5-1]的元素.(Ps: 下标从0开始)
    实际上, 关于切片,还有一个隐藏的parameter.

    >>> len[0:5:2]
    [1, 3, 5]

    第三个的参数的相当于设置步长, x+step. 比如,你可以获得,奇数元素或者偶数元素等等.

    迭代

    实际上,这里的迭代,我们理解为for...in...循环就好. 如下格式

    >>> for v in len:
    ...     print(v)

    v就代表,len中的每一个元素. 然后你就可以执行相关的操作即可.
    另外, 如果你的list是这样的

    >>> lists = [[1,2],[2,3]]
    >>> for [a,b] in lists:
    ...     print(a,b)

    则,你也可以套用同样的格式即可.

    built-in method

    ok, 现在正是介绍一下, 关于python里相关操作list的方法. 同样,无外乎就是CRUD.这里先放一个图谱吧:
    list方法

    添加

    在python中, 常有append,extend,insert 3个方法用来进行添加. 不过,在介绍这3个方法之前,我们先要体会一下python flexibility--+,*,切片. 利用这3个trick来进行添加.

    +
    我们使用+, 来对list进行扩展.但实际上,他并不会修改原始的list。 所以这就有点尴尬了

    >>> lists+[1]
    [1, 2, 3, 4, 5, 1]

    that's all.

    *
    使用*进行翻倍扩展.但,同样不会改变原值

    >>> lists * 2
    [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

    切片
    使用切片,来对list直接修改.

    >>> lists[1:3]=[1,2,3]  //只能使用另外一个list进行替代
    >>> lists
    [1, 1, 2, 3, 4, 5]

    这里简要说一下分片的原理吧. 分片实际上是,内部创建一个list,然后进行替换, 所以,对应的类型只能是list.
    比如下面, 就会报错

    >>> lists[1:3]=1
    TypeError: can only assign an iterable

    现在,我们来正式看看python中的built-method.

    append

    这里就是向list中,尾加一个ele.

    >>> lists.append(1)

    extend

    用来向list中,添加多个ele.

    >>> lists.extend([1,2,3,4])

    他和+操作的区别就是, +不会改变原始的list,而extend会!

    insert

    用来往指定index后添加一个ele.

    >>> lists.insert(0,123)
    >>> lists.insert(0,[1,23])

    ok, 添加就到此为止了.

    删除

    list里面的移除也是有很多讲究的, 常用的方法有pop,remove,del,clear

    pop

    这里,我们就要将list理解为一个栈(Ps:一种数据结果). 他的结果就是先进后出(FILO). 相当于一个瓶子,你最后放的,会被最先拿出来. 实际上, 他和append是完全相反的.
    append->入栈
    pop->出栈
    使用pop时, 他会返回被删除的元素

    >>> lists = [1,2,3,4]
    >>> lists.pop()
    4
    >>> lists
    [1, 2, 3]

    我们对比看一下,append

    >>> lists.append(4)
    >>> lists
    [1, 2, 3, 4]

    另外, pop还可以用来删除指定index的ele.

    //删除第一个元素
    >>> lists.pop(0)

    remove

    remove是用来移除指定值. 并且,一次只会移除一个

    >>> lists = [1,2,3,1,1,1]
    >>> lists.remove(1)
    >>> lists
    [2, 3, 1, 1, 1]

    del && clear

    前面说了pop,用来删除最新的栈元素, 但是我怎么删除list中最先放入, 也就是 list[0]的元素呢?
    一个是用remove()造一个trick. 或者上面的pop例子

    >>> lists.remove(lists[0])
    >>> lists.pop(0)

    不过使用remove的可读性超级差(pop的还可以), 所以, 我们可以使用 python中的内置函数, del 进行删除

    del lists[0]

    这里,我们来对比一下,3者的复杂度

    • del O(n - i)

    • pop O(n - i)

    • remove O(n)

    很容器看出, del和pop的复杂度,比remove小, 所以,如果你想删除以下标开始的list的话,pop和del都行.

    最后,我们如果想删除list的所有元素的话, 直接刚他. 使用clear()即可.

    >>> lists.clear()
    >>> lists
    []

    排序操作

    实际上, 这应该算是一切算法的根源了, 算法做的工作就是筛选和排序. 在list中,提供了两个方法供我们选择 sort, reverse.

    reverse()

    实际上就是倒叙, 将你现在的list的顺序,逆向一遍》

    >>> lists
    [1, 2, 3, 4]
    >>> lists.reverse()
    >>> lists
    [4, 3, 2, 1]

    sort([fn])

    sort应该是最有用的一个方法了. 他根据fn的返回值来判断你原来顺序中的大小. fn接受两个参数fn(pre,next). 代表按照顺序的list的相邻两个元素.

    • fn>0: 则保持现在的顺序

    • fn<0: 交换两者顺序继续比较

    • fn=0: 保留两者的顺序

    你可以自定义函数, 也可以直接使用默认的从小到大的排列.
    即:

    >>> lists = [1,3,2,4,2,3]
    >>> lists.sort()
    >>> lists
    [1, 2, 2, 3, 3, 4]

    这里需要注意一点《 在python3里面, 自带的cmp参数已经被移除了. 可以使用help(list.sort) 检查一遍
    不过, sort本身自带了两个参数,可以用来决定排列的顺序: key,reverse

    >>> lists=['ss','sss','s','ss']
    >>> lists.sort(key=len)
    >>> lists
    ['s', 'ss', 'ss', 'sss']

    或者指明使用reverse=True

    >>> lists=['ss','sss','s','ss']
    >>> lists.sort(reverse=True)
    >>> lists
    ['sss', 'ss', 'ss', 's']

    当然, 如果你不想对原来的list进行改变, 可以使用sorted方法,返回一个新的list进行相关操作.
    我们使用,help(sorted)来看一下具体用法

    sorted(iterable, key=None, reverse=False)
        Return a new list containing all items from the iterable in ascending order.

    同样, 他默认情况下也是升序表示

    >>> lists
    [5, 4, 3, 2, 1]
    >>> sorted(lists)
    [1, 2, 3, 4, 5]

    同样,你也可以使用reverse和key进行相关指定. 同,list这里就不赘述了.

    查询

    在list 查询中, python也提供了我们两个方法, index,count.

    • index(ele): 用来查找具体ele,在list中的序号,没有则会出现ValueError的错误.具体表达式为:

    L.index(value, [start, [stop]])

    看到这个表示之后,我们大概就可以猜到index的基本用法了, 限定范围查找, 也是很重要的一个feature

    • count(ele): 用来统计具体ele在list中出现的次数.

    >>> lists.count(2)
    1

    当然, 如果有同学相到, in 关键字能否实现这个查询的功能呢?答案 is yes!!!
    即, 我们判断一个ele 是否存在于list 可以使用in 来判断

    >>> if 1 in lists:
    ...     print(1)
    ... 
    1
    //或者使用index
    >>> if lists.index(1):
    ...     print(1)
    ... 
    1

    这都是完全行得通的

    复制

    如果你想复制一个list最快的方法就是使用分片. 即

    >>> lists
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> newOne = lists[0:3]
    >>> newOne
    [0, 1, 2]

    不过, python提供了我们另外一个更加语义的方法,copy().

    newOne = lists.copy();
    //或者使用
    newOne = lists[:]

    这样,就避免了 内存地址重叠的problem了.

    额外方法

    除了上面说了的max,min,list等转换方法外, python 内置的还有sum,all,any.

    • sum(): 这里就不写说了, 就是返回 list中所有元素之和

    sum(lists)
    • all(): 是为了判断, lists中所有元素 通过bool(ele)之后都为True,则返回True. 所以,当list元素中有'',0,[]的话,则会返回False 另外, 如果list为空的话, 返回的也是True

    • any(): 使用bool(ele) 判断list中的每一个元素, 如果有一个为ture的话, 返回True, 相当于或的意思. 如果list为空的话返回的是False

    >>> lists
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> any(lists)
    True
    >>> all(lists)  //存在0
    False
    >>> lists = []
    >>> any(lists) //没有元素,不通过
    False
    >>> all(lists)  //没有元素,通过
    True

    Tuple

    另外, 还有一个和list 很像的数据tuple. 中文叫元组. 他和list的主要区别就是, tuple是一开始就定义好的, 即, assign first, 之后就永远不能被改变了. 所以, 一般全局比较重要的数据,我们都是使用tuple进行存放的.
    OK, 首先,我们来创建一个Tuple

    创建一个Tuple

    通常来说,Tuple是放在parentheses 即, 圆括号() 内部.

    >>> tub = (1,2,3)
    >>> type(tub)
    <class 'tuple'>

    不过, 最近很流行的是 without parentheses. 即, 不加括号的方式. show:

    >>> tub = 1,2,3
    >>> type(tub)
    <class 'tuple'>

    这个名叫, tuple packing. 鄙人翻译为, 元组包.

    不过在, 使用tuple 的时候,需要注意,只有一个元素的tuple的创建(md,一个元素你还创建tuple干嘛,浪费内存?)
    一个元素的tuple创建, 需要在末尾+, 进行相关标识

    >>> tub = 1,
    // 或者
    >>> tub = (1,)
    >>> type(tub)
    <class 'tuple'>

    如果,你想访问tuple的话, 和访问list 是一个道理

    >>> tub = (1,2,3,4,5,6,7)
    >>> tub[0]
    1
    //当然,你也可以取负值
    >>> tub[-1]
    7

    所以,这里我们也可以使用for...in...进行 遍历.

    不变的Tuple

    所以, 你一般创建了一个tuple, 之后你就用于无法改变他的值了, 也就是你不能删除, 或者添加. 不过, 如果你的tuple里面放一些可变的内容的话, 比如,list的话, 那情况就不一样了。 基于这一点,我们理解tuple 应该说为 shallow 不变形. 即, 不能改变值类型,但可以改变引用类型.

    >>> tup
    (1, 2, 3, [2, 3], 5)
    >>> tup[3]
    [2, 3]
    >>> tup[3].append(1)
    >>> tup
    (1, 2, 3, [2, 3, 1], 5)
    //删除tup, 会报错
    >>> del tup[0]
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'tuple' object doesn't support item deletion

    虽然,我们不能对tuple执行CD操作, 但相关的查询方法我们还是可以使用的

    Tuple 查询

    在tuple里面有两个查询方法, index和count, 另外你使用in也是没有问题的》

    >>> my_tuple = ('a','p','p','l','e',)
    >>> my_tuple.count('p')
    2
    >>> my_tuple.index('l')
    3
    >>> 'a' in my_tuple
    True

    同样, 关于list的一些built-in methond. 在tuple身上也是使用的, 有 max,min,sum,all,any,len,sorted. 这几个, 都是木有问题的.
    ok, 总结一下:
    tuple方法

    什么时候我们用Tuple

    不费话了, tuple就是用来放不变的数据, 并且tuple 在内部中有遍历加速(因为不变).
    ok~
    That's all

    展开全文
  • 上一次我们介绍了标准数据类型,学完了数据类型是不是还不太会用呢,自己在消化下,我们这次再来说下相对比较常用一个功能,就是数据类型转换,不同的数据类型之间怎么做转换,往下: 上面这个表格是我个人整理...
  • 读书笔记 http://www.runoob.com/python/python-variable-types.html 1.多个变量赋值 a, b, c = 1, 2, “john” ...其实不怎么习惯这种一行多个赋值,感觉java逻辑上维护行低。 2.标准数据类型 后来发现
  • python基本数据类型都在这里

    千次阅读 多人点赞 2020-12-01 14:26:42
    python中列表,元祖,字典怎么还分不清,随便看看完不会我给你买iphone12! 一、列表 1.什么是列表 类比其他语言数组强大地方在于列表中元素可以是不同类型的,到底有多强,上代码。 my_list = [1, "xin...
  • 到目前为止,我们学习了python中三种基本的数据类型,分别为数字类型、布尔值和字符串类型。在实际应用中,我们有时候需要把当前数据转换为其他的数据类型,比如用input获取用户输入年龄时,返回是str类型,但是...
  • 那么,在项目开发中,怎么才能做到检测赋值的时候输入数据的合法性呢? ---------------------------------- 先下面的代码 # -*- coding:utf-8 -*- ''' Created on 2013-3-29 @author: naughty ''' clas
  • 关于python辨别数据类型可以用python type()方法,那么想要查看一串字符中每项类型,并逐一输出要怎么处理?下我是怎么处理 习题要求:输入一行字符,分别统计其中英文字母、数字、空格、和其他字符格式 1 ...
  • 学习一门语言,了解并掌握这门语言的数据类型是无可厚非事情。作为一名初学者,我在这里只列举我现阶段学习到 的数据类型...介绍了数据类型就要知道怎么去获取一个变量的数据类型,下面介绍两个内置函数:type、 ...
  • 零基础初学PythonPython学习路线是怎样?学习Python编程技术流程与步骤,可以参考下面几点内容: 一、清楚学习目标无论是学习什么知识,都要有一个对... Python基本数据类型; 4. 列表和元组操作方法;...
  • 但各种编程语言之间概念可能又会有差异,所以,老生常谈,我们还是需要从新过一遍 Python 概念,当然,如果你已经是老司机了,完全可以一晃而过,不过老司机应该也不会再这些基础。 另外,编程一开始都是枯燥...
  • 暂不考虑应用场景,我只是想把类属性是什么、怎么调用搞清楚 内部(实例方法),分别用 实例对象.类属性 和 类名.类属性 查看类属性 内部(实例方法),分别用 实例对象.类属性 和 类名.类属性 编辑类属性 编辑类...
  • 目前看着教材来,这本教材,好像还是当年得那本,《Python学习手册(第四版)》,不过现在用是eclipse集成环境,写python也方便了很多。 数学部分示例: import math print math....
  • 由于研究方向需要Cornell数据集进行训练,所以最近把数据集下载下来看看怎么,如何输入到pytorchDataLoader里读取。数据集下载下来以后发现数据文件都混杂在一起,搜了一下大概如何构造自己dataset,...
  • Comma Separated Values,简称CSV,它是一种以逗号分隔数值文件类型。在数据库或电子表格中,它是最...一、数据源首先,我们来看看本次操作的数据源,图1 CSV文件是在Excel中打开,图2 CSV文件是在Notepad++中...
  • 1.python采用了动态类型机制2.python变量本质上是对内存空间指针3.python的垃圾收集机制4.python的共享引用现象 【妹子说】这段时间以来,我一直有个疑问,C语言中可以看到int a = 1这种表达,可是python怎么...
  • 我在学习python的时候,接触到列表类型的时候,里面元素大多为str类型的或者为int。 我现在碰到一个题目,要将列表的数据提出组合起来。这个时候我想到就是’’.join()。这个代码,但是如果列表里面是int类型的...
  • 可变类型的数据不可哈希,如list,字典:同值不同址,不同值同址 列表,字典可变, 数值、字母、字符串、数字、元组不可变:同值同址,不同值不同址 怎么判断可变不可变 ? 总结:改个值...
  • 时间序列是日常生活中遇到最常见的数据类型之一。股票价格、销售数据、气候数据、能源使用、甚至个人体重都是可以定期收集的数据。几乎每个数据科学家都会在工作中遇到时间序列,能够有效地处理这些数据数据科学...
  • Python:pkl文件类型

    2019-12-09 09:33:35
    pkl格式文件是python用于保存文件用,一般用来存储图像数据集,有字典类型、列表类型及其他。 怎么使用或者打开这类文件呢? 如果在打开文件时候用是r,r是用来打开文本类型文件,我要打开是二进制类型...
  • 不多BB,直接上干货!现在很多学校都已经将...一、Python基础本部分描述了python的基本语法、数据类型以及编程一些常见操作,适合新手入门,点击链接直接跳转到对应教程。二、Python高级到目前为止,如果你...
  • Python适合进军IT行业吗?怎么深入学好Python?不管怎么说,Python都是大家进军IT行业值得选择... 二是数据结构,字符串、列表、字典、元组这些需要非常熟练,数据类型将贯穿你整个编程始终。  这个部分一些简
  • 更多理论细节可以用《数据结构》严蔚敏 几遍,数据结构很重要是实现算法很大一部分 下面主要谈谈python怎么实现 10.1 栈和队列 栈:后进先出LIFO 队列:先进先出FIFO python 中使用list实现在这些功能 ...
  • 无论是应聘Python方向web开发,还是爬虫工程师,或是数据分析,还是自动化运维,都涉及到一些基础知识!小编挑了一些Python的基础面试题,看看你能不能答上来,也许面试同学用着 1.Python这么好,说说它...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 236
精华内容 94
关键字:

python怎么看数据的类型

python 订阅