python学习day7 数据类型及内置方法补充

http://www.cnblogs.com/linhaifeng/articles/7133357.html#_label4

1。列表类型

用途：记录多个值（一般存放同属性的值）

定义方法

在[]内用逗号分隔多个任意类型的值

l=list{'hello'}

l=list({'x':1,'y':2})

print(l)

常用操作+内置的方法

优先掌握的操作：

l=['a','b','c','e']

按索引存取值（正向存取+反向存取）：即可存也可以取

print(l(0))

print(l[-1])取最后一个元素

print(id(l))

l[0]='A'

print(id(l))

l[4]='EEEEE' 会修改值

l[5]='ddddd'索引不存在的值回报错

切片（顾头不顾尾，步长）
l=['a','b','c','d','e']

print(l[1:4])从索引开始输出，到索引4截止

print（l）

求长度 len

l=['a','b','c','d','e']

print(len(l))

成员运算符 in和not in

print('a' in l)

print('a' not in l)

追加和插入

l=['a','b','c','d','e']

l.append(4444)，在列表末尾加上添加的内容g

print(l)

l.insert(0,1111111)在索引0的位置添加上要添加的内容

print（l）

删除

l=['a','b','c','d','e']

del l[0] 删除索引值对应的元素,假如索引值超过列表长度也会报错

res=l.remove('b') 假如要删除的内容不在l中，会报错

print(l)

print（res）成功remove的话会返回None

res=l.pop(0)删除索引对应的值

print(l)

print（res）#pop会把删除的值取回

循环

l=['a','b','c','d','e']

for item in l:

　　print(item)

需要掌握的操作

l=['a','b','a','c','d','e']

print(l.count('a')) 计算字符出现的次数

l=['a','b','a','c','d','e']

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

for item in items:

　　l.append(item) 把另一个列表内添加进一个列表中

也可以用extend把另一个列表添加进列表中

l.extend(items) 本身返回值None

print(l)

l=['a','b','a','c','d','e']

print(l.index('a',2,5))从索引2开始到索引5找值‘a'，找到就返回’a'的索引

l.index(234234234) 索引没找到值会报错

if 234234234 in l:

　　print(l.index(234234234))

l=['a','b','a','c','d','e']

l.reverse()

print(l)反转列表l的内容

l=[10,-1,3,11,9]

l.sort()

print()从小打到排列l

l.sort(reverse=True)从大到小排列l

print(l.extend(['a','b','c']))返回值None

print(l.pop())返回删除的值

总结：

存多个值

可变类型（1.可变：值变，id不变。可变==不可hash 2.不可变：值变，id就变。不可变=可hash）

有序

练习题；

队列：先进先出

l=[]

入队

l.append('first')

l.append('secord')

l.append('third')

出队

l.pop(0)

l.pop(0)

l.pop(0)

堆栈：后进先出

l.append('first')

l.append('second')

l.append('third')

l.pop()

l.pop()

l.pop()

2.元组类型

用途：元组就是一个不可变的列表

定义方法：在（）内用逗号分隔开多个任意数据类型的元素

t=(1,2.2,'aa',('b','c'),['a','b','c'])

print(type(t))

l=['a']这是定义了一个列表，只有一个元素，就是‘a'

print(type(l),l[0])

t=('a',)，只有一个字符串的时候要用圆括号带逗号的形式定义，否则会定义成字符串类型

print(type(t))

print(t)

msg=('hello world')

类型转换

t1=tuple('hello world')

t2=tuple([1,2,3])能在for循环中循环的元素都可以放在tuple中，会循环取出后面的元素,组成一个元组

print(t1)

print(t2)

常用操作和内置的方法

优先掌握的操作：

t=(1,2.2,'aa',('b','c'),['a','b','c'])

1.按索引取值（正向取+反向取：只能取

print(t[0])

print(t[-1])

t[0]=111111 # 无法运行，报错，因为元组是不可变了类型

切片（顾头不顾尾，步长）

t=('a','b','c','e','f')

print(t[1:4])从索引1开始取值，到索引4截止

求长度

print（len(t)）

成员运算符in和not in

print（'a' in t）

循环

for item in t：

　　print（item）

需要掌握的操作

t=('a','b','c','e','a','f')

print(t.index('a',1,5))从索引1位置开始找’a'对应的索引，到5截止。没找到该值的话会报错

print(t.count('a'))计算‘a'出现几次

总结：

可以存多个值

有序

不可变类型（值变，id也改变）元组中索引于值的对应关系不能改变，如果元素中有列表，但是列表内 的元素可以修改,因为元组中索引与列表内存地址的对应关系没有改变

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

print(id(t))

t=('A','B','C')

print(id(t))

t=('a',111,['b','c'])

