Python数据结构

 

python中数据结构

 

a.列表             

b.元组

c.字典

d.集合  

名称

与java类似

表示方法

功能

列表

Java中的数组

[]或List()

增删改、切片

元组

Java中的不可变数组

()

切片，不可更改

字符串

Java中的字符串

‘ ‘   “”  ‘’’ ‘’’

不能修改或增加删除 

字典

Java中的Map集合

{}键值对组成的集合 

增删改、切片

集合

Java中的Set集合

只有key值

增删改、切片

1、列表

         类似数组 

                   列表可以存储不同数据类型的元素，数组内元素是相同的 

         列表可以动态扩展长度，添加、删除、更改

                   scala中有变长数组和定长数组之分

         使用[]表示一个列表 

        

1）基本操作：

                  

print(a[0])

print(a[3])

print(a[-1])  //-1代表列表的最后一个元素

 

a[0]=9  //更改

print(a)

a.append(99)  //添加一个元素到列表的最后

print(a)

a.extend([100,200,300])  //添加一个列表

print(a)          

                  

                  

 

a.insert(1,33)  在指定角标插入一个元素

print(a)

 

a.pop()   删除一个元素，参数为默认参数，默认的脚本值是-1  

 

a.pop(3)  删除指定角标的元素，此时默认值-1被3覆盖 

 

del a[0]

print(len(a))  列表的长度 

 

 

2）列表的切片

         python提供了对列表的切片操作，可以快速的简单的取出列表中的部分元素

        

print(a[0:3])#左闭右开

print(a[:3])

print(a[-3:-1])

print(a[-3:])  

print(a[3:10])     不会报脚本越界 

 

 

list =list(range(1,100))  //创建一个列表，使用list()对range类型进行强制转换

print(list)

print(type(list))  //type可以判断一个对象的类型

 

print(list[10:20])  //将角标10到20之间的元素取出

print(list[10:20:3])  //取值时对角标的步长设置

print(list[:20:3])

print(list[::5])  //如果起止脚本都为空，则表示取整个列表中的元素

print(list[:])  //表示将一个列表进行了复制 

list1=list[:]

 

3）其他常用的操作方法

 

reversed反转元素脚本位置

         list = [22, 11, 4, 55, 88]

         print(list)

         print(reversed(list))  //reversed方法返回的不是一列表类型，是一个可迭代对象

 

         for x in reversed(list): 

                   print(x)

 

                  

sorted排序

         list = [22, 11, 4, 55, 88]

 

         # sorted

         print(sorted(list))   //sorted返回一个新的列表，默认是升序排序 

 

 

sum求和

         print(sum(list))  

 

        

4）列表生成式 （重点）    

                  

对一个1-10数字范围先进行乘方，在放入一个列表内 

        

list =list(range(1,10))

 

print(list)

方法一：

         L = []  空的列表 

         for x in list:

                   L.append(x*x)

 

         print(L)

 

方法二：

         使用列表生成式

        

         L = [x * x for x in range(1, 10)] 

 

         L = [x * x for x in range(1, 10) if x %2 == 0]  //可以对范围内的元素进行过滤操作 

 

         L = [x * x if x % 2==0 else x  for x in range(1, 10)]  

        

5）生成器generator （重点！）

         通过列表生成式可以直接得到一个包含具体元素值的列表

                   列表生成式中的元素都是直接经过计算得出了结果 

                   如果该列表生成式的元素非常多，很容易造成应用阻塞或oom 

         可以使用生成器解决：

                  生成器只是保存了生成式的计算规则（算法）

                   每次调用生成器时才会进行一次计算，而不是像列表生成式一样直接一次性计算出全部的元素的值 

                           

生成器的创建:

 

 

L = [x *x for x in range(1, 10)]  //列表生成式返回的结果是list列表类型

G = (x *x for x in range(1, 10))  //生成器表达式返回的结果是generator生成器类型

print(type(L))

print(type(G))

        

        

         方法1：

                   将列表生成式中的[]改为() 

                   G = (x * x for x in range(1,10))

 

                  

         取值：每调用一次，抛出一次计算结果                      

                            print(next(G))

                            print(next(G))

                            print(next(G))

 

                  

         方法2：（在爬虫项目中经常使用）          

                   在一个函数的最后加上关键字yield

                  

------          

defgetSquare(li):

    for i in li:

        squ = i * i

        print(squ)

 

list =[1, 2, 3, 4, 5, 6]

getSquare(list)         

 

-----

defgetSquare(li):

    for i in li:

        squ = i * i

        yield squ

 

list =[1, 2, 3, 4, 5, 6]

 

print(getSquare(list))

print(type(getSquare(list)))

 

list1 =getSquare(list)

 

print(next(list1))

print(next(list1))

print(next(list1))

 

-------

 

         取值：

                   方法一：

                            通过next（）方法

                                    

                   方法二：

                            通过for循环遍历

                            for x in list1:

                                     print(x)

 

 

---------------------------------------

 

 

2、元组 tuple

         是python和scala中特有的一种数据结构

 

         类似列表   

                   相同：也可以存储不同数据类型的元素

                   不同：元组的元素不可进行修改或长度进行动态增加或删除

 

         表示方法：

                   列表：[] 

                   元组：() 

                  

基本操作：

        

t = (22,'hello', True, 33)   元组的定义

print(t[0])          元组的取值，角标从0开始（scala中的元组的脚本起始点？？）                 

t[1]='aa'  报错，tuple元组不支持元素值的更改 

 

