【python学习】-学习笔记.04

#python学习Tips:
##///////////PY.04：容器：字符串、列表、元组、字典///////////////////////////////////
#====================================================
# 目录：
# 一、字符串
#   1.字符串介绍
#   2.字符串输出
#   3.字符串输入
#   4.下标和切片
#   5.字符串常见操作
#   6.字符串其他操作（课外阅读）
# 二、列表
#   1.列表介绍
#   2.列表的循环遍历
#   3.列表的相关操作
#   4.列表的嵌套
# 三、元组
# 四、字典


##====================================================

##//////////////////////////////一、字符串//////////////////////////////

#==============1.字符串介绍=======================
# 1.1========字符串的表示==========
# 字符串（str）：带引号的内容就是字符串
#单引号、双引号和三引号都可以：
# 单引号：
name = 'issac'
print(type(name))
# 双引号：
name = "issac"
print(type(name),name)
# 三引号：三个单引号或者三个双引号都可以
my_str = """hello world
hello python
"""
print(type(my_str))
# 1.2========字符串乘以一个整数=======
name = 'issac'
name * 7
# 会将字符串里的内容直接拼在一起形成一个新的字符串
'hello' * 3
# 1.3========字符串的输入和输出=======
# 输入：input  input()函数得到的内容就是字符串（以字符串的方式保存）
# 输出：print  prit()函数 %s
# f-strings: f或者F都可以，可以在字符串中包含python表达式
#          使用单引号、双引号、三引号（三单或三双）都可以
# 如：
name = 'issac'
print(f'我的名字是{name}')

# 当字符串内包含引号时：
# 内含单引号，字符串就用双引号；
# 内含双引号，字符串就用单引号或者三引号；
# 内含单引号和双引号，字符串就统一使用三引号。

# 1.4========字符串的下标==========
# 下标：一种编号/索引，通过该编号能找到对应的储存空间，是整数，有正有负。
# 正数下标：python中的下标是从左往右从0开始的（第一位是0.第二位是1，以此类推……）
# 负数下标：从右往左数，依次是-1、-2、-3……
# 下标语法： 变量[下标]

# 应用场景：比如，需要取出字符串中的单个字母
my_str = 'hello'
print(my_str[2])
print(my_str[-4])
print(my_str[0])

# len()函数可以得到字符串的长度
print(len(my_str))
# 使用正数下标书写字符串中的最后一个元素：
print(my_str[len(my_str)-1])
# len()函数输出的直接是数值型，不用再加int()函数了
# 注意这种用法里的len()-1, 易错

# 1.5===========切片================
# 如果要从字符串中截取不止一个字母，下标就实现不了了，得用切片
# 切片是指对操作对象截取其中一部分的操作，字符串、列表、元组都支持切片。

# 切片的语法：[起始位下标：结束位下标：步长],切片会得到一个新的字符串
#   步长：下标之间的间隔，默认是1
# 选取的区间从“起始位”开始，到结束位的前一位结束（不包含结束位本身），步长表示选取间隔。
#   如：
my_str = 'hello'
my_str1 = my_str[2:4:1] # 输出 ll
print(my_str1)
my_str2 = my_str[1::3] # 输出 eo （这是在跳跃式输出）
print(my_str2)
my_str3 = my_str[2:]  #输出llo (后面不写表示从下标2开始截取后面所有)
print(my_str3)
# step如果是1，可以不写
# end位置不写，表示是len()，也就是字符串本身的长度,即，可以取到最后一个元素

# 起始位不写 表示0，但切片语法里面至少要包含一个冒号
my_str = 'hello'
my_str4 = my_str[:3] #输出hel
print(my_str4)
my_str5 = my_str[:] #输出hello
print(my_str5)
# 只写两个，默认不写步长：
my_str = 'hello'
my_str6 = my_str[-4:-1] #输出ell
print(my_str6)
# 如果start和end写反了，将没有数据，没有输出

