基本数据类型及内置方法2

一、列表

　　1、基本方法

　　　　用途：

　　　　　　用于存一个或者多个不同类型的值

　　　　定义方法：

　　　　　　通过中括号存值，每个值之间通过逗号进行分隔

　　　　　　s1 = ['a','b',1,'cd']

　　　　内置方法:

　　　　　　①索引取值

# 索引取值
>>> l1 = [1,2,3,4,5]
>>> l1[2]
3
# 索引切片
>>> l1[1:4]
[2, 3, 4]

　　　　　　②append()：追加，只能添加到列表的最后一位,一次性只能添加一个值

>>> l1 = [1,2,3,4,5]
>>> l1.append(1000)
>>> l1
[1, 2, 3, 4, 5, 1000]
>>> l1.append([9,0])
>>> l1
[1, 2, 3, 4, 5, 1000, [9, 0]]

　　　　　　③insert()：插入值，通过索引指定插入的位置

>>> l1 = [1,2,3,4,5]
>>> l1.insert(3,99)
>>> l1
[1, 2, 3, 99, 4, 5]

　　　　　　④extend()：追加多个值

>>> l1 = [1,2,3,4,5]
>>> l1.extend([6,7,8])
>>> l1
[1, 2, 3, 4, 5, 6, 7, 8]

　　　　　　⑤remove()：指定删除，若后面有相同的，则从左到右删除第一个

>>> l1 = [1,2,3,1,4,5]
>>> l1.remove(1)
>>> l1
[2, 3, 1, 4, 5]

　　　　　　⑥pop()：默认从最后开始删除，指定索引删除，pop是有返回值，返回删除的元素

>>> l1 = [1,2,3,1,4,5]
>>> l1.pop()
5
>>> l1
[1, 2, 3, 1, 4]
>>> l1.pop(1)
2
>>> l1
[1, 3, 1, 4]

　　　　　　⑦del：清除

>>> l1 = [1,2,3,1,4,5]
>>> del l1[2]
>>> l1
[1, 2, 1, 4, 5]

　　　　　　⑧count()：统计列表中指定元素个数

>>> l1 = [1,2,3,1,4,5]
>>> l1.count(1)
2

　　　　　　⑨index()：获取指定元素的索引值，还可以在指定范围内查找

>>> l1 = [1,2,3,1,4,5]
>>> l1.index(3)
2
>>> l1.index(1,1,5)  # 在[2,3,1,4,5]中查1所在索引
3

　　　　　　⑩sort()：排序，在原列表上进行排序（默认从小到大 ，当输入参数reverse = True，从大到小排序），原列表被修改

>>> l1 = [4,5,1,7,4,8,3,9]
>>> l1.sort()
>>> l1
[1, 3, 4, 4, 5, 7, 8, 9]
>>> l1.sort(reverse = True)
>>> l1
[9, 8, 7, 5, 4, 4, 3, 1]

# sorted()：排序时候生成新列表，原列表不变
>>> l1 = [4,5,1,7,8,3,9]
>>> sorted(l1)
[1, 3, 4, 5, 7, 8, 9]
>>> l1
[4, 5, 1, 7, 8, 3, 9]

　　　　　　⑾clear()：清空数据

>>> l1 = [4,5,1,7,8,3,9]
>>> l1.clear()
>>> l1
[]

　　　　　　队列：先进先出

l1 = []
l1.append(1)
l1.append(2)
l1.append(3)
l1.append(4)
print(l1)
for i in range(len(l1)):
    print(l1.pop(0))
    print(l1)

　　　　　　堆栈：先进后出

l1 = []
l1.append(1)
l1.append(2)
l1.append(3)
l1.append(4)
print(l1)
for i in range(len(l1)):
    print(l1.pop())
    print(l1)

2、类型总结：

　　　　有序or无序（有索引的都是有序的）：

　　　　　　列表类型有序

　　　　可变or不可变：

　　　　　　值改变id不变就是可变类型，值改变id也变就是不可变类型

　　　　　　列表类型是可变类型

　　　　存一个值or多值：

　　　　　　列表可以存多个值

二、元组

　　1、基本方法：

　　　　用途：

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

　　　　定义方法：

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

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

　　　　　　# 定义容器类型的时候，如果里面只有一个值，在值的后面加上一个逗号*****
　　　　　　# 在元组中如果不加，就是字符串

　　　　内置方法:

　　　　　　①索引取值

>>> t1 = ('a','b','c')
>>> t1[0]
'a'
>>> t1[0:2]
('a', 'b')

　　　　　　②成员运算in、not in

　　　　　　③len()

　　　　　　④count()

　　　　　　⑤index()

2、类型总结：

　　　　有序or无序（有索引的都是有序的）：

　　　　　　元组类型有序

　　　　可变or不可变：

