python基础知识分享03-容器类型介绍2

• 元组详解
• 字典详解**(重点)**
• 集合简介
• 函数入门
  • 相关概述
  • 格式
  • 形参和实参区别

---

1.元组详解

"""
元组介绍:
    概述:
        和列表一样, 元组也属于容器类型的一种, 元组用tuple表示, 它属于 不可变类型.
    格式:
        t1 = (值1, 值2, 值3...)
        t2 = tuple()
        t3 = (值1, )         如果元组就1个值, 则该值后要加逗号隔开.
    元组的相关操作:
        元组名[索引]         根据索引, 获取其对应的值.
        index()            获取指定元素在元组中第一次出现的位置, 找不到就报错
        count()            统计指定元素在元组中出现的次数.
        len()              元组的长度, 即: 元素个数
"""
# 1. 定义元组.
t1 = (10, 20, 30)       # <class 'tuple'>
t2 = tuple()            # <class 'tuple'>
t3 = (10, )             # <class 'tuple'>
t4 = ()                 # <class 'tuple'>
t5 = (10)               # <class 'int'>

# 2. 打印元素类型.
print(type(t1))
print(type(t2))
print(type(t3))
print(type(t4))
print(type(t5))
print('-' * 31)

# 3. 尝试修改元组的内容.
# t1[0] = 100       报错, 元组值不允许修改, 所以 元组是不可变类型.

# 4. 测试元组的相关函数
t1 = (10, 20, 30, 'abc', True, 20, False, 20, 10.3)
# 演示 元组名[索引]         根据索引, 获取其对应的值.
print(t1[3])      # 'abc'
print(t1[-6])     # 'abc'

# 演示 index()            获取指定元素在元组中第一次出现的位置, 找不到就报错
print(t1.index(20))     # 1
# print(t1.index(200))    # 找不到, 报错.

# 演示 count()            统计指定元素在元组中出现的次数.
print(t1.count(20))     # 3

# 演示 len()              元组的长度, 即: 元素个数
print(len(t1))
print('-' * 31)

print(10 in t1)      # True
print(100 in t1)     # False
print('-' * 31)

# 5. 思考, 如下的代码, 怎么解释?
t1 = (10, 20, 30, ['a', 'b'])
print(t1[3][0])     # 修改前: 'a'

t1[3][0] = 'xyz'    # 元组嵌套列表, 则列表的地址值不能改变, 但是列表的元素值是可以变化的.

print(t1[3][0])     # 修改后: 'xyz'

2.案例-幸运数字

# 输入任意数字, 生成nums列表, 元素值为 1 ~ 输入的任意数字. 然后从中选取幸运数字(即: 能被6整数的数字)
# 把幸运数字移动到新列表 lucky中, 打印 nums 和 lucky列表.

# 1. 提示用户键盘录入1个整数, 并接收.
n = eval(input('请录入任意的1个整数: '))     # 假设是: 8

# 2. 定义nums列表, 用于记录: 1 ~ 用户输入的任意数字 区间内所有的整数.
# 方式1: for循环版.
# nums = []       # 1 ~ 8
# for i in range(1, n + 1):
#     nums.append(i)

# 方式2: 列表推导式(后续讲解)
# nums = [i for i in range(1, n + 1)]     # 效果同上.

# 方式3: 类型转换.
nums = list(range(1, n + 1))

# 3. 定义lucky列表, 记录幸运数字(即: 能被6整数的数字)
lucky = []

# 4. 遍历nums列表, 获取到每一个元素值.
for n in nums:
    # n就是 nums列表中的每个数字, 例如: 1, 2, 3, 4, 5, 6...
    # 5. 判断n是否是幸运数字.
    if n % 6 == 0:
        # 走到这里, 说明n是幸运数字(能被6整除)
        # 6. 把该数字添加到lucky列表中, 并从nums列表删除该元素.
        lucky.append(n)
        nums.remove(n)      # remove(): 根据元素内容删除.

# 打印最终结果.
print(f'nums列表的元素值为: {nums}')
print(f'lucky列表的元素值为: {lucky}')

3.案例-排列组合

