学习python课程第六天

一.元祖类型  (tuple)

1.什么是元祖?

用途:用于存放多个值,当存放的多个值只有读的需求没有改变的需求时,用元祖最合适.

定义方式:在()内用逗号分隔开的多个任意类型的值

t=(1,3,1,'aaa',(1,2,3),['a','b'])   #= tuple

res=tuple('hello')

res=tuple({'x':1,'y':2})

print(res)

2.常用的操作内置方法.

优先掌握的操作:

1.按索引的方式取值,(正向取,反向取都可以,但是只能去不能存.)

t=('a','b',1)

t[0]=111

2.切片(顾头不顾尾,步长)

t=('h','e','l','l','o')

res=t[1:3]

print(res)

print(t)

3.长度

t=('h','e','l','l','o')

print(len(t))

4.成员运算 in 和 not in

t=('h','e','l','l','o')

print('h' in t)

5.循环

t=('h','e','l','l','o')

for item in t:

　　print(item)

该类型总结.

可以存多个值,是有序的, 是不可变类型.(但是元祖里面有列表的情况下,可以改变列表.)

t=(1,'a',['x','y','z'])

print(id(t[2]))

print(id(t))

t[2][0]='X'

print(t)

print(id(t))

print(id(t[2]))

需要掌握的方法

t=('a','b','a')

print(t.index('a'))

t.index('xxx')

print(t.count('a'))

可以运算一下有几个a

元祖符号

name=input('>>:').strip()

print(('my name is %s'%name).center(50,'*'))

center 代表可以在一行代码里补充入多少个字符,数字是整个长度有多少

二.字典类型  (dict)

用途:用来存多个(不同种类的值)

1.定义方式:在{}内用逗号分隔开多个Key:value的元素,其中value可以是任意的数据类型,而Key的功能通常是用来描述value的,

所以Key通常是字符串类型,但其实Key必须是不可变的类型(intfloatstr uple)

d={0:'x',1.3:'y','K1':'z',(1,2,3):'aaa'}  #d=dict(...)

print(d[(1,2,3)])

d1

{[1,2,3]:'aaaa'}

d=dict([('K1',1),('K2',2),('K3',3)])

print(d)

l=[('k1',1),('k2',2),('k3',3)]
d={}
for t in l:   #t=('k1',1)
    k,v=t
    print(k,v)
    d[k]=v
print(d)

d=dict(l)
print(d)

d=dict(x=1,y=2,z=3)
print(d)

2.常用的操作+内置的方法

优先掌握的操作:

1.按Key存取值,可存可取

d={'x':1}
print(d['x'])
print(id(d))
d['x']=1111
print(d)
print(id(d))
d['y']=2222
print(d)


3.长度
d={'x':1,'y':2,'z':3}
print(len(d))          (可以查看字典的长度)


4.成员运算in和not in

d={'x':1,'y':2,'z':3}
print(1 in d)  True
print('x ' in d)  True


5.删除

d={'x':1,'y':2,'z':3}
del d['y']
print(d)    (del直接删除)

d={'x':1,'y':2,'z':3}

res=d.pop('y')

print(d)

print(res)   (pop可以在后面按索引删除)


6.键Keys(),值value(),键值一起是items()

d={'name':'egon','age':18,'sex':'male','hobbies':[1,2,3]}
print(d.keys())
print(list(d.keys()))

print(d.values())
print(list(d.values()))
print(d.items())
print(list(d.items()))

7.循环的使用

d={'name':'egon','age':18,'sex':'male','hobbies':[1,2,3]}

for k in d.keys():
    print(k)
for k in d:
    print(k)

for v in d.values():
    print(v)

for k,v in d.items():   #k,v=('name', 'egon')
    print(k,v)

该类型的总结:
存在多个值, 是无序的 可变的.

需要掌握的操作.
get的方法

d={'name':'egon','age':18,'sex':'male','hobbies':[1,2,3]}
v=d.get('namexxxxxxx')
print(v)
输出结果为: none 
 
get可以随意的取值,还不会报错.


