# list
##概念
列表是序列类型的一种扩展，十分常用
• 列表是一种序列类型，创建后可以随意被修改
##创建
• 使用方括号 [] 或list() 创建，元素间用逗号 , 分隔
• 列表中各元素类型可以不同，无长度限制
• list01 = [1,2,3,4]
• """
• [] 空列表
• list() 里面什么都没有，创建空列表
• list(["张三","李四"])
• """
• list02 = list() #[]
• list03 = list(["张三","李四"])
• print(list01)
• print(list02)
• print(list03)
• list04 = [12.3,10,3.14e2,"张三"]
print(list04) #[12.3, 10, 314.0, '张三']
常用函数
#创建list
list01 = [1,2,5,7,-2,-9]#len(列表) 统计列表中元素的个数
a = len(list01)
print(a) #6#sum(列表) 求和
b = sum(list01)
print(b) #4#max(列表) 最大值
c= max(list01)
print(c) #7
#min(列表) 最小值
d = min(list01)
print(d) #9#增
#创建
删
#创建
#list.clear() 删除所有数据
list01.clear()
print(list01) #[]
改
• List[i] = 值（要修改的值）
查
#创建list
list01 = [1,2,5,7,-2,-9]#查询所有 ---直接打印列表名字
print(list01)
"""
查询单个值
利用[index]进行查询 index-->从0开始
"""
print(list01[1]) #2
"""
查询多个值
[start:stop] 左开右闭
小数在前面
正向递增 反向递减 一负一正
-6 -5 -4 -3 -2 -1
[1 2 5 7 -2 -9]
0 1 2 3 4 5
"""
print(list01[1:4]) #[2, 5, 7]
print(list01[-5:-2]) #[2, 5, 7]
print(list01[-5:4]) #[2, 5, 7]
常用方法
#list.reverse() 反转
list01 = [1,2,3,4,5,6]
list01.reverse()
print(list01) #[6, 5, 4, 3, 2, 1]
#list.copy() 拷贝
list02 = list01.copy()
print(list02)
"""
list.sort(reverse = Ture/False) 排序 默认是升序
reverse = Ture降序 reverse = False 升序
"""
list03 = [1,8,4,2,-9]
list03.sort()
print(list03) #[-9, 1, 2, 4, 8]
list03.sort(reverse=True)
print(list03) #[8, 4, 2, 1, -9]
元组
概念
元组是序列类型的一种扩展
• 元组是一种序列类型，一旦创建就不能被修改 不能增删改
创建
• 使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔
• #创建
• tuple01 = (1,2,3)
• tuple02 = tuple() #空元组 ()
• tuple03 = tuple((5,6,7))
• print(tuple01)
• print(tuple02)
• print(tuple03)
意义
• #创建
• tuple02 = tuple() #空元组 ()
• list01 = list() #[]
• """
• 空列表 空元组 空集合 空字典都是False
• all()
• """
• print(all([[],()])) #False
查
#创建
• tuple01 = (1,2,3)
• tuple02 = tuple() #空元组 ()
• tuple03 = tuple((5,6,7))
• print(tuple01)
• print(tuple02)
• print(tuple03)
"""
查询所有值 直接打印元组名字
查询单个值 [index]
查询多个值 [start:stop] 左开右闭 一负一正
-6 -5 -4 -3 -2 -1
(1, 2, 3, 4, 5, 6)
0 1 2 3 4 5
"""
print(tuple02)
print(tuple02[2])
print(tuple02[1:4])
print(tuple02[-5:-2])
print(tuple02[-5:4])
运算符
#创建
Str = ("张三")
print(type(Str)) #<class 'str'>
#字符串只能存放一个值 元组可以存放多个值，加个逗号可以进行区分
tuple01 = ("张三",)
print(type(tuple01)) #<class 'tuple'>
#复制完以后把数据变成元组
print(tuple01*3) #('张三', '张三', '张三')
#set
概念
集合是多个元素的无序(没有下标)组合
集合类型与数学中的集合概念一致
集合元素之间无序，每个元素唯一，不存在相同元素
集合元素不可更改，不能是可变数据类型
为什么？ 无序唯一
数据重复，会自动去重
创建
• 集合用大括号 {} 表示，元素间用逗号分隔
• 建立集合类型用 {} 或 set()
• 建立空集合类型，必须使用set()
• #创建
• set01 = {1,2,3,4,5}
• set02 = set() #set()
• set03 = set({9,10,11})
• print(set01)
• print(set02)
• print(set03)
• """
• 空列表 []
• 空元组 ()
• 空字典 {}
• 空集合 set()
• 原因是字典的创建也是{}，两者冲突了
• 所以我们的空集合是set(),创建空集合的时候必须使用set()
• """
• set01 = {1,2,3,4,5}
• set02 = set() #set()
• set03 = set({9,10,11})
• print(set01)
• print(set02)
• print(set03)增
#创建
set01 = {"花木兰","貂蝉","妲己","王昭君"}
"""
set.add(数据) 添加一个数据 也能添加已有的数据，
虽然不报错，但是不显示
"""
set01.add("杨玉环")
print(set01) #{'花木兰', '王昭君', '貂蝉', '妲己', '杨玉环'}
set01.add("花木兰")
print(set01) #{'花木兰', '杨玉环', '王昭君', '妲己', '貂蝉'}
"""
set01.update(set02) 批量添加数据
把set02添加到zet01中
"""
set02 = {"嬴政","武则天"}
set01.update(set02)
print(set01) #{'花木兰', '嬴政', '杨玉环', '妲己', '王昭君', '武则天', '貂蝉'}
删
#创建
set01 = {"喜羊羊","美羊羊","懒洋洋","沸羊羊","暖羊羊","慢羊羊","灰太狼"}
"""
set.discard(值) 删除集合中的值
如果数据不存在，不报错
"""
set01.discard("美羊羊")
print(set01) #{'慢羊羊', '喜羊羊', '灰太狼', '暖羊羊', '懒洋洋', '沸羊羊'}
set01.discard("小灰灰")
print(set01)
"""
set.remove(值) 删除集合中的值
KeyError: '小灰灰'
如果没有这个值，会报错
"""
set01.remove("慢羊羊")
print(set01) #{'懒洋洋', '灰太狼', '沸羊羊', '喜羊羊', '暖羊羊'}
#set01.remove("小灰灰")
#print(set01)
"""
set.pop() 随机删除
"""
set01.pop() #{'懒洋洋', '沸羊羊', '喜羊羊', '暖羊羊'}
#{'灰太狼', '喜羊羊', '沸羊羊', '暖羊羊'}
print(set01)
# set.clear() 清空
改
不可以更改数据
集合元素不可更改，不能是可变数据类型
为什么？ 无序唯一
查
直接打印集合名字去查询
不能使用索引进行查询，因为我们集合是无序的
print(set01)
print(set02)
print(set03)
集合常用函数和方法
#创建
set01 = {"喜羊羊","美羊羊","懒洋洋","沸羊羊","暖羊羊","慢羊羊","灰太狼"}
#set.copy() 复制/拷贝一个一模一样的集合
set02 = set01.copy()
print(set02) #{'慢羊羊', '美羊羊', '灰太狼', '喜羊羊', '沸羊羊', '暖羊羊', '懒洋洋'}
#len(set) 返回集合的元素个数，集合的长度
a = len(set01)
print(a) #7
"""
x in set 元素x在不在集合当中
x not in set 元素不在集合中
"""
print("慢羊羊" in set01) #True
print("慢羊羊" not in set01) #False
#set(x) 把其他数据类型（x）转换成集合类型
Str = "hello"
print(Str) #hello
print(type(Str))
b = set(Str)
print(type(b)) #<class 'set'>
print(b) #{'o', 'e', 'h', 'l'}
重点
并
"""
并
1.他的符号是 |
2.返回两个集合的所有值
"""
print(set01 | set02) #{1,2,3,4,5,7,9}
差
"""
差
1.差的符号是 -
2.set01 - set02 set01去掉公共部分的值
"""
print(set01 - set02) #{1, 4}
print(set02 - set01) #{9, 7}
交
"""
交
1.交的符号 &
2.两个的公共部分
"""
print(set01 & set02) #{2, 3, 5}
补
"""
补集
1.补集的符号 ^
2.并集-交集 = 补集
3.除去公共部分，set01和set02的单独部分我都要
"""
print(set01 ^ set02) #{1, 4, 7, 9}
包含关系
"""
判断set01 和 set02是不是包含关系
> < >= <=
口朝向那边，那边是大的
set01 >= set02 set01包含set02
"""
print(set01 >= set02) #True
print(set01 < set02) #False
print(set02 < set01) #True
增强符
S |= t --- s=s | t
"""
并
|=
set01 |= set02 -----》set01 = set01 | set02
你就看并完以后重新赋值给了谁
"""
s = set01 | set02
print(s) #{'孙策', '李白', '花木兰', '妲己', '鲁班', '雅典娜'}
set01 |= set02 #set01 = set01 | set02
print(set01) #{'孙策', '李白', '花木兰', '妲己', '鲁班', '雅典娜'}
"""
交
&=
set01 &= Set02 ------------>set01 = set01 & set02
普通（&）和增强班 （&=）
1.数据是一样
不同之处是普通的要自己声明变量，增强的是赋值给set01
"""
j = set01 & set02
print(j) #{'花木兰', '鲁班'}
set01 &= set02
print(set01) #{'花木兰', '鲁班'}
编程语言的函数都可以分为两类：内置函数和自定义函数。
内置函数分为
数字相关的内置函数
# abs(x) 求绝对值
print(abs(-10)) #10
"""
divmod(x,y) (x//y)商和(x%y)余数，同时输出商和余数
x//y 整除 向下取整
x%y 余数=被除数-除数*商 10%-3=-2
"""
x = 10
y = 3
print(divmod(10,3)) #(3, 1)
"""
pow(x,y) 幂 x的y次方 -------x**y
pow(x,y,z) 先求x的y次方 得到的结果和z进行取余----x**y%z
"""
print(pow(x,y)) #1000
print(pow(x,y,3)) #1
print(pow(2,5,10)) #2**5 = 32 32%10=2
#round(x,f) 四舍五入保留小数
print(round(3.1415926,4)) #3.1416
#max(x1,x2,..........,xn) 返回最大值
print(max(4,6,9,1,0,10)) #10
"""
int(x) 将x转换成整数，舍弃小数部分
可以把字符串转成整数,但是你的字符串必须是数字字符串 比如"123"
"""
print(int(3.92)) #3
print(int("123")) #123
#print(int("hello"))
"""
float(x) 将x转换成小数，增加小数部分
可以把字符串变成小数,但是字符串必须是数字字符串 比如"123" "22.9"
"""
print(float(12)) #12.0
print(float("22")) #22.0
#print(float("hello"))
"""
complex(x) 将x变成复数，增加虚数部分
x可以是整数 、小数、数字类型的字符串
"""
print(complex(10)) #(10+0j)
print(complex(3.14)) #(3.14+0j)
print(complex("4.56")) #(4.56+0j)
#complex("hello")
- 进制的转换：bin()，oct()和hex()函数
"""
•进制的转换：
bin() 转换成二进制(0b) 返回一个字符串
oct() 转换成八进制(0o) 返回一个字符串
hex() 转换成十六进制(0x) 返回一个字符串
"""
a = bin(100)
print(a) #0b1100100
print(type(a)) #<class 'str'>
ASCII码与字符的转换：∞
"""
chr(x) 把十进制转换成ASCLL编码字符
ord(x) 把ASCLL编码字符转换成十进制
"""
print(ord("∞")) #8734
print(chr(64)) #@
序列相关的内置函数
"""
all(序列) all()接受一个序列
当序列中所有的元素都计算为真时，返回True，否则为False
[] () {} set()都是Flase
All(“张三”,12.5,3e10,())
"""
a = ["hello",3.14,4+3j,{"张三":18,"李四":20}]
print(all(a)) #True
b = ["hello",3.14,4+3j,{"张三":18,"李四":20},[]]
print(all(b)) #False
"""
any(x) any()则在序列中的任意一个元素为真时返回True，否则为False
Any(“张三”,[],(),{})
"""
c = [{},(),set()]
print(any(c)) #False
"""
range(start,stop,step) 返回一个迭代对象
左开右闭 迭代对象（需要list转换才能输出）
start:开始数值
stop:结束数值
step:步长,和间隔不一样
1.省略开始数值,开始数值会被默认成0
2.不能省略结束数值
3.步长可以省略，如果步长不写，默认是1
步长是2，间隔是1
步长是3，间隔是2
"""
a = range(10)
print(a) #range(0, 10)
print(list(a)) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
c = range(1,10,2)
print(list(c)) #[1, 3, 5, 7, 9]
d = range(1,10,3)
print(list(d)) #[1, 4, 7]
Sorted(x) 排序，升序排序
Reversed(x) 反序，
List.sort(reverse = Ture)
"""
sorted(x) 升序排序 返回一个新的序列
"""
a = [1,7,3,5,8,2]
print(sorted(a)) #[1, 2, 3, 5, 7, 8]
"""
reversed(x) 反序排序 返回迭代器
"""
b = reversed(a)
print(list(b)) #[2, 8, 5, 3, 7, 1]
c = [1,2,3,4,5,6]
print(reversed(c)) #<list_reverseiterator object at 0x0000026D0B74C7C8>
>>> x = [1,5,3,6,2,7,8,0,9]
>>> a = sorted(x)
>>> a
[0, 1, 2, 3, 5, 6, 7, 8, 9]
>>> b = reversed(a)
>>> b
<list_reverseiterator object at 0x000002663F248BC8>
>>> list(b)
[9, 8, 7, 6, 5, 3, 2, 1, 0]
"""
slice(start,stop,step) 切片，返回一个切片对象
左开右闭 返回一个切片对象
start:开始数值
stop：结束数值
step：步长
1.步长可以省略，默认是1
"""
a = slice(5,15)
print(a) #slice(5, 15, None)
#把a换成一个迭代对象
b = range(20)[a]
print(b) #range(5, 15)
print(list(b)) #[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
enumerate(x) 可以迭代序号和值：返回一个迭代对象
"""
enumerate(x) 输出序号（下标）和值
返回值是一个枚举对象，利用for循环输出
"""
a = enumerate(['a','b','c','d','e'])
print(a) #<enumerate object at 0x000001FFA3DC3AE8>
for xiabiao,zhi in a:
print(xiabiao,zhi)
"""
0 a
1 b
2 c
3 d
4 e
类型相关的内置函数
"""
int(x) 将x转换成整数，舍弃小数部分
可以把字符串转成整数,但是你的字符串必须是数字字符串 比如"123"
"""
print(int(3.92)) #3
print(int("123")) #123
#print(int("hello"))
"""
float(x) 将x转换成小数，增加小数部分
可以把字符串变成小数,但是字符串必须是数字字符串 比如"123" "22.9"
"""
print(float(12)) #12.0
print(float("22")) #22.0
#print(float("hello"))
"""
complex(x) 将x变成复数，增加虚数部分
x可以是整数 、小数、数字类型的字符串
"""
print(complex(10)) #(10+0j)
print(complex(3.14)) #(3.14+0j)
print(complex("4.56")) #(4.56+0j)
#complex("hello")
"""
isinstance(变量,类型) 类型判断,如果变量和类型一致是true，不一致是false
变量：自定义变量
类型：Str int float list stuple dict set
[1,2,3,4] --list列表
{"张三":18,"李四":20}----dict字典
{1,2,3} ---set集合
(1,2) --tuple元组
"""
a = [1,2,3,4]
print(isinstance(a,list)) #True
print(isinstance(a,int)) #False
自定义函数
定义
- 使用关键字def引导；
- def后面是函数的名称，括号中是函数的参数，不同的参数用逗号“,”隔开，参数可以为空，但括号不能省略；
- 函数的代码块要缩进；
- 用一对"""包含的字符串作为函数的说明，用来解释函数的用途，可省略，在查看函数帮助时会显示；
- 使用关键字 return返回一个特定的值，如果省略，返回None。
def 函数名称(参数1，参数2):
代码块
return
调用
>>> def add(x,y):
sum01 = x+y
return sum01
>>> add(2,3)
5
参数
参数可以是0个，也可以是多个
带默认值的参数
定义
Y的默认值是10
>>> def cheng(x,y=10):
c = x*y
return c
调用
- 可以只传一个参数，那这个参数就是x，y是默认值10
- 如果传入两个参数，那么默认值不起作用
>>> cheng(2)
20
>>> cheng(2,5)
10
不定数目的参数
定义
- * 号代表这个参数是个不确定个数的参数
- 多个参数要用for进行循环输出
- 在for循环中进行累加
def add(x,*y):
total = x
for i in y:
#累加
total += i
return total
调用
相当于x=1 y= 2,3,4,5,6,7,8,9
>>> add(1,2,3,4,5,6,7,8,9)
45
相当于x=1 y=2
>>> add(1,2)
3
返回值
返回值只能是一个吗，可以是多个吗
可以返回多个值，多个值之间用逗号隔开
定义
>>> def suanfa(x,y):
sum01 = x+y
cheng01 = x*y
jian01 = x-y
return sum01,cheng01,jian01
调用
>>> suanfa(6,2)
(8, 12, 4)
概念
- 映射是一种键(索引)和值(数据)的对应
"""
映射
key value
张三 18
李四 20
王五 80
"""
"""
[1,2,3,4]
索引 0 1 2 3
"""
创建
- 键值对：键是数据索引的扩展
- 字典是键值对的集合，键值对之间无序(没有索引）
- 采用大括号{}和dict()创建，键值对用冒号: 表示
- 字典类型是“映射”的体现
- <字典变量> = {<键1>:<值1>, … , <键n>:<值n>}
#创建
dict01 = {"张三":18,"李四":20,"王五":80}
dict02 = dict()
dict03 = dict({"张三":90,"李四":20})
print(dict01) #{'张三': 18, '李四': 20, '王': 80}
print(dict02) #{}
print(dict03) #{'张三': 90, '李四': 20}
增
"""
dict01[新的key] = 新的值 添加数据
"""
dict01["小乔"] = "天魔缭乱"
print(dict01) #{'鲁班': '空中支援', '花木兰': '切换形态', '孙策': '开船', '元哥': '无敌时间移位', '小乔': '天魔缭乱'}
删
"""
dict.pop(key) 根据key删除一对数据
dict.clear() 清除所有数据
"""
dict01.pop("元哥")
print(dict01) #{'鲁班': '空中支援', '花木兰': '切换形态', '孙策': '开船'}
改
"""
只能修改值，不可以修改key
为什么：因为key是唯一的，不能重复的，避免出现重复的情况所以不能修改
怎么修改：
先根据key拿到值 dict01["孙策"]
再重新赋值
"""
dict01["孙策"] = "乘风破浪"
print(dict01) #{'鲁班': '空中支援', '花木兰': '切换形态', '孙策': '乘风破浪', '元哥': '无敌时间移位'}
查
#创建
dict01 = {"鲁班":"空中支援","花木兰":"切换形态","孙策":"开船","元哥":"无敌时间移位"}
# dict.keys() 查看所有的key(英雄)
print(dict01.keys()) #dict_keys(['鲁班', '花木兰', '孙策', '元哥'])
# dict.values() 查询所有的value(大招)
print(dict01.values()) #dict_values(['空中支援', '切换形态', '开船', '无敌时间移位'])
"""
查询单个值
1.dict[key] 利用key查询value
2.dict.get(key,默认值) 利用key查询value 如果key没有，那么就输出默认值
"""
print(dict01["花木兰"]) #切换形态
print(dict01.get("花木兰")) #切换形态
print(dict01.get("貂蝉","没有此英雄，请购买")) #没有此英雄，请购买
"""
查询所有值(包括key和value)
1.直接打印字典名
2.dict.items() 迭代方法
"""
print(dict01) #{'鲁班': '空中支援', '花木兰': '切换形态', '孙策': '开船', '元哥': '无敌时间移位'}
print(dict01.items()) #dict_items([('鲁班', '空中支援'), ('花木兰', '切换形态'), ('孙策', '开船'), ('元哥', '无敌时间移位')])
常用的函数和方法
"""
k in dict key在不在字典里面
如果在输出True 如果不在输出False
为什么 20 in dict0
原因是他只能判断key在不在，不能判断value在不在
"""
print("张三" in dict01) #True
print(20 in dict01) #False
"""
dict01.update(dict02) 把02中的数据更新到01中
更新是更新多个数据
是复制吗？ no
但是你可以理解成添加数据
"""
#创建字典
dict01 = {"张三":20,"王五":30,"赵六":70,"李四":80}
dict02 = {"翠花":20,"光头强":10}
dict01.update(dict02)
print(dict01) #{'张三': 20, '王五': 30, '赵六': 70, '李四': 80, '翠花': 20, '光头强': 10}
print(dict02) #{'翠花': 20, '光头强': 10}
#创建字典
dict01 = {"张三":20,"王五":30,"赵六":70,"李四":80}
dict02 = {"翠花":20,"光头强":10}
"""
del 字典名[key] 删除指定位置的数据
和pop一样
dict.pop(key) 删除指定位置的数据
"""
del dict01["李四"]
print(dict01) #{'张三': 20, '王五': 30, '赵六': 70}
字符串
概念
字符串：由0个或多个字符组成的有序字符序列
字符串由一对单引号或一对双引号表示
字符串是字符的有序序列，可以对其中的字符进行索引
"hello"---->h e l l o
索引 0 1 2 3 4
基本操作
b = "李同学"
c = "李同学张同学刘同学"
#b是c的子集
print(b in c)
字符串的序号
使用[ ]获取字符串中一个或多个字符
数值小的在前面 [1:5] [-6 :-1]
之间有区间的时候，可以使用一负一正 [-1:0] 空
索引：返回字符串中单个字符 <字符串>[M]
切片：返回字符串中一段字符子串 <字符串>[M: N]
左开右闭 print(a[8:14]) print(a[8:15])
虽然索引没有15，但同样我们也取不到15的这个数据
"""
正向递增 0 1 2 3 4 5 6
反向递减 -7 -6 -5 -4 -3 -2 -1
云 想 衣 裳 花 想 容
"""
Str = "云想衣裳花想容"
print(Str[2:4])
print(Str[-5:-3])
print(Str[-5:4])
需求分析
转义字符
1.转义符形成一些组合，表达一些不可打印的含义
"\b"回退
"\n"换行(光标移动到下行首)
"\r" 回车(光标移动到本行首)
- 可以去掉特殊含义
# 让这个双引号去掉本身含义，就打印双引号
print("我想\"嫁给\"秦霄贤")
常用函数
# len() 获取字符串的长度
a = len("去某个国家追个星")
print(a)
# str() 把任意数据类型转换成string
b = 30
print(type(b))
c = str(b)
print(type(c))
#Type()输出数据类型的
#hex() 十进制转换成十六进制(0x)
print(hex(99))
#oct() 十进制转换成八进制(0o)
print(oct(99))
#chr() 十进制转换成字符
print(chr(68))
#ord() 字符转换成十进制
print(ord('A'))
方法
方法本身也是函数，但与<a>有关，<a>.<b>()风格使用
方法是一个特殊的函数
方法vs 函数
- 函数--->函数名字() 方法 类/模块.方法名字()
- 方法是一个特殊的函数
# str.lower() 把字符串转换成小写 返回字符串
a = "AASDFGH"
print(a.lower())
#str.upper() 把字符串转换成大写 返回字符串
b = "luck"
print(b.upper())
#str.split(按照什么拆分) 拆分 返回的是list列表[]
c = "I,love,you"
print(c.split(","))
#str.count(子串) 某一个子串在str(字符串)中出现的次数 返回值整数类型
d = "o"
#o在I,love,you中出现了多少次 2
print(c.count(d))
print(type(c.count(d)))
#str.replace(old,new) str中的任意一个子串替换成新的子串 返回字符串
Str01 = "I,LOVE,YOU"
Str02 = Str01.replace("YOU", "李雪琴")
print(Str02)
#str.center(宽度,新的字符) Str字符串根据某一个宽度进行居中 返回值字符串
"""
宽度 = 新的字符+str
新的字符必须是一个字符
"""
Str03 = "刘华强"
Str04 = Str03.center(10)
print(Str04)
Str05 = Str03.center(10,"牛")
print(Str05)
#str.strip(字符) 去掉左右两边的字符 返回字符串
Str06 = "==I,LIVE,YOU=="
Str07 = Str06.strip("=L")
print(Str07)
格式化
第一种方式
- 使用百分号进行格式化输出的方式，用法如下：
%s，表示字符串；
%d，表示整数；
%f，表示浮点数。
%代表一个占位符
name = "张三"
age = 18
print("%s is %d year old"%(name,age))
'''
1.字符串和int不能拼接
2.对数据有未知性
格式化：让数据更加明了
商品 价格
口红 399
装备 80
'''
#商品名字为口红的价格是399
#价格名字为商品的口红是399
print("%s名字为%s的%s是%d"%("价格","商品","口红",399))
bug: 占位符必须和参数一一对应，否则，语句不通顺，报错
第二种
- ，用法如下：
<模板字符串>.format(<逗号分隔的参数>)
"""
<模板字符串> .format(<逗号分隔的参数>)
"{}的爱徒是{}，儿徒是{}"
第一种
利用{}为占位符
"""
print("{}的爱徒是{}，儿徒是{}".format("郭德纲","栾云平","烧饼"))
"""
第二种
利用索引（索引是0）
"栾云平","烧饼","郭德纲"
0 1 2
能充分解决我们之前的bug，又有一个新的bug
bug:比如100以上条数据，数数比较麻烦
"""
print("{2}的爱徒是{0}，儿徒是{1}".format("栾云平","烧饼","郭德纲"))
print("{1}的主角是{2}，由{0}出演".format("孙红雷","扫黑风暴","李成阳"))
"""
第三种
利用变量的赋值
"""
"{c}告诉我们：{b}不要和三观不合的人结婚,{a}我们不要和妈宝结婚".format(a="乔三丽",b="乔一成",c="乔家儿女")
大括号{}内部对格式化的配置方式
{ <参数序号> ： <格式控制标记>}
参数序号：默认是0
填充字符：默认空格
如果是整数，在前面补空格，如果是字符串在后面补空格，
对齐方式：默认是左对齐
>>> "{0:=^20}".format("python","hello")
'=======python======='
>>> "0:*>20".format("bit")
'0:*>20'
>>> "{0:*>20}".format("bit")
'*****************bit'
>>> "{:10}".format("bit")
'bit '
>>> "{:,.2f}".format(123456.78901)
'123,456.79'
>>> "{:x}".format(99)
'63'
>>> "{1}的温度是{0:.1f}C".format(31.97854,"今天")
'今天的温度是32.0C'
练习
1.以下代码输出的结果是：
'{:10s} is nice'.format('Python’)
'{:*>20,.2f}'.format(123456.789)
- 需求：3.1415926保留两位小数
>>> "{:.2f}".format(3.1415926)
'3.14'
3.需求：输入一串字符串，打印出*******123
>>> Str = input("请输入一个字符串：")
请输入一个字符串：2345
>>> "{:*>10}".format(Str)
'******2345'
447
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