print(id(t[0],id(t[1]),id(t[2]))

t[2][0]='B'

print(t)

print(id(t[0]),id(t[1]),id(t[2]))

t[0]='A' #不能执行，会报错，因为会修改索引和内存地址的对应关系

t[2]=[1,2,3] #同理不能运行

l=['a','b','c']

l[0]='A' 列表类型就可以随意更改了

3.字典类型 dict

用途：记录多个值，列表用索引取值，而字典用key对应值，其中key对value有描述性的作用

4.定义方法：在{}用逗号分隔开多个元素，每个元素都是key：value的形式，其中key可以为不可变类型通常是字符串类型，而value可以是任意类型

d={1:'aaa',2.2:'bbb','xxx':'ccc',(1,2,3):'dddd'} # d=dict{}

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

类型转换

d=dict(x=1,y=2,z=3) 前面的变量名是key，后面的值是value

print(d)

items=[('name','egon'),('age',18),('gender','male')]

d={}

for item in items: #items是一个列表，这个循环会按，号分隔取出列表中的元素，赋值给item，取出的item是元组，索引可以继续按索引操作

　　d[item[0]]=item[1] #元组的第一个元素做key，第二个元素做value

d=dict(items)(相当于上面的循环，把列表中的key和value取出来，对列表中值的格式有要求)

print(d)

了解

keys=['names','age','gender','height','weight']

d={}

for key in keys:

　　d[key]=None 用循环先建立一个value为空的字典

d={}.fromkeys(key,None) 从key列表中去key，value先设为None

常用操作+内置方法

优先掌握的方法：

1.按key存取值：可存可取

dic={'name':'egon','age':18}

dic['name'] 取不到值时报错

print(dic.get'name')取不到值时返回None

print(dic['name'])

dic['name']='EGON'

dic['gender']='male'#对于字典中没有的key和值，会直接添加进字典

l=['a','b','c']

l[0]='A'

l[4]='AAA' 列表类型这样操作就会报错，找不到索引值

求长度

len

dic={'name':'egon','age':18}

print(dic)

print(len(dic)) 返回key的个数，也是value个数

成员运算符 in 和not in：是以字典的key为准的

dic={'name':'egon','age':18}

print('name' in dic) 判断是否是key

print('egon' in dic)

删除

dic={'name':'egon','age':18}

del dic['name'] #key如果不存在就报错，如果存在就把key和对饮的value一起删除

print（dic）

res=dic.pop('name') 同样是删除key和对应的value，但是会返回删除的value

res=dic.popitem() 随机删除字典的一个key和value，把删除的key和value转成一个元组

print（res）

键keys（），值values（），键值对items（）

python2中

# >>> dic={'name':'egon','age':18}
# >>>
# >>>
# >>> dic.keys()
# ['age', 'name']
# >>>
# >>>
# >>> dic.values()
# [18, 'egon']
# >>>
# >>>
# >>> dic.items()
# [('age', 18), ('name', 'egon')]

# 在python3
# >>> dic={'name':'egon','age':18}
# >>>
# >>> dic.keys()
# dict_keys(['name', 'age'])
# >>> dic.values()
# dict_values(['egon', 18])
# >>> dic.items()
# dict_items([('name', 'egon'), ('age', 18)])

循环
dic={'name':'egon','age':18}
for k in dic:
　　print(k) #输出key
for k in dic.keys():
　　print(k)#输出key

for v in dic.values():
　　print(v) #输出value
for k,v in dic.items():
　　print(k,v)

需要掌握的操作
dic={'name':'egon','age':18}
当key存在时，不改原值，返回原值
res=dic.setdefault('gender','male')
print(dic)
print(res)
当key不存在时，增加新值
res=dic.setdefault('gender','male')
print(dic)
print(res)

总结：
可变类型
存多个值
无序

4.集合类型set

pythons=['张铁蛋','李铜淡','王金蛋','赵银胆','alex','kevin']
# linuxs=['oldboy','张铁蛋','赵银胆','alex','wxx']
#
# res=[]
# for stu in pythons:
#     if stu in linuxs:
#         res.append(stu)
#
# print(res)

用途：1.关系运算 2.去重

定义方法：在{}内用逗号分隔开多个元素，但是元素的特点是
1.集合内元素必须是不可变类型
2.集合内元素无序
3.集合内元素不能重复
s={1,'aaa',2}#s=set(...)
print(s,type(s))
s={1,1,1,1,1,1,1,'a','a','a'}
print(s)#会去重

数据类型转换
res=set('hello')
print(res) #会把字符串中每个字符单独取出来，存成一个集合

res=set([1,'a','b'])
print(res)#会把列表中元素一次取出存成集合

常用操作+内置方法
优先掌握的操作

长度len
成员运算in和not in

pythons={'张铁蛋','李铜淡','王金蛋','赵银胆','alex','kevin'}
linuxs={'oldboy','张铁蛋','赵银胆','alex','wxx'}
#3、|合集:求所有报名的学生
# print(pythons | linuxs)
# print(pythons.union(linuxs))

#4、&交集:求同时报名两门课程的学生
# print(pythons & linuxs)

#5、-差集: 求只报名python课程的学员
# print(pythons - linuxs)
# print(linuxs - pythons) #求只报名linux课程的学员

#6、^对称差集:求没有同时报名两门课程的学生
# res=(pythons - linuxs) | (linuxs - pythons)
# res=pythons ^ linuxs
# print(res)

== 判断是否内容相同
s1={1,2,3}
s2={3,2,1}
print(s1==s2)

父子集描述的是一种包含和被包含的关系
父集：>=
子集: <=

# s1={1,2,3}
# s2={1,2,3,4}
# print(s2 >= s1)
# print(s1 <= s2)

需要掌握的
s1={1,2,3}
s1.update(3,4,5,6)
print(s1) 会把s1中没有的元素加进去

s1={1,'aa','bb',3}
print(s1.pop()) 随意扔一个值，返回被扔的值

res=s1.remove('bbbb')如果集合中没有这个值，会报错
print(s1)
print(res)如果删除成功的话返回None

s1.discard('bbb')没有这个值可以删除的话，返回None，不会报错
s1.add(4) 如果集合里没有该值，就添加进去，返回None
print(s1)

总结
存多个值
无序
可变

集合的去重
局限性
1.只能针对不可变类型
2.不能保证原来的顺序
names=['egon','egon','egon','alex','alex','kevin']

new_names=list(set(names))
print(new_names)
l=[
{'name':'egon','age':18,'sex':'male'},
{'name':'alex','age':73,'sex':'male'},
{'name':'kevin','age':20,'sex':'female'},
{'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)