# 若步长是负数，会输出字符串的逆置
print(my_str[::-1]) #输出：olleh
print(my_str[::2]) 
# 输出：hlo（从0开始，跨步长为2去取，因此取位0、2、4）
# 相当于：my_str[0:5:2]

#====常用的切片公式==========
# 1.得到和原来一样的字符串：
my_str[:]
# 2.字符串的逆置：
my_str[::-1]

# 1.6===============字符串常见的操作==================

# 查找：find / index / count

# =====1.6.1 字符串查找：find/rfind==========
# （1）find()
# find(): 在字符串中查找是否存在某个字符串
# my_str.find(sub_str, start, end)
# sub_str:要在字符串中查找的内容，类型是str
# start: 开始位置，从哪个下标开始查找，默认是0
# end: 结束的位置，查找到哪里结束，默认是len()
# 返回值：即方法执行的结果是什么，
#   若找到了sub_str,返回的是sub_str在my_str中的位置（）正数下标
#   若没找到，返回-1

# 例如：
my_str = 'hello world itcast and python'
index = my_str.find('python') # 字符串中，空格也占下标位
print(index) # 输出23
print(my_str.find('hello', 3)) # 输出-1  （从下标3开始找）
print(my_str.find('itcast')) # 输出12

# （2）rfind() : 即right find(): 从右往左寻找
# 例如：
my_str = 'hello world itcast and python'
print(my_str.rfind('itcast')) # 输出12 （输出内容与从左往右的结果相同）

# =====1.6.2 字符串查找：index==========
# index与find的用法一致，区别在于，如果没有找到，会报错
# rindex()同理，也是从右往左找
# 例子：
my_str = 'hello world itcast and python hello'
print(my_str.index('hello'))  # 0
print(my_str.index('itcast', 20)) # 输出将会报错
print(my_str.rindex('hello')) # 30

# =====1.6.3字符串查找:统计出现次数：count==========
# count: 在字符串中统计内容出现的次数
# 语法： count(sub_str, start ,end)
#  同上，只写两个，默认写了start没写end
my_str = 'hello world itcast and python hello'
print(my_str.count('hello')) # 2
print(my_str.count('and'))  #1
print(my_str.count('abcd')) # 0
print(my_str.count('l')) # 5
print(my_str.count('itcast', 20)) # 0
print(my_str.count('itcast', 9)) # 1

# =====1.6.4 字符串替换：replace==========
# my_str.replace(old_str, new_str, count):
#   old_str: 要被替换的字符
#   new_str: 要用来替换的新字符串
#   count:替换的次数，若默认，则全部替换
# 返回值：输出结果是一个新的字符串，不会返回原来的字符串
#       而原字符串储存在原变量名中没有被改变。

# 例如：
my_str = 'hello world itcast and python hello'

my_str1 = my_str.replace('itcast','ithiema')
print(my_str1)

my_str2 = my_str.replace('hello','hi') # 默认替换全部
print(my_str2)

my_str3 = my_str.replace('hello','hi', 1) # 替换1次（次数位置如何指定？默认是从左往右累计次数？）
print(my_str3)

# =======1.6.5 字符串的分隔：split与rsplit=============
# my_str.split(sub_str, count): 将内容词汇的前后切隔开，并且罗列在列表里，内容词汇被剔除。
#   将my_str字符串按照sub_str字符串进行切割
#   sub_str: 切割的内容，默认是空格和Tab键
#   count: 切割几次,默认是全部切割
#   返回值：输出的是列表[]

# 例如：
my_str = 'hello world itcast and python hello'
result = my_str.split() 
# 默认：按照空白字符全部切割：
#   则把句子切成了单个的词罗列在列表里
print(result)
print(my_str.split('itcast'))
print(my_str.split('hello',1))

# rsplit: 从右往左切：(计数也是从右往左累计)
print(my_str.rsplit('hello',1))

# ==========1.6.6 字符串的连接：join()=============
# mystr.join(可迭代对象：str/列表): 将mystr插入到str的每一个元素之间，构造出一个新的字符串
# 可迭代对象里面可以是字符串也可以是列表，若是列表/元组，需要列表中的每一个数据都是字符串类型
# 功能： 会将mystr插入到“可迭代对象”的两个元素之间

