0621 Python 中数据类型:字符串str（切片，print，input）、列表list、元祖tople、字典dict

一、字符串str

1、定义

• 一串字符，用于表达文本数据类型
• 可以使用一对双引号 “”，或一对单引号 '',定义一个字符
• 如果字符串当中有单引号或者双引号？
  • 可以使用 “ 或者 ‘  做字符串的转义　　
  • 字符串内需要使用 “ ，可以使用 ’ 定义字符串　　
  • 字符串内需要使用 ‘ ，可以使用 “ 定义字符串　　

2、获取指定位置的字符

• 可以使用  索引  获取一个字符串中  指定位置的字符，索引计数从0开始
• 支持顺序索引（开始索引为0）、倒序索引（开始索引为：-1）

# python有6个字符，它的索引从0开始，最大为5
# 正向数字索引
one_str = "python"
print(one_str[5])
# 结果为：n

# 反向数字索引
print(one_str[-3])
# 结果为：h

# 切片操作，只能取到结束索引的前一位
print(one_str[2:4])
# 结果为：th

3、字符串的切片

使用  索引值  来限定范围

格式：

字符串[开始索引：结束索引：步长]

　　　　

=====

# 例子：
two_str = "Monty Python"

print(two_str[6:10])    # 获取“Pyth”

print(two_str[0:5])     # 通过顺序索引，获取“Monty”
print(two_str[:5])      # 起始索引为 0  可以省略 Monty

print(two_str[-12:-7])   # 通过倒序索引，获取“Monty”

print(two_str[6:-1:2])   # 如果要获取Pto
# 或者
print(two_str[6::2])

print(two_str[:])        # 全部取出Monty Python

重点注意：

1. 指定的区间属于 左闭右开  型  [开始索引：结束索引]
2. 从 起始 位开始，到 结束位的前一位  结束（不包含结束本身）
3. 从头开始，开始索引的  数字  0  可以省略，冒号不能省略
4. 到末尾结束，结束索引的   数字  -1  可以省略，冒号不能省略
5. 步长默认为  1，如果连续切片，数字和冒号都可以省略

切片适用范围：字符串、列表、元祖  等序列类型

列表 和元祖 都是有序 的集合，都能够 通过索引值  获取到对应的数据

字典  是一个  无序  的集合，是使用 键值对  保存数据

4、内置方法 ---- 标红为重点

• 在 ipython 中定义一个 字符串，例如: string =""
• 输入string. 按下TAB键，ipython 会提示字符串能够使用的方法如下:

1.判断类型

1. string.isspace()　　　　 # 如果string中只包含空格，则返回True
2. string.isalnum()　　　　 # 如果string 至少有一个字符并且所有字符都是字母或数字则返回True
3. string.isalpha()　　　　  # 如果string 至少有一个字符并且所有字符都是字母则返回True
4. string.isdecimal()　　　 # 如果string 只包含数字则返回 True，全角数字
5. string.isdigit()　　　　　# 如果string 只包含数字则返回 True，全角数字、(1)、u00b2
6. string.isnumeric()　　　 # 如果string 只包含数字则返回 True，全角数字、汉子数字
7. string.istitle()　　　　　 #  如果string 是标题化的(每个单词的首字母大写)，则返回 True
8. string.islower()　　　　  # 如果string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True
9. string.isupper()　　　　  # 如果string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True

first_str = "100"   # 数字类型的字符串

print(first_str.isalnum())
print(first_str.isalpha())
print(first_str.isdigit())

2.查找和替换

1. string.startswith(str)　　　　# 检查字符串是否以 str 开头，是则返回 True
2. string.endswith(str)　　　　# 检查字符串是否以 str 结束，是则返回 True
3. string.find(str,__start=0,__end=len(string))　　　　# 检查 str 是否包含在 string 中，如果 star 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回 -1
4. string.rfind(str,__start=0,__end=len(string))　　　　# 类似于 find(),不过是从右边开始查找
5. string.index(str,__start=0,__end=len(string))　　　　# 跟 find() 方法类似，不过如果 str 不在string 会报错
6. string.rfind(str,__start=0,__end=len(string))　　　　# 类似于 index(),不过是从右边开始
7. string.replace(old_str,new_str,num=string.count(old))　　　　# 把 string 中的 old_str 替换成 new_str，如果 num 指定，则替换不超过 num次

3.大小写转换

