Python基本数据类型--列表、元组、字典、集合

一、Python基本数据类型--列表（List）

　　1、定义：[ ]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素。

　　2、列表的创建：　　　

# 方式一
list1 = ['name','age',''job]

# 方式二
list2 = list('age','name,'salary'')

　　3、列表的特点

　　　<1> 可存放多个值。

　　　<2> 按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序。

　　　<3> 可修改指定索引位置对应的值，属于可变类型。

　　4、常用操作（较多，和示例一起放出）　

#！/usr/bin/env python
#！-*- coding:utf-8 -*-
# write by congcong

'''列表的查询'''
list1 = ['luffy','python','buy',666,666,888,999] #创建列表
list2 = [] #创建空列表
print(list1[1],list1[-1]) # []中取正时从左侧开始索引，取负时从右侧开始索引，输出：python  999
print(list1.index('buy')) # index可索引查找指定元素的位置，此处输出：2
print(list1.count(666)) # count可以统计指定元素出现的次数，此处输出：2

'''列表的切片 :顾头不顾尾'''
list3 = ['Congcong','Baidu','Tengxun','Aali',123,456,666,888,999]
print(list3[1:4]) # 返回从索引1到4的元素，不包括索引4 ，输出：['Baidu', 'Tengxun', 'Aali']
print(list3[-5:]) # 返回从索引-5到末尾-1的元素，包括索引 -1 ，输出：[123, 456, 666, 888, 999]
print(list3[:4]) # 返回从索引0到4的元素，包括索引0 ，输出：['Congcong', 'Baidu', 'Tengxun', 'Aali']
print(list3[1:6:2]) # 返回索引1到6的值，步长为2（每隔一个打印一个），输出：['Baidu', 'Aali', 456]
print(list3[:]) # 返回所有的值,输出：['Congcong', 'Baidu', 'Tengxun', 'Aali', 123, 456, 666, 888, 999]
print(list3[::2]) # 按步长为2，返回所有的值,输出：['Congcong', 'Tengxun', 123, 666, 999]

'''列表的添加，修改，插入'''
list4 = ['Xingyuan','song','happy',1,5,7,2,9]
list4.append(0) # 在列表末尾追加元素 0
print(list4) #输出：['Xingyuan', 'song', 'happy', 1, 5, 7, 2, 9, 0]
list4[2] = 'lyric' #将索引为2的元素修改为 'lyric'
print(list4) #输出：['Xingyuan', 'song', 'lyric', 1, 5, 7, 2, 9, 0]
list4.insert(3,'great') #在索引为3的元素前插入'great'
print(list4) # 输出： ['Xingyuan', 'song', 'lyric', 'great', 1, 5, 7, 2, 9, 0]
list4[0:4] = 'Wangyiyun' #修改索引从0到4之间的元素(不包括4)，不足部分自动向后扩充
print(list4) #输出：['W', 'a', 'n', 'g', 'y', 'i', 'y', 'u', 'n', 1, 5, 7, 2, 9, 0]

print(list3+list4)# 合并两个列表，输出：['Congcong', 'Baidu', 'Tengxun', 'Aali', 123, 456, 666, 888, 999, 'W', 'a', 'n', 'g', 'y', 'i', 'y', 'u', 'n', 1, 5, 7, 2, 9, 0]
list4.extend(list3) # extend继承合并，即前者继承后者
print(list4) #输出：['W', 'a', 'n', 'g', 'y', 'i', 'y', 'u', 'n', 1, 5, 7, 2, 9, 0, 'Congcong', 'Baidu', 'Tengxun', 'Aali', 123, 456, 666, 888, 999]

'''列表的删除'''
list5 = ['life','poem','distance','people',2,0,1,8,1,4]
print(list5.pop(3)) # 删除列表中索引为3的元素people
print(list5)  # 输出结果：['life', 'poem', 'distance', 2, 0, 1, 8, 1, 4]
list5.remove('life') # 删除列表中的'life'元素
print(list5) # 输出：['poem', 'distance', 2, 0, 1, 8, 1, 4]
del list5[-5:] # 删除索引为-5之后的所有元素
print(list5) #输出：['poem', 'distance', 2]
del list5[2] #删除索引为2的元素
print(list5) #['poem', 'distance']
#del list5 #删除整个列表
#print(list5)

