字符串，列表，元组，及综合训练

一、字符串

1、定义

带引号的内容就是字符串.

在 python 中,字符串可以乘上一个整数, 
字符串 * num

# 单引号
name = "isaac"
print(type(name),name)
# 双引号
name = "isaac"
print(type(name),name)

# 三引号
my_str = """hello world
              hello python!
"""
print(type(my_str),my_str)  # <class 'str'> hello world
                            #               hello python!

my_str = '''aaa 
bbb'''
print(type(my_str),my_str)

# 如果字符串本身包含单引号，使用双引号定义，
# 如果包含双引号可以使用单引号定义，或者统一使用三引号
# my name is 'isaac'
my_name = "my name is 'isaac'"
print(my_name)  # my name is 'isaac'

在Python中单引号和双引号的作用相同

 2、下标

支持正反下标

# 下标也称为是索引，是一个整型数字，可以是正数，也可以是负数
# 正数下标是从0开始的，表示第一个字符，
# -1表示最后一个字符，倒着往前走，从后往前分别是：-1，-2,-3，-4，-5

my_str = "hello"
# 下标的使用语法：  变量[下标]
print(my_str[0])  # h
print(my_str[1])  # e

print(my_str[-1])  # 0
print(my_str[-3])  # l


# len() 函数可以得到字符串的长度
print(len(my_str))
# 使用正数下标书写字符串中的最后一个元素
print(my_str[len(my_str)-1])

 3、切片

# 切片可以获取一段数据，多个数据，下标（索引只能获得一个数据）
# 切片语法：变量[start:end:step]，会得到一个新的字符串
# start 开始位置的下标
# end 结束位置的下标，不包含end 对应的下标
# step 步长，下标之间的间隔，默认为1、

my_str = "hello"
my_str1 = my_str[2:4:1]  # ll  只会打出第二和三位置的字
print(my_str1)
# step 如果是1，即默认值，可以不写
my_str2 = my_str[2:4]
print(my_str2)  # ll

# end a位置不写。表示len(),即可以取到最后一个元素
my_str3 = my_str[2:]
print(my_str3)  # llo  因为len的长度大于索引的最大值（最后一个元素索引）
# start 位置也可以不写，表示是0
my_str4 = my_str[:3]

# start 和 end 都不写，但是冒号需要写
my_str5 = my_str[:]
print(my_str5)  # hello

print(my_str[-4:-1])  # ell
print(my_str[3:1],"1")  # 没有数据
# 步长可以是负数
print(my_str[3:1:-1],"2")  # ll 2

print(my_str[::-1],)  # 逆序打印 olleh

print(my_str[::-2])  # 0 2 4 hel  my_str[0:5:2]

 4、字符串查找的相关方法

''' find() 在字符串中查找是否存在某个字符串

my_str.find(sub_str, start, end) sub_str: 要在字符串中查找的内容，，类型str

start：开始的位置，从哪开始找，默认是0

end ：结束的位置，默认是len()

返回值：即方法执行的结果是什么，如果找到sub_str，返回sub_str，在my_str中的位置的正数下标 如果找不到的话，就返回-1 '''

也支持rfind方法，反向寻找

''' index() 在字符串中查找是否存在某个字符串

my_str.index(sub_str, start, end) sub_str: 要在字符串中查找的内容，

，类型str start：开始的位置，从哪开始找，默认是0

end ：结束的位置，默认是len()

返回值：即方法执行的结果是什么，如果找到sub_str，返回sub_str，在my_str中的位置的正数下标 如果找不到的话，就报错（这里就是index和find之间最大的差距） '''

还支持rindex ：反向寻找，从最右边开始找

 count：统计出现的次数

my_str = "hello world itcast and itcastcop"

'''
find() 在字符串中查找是否存在某个字符串
my_str.find(sub_str, start, end)
sub_str: 要在字符串中查找的内容，，类型str
start：开始的位置，从哪开始找，默认是0
end ：结束的位置，默认是len()
返回值：即方法执行的结果是什么，如果找到sub_str，返回sub_str，在my_str中的位置的正数下标
如果找不到的话，就返回-1
'''

index = my_str.find("hello")  # 0
print(index)

# 从瞎比哦啊为3的位置开始查找字符串hello
print(my_str.find("hello", 3))  # -1 说明没找到
print(my_str.find("itcast", ))  # 12 说明没找到
print(my_str.find("itcast", 15))  # 23 说明没找到

