美文网首页
Day08学习总结-元组、字典、集合

Day08学习总结-元组、字典、集合

作者: 萌王史莱姆 | 来源:发表于2019-01-03 16:38 被阅读0次

1.什么是元组(tuple)

python提供的容器型数据类型,不可变并且有序(元组就是不可变的列表)
不可变 - 不支持增删改,只支持查
有序 - 每个元素都对应一个确定的下标

2.字面量和元素

(元素1, 元素2, 元素3...)
其中的元素可以是任何类型的数据,并且类型可以不一样,同样的元素可以有多个

point = (100, 30)
print(point, type(point))

注意:
1.空的元组:()

tuple1 = ()
print(type(tuple1))

2.只有一个元素的元组,元素后要加一个逗号才是元组

tuple2 = (100,)
print(tuple2, type(tuple2))

3.直接将多个元素用逗号隔开,不加小括号表示也是一个元组

tuple3 = 1, 2, 3
print(tuple3, type(tuple3))

3.元组获取元素和列表是一样的

tuple4 = ('成都', '达州', '绵阳', '南充', '广元')
# 获取单个元素
print(tuple4[1], tuple4[-1])
# 获取部分
print(tuple4[0:3])
print(tuple4[::-1])
# 遍历
for city in tuple4:
    print(city)

for index in range(len(tuple4)):
    print(tuple4[index])

补充:特殊的获取方式
1.变量1, 变量2... = 元组 --> 用前面的变量依次获取元组中元素的值(要求前面变量的个数和元组元素的个数一致)

point = (100, 200)
x, y = point   # x, y = (100, 200)  <==>  x, y = 100, 200
print(x, y)

2.变量1, 变量2 = 元组 --> 通过带的变量获取元组中剩余的部分
注意:这个结构中带*的变量只能有一个,不带*的变量可以有多个

name, *scores = ('小明', 100, 89, 67, 99)
print(name, scores)

*info, num = ('小明', 100, 89, 67, 99)
print(info, num)

info1, *nums, num1 = ('小明', 100, 89, 67, 99)
print(nums)

补充:*的用法
1.取元组和列表中的数据

nums = (1, 2, 3)
nums2 = [11, 22, 33]
print(*nums, *nums2)

4.相关运算(和列表一样)

+, *
in / not in
len(), max(), min(), sum(), tuple()

tuple1 = (1, 2, 3)
tuple2 = ('aa', 'bb')
print(tuple1 + tuple2)
print(tuple1 * 3)

print('aa' in tuple2)

5.排序

sorted(序列) - 对序列中的元素排序,产生一个新的列表(不管是什么序列,排完后最后都是列表)

注意:列表.sort() -- 修改原列表中元素的顺序; sorted(列表) -- 产生一个新的列表

nums = (1, 34, 89, 9)
new_nums = sorted(nums, reverse=True)
print(new_nums, nums)

new_strs = sorted('ffegwifigeigiegi')
print(str(new_strs), ''.join(new_strs))

join的使用
字符串.join(序列) - 将序列中的元素取出,用指定的字符串连接在一起。要求序列中的元素必须是字符串

new_str = ''.join(['a', 'b', 'c'])
print(new_str, type(new_str))

list1 = [1, 345, 90, 9]
new_list = list1.sort()      # None; sort()不会产生新的列表
print(list1, new_list)

1.什么是字典(dict)

python提供的容器型数据类型,可变并且无序
可变 - 支持元素的增删改
无序 - 不支持下标操作

2.字面量和元素

用大括号括起来,里面有多个键值对,每个键值对用逗号隔开。键值对就是字典的元素。
{key1:value1, key2:value2, key3:value3...}

键值对 - 键/key:值/value(键值对); 键值对必须成对出现,而且脱离字典单独出现没有任何意义
键/key - 必须是不可变的,而且是唯一的。实际一般将字符串作为键
值/value - 可以是任意类型的数据

注意:字典存储数据,实质是通过值来存储的。key是值对应的标签和获取值的方式

dict1 = {'a': 100, 10: 200, (1, 2): 'abc', 'a': 111, 'a': [1, 11, 111]}
print(dict1)    # {'a': [1, 11, 111], 10: 200, (1, 2): 'abc'}, key唯一

# dict2 = {[1, 2]: 120}   # TypeError: unhashable type: 'list'

3.什么时候使用字典:多个没有相同意义的数据(需要区分),就是用字典。例如:保存一个人的不同信息,一辆车的不同信息

什么时候使用列表:存储的多个数据是有相同意义的数据(不需要区分),就是用列表。例如:保存一个班的学生信息,保存所有的价格

person = {'name': 'xiaohua', 'age': 18, 'sex': 'girl', 'height': 160, 'weight': 90, 'score': 89}
print(person['name'])

