字段初识概括

day 7 summary

1.什么是字典(dict))

字典是容器型数据类型(序列), 将{}作为容器标志，里面多个元素用逗号隔开(每个元素必须是键值对): {键1:值1, 键2:值2, 键3:值3,…}
字典是可变的(支持增删改);字典无序
键: 不可变的数据才可以作为字典的键(数字、字符串、元组)；键是唯一的
值：值才是字典真正想要保存的数据，键只是的作用就像列表中的下标用来对值进行区分和说明的。值可以是任何类型的数据

1)空字典

dict1 = {}
print(dict1, type(dict1), len(dict1))   # {} <class  'dict'>   0

2)字典无序

print([1, 2, 3] == [3, 2, 1])   # False
print({'a': 10, 'b': 20} == {'b': 20, 'a': 10})    # True

3. 键是不可变的

print({10: 20, 'abc': 100, (1, 2): 300})
# print({10: 20, 'abc': 100, [1, 2]: 300})    # 报错

4）键是唯一的

print({10: 20, 'abc': 30, 10: 40, 'abc': 50})    # {10: 40, 'abc': 50}

num = [10, 20, 30, 40]
num2 = []
[num2.append(x) for x in num]
print(num2)

2.字典的增删查改

1.查 - 获取值

1）查单个:

a. 字典[键] - 获取字典中指定键对应的值, 键不存在会报错

b. 字典.get(键) - 获取字典中指定键对应的值，键不存在不会报错返回None

c. 字典.get(键, 默认值) - 获取字典中指定键对应的值，键不存在不会报错返回指定默认值

dog = {'name': '财财', 'breed': '土狗', 'gender': '母狗', 'age': 2}
print(dog['name'])  #财财
print(dog['age'])  # 2

print(dog.get('breed'))    # 土狗

# print(dog['height'])        # KeyError: 'height'
print(dog.get('height'))      # None
print(dog.get('height', 0))   # 0

2. 遍历

“”"
for 变量 in 字典:
循环体

注意：变量取到的是字典的键
“”"

rint('===============================')
dog = {'name': '财财', 'breed': '土狗', 'gender': '母狗', 'age': 2}
for x in dog:
    print(x, dog[x]) #name 财财 breed 土狗 gender 母狗 age 2

students = [
    {'name': '程明明', 'age': 27, 'score': 89, 'tel': '18860901744', 'gender': '男'},
    {'name': '梅迁', 'age': 26, 'score': 93, 'tel': '13567193428', 'gender': '男'},
    {'name': '张三', 'age': 18, 'score': 43, 'tel': '15367423810', 'gender': '女'},
    {'name': '李四', 'age': 34, 'score': 65, 'tel': '13799413758', 'gender': '不明'},
    {'name': '王麻子', 'age': 23, 'score': 76, 'tel': '15533753219', 'gender': '男'},
    {'name': '李冰冰', 'age': 17, 'score': 99, 'tel': '17742589773', 'gender': '女'}
]
# 练习：统计未成年的人数
count = 0
for stu in students:
    if stu['age'] < 18:
        count += 1
print('未成年人数:', count)

# 练习：通过列表推导式获取字典所有的值
stu = {'name': '程明明', 'age': 27, 'score': 89, 'tel': '18860901744', 'gender': '男'}
values = [stu[x] for x in stu]
print(values)   # ['程明明', 27, 89, '18860901744', '男']

2. 增、改

字典[键] = 值 - 当键不存的时候添加键值对，当键存在的时候修改指定键对应的值

dog = {'name': '财财', 'breed': '土狗', 'gender': '母狗', 'age': 2}
# 添加
dog['weight'] = 10
print(dog)  #{'name': '财财', 'breed': '土狗', 'gender': '母狗', 'age': 2, 'weight': 10}

# 修改
dog['name'] = '旺财'
print(dog)  #{'name': '旺财', 'breed': '土狗', 'gender': '母狗', 'age': 2, 'weight': 10}