# rfind()   right find()  从右边（后边）开始查找
print(my_str.rfind("itcast"))  # 23


'''
index() 在字符串中查找是否存在某个字符串
my_str.index(sub_str, start, end)
sub_str: 要在字符串中查找的内容，，类型str
start：开始的位置，从哪开始找，默认是0
end ：结束的位置，默认是len()
返回值：即方法执行的结果是什么，如果找到sub_str，返回sub_str，在my_str中的位置的正数下标
如果找不到的话，就报错（这里就是index和find之间最大的差距）
'''

print(my_str.index("hello"))  # 0

# print(my_str.index("hello",3))  # 没有找到的话，代码会报错

# rindex()  从后边往前面找
print(my_str.rindex("itcast"))  # 23
print(my_str.index("itcast"))  # 12

# count(sub_str,start,end) 统计出现的次数
print(my_str.count("aaaa"))  # 0
print(my_str.count("hello"))  # 1
print(my_str.count("itcast"))  # 2
print(my_str.count("itcast", 20))  # 1

print("*" * 30)
print("hello  " * 3)  # hello  hello  hello

5、替换

"""
my_str.replace(old_str, new_str, count)
字符串的替换，将my_str中的old_str 替换成new_str
old_str: 将要被替换的字符串
new_str：新的字符串，替换成的字符串
count ：替换的次数，默认是全部替换
返回值：得到的是一个新的字符串，不会改变原来的字符串
"""

my_str = "hello world itcast and itcastcpp"

my_str1 = my_str.replace("itcast","ithima")
print(my_str1)  # hello world ithima and ithimacpp
print("my_str:", my_str )  # my_str: hello world itcast and itcastcpp

my_str2 = my_str.replace("itcast","ithima",1)
print(my_str2)  # hello world ithima and itcastcpp

6、分割

'''
my_str.split(sub_str, count)
字符串的替换，将my_str 字符串按照sub_str进行切割
sub_str: 按照什么内容切割字符串，默认是空白字符，空格及tab键
count: 切割几次，默认是全部切割
返回值： 列表
相当于是把字符串切成了列表
'''

my_str = "hello world itcast and itcastcpp"


result = my_str.split()  # 按照空白字符，全部切割
print(result)  # ['hello', 'world', 'itcast', 'and', 'itcastcpp']

print(my_str.split("2",1))  # ['hello world itcast and itcastcpp']
#                              这个由于未找到，所以返回的是一个完整的列表
print(my_str.split("itcast"))  # ['hello world ', ' and ', 'cpp']
print(my_str.split("itcast",1))  # ['hello world ', ' and itcastcpp']
print(my_str.rsplit("itcast",1))  # ['hello world itcast and ', 'cpp']
# 也有rsplit

 7、join字符串的连接

'''
my_str.join(可迭代对象)
可迭代对象，str类型和列表（需要列表中的每一个数据都是字符串类型的）
将my_str 这个字符串添加到可迭代对象的两个元素之间
返回值：一个新的字符串，不会改变原字符串的值
与split方法相反，这个是把列表改成了字符串
'''

my_str = "_".join("hello")
print(my_str)  # h_e_l_l_o
print("_*_".join("hello"))  # h_*_e_*_l_*_l_*_o

# 定义列表
my_list = ["hello", "cpp", "python"]

print("_".join(my_list))  # hello_cpp_python
print("_*_".join(my_list))  # hello_*_cpp_*_python
print(" ".join(my_list))  # hello cpp python

二、列表

1、定义

# 列表： 是Python中的一种数据类型，可以存放多个数据，列表中的数据可以是任意类型的
# 列表list ，定义使用[] 进行定义

# 定义空列表
my_list = []
my_list1 = list()
print(my_list ,type(my_list))  # [] <class 'list'>
print(my_list1 ,type(my_list1))  # [] <class 'list'>

# 定义带数据的列表数据元素之间使用逗号隔开
my_list2 = [1, 3.24, True, "IT"]  # 在计算中布尔表达式的true代表1，false代表0
print(my_list2 ,type(my_list2))  # [1, 3.24, True, 'IT'] <class 'list'>
# 求列表中数据元素的个数，即列表的长度
num = len(my_list2)
print(num)  # 4

# 列表支持下标和切片操作
print(my_list2[-1])  # IT
print(my_list2[1])  # 3.24

print(my_list2[1:3])  # [3.24, True]