# 例：

# （1）添加元素：
mystr = '_'.join('hello') # 会把_加入到hello的每两个元素之间
print(my_str)
print('_*_'.join('hello'))

# （2）添加列表内容：
my_list = ['hello','cpp','python']
print('_'.join(my_list))

# （3）添加空格
my_list = ['hello','cpp','python']
print(' '.join(my_list))

# ==========1.7 字符串的其他方法（了解即可）=======================
# （1）.capitalize(): 将句子的首字母大写
my_str = 'hello itcast and itcastpython'
my_str.capitalize()

# (2).title(): 将句子中每个单词的首字母都大写
my_str = 'hello itcast and itcastpython'
my_str.title()
print(my_str.title())

#（3）.upper（）:将句子的所有字母都大写
my_str = 'hello itcast and itcastpython'
my_str.upper()

# (4).lower():将句子中的所有字母都小写
my_str = 'hello itcast and itcastpython'
my_str.lower()

# (5).判断是否是大小写：.islower()/.isupper()
my_str = 'hello itcast and itcastpython'
my_str.islower()
my_str.isupper()
my_str.istitle()

# (6).判断是否是固定的开头和结尾：
# .startswith():检查字符串是否以括号内的内容开头，是则True,否则False;
# .endswith():检查字符串是否以括号内的内容结尾，是则True,否则False;
my_str = 'hello itcast and itcastpython'
my_str.startswith('hell')
my_str.endswith('python')
# 注意别漏掉s

# (7)调整位置：.center()/.ljust()/.rjust()
# .center():居中显示
'hello'.center(30)
# .ljust():左对齐
'hello'.ljust(30)
# .rjust():右对齐
'hello'.rjust(30)

# (8)去除空白字符：.lstrip()/.rstrip()/.strip()
# .lstrip():去除左边的空白字符
s1 = '     hell o   '
s1.lstrip()
# .rstrip():去除右边的空白字符
s1.rstrip()
# .strip():去除两边的空白字符（但中间的空白不会去掉）
s1.strip()
# 中间的空格是去不掉的，要去掉就用替换：.replace(' ','')
s1.replace(' ','')

# (9).partition():将字符串在括号内容的前后各自切开，罗列出来
my_str = 'hello itcast and itcastpython'
my_str.partition('and')
# 输出：('hello itcast ', 'and', ' itcastpython')
# 区别于.split():切割的输出结果不包含括号内的内容（split把括号内容给剔除掉了）

s2 = 'Today is 2025.8.30'
s3 = '1982'
s4 = "OK, that's right"
s5 = 'abcde'
# (10)判断是否是纯字母：.isalpha()有空格有括号都不可以
s2.isalpha()
s3.isalpha()
s4.isalpha()
s5.isalpha()
# (11)判断是否是纯数字：.isdigit()
s2.isdigit()
s3.isdigit()
s4.isdigit()


##//////////////////////////////二、列表//////////////////////////////
# 列表是python中的一种数据类型，可以存放多个数据，列表中的数据可以是任意类型的；
# 列表list,使用[]进行定义
#==========1.定义列表==============
# （1）定义空列表：
# 方式1：
my_list = []
print(my_list,type(my_list))
# 方式2：
my_list1 = list()
print(my_list1,type(my_list1))

#（2）定义带数据的列表：元素之间使用逗号隔开
my_list2 = [1,2,'Tony','牛顿']
print(my_list2,type(my_list2))


#==========2..len():求列表的长度（列表中数据元素的个数）==============
my_list2 = [1,2,'Tony','牛顿']
num = len(my_list2)
print(num)

#==========3.列表的下标和切片操作==============
# 下标：
my_list2 = [1,2,'Tony','牛顿']
print(my_list2[1])  # 输出：2
print(my_list2[-1])  # 输出： 牛顿
# 切片：
print(my_list2[1:3])  # 输出：[2, 'Tony']