"""
需求:
    问1, 2, 3, 4这四个数字能组合成的四位数有多少种情况, 并将结果打印到控制台上, 按照3个一行的方式进行输出.
要求:
    1. 该四位数必须同时包含1, 2, 3, 4, 即: 1234可以, 1122不行.
    2. 数字1 和 3不能挨着, 即: 1324, 3124都不行.
    3. 数字4不能开头.

核心思想:
    你可以用排列组合的方式做, 也可以用数学思维做, 这里我用的是最简单的思维: 面向对象思维.
    即: 把数字转成字符串, 然后调用字符串中自带的函数即可.

举例:
    数字1234 => 字符串 '1234', 就可以使用 字符串的函数了.

本题涉及到的字符串函数:
    __contains__()      判断字符串中是否包含指定内容.
    startswith()        判断字符串是否以指定内容开头.
    endswith()          判断字符串是否以指定内容结尾.
"""
# 1. 定义计数器.
count = 0

# 2. 通过for循环, 获取到所有的四位数.
for i in range(1000, 10000):
    # 3. 核心思维: 把数字转成字符串
    s = str(i)      # 例如: '1000', '1122', '1234'
    # 4. 直接判断是否合法, 合法打印即可.
    # if s.__contains__("1") and s.__contains__("2") and s.__contains__("3") and s.__contains__("4") and not s.__contains__("13") and not s.__contains__("31") and not s.startswith("4"):
    if "1" in s and "2" in s and "3" in s and "4" in s and "13" not in s and "31" not in s and s[0] != '4':
        count += 1
        print(i, end='\n' if count % 3 == 0 else '\t')

4.字典入门

"""
字典入门:
    概述:
        它属于容器类型的一种, 用dict表示, 存储的是键值对元素.
    特点:
        键具有唯一性, 值可以重复.
    格式:
        d1 = dict()
        d1 = {}
        d3 = {键:值, 键:值, 键:值, ...}
    细节:
        1. 字典中是没有索引的概念的, 只能通过 键 获取 其对应的值.
        2. 键具有唯一性, 所以它可以是 单值类型的 int, float, bool, 容器类型的(不可变类型): 字符串, 元组, 不能是列表, 因为列表是可变类型.
"""
# 1. 演示字典的定义.
d1 = dict()
d2 = {}
d3 = {10:'a', 10.3:True, False:'a', 'name':'乔峰', (10, 20):[1, 2, 3]}        # [1, 2]:'abc' 不支持的键值对.

# 2. 打印数据类型.
print(type(d1))
print(type(d2))
print(type(d3))

# 3. 打印集合.
print(d1)
print(d2)
print(d3)

5.字典-增删改操作

"""
字典增删改操作介绍:
    增 和 改:
        字典名[键] = 值    键不存在就是添加, 存在就是修改.
    删:
        pop()
        clear()
        del()
"""

# 1. 定义字典.
d1 = {'name':'段誉', 'age':23, 'wife':['穆婉清', '钟灵儿', '王语嫣']}

# 2. 演示添加元素.
d1['address'] = '大理'    # 键不存在, 就是添加.

# 3. 演示修改元素.
d1['age'] = 18           # 键存在, 就是修改.

# 4. 演示删除元素.
# print(d1.pop('name'))       # 段誉, 根据键, 删除该键值对, 并返回删除前的值.
# print(d1.pop('phone'))        # 如果键不存在, 就报错.

# del d1['name']                # 根据键, 删除该键值对
# del d1                      # 从内存中注销.

d1.clear()              # 清空所有元素

# 5. 打印字典.
print(d1)

6.字典-查

"""
字典 查询 相关操作:
    get(key, 默认值)      根据键获取其对应的值, 如果键不存在就返回默认值, 默认值不写默认是None
    keys()               获取所有 键 的集合.
    values()             获取所有 值 的集合.
    items()              获取所有 键值对 的集合.   把键和值封装到元组中, 再把所有的元组放到列表中.
"""

# 1. 定义字典.
d1 = {'name':'张三', 'age':23, 'address':'北京'}