# 下标操作和字符串操作中不同的是：字符串不能使用下标修改啊其中的数据，但是列表可以使用下标修改列表中的数据
# 字符串是一个整体，不能修改，但列表是分散的，所以支持索引修改
my_list2[0] = 18
print(my_list2)  # [18, 3.24, True, 'IT']

my_list2[-1] = "hello"
print(my_list2)   # [18, 3.24, True, 'hello']

my_list2[0] = "python"
print(my_list2)  # ['python', 3.24, True, 'hello']

2、遍历

支持for循环和while循环

my_list = ["郭德纲","于谦",'孙越','名之以父']

for i in my_list :
    print(i)
    '''
    郭德纲
    于谦
    孙越
    名之以父
    
    '''

print("*"*30)

j = 0
while j < len(my_list):
    print(my_list[j])
    j += 1
    '''
    郭德纲
    于谦
    孙越
    名之以父

    '''

3、CRUD 增删改查

（1）增加数据

有：列表.append（数据）方法向列表的尾部追加数据

       列表. insert(下标，数据)在指定的下标位置进行添加数据

       列表.extend(可迭代对象) # str类型和列表，会将可迭代对象中的数据逐个添加到原列表的末尾

        还可以使用“+”号，直接添加在末尾

        NOTE：添加数据都是在原列表的基础上进行的添加，并非新创建了一个列表！

# 向列表中添加数据的方法，都是直接在原列表中进行添加的，不会返回新的列表
my_list = ["郭德纲","于谦",'孙越','名之以父']
print(my_list)
# 列表：append(数据)向列表的尾部追加数据
my_list.append("aa")
print(my_list)  # ['郭德纲', '于谦', '孙越', '名之以父', 'aa']
result = my_list.append(12)
print(result)  # None 关键字，表示空
print(my_list)  # ['郭德纲', '于谦', '孙越', '名之以父', 'aa', 12]

# 列表.insert(下标，数据)在指定的下标位置进行添加数据
my_list.insert(0,"isaac")
print(my_list)  # ['isaac', '郭德纲', '于谦', '孙越', '名之以父', 'aa', 12]
print(my_list.insert(5, 3.24 ))  # None

# 列表.extend(可迭代对象)  # str类型和列表，会将可迭代对象中的数据逐个添加到原列表的末尾
my_list.extend('helli')
print(my_list)  # ['isaac', '郭德纲', '于谦', '孙越', '名之以父', 3.24, 'aa', 12, 'h', 'e', 'l', 'l', 'i']
my_list.extend([1,'python',3])
print(my_list)  # ['isaac', '郭德纲', '于谦', '孙越', '名之以父', 3.24, 'aa', 12, 'h', 'e', 'l', 'l', 'i', 1, 'python', 3]
# 在这里Python被作为一个整体输出，需要带引号才会被认为是作为整体的

（2）删除数据

方法：1、根据元素的数据值删除remove（数据值），直接原列表中的数据

           2、 根据下标删除

                 2.1 pop（下标） ：默认删除最后一个数据，返回删除的元素值

                 2.2 del 列表[下标]  （慎用）

my_list = [1, 2, 4, 5, 6, 9]
# 1、根据元素的数据值删除remove（数据值），直接原列表中的数据
my_list.remove(4)
print(my_list)  # [1, 2, 5 ,6, 9]
# print(my_list.remove(4))  # 程序报错，要删除的数据不存在

# 2、 根据下标删除
# 2.1 pop（下标） ：默认删除最后一个数据，返回删=删除的内存
num = my_list.pop()  # 删除最后一个数据
print(num)  # 9
print(my_list)  # [1, 2, 5, 6]

num = my_list.pop(2)  # 删除下标为2的数据  5
print(num)
print(my_list)  # [1, 2, 6]


# 2.2 del 列表[下标]
del my_list[1]
print(my_list)  # [1, 6]


# del my_list[10]  # 删除下标不存在的，会报错

（3）修改数据

直接修改即可

例：my_list = [ 14, 'ye' , ' isaac' ]

        my_list[0] = 18

就是修改完成了

（4）数据查询

有三种方法：

index（）：根据数据值，查找元素的下标找到返回元素的下标，没有找到，程序报错 

# find（）列表不支持这个方法，只是字符串支持

count（）;统计出现的次数

in / not in ：判断是否存在，存在是True，不存在是False，一般和if结合使用

（True代表数字1，False代表数字0）

my_list = [1, 3.14, 'isaac' , True]
num = my_list.index(3.14)  # 1
print(num)

# num1 = my_list.index(100)  # 程序报错，因为数据不存在

