您还未登录! 登录 | 注册 | 帮助  

您的位置: 首页 > 软件开发专栏 > 开发技术 > 正文

万能Python的秘诀:操纵数据的内置工具

发表于:2020-11-01 作者:读芯术 来源:今日头条

本文转载自公众号“读芯术”(ID:AI_Discovery)。

Python可谓是如今最流行的编程语言,甚至孩子们也可以从它开始学习趣味编程。Python类似英语的简单语法使它成为一种通用语言,已在全世界各个领域被广泛使用。

Python的万能之处正在于其内置的数据结构,它使编码变得简单,不受数据类型限制,并可以根据需要操纵数据。

首先,让我们试着理解什么是数据结构?数据结构是能够存储、组织和管理数据的结构/容器,以便能够有效地访问和使用数据。数据结构就是收集数据类型。Python中有四种内置数据结构。它们是:

  • 列表
  • 字典
  • 元组
  • 集合

开发人员最常用的数据结构是列表和字典。接下来,让我们详细看看每一个数据结构。

1. 列表

Python列表是按顺序排列的任意类型的项的集合。一个列表可以有重复的项,因为每个项都是使用索引访问的,而且可以通过使用负索引逆向访问该列项。列表是可变的,这意味着即使在创建了项之后,也可以添加、删除或更改项;一个列表中还可以包含另一个列表。

(1) 创建列表:

列表可以通过将元素括在[ ]方括号中来创建,每个项之间用逗号分隔。以购物清单为例,创建列表的语法是:


  1. #Creating a list fruits = ['Apple', 'Banana', "Orange"] 
  2. print(type(fruits)) #returns type 
  3. print(fruits) #prints the elements of the listOutput: 
  4.     <class 'list'> 
  5.     ['Apple', 'Banana', 'Orange'] 

(2) 访问列表:

可以使用索引访问列表中的项。列表中的每个项都有一个与之关联的索引,具体取决于该项在列表中的位置。访问列表中的项的语法:


  1. #Access elements in the fruits listfruits = ['Apple', 'Banana',"Orange"] 
  2. print(fruits[0]) #index 0 is the first element 
  3. print(fruits[1]) 
  4. print(fruits[2])Output: 
  5.     Apple 
  6.     Banana 
  7.     Orange 

但是,索引不必总是为正。如果想逆向访问列表,也就是按照相反的顺序,可以使用负索引,如下所示:


  1. #Access elements in the fruits list using negative indexesfruits = ['Apple','Banana', "Orange"] 
  2. print(fruits[-1]) #index -1 is the last element 
  3. print(fruits[-2]) 
  4. print(fruits[-3])Output: 
  5.     Orange 
  6.     Banana 
  7.     Apple 

如果必须返回列表中两个位置之间的元素,则使用切片。必须指定起始索引和结束索引来从列表中获取元素的范围。语法是List_name[起始:结束:步长]。在这里,步长是增量值,默认为1。


  1. #Accessing range of elements using slicingfruits = ['Apple', 'Banana',"Orange"] 
  2.  
  3. fruits #all elements  
  4. ['Apple', 'Guava', 'Banana', 'Kiwi'] #output 
  5.  
  6. fruits[::1] #start to end with step 1 
  7. ['Apple', 'Guava', 'Banana', 'Kiwi'] #outputfruits[::2] #start to endwith step 2 basically index 0 & 2 
  8. ['Apple', 'Banana'] #output 
  9.  
  10. fruits[::3] #start to end with step 2 basically index 0 & 3 
  11. ['Apple', 'Kiwi'] #output 
  12.  
  13. fruits[::-1] #start to end with step 2 - reverse order 
  14. ['Kiwi', 'Banana', 'Guava', 'Apple'] #output 

(3) 向列表中添加元素:

可以使用append()、extend()和insert()函数向列表添加项。


  1. #Adding elementsfruits = ['Apple', 'Banana', "Orange"]#Appendnew elements 
  2. fruits.append('Kiwi') 
  3. print(fruits) 
  4.  
  5. Output:  
  6.     ['Apple', 'Banana', 'Orange', 'Kiwi']#Insertelements in to the listfruits.insert(1,'Guava') #inserts Guava as secondelement is the list since the index is specified as 1 
  7. print(fruits) 
  8.  
  9. Output:  
  10.     ['Apple', 'Guava', 'Banana','Orange', 'Kiwi']  

(4) 从列表中删除项:

与添加元素类似,从列表中删除元素也非常容易,可以使用del()、remove()和pop()方法实现。要清除整个列表,可以使用clear()函数。

  • del()函数删除给定索引处的元素。
  • pop()函数从列表中删除给定索引处的元素,也可以将删除的元素赋值给变量。如果未指定索引值,则删除列表中的最后一个元素。
  • remove()函数根据元素的值来删除元素。
  • clear()函数清空列表。

  1. #Deleting elements from the listfruits = ['Apple', 'Guava', 'Banana','Orange', 'Kiwi'] 
  2.  
  3. #del() function 
  4. del fruits[3] #delete element at index 4 
  5. print(fruits) 
  6.  
  7. Output:  
  8.     ['Apple', 'Guava', 'Banana', 'Kiwi']#pop()function 
  9. del_fruit = fruits.pop(2) 
  10. print(del_fruit) 
  11. print(fruits) 
  12.  
  13. Output:  
  14.     'Banana'   
  15.     ['Apple', 'Guava', 'Orange', 'Kiwi'] 
  16.  
  17. #Remove function 
  18. fruits.remove('Apple') 
  19. print(fruits) 
  20.  
  21. Output:  
  22.     ['Guava', 'Banana', 'Orange', 'Kiwi'] 
  23.      
  24. #Clear() function 
  25. fruits.clear() 
  26. print(fruits) 
  27.  
  28. Output :  
  29.     [] # clears the list 

其他函数:

在处理列表时,还可以使用其他几个函数:

  • len()函数返回列表的长度。
  • index()函数查找第一次遇到的传入值的索引值。
  • count()函数查找传递给它的值的个数。
  • sorted()和sort()函数用于对列表的值进行排序。sorted()具有返回类型,而sort()修改原始列表。

  1. #Other functions for listnum_list = [1, 2, 3, 10, 20, 10] 
  2. print(len(num_list)) #find length of list 
  3. print(num_list.index(10)) #find index of element that occurs first 
  4. print(num_list.count(10)) #find count of the element 
  5. print(sorted(num_list)) #print sorted list but not change original 
  6. num_list.sort(reverse=True) #sort original list 
  7. print(num_list)Output: 
  8. [1, 2, 3, 10, 10, 20] 
  9. [20, 10, 10, 3, 2, 1] 

2. 字典

字典是另一种无序的数据结构,即元素的存储顺序与它们被插入的顺序不同。这是因为索引值不能访问字典中的元素。在字典中,数据以键值对的形式存储,元素值是通过键访问的。

图源:unsplash

(1) 创建字典:

字典由冒号分隔的{}大括号或使用dict()函数编写键和值被创建。


  1. #Creating Dictionariesnew_dict = {} #empty dictionary 
  2. print(new_dict) 
  3.  
  4. new_dict = {1: 'Python', 2: 'Java'} #dictionary with elements 
  5. print(new_dict)Output: 
  6.     {} 
  7.     {1: 'Python', 2: 'Java'} 

(2) 改变并增加键值对:

要更改字典的值,将使用键来访问键,然后相应地更改值。要添加值,只需添加另一个键-值对,如下所示:


  1. #Changing and Adding key, value pairslang_dict = {'First': 'Python','Second': 'Java'} 
  2. print(lang_dict) 
  3.  
  4. lang_dict['Second'] = 'C++' #changing element 
  5. print(lang_dict) 
  6.  
  7. lang_dict['Third'] = 'Ruby' #adding key-value pair 
  8. print(lang_dict)Output: 
  9.     {'First': 'Python', 'Second': 'Java'} 
  10.     {'First': 'Python', 'Second': 'C++'} 
  11.     {'First': 'Python', 'Second': 'C++','Third': 'Ruby'} 

(3) 访问字典中的元素:

字典中的元素只能使用键访问,可以使用get()函数或只是通过键来获取值。


  1. #Accessing Elementslang_dict = {'First': 'Python', 'Second': 'Java'} 
  2. print(lang_dict['First']) #access elements using keys 
  3. print(lang_dict.get('Second'))Output: 
  4.     Python 
  5.     Java 

(4) 删除字典中的键值对:

这些是字典中用于删除元素的函数。

  • pop()-删除值并返回已删除的值
  • popitem()-获取键值对并返回键和值的元组
  • clear()-清除整个字典

  1. #Deleting key, value pairs in a dictionarylang_dict = {'First': 'Python','Second': 'Java', 'Third': 'Ruby'} 
  2. a = lang_dict.pop('Third') #pop element 
  3. print('Value:', a) 
  4. print('Dictionary:', lang_dict) 
  5.  
  6. b = lang_dict.popitem() #pop the key-value pair 
  7. print('Key, value pair:', b) 
  8. print('Dictionary', lang_dict) 
  9.  
  10. lang_dict.clear() #empty dictionary 
  11. print(lang_dict)Output: 
  12.     Value: Ruby #pop element 
  13.     Dictionary: {'First': 'Python','Second': 'Java'} 
  14.     Key, value pair: ('Second', 'Java') #popthe key-value pair 
  15.     Dictionary {'First': 'Python'} 
  16.     {} #empty dictionary 

