Python学习—基础篇之基本数据类型(二)

Python中重要的数据结构

1.列表

2.元组

3.字典

4.集合

列表

1、创建列表

 # 方式一
 name = []
 print(type(name))  # 执行结果 >>>  <class 'list'> 

 # 方式二
 name = list()
 print(type(name))  # 执行结果 >>>  <class 'list'> 

2、增（append，insert）

insert 方法用于将对象插入到列表中对应的索引位置(索引从0开始)，而append方法则用于在列表末尾追加新的对象

 name = ["cdc","ctt","cct","ttr"]

 name.append('alex')
 name.insert(2,'alvin')
 print(name)

 # 执行结果 >>> ['cdc', 'ctt', 'alvin', 'cct', 'ttr', 'alex']

3、删（remove，del，pop）

 name.remove('alex')   # 删除列表中的'alex'元素

 name.remove(name[0])  # 删除列表中索引为0的元素(即第一个元素)

 del name[0]           # 删除列表中索引为0的元素(即第一个元素)

 value = name.pop()    # 弹栈删除，会默认将列表的最后一个元素删除并返回(有返回值)　
 print(value)

 del name              # 删除整个列表

4、改

 names_class2 = ['张三', '李四', '王五', '赵六']

 names_class2[3] = '赵七'
 names_class2[0:2] = ['wusir', 'alvin']
 print(names_class2)

5、查

 names_class2 = ['张三', '李四', '王五', '赵六']

 print(names_class2[2])       # 查询索引为2的元素的值(即第三个元素)
 print(names_class2[0:3])     # 查询索引值为0-3的元素的值(左闭右开)
 print(names_class2[0:7])
 print(names_class2[-1])      # 查询倒数第一个元素的值
 print(names_class2[2:3])
 print(names_class2[0:3:1])   # 查询索引值为0-3的元素的值,步长为1,即挨个查
 print(names_class2[0:3:2])   # 查询索引值为0-3的元素的值,步长为2,即隔一个查一个
 print(names_class2[3:0:-1])  # 从后往前查
 print(names_class2[:])       # 查所有

6、其他操作

6.1  count    统计某个元素在列表中出现的次数

 [

 x = [[1,2], 1, 1, [2, 1, [1, 2]]]
 x.count(1)  

 x.count([1,2])  

6.2 extend     extend 方法可以在列表的末尾一次性追加另一个序列中的多个值。

 a = [1, 2, 3]
 b = [4, 5, 6]
 a.extend(b)
 print(a)   #  [1, 2, 3, 4, 5, 6] 

extend 方法修改了被扩展的列表，而原始的连接操作（+）则不然，它会返回一个全新的列表。

 a = [1, 2, 3]
 b = [4, 5, 6]
 a.extend(b)
 print(a)  #  [1, 2, 3, 4, 5, 6]  

 print(a + b)  #  [1, 2, 3, 4, 5, 6, 4, 5, 6] 

 print(a)   #  [1, 2, 3, 4, 5, 6] 

6.3  index      index 方法用于从列表中找出某个值第一个匹配项的索引位置

 names_class2.index('李四')

6.4  reverse     reverse 方法将列表中的元素反向存放。

 names_class2.reverse()
 print(names_class2)

6.5  sort         sort 方法用于在原位置对列表进行排序。

 x = [4, 6, 2, 1, 7, 9]
 x.sort()   #  x.sort(reverse=True)

6.6 拷贝

 names = ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]
 name_copy = names.copy()
 print(name_copy)

 # 执行结果  ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

补充

 b,*c=[1,2,3,4,5]

 print(*c)   # 2 3 4 5

元组

元组被称为只读列表，即数据可以被查询，但不能被修改，所以，列表的切片操作同样适用于元组。

元组写在小括号(())里，元素之间用逗号隔开。

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

 tup1 = ()    # 空元组
 tup2 = (20,) # 一个元素，需要在元素后添加逗号

 name = ('cdc','ctt','tr')
 print(name[0])
 print(name[1])
 print(name[0:2])

字典

字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。

字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

1、创建字典

 dic1={'name':'alex','age':36,'sex':'male'}  # 推荐使用
 dic2=dict((('name','alex'),))
 print(dic1)
 print(dic2)

2、增

 dic3={}

 dic3['name']='alex'
 dic3['age']=18
 print(dic3)     #  {'name': 'alex', 'age': 18}

 # 如果键已存在，不改变键原来的值
 a=dic3.setdefault('name','yuan')
 b=dic3.setdefault('ages',22)
 print(a,b)
 print(dic3)

3、查

 dic3={'name': 'alex', 'age': 18}

 # print(dic3['name'])
 # print(dic3['names'])
 #
 # print(dic3.get('age',False))
 # print(dic3.get('ages',False))

 print(dic3.items())
 print(dic3.keys())
 print(dic3.values())

 print('name' in dic3)# py2:  dic3.has_key('name')
 print(list(dic3.values()))

4、改

 dic3={'name': 'alex', 'age': 18}

 dic3['name']='alvin'
 dic4={'sex':'male','hobby':'girl','age':36}
 dic3.update(dic4)
 print(dic3)

5、删

 dic4={'name': 'alex', 'age': 18,'class':1}

 # dic4.clear()
 # print(dic4)
 del dic4['name']
 print(dic4)

 a=dic4.popitem()
 print(a,dic4)

 # print(dic4.pop('age'))
 # print(dic4)

 # del dic4
 # print(dic4)

6、其他方法