'''列表的其他方法'''
list6 = ['b','a','p','f','c']
list6.sort()# 将元素按ASCII表排序，字符和数字同时排序会报错
list7 = list6
print(list6,list7) #输出：['a', 'b', 'c', 'f', 'p']  ['a', 'b', 'c', 'f', 'p']
list6.reverse() # 将list6中的元素按ASCII表倒序存放
print(list6)  # ['p', 'f', 'c', 'b', 'a']
list6[1] = 'd' # 修改list6中索引为1的元素
print(list6,list7) #输出：['p', 'd', 'c', 'b', 'a'] ['p', 'd', 'c', 'b', 'a']，直接将list6赋给list7时，一改全改
list8 = list6.copy() #将list6复制一份赋给list8，list8和list6完全独立
print(list6,list8) #输出：['p', 'd', 'c', 'b', 'a'] ['p', 'd', 'c', 'b', 'a']
list6[0] = 'E' #修改list6中索引为0的元素
print(list6,list8) # 输出：['E', 'd', 'c', 'b', 'a'] ['p', 'd', 'c', 'b', 'a']，list6复制后再赋给list8时，list6被修改时，不会影响list8

list8.clear() #清空列表
print(list8) #输出：[]

　　　4.1 列表的深浅copy（难点）　

#！/usr/bin/env python
#！-*- coding:utf-8 -*-
# write by congcong

#单层列表的赋值、拷贝（浅copy）与修改
name1 = [1,2,3,4,5,6]
name2 = name1
print(name1,name2,id(name1),id(name2))#输出：[1, 2, 3, 4, 5, 6] [1, 2, 3, 4, 5, 6] 2139917318536 2139917318536
name1.append('add') #修改name1
print(name1,name2)#输出：[1, 2, 3, 4, 5, 6, 'add'] [1, 2, 3, 4, 5, 6, 'add']
print(id(name1),id(name2),id(name1[1]))#id方法获取内存地址，输出：1277397235848 1277397235848  1633399904
name1 = [7,8,9,0] #name1重新赋值，即重新分配内存地址
print(name1,name2)#输出：[7, 8, 9, 0] [1, 2, 3, 4, 5, 6, 'add']
print(id(name1),id(name2)) #输出：1370758379848 1370758379656

name3 = name1.copy() # 浅copy方法，对列表name1进行拷贝并赋给name3
print(name1,name3) #输出：[7, 8, 9, 0] [7, 8, 9, 0]
print(id(name1),id(name3)) #输出：1694957304264 1694957304328 两者内存地址不同，故并无联系
name1.append(66) #修改列表name1
print(name1,name3) #输出：[7, 8, 9, 0, 66] [7, 8, 9, 0] ，可见name3并不受影响

#多层嵌套列表的浅copy和深copy(deepcopy)，深copy，完全克隆谨慎使用
import copy   #深copy必须要导入copy模块
L1 = [1,2,3,['CC',21]]
L2 = L1.copy() #浅copy
L3 = copy.deepcopy(L1) #深copy
print(L1,L2) #输出：[1, 2, 3, ['CC', 21]] [1, 2, 3, ['CC', 21]]
L1[0] = 'LF' #浅copy时第一层列表元素内存相互独立，修改时不会相互影响
print("L1:\033[32;1m%s\033[0m\n L2:\033[33;1m%s\033[0m\n L3:\033[34;1m%s\033[0m\n"%(L1,L2,L3))
'''输出(此时L2,L3并未改变):
 L1:['LF', 2, 3, ['CC', 21]]
 L2:[1, 2, 3, ['CC', 21]]
 L3:[1, 2, 3, ['CC', 21]]
'''
L1[-1][0] = 'SC'#修改列表L1中的小列表，第二层的嵌套小列表仍会相互影响
print("L1:\033[35;1m%s\033[0m\n L2:\033[36;1m%s\033[0m\n L3:\033[30;1m%s\033[0m"%(L1,L2,L3))
'''输出（L2随之改变,L3仍未改变）：
 L1:['LF', 2, 3, ['SC', 21]]
 L2:[1, 2, 3, ['SC', 21]]
 L3:[1, 2, 3, ['CC', 21]]
'''