3. 删

1) del 字典[键]   -  删除字典中指定键对应的键值对
dog = {'name': '财财', 'breed': '土狗', 'gender': '母狗', 'age': 2}
del dog['breed']
print(dog)  #{'name': '财财', 'gender': '母狗', 'age': 2}

# del dog['height']     # KeyError: 'height'

# 2) 字典.pop(键)  -   取出字典中指定键对应的值
dog = {'name': '财财', 'breed': '土狗', 'gender': '母狗', 'age': 2}
del_val = dog.pop('gender')
print(dog, del_val)  #{'name': '财财', 'breed': '土狗', 'age': 2} 母狗 ==del_val 

# 练习：写程序交换字典的键和值
# {'a': 'b', 'c': 'd', 'e': 'f'}  -> {'b': 'a', 'd': 'c', 'f': 'e'}
# 方法一：
dict2 = {}
for x in dict1:
    dict2[dict1[x]] = x
print(dict2)    # {'b': 'a', 'd': 'c', 'f': 'e'}

# 方法二：
# 字典推导式: {键:值 for 变量 in 序列}
dict2 = {dict1[x]: x for x in dict1}
print(dict2)

练习：使用推导式产生一个字典:
# {2:4, 3:6, 4:8, 5:10}
dict1 = {x: x*2 for x in range(2, 6)}
print(dict1)    # {2: 4, 3: 6, 4: 8, 5: 10}
# {2:22, 3:33, 4:44, 5:55}
dict2 = {x: x*11 for x in range(2, 6)}
print(dict2)  #{2:22, 3:33, 4:44, 5:55}

3.字典的相关操作

# 1. 运算符
# 字典不支持比较运算(比较大小)和数学运算
print([10, 20, 3, 4, 5] > [10, 20])    # 比较第一对不想等的元素的大小
# print({'a': 10} > {'a': 20})  # TypeError: '>' not supported between instances of 'dict' and 'dict'
# print({'a': 20} + {'b': 30})   #  TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
# 2. in 和 not in
# 键 in 字典   -   判断字典中是否存在指定键对应的键值对
# 键 not in 字典
cat = {'name': '咖啡', 'color': '白色', 'breed': '折耳'}
print('咖啡' in cat)    # False
print('name' in cat)   # True
print('咖啡' not in cat)#  True

3. 相关函数: len、dict

cat = {'name': '咖啡', 'color': '白色', 'breed': '折耳'}
print(len(cat))    # 3

dict(数据) - 将指定数据转换成字典。

数据的要求： a.数据本身是一个序列 b.序列中的元素必须是有且只有两个元素的小序列

c.小序列中的元素必须是不可变的数据

seq = [(10, 20), 'ab']
result = dict(seq)
print(result)    # {10: 20, 'a': 'b'}

result = dict((x, x*2) for x in range(3))
print(result)

字典转列表 list – 列表中的元素是键

cat = {'name': '咖啡', 'color': '白色', 'breed': '折耳'}
print(list(cat))   # ['name', 'color', 'breed']

# 2) 字典.copy()
cat = {'name': '咖啡', 'color': '白色', 'breed': '折耳'}
cat2 = cat.copy()
print(cat2, id(cat), id(cat2))

# 3) keys、values、items
# 字典.keys()  - 获取字典所有的键，返回值是序列
# 字典.values() - 获取字典所有的值，返回值是序列
# 字典.items() - 将字典转换成元素是元组的序列（一个键值对对应一个元组）
print(cat.keys())    # dict_keys(['name', 'color', 'breed'])
print(cat.values())     # dict_values(['咖啡', '白色', '折耳'])
print(cat.items())     # dict_items([('name', '咖啡'), ('color', '白色'), ('breed', '折耳')])

for x, y in cat.items():
    print(x, y)


