python的元组程序 快速入门

#元组快速入门
#元祖 Tuple
#元祖是一个不可变序列：（）
#一般情况下我们不希望这个数据改变的时候就用元祖（），其它情况用列表[]。

my_tuple=(1,2,3,4,5)
print(my_tuple,type(my_tuple))
print(my_tuple[4])
#如果元祖不是空的，元祖至少有一个逗号。
my_tuple=10,
print(my_tuple,type(my_tuple))

#元祖的解包，将元祖当中的每一个元素赋值給一个变量
my_tuple=10,20,30,40
a,b,c,d=my_tuple
print(‘a=’,a)
print(‘b=’,b)
#print(‘c=’,c)
#print(‘d=’,d)

my_tuple=10,20,30,40
a,b,*c=my_tuple
print(‘a=’,a)
print(‘b=’,b)
print(‘c=’,c)
#print(‘d=’,d)

a,b,*c=“how are you”
print(‘a=’,a)
print(‘b=’,b)
print(‘c=’,c)

#字典快速入门
#字典是一种数据结构　映射（mapping)
#字典的作用其实和列表类型，用来存储对象的容器
#列表存储数据的性能非常好，但是查询数据的性能很差；字典正好与列表相反。
#在字典当中每一个元素都有一个唯一的一个名字，通过这个名字可以快速查询指定的元素。
#这个唯一的名字我们一般称之为 键（key),通过key 我们可以查询value值
#所以字典我们称之为键值对（key-value)
#每个字典当中可以有多个键值对，每一个键值对我们可以称之为一项（item）
#语法：{key:vale,key：value …}
#需要根据键来获取值
d1={‘name’:‘limeng’,‘age’:33,‘sex’:‘man’}
print(d1[‘name’],d1[‘sex’],d1[‘age’])

#字典的使用
#使用dict()函数来创建字典
#d=dict(name=‘limeng’,age=33,sex=‘man’)
#dict()也可以将一个包含双值子序列转换为字典
#双值序列 序列中有2个值1,2’ab’
#子序列 如果序列中的元素，那么我们就称这个元素为子序列[1,2,3]
d2=dict([(‘name’,‘limeng’),(‘age’,33)])
print(d2,type(d2))

#len() 获取字典中键值对的个数
#in 检查字典汇总是否包含指定的键

not in 检查字典中是否不包含指定的键

#get(key,[default])该方法是用来根据键来获取字典当中的值
#也可以指定一个默认值，来作为第二个参数，这样获取不到key 值时候就退回默认值

print(len(d1))

d2=dict([(‘name’,‘limeng’),(‘age’,33)])
d2[‘name’]=‘zhangliwen’ #修改字典的name
d2[‘sex’]=‘girl’ #字典里添加
print(d2)

#setdefault(key,[defalut]) 向字典中添加 key-value
#如果这个key 已经存在于字典当中，则返回key值，不会对字典有任何的影响
#如果key 不存在， 则向字典中添加这个key，并设置value
#d=d2.setdefault(‘name’,‘limeng’)
d=dict([(‘name’,‘limeng’),(‘age’,33)])
d1=d.setdefault(‘name1’,‘zlw’)
print(d1)
print(d)

#update() 将其它字典当中的key-value 添加到当前字典当中
a1={‘a’:1,‘b’:2,‘c’:3}
a2={‘d’:4,‘e’:5,‘f’:6}
a2.update(a1) #a1 字典中的键值 输入到a2 字典中去
print(a2)
print(a1)

#del 删除
#del 删除字典中的key-value
a1={‘a’:1,‘b’:2,‘c’:3}
del a1[‘a’]
print(a1)

#popitem() 随机删除一个键值对，一般都会删除最后一个
#它会将删除之后的键值对返回
a1={‘a’:1,‘b’:2,‘c’:3}
result=a1.popitem()
print(result)
print(a1)

#pop() 根据key来删除key-value
a1={‘a’:1,‘b’:2,‘c’:3}
#result=a1.pop(‘a’)
result=a1.pop(‘d’,‘k值不存在’)
print(result)
print(a1)

#clear()清空字典
a1={‘a’:1,‘b’:2,‘c’:3}
#result=a1.pop(‘a’)
result=a1.clear()
#print(result)
print(a1)

#潜复制
#copy() 复制函数，用于对字典进行一个潜复制
#潜复制只会复制字典的本身，如果字典中还有个字典不会被复制的，
#复制以后的对象，和原对象是对立的，修改一个不会影响另一个。
a1={‘a’:{‘city’:‘huanggang’},‘b’:2,‘c’:3}
#result=a1.pop(‘a’)
a=a1.copy()
print(‘a =’,a1,id(a1))
#print(a,id(a))
a1[‘a’][‘city’]=‘qichun’
print(‘a =’,a1,id(a1))

#遍历字典
#d.keys() 该方法返回的是一个徐丽，保存的是字典当中所有的键
#d.values(）该方法返回的是一个序列，保存的是字典中的值
#d.items() 该方法会返回字典中的所有的项，它返回的也是一个序列，这个序列当中包含双值序列
#items()
#hero = ((‘name a=’,‘钢铁侠’),(‘name b=’,‘绿巨人’),(‘name c=’,‘蜘蛛侠’),(‘name d=’,‘黑寡妇’)) #SyntaxError: invalid syntax
#for k in hero.keys():
#print(hero[k])
#hero = [‘namea’:‘钢铁侠’,‘nameb’:‘绿巨人’,‘namec’:‘蜘蛛侠’,‘named’:‘黑寡妇’] #SyntaxError: invalid syntax
#for k in hero.keys():
#print(hero[k])
hero = {‘name a’:‘钢铁侠’,‘name b’:‘绿巨人’,‘name c’:‘蜘蛛侠’,‘name d’:‘黑寡妇’}
for k in hero.keys():
print(hero[k])
for v in hero.values():
print(v)
for k,v in hero.items():
print(k,’=’,v)
print(k)

#set 集合
#集合和列表非常相似
#不同点1：集合只能存储不可变对象；2.集合中存储的对象是无序的；#3.集合中不能出现重复的元素
lst = (‘a：1’, ‘b:2’, ‘c:3’ , ‘d:4’, ‘e:5’, ‘f:6’) #元祖
print(lst ,type(lst))
hero = [‘钢铁侠’,‘绿巨人’,‘蜘蛛侠’,‘黑寡妇’,‘超人’] #列表
print(hero,type(hero))
hero = {‘钢铁侠’,‘绿巨人’,‘蜘蛛侠’,‘黑寡妇’,‘超人’} #集合

print(hero,type(hero))
#hero =set((‘name=钢铁侠’,‘name =绿巨人’,‘name=蜘蛛侠’,‘name=黑寡妇’,‘name=超人’),(‘city=huanggang’))#TypeError: set expected at most 1 arguments, got 2
hero =set(((‘name=钢铁侠’,‘name =绿巨人’,‘name=蜘蛛侠’,‘name=黑寡妇’,‘name=超人’),(‘city=huanggang’))) #集合
print(hero,type(hero))

hero =set([1,2,3,4,5,6,6,5,4,2,1,4,8,9,1]) #集合
print(hero,type(hero))

d={‘name’:‘123’,‘data’:{‘result’:[{‘src’:‘python1’},{‘src’:‘python’},{‘src’:‘python’}]}}
#控制台打印 python1,python2,python3
print(d)

i1=[11,22,33]
i2=[22,33,44]
for i3 in i1:
for i4 in i2:
if i3 == i4:
print(i3)