# 2. 演示字典的获取功能
# 演示 get(key, 默认值)      根据键获取其对应的值, 如果键不存在就返回默认值, 默认值不写默认是None
print(d1.get('name'))       # 张三
print(d1.get('phone', 10))  # 10
print(d1.get('phone'))      # None
print('-' * 31)

# 上述格式的相似写法, 字典名[键]  也可以实现根据键获取其对应的值.
print(d1['name'])           # 张三
# print(d1['phone'])          # 键不存在就报错.
print('-' * 31)

# 演示 keys()               获取所有 键 的集合.
result = d1.keys()
print(result)               # dict_keys(['name', 'age', 'address'])
print(type(result))         # <class 'dict_keys'>
print('-' * 31)

# 演示 values()             获取所有 值 的集合.
result2 = d1.values()
print(result2)               # dict_values(['张三', 23, '北京'])
print(type(result2))         # <class 'dict_values'>
print('-' * 31)

# 演示 items()              获取所有 键值对 的集合.   把键和值封装到元组中, 再把所有的元组放到列表中.
result3 = d1.items()
print(result3)               # dict_items([('name', '张三'), ('age', 23), ('address', '北京')])
print(type(result3))         # <class 'dict_items'>

7.字典-遍历

"""
字典遍历:
    思路1: 根据键获取其对应的值.
        大白话: 根据丈夫找妻子.

    思路2: 根据键值对获取其对应的键和值.
        大白话: 根据结婚证找丈夫和妻子.
"""

# 1. 定义字典.
d1 = {'name':'张三', 'age':23, 'address':'北京'}

# 2. 演示 keys()方法, 遍历, 获取到每个键.
# print(d1.keys())
for key in d1.keys():
    print(key)      # 字典中的每个键.
print('-' * 31)


# 3. 演示 values()方法, 遍历, 获取到每个值.
for value in d1.values():
    print(value)    # 字典中的每个值
print('-' * 31)

# 4. 演示 items()方法, 遍历, 获取到每个键值对.
for item in d1.items():
    print(item)     # 字典中的每个键值对
print('-' * 31)

# 5. 遍历字典.
# 思路1: 根据键获取其对应的值.
for key in d1.keys():
    # 根据键获取其对应的值.
    # value = d1.get(key)
    value = d1[key]
    print(key, '=', value)

print('-' * 31)

# 思路2: 根据键值对获取其对应的键和值.
for item in d1.items():
    print(item[0], '=', item[1])     # 字典中的每个键值对
print('-' * 31)

# 上述格式的简化版, 拆包.
# list1 = [10, 20]       # 组包, 把多个值赋值给1个变量.
# a, b = list1           # 拆包, 把1个容器类型的多个值, 分别赋值给多个变量.
for k, v in d1.items():
    print(k, '=', v)     # 字典中的每个键值对
print('-' * 31)

8.集合-入门

"""
集合入门:
    概述:
        它也属于容器类型的一种, 用 set 表示.
    元素特点是:
        无序(元素的存取顺序不一致), 唯一
    定义格式:
        set1 = {10, 20, 30}
        set2 = set()
    常用操作:
        去重.

    回顾容器类型的一些写法:
        s1 = "abc"
        list1 = [1, 2, 3]
        tuple1 = (1, 2, 3)
        set1 = {1, 2, 3}
        dict1 = {'name':'张三', 'age':23}
"""

# 1. 定义集合.
set1 = {10, 20, 30, 'a', 20, 'a', '10'}
set2 = set()
set3 = {}       # 这个是创建字典, 不是创建集合.

# 2. 打印变量类型.
print(type(set1))   # <class 'set'>
print(type(set2))   # <class 'set'>
print(type(set3))   # <class 'dict'>

# 3. 打印集合.
print(set1) # {10, 'a', '10', 20, 30}  无序, 唯一.
print(set2) # set()
print(set3) # {}
print('-' * 31)

# 4. 集合不支持索引写法
# print(set1[0])  # 报错

# 5. 演示实际开发中, 集合的作用, 去重.
# 需求: 对如下列表中的元素进行去重操作.
list1 = [10, 20, 30, 20, 10, 50, 'a', 'b', 'a']

