内置方法02

列表:

　　1、优先掌握的方法：

　　　　1、索引取值(正、反取)，可以取可以存

　　　　2、索引切片(正切，反切，步长)

　　　　3、成员运算in、not in

　　　　4、len()获取列表中元素的个数

　　　　5、for循环

　　内置方法:

　　　　增:

　　　　append():在列表尾部追加单个元素

　　　　insert():指定索引位置插入值

　　　　extend():将传入的可迭代对象值中依次取出，从尾部传入列表

　　　　删：

　　　　　　万能删:

　　　　　　del l1[0]

　　　　　　remove():指定元素删除

　　　　　　pop():默认弹出最后一位元素，还可以指定索引弹出，返回被弹出的元素

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

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

　　　　　　sort:排序，在原列表上进行排序操作 默认情况 (False)下进行升序，(reverse = True)进行降序

l2 = [2, 1, 4, 6, 8, 3, 5, 6]
l2.sort(reverse = True)
print(l2)
>>[8, 6, 6, 5, 4, 3, 2, 1]

l1 = ['sean', 'egon', 'tank', 'sean']
l1.sort()  #英文字母排序按照首字母的ASCII码进行排序
print(l1)
l3 = sorted(l2,)  # python的内置函数，在排序时生成了一个新列表，原数据不变
print(l3)
>>[1, 2, 3, 4, 5, 6, 6,8]

clear() 清空数据列表

　　l3.clear()
　　print(l3)
　　>>[]

# l1 = []
# 队列：先进先出

# l1.append(1)
# l1.append(2)
# l1.append(3)
# print(l1)
# l1.pop(0)
# print(l1)
# l1.pop(0)
# l1.pop(0)
# print(l1)


# 堆栈：先进后出

# l1.append(1)
# l1.append(2)
# l1.append(3)
# print(l1)
# l1.pop()
# print(l1)
# l1.pop()
# print(l1)
# l1.pop()
# print(l1)

元组：

　　用途:存储多个不同类型的值（不能存可变类型）

　　定义方式:用过小括号存储数据，数据与数据之间通过逗号分隔,(值不能被改变)

　　定义容器类型的时候，如果里面只有一个值，在值的后面加上一个逗号*

　　在元组中如果不加，就是字符串

t1 = ('a','b','c','a')  # t1 = tuple(('a','b'))
print(t1)
print(type(t1))

常用方法:

　　1、索引取值(正取，反取)

　　2、索引切片

　　3、成员运算in ,not in

　　4、len()

t1 = ('a','b','c','a') 
print(t1[0:2])
>>('a','b')
print(t1.count('a'))
>>2
print(t1.index('a',1))
>>3

　　　　元组有索引，有序，不可变，可多个值

字典：

　　用途：

　　　　定义方式:通过大括号来存储数据，通过key:value来定义键值对数据，诶个键值间通过逗号分隔

　　　　key:一定是一个不可变类型

　　　　value:可以使任意类型

字典的三种定义方式:
    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))
      >>{'name':'egon','age':18}

1、优先掌握的

　　　　1、按照key:value映射关系取值(可存可取)

　　　　2、成员运算in, not in #默认判断key

　　　　3、len() #获取当前字典中键值对的个数

d1 = {'name':'egon', 'age': 73}
        print(d1['name'])
        print(d1['age'])
        d1['name'] = 'tank'
        d1['gender'] = 'male'
        print(d1)
        print('egon' in d1)
        >>egon
        >>73
        >>{'name':'tank','age':'73','gender':'male'}
        >>False

内置方法:

　　get():获取指定key的值，如果值不存在，默认返回None，可以通过第二个参数修改默认返回的内容。

d1 = {'name':'egon', 'age': 73}
print(d1.get('gender'))
print(d1.get('gender','male'))
>>None
>>male


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

>>dict_keys(['name', 'age'])
>>dict_values(['egon', 73])
>>dict_items([('name', 'egon'), ('age', 73)])

for key in d1.keys():
    print(key)
for value in d1.values():
    print(value)
for key,value in d1.items():
    print(key,value)
key,value = ("name",'age')
>>name
  age
>>egon
  73
>>name egon
  age  73

pop:删除 指定key进行删除，有返回值，返回为对于的value

a = d1.pop('name')
print(d1)
print(a)
>>{'age':73}
  egon

popitem(),随机弹出一个键值对，有返回值，返回只是一个元组

d1 = {'name':'egon', 'age': 73,'gender':'male','a':"1"}
d1.popitem()
print(d1)
>>{'name': 'egon', 'age': 73, 'gender': 'male'}

update:用新字典替换旧字典

d1 = {'name':'egon', 'age': 73}
d1.update({"b":'2'})
print(d1)
d1.update({'name':'tank'})
print(d1)
>>{'name': 'egon', 'age': 73, 'b': '2'}
>>{'name': 'tank', 'age': 73, 'b': '2'}

fromkeys : 生产一个新字典， 第一个参数（列表），它会以第一个参数中各个元素为key，以第二 个参数为值，组成一个新字典

print(dict.fromkeys([1,2,3],['ke','k1']))
>>{1: ['ke', 'k1'], 2: ['ke', 'k1'], 3: ['ke', 'k1']}

setdefault :key不存在新增键值对，有返回值，返回新增value，key存在返回对应的value

d1 = {'name':'egon', 'age': 73,'gender':'male','a':"1"}
print(d1.setdefault('name',1))
print(d1)
>>egon
>>{'name': 'egon', 'age': 73, 'gender': 'male', 'a': '1'}

　　字典为无序，可变类型，存多个值

集合：

　　用途: 去重、关系运算

　　定义方式: 通过大括号存储数据，每个元素通过逗号分隔

　　定义空集合，必须使用set()来定义

　　　　l1 = []

　　　　s1 = ""

　　　　d1 = {}

　　　　ss1 = set()

常用方法：

　　　　合集：|

　　　　交集：&

　　　　差集：-

　　　　对称差集：^

 

>>> friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们 
>>> friends2 = {"Jy","ricky","jason","egon"}   # 用户2的好友们

# 1.合集(|)：求两个用户所有的好友（重复好友只留一个）
>>> friends1 | friends2
{'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}

# 2.交集(&)：求两个用户的共同好友
>>> friends1 & friends2
{'jason', 'egon'}

# 3.差集(-)：
>>> friends1 - friends2 # 求用户1独有的好友
{'kevin', 'zero'}
>>> friends2 - friends1 # 求用户2独有的好友
{'ricky', 'Jy'}

# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）
>>> friends1 ^ friends2
{'kevin', 'zero', 'ricky', 'Jy'}
# 5.值是否相等(==)
>>> friends1 == friends2
False

# 6.父集：一个集合是否包含另外一个集合
# 6.1 包含则返回True
>>> {1,2,3} > {1,2}
True
>>> {1,2,3} >= {1,2}
True
# 6.2 不存在包含关系，则返回True
>>> {1,2,3} > {1,3,4,5}
False
>>> {1,2,3} >= {1,3,4,5}
False


# 7.子集
>>> {1,2} < {1,2,3}
True
>>> {1,2} <= {1,2,3}
True

总结：

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


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

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

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