# count() 统计出现的次数
num2 = my_list.count(1)
print(num2)  # 2  True算 1

# in / not in : 判断是否存在，存在是True，不存在是False，一般和if结合使用
num3 = 3.14 in my_list
print(num3)  # True

num3 = 3.14 not in my_list
print(num3)  # False

 4、列表的排序和逆置

sorted（）：默认升序

要降序的话，需要在括号里面加reverse=True（     sorted(my_list,reverse=True)   ）

逆置的话，(1)需要用到切片，[ : : -1]  （得到一个新列表）

                （2）用列表.reverse()   （在原列表上进行逆置）

# 想要对列表中的数据进行排序，前提是列表中的数据类型是一样的
my_list = [1, 5, 3, 7, 9, 6]

# 列表.sorted(列表)  排序，不会在原列表中进行排序，会得到一个新的列表
# my_list.sort()  # 默认是从小到大的，即升序
# my_list.sort(reverse=True)  # 通过reverse=True，从大到小排序
print(my_list)

# 补充：sorted(列表) 排序，不会在原列表中进行排序，会得到一个新的列表
my_list1 = sorted(my_list)  # [1, 3, 5, 6, 7, 9]
my_list2 = sorted(my_list,reverse=False)  # [1, 3, 5, 6, 7, 9] ,填False的话，相当于是没改变，还是升序的
my_list3 = sorted(my_list,reverse=True)  # [9, 7, 6, 5, 3, 1]
print(my_list)
print(my_list1)
print(my_list2)
print(my_list3)

print("*"*30)

my_list4 = ['a', 'b', 'c', 'd', 'e']
# 逆置
my_list5 = my_list4[::-1]  # 得到一个新的列表
print(my_list4)
print(my_list5)  # ['e', 'd', 'c', 'b', 'a']

# 在原列表直接逆置  列表，reverse()
# print(my_list4.reverse())  # None

my_list4.reverse()
print(my_list4)  # ['e', 'd', 'c', 'b', 'a']

5、列表嵌套

school_names = [['北京大学', '清华大学'],
                ['北京邮电大学', '西安邮电大学', '重庆邮电大学'],
                ['山东大学', '南开大学']]
print(school_names[1])  # ['北京邮电大学', '西安邮电大学', '重庆邮电大学']
print(school_names[1][1])  # 西安邮电大学
print(school_names[1][1][1])  # 安

# 山东大学
print(school_names[2][0])

for schools in school_names:  # 先遍历外层循环，大列表
    # print(schools)  # 列表
    for name in schools:  # 再遍历小循环，内层列表
        print(name)

6、案例：分配办公室

import random

# 1、定义学校列表
schools = [[], [], []]  # 三个小列表就是三个办公室，对应的下标是 0  1  2
# 2、定义老师列表
teachers = ['A','B','C','D','E','F','G','H']
# 3、让老师抓阄
# 3.1 遍历老师列表
for teacher in teachers :
    # 3.2 抓阄产生随机数
    num = random.randint(0, 2)  # 产生的随机数，相当于是办公室的下标
    # 在randint里面包含结束位置的（Python里面唯一一个包含结束位置的）
    # 3.2 老师进入办公室，蒋老师名字添加到办公室列表中
    schools[num].append(teacher)

print(schools)

for office in schools:
    print(f'该办公室老师的个数为{len(office)},办公室老师的名字是：')
    # 相当于是遍历里面每个列表的长度
    for teacher in office:
        print(teacher,end=' ')
    print()

三、元组

'''

元祖和列表非常相似，都可以存放多个数据，可以存放不同数据类型的数据

不同点：  列表使用[] 定义，元组使用()定义

                列表中的数据可以修改，元组中的数据不能被修改

'''

定义一个数据类型的元组，数据元素后边，必须有一个逗号！！！

my_list = [18, 3.14, True, 'isaac']  # 列表

my_tuple = (18, 3.14, True, 'isaac')  # 元组
print(my_tuple, type(my_tuple ))  # (18, 3.14, True, 'isaac') <class 'tuple'>

# 元组支持下标和切片
print(my_tuple[1])  # 3.14

# 定义空元组，没有意义
my_tuple1 = ()
print(my_tuple1, type(my_tuple1 ))  # () <class 'tuple'>
my_tuple2 = tuple()
print(my_tuple2, type(my_tuple2 ))  # () <class 'tuple'>