1. string.capitalize()　　　　# 把字符串的第一个字符大写
2. string.title()　　　　　　  # 把字符串的每个单词首字母大写
3. string.lower()　　　　　　# 转换 string 中所有大写字符为小写
4. string.upper()　　　　　　# 转换 string 中的小写字母为大写
5. string.swapcase()　　　　# 翻转 string 中的大小写

a = "PYTHON"
b = a.lower()
print(b)
结果为：python

4、文本对齐

1. string.ljust(width)　　　　# 返回一个原字符串左对齐，并使空格填充至长度 width 的新字符串
2. string.rjust(width)　　　　# 返回一个原字符串右对齐，并使空格填充至长度 width 的新字符串
3. string.center(width)　　　　# 返回一个原字符串居中，并使空格填充至长度 width 的新字符串

5、去除空白字符

1. string.lstrip()　　　　# 截掉 string 左边 (开始)的空白字符
2. string.rstrip()　　　　# 截掉 string 右边 (末尾)的空白字符
3. string.strip()　　　　# 截掉 string 左右两边的空白字符

6、拆分和链接

1. string.partition(str)　　　　 # 把字符串 string 分成一个 3元素的元祖(str前面，str,str后面)
2. string.rpartition(str)　　　　# 类似于 partition() 方法，不过是从有伴开始查找
3. string.split(str="",num)　　  # 以 str 为分隔符拆分 string ，如果 num 有指定值，则仅分割 num + 1 个子字符串，石头人默认包含' ',' ',' '和空格
4. string.splitlines()　　　　　# 按照行(' ',' ',' ')分隔，返回一个包含各行作为元素的列表
5. string.join(seq)　　　　　　# 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新字符串

a = "莫*名*其*妙"
a = a.split('*')
print(a)
# 结果为：['莫', '名', '其', '妙']

# 再把结果以"-"拼接成一个列表
a = "-".join(a)
print(a)
# 结果：莫-名-其-妙

5、input 字符串输入

1、定义

用代码获取用户通过键盘输入的内容

使用 input 函数

input 函数实现键盘输入

　　　　等待用户从键盘输入

　　　　用户输入的 任何内容 ，都会被当做一个字符串