　　　　　　值改变id不变就是可变类型，值改变id也变就是不可变类型

　　　　　　元组类型是不可变类型

　　　　存一个值or多值：

　　　　　　元组可以存多个值

三、字典

1、基本方法：

　　　　用途：

　　　　　　存储多个不同类型的值

　　　　定义方法：

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

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

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

　　　　　　zip :

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

　　　　　　# key:一定是一个不可变类型
　　　　　　# value：可以是任意类型

　　　　内置方法:

　　　　　　①按照key:value映射关系取值（可存可取）

>>> d1 = {'name':'abc','age':18}

# 取
>>> d1['name']
'abc'

# 改
>>> d1['name'] = 'a'
>>> d1
{'name': 'a', 'age': 18}

# 增
>>> d1['gender'] = 'male'
>>> d1
{'name': 'a', 'age': 18, 'gender': 'male'}

　　　　　　②成员运算in、not in：默认判断key值

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

>>> d1 = {'name':'abc','age':18}
>>> d1.get('name')
'abc'
>>> d1.get('a')
None
>>> d1.get('a','*')
'*'

　　　　　　④keys、values、items

>>> d1 = {'name':'abc','age':18}
>>> d1.keys()
dict_keys(['name', 'age'])    # 返回所有key值
>>> d1.values()
dict_values(['abc', 18])        # 返回所有value值
>>> d1.items()
dict_items([('name', 'abc'), ('age', 18)])    # 返回所有键值对，返回是列表套元组

# 取出所有
for key,value in d1.items():
    print(key,value)        #  key,value = ("name",'age')

　　　　　⑤pop：指定key进行删除，有返回值，返回为对应的value

　　　　　　popitem：随机删除键值对，返回删除元组

# pop
>>> d1 = {'name':'abc','age':18}
>>> d1.pop('name')
'abc'
>>> d1
{'age': 18}

# popitem
>>> d1 = {'name':'abc','age':18}
>>> d1.popitem()
('age', 18)
>>> d1
{'name': 'abc'}

　　　　　　⑥update：用新字典替换旧字典，key值不存在新增，key值存在就修改

>>> d1 = {'name':'abc','age':18}
>>> d1.update({'a':'2'})
>>> d1
{'name': 'abc', 'age': 18, 'a': '2'}
>>> d1.update({'name':'a'})
>>> d1
{'name': 'a', 'age': 18, 'a': '2'}

　　　　　　⑦fromkeys：生成一个字典，第一个参数（列表），它会以第一个参数中的每个元素为key值，第二个参数为value

>>> dict.fromkeys(['k1','k2'],['v1','v2'])
{'k1': ['v1', 'v2'], 'k2': ['v1', 'v2']}

　　　　　　⑧setdefault：key不存在，新增键值对，返回所增value；key存在，返回对应value

>>> d1 = {'name':'abc','age':18}
>>> d1.setdefault('name',1)
'abc'
>>> d1
{'name': 'abc', 'age': 18}
>>> d1.setdefault('a',1)
1
>>> d1
{'name': 'abc', 'age': 18, 'a': 1}

2、类型总结：

　　　　有序or无序（有索引的都是有序的）：

　　　　　　字典类型无序

　　　　可变or不可变：

　　　　　　值改变id不变就是可变类型，值改变id也变就是不可变类型

　　　　　　字典类型是可变类型

　　　　存一个值or多值：

　　　　　　字典可以存多个值

四、集合

1、基本方法：

　　　　用途：

　　　　　　去重、关系运算

　　　　定义方法：

　　　　　　通过大括号存储数据，每个元素通过逗号分隔

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

　　　　内置方法:　　　　　

　　　　　　合集：|
　　　　　　交集：&
　　　　　　差集：-
　　　　　　对称差集：^

　　集合中不可能出现两个相同的元素

pythons = {'egon', 'kevin', 'echo', 'owen', 'jason'}
linuxs = {'egon', 'echo', 'tank', 'oscar'}

pythons = {'egon', 'kevin', 'echo', 'owen', 'jason'}
linuxs = {'egon', 'echo', 'tank', 'oscar'}
print("报名python学员：", pythons)
print("报名linux学员：", linuxs)
print("既报名python又报名Linux的学生：", pythons & linuxs)
print("所有报名的学生：", pythons | linuxs)
print("只报名python课程的学员：", pythons - linuxs)
print("没有同时这两门课程的学员：", pythons ^ linuxs)

2、类型总结：

　　　　有序or无序（有索引的都是有序的）：

　　　　　　集合类型无序

　　　　可变or不可变：

　　　　　　值改变id不变就是可变类型，值改变id也变就是不可变类型

　　　　　　集合类型是可变类型

　　　　存一个值or多值：

　　　　　　集合可以存多个值

小结：

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

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

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

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