# 与字符串下标操作的区别：
# 字符串不能使用下标修改其中的数据，但列表可以（可以改为任意的类型）
my_list2 = [1,2,'Tony','牛顿']
my_list2[1] = 3.14
print(my_list2)
# 输出：[1, 3.14, 'Tony', '牛顿']
my_list2[-2] = 'Marry'
print(my_list2)

#==========4.列表的遍历:for/while==============
# for:
my_list3 = ['郭德纲','于谦','小岳岳','孙悦']
for i in my_list3:
    print(i)

# while:
j = 0 # j为下标
while j < len(my_list3):
    print(my_list3[j])
    j += 1
    
#==========5.列表的相关操作：添加数据==============
# 添加数据：append, extend, insert，+=
# 这些方法都是在原列表中添加的，不会返回新的列表


# ====(1)列表.append():向列表的尾部追加数据
# ！注意：append方法每次只能追加一个元素，不能用于多个元素的添加
my_list3 = ['郭德纲','于谦','小岳岳','孙悦']
my_list3.append('张起灵')
print(my_list3)

# 不要这样书写，会返回None:
# result = my_list3.append(12)
# print(result)
# 因为，`append()`方法是在原列表上修改，它不返回任何值（是空值，返回None）。
# 将`my_list3.append(12)`的none结果赋值给`result`，然后打印`result`，会输出None
# 除非在my_list3.append('张起灵')操作后再输出原列表print(my_list3),此时会输出修改后的原列表

# ====(2)列表.insert(下标，数据)：在指定的下标位置添加数据
my_list3 = ['郭德纲','于谦','小岳岳','孙悦']
my_list3.insert(1,'张起灵')
print(my_list3)
# 输出：['郭德纲', '张起灵', '于谦', '小岳岳', '孙悦']

# 同样，也不能这样书写，道理同上：
# result = my_list3.insert(1,'张起灵')
# print(result)
# 也不能这样写：
# print(my_list3.insert(1,'张起灵'))

# ====(3)列表.extend(可迭代对象)============
# 用于多数据添加：可将可迭代对象的数据依次添加到原列表的末尾
# 1
my_list3 = ['郭德纲','于谦','小岳岳','孙悦']
my_list3.extend(['张起灵','吴邪','王胖子'])
print(my_list3)
# 输出：['郭德纲', '于谦', '小岳岳', '孙悦', '张起灵', '吴邪', '王胖子']
my_list3 = ['郭德纲','于谦','小岳岳','孙悦']

# 2
my_list3.extend('Marry') # 拆成单个字母再分别添加
print(my_list3) 
# 输出：['郭德纲', '于谦', '小岳岳', '孙悦', 'M', 'a', 'r', 'r', 'y']

# 3
my_list3 = ['郭德纲','于谦','小岳岳','孙悦']
my_list3.extend('张起灵 吴邪 王胖子') # 拆成单字和空格，再分别添加
print(my_list3) 
# 输出：['郭德纲', '于谦', '小岳岳', '孙悦', '张', '起', '灵', ' ', '吴', '邪', ' ', '王', '胖', '子']

# 综上，extend()里面写单个元素作用是极度有限的，
# 最好直接使用列表形式添加，才能达到目的。

# ====(4)用+=号添加元素====================
# 源列表 += [新列表/可迭代对象]：加到原列表的尾部，作用相当于extend
# 1
my_list = [1, 2, 3]
my_list += [4, 5]  # 相当于 my_list.extend([4, 5])
print(my_list)     # 输出: [1, 2, 3, 4, 5]
# 2
my_list3 = ['郭德纲','于谦','小岳岳','孙悦']
my_list3 += ['张起灵','吴邪','王胖子']
print(my_list3)
# 输出：['郭德纲', '于谦', '小岳岳', '孙悦', '张起灵', '吴邪', '王胖子']
# 3
my_list3 = ['郭德纲','于谦','小岳岳','孙悦']
my_list3 += ['Marry']
print(my_list3)
# 输出：['郭德纲', '于谦', '小岳岳', '孙悦', 'Marry']