# 思路1: 搞1个新的列表, 然后遍历上述列表, 逐个获取每个元素, 然后判断是否不存在于新列表, 满足就添加.
# 自己写.

# 思路2: 结合set集合实现.
# 流程为: list => set => 清空原始list列表 => 把set元素添加到list中.
set1 = set(list1)
list1.clear()
list1.extend(set1)      # 不想这样写, 就写: list1 = list(set1)
print(list1)

9.案例-统计字符次数

# 需求: 键盘录入1个字符串, 并接收, 统计其中每个字符出现的次数, 并按照格式将结果打印到控制台上.
# 例如: 录入 aabbbccccAA, 结果为: a(2)b(3)c(4)A(2)  顺序可以不是这个.

# 1. 键盘录入1个字符串, 并接收.
s = input('请录入1个字符串, 我来统计每个字符出现的次数: ')      # 例如: 'aabbbccccAA'

# 2. 创建字典, 用于记录字符及其出现的次数, 其中: 字符(串)做键, 其出现的次数做值, 例如:  a : 2
word_count = {}

# 3. 遍历上述的字符串, 获取到每个字符(其实就是字典的键)
for key in s:   # key的值是: 'a', 'a', 'b, 'b'...
    # 4. 判断该字符(键)在字典中是否存在.
    # if key in word_count:
    #     # 5. 核心细节1: 如果存在, 就将其值(目前的次数) + 1, 然后重新存储.  即: a:2 ==> a:3
    #     word_count[key] = word_count[key] + 1
    # else:
    #     # 6. 核心细节2: 如果不存在, 就将其值记录为 1, 例如: b:1
    #     word_count[key] = 1

    # 优化版, 上述写法用 三元表达式改造.
    word_count[key] = word_count[key] + 1 if key in word_count else 1

# 7. 打印结果.
for k, v in word_count.items():
    print(f'{k}({v})', end='')
# 8. 记得换行.
print()

10.公共的运算符

"""
公共运算符介绍
    概述:
        就是用来操作容器类型的一些符号, 大多数的容器类型基本上都支持.
    公共运算符分类:
        +           合并(拼接), 支持: 字符串, 列表, 元组.
        *           复制, 支持: 字符串, 列表, 元组.
        in          是否包含, 支持: 字符串, 列表, 元组, 字典, 集合
        not in      是否不包含, 支持: 字符串, 列表, 元组, 字典, 集合
"""
# 1. 演示 +           合并(拼接), 支持: 字符串, 列表, 元组.
print('a' + 'b')                    # 'ab'
print([1, 2, 3] + [10.3, False])    # [1, 2, 3, 10.3, False]
print((11, 22) + (10, 20, 30))      # (11, 22, 10, 20, 30)
# print({1, 2, 3} + {10, 20})       # 报错, 因为set元素内容不能修改.
print('-' * 31)

# 2. 演示 *           复制, 支持: 字符串, 列表, 元组.
print('abc' * 3)
print([1, 2, 3] * 2)
print((11, 22, 33) * 3)
# print({11, 22, 33} * 3)   # 报错, 集合元素具有唯一性, 不支持复制操作, 无意义.
print('-' * 31)

# 3. 演示 in          是否包含, 支持: 字符串, 列表, 元组, 字典, 集合
print('a' in 'abc')         # True
print(10 in [10, 20, 30])   # True
print(20 in (10, 20, 30))   # True
print(20 in {10, 20, 30})   # True
print('name' in {'name':'张三', 'age': 23})   # True
print('-' * 31)

# 4. 演示 not in      是否不包含, 支持: 字符串, 列表, 元组, 字典
print('a' not in 'abc')         # False
print(10 not in [10, 20, 30])   # False
print(20 not in (10, 20, 30))   # False
print(20 not in {10, 20, 30})   # False
print('name' not in {'name':'张三', 'age': 23})   # False

11.公共的函数

