python基础数据类型之列表，字典，元组，集合

1.列表list

1.列表的创建

# 创建一个列表有三种方式：

# 方式一：（常用）
l1 = [1, 2, '小白']


# 方式二：（不常用）
l1 = list()  # 空列表
# l1 = list(iterable)  # 可迭代对象
l1 = list('123')
print(l1)  # ['1', '2', '3']


# 方式三：列表推导式
l1 = [i for i in range(1,5)]
print(l1)  # [1, 2, 3, 4]

2.列表的索引切片

索引

li = [100, '小白', True, [1, 2, 3]]
li2= li[1]
print(li2)
# 小白

li =  [100, '小白', True, [1, 2, 3]]
li3 = li[3][1]
print(li3)
# 2 

切片

li = [100, '小白', True, [1, 2, 3]]
li4 = li[:2]
print(li4)
# [100, '小白']

li = [100, '小白', True, [1, 2, 3],22]
li5 = li[::2]
print(li5)
# [100, True, 22]

索引与切片相关练习题

li = [1, 3, 2, "a", 4, "b", 5,"c"]
# 通过对li列表的切片形成新的列表l1,l1 = [1,3,2]
li = [1, 3, 2, "a", 4, "b", 5,"c"]
l1 = li[:3]
print(l1)

# 通过对li列表的切片形成新的列表l2,l2 = ["a",4,"b"]
li = [1, 3, 2, "a", 4, "b", 5,"c"]
l2 = li[3:-2]
l2 = li[3:6]
print(l2)

# 通过对li列表的切片形成新的列表l4,l4 = [3,"a","b"]
li = [1, 3, 2, "a", 4, "b", 5,"c"]
l3 = li[1:-2:2]
print(l3)

# 通过对li列表的切片形成新的列表l6,l6 = ["b","a",3]
li = [1, 3, 2, "a", 4, "b", 5,"c"]
l6 = li[-3::-2]
print(l6)

3.列表的常用方法（增删改查）

append()  追加

alist = ["xiaobai", "美丽的茧", "道路和生活"]
alist.append("在路上")
print(alist)
# ['xiaobai', '美丽的茧', '道路和生活', '在路上']

insert()  插入元素

# insert()  参数格式
insert(索引位置，插入元素)


alist = ["xiaobai", "美丽的茧", "道路和生活"]
alist.insert(1, "在路上")
print(alist)
# ['xiaobai', '在路上', '美丽的茧', '道路和生活']

alist = ["xiaobai", "美丽的茧", "道路和生活"]
alist.insert(-1, "在路上")
print(alist)
# ['xiaobai', '美丽的茧', '在路上', '道路和生活']

extend()  迭代着追加

alist = ["xiaobai", "美丽的茧", "道路和生活"]
alist1 = ["在路上", "爱你就像爱生命"]
alist.extend(alist1)
print(alist)
# ['xiaobai', '美丽的茧', '道路和生活', '在路上', '爱你就像爱生命']

pop()   

# 默认删除最后一个
l1 = ['xiaobai', '美丽的茧', '道路和生活', '在路上', '爱你就像爱生命']
l1.pop()
print(l1)
# ['xiaobai', '美丽的茧', '道路和生活', '在路上']

# 按照索引位置进行删除
l1 = ['xiaobai', '美丽的茧', '道路和生活', '在路上', '爱你就像爱生命']
l1.pop(2)
print(l1)
# ['xiaobai', '美丽的茧', '在路上', '爱你就像爱生命']

# 返回删除的元素
l1 = ['xiaobai', '美丽的茧', '道路和生活', '在路上', '爱你就像爱生命']
l3 = l1.pop(2)
print(l3)
# 道路和生活

remove()  指定删除元素，如果有重名元素，默认删除从左边的第一个，如果指定的元素不存在，则会报错

alist = ['xiaobai', '美丽的茧', '道路和生活', '在路上', '爱你就像爱生命']
alist.remove('美丽的茧')
print(alist)
# ['xiaobai', '道路和生活', '在路上', '爱你就像爱生命']


alist = ['xiaobai', '美丽的茧', '道路和生活', '在路上', '爱你就像爱生命',"美丽的茧"]
alist.remove('美丽的茧')
print(alist)
# ['xiaobai', '道路和生活', '在路上', '爱你就像爱生命', '美丽的茧']


alist = ['xiaobai', '美丽的茧', '道路和生活', '在路上', '爱你就像爱生命']
alist.remove('美丽的春茧')
print(alist)
# ValueError: list.remove(x): x not in list

clear() 清除

alist = ['xiaobai', '美丽的茧', '道路和生活', '在路上', '爱你就像爱生命']
alist.clear()
print(alist)
# []

del 删除

