python的组合数据类型详解（集合、字符串、元组、列表、字典）

集合类型及操作

1、集合类型的定义

集合是多个元素的无序组合

-集合类型与数学中的集合概念一致，集合元素之间无序，每个元素唯一，不存在相同元素

-集合元素不可更改，不能是可变数据类型

-集合用大括号{}表示，元素之间用逗号隔开

-建立集合类型用{}或set()，建立空集合类型，必须使用set()

A={"python",123,("python",123)} #使用{}建立集合
print(A)

B=set("pypy123") #使用set()建立集合
print(B)

C={"python",123,"python"}
print(C)

2、集合操作符

操作符及应用	描述
S | T	返回一个新集合，包括在集合S和T中的所有元素
S - T	返回一个新集合，包括在集合S但不在T中的元素
S & T	返回一个新集合，包括同时在集合S和T中的元素
S ^ T	返回一个新集合，包括集合S和T中的非相同元素
S <=T 或 S < T	返回True/False，判断S和T的子集关系
S >=T 或 S > T	返回True/False，判断S和T的包含关系

                                                  4个增强操作符:

操作符及应用	描述
S | =T	更新集合S，包括在集合S和T中的所有元素
S - =T	更新集合S，包括在集合S但不在T中的元素
S &= T	更新集合S，包括同时在集合S和T中的元素
S ^= T	更新集合S，包括集合S和T中的非相同元素

（测试得）在python3.x中 | - & ^和下面代码中都能用，但在pycharm中，上面列表中的操作符不可用，要用以下写法

s1 = {'小马', '小乔', '小敏'}
s2 = {'小王', '小乔', '小敏'}

# 并集
print(s1.union(s2))

# 交集
print(s1.intersection(s2))
# 求交集，并用交集更新原集合
# s1.intersection_update(s2)
# print(s1)

# 差集
print(s1.difference(s2))
# s1.difference_update(s2)
# print(s1)

# 判断是否没有交集
print(s1.isdisjoint(s2))
# 判断是否是另一集合的子集
print(s1.issubset(s2))
# 判断是否是另一集合的超集/父集
print(s1.issuperset(s2))

运行结果：
{'小马', '小王', '小敏', '小乔'}
{'小敏', '小乔'}
{'小马'}
False
False
False

3、集合处理方法

操作函数或方法	描述
S.add(x)	如果x不在集合S中，将x增加到S
S.discard(x)	移除S中元素x，如果x不在S中，不报错
S.remove()	移除S中元素x，如果x不在S中，产生KeyError异常
S.clear()	移除S中所有元素
S.pop()	随机返回S的一个元素，更新S，若S为空产生KeyError异常
S.copy()	返回集合S的一个副本
len(S)	返回集合S的元素个数
x in S	判断S中元素x，x在集合S中，返回True,否则返回False
x not in S	判断S中元素x，x不在集合S中，返回True，否则返回True
set(x)	将其他类型变量x转变为集合类型

'''
for item in A
'''
A = {"123","python",5}
try:
    while True:
        print(A.pop(),sep=" ")
except:
    pass
print(A)

运行结果：
python
123
5
set()

print("p" in {"p","y",123})
print({"p","y"} >= {"p","y",123})
运行：
True
False

数据去重：

ls = ["p","p","y","y",123]
s =set(ls)                    #利用了集合无重复元素的特点
print(s)
print(list(s))                #将集合转换为列表

运行结果：
{123, 'y', 'p'}
[123, 'y', 'p']

练习：

s = {'炎生', '王鹏', '丙南', '昆鹏', '王鹏'}

# 添加元素
s.add('飞虎')

# 删除元素
s.remove('昆鹏')
# 若集合中不存在此元素则会报KeyError错
# s.remove('狗蛋')

# 存在则删除，不存在也不报错
s.discard('狗蛋')

# 随机弹出一个元素
print(s.pop())

# 清空元素
s.clear()

print(s)

序列类型（字符串、元组、列表）

1、序列类型的定义

-序列是具有先后关系的一组元素，序列是一维元素向量，元素类型可以不同

-元素间由序号引导，通过下标访问序列的特定元素

       

2、序列类型通用操作符

3、序列类型通用函数和方法

4、元组类型

（1）定义

-元组是序列类型的一种扩展，一旦创建就不能修改