练习:声明一个变量,保存一个班的学生信息(4个学生),每个学生需要保存姓名,电话和年龄

all_students = [
    {'name': 'xiaoming', 'tel': 1352654215, 'age': 18},
    {'name': 'xiaohua', 'tel': 1538337373, 'age': 17},
    {'name': 'xiaogou', 'tel': 137777215, 'age': 20},
    {'name': 'xiaoguang', 'tel': 1375755, 'age': 17}
]
print(all_students[0])

字典元素的增删改查

1.查(获取值)

注意:字典中的键值对单独拿出来没有任何意义

a.字典[key] - 获取字典中key对应的值
注意:当key不存在的时候,会报KeyError

car = {'color': '黄色', 'type': '跑车', 'price': 500000}
print(car['color'])
print(car['price'])
# print(car['speed'])   # KeyError: 'speed'

b.字典.get(key) - 获取字典中key对应的值; 当key不存在的时候不会报错,并且取到一个默认值None
字典.get(key, 值1) - 获取字典中key对应的值;当key不存在的时候不会报错,并且取到指定的值1

print(car.get('type'))
print(car.get('speed'))

print(car.get('color', '红色'))   # 黄色
print(car.get('speed', 100))      # 100

c.遍历字典
注意:直接通过for-in遍历字典取到的是key

dict1 = {'a': 100, 'b': 200, 'c': 300}
# 遍历字典取到的是key推荐使用)
for key in dict1:
    # key
    print(key, end=' ')
    # value
    print(dict1[key])

print(dict1.values(), dict1.items())
# 遍历字典的values(),获取所有的值
for value in dict1.values():
    print(value)

# 相当于

# values = []
# for key in dict1:
#     values.append(dict1[key])
# for value in values:
#     print(value)

# 遍历字典的items(),直接获取key和value (不建议使用)
for key, value in dict1.items():
    print(key, value)

# 相当于

# items = []
# for key in dict1:
#     items.append((key, dict1[key]))
# for key, value in items:
#     print(key, value)

2.增、改

字典[key] = 值 - 当key不存在时就是添加键值对;当key存在时就修改key对应的值

movie = {'name': '喜羊羊与灰太狼', 'type': '卡通', 'time': 120}

# 添加
movie['score'] = 7.9
print(movie)

# 修改
movie['type'] = '搞笑'
print(movie)

3.删(删除键值对)

a. del 字典[key] - 删除字典中指定的key对应的键值对

del movie['time']
print(movie)

b. 字典.pop(key) - 取出字典中key对应的值

name = movie.pop('name')
print(movie, name)

练习:用一个字典保存一个学生的信息:{'name': '张三', 'age': 30, 'score': 80}
输入需要修改的信息,例如输入:name -> 修改名字, age -> 修改年龄...abc -> 提示'没有该信息'

stu = {'name': '张三', 'age': 30, 'score': 80}
while True:
    change_message = input('请输入需要修改的信息(输入\'end\'来结束输入):')
    if change_message == 'end':
        break
    if stu.get(change_message):
        if change_message == 'name':
            new_name = input('请输入新的名字:')
            stu['name'] = new_name
        elif change_message == 'age':
            new_age = int(input('请输入新的年龄:'))
            stu['age'] = new_age
        else:
            new_score = float(input('请输入新的成绩:'))
            stu['score'] = new_score
        print(stu)
    else:
        print('没有该信息')


# student = {'name': '张三', 'age': 30, 'score': 80}
# message = input('请输入要修改的信息:')
# if student.get(message):
#     if message == 'name':
#         new_name = input('请输入新的名字:')
#         student[message] = new_name
#     elif message == 'age':
#         new_age = int(input('请输入新的年龄:'))
#         student['age'] = new_age
#     else:
#         new_score = float(input('请输入新的成绩:'))
#         student['score'] = new_score
#     print(student)
# else:
#     print('没有该信息')

1.比较运算

==, !=
注意:判断两个字典是否相等,只看键值对是否一样,不管键值对的顺序;
字典不支持 > 和 < 符号

print({'a': 11, 'b': 22} == {'b': 22, 'a': 11})    # True

2.in / not in

key in 字典 - 判断字典中指定的key是否存在
key not in 字典 - 判断字典中指定的key是否不存在

dict1 = {'a': 1, 'b': 2, 'c': 3}
print('a' in dict1)   # True
print(1 in dict1)     # False

3.len(), max(), min()

dict(数据) - 数据要求是序列,并且序列中的元素都是有两个元素的子序列

# 获取字典中键值对的个数
print(len(dict1))
# 获取字典中key的最大值
print(max(dict1))
# 获取字典中key的最小值
print(min(dict1))