"""
公共函数介绍
    概述:
        就是用来操作容器类型的一些函数, 大多数的容器类型基本上都支持.
    公共函数分类:
        len()    获取长度
        del     删除元素
        max()   获取最大值
        min()   获取最小值
        range() 生成范围内的数据
        enumerate() 生成元组, 即: (下标, 元素)
"""
# 1. 演示 len()    获取长度
list1 = [1, 2, 3]
print(len(list1))       # 3

print(len({10, 20, 30, 40, 50}))    # 5
print('-' * 31)

# 2. 演示 del     删除元素
# del list1[0]    # 删除列表list1的索引为0的元素.
# del(list1[0])     # 效果同上.
# del list1           # 从内存中删除list1变量, 相当于没有定义该变量.
#
# print(list1)

# 3. 演示 max()   获取最大值
print(max(['10', '20', '30']))      # 30
print(max(['乔峰', '虚竹', '段誉']))  # 虚竹
print('-' * 31)

# 4. 演示 min()   获取最小值
print(min(['10', '20', '30']))      # 10
print(min(['饿饕餮', '慕容复', '最最', '随便']))  # 虚竹

# 5. 演示 range() 生成范围内的数据
print(list(range(1, 10, 3)))  # 1, 4, 7
print('-' * 31)

# 6. 演示 enumerate() 生成元组, 即: (下标, 元素)
list1 = [10, 20, 30]
# for i in enumerate(list1):      # 下标默认从0开始.
#     print(i)    # 格式为: (下标, 元素), 例如: (0, 10), (1, 20), (2, 30)

for i in enumerate(list1, 5):        # 可以指定起始下标.
    print(i)    # 格式为: (下标, 元素), 例如: (5, 10), (6, 20), (7, 30)

12.推导式

"""
推导式介绍:
    概述:
        推导式也叫解析式, 是通过简单的代码, 完成相对较复杂的生成数据的动作.
        即: 根据一个数据列表 来生成 另一个数据列表.
    好处/作用:
        简单代码.
    格式:
        列表 = [变量名 for 变量名 in 容器类型 if 判断条件...]
        集合/字典 = {变量名...}
    分类:
        列表推导式
        集合推导式
        字典推导式
"""
# 需求1: 生成 0 ~ 9的列表.
# 思路1: 不使用推导式.
list1 = []
for i in range(10):  # 不写起始索引, 默认是: 0     不写步长, 默认是 1    包左不包右.
    list1.append(i)
print(list1)        # 打印列表
print('-' * 31)

# 思路2: 使用列表推导式
list2 = [i for i in range(10)]  # 效果同上.
print(list2)
print('-' * 31)

# 需求2: 生成 0 ~ 9的偶数列表.
# 思路1: for + if判断
list3 = [i for i in range(10) if i % 2 == 0]
print(list3)
print('-' * 31)

# 思路2: 合理运用range()函数的步长.
list4 = [i for i in range(0, 10, 2)]
print(list4)
print('-' * 31)


# 需求3: 列表推导式, for循环嵌套. 即: i = 1, 2   j = 0, 1, 2
# for循环嵌套.
for i in range(1, 3):
    for j in range(3):
        print((i, j))
print('-' * 31)

# 列表推导式写法.
list5 = [(i, j) for i in range(1, 3) for j in range(3)]  # 效果类似于上边, 只不过上边没有把元组加到集合中.
print(list5)
print('-' * 31)



# 需求4: 集合推导式.  格式和列表推导式几乎一致, 把[] 换成 {}就行了.
list1 = [1, 2, 3]
# 生成1个集合, 它的元素值为: 列表元素值的平方, 即: {1, 4, 9}
set1 = {i ** 2 for i in list1}
print(set1)
print('-' * 31)


# 需求5: 创建1个字典, 键是:1~5的数字, 值是该数字的平方, 例如: 1:1, 2:4, 3:9, 4:16, 5:25
dict1 = {i: i ** 2 for i in range(1, 6)}    # 字典的键和值之间, 用冒号:隔开.
print(dict1)
print('-' * 31)

# 需求6: 将两个列表合并为1个字典.
list1 = ['乔峰', '虚竹', '段誉']
list2 = ['阿朱', '梦姑', '王语嫣']

#                               i的值:  10, 1, 2
dict2 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict2)