　　5、列表和字符串（split 和 join）　　　

s = 'Hello everyone'
s1 = s.split()  # 将字符串默认以空格划分
s = 'Hello,everyone'
s2 = s.split(',')  # # 将字符串默认以逗号划分
print(s1,s2)  # ['Hello', 'everyone'] ['Hello', 'everyone']

list = ['want','fly']
s3 = ','.join(list)  # 将列表转为字符串
print(s3)  # 'want,fly'

二、Python基本数据类型--元组（tuple）

　　1、定义：与列表类似，只不过［］改成（）。

　　2、特性：

　　　　　　<1> 可存放多个值 。
　　　　　　<2> 不可变 。
　　　　　　<3> 按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序。

　　3、作用：因为元组一旦创建，便不可更改，所以可用于储存一些不变的量，防止被修改或误操作。

　　4、元组的创建　

方式一：

                    ages = (11, 22, 33, 44, 55)

方式二：　　　

                   ages = tuple((11, 22, 33, 44, 55)

   5、常用操作

#！/usr/bin/env python
#！-*- coding:utf-8 -*-
# write by congcong

names = ('Jack','Rose','Bob','Alice','a','a')#元组又称只读列表
print(type(names))
print(names.index('Bob'))
print(names[1:])
print(names.count('a'))
name2 = (1,2,3,4,['cc',21]) #元组第一层不可修改，但内嵌列表可修改
name2[-1][0] = 'sc'
print(name2) #输出：(1, 2, 3, 4, ['sc', 21])
name3 = (5,6,7,8,('Jack',24))#错误写法
name3[-1][0] = 'Frank'
print(name3)

三、Python基本数据类型--字典（dict）
    1、定义：｛key1:value1,key2:value2｝
　　　　　注意：
　　　　　　　<1> 键与值用冒号“：”分开；
　　　　　　　<2> 项与项用逗号“，”分开。
    2、特性：
      <1> key-value结构
      <2> key必须可hash、且必须为不可变数据类型、必须唯一
      <3> 可存放任意多个值、可修改、可以不唯一
      <4> 无序
　　
    3、字典的创建
　　　　方式一：
　　　　　　st = {'name1':'hyt','age':19}
　　　　方式二：
　　　　　　p = dict(name='cc',age=21)
　　　　方式三：
　　　　　　dic={}.fromkeys(['k1','k2'],[])    #{}.fromkeys(seq,100) 不指定100默认为None

4、字典的常见用法

#！/usr/bin/env python
#！-*- coding:utf-8 -*-
# write by congcong

'''
字典是一种 key - value 的数据类型
例如：
    info = {
          "Jack":[21,'学生','Hgzx','good'],
          "Alice":[20,'会计','Hgsf','great'],
          "Bob":[23,'老师','Hgsf','happy']
    }
    特性：
        key - value 结构
        key必须是可hash，且必须为不可变的数据类型，必须唯一
        value 可存放任意多个值、可修改、可以不唯一
        字典无序
        查找速度快
'''

info = {
          "Jack":[21,'学生','Hgzx','good'],
          "Alice":[20,'会计','Hgsf','great'],
          "Bob":[23,'老师','Hgsf','happy']
    }
#字典的查找
print(info['Jack']) #输出：[21, '学生', 'Hgzx', 'good']
#字典的修改
info['Jack'][0] = 22
print(info['Jack']) #输出：[22, '学生', 'Hgzx', 'good']
#字典的添加
info['Rose'] = [19,'学生','Hgsf','upset']
print(info)#输出：{'Jack': [22, '学生', 'Hgzx', 'good'], 'Alice': [20, '会计', 'Hgsf', 'great'], 'Bob': [23, '老师', 'Hgsf', 'happy'], 'Rose': [19, '学生', 'Hgsf', 'upset']}
#字典的删除
info_del1 = info.pop('Bob') # 默认删除末尾的元素，可删除指定的字符串，并返回所删除的信息，输出：[23, '老师', 'Hgsf', 'happy']
info_del2 = info.popitem()  #随机删除字符串，并返回所删除的字符串，输出：('Rose', [19, '学生', 'Hgsf', 'upset'])
del info['Jack'] #删除指定的字符串
print(info_del1,info_del2,info) #删除之后的字典：{ 'Alice': [20, '会计', 'Hgsf', 'great']}

#字典的复制
n1 = {'Alice': [20, '会计', 'Hgsf', 'great']}
print(type(n1)) # 输出数据类型，<class 'dict'>
n2 = n1.copy()
print(n2) #输出：{'Alice': [20, '会计', 'Hgsf', 'great']}
n1['Alice'][0] = 21 #仍然一改全改
print(n1,n2) #{'Alice': [21, '会计', 'Hgsf', 'great']}    {'Alice': [21, '会计', 'Hgsf', 'great']}

# 判断要查找的字符串是否在字典内
print('Alice' in info,'Frank'in info) # in方法，输出;True  False

# 获取指定的字符串内容
print(info.get('Alice')) # get方法，输出;[20, '会计', 'Hgsf', 'great']
print(info.get('Frank')) # 没有找到时，返回 None ,输出：None
print(info['Alice']) # 输出;[20, '会计', 'Hgsf', 'great'],没找到时会报错

#字典的清空
print(info.clear()) #输出：None

#仅输出字典的 keys 或 values
info = {'lufei':[666,'hope'],'qiqi':[999,'hard'],'keke':[333,'will']}
info_keys = info.keys() #只输出字典的keys
info_values = info.values() #只输出字典的values
print(info_keys,info_values) #输出：dict_keys(['lufei', 'qiqi', 'keke'])   dict_values([[666, 'hope'], [999, 'hard'], [333, 'will']])

#将字典转成列表
dit_items = info.items() # 将字典转成列表
print(dit_items) #输出：dict_items([('lufei', [666, 'hope']), ('qiqi', [999, 'hard']), ('keke', [333, 'will'])])

#创建新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。
names = ['cc','linux','python']
info2 = dict.fromkeys(names)#  fromkeys() 函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。
print(info2) # 输出;{'cc': None, 'linux': None, 'python': None}
info3 = dict.fromkeys(names,666)
print(info3) # 输出：{'cc': 666, 'linux': 666, 'python': 666}

#字典的更新
n1 = {'first':1,'second':2,'three':3}
n2 = {'four':4,'five':5}
n1.update(n2) #将字典 n2 更新到字典 n1中
print(n1) #输出;{'first': 1, 'second': 2, 'three': 3, 'four': 4, 'five': 5}

# setdefault() 方法和get()方法类似, 键存在时，返回值；如果键已经不存在于字典中，将会添加键并将值设为默认值。
print(n1.setdefault('four')) #输出：4，键'four'存在时返回值
n1.setdefault('six')
print(n1) #输出：{'first': 1, 'second': 2, 'three': 3, 'four': 4, 'five': 5, 'six': None}

#字典的循环
for k in n1:
    print(k,n1[k])

'''
输出：
    first 1
    second 2
    three 3
    four 4
    five 5
    six None

'''

四、Python基本数据类型--集合（set）

　　1、定义：由一个或多个确定的元素所构成的整体叫做集合。

　　　　例如：

　　　　　　#定义可变集合 set1=set('hello')  # {'l', 'o', 'e', 'h'}

　　　　　　#改为不可变集合frozenset  set2=frozenset(set1)  # frozenset({'o', 'h', 'l', 'e'})

　　2、集合中的元素有三个特征：

　　　　<1> 确定性（元素必须可hash）

　　　　<2> 互异性（去重）

　　　　<3> 无序性（集合中的元素没有先后之分），如集合{3,4,5}和{3,5,4}算作同一个集合。

　　　注意：集合存在的意义就在于去重和关系运算

　　3、集合的关系运算（见下方代码）　

#！/usr/bin/env python
#！-*- coding:utf-8 -*-
# write by congcong

#集合
'''
例如：s = {1,2,3,4,5,6}

集合中元素的三个特征：

    1、确定性（元素必须可hash）
    2、互异形（去重）
    3、无序性（集合中元素无先后之分），如{3,4,5}和{5，3，4}是同一个集合

'''
#字典，列表转集合
s1 = {1,2,3,4,2,1,6,6,12}
print(type(s1))
s2 = set(s1) #字典转集合，去重
print(s2,type(s2))# 输出：{1, 2, 3, 4, 6, 12} <class 'set'>
s1 = [1,2,3,4,2,1,6,6,12]
s2  = set(s1)
print(s2,type(s2))# 输出： {1, 2, 3, 4, 6, 12} <class 'set'>

#集合元素的添加
s2.add(5)
print(s2)# 输出：{1, 2, 3, 4, 5, 6, 12}，当所添加的元素已存在时，无法再添加

#集合的删除
s2.pop() # pop随机删除
print(s2) #输出：{2, 3, 4, 5, 6, 12}
s2.remove(12) #指定删除,若元素不存在，则报错
print(s2) # 输出：{2, 3, 4, 5, 6}
s2.discard(1) #指定删除,若元素不存在，则仍然返回集合，输出：{2, 3, 4, 5, 6}
print(s2)

#集合的更新
s3 = {1,2,3,4}
s4 = {5,6,7,8,9}
s3.update(s4) #合并集合
print(s3) # {1, 2, 3, 4, 5, 6, 7, 8, 9}
s3.update([0,10]) #添加元素
print(s3) # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

#集合的复制与清空
s4 = s3.copy() #浅复制
s3.clear() # 清空
print(s4,s3) # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10} set()

'''集合关系测试'''
n1 = {'hongmao','lantu',13,14}
n2 = {'hongmao','tiaotiao',15,16}

#交集
print(n1.intersection(n2)) # intersection方法求交集，输出：{'hongmao'}
print(n1&n2) # "&" 也可求交集，输出：{'hongmao'}

#差集
print(n1.difference(n2)) #difference方法求差集，n1中有而n2中没有的元素，输出：'lantu', 13, 14}
print(n1-n2) # "-"也可求差集，输出：{'lantu', 13, 14}
print(n2.difference(n1)) # n2中有而n1中没有的元素，输出：{16, 'tiaotiao', 15}
print(n2-n1) #  输出：{16, 'tiaotiao', 15}

#并集
print(n1.union(n2)) # union方法求并集，合并两个集合并去掉重复的元素后的集合，输出：{'hongmao', 13, 14, 15, 16, 'tiaotiao', 'lantu'}

#对称差集
print(n1.symmetric_difference(n2)) #两个差集的集合,输出：{'lantu', 13, 14, 15, 16, 'tiaotiao'}

'''判断包含关系'''
n3 = {1,2,3,4,5,'cc','syc'}
n4 = {1,3,5}

# in , not in  判断元素是否在集合内; == , != 判断两个集合是否相等
print('cc' in n3,'sc' not in n3) #输出：True  True
print(n3==n4,n3!=n4) #输出：False  True

# 两个集合间一般有三种关系，相交、包含、不相交，在python中用以下方法判断：
print(n3.issuperset(n4)) #判断n3是否包含n4，输出：True
print(n3>n4) #作用同issuperset,输出：True
print(n3.issubset(n4)) #判断n3是否小于n4，输出：False
print(n3<n4)  #作用同issubset,输出：False

print(n3.isdisjoint(n4)) #判断n3和n4是不是不相交，输出：False

n5 = {1,3,5,6}
n6 = {2,4,5,7}
n5.difference_update(n6) # n5-n6的差集赋给n5
print(n5) # 输出：{1, 3, 6}
n5.add(2)
n5.intersection_update(n6) # n5&n6的交集赋给n5
print(n5) #输出：{2}

　　

　　4、clear()方法可以清空集合

　　　　a={3,"a",2.1,1}

　　　　print(a.clear()) # None