数据的基本类型和内置方法（二）

列表

# l1 = ['sean', 'egon', 'tank', 'sean']

# count:统计当前列表内指定元素的个数

s1 = ["asd", "sde", "weq", 1223, 1223]
print(s1.count(1223))
>>2

# index : 获取当前指定元素的索引值，还可以指定指定查找范围

s1 = ["asd", "sde", "weq", 1223, 1223]
print(s1.index(1223, 1, 4))
>>3

# sort:排序，在原列表上进行排序操作

s2 = [2, 10, 5, 6, 8]
s2.sort()
>>>[2, 5, 6, 8, 10]

s1 = ["asd", "sde", "weq"]
s1.sort()
print(s1)
>>>['asd', 'sde', 'weq']

reverse 是用来把值反转
a1 = [1, 2, 'ads']
a1.reverse()
print(a1)
>>>>>>
['ads', 2, 1]

 sorted  python的内置函数，在排序时生成了一个新列表，原数据不变

s2 = [2, 10, 5, 6, 8]
l1 = sorted(s2)     #python 的内置函数
print(l1)

# clear()  清空列表数据

s2 = [2, 10, 5, 6, 8]
s2.clear()

print(s2)
>>[]

队列：先进先出

s1 = []
s1.append(1)#先安排进去
s1.append(2)
s1.append(3)
print(s1)

s1.pop(0)#先进的安排出来
print(s1)
s1.pop(0)
s1.pop(0)
print(s1)

对栈 ：先进的后出

s1 = []
s1.append(1)#先进的 依次
s1.append(2)
s1.append(3)
print(s1)

s1.pop()#后进的后出
print(s1)
s1.pop()
s1.pop()
print(s1)

元组

# ========================元组基本方法===========================
# 用途:存储多个不同类型的值（可以存可变类型和不可变类型）
# 定义方式:用过小括号存储数据，数据与数据之间通过逗号分隔,(值不能被改变)
    # 定义容器类型的时候，如果里面只有一个值，在值的后面加上一个逗号*****
    # 在元组中如果不加，就是字符串
    #元组是不可变的类型
    
    
    与列表的区别是：
    元组的元素不能修改，元组相当于不可变的列表，用于记录多个固定不修改的值，单独用于取

t1 = ("a", 'b', 'c', 'd') # t1 = tuple(('a', 'b', 'c', 'd'))
# print(type(t1))
print(t1[2])#索引取值
print(t1[1:3])#索引切片
print('a' in t1)#成员判断
print(len(t1))#长度

for i in t1:
    print(i)
 >>>   
a
b
c
d
count 数出一个值得个数 
a1 = (1, 2, 3, 3, 'sda')
print(a1.count(3))
>>>>>>
2
index  指定值得索引位置
a1 = (1, 2, 3, 3, 'sda')
print(a1.index(2))
>>>>>
1

# =========================类型总结==========================
# # 有序or无序  : 有索引，有序
# # 可变or不可变: 不可变
# # 存一个值or存多个值：存多个值

字典

# ========================字典(dict)基本方法===========================
# 用途:
# 定义方式:通过大括号来存储数据，通过key:value来定义键值对数据，每个键值对中间通过逗号分隔

# key:一定是一个不可变类型
# value：可以是任意类型
# d1 = {(1,2):[1,2]}

"""
字典的三种定义方式·：
"""
# 1、*****
# d1 = {'name':'egon','age':84}

# 2、*****

# d2 = dict({'name':'egon'})

# 3、zip : 了解即可

# l1 = ['name',"age"]
# l2 = ['egon',18]
# z1 = zip(l1,l2)
# print(dict(z1))

下面也是字典的定义方式之一

d2 = dict(name='sean',age=18)

1、优先掌握的
    1、按照key:value映射关系取值（可存可取）
    2、成员运算in，not in # 默认判断key
    3、len()  # 获取当前字典中键值对的个数

s1 = {"a": 'abs', 'b': 'wedding', 'd': 123}

print(s1['a'])
print(s1['d'])
s1['a'] = 'tank'
print(s1)
s1['f'] = 'morning'
print(s1)
>>>>>
abs
123
{'a': 'tank', 'b': 'wedding', 'd': 123}
{'a': 'tank', 'b': 'wedding', 'd': 123, 'f': 'morning'}



# 内置方法：
# get(******) : 获取指定key的值，如果值不存在·，默认返回None,可以通过第二个参数修改默认返回的内容
s1 = {"a": 'abs', 'b': 'wedding', 'd': 123}
print(s1['b'])
print(s1.get('b'))
print(s1.get('h'))
print(s1.get('h', 'konghong'))
>>>>>
wedding
wedding
None
konghong


# keys、values、items  ******
# print(d1.keys())  # 返回所有的key
# print(d1.values())  # 返回所有的值
# print(d1.items())  # 返回所有的键值对，返回值是列表套元组，每一个键值对都是存在元组