#==========6.列表的数据查询========================
# index; count; in/not in

# ====（1） index():查找下标==========
# 根据数据值，查找元素所在的下标，并返回下标，没找到会报错
my_list4 = ['张起灵','吴邪','王胖子']
num = my_list4.index('吴邪')
print(num)   # 输出：1

num1= my_list4.index('三叔')
print(num1)
# 输出：ValueError: '三叔' is not in list

# ====（2）count():统计内容出现的次数=======
num2 = my_list4.count('吴邪')
print(num2)  # 输出：1

my_list = ['吴三省','吴邪','解雨臣',3.14,1,True]
my_listt = ['吴三省','吴邪','解雨臣',3.14,1,False]
num3 = my_list.count(1)
num4 = my_listt.count(1) 
print(num3)  # 输出：2（因为True也被算作了1）
print(num4)  # 输出：1（False不会被被算作1）

# ====（3）in / not in:判断内容是否存在（True/False）=======
# 一般和if结合使用
my_list = ['吴三省','吴邪','解雨臣',3.14,1,True]
num5 = 3.14 in my_list # 将判断结果（bool类型）赋值给num5
print(num5)  # 输出:True


#==========7.列表的内容删除: remove/pop/del========================
# 两类：根据数据值内容删除/根据元素的下标删除


# ====(1)根据内容删除：.remove()==========
# 注意：也是直接在原来的列表上删除，不能用赋值打印的写法
# 如果要删除的数据不存在，程序会报错
my_list = ['吴三省','吴邪','解雨臣',3.14,1,True]
my_list.remove('吴三省')
print(my_list)
# 输出：['吴邪', '解雨臣', 3.14, 1, True]

# ====(2)根据下标删除（弹出）：.pop(下标)==========
# .pop(下标)：若不写下标，则默认删除最后一个数据
# .pop()会返回删除的内容，所以可以直接用那种写法,但是会输出删掉的那个数据
my_list = ['吴三省','吴邪','解雨臣',3.14,1,True]
num6 = my_list.pop(3)
print(num6)   # 输出：3
print(my_list)
# 输出：['吴三省', '吴邪', '解雨臣', 1, True]

# ====(3)根据下标删除：del 列表[下标]==========
my_list = ['吴三省','吴邪','解雨臣',3.14,1,True]
del my_list[2]
print(my_list)

#==========8.列表的排序和逆置========================
# 列表排序：排序的前提是--列表中的数据类型是一样的（这样才有比较的基础和排序的依据）
# 排序语法：列表.sort():直接在原列表中进行排序（默认升序）
#           列表.sort(reverse=True):降序排列
my_list = [1,9,8,3,4,6]
my_list.sort(reverse=True)
print(my_list)
# 输出：[9, 8, 6, 4, 3, 1]

# 补充：sorted(列表)：不会在原来的列表中排序，而是会得到一个新的列表
my_list = [1,9,8,3,4,6]
my_list1 = sorted(my_list)  #升序排列
my_list2 = sorted(my_list,reverse=True) # 指定降序
print(my_list)   # 原列表没变
print(my_list1)  # 升序排列
print(my_list2)  #降序排列

print('*'*30)

# 让列表逆置（得到新的列表）：
my_list3 = ['a','b','c','d']
my_list4 = my_list3[::-1]
print(my_list4)   # 输出：['d', 'c', 'b', 'a']

# 在原列表中直接逆置： 列表.reverse
my_list3 = ['a','b','c','d']
my_list3.reverse()  # 注意别漏了这个括号
print(my_list3)

#==========9.列表的嵌套========================
# 列表的嵌套：列表中的内容也还是列表

### 比如 二维列表的查找：
character_names = [['吴邪','王胖子','张起灵'],['解雨臣','黑瞎子'],['吴三省']]
print(character_names[1])
# 输出：['解雨臣', '黑瞎子']
print(character_names[1][1])
# 输出：黑瞎子
print(character_names[1][1][1])
# 输出：瞎

