数据类型及内置方法二

一.List

方法：count统计  ，clear清空 ，reverse反转

l1.sort(reverse=True) # reverse = True 降序， reverse = False 升序（默认）。

队列 ：先进先出

堆栈 ：先进后出

　　　　

二.tuple类型

用途：能够存储多个元素，元素与元素之间逗号隔开

定义：在( )内用逗号分隔开多个任意类型的值       #  t = tuple( )

　　t  = (“egon”， ） # 注意：当元组内只有一个元素时，必须加逗号，可以避免报错

 内置方法：count，index

优先掌握的操作：

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

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

               print(t[0],t[-1])    

2.切片（顾头不顾尾步长）

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


            print(t[0:2])
    

3.长度 

            print(len(t))        

4.成员运算in和not in

            t=('a','b','c',(1,2,3))


            print((1,2,3) in t)

5.循环

            t=('a','b','c',(1,2,3))

            for item in t:

                 print(item)

ps：tuple类型能存多个值，有序，是不可变类型

三.dict类型

用途：记录多个值，每一个值都对应的key用来描述value的作用

　　　其中value可以是任意类型，而key必须是不可变的类型，通常情况下应该str类型

定义：在{}内用逗号分隔开多个key:value。　　# 　dic=dict()

# 强调:字典的key是不能重复的 要唯一标识一条数据

# 如果重复了 只会按照最后一组重复的键值对存储

定义字典的四种方式

d1 = {'name': 'wanglei', 'age': 18}



d2 = dict({'name': 'wanglei', 'age': 18})

l = [
    ['name','jason'],
    ['age',18],
    ['hobby','read']
]
d3 = dict(l)
d4 = dict(name='jaosn',age='18')

print(d3)

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

          

            d2 = {'name':'jason','password':'123'}

            d2['name'] = 'kevin'    

2.长度len

统计的键值对的个数

d2 = {'name':'jason','password':'123'}
print(len(d2))

3.成员运算in和not in

对于字典来说只能判断key值

d3 = {'name':'jason','password':'123'}

print('name' in d3)

4.删除

d4 = {'username':'stevin','password':'124'}
del d4['username']
print(d4)

res = d4.pop("username")
res = d4.pop('username')  # 弹出仅仅是value
res = d4.pop('age')  # 当键不存在的时候直接报错

d4.clear()
print(d4)

5.键keys()，值values()，键值对items()

dic2 = {'username':'stevin','password':123}
print(dic2.keys())  # dict_keys(['username', 'password'])  迭代器
print(dic2.values())  # dict_values(['stevin', 123])  迭代器  现在就把它当做一个列表
print(dic2.items())  # dict_items([('username', 'stevin'), ('password', 123)])
# 列表套元组，元组的第一个元素是字典的key 第二个元素是字典的value

# get()根据key获取value
dic2 = {'username':'stevin','pwd':123}

res = dic2.get('age')  # key不存在 不报错 返回None
res1 = dic2.get('xxx','不在')
# get设置第二个参数。当key不在的情况下，设置好的参数信息
print(res1)
print(dic2.get('xxx','asdsad'))
# 第二个参数不写的话 当key不存在的情况下返回None，写了就返回设置好的参数信息




# dict.fromkeys()   快速的创建一个字典
l1 = ['username','password','age','hobby']
print(dict.fromkeys(l1,123))


# dict.popitem()
print(dic2.popitem())  # 尾部以元组的形式弹出键值对

# dict.setdefault()
dic2 = {'username':'stevin','pwd':123}
res1 = dic2.setdefault('username','xxoo')  # 当key存在时 不修改值 并且将原先key对应值返回给你
print(dic2,res1)
res2 = dic2.setdefault('age',18)  # 当key不存在时  新增一个键值对 并且将新增的键值对的值返回给你
print(dic2,res2)

# dict.update()
dic2 = {'username':'stevin','pwd':123}
d2 = {"age":18}
# dic2.update(d2)
dic2['age'] = 18
dic2.update(age=666)
print(dic2)

6.循环

dic2 = {'name':'stevin','password':123}
for i in dic2:
    print(i)

ps:dict类型可存多值，无序，是可变类型

四.set类型

　　

用途：关系运算,去重

定义：在{    }内用逗号分开个的多个值    # 　s = set（ ）

如果你仅仅只写了一个大括号 那么python默认将它当做字典类型

集合三大特性：

　　　　　　（1）.每一个值都必须是不可变类型
　　　　　　（2）.元素不能重复
　　　　　　（3）. 集合内元素无序

1.关系运算

pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}

print(pythons & linuxs ) #交集
print(pythons | linuxs )  #并集
print(pythons - linuxs )  #差集
print(pythons ^ linuxs )  #对称差集

关系运算还有

　　    ==   

　　父集：>,>=
　　issubset()

　　子集：<,<=
　　issuperset()

 集合去重局限性
（1）无法保证原数据类型的顺序
（2）当某一个数据中包含的多个值全部为不可变的类型时才能用集合去重

 2.需要掌握的操作

# 需要掌握操作
s1={1,2,3}
s1.update({3,4,5})
print(s1)

s1={1,2,3}
res=s1.pop()
print(res)

s1={1,2,3}
res=s1.remove(3) #单纯的删除,返回值为None
print(s1)

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

s1={1,2,3}
s2={1,2}
s1.difference_update(s2) #s1=s1.difference(s2)
print(s1)

s1={1,2,3}
res=s1.discard(3) ##单纯的删除,返回值为None
print(s1)
print(res)
s1.remove(444444) #删除的元素不存在则报错
s1.discard(444444) #删除的元素不存在不会报错


s1={1,2,3}
s2={1,2,4}
print(s1.isdisjoint(s2)) #如果两个集合没有交集则返回True

s1={1,2,3}
s2={4,5,6}
print(s1.isdisjoint(s2)) #如果两个集合没有交集则返回True

ps：set类型可以存多个值，无序，是可变类型

　　可变类型有  list dict set

　　不可变类型有   int float str tuple bool