集合类型及操作:

多个元素的无序组合
-用大括号表示,逗号分隔
-建立集合类型使用{}或者set()

例如:

a = set("PYPY123")
print(a)
#由于集合中不能存在相同的元素而且元素无序所以输出结果为{'3', 'Y', '1', 'P', '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的子集关系

例如:

a = {"p","y",123}
b = set("pypy123")
print("a - b = {}\nb - a = {}\na & b = {}\na | b = {}\na ^ b = {}\n".format(a-b,b-a,a&b,a|b,a^b))
#输出结果为:
#a - b = {123}
#b - a = {'3', '1', '2'}
#a & b = {'y', 'p'}
#a | b = {'y', '3', 'p', '1', '2', 123}
#a ^ b = {'3', '1', '2', 123}

集合处理方法:

操作函数或方法 描述
s.add(x) 如果x不在集合s中,将x增加到集合s
s.discard(x) 将x从集合s移除,如果x不在集合s中不报错
s.remove(x) 将x从集合s移除,如果x不在集合x中,产生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,否则返回False

例如:

#简单操作
a = set("1234")
a.add("5")
print(a)
a.remove("1")
if 2 in a:
    print("2 is in a")
else:
    print("2 is not in a")
print(a)

数据去重:

集合类型可以用于各种数据去重,例如:给出一个列表ls,要求去掉列表中的重复元素,我们可以这样操作:

#先将列表类型转换为集合类型,再把集合类型转换为列表类型,这样就实现了简单的数据去重
ls = ['1','1','2','3','4','4']
s = set(ls)
ls = list(s)
print(ls)

序列类型及操作:

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

序列类型的操作方法:

函数和方法 描述
max(s) 返回序列s中的最大元素,s中元素需要可比较
min(s) 返回序列s中的最小元素,s中元素需要可比较
s.index(x) 返回序列s中x第一次出现的位置
s.index(x,i,j) 返回序列s从i开始到j位置中第一次出现元素x的位置
#定义ls1,ls2为两个列表,一个存放数字,一个存放字符
#max,min函数会根据字典序或者数字大小进行排序
ls1 = [1,2,3,4,1]
ls2 = ["a","b","c","d"]
print(max(ls1))
print(min(ls2))
#输出结果:4 a
#返回ls中元素1的第一次出现的位置
ls = [1,2,3,4,1]
print(ls.index(1))
#输出结果为:0

元组类型及操作:

元素是序列类型的一种扩展
-元组是一种序列类型,一旦创建就不能被修改
-使用小括号()或tuple()创建,元素间用逗号,分隔

#元组的定义
s = "1","2","3"
print(s)
ss = (123,"456",s)
print(ss)
#s是一个元组,ss也是一个元组,但他内部有一个s元组,所以要想使用ss调用s中的元素,可以这样
s = "1","2","3"
ss = (123,"456",s)
print(ss[2][1])
#输出结果为:2

列表类型及操作:

列表是序列类型的一种扩展
-列表是一种序列类型,创建后可以随意被修改
-使用[]或list()创建,元素间用逗号分隔

函数及方法 描述
ls[i] = x 将列表里第i的元素替换为x
ls[i:j:k] = lt 用列表lt替换ls切片后所对应元素子列表
del ls[i] 删除列表ls中的第i个元素
del ls[i:j:k] 删除列表从i到j,k为步长的元素
ls += lt 将lt中的元素增加到ls中,并更新ls
#简单操作
ls = ["cat","dog","tiger",1024]
ls[1:2] = [1,2,3,4] #将第1个元素换成[1,2,3,4]组成的列表
print(ls)
del ls[::3] #删除步长为3的元素
print(ls)
函数及方法 描述
ls.append(x) 在列表ls后增加一个元素x
ls.pop(i) 取出ls中第i个元素,并删除(类似C/C++中的弹栈)
ls.remove(x) 删除列表ls中第一次出现的x
ls.reverse() 反转列表ls
ls.insert(i,x) 在列表第i个位置插入元素x
ls.copy() 生成一个新的列表,并复制ls中的所有元素
ls.clear() 清除列表ls中的所有元素
#利用上面的函数进行操作:
ls = [1,2,3,4,5,6,7]
print(ls)
ls.append(3)    #在列表末尾增加一个元素3
print(ls)
ls.insert(3,5)  #在列表的第3个位置增加一个元素5
print(ls)
ls.pop(1)       #取出列表中的第1个元素并删除
print(ls)
ls.remove(3)    #删除列表中第一次出现的元素3
print(ls)
ls.reverse()   #列表反转
print(ls)
ls.clear()      #清空列表
print(ls)