s1 = {"a": 'abs', 'b': 'wedding', 'd': 123}
print(s1.keys())
print(s1.values())
print(s1.items())
>>>>>>
dict_keys(['a', 'b', 'd'])
dict_values(['abs', 'wedding', 123])
dict_items([('a', 'abs'), ('b', 'wedding'), ('d', 123)])



for 循环
s1 = {"a": 'abs', 'b': 'wedding', 'd': 123}

for key in s1.keys():
    print(key)
for value in s1.values():
    print(value)
for item in s1.items():
    print(item)
    
   ＞＞＞＞＞
a
b
d
abs
wedding
123
('a', 'abs')
('b', 'wedding')
('d', 123)



# pop:弹出 ： 指定key进行弹出，有返回值，返回为对应的value
s1 = {"a": 'abs', 'b': 'wedding', 'd': 123}
a = s1.pop('b')
print(a)
print(s1)
＞＞＞＞
wedding
{'a': 'abs', 'd': 123}

# popitem() ,随机弹出一个键值对，有返回值，返回只是一个元组
s1 = {"a": 'abs', 'b': 'wedding', 'd': 123}
s1.popitem()
print(s1)
＞＞＞＞
{'a': 'abs', 'b': 'wedding'}

# update : 用新字典替换旧字典　有新的就添加上，有旧的就是去替换。
s1 = {"a": 'abs', 'b': 'wedding', 'd': 123}
s1.update({'d': "ending "})
print(s1)
＞＞＞＞
{'a': 'abs', 'b': 'wedding', 'd': 'ending '}



s1 = {"a": 'abs', 'b': 'wedding', 'd': 123}
s1.update({'a': "ending "})
print(s1)
＞＞＞＞＞
{'a': 'ending ', 'b': 'wedding', 'd': 123}

update可以更新一个字典
l1 = {}
l1.update({'dd':123})
print(l1)
>>>>>>>>>>>
{'dd': 123}

# fromkeys : 生产一个新字典， 第一个参数（列表），它会以第一个参数中各个元素为key，以第二个参数为值，组成一个新字典
print(dict.fromkeys([1, 2, 3], ['k', 'h']))
＞＞＞
{1: ['k', 'h'], 2: ['k', 'h'], 3: ['k', 'h']}

# setdefault :key不存在新增键值对，有返回值，返回新增value   如果key存在键值对，存在返回对应的value
s1 = {"a": 'abs', 'b': 'wedding', 'd': 123}
print(s1.setdefault('a'))
>>>>>>
abs

s1 = {"a": 'abs', 'b': 'wedding', 'd': 123}
print(s1.setdefault('j', 908))
＞＞＞
908

# =========================类型总结==========================
# 有序or无序  ： 无序
# 可变or不可变  ：可变类型
# 存一个值or存多个值 ： 存多个值

    

集合

# ========================集合基本方法===========================
# 用途: 去重、关系运算
# 定义方式: 通过大括号存储数据，每个元素通过逗号分隔
# 定义空集合，必须使用set()来定义
3个特性：
1.
# l1 = []
# s1 = ""
# d1 = {}
# ss1 = set()
# 常用方法:
合集：|
交集：&
差集：-
对称差集：^

1、集合中不可能出现两个相同的元素
a = {'asa', 'dfs', 'fds', 'aaa'}
b = {'dws', 'caz', 'aqw', 'aaa'}
c = {'dws', 'caz'}
print(a | b)
print(a & b)
print(a - b)
print(a ^ b)
>>>>
{'dws', 'aqw', 'fds', 'caz', 'asa', 'dfs', 'aaa'}
{'aaa'}
{'dfs', 'fds', 'asa'}
{'dws', 'aqw', 'fds', 'caz', 'asa', 'dfs'}

父集 子集
a = {'asa', 'dfs', 'fds', 'aaa'}
b = {'dws', 'caz', 'aqw', 'aaa'}
c = {'dws', 'caz'}
print(b >= c)
print(c <= b)
>>>>
True
True

去重
只针对于不可变类型，集合本身是无序的，去重之后，无法保留原来的顺序
s1 = [1, 2, 3, 4, 2, 5, 6, 5]
print(s1)
s2 = set(s1)
print(s2)
print(type(s2))
s3 = list(s2)
print(s3)
print(type(s3))

>>>>
[1, 2, 3, 4, 2, 5, 6, 5]
{1, 2, 3, 4, 5, 6}
<class 'set'>
[1, 2, 3, 4, 5, 6]
<class 'list'>


总结

存一个:整型、浮点型、字符串
存多个值：列表、元组、字典、集合


可变or不可变：
    可变：；列表，字典、集合
    不可变：整型、浮点型、字符串、元组、

有序or无序：
    有序：字符串、列表、元组
    无序：字典、集合

占用空间：
    字典
    列表
    元组
    集合
    字符串
    数字类型
"""