第三章集合等

# 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

调用

1. 可以只传一个参数，那这个参数就是x，y是默认值10
2. 如果传入两个参数，那么默认值不起作用

 >>> cheng(2)

20

>>> cheng(2,5)

10

不定数目的参数

定义

1.  * 号代表这个参数是个不确定个数的参数
2. 多个参数要用for进行循环输出
3. 在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" 回车(光标移动到本行首)

1. 可以去掉特殊含义

# 让这个双引号去掉本身含义，就打印双引号

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 函数

1. 函数--->函数名字()       方法  类/模块.方法名字()
2. 方法是一个特殊的函数

# 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)

1. 需求：3.1415926保留两位小数

>>> "{:.2f}".format(3.1415926)

'3.14'

3.需求：输入一串字符串，打印出*******123

>>> Str = input("请输入一个字符串：")

请输入一个字符串：2345

>>> "{:*>10}".format(Str)

'******2345'