6.1 dict.fromkeys

 # 相当于初始化，将所有键都赋同样的值
 d1=dict.fromkeys(['host1','host2','host3'],'Mac')
 print(d1)

 d1['host1']='xiaomi'
 print(d1)
 #######
 d2=dict.fromkeys(['host1','host2','host3'],['Mac','huawei'])
 print(d2)
 d2['host1'][0]='xiaomi'
 print(d2)

6.2  d.copy() 对字典 d 进行浅复制，返回一个和d有相同键值对的新字典

6.3  字典的嵌套

 dic={'zhangsan':{'age':23,'sex':'male'},
      '李四':{'age':33,'sex':'male'},
      'wangwu':{'age':27,'sex':'women'}
      }

6.4 sorted(dict) : 返回一个有序的包含字典所有key的列表

 dic4 = {5:"}
 print(sorted(dic4)) #根据键值来排序
 print(sorted(dic4.values())) #根据值来排序
 print(sorted(dic4.items())) #根据键值对来排序（按照键大小）

6.5 字典的遍历

 dic5 = {"name":"cdc","age":22}

 for i in dic5:
     print(i,dic5[i])        #效率较高

 for i in dic5.items():      #效率较低
     print(i)

 for i,v in dic5.items():
     print(i,v)

集合

集合是一个无序的，不重复的数据组合，它的主要作用如下：

• 去重，把一个列表变成集合，就自动去重了
• 关系测试，测试两组数据之前的交集、差集、并集等关系

集合(set)：把不同的元素组成一起形成集合，是python基本的数据类型。

集合元素(set elements):组成集合的成员(不可重复)

li=[1,2,'a','b']
s =set(li)
print(s)    # {1, 2, 'a', 'b'}

li2=[1,2,1,'a','a']
s=set(li2)
print(s)  #{1, 2, 'a'}

集合对象是一组无序排列的可哈希的值：集合成员可以做字典的键

 li=[[1,2],'a','b']
 s =set(li) #TypeError: unhashable type: 'list'
 print(s)

集合分类：可变集合、不可变集合

可变集合(set)：可添加和删除元素，非可哈希的，不能用作字典的键，也不能做其他集合的元素

不可变集合(frozenset)：与上面恰恰相反

 li=[1,'a','b']
 s =set(li)
 dic={s:'} #TypeError: unhashable type: 'set'

集合的相关操作　　

1、创建集合

由于集合没有自己的语法格式，只能通过集合的工厂方法set()和frozenset()创建

 s1 = set('alvin')

 s2= frozenset('yuan')

 print(s1,type(s1))  #{'l', 'v', 'i', 'a', 'n'} <class 'set'>
 print(s2,type(s2))  #frozenset({'n', 'y', 'a', 'u'}) <class 'frozenset'>

2、访问集合

由于集合本身是无序的，所以不能为集合创建索引或切片操作，只能循环遍历或使用in、not in来访问或判断集合元素。

 s1 = set('alvin')
 print('a' in s1)
 print('b' in s1)
 #s1[1]  #TypeError: 'set' object does not support indexing

 for i in s1:
     print(i)
 #
 # True
 # False
 # v
 # n
 # l
 # i
 # a

3、更新集合

可使用以下内建方法来更新：

s.add()
s.update()
s.remove()

注意只有可变集合才能更新：

 # s1 = frozenset('alvin')
 # s1.add(0)  #AttributeError: 'frozenset' object has no attribute 'add'

 s2=set('alvin')
 s2.add('mm')
 print(s2)  #{'mm', 'l', 'n', 'a', 'i', 'v'}

 s2.update('HO')#添加多个元素
 print(s2)  #{'mm', 'l', 'n', 'a', 'i', 'H', 'O', 'v'}

 s2.remove('l')
 print(s2)  #{'mm', 'n', 'a', 'i', 'H', 'O', 'v'}

del：删除集合本身　

四、集合类型操作符　

1   in ,not in
2   集合等价与不等价(==, !=)
3   子集、超集

 s=set('alvinyuan')
 s1=set('alvin')
 print('v' in s)
 print(s1<s)

  4   联合(|)

联合(union)操作与集合的or操作其实等价的，联合符号有个等价的方法，union()。

 s1=set('alvin')
 s2=set('yuan')
 s3=s1|s2
 print(s3)  #{'a', 'l', 'i', 'n', 'y', 'v', 'u'}
 print(s1.union(s2)) #{'a', 'l', 'i', 'n', 'y', 'v', 'u'}　

5、交集(&)

与集合and等价，交集符号的等价方法是intersection()

 s1=set('alvin')
 s2=set('yuan')
 s3=s1&s2
 print(s3)  #{'n', 'a'}

 print(s1.intersection(s2)) #{'n', 'a'}

6、查集(-)
      等价方法是difference()

 s1=set('alvin')
 s2=set('yuan')
 s3=s1-s2
 print(s3)  #{'v', 'i', 'l'}

 print(s1.difference(s2)) #{'v', 'i', 'l'}　

7、对称差集(^)

对称差分是集合的XOR(‘异或’)，取得的元素属于s1,s2但不同时属于s1和s2.其等价方法symmetric_difference()

s1=set('alvin')
s2=set('yuan')
s3=s1^s2
print(s3)  #{'l', 'v', 'y', 'u', 'i'}

print(s1.symmetric_difference(s2)) #{'l', 'v', 'y', 'u', 'i'}

应用

 '''最简单的去重方式'''
 lis = [1,2,3,4,1,2,3,4]
 print list(set(lis))    #[1, 2, 3, 4]

参考博客：https://www.cnblogs.com/yuanchenqi/articles/5782764.html