alist = ['xiaobai', '美丽的茧', '道路和生活', '在路上', '爱你就像爱生命']
del alist[-1]
print(alist)
# ['xiaobai', '美丽的茧', '道路和生活', '在路上']

alist = ['xiaobai', '美丽的茧', '道路和生活', '在路上', '爱你就像爱生命']
del alist[::-2]
print(alist)
# ['美丽的茧', '在路上']

count()  计数

alist = ['xiaobai', '美丽的茧', '道路和生活', '在路上', '爱你就像爱生命', "xiaobai"]
alist1 = alist.count("xiaobai")
print(alist1)
# 2

index() 获取该元素的索引位置

alist = ['xiaobai', '美丽的茧', '道路和生活', '在路上', '爱你就像爱生命', "xiaobai"]
alist1 = alist.index("xiaobai")
print(alist1)
# 0

sort()  排序，默认从小到大排序

l1 = [5, 4, 3, 7, 8, 6, 1, 9]
l1.sort()
print(l1)
# [1, 3, 4, 5, 6, 7, 8, 9]

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

reverse()  反转

l1 = [5, 4, 3, 7, 8, 6, 1, 9]
l1.reverse()
print(l1)
# [9, 1, 6, 8, 7, 3, 4, 5]

列表相加

v1 = [5, 4, 3, 7]
v2 = [4, 5, 6]
print(v1 + v2)
# [5, 4, 3, 7, 4, 5, 6]

列表与数字相乘

v2 = [4, 5, 6]
print(v2 * 3)
# [4, 5, 6, 4, 5, 6, 4, 5, 6]

4.列表的嵌套

l1 = [1, 2, 'xiaobai', [1, '小黑', 3,]]
# 1, 将l1中的'xiaobai'变成大写并放回原处。
l1 = [1, 2, 'xiaobai', [1, '小黑', 3,]]
l1[2] = l1[2].upper()
print(l1)


# 2，给小列表[1,'小黑',3,]追加一个元素'生活与道路'。
l1 = [1, 2, 'taibai', [1, '小黑', 3,]]
l1[3].append('生活与道路')
print(l1)


# 3，将列表中的'小黑'通过字符串拼接的方式在列表中变成'小黑太黑了'
l1 = [1, 2, 'xiaobai', [1, '小黑', 3,]]
l1[3][1] = l1[3][1]+"太黑了"
print(l1)

注意：循环列表，改变列表大小的问题

有列表lis = [11, 22, 33, 44, 55]，请把索引为奇数对应的元素删除
# 错误方式
lis = [11, 22, 33, 44, 55]
for i in range(len(lis)-1):
    if i % 2 == 1:
        lis.remove(lis[i])
print(lis)
# [11, 33, 44]

# 方式一（直接删除）
lis = [11, 22, 33, 44, 55]
del lis[1::2]
print(lis)

# 方式二（倒序删除）
lis = [11, 22, 33, 44, 55]
for i in range(len(lis)-1,-1,-1):
    if i % 2 == 1:
       lis.pop(i)
print(lis)

# 方式三（思维置换）
lis1= []
for i in range(len(lis)):
    if i % 2 == 0:
        lis1.append(lis[i])
lis = lis1
print(lis)


总结：循环一个列表的时，最好不要改变列表的大小，这样会影响你的最终的结果

2.元组tuple

　　只读列表，可以存储大量的数据，可以索引，切片，步长.但是内部元素不能做增删改。

元组的特殊性：

元组中如果只有一个元素，并且没有逗号，那么他不是元组，他与该元素的数据类型一致。
tu1 = (2,3,4)        # 类型是tuple
tu1 = (2)            # 类型是int
tu1 = ('xiaobai')    # 类型是str
tu1 = ([1,2,3])      # 类型是list
tu1 = (1,)           # 类型是tuple 

3.字典dict

1.字典的创建方式：

方式一：
dic = dict((('one', 1), ('two', 2), ('three', 3)))
print(dic)
# {'one': 1, 'two': 2, 'three': 3}

方式二：
dic = dict(one=1, two=2, three=3)
print(dic)
# {'one': 1, 'two': 2, 'three': 3}

方式三：
dic = dict({'one': 1, 'two': 2, 'three': 3})
print(dic)
# {'one': 1, 'two': 2, 'three': 3}

2.字典的常用方法（增删改查）

直接增加，有则改之，无则增加

dic = {'name': '小白', 'age': 18}
dic["happy"] = '球类运动'
print(dic)
# {'name': '小白', 'age': 18, 'happy': '球类运动'}


dic = {'name': '小白', 'age': 18, 'happy': '球类运动'}
dic["age"] = 35
print(dic)
# {'name': '小白', 'age': 35, 'happy': '球类运动'}

setdefault()  有则不变，无则添加

dic = {'name': '小白', 'age': 18, 'happy': '球类运动'}
dic.setdefault("name")
print(dic)
# {'name': '小白', 'age': 18, 'happy': '球类运动'}


