3 - 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

重点注意：

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

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

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

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

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

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

1.判断类型

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

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

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

2.查找和替换

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

3.大小写转换

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

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

4、文本对齐

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

5、去除空白字符

string.lstrip()　　　　# 截掉 string 左边 (开始)的空白字符
string.rstrip()　　　　# 截掉 string 右边 (末尾)的空白字符
string.strip()　　　　# 截掉 string 左右两边的空白字符（空格）

6、拆分和链接

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

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

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

count 统计

# count(子字符串) 统计  子字符串出现的次数
# 已经定义的字符串，不可以修改。
str_a = "hello43,World!Py43,Welcome43!"
counts = str_a.count("43")
print(counts)   结果：3

index 获取字符串的索引

# index(子字符串)  获取指定字符串的索引。
str_a = "hello43,World!Py483,Welcome43!"
index = str_a.index("43") # 从索引为0开始
index2 = str_a.index("43",6)  # 从索引为6开始往后找
print(index)
print(index2)

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))
# \n 为换行符
print("【{}】是最靓的！\n芳年{}岁！".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("值为：{}\n类型为：{}".format(one_list[1], type(one_list[1])))
print()
# 获取多个元素
# 列表也是支持切片操作
print("值为：{}\n类型为：{}".format(one_list[1:3], type(one_list[1:3])))

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

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

2、列表的其他操作

以这个为例进行一下操作

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

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

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

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

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

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

执行结果：

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

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

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

one_list.append("活着")
one_list.append(12)
one_list.append(["北辰", "初心", "帅哥可优"])
print("修改之后的字符串为：{}\n".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("修改之后的字符串为：{}\n".format(one_list))

three_str = "Lemon"
one_list.extend(three_str)
print("修改之后的字符串为：{}\n".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("修改之后的字符串为：{}\n".format(one_list))

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

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

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

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

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

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

3、del 列表【索引】特定索引上的元素删除

4、remove：移除一个元素

删除特定位置上的元素，列表.remove(数据)

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

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

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

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

操作7：sort 与 sorted

sort() 函数用于对原列表进行排序（从小到大），如果指定参数，则使用比较函数指定的比较函数。

key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。

语法：

list.sort( key=None, reverse=False)

# 列表
vowels = ['e', 'a', 'u', 'o', 'i']
 
# 降序
vowels.sort(reverse=True)
 
# 输出结果
print ( '降序输出:', vowels )

sorted() 函数对所有可迭代的对象进行排序操作。

iterable -- 可迭代对象。

cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。

key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。

# 问题：不修改原列表test_list=[2,6,3,9,1,6,32,68]从大到小排序

test_list = [2, 6, 3, 9, 1, 6, 32, 68]
new_list = sorted(test_list, reverse=True)
print(new_list)

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，

而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

其它操作函数：

count：（译：抗的）某一个元素出现的次数

remove：移除一个元素

reverse：列表翻转（译：瑞我死）

三、元祖(tople)

1、元祖(tuple)定义

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

2、元祖的创建

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

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

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

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

3、元祖的相关类型

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

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

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

1、取出某个元素

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

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

one_num = four_tuple[0]
print("值为：{}\n类型为：{}".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("出现的次数值为：{}\n类型为：{}\n".format(count_num, type(count_num)))

# index方法，返回第一次出现某个元素的索引值
index_num = four_tuple.index(True)
print("元素的索引值为：{}\n类型为：{}\n".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("值为: {}\n类型为: {}\n".format(my_dict, type(my_dict)))

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

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

也可以使用 dict() 来创建空字典

a = dict()
print("值为: {}\n类型为: {}\n".format(a, type(a)))

1.字典的相关操作：

求长度　　　len（字典)

取值　　　　通过 key 取值

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

# 求长度
print(len(one_dict))

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

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

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

# key 在字典中存在，则返回value值，指定失效
one_value = one_dict.get("sex", "女")
print("值为: {}\n类型为: {}\n".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("原字典值为: {}\n类型为: {}\n".format(one_dict, type(one_dict)))

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

# 插入一个键值对
one_dict['other'] = "Keyou"  # 需要添加一个键值对, 使用 字典[new_key] = new_value
print("插入值为: {}\n类型为: {}\n".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("原字典值为: {}\n类型为: {}".format(one_dict, type(one_dict)))

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

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

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

# 清空字典，使用clear方法
one_dict.clear()
print("值为: {}\n类型为: {}\n".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("个人信息展示\n姓名(网名):{}\n年龄:{}\n性别:{}\n爱好:{}\n座右铭:{}".
      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/，谢谢！！*******

posted @ 2019-10-23 20:20 守护往昔阅读(909) 评论(1) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

守护@往昔

守护当下，珍惜过往

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

一、字符串str

1、定义

2、获取指定位置的字符

3、字符串的切片

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

1.判断类型

2.查找和替换

3.大小写转换

4、文本对齐

5、去除空白字符

6、拆分和链接

5、input 字符串输入

1、定义

2、类型转换函数

6、print 格式化输出

1、定义

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

3.使用format方法

二、列表 [list]

1、列表(list)中的定义

2、列表的创建

3、列表的相关操作

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

2、列表的其他操作

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

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

操作7：sort 与 sorted

sort() 函数用于对原列表进行排序（从小到大），如果指定参数，则使用比较函数指定的比较函数。

sort 与 sorted 区别：

三、元祖(tople)

1、元祖(tuple)定义

2、元祖的创建

3、元祖的相关类型

1、取出某个元素

2、元组支持的常用操作

3、应用场景

四、字典{dict}

1.字典的相关操作：

练习：

1.去生鲜超市买橘子

2.个人信息展示

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

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

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

6.判断是否是数字

公告