# 定义一个数据类型的元组，数据元素后边，必须有一个逗号！！！
my_tuple3 = (3)
my_tuple4 = (3,)
print(my_tuple3, type(my_tuple3 ))  # 3 <class 'int'>
print(my_tuple4, type(my_tuple4 ))  # (3,) <class 'tuple'>

四、综合案例

1、字符串训练

（1）使用变量保存字符串

引号可以套引号：

单引号里面可以有双引号

双引号里面可以有单引号

三引号也可以！

'''
如果需要使用变量保存以下字符串，我们该如何书写代码
鲁迅说:"我没有说过这句话"
'''
word = '鲁迅说："我没有说过这话！"'
print(word)  # 鲁迅说："我没有说过这话！"


words = '''鲁迅说："我没有说过这话！"'''
print(words)  # 鲁迅说："我没有说过这话！"

（2）简单的用户管理系统

'''
做一个简单的用户信息管理系统：
提示用户依次输入姓名，年龄和爱好
并且在输入完成之后，一次性将用户输入的数据展示出来
'''
name = input("请输入姓名：")
age = input("请输入年龄：")
hobby = input("请输入爱好：")
# 格式化输出数据
# print("您的姓名是%s, 您的年龄是%s， 您的爱好是%s" % (name, age, hobby))
# 使用 f-string
print(f'用户的名字是：{name}，年龄是：{age}，爱好是：{hobby}')

'''
请输入姓名：名之以父
请输入年龄：18
请输入爱好：编程
用户的名字是：名之以父，年龄是：18，爱好是：编程
'''

'''
1. 在python中，通过 "" 或者 '' 声明一个字符串类型的变量 
2. 使用input（）函数从键盘获取数据
3. 通过%s 的格式化操作符来输出字符串类型
'''

（3）切片练习

'''
现有字符串如下，请使用切片提取出ceg
words = "abcdefghi"
'''

words = "abcdefghi"
word = words[2:7:2]
# word = words[-7:-1:2]
print(word)  # ceg

'''
1， 切片的语法：[起始:结束:步长]
2， 选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，
3， 步长表示选取间隔，默认步长是正值，即从左到右选取，如果步长为负值，则从右向左选取

### 
'''

（4）理解find函数和index函数

'''
题目要求：
james有一个关于爬虫的项目，他需要在一个字符串中查找python这个关键字，
当前他通过index()函数进行查找，虽然可以实现查找的需求，但是总会在
没有查找到关键字的时候报错，为什么会报错，如何优化？
'''

'''
提示：
1. find函数如果查找到则返回索引值，如果查不到，则返回-1
2. index函数如果查找到则返回索引值，如果查不到，则报错
通过使用find函数的方式替换掉index
'''

'''
答案：
只需要使用find函数替换掉index函数即可，
在功能上, find函数index函数完全一致,
不同的是index函数在没有查找到关键字的情况下会报ValueError的异常,
因此在一般开发环境下通常都会使用find函数
'''

（5）综合运用函数

'''
1.判断单词great是否在字符串words中，如果在，则将每一个great后面加一个s， 如果不在则输出 great不在该字符串中
2.将整个字符串的每一个单词都变成小写，并使每一个单词的首字母变成大写
3.去除首尾的空白，并输出处理过后的字符串
words = " great craTes Create great craters, But great craters Create great craters "
'''

'''
方法：
1. 使用in判断某一个子字符串是否在母字符串中
2. 使用replace函数替换子字符串
3. 使用lower函数将字符串变为小写
4. 使用title函数将单词的首字母大写
5. 使用strip函数去除字符串首尾的空白
'''
words = " great craTes Create great craters, But great craters Create great craters "

# 判断单词great是否在这个字符串中
if 'great' in words:
	# 将每一个great替换成greats
    words = words.replace("great", "greats")

    # 将单词变成小写
    words = words.lower()

    # 将每一个单词的首字母都大写
    words = words.title()

    # 去除首尾的空白
    words = words.strip()

    # 最后进行输出
    print(words)

else:
    print("great不在该字符串中")

2、列表训练

（1）判断元素

'''
有一个列表，判断列表中的每一个元素是否以s或e结尾，
如果是，则将其放入一个新的列表中，最后输出这个新的列表
'''
my_list = ["red", "apples", "orange", "pink", "bananas", "blue", "black", "white"]

# 用来存放以e或者s结尾的字符串
new_list = []