dic = {'name': '小白', 'age': 18, 'happy': '球类运动'}
dic.setdefault("sex")
print(dic)
# {'name': '小白', 'age': 18, 'happy': '球类运动', 'sex': None}


dic = {'name': '小白', 'age': 18, 'happy': '球类运动'}
dic.setdefault("sex","男")
print(dic)
# {'name': '小白', 'age': 18, 'happy': '球类运动', 'sex': '男'}

fromkeys()  创建一个字典，字典的所有的键来自一个可迭代对象，字典的值使用用一个

dic = dict.fromkeys('abc', 100)
print(dic)
# {'a': 100, 'b': 100, 'c': 100}

dic = dict.fromkeys([1, 2, 3], 'alex')
print(dic)
# {1: 'alex', 2: 'alex', 3: 'alex'}

dic = dict.fromkeys([1, 2, 3],[])
dic[1].append(666)
print(dic)
# {1: [666], 2: [666], 3: [666]}

pop()  根据键删除值，有返回值，设置第二个参数则无论字典中有无键都不会报错

dic = {'name': '小白', 'age': 18, 'happy': '球类运动'}
dic.pop("name")
print(dic)
# {'age': 18, 'happy': '球类运动'}

dic = {'name': '小白', 'age': 18, 'happy': '球类运动'}
dic1 = dic.pop("name")
print(dic1)
# 小白

dic = {'name': '小白', 'age': 18, 'happy': '球类运动'}
dic1 = dic.pop("sex")
print(dic1)
# 报错信息KeyError: 'sex'


# 设置第二个参数则无论字典中有无此键都不会报错
dic = {'name': '小白', 'age': 18, 'happy': '球类运动'}
dic1 = dic.pop("name"，None)
print(dic1)
# 小白

dic = {'name': '小白', 'age': 18, 'happy': '球类运动'}
dic1 = dic.pop("sex",None)
print(dic1)
# None

clear()  清除

dic = {'name': '小白', 'age': 18, 'happy': '球类运动'}
dic.clear()
print(dic)
# {}

del  根据键删除值

dic = {'name': '小白', 'age': 18, 'happy': '球类运动'}
del dic['name']
print(dic)
# {'age': 18, 'happy': '球类运动'}

update()  更新，有则覆盖，无则添加

dic = {'name': '小白', 'age': 18}
dic.update(hobby='运动', hight='175')
print(dic)
# {'name': '小白', 'age': 18, 'hobby': '运动', 'hight': '175'}


dic = {'name': '小白', 'age': 18}
dic.update(name='小黑')
print(dic)
# {'name': '小黑', 'age': 18}


dic = {'name': '小白', 'age': 18}
dic.update([(1, 'a'),(2, 'b'),(3, 'c'),(4, 'd')])  
print(dic)
# {'name': '小白', 'age': 18, 1: 'a', 2: 'b', 3: 'c', 4: 'd'}


dic1 = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"han123","weight":75}
dic1.update(dic2)  
print(dic1)  
# {'name': 'han123', 'age': 18, 'sex': 'male', 'weight': 75}

修改值

dic = {'name': '小白', 'age': 18, 'happy': '球类运动'}
dic["name"] = "小黑"
print(dic)
# {'name': '小黑', 'age': 18, 'happy': '球类运动'}

直接查找

dic = {'name': '小白', 'age': 18, 'happy': '球类运动'}
dic1 = dic["name"]
print(dic1)
# 小白

get()  根据键获取值，可以设置返回值

dic = {'name': '小白', 'age': 18, 'happy': '球类运动'}
dic1 = dic.get("name")
print(dic1)
# 小白


#可以设置返回值
dic = {'name': '小白', 'age': 18, 'happy': '球类运动'}
dic1 = dic.get("sex","没有此键")
print(dic1)
# 没有此键


dic = {'name': '小白', 'age': 18, 'happy': '球类运动'}
dic1 = dic.get("sex")
print(dic1)
# None

keys()  获取字典的键

dic = {'name': '小白', 'age': 18, 'sex': '男'}
print(list(dic.keys()))
# ['name', 'age', 'sex']


for i in dic.keys():
    print(i)
# name
# age
# sex

values()  获取字典的值

dic = {'name': '小白', 'age': 18, 'sex': '男'}
print(list(dic.values()))
# ['小白', 18, '男']

for i in dic.values():
    print(i)
# 小白
# 18
# 男

items()  获取字典的键值对

dic = {'name': '小白', 'age': 18, 'sex': '男'}
print(list(dic.items()))
# [('name', '小白'), ('age', 18), ('sex', '男')]


for i in dic.items():
    print(i)
# ('name', "小白")
# ('age', 18)
# ('sex', '男')


