精华内容
下载资源
问答
  • 主要介绍了Python列表元素转为数字的方法,结合实例形式对比分析了Python列表操作及数学运算的相关技巧,需要的朋友可以参考下
  • python中列表的定义以及特性

    千次阅读 2020-04-19 22:27:55
    1.列表定义 列表是由一系列按特定顺序排列的元素组成,他是python当中内置的可变序列。在形式上,列表的所有元素都放在...python中列表是非常灵活的,这一点去其他语言不同。 2.列表的创建 列表中通常情况下只放入...

    1.列表定义
    列表是由一系列按特定顺序排列的元素组成,他是python当中内置的可变序列。在形式上,列表的所有元素都放在一堆中括号[]里面,两个相邻的元素之间用逗号隔开,在内容上可以将整数、实数、字符串、列表、元组等任何类型的内容放入列表中并且同一个列表中,元素的类型可以不同,因为他们之间没有任何关系。python中的列表是非常灵活的,这一点去其他语言不同。
    2.列表的创建
    列表中通常情况下只放入一种类型的数据,这样可以提高程序的可读性
    使用赋值运算符创建列表

    list = [1,1.2,False,True,'westos']  定义列表内的元素依次为整型、浮点型、布尔型、字符串类型
    print(list)   打印列表
    print(type(list))  查看类型
    
    打印结果
    [1, 1.2, False, True, 'westos']
    <class 'list'>    list:类型为列表
    创建嵌套列表
    list = [1,1.2,True,'westos',[1,2,3,4,5]]
    
    
    ipython中演示效果
    print(list)   打印列表
    [1, 1.2, True, 'westos', [1, 2, 3, 4, 5]]
    In [7]: print (list)                                                            
    [1, 1.2, True, 'westos']
    In [8]: list = [1,1.2,True,'westos']                                            
    In [9]: print (list)                                                            
    [1, 1.2, True, 'westos']
    In [10]: print (type(list))                                                     
    <class 'list'>
    

    3.索引

    service = ['http','ssh','ftp']
    print(service[0])    打印第一个元素
    print(service[-1])   打印倒数第一个元素
    
    打印结果
    http
    ftp
    3.1嵌套列表索引
    service = [['http','80'],['ssh','22'],['ftp','21']]
    print(service[0][1])
    print(service[-1][1])
    
    打印结果
    80
    21
    

    4.切片

    service = ['http','ssh','ftp']
    print(service[::-1])  倒排序
    print(service[1:])  除了第一个都打印
    print(service[:-1])  除了最后一个都打印
    
    打印结果
    ['ftp', 'ssh', 'http']
    ['ssh', 'ftp']
    ['http', 'ssh']
    
    嵌套列表切片
    service = [['http','80'],['ssh','22'],['ftp','21']]
    print(service[:][1])   打印列表里面的所有元素(列表)并打印第二个元素元素(列表)
    print(service[:-1][0])   除了最后一个元素(列表)都打印并且只打印第一个元素(列表)
    
    打印结果
    ['ssh', '22']
    ['http', '80']
    

    5.重复

    service = ['http','ssh','ftp']
    print(service * 3)
    打印结果
    ['http', 'ssh', 'ftp', 'http', 'ssh', 'ftp', 'http', 'ssh', 'ftp']
    

    6.连接

    service = ['http','ssh','ftp']
    service1 = ['westos','hello']
    print(service + service1)
    打印结果
    ['http', 'ssh', 'ftp', 'westos', 'hello']
    

    6.成员操作符

    ervice = ['http','ssh','ftp']
    service1 = ['westos','hello']
    print('http' in service1)   http不在service1里面为假
    print('http' in service)   
    print('http' not in  service)not  in)存在为假
    print('http' not in  service1)    不存在为真
    
    
    打印结果
    False
    True
    False
    True
    

    7.for循环遍历

    遍历:遍历列表中的所有元素是常用的一种的操作,在遍历的过程中可以完成查询、处理等功能。在生活中如果想去买衣服那就要把所有的服装店都要逛一遍,看是否有喜欢的才会去买,那么逛服装店就是遍历的一个操作。

    service = ['http','ssh','ftp']   列表自定义
    for se in service:     
        print(se)     se表示获取到列表当中的元素并输出
     打印结果
    http
    ssh
    ftp
    

    8.计算序列的长度、最大值最小值
    使用len()函数计算计算序列的长度,即返回序列当中有多少个元素
    使用min函数()返回序列当中值最大的元素
    使用max()函数返回序列当中值最大的元素

    li = [1,2,3,4,5,6,7,8,9]
    print('序列li的长度为', len(li))
    print('序列'':''li','最大值是',':',max(li))
    print('序列'':''li','最小值为'':',min(li))
    打印结果
    序列li的长度为 9
    序列:li 最大值是 : 9
    序列:li 最小值为: 1
    

    活学活用(习题)

    1. 假定有下面这样的列表:
      names = [‘fentiao’, ‘fendai’, ‘fensi’, ‘apple’]
      输出结果为:‘I have fentiao, fendai, fensi and apple.’
    .join()连接函数
    names = ['fentiao', 'fendai', 'fensi', 'apple']
    print('I have '  +  ', '.join(names[:-1]) + ' and' + names[-1])
    ', '表示以逗号和空格连接但除了最后一个
    打印结果
    I have fentiao, fendai, fensi andapple
    
    展开全文
  • python列表

    千次阅读 2019-05-29 17:43:26
    python列表

    python列表

    列表是由一系列按特定顺序排列的元素组成,你可以创建包含字母表中的所有字母、数字或所有家庭成员姓名的列表;也可以将任何东西放入列表中,其中的元素之间可以没有任何关系。因为列表中通常包含多个元素,所以一般给列表指定一个表示复数的名称(如letters、digits或names)。
    python中,用方括号([ ])来表示列表,并用逗号来分隔其中的元素。如下:
    bicycles.py

    bicycles = ['trek', 'cannondale', 'redline', 'specialized']
    print (bicycles)
    

    如果让python将列表打印出来,python将打印列表的内部,包括括号:

    ['trek', 'cannondale', 'redline', 'specialized']
    

    访问列表元素

    列表是有序集合,因此要访问列表的任何元素,只需将该元素的位置或索引告诉python即可。要访问列表元素,可指出列表的名称,在指出元素的索引,并将其放在方括号内,例如,下面的代码从列表bicycles中提取第一款自行车:

    bicycles = ['trek', 'cannondale', 'redline', 'specialized']
    print (bicycles[0])
    

    结果如下:

    trek
    

    索引从0开始,所以,要访问具体的元素时,将其位置减一,将结果作为索引,下面访问索引1和索引3处的自行车:

    bicycles = ['trek', 'cannondale', 'redline', 'specialized']
    print (bicycles[1])
    print (bicycles [3])
    

    这个代码会返回列表中的第二个和第四个元素:

    cannondale
    specialized
    

    python为访问最后一个列表元素提供了一种特殊语法。通过将索引指定为-1,可让python返回最后一个列表元素:

    bicycles = ['trek', 'cannondale', 'redline', 'specialized']
    print (bicycles[-1])
    

    这个将会返回‘specialized’。这种语法在当你不知道列表的长度时比较有用,可以直接访问末尾元素,这种约定也适用于其他复数索引,例如-2返回倒数第二个列表元素,索引-3返回倒数第三个列表元素,以此类推。

    使用列表中的各个值

    可像使用其他变量一样使用列表中的各个值。例如,你可以使用拼接根据列表中的值来创建消息。如下:

    bicycles = ['trek', 'cannondale', 'redline', 'specialized']
    message = "My first bicycle was a " + bicycles[0].title() + "."
    
    print (message)
    

    我们使用bicycles[0]的值生成了一个句子,并将其存储在变量message中,输出如下:

    My first bicycle was a Trek.
    

    修改、添加和删除元素

    创建的大多数列表都将是动态的,这意味着列表创建后,将随着程序的运行而增删元素。

    修改列表元素

    修改列表元素的语法与访问列表元素的语法类似。要修改列表元素,可指定列表名和要修改的元素的索引,在指定该元素的新值。
    例如,假设有一个摩托车列表,其中的第一个元素为‘honda’,如何修改它的值?
    motorcycles.py

    motorcycles = ['honda', 'yamaha', 'suzuki']
    print (motorcycles)
    
    motorcycles[0] = 'ducati'
    print (motorcycles)
    

    我们首先定义一个摩托车列表,其中第一个元素为‘honda’。接下来,我们将第一个元素的值改为‘ducati’。输出表明,第一个元素的值确实变了,但其他列表元素的值没变:

    ['honda', 'yamaha', 'suzuki']
    ['ducati', 'yamaha', 'suzuki']
    

    在列表中添加元素

    在列表末尾添加元素

    最简单的方式是将元素添加到列表末尾。给列表附加元素时,它将添加到列表末尾。继续使用前一个实例中,在其末尾添加新元素‘ducati’:

    motorcycles = ['honda', 'yamaha', 'suzuki']
    print (motorcycles)
    
    motorcycles.append('ducati')
    print (motorcycles)
    

    方法append()将元素‘ducati’添加到列表末尾,而不影响列表中的其他所有元素:

    ['honda', 'yamaha', 'suzuki']
    ['ducati', 'yamaha', 'suzuki',‘ducati’]
    

    方法append()让动态地创建列表易如反掌,例如,你可以先创建一个空列表,再使用一系列的append()语句添加元素。下面先创造一个空列表,再在其中添加元素‘honda’、‘yamaha’和‘suzuki’:

    motorcycles = [ ]
    
    motorcycles.append('honda')
    motorcycles.append('yamaha')
    motorcycles.append('suzuki')
    
    print (motorcycles)
    

    最终的列表与前述示例中的列表完全相同:

    ['honda', 'yamaha', 'suzuki']
    

    这种创建列表的方式极其常见,因为经常等程序运行后,你才知道用户要在程序中存储哪些数据。为控制用户,可首先创建一个空列表,用于存储用户将要输入的值,然后将用户提供的每个新值附加到列表中。

    在列表中插入元素

    使用方法insert()可在列表的任何位置添加新元素。为此,你需要指定新元素的索引和值。

    motorcycles = ['honda', 'yamaha', 'suzuki']
    
    motorcycles.insert(0, 'ducati')
    print (motorcycles)
    

    这个示例中,‘ducati’被插入到了列表开头,方法insert()在索引0处添加空间,并将值‘ducati’存储到这个地方,然后列表中既有的元素每个都会右移一个位置:

    ['ducati', 'honda', 'yamaha', 'suzuki']
    

    从列表中删除元素

    使用del语句删除元素

    如果知道要删除的元素在列表中的位置,可使用del语句。

    motorcycles = ['honda', 'yamaha', 'suzuki']
    print (motorcycles)
    
    del motorcycles[0]
    print (motorcycles)
    

    此示例中使用del删除了列表motorcycles中的第一个元素‘honda’:

    ['honda', 'yamaha', 'suzuki']
    ['yamaha', suzuki'']
    

    使用del可删除任何位置处的列表元素,条件是知道其索引。但是使用del语句将值从列表中删除后,你就无法再访问它了。

    使用方法pop()删除元素

    有时候,我们要将元素从列表中删除,并接着使用它的值。例如,你可能需要获取被删除元素的位置,从而进行其他操作,例如显示死亡的效果了之类的,而方法pop()可删除列表末尾的元素,并让我们能够接着使用它。术语弹出(pop)源自这样的类比:列表就像一个栈,而删除列表元素相当于弹出栈顶元素。
    下面从列表motorcycles中弹出一款摩托车:

    motorcycles = ['honda', 'yamaha', 'suzuki']
    print (motorcycles)
    
    poped_motorcycles = motorcycles.pop()
    print (motorcycles)
    print (poped_motorcycles)
    

    我们首先定义并打印了列表motorcycles, 接下来,我们从这个列表中弹出一个值,并将其存储到变量poped_motorcycles中,然后我们打印了这个列表和删除的值:

    ['honda', 'yamaha', 'suzuki']
    ['honda', 'yamaha']
    suzuki
    

    弹出列表中任何位置处的元素

    实际上,你可以使用pop()来删除列表中任何位置的元素,只需在括号内指定要删除的元素的索引即可。

    motorcycles = ['honda', 'yamaha', 'suzuki']
    
    first_owned = motorcycles.pop(0)
    print ('The first motorcycle I owned was a ' + first_owned.title() + '.')
    

    首先,我们弹出了列表中的第一款摩托车,然后打印了一条有关这辆摩托车的消息,输出是一个简单的句子,描述了我购买的第一辆摩托车:

    The first motorcycle I owned was a Honda.
    

    使用pop()语句时,被弹出的元素就不再在列表中了。

    使用del()还是pop(),主要根据具体情况,如果你要从列表中删除一个元素,且不在以任何方式使用它,使用del语句;如果你要在删除元素后还能继续使用它,就是用pop()方法

    根据值删除元素

    有些时候,我们并不知道从列表中删除的值所处的位置,如果你只知道要删除的元素的值,可使用方法remove()。例如,假设我们要从列表motorcycles中删除值‘ducati’:

    motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']
    print (motorcycles)
    
    motorcycles.remove('ducati')
    print (motorcycles)
    

    结果如下:

    ['honda', 'yamaha', 'suzuki', 'ducati']
    ['honda', 'yamaha', 'suzuki']
    

    使用remove()从列表中删除元素时,也可接着使用它的值。下面删除值‘ducati’,并打印一条消息,指出要将其从列表中删除的原因:

    motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']
    print (motorcycles)
    
    too_expensive = 'ducati'
    motorcycles.remove (too_expensive)
    print (motorcycles)
    print ("\nA " + too_expensive.title() + " is too expensive for me.")
    

    结果如下:

    ['honda', 'yamaha', 'suzuki', 'ducati']
    ['honda', 'yamaha', 'suzuki']
    
    A Ducati is too expensive for me.
    

    :方法remove()只删除第一个指定的值。如果要删除的值可能在列表中出现多次,就需要使用循环来判断是否删除了所有这样的值。

    组织列表

    使用方法sort()对列表进行永久性排序

    python方法sort()让你能够较为轻松地对列表进行排序。假设你有一个汽车列表,并要让其中地汽车按字母顺序排列,为简化这项任务,我们假设该列表中地所有值都是小写的。
    cars.py

    cars = ['bmw', 'audi', 'toyota', 'subaru']
    cars.sort()
    print (cars)
    

    方法sort()永久性地修改了列表元素地排列顺序。现在汽车是按字母顺序排列地,再也无法恢复到原来地排列顺序:

    ['audi', 'bmw', 'subaru', 'toyota']
    

    还可以按与字母顺序相反地顺序排列列表元素,为此,只需向sort()方法传递参数reverse = True。如下:

    cars = ['bmw', 'audi', 'toyota', 'subaru']
    cars.sort(reverse = True)
    print (cars)
    

    同样,对列表元素排列顺序的修改是永久性的:

    ['toyota', 'subaru', 'bmw', 'audi']
    

    使用函数sorted()对列表进行临时排序

    要保留列表元素原来的排列顺序,同时以特定的顺序呈现它们,可使用函数sorted()。函数sorted()让你能够按照特定顺序显示列表元素,同时不影响它们在列表中的原始排列顺序。
    如下:

    cars = ['bmw', 'audi', 'toyota', 'subaru']
    
    print ("Here is the original list: ")
    print (cars)
    
    print ("\nHere is the sorted list: ")
    print (sorted(cars))
    
    print ("\nHere is the original list again: ")
    print (cars)
    

    结果如下:

    Here is the original list:
    ['bmw', 'audi', 'toyota', 'subaru']
    
    Here is the sorted list:
    ['audi', 'bmw', 'subaru', 'toyota']
    
    Here is the original list again:
    ['bmw', 'audi', 'toyota', 'subaru']
    

    调用sorted()后,列表元素的排列顺序并没有变。如果你要按与字母顺序相反的顺序显示列表,也可向函数sorted()传递参数reverse = True。
    :在并非所有的值都是小写时,按字母顺序排列列表要复杂些。决定排列顺序时,有多种解读大写字母的方式,要指定准确的排列顺序,可能比我们这里所做的要复杂,但是,大多数排列顺序都基于上述知识。

    倒着打印列表

    要反转列表元素的排列顺序,可使用方法reverse(),假设汽车列表是按照购买时间排列的,可轻松地按相反地顺序排列其中地汽车:

    cars = ['bmw', 'audi', 'toyota', 'subaru']
    print (cars)
    
    cars.reverse()
    print (cars)
    

    注:reverse()不是指按与字母顺序相反地顺序排列列表元素,而只是反转列表元素的排列顺序:

     ['bmw', 'audi', 'toyota', 'subaru']
     ['subaru', 'toyota', 'audi', 'bmw', ]
    

    方法reverse()永久性地修改列表元素地排列顺序,但可随时恢复到原来地排列顺序,此时只需对列表再次调用reverse()即可。

    确定列表的长度

    使用函数len()可快速获悉列表的长度。在下面的示例中,列表包含四个元素,因此其长度为4:

    >>> cars =  ['bmw', 'audi', 'toyota', 'subaru']
    >>> len(cars)
    4
    

    注:python在计算列表元素数时从1开始,因此确定列表长度时,你应该不会遇到差一错误。

    使用列表时避免索引错误

    刚开始使用列表时,经常会遇到一种错误,假设你有一个包含三个元素的列表,却要求获取第四个元素:

    motorcycles = ['honda', 'yamaha', 'suzuki']
    print (motorcycles[3])
    

    这会导致索引错误:

    Traceback (most recent call last):
    	File "motorcycles.py",line 3, in <module>
    		print (motorcycles[3])
    IndexError: list index out of range
    

    python试图向你提供位于索引3处的元素,但它搜索列表motorcycles时,却发现索引3处没有元素。鉴于列表索引差一的特征,这种错误会时有发生,时刻记得索引差一即减一操作就可避免。
    当需要访问最后一个元素时,我们可以以索引-1来访问,但是当列表为空时,此时,索引-1就会出错。
    :发生索引错误却找不到解决办法时,请尝试将列表长度打印出来,列表可能与你以为的截然不同,在程序对其进行了动态处理时尤其如此,通过查看列表或其包含的元素数,可帮助找出这种逻辑错误。

    展开全文
  • 本文实例讲述了Python列表解析操作。分享给大家供大家参考,具体如下: 列表解析 Python 的强大特性之一是其对 list 的解析,它提供一种紧凑的方法,可以通过对 list 的每个元素应用一个函数,从而将一个 list ...
  • python中列表、元组、字典、集合的异同

    万次阅读 多人点赞 2018-10-19 10:08:53
    转载地址 &nbsp; &nbsp;... 一....一直想写写这四种类型的相同点,与不同点在哪里,以及在什么情况下应该使用哪种类型。无奈水平不够,怕写出来不够深刻,所以一直拖着。今天想了想还是写出来吧,...列表(list...

    转载地址    http://blog.csdn.net/weixin_37720172/article/details/78769301


    一.前言

    一直想写写这四种类型的相同点,与不同点在哪里,以及在什么情况下应该使用哪种类型。无奈水平不够,怕写出来不够深刻,所以一直拖着。今天想了想还是写出来吧,如果以后还有新的见解或者技巧我会继续更上去的。


    二.列表(list)

    具有以下特点: 
    1.可以用list()函数或者方括号[]创建,元素之间用逗号’,‘’分隔。 
    2.列表的元素不需要具有相同的类型 
    3.使用索引来访问元素 
    4.可切片

    
     
    1. # 可用list()函数建立
    2. list1 = list(( 1, 2))
    3. # 用[]建立,可包含不同数据类型
    4. list2 = [ 1, 3, 'hello', 3.5]
    5. # 可用下标访问
    6. print(list1[ 1])
    7. # 切片
    8. print(list2[ 1: 3])
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    结果:

    
     
    1. 2
    2. [ 3, 'hello']
    • 1
    • 2

    方法:

    操作 解释
    list.append(): 追加成员
    list.count(x): 计算列表中参数x出现的次数
    list.extend(L): 向列表中追加另一个列表L
    list.index(x): 获得参数x在列表中的位置
    list.insert(): 向列表中插入数据
    list.pop(): 删除列表中的成员(通过下标删除)
    list.remove(): 删除列表中的成员(直接删除)
    list.reverse(): 将列表中成员的顺序颠倒
    list.sort(): 将列表中成员排序

    三.元组

    元组跟列表很像,只不过元组用小括号来实现(),这里要区分好和生成器的区别,两者都可用小括号来实现的

    具有以下特点: 
    1.可以用tuple()函数或者方括号()创建,元素之间用逗号’,‘’分隔。 
    2.元组的元素不需要具有相同的类型 
    3.使用索引来访问元素 
    4.可切片 
    5.元素的值一旦创建就不可修改!!!!!(这是区别与列表的一个特征)

    
     
    1. # 可用tuple()函数创建
    2. tuple1 = tuple([ 1, 2])
    3. # 用()建立,可包含不同数据类型
    4. tuple2 = ( 1, 3, 'hello', 3.5)
    5. # 可用下标访问
    6. print(tuple1[ 1])
    7. # 可切片
    8. print(tuple2[ 1: 3])
    9. # 不可以修改元素
    10. tuple1[ 1] = 10
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    结果:

    
     
    1. 2
    2. ( 3, 'hello')
    3. TypeError: 'tuple' object does not support item assignment
    • 1
    • 2
    • 3

    可进行的操作:元组由于它的不可变性(第五点特点),相比列表的操作少了很多,只保留了index(),count()函数,用法同列表。

    当然也可以用内置函数来对他进行操作,这些内置函数对于列表也适用。

    操作 解释
    cmp(tuple1, tuple2) 比较两个元组元素。
    len(tuple) 计算元组元素个数。
    max(tuple) 返回元组中元素最大值。
    min(tuple) 返回元组中元素最小值。
    tuple(seq) 将列表转换为元组。

    上面第五点在列表中的操作为(参考上面示例代码的第一点):

    操作 解释
    list(seq) 将元组转换为列表。

    四.字典(Dictionary)

    字典是另一种可变容器模型,且可存储任意类型对象。

    具有以下特点: 
    1.元素由键(key)和值(value)组成 
    2.可以用dict()函数或者方括号()创建,元素之间用逗号’,‘’分隔,键与值之间用冒号”:”隔开 
    3.键必须是唯一的,但值则不必。值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组 
    4.使用键(key)来访问元素

    
     
    1. # 用dict()函数创建
    2. dict1 = dict([( 'name', 'kyda'), ( 'e', 10)])
    3. # 用{}创建
    4. dict2 = { 'name': 'lin', 'age': 21}
    5. print(dict1)
    6. # 使用键(key)来访问元素
    7. print(dict2[ 'name'])
    8. # 使用键(key)来访问元素,并修改元素的值
    9. dict2[ 'age'] = 23
    10. print(dict2)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    结果:

    
     
    1. ( 3, 'hello')
    2. { 'name': 'kyda', 'age': 10}
    3. lin
    4. { 'name': 'lin', 'age': 23}
    • 1
    • 2
    • 3
    • 4

    字典的方法:

    操作 解释
    adict.keys() 返回一个包含字典所有KEY的列表;
    adict.values() 返回一个包含字典所有value的列表;
    adict.items() 返回一个包含所有(键,值)元祖的列表;
    adict.clear() 删除字典中的所有项或元素;
    adict.copy() 返回一个字典浅拷贝的副本;
    adict.fromkeys(seq, val=None) 创建并返回一个新字典,以seq中的元素做该字典的键,val做该字典中所有键对应的初始值(默认为None);
    adict.get(key, default = None) 返回字典中key对应的值,若key不存在字典中,则返回default的值(default默认为None);
    adict.has_key(key) 如果key在字典中,返回True,否则返回False。 现在用 in 、 not in;
    adict.iteritems() adict.iterkeys() adict.itervalues() 与它们对应的非迭代方法一样,不同的是它们返回一个迭代子,而不是一个列表;
    adict.pop(key[,default]) 和get方法相似。如果字典中存在key,删除并返回key对应的vuale;如果key不存在,且没有给出default的值,则引发keyerror异常;
    adict.setdefault(key, default=None) 和set()方法相似,但如果字典中不存在Key键,由 adict[key] = default 为它赋值;
    adict.update(bdict) 将字典bdict的键值对添加到字典adict中。

    五.集合(set)

    具有以下特点: 
    1.可以用set()函数或者方括号{}创建,元素之间用逗号”,”分隔。 
    2.与字典相比少了键 
    3.不可索引,不可切片 
    4.不可以有重复元素

    
     
    1. # 两种方法创建
    2. set1 = set( 'kydaa')
    3. set2 = { 'abc', 'jaja', 'abc', 'kyda'}
    4. print( set1)
    5. print( set2)
    • 1
    • 2
    • 3
    • 4
    • 5

    结果:自动将重复元素去除

    
     
    1. {'a', 'y', 'd', 'k'}
    2. {'jaja', 'abc', 'kyda'}
    • 1
    • 2

    集合的方法:

    操作 解释
    s.issubset(t),s <= t 测试是否 s 中的每一个元素都在 t 中
    s.issuperset(t),s >= t 测试是否 t 中的每一个元素都在 s 中
    s.union(t),s | t 返回一个新的 set 包含 s 和 t 中的每一个元素
    s.intersection(t),s & t 返回一个新的 set 包含 s 和 t 中的公共元素
    s.difference(t),s - t 返回一个新的 set 包含 s 中有但是 t 中没有的元素
    s.symmetric_difference(t),s ^ t 返回一个新的 set 包含 s 和 t 中不重复的元素
    s.copy() 返回 set “s”的一个浅复制

    六.同异

    1.列表和元组

    列表和元组有很多相似的地方,操作也差不多。不过列表是可变序列,元组为不可变序列。也就是说列表主要用于对象长度不可知的情况下,而元组用于对象长度已知的情况下,而且元组元素一旦创建变就不可修改。 
    例如我们在打开一个文本时,并不知道里面有多少行文字,所以用列表来保存。

    
     
    1. with open( 'test.txt', 'r') as f:
    2. print(f.readlines())
    3. # 结果:
    4. # [ 'hello world\n' , 'hi kyda\n' , 'this is my program' ]
    • 1
    • 2
    • 3
    • 4

    而我们在储存一个人的信息(名字,年龄,性别,假定只需要这三种信息,所以对象长度为3)的时候,就可以用元组来实现。

    
     
    1. id = ( 'kyda', 19, 'man')
    2. print(id)
    3. # 结果:
    4. # ( 'kyda' , 19 , 'man' )
    • 1
    • 2
    • 3
    • 4

    2.字典 
    字典主要应用于需要对元素进行标记的对象,这样在使用的时候便不必记住元素列表中或者元组中的位置,只需要利用键来进行访问对象中相应的值。

    
     
    1. id = { 'name': 'kyda', 'age': 19, ‘sex ': 'man ')
    2. print(id['age '])
    3. # 结果:
    4. # 19
    • 1
    • 2
    • 3
    • 4

    3.集合 
    集合中的元素不可重复的特点使它被拿来去重。比如我在爬去糗事百科全站的文章链接(存放与列表中)的时候,不可避免的会遇到重复的链接。这是我们只需将列表转换为集合便能有效的去除重复部分。 
    比如上面的例程。

    4.在海量数据中查找元素时,最好将数据创建为字典,或者是集合

    这是由于字典和集合背后的查找原理是散列(哈希)表。由于散列表在查找元素时的时间复杂度基本是O(1),这使查找时间很短。

    在我的一篇博客专门实验了列表,元组,字典,集合在查找元素时所用的时间: 
    Python进阶(八):in的详解

    5.灵活运用推导来创建 
    推导可以说是python最灵活的特性之一。 
    例子:

    list1 = [x for x in range(1, 10)]
     
    • 1

    元组和集合都可以用上面的推导方式进行简单创建

    对于字典来说我们也可以运用双重推导(笛卡尔积)来创建:

    
     
    1. list1 = [ 'name', 'age', 'sex']
    2. list2 = [ 'kyda', 19, 'man']
    3. ID = {x: y for x in list1 for y in list2}
    4. print(ID)
    5. # 结果
    6. # { 'name': 'man', 'age': 'man', 'sex': 'man'}
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    当然上面还可以运用zip()函数简化为:

    ID = {x: y for x, y in zip(list1, list2)} 
     
    • 1

    列表和元组也可以运用双重推导(笛卡尔积)来创建。比如我们要生成一个二维坐标数组:

    
     
    1. coordinate = [(x, y) for x in range( 2)
    2. for y in range( 2)]
    3. print(coordinate)
    4. # 结果
    5. # [(0, 0), (0, 1), (1, 0), (1, 1)]
    • 1
    • 2
    • 3
    • 4
    • 5

    6.枚举元素

    对于列表, 集合,集合都可以运用for…in…来进行枚举

    
     
    1. set1 = { 'name', 'age', 'sex'}
    2. for tmp in set1:
    3. print(tmp)
    4. # 结果
    5. # name
    6. # age
    7. # sex
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    有时候,我们需要用到元素的索引:

    
     
    1. index = 0
    2. for tmp in set1:
    3. print(tmp, index)
    4. index += 1
    • 1
    • 2
    • 3
    • 4

    这样写太过于冗余,我可以用enumerate()函数来帮组我们实现:

    
     
    1. for index, tmp in enumerate(set1):
    2. print(tmp, index)
    • 1
    • 2

    效果是一样的,可这样看起来更加简洁了

    而对于字典,我们要枚举时就有点麻烦。不过还好,字典的方法中有三个方法帮助我们解决这个问题:

    操作 解释
    adict.keys() 返回一个包含字典所有KEY的列表;
    adict.values() 返回一个包含字典所有value的列表;
    adict.items() 返回一个包含所有(键,值)元祖的列表;

    示例:

    
     
    1. list1 = [ 'name', 'age', 'sex']
    2. list2 = [ 'kyda', 19, 'man']
    3. ID = {x: y for x, y in zip(list1, list2)}
    4. for tmp in ID.items():
    5. print(tmp)
    6. # 结果:
    7. # ( 'age' , 19 )
    8. # ( 'sex' , 'man' )
    9. # ( 'name' , 'kyda' )


    转载地址    http://blog.csdn.net/weixin_37720172/article/details/78769301


    一.前言

    一直想写写这四种类型的相同点,与不同点在哪里,以及在什么情况下应该使用哪种类型。无奈水平不够,怕写出来不够深刻,所以一直拖着。今天想了想还是写出来吧,如果以后还有新的见解或者技巧我会继续更上去的。


    二.列表(list)

    具有以下特点: 
    1.可以用list()函数或者方括号[]创建,元素之间用逗号’,‘’分隔。 
    2.列表的元素不需要具有相同的类型 
    3.使用索引来访问元素 
    4.可切片

    
     
    1. # 可用list()函数建立
    2. list1 = list(( 1, 2))
    3. # 用[]建立,可包含不同数据类型
    4. list2 = [ 1, 3, 'hello', 3.5]
    5. # 可用下标访问
    6. print(list1[ 1])
    7. # 切片
    8. print(list2[ 1: 3])
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    结果:

    
     
    1. 2
    2. [ 3, 'hello']
    • 1
    • 2

    方法:

    操作 解释
    list.append(): 追加成员
    list.count(x): 计算列表中参数x出现的次数
    list.extend(L): 向列表中追加另一个列表L
    list.index(x): 获得参数x在列表中的位置
    list.insert(): 向列表中插入数据
    list.pop(): 删除列表中的成员(通过下标删除)
    list.remove(): 删除列表中的成员(直接删除)
    list.reverse(): 将列表中成员的顺序颠倒
    list.sort(): 将列表中成员排序

    三.元组

    元组跟列表很像,只不过元组用小括号来实现(),这里要区分好和生成器的区别,两者都可用小括号来实现的

    具有以下特点: 
    1.可以用tuple()函数或者方括号()创建,元素之间用逗号’,‘’分隔。 
    2.元组的元素不需要具有相同的类型 
    3.使用索引来访问元素 
    4.可切片 
    5.元素的值一旦创建就不可修改!!!!!(这是区别与列表的一个特征)

    
     
    1. # 可用tuple()函数创建
    2. tuple1 = tuple([ 1, 2])
    3. # 用()建立,可包含不同数据类型
    4. tuple2 = ( 1, 3, 'hello', 3.5)
    5. # 可用下标访问
    6. print(tuple1[ 1])
    7. # 可切片
    8. print(tuple2[ 1: 3])
    9. # 不可以修改元素
    10. tuple1[ 1] = 10
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    结果:

    
     
    1. 2
    2. ( 3, 'hello')
    3. TypeError: 'tuple' object does not support item assignment
    • 1
    • 2
    • 3

    可进行的操作:元组由于它的不可变性(第五点特点),相比列表的操作少了很多,只保留了index(),count()函数,用法同列表。

    当然也可以用内置函数来对他进行操作,这些内置函数对于列表也适用。

    操作 解释
    cmp(tuple1, tuple2) 比较两个元组元素。
    len(tuple) 计算元组元素个数。
    max(tuple) 返回元组中元素最大值。
    min(tuple) 返回元组中元素最小值。
    tuple(seq) 将列表转换为元组。

    上面第五点在列表中的操作为(参考上面示例代码的第一点):

    操作 解释
    list(seq) 将元组转换为列表。

    四.字典(Dictionary)

    字典是另一种可变容器模型,且可存储任意类型对象。

    具有以下特点: 
    1.元素由键(key)和值(value)组成 
    2.可以用dict()函数或者方括号()创建,元素之间用逗号’,‘’分隔,键与值之间用冒号”:”隔开 
    3.键必须是唯一的,但值则不必。值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组 
    4.使用键(key)来访问元素

    
     
    1. # 用dict()函数创建
    2. dict1 = dict([( 'name', 'kyda'), ( 'e', 10)])
    3. # 用{}创建
    4. dict2 = { 'name': 'lin', 'age': 21}
    5. print(dict1)
    6. # 使用键(key)来访问元素
    7. print(dict2[ 'name'])
    8. # 使用键(key)来访问元素,并修改元素的值
    9. dict2[ 'age'] = 23
    10. print(dict2)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    结果:

    
     
    1. ( 3, 'hello')
    2. { 'name': 'kyda', 'age': 10}
    3. lin
    4. { 'name': 'lin', 'age': 23}
    • 1
    • 2
    • 3
    • 4

    字典的方法:

    操作 解释
    adict.keys() 返回一个包含字典所有KEY的列表;
    adict.values() 返回一个包含字典所有value的列表;
    adict.items() 返回一个包含所有(键,值)元祖的列表;
    adict.clear() 删除字典中的所有项或元素;
    adict.copy() 返回一个字典浅拷贝的副本;
    adict.fromkeys(seq, val=None) 创建并返回一个新字典,以seq中的元素做该字典的键,val做该字典中所有键对应的初始值(默认为None);
    adict.get(key, default = None) 返回字典中key对应的值,若key不存在字典中,则返回default的值(default默认为None);
    adict.has_key(key) 如果key在字典中,返回True,否则返回False。 现在用 in 、 not in;
    adict.iteritems() adict.iterkeys() adict.itervalues() 与它们对应的非迭代方法一样,不同的是它们返回一个迭代子,而不是一个列表;
    adict.pop(key[,default]) 和get方法相似。如果字典中存在key,删除并返回key对应的vuale;如果key不存在,且没有给出default的值,则引发keyerror异常;
    adict.setdefault(key, default=None) 和set()方法相似,但如果字典中不存在Key键,由 adict[key] = default 为它赋值;
    adict.update(bdict) 将字典bdict的键值对添加到字典adict中。

    五.集合(set)

    具有以下特点: 
    1.可以用set()函数或者方括号{}创建,元素之间用逗号”,”分隔。 
    2.与字典相比少了键 
    3.不可索引,不可切片 
    4.不可以有重复元素

    
     
    1. # 两种方法创建
    2. set1 = set( 'kydaa')
    3. set2 = { 'abc', 'jaja', 'abc', 'kyda'}
    4. print( set1)
    5. print( set2)
    • 1
    • 2
    • 3
    • 4
    • 5

    结果:自动将重复元素去除

    
     
    1. {'a', 'y', 'd', 'k'}
    2. {'jaja', 'abc', 'kyda'}
    • 1
    • 2

    集合的方法:

    操作 解释
    s.issubset(t),s <= t 测试是否 s 中的每一个元素都在 t 中
    s.issuperset(t),s >= t 测试是否 t 中的每一个元素都在 s 中
    s.union(t),s | t 返回一个新的 set 包含 s 和 t 中的每一个元素
    s.intersection(t),s & t 返回一个新的 set 包含 s 和 t 中的公共元素
    s.difference(t),s - t 返回一个新的 set 包含 s 中有但是 t 中没有的元素
    s.symmetric_difference(t),s ^ t 返回一个新的 set 包含 s 和 t 中不重复的元素
    s.copy() 返回 set “s”的一个浅复制

    六.同异

    1.列表和元组

    列表和元组有很多相似的地方,操作也差不多。不过列表是可变序列,元组为不可变序列。也就是说列表主要用于对象长度不可知的情况下,而元组用于对象长度已知的情况下,而且元组元素一旦创建变就不可修改。 
    例如我们在打开一个文本时,并不知道里面有多少行文字,所以用列表来保存。

    
     
    1. with open( 'test.txt', 'r') as f:
    2. print(f.readlines())
    3. # 结果:
    4. # [ 'hello world\n' , 'hi kyda\n' , 'this is my program' ]
    • 1
    • 2
    • 3
    • 4

    而我们在储存一个人的信息(名字,年龄,性别,假定只需要这三种信息,所以对象长度为3)的时候,就可以用元组来实现。

    
     
    1. id = ( 'kyda', 19, 'man')
    2. print(id)
    3. # 结果:
    4. # ( 'kyda' , 19 , 'man' )
    • 1
    • 2
    • 3
    • 4

    2.字典 
    字典主要应用于需要对元素进行标记的对象,这样在使用的时候便不必记住元素列表中或者元组中的位置,只需要利用键来进行访问对象中相应的值。

    
     
    1. id = { 'name': 'kyda', 'age': 19, ‘sex ': 'man ')
    2. print(id['age '])
    3. # 结果:
    4. # 19
    • 1
    • 2
    • 3
    • 4

    3.集合 
    集合中的元素不可重复的特点使它被拿来去重。比如我在爬去糗事百科全站的文章链接(存放与列表中)的时候,不可避免的会遇到重复的链接。这是我们只需将列表转换为集合便能有效的去除重复部分。 
    比如上面的例程。

    4.在海量数据中查找元素时,最好将数据创建为字典,或者是集合

    这是由于字典和集合背后的查找原理是散列(哈希)表。由于散列表在查找元素时的时间复杂度基本是O(1),这使查找时间很短。

    在我的一篇博客专门实验了列表,元组,字典,集合在查找元素时所用的时间: 
    Python进阶(八):in的详解

    5.灵活运用推导来创建 
    推导可以说是python最灵活的特性之一。 
    例子:

    list1 = [x for x in range(1, 10)]
     
    • 1

    元组和集合都可以用上面的推导方式进行简单创建

    对于字典来说我们也可以运用双重推导(笛卡尔积)来创建:

    
     
    1. list1 = [ 'name', 'age', 'sex']
    2. list2 = [ 'kyda', 19, 'man']
    3. ID = {x: y for x in list1 for y in list2}
    4. print(ID)
    5. # 结果
    6. # { 'name': 'man', 'age': 'man', 'sex': 'man'}
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    当然上面还可以运用zip()函数简化为:

    ID = {x: y for x, y in zip(list1, list2)} 
     
    • 1

    列表和元组也可以运用双重推导(笛卡尔积)来创建。比如我们要生成一个二维坐标数组:

    
     
    1. coordinate = [(x, y) for x in range( 2)
    2. for y in range( 2)]
    3. print(coordinate)
    4. # 结果
    5. # [(0, 0), (0, 1), (1, 0), (1, 1)]
    • 1
    • 2
    • 3
    • 4
    • 5

    6.枚举元素

    对于列表, 集合,集合都可以运用for…in…来进行枚举

    
     
    1. set1 = { 'name', 'age', 'sex'}
    2. for tmp in set1:
    3. print(tmp)
    4. # 结果
    5. # name
    6. # age
    7. # sex
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    有时候,我们需要用到元素的索引:

    
     
    1. index = 0
    2. for tmp in set1:
    3. print(tmp, index)
    4. index += 1
    • 1
    • 2
    • 3
    • 4

    这样写太过于冗余,我可以用enumerate()函数来帮组我们实现:

    
     
    1. for index, tmp in enumerate(set1):
    2. print(tmp, index)
    • 1
    • 2

    效果是一样的,可这样看起来更加简洁了

    而对于字典,我们要枚举时就有点麻烦。不过还好,字典的方法中有三个方法帮助我们解决这个问题:

    操作 解释
    adict.keys() 返回一个包含字典所有KEY的列表;
    adict.values() 返回一个包含字典所有value的列表;
    adict.items() 返回一个包含所有(键,值)元祖的列表;

    示例:

    
     
    1. list1 = [ 'name', 'age', 'sex']
    2. list2 = [ 'kyda', 19, 'man']
    3. ID = {x: y for x, y in zip(list1, list2)}
    4. for tmp in ID.items():
    5. print(tmp)
    6. # 结果:
    7. # ( 'age' , 19 )
    8. # ( 'sex' , 'man' )
    9. # ( 'name' , 'kyda' )


    展开全文
  • python中统计特征

    千次阅读 2018-07-09 16:30:56
    1.np.sum(a,axis=None,dtype=None) 发现对于布尔运算的结果,np.sum()只是返回其中True的个数。如:&gt;&...3用在统计样本各类元素个数:from sklearn import datasets iris = dat...

    1.np.sum(a,axis=None,dtype=None)

        发现对于布尔运算的结果,np.sum()只是返回其中True的个数。如:

    >>> np.sum(np.array([True,False,True,False,False,True]))
          
    3

    用在统计样本中各类元素个数中:

    from sklearn import datasets
    iris = datasets.load_iris()
    x = iris.data
    data = x[0]  # 数据集中第一个属性
    features = set(data)  # data中各不同的特征
    tmp = [data == feature for feature in features]  # 返回的tmp是含35个元素的表,每个表中元素是150个元素的矩阵,矩阵中元素是布尔运算判别结果,True or False
    >>>[np.sum(x) for x in tmp]
    [2, 7, 9, 10, 6, 9, 4, 6, 3, 5, 7, 1, 1, 1, 3, 6, 4, 2, 5, 7, 6, 6, 1, 1, 1, 1, 8, 1, 4, 8, 4, 3, 1, 3, 4]

    同样如同np.argsort(),或者np.argmax(a,axis=None).返回最大值的索引。

    2.set(iterable)

    set() 函数创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等。

    显然可以用来提取出所以类别

    3.np.bincount(x,weights=None,minlength=0)

    x 可以是列表,数组,weights是每个元素的权重,写成列表形式,如果weights不是None,则返回结果为权重的叠加和,其中每个元素是对应元素的权重的和。元素个数和x的元素个数是相同的,minlength是指定结果的长度,如果minlength被指定,那么输出数组中bin的数量至少为它指定的数(如果必要的话,bin的数量会更大,这取决于x)。

    >>> np.bincount([2,3,3,4],weights=None,minlength=0)
          
    array([0, 0, 1, 2, 1], dtype=int64)
    >>> np.bincount(np.array([2,3,3,4]),weights=[0.5,0.4,-0.2,0.6],minlength=0)
          
    array([0. , 0. , 0.5, 0.2, 0.6])
    >>> np.bincount([0.2,0.3,0.3,0.4],weights=None,minlength=0)
          
    array([4], dtype=int64)

    注意到没法处理浮点数,因为他会把浮点数变成整数。

    3.collcetions.Counter()

    Counter()函数可以统计一维数组中不同元素及其出现次数。返回结果为一个字典,字典keys是元素的类别,values是类别对应出现次数。可以通过Counter(x).values(),和Counter(x).keys()来访问各类别出现次数,和类别。当然是列表形式。只能以for循环访问具体元素。

    >>> d=np.random.randint(1,5,size=7)      
    >>> d      
    array([2, 4, 3, 4, 2, 2, 2])
    >>> Counter(d)     
    Counter({2: 4, 4: 2, 3: 1})
    >>> Counter(d).values()      
    dict_values([4, 2, 1])
    >>> Counter(d).keys()      
    dict_keys([2, 4, 3])
    >>> for i in Counter(d).keys():
          print(i)
    
          
    2
    4
    3

    Counter统计对象可以是字符串,也可以是浮点数:

    >>> a=np.array(['是','否','是','是','否','非',])
    >>> from collections import Counter
    >>> Counter(a)
    Counter({'是': 3, '否': 2, '非': 1})
    >>> Counter(np.array([0.1,0.3,0.5,0.8]))
    Counter({0.1: 1, 0.3: 1, 0.5: 1, 0.8: 1})

    这是他的优点,但是没法对每个元素加权,这也是没办法的。这时就需要bincount函数

    counter由于返回的是字典,因此没法索引。如果一定要索引,就需要将字典类型转换。如list(counter(a)).这样就可以索引其中元素了.一般索引keys()或values()。


    4.np.bincount(x, weights=None, minlength)

    点击打开链接np.bincount详解

    补充几点:

    0.bincount对自然数统计,不管是否出现,如果对象中只有1,3,那么输出会补上0,2,虽然他们的出现次数都为0.

    0.1. 输出的数组实际是对应元素的权重和,如果weights=None,则权重默认为1,否则就按加法计算。

    1.bincount只能统计数字出现次数,不能统计字符串出现次数,如:

    >>> a=np.array(['是','否','是','是','否','非',])
    >>> np.bincount(a)
    Traceback (most recent call last):
      File "<pyshell#44>", line 1, in <module>
        np.bincount(a)
    TypeError: Cannot cast array data from dtype('<U1') to dtype('int64') according to the rule 'safe'
    >>> a=np.array(['a','c','d'])
    >>> np.bincount(a)
    Traceback (most recent call last):
      File "<pyshell#46>", line 1, in <module>
        np.bincount(a)
    TypeError: Cannot cast array data from dtype('<U1') to dtype('int64') according to the rule 'safe'

    2.数字必须是整数,不能是浮点数,如:

    >>> np.bincount(np.array([0.1,0.3,0.5,0.8,2]))
    Traceback (most recent call last):
      File "<pyshell#35>", line 1, in <module>
        np.bincount(np.array([0.1,0.3,0.5,0.8,2]))
    TypeError: Cannot cast array data from dtype('float64') to dtype('int64') according to the rule 'safe'
    >>> 

    3.必须是自然数,不能是负数。例如:

    >>> b=[-1,-2,1,1,2,3,6]
    >>> b=np.array([b])
    >>> np.bincount(b)
    Traceback (most recent call last):
      File "<pyshell#32>", line 1, in <module>
        np.bincount(b)
    ValueError: object too deep for desired array
    4.bincount统计对象可以是列表,元组,但是也不许有字符串,或者负数,浮点数


    5.enumerate(iterable)

    enumerate()是内置函数,返回对应索引及其值,也是没法直接访问其中元素。

    enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。

    >>> d
    array([2, 3, 4, 2, 3, 2])
    >>> index_lst=[]  # 存放索引
    >>> ele_lst=[]  # 存放元素
    >>> from collections import Counter
    >>> features=Counter(d).keys() # 找features也可用set(d)获取,都一样需要转变成list才能索引
    >>> features
    dict_keys([2, 3, 4])
    >>> features=list(feautres)  # 如果不把feature变成列表格式就没法索引里面的元素
    >>> for index,ele in enumerate(d):
    	if ele == features[0]:
    		ele_lst.append(ele)
    		index_lst.append(index)
    >>> index_lst
    [0, 3, 5]
    >>> ele_lst
    [2, 2, 2]



    6.filter(function,iterable)

    filter() 函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。

    该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判,然后返回 True 或 False,最后将返回 True 的元素放到新列表中。


    7.用判别语句实现分类统计

    最简单的例子:

    >>> d=[2,3,4,2,3,2]  # 定义一个列表
    >>> d == 2  # 这里只能这这个判句
    False
    >>> d=np.array(d)  # 如果变成矩阵,就可以对所有元素进行判断了
    >>> d == 2
    array([ True, False, False,  True, False,  True])
    
    >>> features=set(d)
    >>> features
    {2, 3, 4}
    

    最好用矩阵判断。列表默认对整个表判断

    >>> e=[d == feature for feature in features]
    >>> e
    [array([ True, False, False,  True, False,  True]), array([False,  True, False, False,  True, False]), array([False, False,  True, False, False, False])]

    每个特征都对所有的元素遍历判别过了,返回结果是每个特征对应的判别结果,可以用来寻找每个特征对于的样本和输出。

    如:

    第一个特征也就是2对应的样本:

    >>> d[e[0]]
    array([2, 2, 2])





    展开全文
  • Python中列表的功能与特性

    千次阅读 2018-08-14 23:18:36
    ########列表特性及使用方法#######     ##列表    所谓列表就可以比喻为(打了激素的数组),它不同于数组,它可以储存任意数据类型的集合。   ##列表的特性   # 索引 print(services[0]) #正向...
  • ”的代码时(在一个例子、在StackOverflow、在开源码软件,等等),我会尝试它直到理解它,然后把它添加到列表中。这篇文章是清理过列表的一部分。如果你是一个有经验的Python程序员,尽管你可能已经知道一些,...
  • 小甲鱼零基础入门学习python笔记

    万次阅读 多人点赞 2019-08-14 11:06:30
    小甲鱼老师零基础入门学习Python全套资料百度云(包括小甲鱼零基础入门学习Python全套视频+全套源码+全套PPT课件+全套课后题及Python常用工具包链接、电子书籍等)请往我的资源... 000 愉快的开始 ...
  • Flase:表示对应特征特征无缺失值 True:表示有缺失值 通常情况下删除行,使用参数axis = 0,删除列的参数axis = 1,通常不会这么做,那样会删除一个变量。 print(df.dropna(axis = 0)) 以上这篇python 检查...
  • 本文主要围绕效率开始说起 常见算法效率复杂度 O(1) <...python列表内置操作方法的复杂度如下 常见的顺序表存储方式如下,python则采用的是分离式结构,表头只存储最大容量值,元素个...
  • 起初的数据是这样的 想将page_no这一列拆分成多个列,然后将其中的值都作为列名。 想要做成的结果如下图(也就是统计每个id下各个page_no出现的次数) 实现的思路是先对page_no这一列进行one-hot编码,将一列变为...
  • 列表特点: 1) 有序的,写进去什么顺序输出还是什么顺序,也可排序 2) 可以修改 可以存放任意类型的数据 2元组特点: · 元组和列表类似,都相当于一个容器,可以存放很多数据 · 元组的单词:tuple ...
  • 如何定义集合,集合与列表有什么区别? 目录如何定义集合,集合与列表有什么区别?如何定义集合?集合与列表有什么区别? 如何定义集合? 使用大括号 {} 或者 set() 函数来创建 格式如下。 parame = {value01,...
  • Python实现列表匹配

    万次阅读 2018-06-09 22:40:00
    要进行文章的最佳匹配与推荐,思路是以15个分词作为特征,进行list与list之间的交集运算。我们认为交集元素数目最多的最匹配,一样多的情况下,分词的序号(例如分词1、分词3、分词10的1、3、10)代表着其重要性,...
  • 今天小编就为大家分享一篇python输出数组指定元素的所有索引示例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 特征选择 Python代码

    千次阅读 2019-12-12 20:38:57
    特征工程包函内容很多,包括数据分析,特征组合变换,特征选择和特征降维等等的技术。特征工程和数据的清洗占据了建模过程绝大部分的时间。其中特征选择是必不可少的阶段。 当建模样本数量不足,但特征较多的...
  • 上一篇博客shuihupo 博客地址,...在文本数据处理,我们遇到的经常是一个个字符串,且对于中文来说,经常要处理没有分割符的大段最原始的字符串(这种数据需要先分词,转化为一个分割好的字符...
  • python中列表,元祖,字典,集合的区别

    万次阅读 多人点赞 2018-08-09 15:33:40
    一.前言 一直想写写这四种类型的相同点,与不同点在哪里,以及在什么情况下应该使用哪种类型。无奈水平不够,怕写出来不够深刻,所以一直拖着。...2.列表的元素不需要具有相同的类型 3.使用索引来访问元素 ...
  • list的定义方式 有关列表的定义: ...列表中可嵌套列表 列表的几种特性 1.index 索引 列表service = [‘ftp’,‘http’,‘apache’,‘ssh’] 作用 print(service[0]) 打印列表中的第一个元素 pr
  • python 3.x 版本 set 有函数intersection() intersection() 方法用于返回两个或更多集合中都包含的元素,即交集。 语法: 在这里插入代码片set.intersection(set1, set2 … etc) 参数: set1 – 必需,要查找...
  • 看了一些删除list带有某些特征元素的帖子,大多都是用remove,pop,del来解决,其实可以换个思路来写,就是找到你需要的元素,再给它们重新放入列表中。 如下,想要删除带有Description特征的元素,保留其他所有元素...
  • Python机器学习实践

    千次阅读 2019-10-15 21:14:08
    前面几篇博文已经整理了Python做数据分析和建模以及机器学习基础知识。 这篇博文主要分享Python做数据分析和建模的实践案例应用。 分为两部分: 1、Python机器学习实践案例的算法总结。 见博文下方的算法总结...
  • 特征 记住您打开过的文件(是的,这里有开创性的东西):3 按类别自定义任务的样式 任务依赖性跟踪。 轻量级文件格式 筛选 树显示轻松的依赖关系可视化 队列显示可立即执行的任务的列表,用于当您真的不觉得需要...
  • 列表是序列,可以理解为数据结构的数组,字典可以理解为数据结构的hashmap 他俩都可以作为集合来存储数据 从差异特征上来说 1. list是有序的,dict是无需的 2. list通过索引访问,dict使用key访问 3. list...
  • 【导读】如今机器学习正在从人工设计模型更多地转移到自动优化工作流,如 H20、TPOT 和 auto-sklearn 等工具已被广泛使用。这些库以及随机搜索等方法都致力于寻找最适合数据集的模型,以此简化模型筛选与调优过程...
  • Python数据科学软件的精选列表很棒的Python数据科学可能是Python数据科学软件的最佳精选列表目录机器学习深度学习数据处理特征工程可视化模型说明强化学习概率方法遗传编程优化自然语言处理计算机试听计算机视觉统计...
  • 使用python中的情感分析库将IMDb电影评论分为正面或负面 情绪分析 情感分析是指使用自然语言处理(NLP),文本分析和计算来系统地提取,识别信息并将其分类为特定类别。 该项目使用python sklearn库的高斯朴素...
  • 在机器学习的算法训练,有很多数据的特征值不止一个,特征有些属性的数字过大,从而对计算结果的影响太大,但是实际情况是每个属性都同等重要,这时候就要处理这种不同取值范围的特征值,通常采用数值归一化,...
  • python升序和降序排序If you want to learn how to work with the sort() method in your Python projects, then this article is for you. This method is very powerful and you can customize it to fit your ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 65,779
精华内容 26,311
关键字:

python中列表的特征

python 订阅