for i in my_list:
    # 判断列表中每一个元素是否以s或e结尾
    if i[-1] == 's' or i[-1] == 'e':
        new_list.append(i)
    # # 判断列表中每一个元素是否以s或e结尾
    # if i.endswith('s') or i.endswith('e'):
    #     new_list.append(i)

# 打印出这个新的列表
print(new_list)  # ['apples', 'orange', 'bananas', 'blue', 'white']

（2）元素删除（两种办法）

'''
给定一个列表，首先删除以s开头的元素，删除后，修改第一个元素为"joke"，并且把最后一个元素复制一份，放在joke的后边
'''

my_list = ["spring", "look", "strange", "curious", "black", "hope"]

for i in my_list[::-1]:  # 这个是 逆序遍历，避免漏删，因为每删除一个，后面的都要前移的
    # 删除以s开头的元素，
    if i[0] == 's':
        my_list.remove(i)

# 修改第一个元素为"joke"
my_list[0] = "joker"

# 获取最后一个元素
last_one = my_list[-1]

# 将最后一个元素放在joke的后面
my_list.insert(1, last_one)

print(my_list)
# ['joker', 'hope', 'curious', 'black', 'hope']

'''
for i in my_list[:]:  # 两种遍历方式，这个是直接复制一份，避免删除后漏删下一个
    # 删除以s开头的元素，
    if i[0] == 's':
        my_list.remove(i)

    # 修改第一个元素为"joke"
my_list[0] = "joker"

# 获取最后一个元素
last_one = my_list[-1]

# 将最后一个元素放在joke的后面
my_list.insert(1, last_one)

print(my_list)
# ['joker', 'hope', 'curious', 'black', 'hope']
'''

（3）列表合并（两种办法）

'''
将下列两个列表合并，将合并后的列表去重，之后降序并输出
list1 = [11, 4, 45, 34, 51, 90]
list2 = [4, 16, 23, 51, 0]
'''


list1 = [11, 4, 45, 34, 51, 90]
list2 = [4, 16, 23, 51, 0]
'''
1.  合并列表可以使用 extend()方法或者两个列表相加。
2.  列表去重有两种方案
3.  自己实现方法实现，借助一个新的列表，循环遍历原列表，判断元素是否在新的列表中，如果在，遍历下一个元素，如果不在，添加到新的列表中。
4.  使用 set() 集合去重
5.  sort 函数可以实现排序，参数reverse=True对列表进行倒序排序
'''

# 1. 使用 + 合并两个列表
my_list = list1 + list2

# 2. 列表去重
# 2.1 定义新的空列表保存去重后的数据
my_list1 = []
# 2.2 遍历合并后的列表
for i in my_list:
    # 2.3 判断i 是否在my_list1 中
    if i in my_list1:
        # 2.3.1 如果存在,直接下一次循环
        continue
    else:
        # 2.3.2 将i添加到my_list1 中.
        my_list1.append(i)

# 3. 循环结束,得到去重后的列表 my_list1,进行排序
my_list1.sort(reverse=True)

# 4. 输出最后的结果
print(my_list1)


'''
方法二、利用set集合，去重特性
# 列表拼接
list3 = list1 + list2

# 列表去重
list4 = set(list3)
list5 = list(list4)  # 转化为list列表

# 列表降序输出
list5.sort(reverse=True)

print(list5)
'''

3、元组训练

（1）比较不同

'''
有如下两行代码：
tuple1 = (2)
tuple2 = (2,)
请问tuple1与tuple2有什么不同
'''

'''
tuple1 = (2)
tuple2 = (2,)
print(type(tuple1))
print(type(tuple2))
# 对于tuple1 = （2），python解释器会将小括号理解成一个运算符号，那么这时候 返回的值是一个int类型
# 所以对于只有一个元素的元组来说，要创建一个元组，那么就必须要加逗号
'''

（2）回答问题

'''
有如下代码，请回答问题？
my_tuple = ("itcast", "python", "CPP", 18, 3.14, True)
1.  使用下标的方法，输出元组中的元素 `"CPP"`
2.  使用 for 循环遍历元组
3.  使用 while 循环遍历元组
'''


my_tuple = ("itcast", "python", "CPP", 18, 3.14, True)

# 1. 使用下标的方法，输出元组中的元素 `"CPP"`使用下标的方法，
result = my_tuple[2]
print(result)

# 2. 使用 for 循环遍历元组
for i in my_tuple:
    print(i)

print("-" * 20)

# 3. 使用 while 循环遍历元组
i = 0
while i < len(my_tuple):
    print(my_tuple[i])
    i += 1