　　　　语法：a = input("请输入一个数字”)

# 获取用户键盘输入
# 使用input函数
username = input("请输入您的用户名：")
# input函数接收到的用户数据，均为字符串类
print(username)
# type 查看类型
print(type(username))

# 结果：
# 请输入您的用户名：name
# name
# <class 'str'>

2、类型转换函数

int(x) 将 x 转换为一个整数

float(x) 将 x 转换为一个浮点数

# 计算用户输入的两个整数的乘积
x = input("请输入一个整数x:")
y = input("请输入一个整数y:")
# 用户输入内容均为字符串，需要转换
result = int(x) * int(y)
print("x * y =", result)

# 控制台结果：
# 请输入一个整数x:12
# 请输入一个整数y:2
# x * y = 24

6、print 格式化输出

1、定义

•  可以使用 print 函数将信息输出到控制台（屏幕）
•  如果希望输出文字信息的同时，一起输出 数据，就需要使用到 格式化操作符 % 或者 format 方法

username = input("请输入您的用户名：")
age = input("请输入您的芳年：")
sex = "男"

print("我们班最靓的人是：", username)
# 使用变量来填充
print(username + "是最靓的！")
print("【{}】是最靓的！".format(username))
# 
 为换行符
print("【{}】是最靓的！
芳年{}岁！".format(username, age))  # 与花括号的顺序是一一对应的
print("芳年{1}岁！【{0}】是最靓的！性别为：{2}".format(username, age, sex))

# 执行结果：
请输入您的用户名：小龙女
请输入您的芳年：28
我们班最靓的人是： 小龙女
小龙女是最靓的！
【小龙女】是最靓的！
【小龙女】是最靓的！
芳年28岁！
芳年28岁！【小龙女】是最靓的！性别为：女

2、格式化操作符 %  ----Python 2中的格式，没必要掌握

•  % 被称为 格式化操作符，专门用于处理字符串中的格式
•  print("格式化字符串 %s" % 变量1)
•  print("格式化字符串 %s %s" % 变量1,变量2、、、)

3.使用format方法

• 把含有 {} 的字符串当成一个模板，通过传入的参数进行格式化
• 不指定序号，会自动按照顺序去匹配
• 制定序号去匹配{0}{1}
• 制定同一个序号去匹配{1}{1}

类型：

{:s} 或者 {}　　含义：输出为字符串

{:d} 或者 {:06d}　　含义：输出为10进制整数

{:f} 或者 {:2f}　　含义：输出为浮点数

# format方法案例演练
# - 定义字符串变量 `name`，输出 **我的名字叫 可优，请多多关照！**
# - 定义整数变量 `student_no`，输出 **我的学号是 1**
# - 定义小数 `apple_price`、`apple_weight`、`money`，输出 **苹果单价 6.5 元／斤，购买了 3.5 斤，需要支付 22.75 元**
# - 定义一个小数 `percent_rate`，输出 **数据比例是88.00%**
name = input("请输入帅哥的名字：")
student_no = int(input("请输入你的学号："))
apple_price = float(input("请输入苹果的价格（元/斤）："))
apple_weight = float(input("请输入苹果的重量（斤）："))

print("我的名字叫{}，请多多关照！".format(name))
print("我的学号是{:d}".format(student_no))
print("苹果单价{:.2f}元／斤，购买{:.2f}斤，需要支付{:.2f}元。".
      format(apple_price, apple_weight, apple_price * apple_weight))

执行结果：
请输入帅哥的名字：郭靖
请输入你的学号：222
请输入苹果的价格（元/斤）：5.5
请输入苹果的重量（斤）：6
我的名字叫郭靖，请多多关照！
我的学号是222
苹果单价5.50元／斤，购买6.00斤，需要支付33.00元。

二、列表 [list]

1、列表(list)中的定义

• 一串数据
• 用  [ ] 定义，数据之间使用 ， 分隔
• 为序列类型，支持序列来的所有操作
• 使用 最频繁的数据类型，在其他语言中通常叫做 数组

2、列表的创建

# 创建列表
# 可以添加任意类型的数据
one_list = [100, "World", "默", True, None]
print("{}是{}类型".format(one_list, type(one_list)))

# 创建空列表
print([])
# 另外一种方法空列表
print(list())

执行结果：
[100, 'World', '默', True, None]是<class 'list'>类型
[]
[]

3、列表的相关操作

1、支持通过数字索引来取值

one_list = ["天天好心情", "未来", 100, None, True, ["阿登", "Sunny"]]
# 索引跟字符串中是一样，也是从0开始
print("值为：{}
类型为：{}".format(one_list[1], type(one_list[1])))
print()
# 获取多个元素
# 列表也是支持切片操作
print("值为：{}
类型为：{}".format(one_list[1:3], type(one_list[1:3])))

执行结果：
值为：未来
类型为：<class 'str'>

值为：['未来', 100]
类型为：<class 'list'>

2、列表的其他操作

以这个为例进行一下操作

one_list = ["天天好心情", "未来", 100, None, True, ["阿登", "Sunny"]]
print("原始字符串为：{}
".format(one_list))

操作1：列表是可变类型，可以被修改的，通过索引

one_list[-5] = "好好生活"
print("修改之后的字符串为：{}
".format(one_list))

原始字符串为：['天天好心情', '未来', 100, None, True, ['阿登', 'Sunny']]
修改之后的字符串为：['天天好心情', '好好生活', 100, None, True, ['阿登', 'Sunny']]

操作2：insert 在指定位置插入一个元素

one_list.insert(2, "太阳风")
print("修改之后的字符串为：{}
".format(one_list))

执行结果：

原始字符串为：['天天好心情', '未来', 100, None, True, ['阿登', 'Sunny']]

修改之后的字符串为：['天天好心情', '未来', '太阳风', 100, None, True, ['阿登', 'Sunny']]

操作3：append（译：额喷的）在末尾追加任意数据

one_list.append("活着")
one_list.append(12)
one_list.append(["北辰", "初心", "帅哥可优"])
print("修改之后的字符串为：{}
".format(one_list))

原始字符串为：['天天好心情', '未来', 100, None, True, ['阿登', 'Sunny']]

修改之后的字符串为：['天天好心情', '未来', 100, None, True, ['阿登', 'Sunny'], '活着', 12, ['北辰', '初心', '帅哥可优']]

操作4：extend（译：意思ten的）可以将任意序列类型（str、list、tuple）的数据扩充到列表；

将里面的数据抽出来再添加到列表内

two_list = ["北辰", "初心", "帅哥可优"]
one_list.extend(two_list)
print("修改之后的字符串为：{}
".format(one_list))

three_str = "Lemon"
one_list.extend(three_str)
print("修改之后的字符串为：{}
".format(one_list))

原始字符串为：['天天好心情', '未来', 100, None, True, ['阿登', 'Sunny']]

修改之后的字符串为：['天天好心情', '未来', 100, None, True, ['阿登', 'Sunny'], '北辰', '初心', '帅哥可优']

修改之后的字符串为：['天天好心情', '未来', 100, None, True, ['阿登', 'Sunny'], '北辰', '初心', '帅哥可优', 'L', 'e', 'm', 'o', 'n']

操作5：pop方法，删除尾部/特定元素

1、将尾部一个元素删除

one_var = one_list.pop()
print("这个要被删除 = ", one_var)
print("修改之后的字符串为：{}
".format(one_list))

原始字符串为：['天天好心情', '未来', 100, None, True, ['阿登', 'Sunny']]

这个要被删除 =  ['阿登', 'Sunny']
修改之后的字符串为：['天天好心情', '未来', 100, None, True]

2、将特定索引上的元素删除

one_var1 = one_list.pop(-3)
print("这个要被删除 = ", one_var1)
print("修改之后的字符串为：{}
".format(one_list))

原始字符串为：['天天好心情', '未来', 100, None, True, ['阿登', 'Sunny']]

这个要被删除 =  None
修改之后的字符串为：['天天好心情', '未来', 100, True, ['阿登', 'Sunny']]

操作6：clear （译：客历儿）方法，清空列表

one_list.clear()
print("修改之后的字符串为：{}
".format(one_list))

原始字符串为：['天天好心情', '未来', 100, None, True, ['阿登', 'Sunny']]

修改之后的字符串为：[]

其它操作函数：

• count：出现的次数
• sort：从小到大排序
• remove：移除一个元素
• reverse：列表翻转（译：瑞我死）

三、元祖(tople)

1、元祖(tuple)定义

• 关键字：tuple，元祖一般用 "()" 圆括号括起来
• 是有序的数据类型
• 元素可以是不同的数据类型（包含整数、字符串等）
• 元祖的元素 不可修改，但是如果包含类表或者是字典，里面的元素可以做更爱
• 元祖如果只有一个元素，那么就要在元素后面加一个逗号，不然 python 无法识别为元祖数据类型的数据

2、元祖的创建

# 创建空元组
one_tuple = ()
print("值为：{}
类型为：{}".format(one_tuple, type(one_tuple)))
值为：()
类型为：<class 'tuple'>

# 创建非空元组
two_tuple1 = ("潇潇", "菲菲", "生如花开")
print("值为：{}
类型为：{}".format(two_tuple1, type(two_tuple1)))
值为：('潇潇', '菲菲', '生如花开')
类型为：<class 'tuple'>

# 如果元组只有一个元素,需要加一个逗号
# three_tuple = ("一二六")
three_tuple2 = ("一二六", )
print("值为：{}
类型为：{}".format(three_tuple2, type(three_tuple2)))
值为：('一二六',)
类型为：<class 'tuple'>

# 元组中也可以加嵌套的元素
# 建议不要在元组中添加可变类型（列表、字典）
four_tuple = ("一二六", None, True, ("可优", "Dake", 100))
print("值为：{}
类型为：{}".format(four_tuple, type(four_tuple)))
值为：('一二六', None, True, ('可优', 'Dake', 100))
类型为：<class 'tuple'>

3、元祖的相关类型

• 元组类型不可修改，会报错

以下两个操作以此元祖为例

four_tuple = ("一二六", None, True, ("可优", "Dake", 100), "一二六", None, "一二六")
print("原始值为：{}
类型为：{}
".format(four_tuple, type(four_tuple)))

1、取出某个元素

• 字符串、列表一样，是支持数字索引取值的
• 同时也是支持切片操作

four_tuple = ("一二六", None, True, ("可优", "Dake", 100), "一二六", None, "一二六")
print("原始值为：{}
类型为：{}
".format(four_tuple, type(four_tuple)))

one_num = four_tuple[0]
print("值为：{}
类型为：{}".format(one_num, type(one_num)))

原始值为：('一二六', None, True, ('可优', 'Dake', 100), '一二六', None, '一二六')
类型为：<class 'tuple'>

值为：一二六
类型为：<class 'str'>

2、元组支持的常用操作

• 元祖.count(数据)      返回元祖中某个元素出现的次数（译：康特）

• 元祖.index(数据)      返回第一次出现某个元素的索引（译：in戴斯）

# 跟列表一样支持count，返回元组中某个元素出现的次数
count_num = four_tuple.count("一二六")
print("出现的次数值为：{}
类型为：{}
".format(count_num, type(count_num)))

# index方法，返回第一次出现某个元素的索引值
index_num = four_tuple.index(True)
print("元素的索引值为：{}
类型为：{}
".format(index_num, type(index_num)))

原始值为：('一二六', None, True, ('可优', 'Dake', 100), '一二六', None, '一二六')
类型为：<class 'tuple'>

出现的次数值为：3
类型为：<class 'int'>

元素的索引值为：2
类型为：<class 'int'>

3、应用场景

• 函数位置参数，*args
• %格式字符串
• 元素不可变的列表
• 字典dict 的 key

 

四、字典{dict}

　　　　　　　　　　

• 用 { } 定义
• 除列表意外最灵活的数据类型，可以用来存储多个数据
• 以键值对 {key:value} ，字典 = key（键）：value（值）

使用键值对存储数据，键值对之间使用，分隔

• 键 key是索引
• 值 value是数据
• 键 和 值 之间使用:分隔
• 键 必须是唯一的
• 值 可以取任意数据类型，但键只能使用不可变类型(字符串、数字或元组)

规定：

• 字典是可变类型，key不可改变、不可重复，value 没有限制，可以是任意类型
• 不可变类型：str, tuple, int, float, bool, None

# 空字典
my_dict = {}
print("值为: {}
类型为: {}
".format(my_dict, type(my_dict)))

# 非空字典
one_dict = {"name": "物是人非", "age": 20, "sex": "男"}
print("值为: {}
类型为: {}".format(one_dict, type(one_dict)))
执行结果：
值为: {}
类型为: <class 'dict'>

值为: {'name': '物是人非', 'age': 20, 'sex': '男'}
类型为: <class 'dict'>

1.字典的相关操作：

求长度　　　len（字典)

取值　　　　通过 key 取值

one_dict = {"name": "物是人非", "age": 20, "sex": "男"}
print("原字典值为: {}
类型为: {}
".format(one_dict, type(one_dict)))

# 求长度
print(len(one_dict))

# 通过 key 取值
one_value = one_dict["name"]   # 如果使用[]去取值,key不存在的话,那么会报错
print("值为: {}
类型为: {}
".format(one_value, type(one_value)))

# 也可以使用get来获取value
# key 不存在返回 None空
one_value = one_dict.get("sex1")
print("值为: {}
类型为: {}".format(one_value, type(one_value)))

# key 在字典中不存在，则返回指定的数据
one_value = one_dict.get("sex1", "女")
print("值为: {}
类型为: {}".format(one_value, type(one_value)))

# key 在字典中存在，则返回value值，指定失效
one_value = one_dict.get("sex", "女")
print("值为: {}
类型为: {}
".format(one_value, type(one_value)))

执行结果：
原字典值为: {'name': '物是人非', 'age': 20, 'sex': '男'}
类型为: <class 'dict'>

3
值为: 物是人非
类型为: <class 'str'>

值为: None
类型为: <class 'NoneType'>
值为: 女
类型为: <class 'str'>
值为: 男
类型为: <class 'str'>

修改字典中的值　　　　字典["key"] = "value新值"

插入一个键值对　　　　

one_dict = {"name": "物是人非", "age": 20, "sex": "男"}
print("原字典值为: {}
类型为: {}
".format(one_dict, type(one_dict)))

# 修改字典中的值
one_dict['name'] = "Low"
print("修改值为: {}
类型为: {}".format(one_dict, type(one_dict)))

# 插入一个键值对
one_dict['other'] = "Keyou"  # 需要添加一个键值对, 使用 字典[new_key] = new_value
print("插入值为: {}
类型为: {}
".format(one_dict, type(one_dict)))

执行结果：

原字典值为: {'name': '物是人非', 'age': 20, 'sex': '男'}
类型为: <class 'dict'>

修改值为: {'name': 'Low', 'age': 20, 'sex': '男'}
类型为: <class 'dict'>
插入值为: {'name': 'Low', 'age': 20, 'sex': '男', 'other': 'Keyou'}
类型为: <class 'dict'>

两个字典合并　　　　第一个字典.update(第二个字典)    　　（译：啊泼得特）

删除指定的键值对　　字典.pop("key键")　　(译：炮泼)

清空字典　　　　　　字典.clear()　　　　（译：可立克）

one_dict = {"name": "物是人非", "age": 20, "sex": "男"}
print("原字典值为: {}
类型为: {}".format(one_dict, type(one_dict)))

two_dict = {"太阳风": "有点帅", "莫名其妙": "帅"}
print("原字典值为: {}
类型为: {}
".format(two_dict, type(two_dict)))

# 将两个字典合并update
one_dict.update(two_dict)
print("值为: {}
类型为: {}
".format(one_dict, type(one_dict)))

# 删除指定的键值对
one_dict.pop("age")
print("值为: {}
类型为: {}
".format(one_dict, type(one_dict)))

# 清空字典，使用clear方法
one_dict.clear()
print("值为: {}
类型为: {}
".format(one_dict, type(one_dict)))

执行结果：
原字典值为: {'name': '物是人非', 'age': 20, 'sex': '男'}
类型为: <class 'dict'>
原字典值为: {'太阳风': '有点帅', '莫名其妙': '帅'}
类型为: <class 'dict'>

值为: {'name': '物是人非', 'age': 20, 'sex': '男', '太阳风': '有点帅', '莫名其妙': '帅'}
类型为: <class 'dict'>

值为: {'name': '物是人非', 'sex': '男', '太阳风': '有点帅', '莫名其妙': '帅'}
类型为: <class 'dict'>

值为: {}
类型为: <class 'dict'>

其他的函数：values()、keys()、items()

练习：

1.去生鲜超市买橘子

• 收银员输入橘子的价格，单位：元／斤
• 收银员输入用户购买橘子的重量，单位：斤
• 计算并且 输出 付款金额
  • 思考：如果输入的不是一个数字，执行程序会怎样？如何解决呢？

tangerine_price = float(input("请输入价格，单位：元/斤 ："))
tangerine_weight = float(input("请输入重量，单位：斤 ："))
rental = tangerine_price * tangerine_weight
print("橘子的价格{:.2f},橘子的重量{:.2f},需要支付的金额{:.2f}".
      format(tangerine_price,tangerine_weight,rental))

2.个人信息展示

• 在控制台依次提示用户输入：姓名、网名、年龄、性别、爱好、座右铭
• 按照以下格式输出：
• 提示：
  • a.可以使用format来格式化显示　　

# 答案：
name = input("请输入姓名(网名)：")
age = int(input("请输入年龄："))
gender = input("请输入性别：")
hobby = input("请输入爱好：")
motto = input("请输入座右铭：")

asterisk = print("*" * 30)
print("个人信息展示
姓名(网名):{}
年龄:{}
性别:{}
爱好:{}
座右铭:{}".
      format(name,age,gender,hobby,motto))
asterisk = print("*" * 30)

3.编写代码，用户输入1-7七个数字，分别代表周一到周日，如果输入的数字是6或7，打印输出“周末”

dict_1 = {"1":"周一","2":"周二","3":"周三","4":"周四","5":"周五","6":"周未","7":"周未"}
while True:
    a = input("请输入1-7：")
    if a in dict_1.keys():
        print(dict_1[a])
    elif a == "n":
        break
    else:
        print("输入错误，请输入数字1-7")

方法二：

dict_2 = ("周一", "周二", "周三", "周四", "周五", "周未", "周未")

day_index = int(input("请输入1-7之间的数字："))
print("今天是{}".format(dict_2[day_index - 1]))

4.删除如下列表中的"矮穷丑"，写出能想到的所有方法

keyou_info = ["可优", 18, "男", "矮穷丑", ["高", "富", "帅"], True, None, "Always Be Coding"]

# del keyou_info[3]
# del keyou_info[-5]
# keyou_info.remove("矮穷丑")
# keyou_info.pop(3)
keyou_info.pop(-5)
# keyou_info[3:4] = []   # 赋值任何一个空的序列类型都可以
print(keyou_info)

5.元组和列表有什么区别？

• 列表可以修改
• 元祖不可修改

6.判断是否是数字

# 两种方法
orange_price = input("请输入值：")
a1 = orange_price.replace(".", "", 1).isdigit()
print(a1)
# 结果：True

def is_digit(num):
    try:
        float(num)
        return True
    except ValueError:
        return False

a2 = is_digit(33)
print(a2)
# 结果：True

总结：

*******请大家尊重原创，如要转载，请注明出处：转载自：https://www.cnblogs.com/shouhu/，谢谢！！*******