t1 =(22,)  当只有一个元素时，需要在元素后加上一个逗号

 

print(type(t1))          

                  

                  

切片：

                           

t = (22,'hello', True, 33)

print(t[0:3])

 

 

3、字符串

         类似元组 

                   字符串中的一个字符相当于是元组中的一个元素

                   字符串不能进行字符的修改或增加删除 

         字符串的表达方法

                   ' '

                   " "

                   ''' '''

                  

基本操作 ：

 

address= "shanghaipudong"

name ='tom'

text='''  //三引号可以保留文本的格式，一般多行文本字符串会用到

aadfdgf

fgsdgdsfsd

'''            

                  

print(address[4])   取字符串中的指定角标的字符 

address[4]= 'G'        报错，字符串不支持元素重新赋值 

 

字符串的加法和乘法

 

str1 ='hello,'

str2 ='world'

print(str1+ str2)  加法，拼接

print(str1,str2)        拼接

 

print(str1* 3)  乘法，复制多份进行拼接

 

 

字符串中的转义：

        

str1 ='hel\'lo,'  

         如果字符串使用单引号表示：

                   内部的单引号需要使用‘\ ’转义

                   内部的双引号不需要进行转义

str2 ="world"

         如果字符串使用双引号表示：

                   内部的单引号不需要转义

                   内部的双引号需要使用‘\ ’转义

str1='''

hellow,

ssff'fdf

fsf"s"dfs

'''

         如果字符串使用三引号表示：

                   则可以直接在文本内添加单引号和双引号

                           

print(str1)        

 

 

字符串切片

str1 ='abcdefg'

print(str1[2:5])        

 

 

字符串中插入变量：（重点）

        

方法一：

         只能将变量插入到字符串的首尾                

name ='Lio'

sayHello= 'hello,'+name

print(sayHello)

 

方法二：

         字符串的格式化功能，在字符串中插入 %s 、%d ....占位符 

                   %s可以代表字符串格式 

                   %d代表数字格式

         在被插入的字符串的最后添加变量： % ( 变量1，变量2... )         变量的位置与字符串中的占位符一一对应

        

name ='Lio'

age = 22

 

sayHello= 'my name is %s ,and age is %d ' % (name, age) 

print(sayHello)         

        

方法三：

         通过字符串的format方法

 

sayHello= 'my name is {0} ,and age is {1} '

print(sayHello.format('tom',22))            

或

sayHello= 'my name is {name} ,and age is {age} ' //字符串中直接使用变量名替代占位编号

print(sayHello.format(age=22,name='tom'))  //在format方法中插入值是必须指定key

 

 

4、字典 

         map 集合  

         由键值对组成的集合 

         为了保证键的唯一性和稳定性：

                   键是需要可以实现哈希的对象，自定义类型的键需要实现哈希方法键的类型需要是一种数量类型，比如            

                            字符串、元组 稳定类型

                            list列表是一种不稳定类型

         定义方式：

                   {key1:value,key2:value,.....}

                   dict(key1=value,key2=value.....)

         在字典中的元素对是无序的 

        

        

基本操作：

a ={'lio': 22, 'tom': 24, 'mary': 19, 'lili': 20}

b =dict(lio=22, tom=24, mary=19, lili=20)               

                  

print(a['tom'])    取值 

a['tom']= 25  对tom的值进行更新 

a['tom1']= 25  如果字典a中没有对应的key，会将该键值对添加进去   

 

print(a.get('tom2'))   如果没有该key，则返回None

print(a.get('tom',-1)) 

         如果有对应的key，则返回key对应的value

         如果没有则返回自定义的默认值

        

print('tom1'in a)   判断在字典a中是否有该key 

print(a.items())   获取字典a中的元素，以元组对的方式返回

print(a.keys())   获取字典中的所有的key值

print(a.values())获取字典中的所有的value值 

 

 

a.update(b) 

         将字典b中的元素全部更新到字典a中

         如果在a和b中出现同名key，以b中对应的value值为准   

print(a)

 

b.clear()清空字典中的元素  

 

 

字典的取值遍历：

                  

for key,value in a.items():  //取出的是具体的key和value的值

    print(key, value)

 

for x ina.items():  //取出的是一个个的元组对

    print(x)

 

 

-------------------------------

 

5、集合

         set集合表示

         集合类似字典，不过只包含了字段中的key的值  

         集合中的元素不能重复  

                   列表中的元素可以重复

                   列表在转化为集合时重复的元素会去重  

         set集合中的元素是无序的，没有角标索引（list列表中的元素是有序的）         

                   set集合不支持切片操作 

         set集合支持数学上的集合操作

                   交集 

                   并集

                   差集

                   补集 

 

         set集合的创建方式

                   需要一个列表对象或range对象进行转化

                  

基本操作：

 

set1 =set([22, 33, 55, 55])   通过列表进行转换为集合，如果有重复的元素会进行去重

print(set1)                

 

set2 =set(range(1, 20))  通过range对象进行转换 

 

        

set1.add(66)  添加一个元素

set1.discard(88)  删除一个元素，如果不存在，不会抛出异常 

set1.remove(88)  删除一个元素，如果不存在会抛出异常  

set1.clear()   清空一个集合 

 

 

集合运行：

 

set1 =set([22, 33, 55])

set2 =set([11, 22, 33, 55, 66])

 

print(set1& set2)   交集  

print(set1| set2)   并集

print(set1- set2)   差集 

print(set1< set2)   set1是否为set2的子集 

print(set1> set2)   set1是否为set2的超集