python-2022-09-20（第六周）

#================================第六周，集合

• #集合是多个元素的无序组合
• #集合元素之间无序，每个元素唯一，不存在相同元素
• #集合元素不可更改，不能是可变的数据类型

'''
==========集合间的操作
并运算  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的包含关系

增强操作符

S |= T   更新集合S，包括在集合S和T中的所有元素
S -= T   更新集合S，包括在集合S但不在T中的元素
S &= T   更新集合S，包括同时在集合S和T中的元素
S ^= T   更新集合S，包括集合S和T中的非相同元素

'''

A = {'p','y',123}
B = set('pypy123')
 
print (A-B)    #{123}
print (A&B)    #{'p','y'}
print (B-A)    #{'1','3','2'}
print (A|B)    #{'y','p','1',123,'3','2'}

'''
集合处理方法
S.add(x)     如果x不在集合S中，将x增加到S
S.discard(x) 移除S中元素x，如果x不在集合S中，不报错
S.remove(x)  移除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,否则返回False
set(x)       将其他类型变量x转换为集合类型
'''

try:
    while True:
        print (A.pop(),end='')
except:
    pass

print (A)

#=========================序列==================================

• #序列--具有先后关系的一组元素
• #序列是一位元素向量，元素类型可以不同
• #类似数学元素序列
• #元素间由序号引导，通过下标访问序列的特定元素
• #序列是一个基类类型
• #序列顺序和字符串类似，字符串是存的是字符，序列存的是元素

'''
序列的处理
x in s            如果x是序列s的元素，返回True,否则返回False
x not in s        如果x是序列s的元素，返回False,否则返回True
s + t             链接两个序列s和t
s*n 或 n*s        将序列s复制n次
s[i]              索引，返回s中的第i个元素，i是序列的序号
s[i:j]或s[i:j:k]  切片，返回序列s中第i到j以k为步长的元素子序列
'''

ls = ['python',123,'.io']
print(ls[::1])

'''

len(s)           返回序列s的长度

min(s)           返回序列s的最小元素，s中元素需要可比较（不可比较会报错）

max(s)           返回序列s的最大元素，s中元素需要可比较（不可比较会报错）

s.index(x) 或 s.index(x,i,j)   返回序列s从i开始到j位置中第一次出现元素x的位置

s.count(x)      返回序列s中出现x的总次数

'''

ls = ['python',123,'.io']
print(len(ls))

#======================元组类型====================

#元组是一种序列类型，一旦创建就不能被修改

#使用小括号（）或tuple()创建，元素间用逗号 ， 分隔

#可以使用或不适用小括号

'''
def func():
    return 1,2
'''
creature = 'cat','dog','tiger','human'
print (creature)

color = (0x001100,'blue',creature)
print (color)

#元组继承了序列类型的全部通用操作

#=====================列表类型================

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

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

#列表各元素类型可以不同，无长度限制

‘’‘

ls[i] = x             替换列表ls第i元素为x

ls[i:j:k] = lt         用列表lt替换ls切片后所对应元素子列表

del ls[i]             删除列表ls中第i元素

del ls[i:j:k]         删除列表ls中第i到第j以k为步长的元素

ls += lt              更新列表ls,将列表lt元素增加到列表ls中

ls *= n              更新列表ls，其元素重复n次

’‘’

ls = ['cat','dog','tiger',1024]
ls[1:2]=[1,2,3,4]
print (ls)

del ls[::3]
print (ls)

print (ls * 2)

‘’‘

ls.append(x)        在列表ls最后增加一各元素x

ls.clear()              删除列表ls中所有元素

ls.copy()               生成一个新列表，复制ls中所有元素

ls.insert(i,x)          在列表ls的第i位置增加元素x

ls.pop(i)               将列表ls中第i位置元素取出并删除该元素

ls.reverse()          将列表ls中出现的第一个元素x删除

’‘’

#练习
#定义空列表lin
lt = list()
print ('定义空列表lt：{}'.format(lt))
#向lt新增5个元素
lt +=[1,2,3,4,5]
print ('向lt新增5个元素：{}'.format(lt))
#修改lt中第二个元素
lt[2]= 7
print ('修改lt中第二个元素：{}'.format(lt))
#向lt中第2个位置增加一个元素
lt.insert(2,8)
print ('向lt中第2个位置增加一个元素：{}'.format(lt))
#从lt中第一个位置删除一个元素
del lt[1] #lt.pop(1)
print ('从lt中第一个位置删除一个元素：{}'.format(lt))
#删除lt中第1-3位置元素
del lt[1:4]
print ('删除lt中第1-3位置元素：{}'.format(lt))
#判断lt中是否包含数字0
print('判断lt中是否包含数字0:{}'.format(0 in lt))
#向lt新增数字0
lt.append(0)
print ('向lt新增数字0:{}'.format(lt))
#返回数字0所在lt中的索引
print ('返回数字0所在lt中的索引:{}'.format(lt.index(0)))
#lt的长度
print('lt的长度:{}'.format(len(lt)))
#lt的最大元素
print('lt的最大元素：{}'.format(max(lt)))
#清空lt
lt.clear()
print('清空lt：{}'.format(lt))

序列应用场景---元组和列表是序列的扩展

元组用于元素不改变的应用场景

列表更加灵活，常用的序列类型

最主要：表示一组有序数据，进而操作他们

 学习犹如打磨一把宝剑，越磨越快