# )4) 字典.setdefault(键, 值)  -  添加键值对(键存在的时候不会修改
cat = {'name': '咖啡', 'color': '白色', 'breed': '折耳'}
cat.setdefault('weight', 10)
print(cat)   # {'name': '咖啡', 'color': '白色', 'breed': '折耳', 'weight': 10}

cat.setdefault('color', '黑色')
print(cat)    # {'name': '咖啡', 'color': '白色', 'breed': '折耳', 'weight': 10}

# 5）字典.update(序列)  - 将序列中的元素添加到字典中(序列必须是可以转换成字典的序列)
# 字典1.update(字典2) - 将字典2中所有的键值对添加到字典1中
cat = {'name': '咖啡', 'color': '白色', 'breed': '折耳'}
cat.update([(10, 20), 'ab'])
print(cat)    # {'name': '咖啡', 'color': '白色', 'breed': '折耳', 10: 20, 'a': 'b'}

cat = {'name': '咖啡', 'color': '白色', 'breed': '折耳'}
cat.update({'a': 10, 'b': 20, 'color': '黑色'})
print(cat)    # {'name': '咖啡', 'color': '黑色', 'breed': '折耳', 'a': 10, 'b': 20}

4 实际开发中的字典

cl = {
    'name': 'python2103',
    'address': '6教室',
    'students': [
        {
            'name': 'stu1',
            'age': 20,
            'tel': '11102',
            'gender': '男',
            'linkman': {'name': '张三', 'tel': '9202'}
        },
        {
            'name': 'stu2',
            'age': 24,
            'tel': '111087',
            'gender': '女',
            'linkman': {'name': '李四', 'tel': '8923'}
        },
        {
            'name': 'stu3',
            'age': 22,
            'tel': '321087',
            'gender': '女',
            'linkman': {'name': '王五', 'tel': '8290123'}
        }
    ],
    'teachers': [
        {'name': '余婷', 'job': '讲师', 'QQ': '72282612'},
        {'name': '舒玲', 'job': '班主任', 'QQ': '8272129'}
    ]
}
# 打印所有学生的紧急联系人的电话
for stu in cl['students']:
    print('紧急联系人的电话:', stu['linkman']['tel'])
  # 给所有的紧急联系人添加性别，性别默认是男
 for stu in cl['students']:
    # stu['linkman']['gender'] = '男'
    stu['linkman'].setdefault('gender', '男')
 print(cl)

# 打印所有老师的名字
# print(cl['teachers'])
for tea in cl['teachers']:
    print(tea['name'])

5.集合

1. 什么是集合(set)
   集合是容器型数据类型(序列), 将{}作为容器标志，里面多个元素用逗号隔开: {元素1, 元素2, 元素3,…}
   集合是可变的(支持增删改)；无序的(不支持下标操作)
   集合的元素：必须是不可变的数据; 唯一的

# 1）空集合
set1 = set()
print(set1, type(set1), len(set1))

# 2）集合无序
print({1, 2, 3} == {3, 2, 1})    # True

# 3）集合的元素是不可变的数据
print({10, 'abc', (2, 3)})
# print({10, 'abc', [2, 3]})   # 报错！

# 4）集合元素是唯一的
print({10, 20, 30, 10, 10, 20})    # {10, 20, 30}

names = ['张三', '李四', '张三', '小明', '张三', '李四']
print(set(names))  #{'李四', '张三', '小明'}
 
# 2.集合的增删改查
# 1）查 -只有遍历
nums = {10, 78, 67, 35, 70, 89}
print(list(nums))  #[35, 67, 70, 10, 78, 89]
for x in nums:
    print(x)

# 2) 增
# 集合.add(元素)    -  在集合中添加指定元素
# 集合.update(序列)     -   将序列中所有的元素都添加到集合中
nums.add(100)
print(nums)  #{35, 67, 100, 70, 10, 78, 89}

nums.update('abc')
print(nums)  #{'b', 35, 67, 70, 'a', 10, 78, 89, 'c'}