update的方法

d={'name':'egon','age':18,'sex':'male','hobbies':[1,2,3]}
d.update({'x':1,'name':"EGON"})
print(d)

update更新的意思,如果没有想要更新的item就可以直接加进去,如果有了.就更新.



fromkeys:需求是快速的新造出一个字典,value的初始值为None.而Key是来自于一个列表

keys=['name','age','sex']

d={}.fromkeys(keys,None)
print(d)


setdefault  在Key存在的情况下不会修改值,会返回原值  在Key不存在的情况下会新增值,会返回新增的值.

d={"x":1,"y":2}
res=d.setdefault('x',11111)
print(d)
print(res)

d={"x":1,"y":2}

res=d.setdefault('z',11111)
print(d)
print(res)



三.集合类型  (set)

1.什么是集合
在{}内用逗号分隔开多个值,集合的特点:
1.每个值必须是不可变类型.
2.集合是无序的.
3.集合内元素不能重复

2.为何要用集合:
1.用作关系运算.
2.去重

3.如何去用集合

集合的第一大用途,关系运算!

pythons={'egon','张铁蛋','李铜蛋','赵银弹','王金蛋','艾里克斯'}
linuxs={'欧德博爱','李铜蛋','艾里克斯','lsb','ysb','wsb'}

1 求同时报名两门课程的学生姓名:交集
print(pythons & linuxs)    (简单的逻辑运算符号)
print(pythons.intersection(linuxs))    (属于内置的方法不建议用)

2.求报名老男孩学校课程的所有学生姓名:并集
print(pythons | linuxs)        (同上)
print(pythons.union(linuxs))

3 求只报名python课程的学生姓名: 差集
print(pythons - linuxs)         (把一起上了两门课程的同学排除)
print(pythons.difference(linuxs))

4 求没有同时报名两门课程的学生姓名: 对称差集
print((pythons - linuxs) | (linuxs - pythons))
print(pythons ^ linuxs)                    (明显第二个字符更简单)
print(pythons.symmetric_difference(linuxs))

5 父子集:指的是一种包含与被包含的关系
s1={1,2,3}
s2={1,2}
print(s1 >= s2)
print(s1.issuperset(s2))
print(s2.issubset(s1))

情况一:
print(s1 > s2)     #>号代表s1是包含s2的,称之为s1为s2的父集
print(s2 < s1)

情况二:
s1={1,2,3}
s2={1,2,3}
print(s1 == s2)    #s1如果等于s2,也可以称为s1是s2的父集

综上:
s1 >= s2 就可以称为s1是s2的父集 两个值相同的集合,可以互为父集,也互为子集.看自己定义

s3={1,2,3}
s4={3,2,1}
print(s3 == s4)  (一样的结果,互为父集.互为子集)

2.集合的第二大用途:去重 
集合去重的局限性:
1.会打乱原值的顺序
2.只能针对不可变的值去重

stus=['egon','lxx','lxx','alex','alex','yxx']
new_l=list(set(stus))
print(new_l)

old_l=[1,[1,2],[1,2]]
set(old_l)
(不可hash的类型不可以被去重)

l=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]
new_l=[]
for dic in l:
    if dic not in new_l:
        new_l.append(dic)
print(new_l)



需要掌握的操作:

s1={1,2,3}
s1.update({3,4,5})
print(s1)
print(s1.pop())
print(s1)

pop在集合里不能索引删除,

s1.remove(2)
print(s1)

remove可以在集合里随便删除,后面加上想删除的字符.


s1={1,2,3}

print(id(s1))
s1.add(4)
print(s1)
print(id(s1))

add可以随便的添加字符,但是有了同样字符的话就不添加,没有影响.

s1={1,2,3}
s1.discard(4)

print(s1)

discard可以随意的删除字符,没有这个字符也没影响.

s1={1,2,3}
s2={4,5}
print(s1.isdisjoint(s2))

isdisjoinnt:判断两个两个集合是否完全不相交.

总结:
集合存在多个值,是无序的.属于可变类型.