# 想要输出 张起灵：
print(character_names[0][2])

### 二维列表的遍历：
for character in character_names:
    for name in character:
        print(name)
# # 输出：
# 吴邪
# 王胖子
# 张起灵
# 解雨臣
# 黑瞎子
# 吴三省
# ==================================================
# =============10.列表的应用练习题====================
# 题目：一个学校，有3个办公室，现在有8位老师等待工位的分配，请编写程序，完成随机的分配。
# 提示：引入random函数；老师用字母A到H来代替。
# 对主体遍历，产生范围内的随机数，即可完成分配。
# 答案：
import random

teachers = ['A','B','C','D','E','F','G','H']
offices = [[],[],[]]  # 定义一个列表，用来储存八位老师的名字

for teacher in teachers:
    index = random.randint(0,2)
    offices[index].append(teacher)
    
print(offices)
# 输出结果示例：
# [['A', 'C'], ['B', 'G'], ['D', 'E', 'F', 'H']]
# 更完整的输出：
for i in offices:
    print(f'该办公室老师的个数为{len(i)},他们分别是：{i}')
    
##//////////////////////////////三、元组//////////////////////////////
# 元组(tuple)和列表(list)非常类似，都可以存放多种不同的类型的数据；
# 但元组中的元素不能修改（没有增、删、改的操作，只能查询）；
# 列表使用中括号，元组使用小括号

my_list = [2025,3.14,True,'issac'] # 列表
my_tuple = (2025,3.14,True,'issac') # 元组
print(my_tuple,type(my_tuple))
print(my_list,type(my_list))

# ====1.元组支持下标和切片操作======================
my_tuple = (2025,3.14,True,'issac') 
print(my_tuple[1])  # 3.14

# ====2.定义元组====================================
# 2.1定义一个空元组（没有意义，因为不能修改）

# 方式1：
my_tuple1 = ()
# 方式2：
my_tuple2 = tuple()

# 2.2定义只含有一个数据元素的元组（一定记得加逗号！！）
my_tuple3 = (3)
print(my_tuple3,type(my_tuple3))
# 输出：3 <class 'int'>
# 这是int类型，而非元组，单元素元组定义要加逗号！！
my_tuple4 = (3,)
print(my_tuple4,type(my_tuple4))
# 输出：(3,) <class 'tuple'>


##////////////////////////////四、字典//////////////////////////////
# 字典(dict)：一种数据类型，用大括号定义, 由键值对组成
# {'key1':'value1','key2':'value2'}
# 一个键值对作为一个整体算一个元素
# 字典中的key可以是字符串类型或者数值类型（int/float）,不能是列表
# 而value可以是任何类型

# ====1.定义空字典：===============
my_dict = {}
my_dict1 = dict()
print(my_dict,type(my_dict))
print(my_dict1,type(my_dict1))
# 输出： {} <class 'dict'>
#       {} <class 'dict'>

# ====2.定义非空字典：================
my_dict2 = {'name':'issac','age':'18','like':['学习','购物','游戏']}
print(my_dict2)

# ====3.访问value值(2种方法)：==============

# 方式1：print(字典[key值]):
# 在字典中没有下标的概念，而是使用key值的内容来访问value值
# 18
print(my_dict2['age'])
print(my_dict2['like'][2])  # 输出：游戏
# 如果key值不存在，访问会报错：keyerror
print(my_dict2['gender'])
# 输出：KeyError: 'gender'

# 方式2：print(字典.get(key)):
print(my_dict2.get('gender'))
# 若不存在，会输出none

# 方式3：print(字典.get(key,数据值)):
#  这种，如果key存在，返回key的value值；如果key不存在，则返回书写的数据值
print(my_dict2.get('gender','男'))  # 男
print(my_dict2.get('age',1))  # 18

# ====4.字典的添加和修改数据================
# 字典中添加和修改数据，需要使用key值进行操作
# 语法：字典[key] = 数据值
# 若key值存在，就是修改；不存在，则是添加