(5) 其他函数:

这是其他一些可以与字典一起使用的函数,用于获取键值和键-值对等。


  1. #Other functions for dictionarylang_dict = {'First': 'Python','Second': 'Java', 'Third': 'Ruby'} 
  2. print(lang_dict.keys()) #get keys 
  3. print(lang_dict.values()) #get values 
  4. print(lang_dict.items()) #get key-value pairs 
  5. print(lang_dict.get('First'))Output: 
  6.     dict_keys(['First', 'Second','Third']) 
  7.     dict_values(['Python', 'Java','Ruby']) 
  8.     dict_items([('First', 'Python'),('Second', 'Java'), ('Third', 'Ruby')]) 
  9.     Python 

3. 元组

图源:unsplash

元组与列表基本相同,不同的是,一旦数据进入元组,无论如何都不能更改。因此,一旦生成元组,就不能添加、删除或编辑任何值。

(1) 创建元组:

使用()圆括号或tuple()函数创建元组。


  1. #Creating Tuplesmy_tuple = (1, 2, 3) #create tupleprint(my_tuple)Output:    (1, 2, 3)#Creating Tuplesmy_tuple = (1, 2, 3) #create tuple 
  2. print(my_tuple)Output: 
  3.     (1, 2, 3) 

(2) 访问元组中的元素:

访问元组元素与列表类似。


  1. #access elementsmy_tuple2 = (1, 2, 3,'new') for x in my_tuple2:  
  2.     print(x) # prints all the elementsin my_tuple2print(my_tuple2) 
  3. print(my_tuple2[0]) #1st element 
  4. print(my_tuple2[:]) #all elements 
  5. print(my_tuple2[3][1]) #this returns the 2nd character of the element atindex 3  
  6. print(my_tuple2[-1]) #last elementOutput: 
  7.     1 
  8.     2 
  9.     3 
  10.     new 
  11.     (1, 2, 3, 'new') 
  12.     1 
  13.     (1, 2, 3, 'new') 
  14.     e 
  15.     new 

(3) 在另一元组中追加元素:

要追加值,可以使用'+'操作符。


  1. #Appending elementsmy_tuple = (1, 2, 3) 
  2. my_tuplemy_tuple = my_tuple + (4, 5, 6) #add elements 
  3. print(my_tuple)Output: 
  4.     (1, 2, 3, 4, 5, 6) 

(4) 元组赋值:

元组打包和解包操作很有用,执行这些操作可以在一行中将另一个元组的元素赋值给当前元组。元组打包就是通过添加单个值来创建元组,元组拆包则是将元组中的值分配给变量。


  1. #tuple packing 
  2. planets = ('Earth','Mars','Jupiter') 
  3.  
  4. #tuple unpackinga,b,c = planets 
  5. print(a) 
  6. print(b) 
  7. print(c)Output: 
  8.     Earth 
  9.     Mars 
  10.     Jupiter 

4. 集合

图源:unsplash

集合是唯一的无序元素的集合。这意味着,即使数据重复一次以上,集合也只保留一次。

(1) 创建集合:

使用{ }花括号创建集合,并赋值。


  1. #Creating setsnew_set = {1, 2, 3, 4, 4, 4, 5} #create set 
  2. print(new_set)Output: 
  3.     {1, 2, 3, 4, 5} 

(2) 向集合中添加元素:

使用add()函数赋值并添加元素。


  1. #Adding elements to a Setnew_set = {1, 2, 3} 
  2. new_set.add(4) #add element to set 
  3. print(new_set)Output: 
  4.     {1, 2, 3, 4} 

(3) 集合操作:

可以对一个集合执行的不同操作如下所示。

  • union()函数合并了两个集合中的数据。
  • intersection()函数只查找在这两个集合中同时出现的数据。
  • difference()函数删除两个集合中同时存在的数据,并只输出在传递的集合中存在的数据。
  • symmetric_difference()函数执行与difference()函数相同的操作,但是输出在两个集合中保留的数据。
  • clear()函数清空该集合。

  1. #Operations on set 
  2. my_set = {1, 2, 3, 4} 
  3. my_set_2 = {3, 4, 5, 6} 
  4.  
  5. print(my_set.union(my_set_2)) 
  6. print(my_set.intersection(my_set_2)) 
  7. print(my_set.difference(my_set_2)) 
  8. print(my_set.symmetric_difference(my_set_2)) 
  9.  
  10. my_set.clear() 
  11. print(my_set)Output: 
  12.     {1, 2, 3, 4, 5, 6} 
  13.     {3, 4} 
  14.     {1, 2} 
  15.     {1, 2, 5, 6} 
  16.     set() 

Python为我们有效管理、组织和访问数据提供了多种选项,学习其基本内置数据结构是Python学习之旅非常关键的一环。