nums.update({'name': '张三', 'age': 18})
print(nums) #{'name', 35, 67, 70, 10, 78, 'age', 89}

# 3）删
# 集合.remove(元素)  -  删除指定元素, 元素不存在报错！
# 集合.discard(元素) - 删除指定元素，元素不存在不会报错
nums = {10, 78, 67, 35, 70, 89}
nums.remove(10)
print(nums)   # {35, 67, 70, 78, 89}

nums.discard(35)
print(nums)    # {67, 70, 78, 89}

# nums.remove(1000)    # KeyError: 1000
nums.discard(1000)
print(nums)     # {67, 70, 78, 89}

6,数字集合运算

数学集合运算：&(交集)、|(并集)、-(差集)、^(对称差集)、>\<(判断是否是真子集)、>=\<=(判断是否是子集)
set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8}

# 1. 集合1 & 集合2  - 交集(获取两个集合公共部分)
print(set1 & set2)    # {4, 5, 6}

# 2. 集合1 | 集合2   - 并集(将两个集合合并产生一个新的集合)
print(set1 | set2)   # {1, 2, 3, 4, 5, 6, 7, 8}

# 3. 集合1 - 集合2  - 差集(获取集合1中除了包含在集合2中以外的元素)
print(set1 - set2)   # {1, 2, 3}
print(set2 - set1)   # {8, 7}

# 4. 集合1 ^ 集合2  - 对称差集(集合1和集合2合并然后去掉公共部分)
print(set1 ^ set2)   # {1, 2, 3, 7, 8}

# 5.子集
# 集合1 > 集合2  - 判断集合2是否是集合1的真子集
# 集合1 >= 集合2  - 判断集合2是否是集合1的子集
print({10, 20, 30, 40} > {1, 2})   # False
print({10, 20, 30, 40} > {10, 20})   # True
print({10, 20} > {10, 20})   # False
print({10, 20} >= {10, 20})     # True

# {1, 2, 3}  的真子集: {1}、{1, 2}、{1, 3}、{2, 3}、{2}、{3}、{}
# {1, 2, 3}  的子集: {1}、{1, 2}、{1, 3}、{2, 3}、{2}、{3}、{}, {1, 2, 3}

07 数字数据

python中数字相关的类型有4种: int、float、bool、complex

True == 1、False == 0

1.complex - 复数

python中复数的格式: a + bj (j是虚数单位，j**2 == -1, b是1的时候不能省)

a = 10 + 2j
print(a, type(a))   # (10+2j) <class 'complex'>

 python的复数直接支持复数运算
b = 5 - 6j
print(a + b)    # (15 - 4j)
print(a * b)    # (62-50j)
# print(a / b)

2.数学模块

import math
import cmath

num = -3.99

# 2.1将浮点数转换成整数
# 1) int(浮点数)   - 直接去掉小数点和小数点后面的数
print(int(num))

# 2) math.ceil(浮点数)  - 向大取整
print(math.ceil(1.99))    # 2
print(math.ceil(1.29))    # 2
print(math.ceil(2.001))   # 3
print(math.ceil(-3.001))   # -3

# 3)math.floor(浮点数)  - 向小取整
print(math.floor(1.99))     # 1
print(math.floor(1.001))     # 1
print(math.floor(-2.999))   # -3

# 4）round(浮点数)  -   四舍五入
print(round(2.999))      # 3
print(round(2.110))      # 2
print(round(-3.001))     # -3
print(round(-3.67))      # -4


print('===================================')
# 2.2 math.fabs(数字)  - 获取数字的绝对值,结果是浮点数
print(math.fabs(-23))    # 23.0
print(math.fabs(12))     # 12.0
print(math.fabs(-23.12))  # 23.12

# abs(数字)  - 获取数字的绝对值
print(abs(-23))    # 23
print(abs(-2.3))   # 2.3