# 将列表转换成字典
print(dict([(1, 2), ('a', 'b'), [10, 'abc']]))

# 字典转列表/元组/集合都是将字典中的key取出来作为列表/元组/集合的元素
dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
print(list(dict2))  # ['name', 'color', 'height']

4.相关方法

1. 字典.clear() - 清空字典

注意:清空容器推荐使用clear操作,而不是重新赋一个空的容器

dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
print(id(dict2))
dict2.clear()
print(dict2, id(dict2))

# 只有容器本身不存在的时候,可以使用
dict2 = {}
print(id(dict2))

2. 字典.copy() - 赋值字典中的元素,产生一个新的字典

dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
# 直接赋值,修改其中一个的元素,会影响另外一个
dict3 = dict2
print(dict3)
dict3['name'] = '小明'
print(dict3)
print(dict2)

dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
# 拷贝赋值,会产生新的地址,复制后相互不影响
dict4 = dict2.copy()
print(dict4)
del dict4['color']
print(dict4)
print(dict2)

3. dict.fromkeys(seq, val) -- 以序列中所有的元素作为key,指定的值作为value创建一个新的字典

new_dict = dict.fromkeys('abc', 100)
print(new_dict)

new_dict = dict.fromkeys(['name', 'age', 'tel'], 0)
print(new_dict)

4.

字典.keys() - 将字典所有的key取出产生一个新的序列

字典.values() - 将字典所有的value取出产生一个新的序列

字典.items - 将字典所有的key和value作为一个元组取出产生一个新的序列

dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
print(dict2.keys(), dict2.values(), dict2.items())

5.字典.setdefault(key, value = None)

字典.setdefault(key) - 当key不存在的时候,添加键值对key:None
字典.setdefault(key, value) - 当key不存在的时候,添加键值对key:value

注意:这个操作当key存在的时候,不会修改

dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}

dict2.setdefault('name2', '小胡')
dict2.setdefault('sex')
print(dict2)

6.字典1.update(字典2) - 使用字典2中的键值对去更新字典1;

如果字典2中的key,字典1中本身存在就是修改,不存在就添加

dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}

dict2.update({'height': 180, 'age': 18})
print(dict2)

dict2.update([('a', 100), ('age', 30)])
print(dict2)

1.什么是集合(set)

可变的,无序的;元素是唯一并且不可变

2.字面量

{元素1, 元素2, 元素3...}

set1 = {1, 23, 5, 'abc'}
print(set1)

# set1 = {1, 23, 5, 'abc', [1, 2]}  # TypeError: unhashable type: 'list'
# print(set1)

# 表示空集合
set2 = set()
print(type(set2))

set3 = {1, 2, 1, 2, 2}
print(set3)

# 集合自带去重功能
list1 = [1, 2, 1, 2, 2]
list1 = list(set(list1))
print(list1)

3.增删查

1.查
集合不能单独的获取单个元素,只能一个一个的遍历

set1 = {1, 28, 90, 8}
for item in set1:
    print(item)

2.增
a. 集合.add(元素) - 在集合当中添加指定的元素
b. 集合.update(序列) - 将序列中的元素添加到集合中

set1 = {1, 28, 90, 8}
set1.add('abc')
print(set1)


set1.update('abc')
print(set1)

set1.update({'name': '张三', 'age': 18})
print(set1)

3.删

集合.remove(元素) - 删除集合中指定的元素

set1 = {1, 28, 90, 8}
set1.remove(90)
print(set1)

4.数学集合运算

交集(&):获取两个集合公共的元素产生一个新的集合
并集(|):将两个集合中的元素合并在一起产生一个新的集合
差集(-):集合1 - 集合2:去掉集合1中包含集合2的部分,剩下的产生一个新的集合
补集(^):将两个集合合并在一起,去掉公共部分,剩下的部分产生一个新的集合
子集的判断:集合1 > 集合2 -> 判断集合1中是否包含集合2, 集合1 < 集合2 -> 判断集合2中是否包含集合1

set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8, 9}
# 交集
print(set1 & set2)  # {4, 5, 6}
# 并集
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7, 8, 9}
# 差集
print(set2 - set1)  # {8, 9, 7}
print(set1 - set2)  # {1, 2, 3}
# 补集
print(set1 ^ set2)  # {1, 2, 3, 7, 8, 9}
# 子集的判断
print({1, 2, 3, 9, 18} > {1, 2, 3})     # True
print({1, 2, 3, 9, 18} > {1, 2, 3, 0})  # False

print({1, 2, 3} >= {1, 2, 3})   # True
print({1, 2, 3} > {1, 2, 3})    # False

相关文章

网友评论

      本文标题:Day08学习总结-元组、字典、集合

      本文链接:https://www.haomeiwen.com/subject/mixqrqtx.html