列表与元组的区别:

列表内容可变,元组不可变,例如给出一个序列ls,一个元组s,对于序列ls,ls[0] = 1这种操作是正确的,但对与元组s,s[0] = 1是错误的,因而,列表中的元素可以改变,而元组中的元素不可变,所以列表是最常用的一种序列,元组类型主要用于数据保护。

字典类型及操作:

字典类型是“映射”的体现
-键值对:键是对数据索引的扩展
-字典是键值对的集合,键值对之间无序
-采用大括号{}和dict()创建,键值对用冒号:表示

函数或方法 描述
del d[k] 删除字典d中键k对应的数据值
k in d 判断键k是否在字典d中,在返回True否则返回False
d.keys() 返回字典d中所有的键的信息
d.values() 返回字典中所有值的信息
d.items() 返回字典d中所有的键值对信息
d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"}
if "中国" in d:
    print("Yes")
else:
    print("NO")
print(d.values()) #输出所有的值
print(d.keys()) #输出所有的键
函数或方法 描述
d.get(k,) 键k存在就返回对应值,否则返回
d.pop(k,) 键k存在就取出对应值,否则返回
d.popitem() 随机从字典d中取出一个键值对,以元组类型返回
d.clear() 删除所有的键值对
len(d) 返回字典d中键值对的个数
#新建字典d并向字典d中增加元素
d = dict()
for i in range(5):
    key,val = input("请输入键以及对应的值(空格隔开)").split()
    d[key] = val
print(d.keys())
print(d.values())

相关函数介绍:

enumerate 函数使用方式:

描述:

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中

遍历方式:

①遍历时返回一个元组,第一个元素为下标,第二个元素为下标对应的值

ls = [21,32,19,3,4]
lss = enumerate(ls)

for item in lss:
    print("下标{}对应的值为{}".format(item[0],item[1]))

②用两个不同的变量表示遍历返回的元组,一个为下标,一个为对应的值

ls = [21,32,19,3,4]
lss = enumerate(ls)
for i,item in lss:
    print("下标{}对应的值为{}".format(i,item))

zip函数使用方式:

描述:将多个迭代器对象中的元素压缩,返回一个zip对象

使用方式:

ls1 = ['1','2','3']
ls2 = ['4','5','6']
ls = zip(ls1,ls2)
for i in ls:
    print(i)

推导式

简介

推导式(comprehensions),又称解析式。利用列表推导式、字典推导式、集合推导式可以从一个数据对象构建另一个新的数据对象。利用生成器推导式可以构建生成器对象。

列表推导式

列表推导式和循环语句

假如想用一个列表中所有元素的平方以构成一个新列表,当然,可以使用append进行添加,但是为了让程序更加简单,可以利用列表推导式与循环的结合

ls = [i ** 2 for i in range(10)]
print(ls)

列表推导式和循环语句以及条件语句

除了上面说的列表推导式,进一步拓展,如果想要对序列中所有正整数进行平方运算,并形成一个新的列表,可以加入条件语句进行判断

ls0 = [-10,2,3,5,-1,-5]
ls = [i ** 2 for i in ls0 if i > 0]
print(ls)

在此基础上,如果想要将列表中的正整数平方,负整数保持不变,形成一个列表,可以使用三目运算符来完成

ls0 = [-10,2,3,5,-1,-5]
ls = [i ** 2 if i > 0 else i for i in ls0]
print(ls)

字典推导式

字典推导式和循环语句

将分别存有学生姓名与成绩的列表,整合到一个字典中,当然你可以,采用直接添加键值对的方式进行整合,这里介绍一种使用字典推导式的方法

id = ['A','B','C','D']
score = [100,90,85,95]
dic = {i:j for i,j in zip(id,score)}
for item in dic.items():
    print("{} {}".format(item[0],item[1]))

字典推导式和循环语句及条件语句

使用方式与列表推导式一致,这里不多赘述

Tip:集合推导式博主不再介绍,个人感觉用处不大