-使用小括号()或tuple()创建，元素用逗号隔开，可以使用

或不使用小括号

def func():
    return 1,2   #返回的是一个元组

（2）元组类型的操作

-继承序列类型的全部通用操作

-元组因为创建后不能修改，因此没有特殊操作

-使用或不使用小括号

5、列表类型

（1）定义

-列表是一种序列类型，创建后可以随意被修改

-使用方括号[]或list()创建，元素间用逗号分隔

ls = ["cat","dog","tiger",1024]
lt = ls
print(lt)
'''方括号[]真正创建一个列表，赋值仅传递引用，ls和lt只是同一个列表的两个名称而已

（2）列表类型操作函数和方法

ls = [0,1,2,3,4,5,6,7,8,9]
print(ls[1:2])
del ls[1::3]
print(ls)

运行：
[1]
[0, 2, 3, 5, 6, 8, 9]

ls = ["cat","dog","tiger",1024]
ls.append(1234)
print(ls)
ls.insert(3,"human")
print(ls)
ls.reverse()
print(ls)

运行结果：
['cat', 'dog', 'tiger', 1024, 1234]
['cat', 'dog', 'tiger', 'human', 1024, 1234]
[1234, 1024, 'human', 'tiger', 'dog', 'cat']

列表功能默写：

   

lt1 = [1, 2, 3]
lt2 = [4, 5, 6]

print(lt1 + lt2)
print(lt1 * 2)
print(lt1[1:-1])
print(len(lt1))

lt = [1, 2, 3, 4, 5]

# 获取元素
print(lt[0])

# 修改元素
lt[0] = 100

# 追加：在列表的末尾添加，作为整体添加
lt.append(200)
lt.append([6, 7])
# 扩充：将序列中的元素一个一个添加到列表
lt.extend([300, 400])

# 插入：在指定的位置添加元素
lt.insert(2, 250)

# 删除：根据下标删除
del lt[0]
# 根据元素进行删除
lt.remove(250)
# 弹出并删除，会返回元素，
# 默认删除最后一个元素，可以指定下标
ele = lt.pop(4)
print(ele)

# 根据元素查第一次出现的下标
print(lt.index(4))

# 统计元素出现的次数
print(lt.count(2))

# 逆序
lt.reverse()

lt = [1, 5, 7, 3, 2]

# 排序：默认是升序，reverse=True会降序排序
lt.sort(reverse=True)

# 清空元素
lt.clear()

print(lt)

运行结果：
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 1, 2, 3]
[2]
3
1
200
2
1
[]

6、序列类型应用场景

（1）元素遍历

for item in ls:       for item in tp:
    <语句块>              <语句块>

（2）数据保护

-如果不希望数据被程序所改变，转换成元组类型

ls = ["cat","dog","tiger",1024]
lt = tuple(ls)
print(lt)

运行结果：
('cat', 'dog', 'tiger', 1024)

7、实例：基本统计值计算

def getNum():     #获取用户不定长度的输入
    nums = []
    iNumStr = input("请输入数字(回车退出)：")
    while iNumStr != "":
        nums.append(eval(iNumStr))
        iNumStr = input("请输入数字(回车退出):")
    return nums

def mean(numbers): #计算平均值
    s = 0.0
    for num in numbers:
        s = s + num
    return s / len(numbers)

def dev(numbers,mean): #计算方差
    sdev = 0.0
    for num in numbers:
        sdev += (num - mean)**2
    return pow(sdev / (len(numbers)-1),0.5)

def median(numbers):  #计算中位数
    sorted(numbers)
    size = len(numbers)
    if size % 2 == 0:
        med = (numbers[size//2-1]+ numbers[size//2])/2
    else:
        med = numbers[size//2]
    return med

n = getNum()
m = mean(n)
print("平均值:{},方差:{:.2},中位数:{}".format(m,dev(n,m),median(n)))

运行结果：
请输入数字(回车退出)：23
请输入数字(回车退出):34
请输入数字(回车退出):56
请输入数字(回车退出):23
请输入数字(回车退出):56
请输入数字(回车退出):35
请输入数字(回车退出):
平均值:37.833333333333336,方差:1.5e+01,中位数:39.5

字典类型及操作

1、字典类型定义

-理解映射：映射是一种键(索引)和值(数据)的对应

-序列类型由0...N整数作为数据的默认索引，映射类型则由用户为数据定义索引

-字典类型是“映射”的体现

键值对：键是数据索引的扩展

字典是键值对的集合，键值对之间无序

采用大括号{}和dict()创建，键值对用冒号：表示

2、字典类型的用法

在字典变量中，通过键获得值

<字典变量> ={<键1>:<值1>，...，<键n>:<值n>}

<值> = <字典变量>[<键>]      <字典变量>[<键>] = <值>

[ ]用来向字典变量中索引或增加元素

d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"}
print(d)
{'中国':'北京','美国':'华盛顿','法国':'巴黎'}
print(d["中国"])
de = {}
print(type(de))

运行结果：
{'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
北京

3、字典处理函数及方法

函数或方法	描述
del d[k]	删除字典d中键k对应的数据值
k in d	判断k是否在字典d中，如果在返回True,否则False
d.keys()	返回字典d中所有的键信息
d.values()	返回字典d中所有的值信息
d.items()	返回字典d中所有的键值对信息
d.get(k,)	键k存在，则返回相应值，不在则返回值
d.pop(k,)	键k存在，则删除相应值，不在则返回值
d.popitem()	随机从字典d中删除（弹出）一个键值对，以元组形式返回
d.clear()	删除所有的键值对
len(d)	返回字典d中元素的个数

d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"}
print("中国" in d)
print(d.keys())
print(d.values())
print(d.get("中国","伊斯坦堡"))
print(d.popitem())

运行结果：
True
dict_keys(['中国', '美国', '法国'])
dict_values(['北京', '华盛顿', '巴黎'])
北京
('法国', '巴黎')


d = {'name': 'dahua', 'age': 18}

# 获取成员：当键不存在时会报错
print(d['name'])
# 获取成员：键存在返回对应的值，不存在返回None，可以指定默认值
print(d.get('height', '默认值'))
# 键存在返回对应的值，不存在先设置然后返回
print(d.setdefault('height', 'xxx'))

# 存在则修改
d['name'] = '王大花'
# 不存在则添加
d['weight'] = 50
# 存在的就覆盖，不存在的就添加
# d.update(name='erhua', sex='女')
d.update({'name': 'erhua', 'sex': '女'})

# 删除
del d['name']
# 删除并返回其键对应的值
print(d.pop('age'))
# 随机弹出并返回一个键值对，一般是末尾的元素，字典为空会报错
print(d.popitem())

# 返回字典的所有键值对组成的元素集合，可以遍历、转换
print(list(d.items()))

# 清空字典
d.clear()

print(d)

运行结果：
dahua
默认值
xxx
18
('sex', '女')
[('height', 'xxx'), ('weight', 50)]
{}

功能默写：

4、应用场景：

（1）映射的表达  例：统计数据出现的次数，数据是键，次数是值

（2）元素遍历      

for k in d:
    <语句块>

简单练习：

从终端获取一个年份，判断是否是闰年，是就打印'xxx年是闰年'，不是就打印'xxx年不是闰年'

输入两个整数，打印较大值

输入三个整数，按照从小到大的顺序打印

输入一个三位数，顺序打印个位、十位、百位上的数

输入一个整数，判断是否既能被3整除，又能被7整除

输入一个字符，是大写转换为小写，是小写转换为大写，其它字符原样输出

#1
a = int(input("请输入一个年份："))
if a % 400 == 0:
    print("{}是闰年".format(a))
else:
    print("{}不是闰年".format(a))

#2、
a, b =map(int,input("请输入两个整数：").split())
if a > b:
    print(a)
else:
    print(b)

#3、
a, b, c = map(int,input("请输入三个整数：").split())
str = [a,b,c]
str.sort()
print(str)

#4、
a = int(input("请输入一个三位数："))
b = a % 10
c = (a // 10) % 10
d =  a // 100
print("个十百位上的数依次是：{},{},{}".format(b,c,d))

#5、
a = int(input("请输入一个整数："))
if a % 3 == 0 and a % 7 == 0:
    print("既能被3整除又能被7整除")
else:
    print("不能既能被3整除又能被7整除")

#6
a = input("请输入一个字符：")
if 65 <= ord(a) <= 90:
    print(chr(ord(a)+32))
elif 97 <=ord(a) <= 122:
    print(chr(ord(a) - 32))
else:
    print(a)