for key,value in dic.items():
    print(key,value)
# name 小白
# age 18
# sex 男

练习题：

dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
# 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
dic["k4"] = "v4"
print(dic)


# 请在修改字典中 "k1" 对应的值为 "alex"，输出修改后的字典
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
dic["k1"] = "alex"
print(dic)


# 请在k3对应的值中追加一个元素 44，输出修改后的字典
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
dic["k3"].append(44)
print(dic)


# 请在k3对应的值的第 1 个位置插入个元素 18，输出修改后的字典
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
dic["k3"].insert(0,18)
print(dic)

3. 字典的嵌套

dic = {
    'name': '汪峰',
    'age': 48,
    'wife': [{'name': '国际章', 'age': 38},],
    'children': {'girl_first': '小苹果','girl_second': '小怡','girl_three': '顶顶'}
}

# 1. 获取汪峰的名字。
name2 = dic.get("name")
print(name2)

# 2.获取这个字典：{'name':'国际章','age':38}。
# 方式一
name2 = dic.get("wife")[0]
print(name2)

# 3. 获取汪峰妻子的名字。
# 方式一
name2 = dic.get("wife")[0]
name3 = name2.get("name")
print(name3)

# 方式二
name2 = dic[ 'wife'][0]["name"]
print(name2)

# 4. 获取汪峰的第三个孩子名字。
# 方式一
name2 = dic.get("children")
name3 = name2.get("girl_three")
print(name3)

# 方式二
name2 = dic[ "children"]["girl_three"]
print(name2)

注意：循环字典，改变字典的大小的问题

# 将字典中键含有'k'元素的键值对删除。

# 错误实例
dic = {'k1':'太白','k2':'barry','k3': '白白', 'age': 18}
for i in dic:
    if 'k' in i:
        del dic[i]
print(dic)
# RuntimeError: dictionary changed size during iteration
# 翻译过来是：字典在循环迭代时，改变了大小。

方式一
lis = []
for key in dic.keys():
    if "k" in key:
        lis.append(key)
for v in lis:
    dic.pop(v)
print(dic)

方式二
for key in list(dic.keys()):
    if "k" in key:
        dic.pop(key)
print(dic)
# {'age': 18}

总结：循环一个字典时，如果改变这个字典的大小，就会报错。

4.集合 set

1.集合的初始

　　容器的数据类型，内部元素是不可变的数据类型，集合是无序的，无重复的，本身是可变的数据类型。

集合的应用

　　- 列表去重

　　- 数据之间的关系

2.集合的创建

set1 = set({1, 2, "xiaobai"})
set1 = set{1, 2, "xiaobai"}
print(set1)

3.集合的常用方法

add()  添加

set1 = {'xiaobai', '美丽的茧', '道路和生活', '在路上', '爱你就像爱生命'}
set1.add("123")
print(set1)
# {'爱你就像爱生命', '美丽的茧', '在路上', 'xiaobai', '123', '道路和生活'}

update()  迭代着添加

set1 = {'xiaobai', '美丽的茧', '道路和生活'}
set2 = {1, 2, 3}
set1.update("123")
print(set1)
# {'道路和生活', 'xiaobai', '美丽的茧', '1', '3', '2'}

pop()  随机删除

set1 = {'xiaobai', '美丽的茧', '道路和生活', '在路上', '爱你就像爱生命'}
set1.pop()
print(set1)
# {'爱你就像爱生命', '美丽的茧', '在路上', '道路和生活'}

clear()  清除

set1 = {'xiaobai', '美丽的茧', '道路和生活', '在路上', '爱你就像爱生命'}
set1.clear()
print(set1)
# {}

remove()  根据元素删除

set1 = {'xiaobai', '美丽的茧', '道路和生活', '在路上', '爱你就像爱生命'}
set1.remove('美丽的茧')
print(set1)
# {'爱你就像爱生命',  '在路上', 'xiaobai', '123', '道路和生活'}

并集  （| 或者 union）

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1 | set2
print(set3)
# {1, 2, 3, 4, 5, 6, 7, 8}


set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1.union(set2)
print(set3)
# {1, 2, 3, 4, 5, 6, 7, 8}

交集  （& 或者 intersection）

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1 & set2
print(set3)
# {4, 5}


set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1.intersection(set2)
print(set3)
# {4, 5}

差集  （- 或者 difference）

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1 - set2
print(set3)
# {1, 2, 3}


set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set2 - set1
print(set3)
# {6, 7, 8}


set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1.difference(set2)
print(set3)
# {1, 2, 3}

反差集  （^ 或者 symmetric_difference）

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1 ^ set2
print(set3)
# {1, 2, 3, 6, 7, 8}

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set3 = set1.symmetric_difference(set2)
print(set3)
# {1, 2, 3, 6, 7, 8}