my_dict = {'name':'issac','age':'18','like':['学习','购物','游戏']}
my_dict['gender'] = '男'  # key值不存在，添加
my_dict['age'] = '19'    # key值存在，修改
print(my_dict)
# 输出：
# {'name': 'issac', 'age': '19', 'like': ['学习', '购物', '游戏'], 'gender': '男'}

# ！！！注意：
#  在字典中，key值int的1 等价于 float的1.0（代表一个键值）
#  而在其他情况下，一般不是这样

# ====5.字典的删除数据（3种方法：deleat\pop\clear）================

#====方式1：根据key值删除数据：del 字典名[key]=======
# 在原字典中修改
my_dict = {'name':'issac','age':'18','like':['学习','购物','游戏']}
del my_dict['age']
print(my_dict)

#====注：del 字典名==========================
# 这样直接将字典给删除了，就不能再使用了，否则报错

#====方式2：pop弹出：字典名.pop[key]=================
my_dict = {'name':'issac','age':'18','like':['学习','购物','游戏']}
result = my_dict.pop('age')
print(my_dict)  # 输出：{'name': 'issac', 'like': ['学习', '购物', '游戏']}
print(result)  # 输出：18  （.pop输出的都是弹出的内容）


#====方式3：clear清空字典（删除掉字典中所有的键值对）==========
#语法：字典名.clear()
my_dict = {'name':'issac','age':'18','like':['学习','购物','游戏']}
my_dict.clear()
print(my_dict)  # 输出：{}



# ====6.字典的遍历（for/while）===========================
my_dict = {'name':'issac','age':'18','like':['学习','购物','游戏']}

# （1）for循环直接遍历字典:遍历的对象是字典中的key值
for i in my_dict:
    print(i,my_dict[i])
# # 输出：
# name issac
# age 18
# like ['学习', '购物', '游戏']


# （2）字典.keys():获取字典中所有的key值，得到的类型是dict_keys;
#  该类型的特征：
#   1.可以使用list()进行类型转换，转换为列表类型
#   2.可以使用for循环遍历（因为是可迭代类型）
result = my_dict.keys()
print(result,type(result))
for key in result:
    print(key)
# 输出：
# dict_keys(['name', 'age', 'like']) <class 'dict_keys'>
# name
# age
# like

# （3）字典.values():获取所有的value值，类型是dict_values
#  该类型的特征(同上)：
#   1.可以使用list()进行类型转换，转换为列表类型
#   2.可以使用for循环遍历（因为是可迭代类型）
for value in my_dict.values():
    print(value)
# 输出：
# issac
# 18
# ['学习', '购物', '游戏']

# （4）字典.items():获取所有的键值对，类型是dict_items
#  该类型的特征(同上)：
#   1.可以使用list()进行类型转换，转换为列表类型
#   2.可以使用for循环遍历（因为是可迭代类型）
result = my_dict.items()
print(result,type(result))
for i in my_dict.items():
    print(i[0],i[1])
# # 输出：
# name issac
# age 18
# like ['学习', '购物', '游戏']

for k,v in my_dict.items(): # k是元组中的第一个数据，v是第二个
    print(k,v)
# 输出：
# name issac
# age 18
# like ['学习', '购物', '游戏']

###///这个就是拆包，将容器中的数据分别给不同的变量，直接把第一、二个数据分开来了

【说明】：这是b站【黑马程序员Python小白基础入门教程 Python入门到精通教程】的跟学笔记，笔记内容均来自于该课程，并非本人原创，另外附上个人的代码解释和少部分的个人练习代码（已在代码中标明）。欢迎参考学习！！   【 如涉及侵权，请联系我删除！】

【内容来源b站课程链接】：
http://【黑马程序员Python小白基础入门教程 Python入门到精通教程】 https://www.bilibili.com/video/BV1Az4y1S7oK/?p=44&share_source=copy_web&vd_source=aa39275a0dee0301507951d7e95177c6