005、python 字符串str

str 字符串

• str
• 转义字符
• 格式化
• 内建函数

字符串

• 表示文字信息
• 用单引号、双引号、三引号括起来

s = "464416463"
print(s)

# 三引号打印出的信息格式不变
s = '''
nihao
nihao 
nihao '''
print(s)


nihao
nihao 
nihao

转义字符

• 用一个特色的方法表示出一系列不方便写出的内容，回车键、换行键、退格键
• 借助反斜杠字符，一旦出现的反斜杠，则反斜杠后面的几个字符的含义进行了转义。
• 在字符串中，一旦出现反写光加倍小心，可能有转义字符出现
• 不同系统对航航操作有不同的表示
  • windows： \n
  • Linux:\r\n

#转义字符案例
#想表达Let's go
#使用转义字符

s = 'Let\'s Go'
print(s)

#使用单双引号嵌套

s = "Let\'s Go"
print(s)

#表示斜杠
#比如表示 C：\user

s = "c:\\user"
print(s)

#回车换行
#windows 下使用 \r\n ，和\n 效果相同

s = "Ich \nlieb"
print(s)



Let's Go
Let's Go
c:\user
Ich 
lieb

常用的转义字符

• 转义字符 描述
• \ 在行尾时，续行符
• \ 反斜杠符号
• ’ 单引号
• " 双引号
• \a 响铃
• \b 退格
• \e 转义
• \000 空
• \n 换行
• \v 纵向制表符
• \t 横向制表符
• \r 回车
• \f 换页
• \oyy 八进制数
• \xyy 十六进制数
• \other 其他字符以普通格式输出

# 单个斜杠的用法
# 在python里，单个反斜杠表示此行未结束，出于美观，需要在下一行继续

def myDemo(x,\
          y,\
          z):
    print("hhh")
    return None
myDemo(1,2,3)

格式化

• 把字符串按照一定格式进行打印或者补充
• 格式化分类：
  • 传统格式化
  • format

# 填充
s = "nihao"
print(s)
s = "nihaoa"
print(s)
s = "nihaob"
print(s)

字符串传统格式化方法

• 使用%进行格式化
• %（百分号）也叫占位符
  • %s：字符串
  • %r：字符串，只能使用repr而不是str
  • %c：整数转化为单个字符
  • %d：十进制整数
  • %u：无符号整数
  • %o: 表示八进制
  • %x：十六进制，字母为小写
  • %X：十六进制，字母为大写
  • %e：浮点数，e为小写
  • %E：浮点数，E为大写
  • %f，%F：浮点数十进制形式
  • %g，%G：十进制形式浮点数或者指数浮点数自动转换
  • 格式字符前出现整数表示此占位符所占的宽度
  • 格式字符前出现‘-’表示左对齐
  • 格式字符前出现‘+’表示右对齐
  • 0位数不足用‘0’补齐
  • width表示宽度
  • pricision 精度

# %s 表示简单的字符串
# 占位符可以单独使用
s = "I love %s"
print(s)

print(s%"yan")

I love %s
I love yan

print("I love %s"%"yan")
#占位符一般只能被同类型替换，或者替换类型能被转换成占位符的类型
print("I love %s"%"yan")

s = "任超今年 %d 岁。"
print(s%19)

s = "I am %fKg, weight, %fm Heigh"
#如果需要格式化的信息多余一个，则用括号括起来就可以
#以下打印使用了默认格式没多余打出了好多零
print(s%(76.1,1.84))

#对格式进行限制
ss ="I am %0.2fKg ,weigjt, %0.2fm Heigh"
print(ss%(75.1,1.84)


I am 76.100000Kg, weight, 1.840000m Heigh
I am 75.10Kg ,weigjt, 1.84m Heigh

format 格式化

• 使用函数形式进行格式化，代替以前的百分号

# 不用指定为，按顺序读取
#方式1
s = "{} {}!"
print(s.format("hello","world"))

#方式2
s = "{} {}!".format("hello","world")
print(s)

#设置指定位置
s = "{0} {1}!".format("hello","world")
print(s)

#设置指定位置
s = "{1} {0}!".format("hello","world")
print(s)

#设置指定位置
s = "I love {1} and {0} loves me!".format("hello","world")
print(s)

#设置指定位置
s = "I love {0} and {0} loves me!".format("yan")
print(s)

#设置指定位置(案例报错)
#s = "I love {} and {} loves me!".format("yan")
#print(s)

# 使用命名参数

s = "我们的是{school_name}，我们的网址是{url}，{teacher}最帅"
print(s.format(school_name="华中", url="www.imzqh.cn", teacher="任超"))



hello world!
hello world!
hello world!
world hello!
I love world and hello loves me!
I love yan and yan loves me!
I love yan and yan loves me!
我们的是华中，我们的网址是www.imzqh.cn，任超最帅

# 通过字典设置参数，需要解包
#使用命名参数
s = "我们的是{school_name}，我们的网址是{url}，{teacher}最帅"

s_dict = {"school_name":"北京",\
          "url":"www.imzqh.cn",\
          "teacher":"任超"}

# ** 是解包操作
s = s.format(**s_dict)
print(s)


我们的是北京，我们的网址是www.imzqh.cn，任超最帅

# 对数字的格式化需要用到
s = "I is {:.2f}m heigh, {:.2f}Kg wight"
print(s.format(1.84,74.12))

# ^ ,< ,> 分别是剧中，左对齐，右对齐，后面带宽度
# ：号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充
# + 表示整数前显示 +，负数前显示 - ；
#（空格）表示在整数加空格
# b，d，o，x 分别是 二进制，十进制，八进制，十六进制
# 此外我们可以使用大括号{}来转义大括号

# 大括号转义案例，有问题？？？？
s = "foemat函数是使用{{}}来进行占位的"
print(s.format("{}"))


I is 1.84m heigh, 74.12Kg wight
foemat函数是使用{}来进行占位的

str 内置函数

• 很多语言字符串使用string表示，但是python中用str表示

查找类函数

• 字符串查找类，find, index, islower
• find：查找字符串中是否包含一个子串
• index：跟find的唯一区别就是找不到会报错
• rfind，lfind：从左开始查找或者从右开始查找

s = "renchao"
s1 = "nc"
#返回第一次发现这个字符串的位置
s.find(s1)
#返回 -1,表示没找到
s2 = "aa"
s.find(s2)


-1

#找不到字符串，index会报错
s.index(s2)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-36-b4467a193c8e> in <module>()
----> 1 s.index(s2)

ValueError: substring not found

s = "I love you, you loves me"
s1 = "me"
#定义区间进行查找，从第5个字符开始查找
s.find(s1,5)


22

判断类函数

• 此类函数的特点一般都是用is开头，比如islower

• isalpha：判断是否是字母，需要注意的是亮点：

  • 此函数默认前提是字符串至少包含一个字符，如果没有，同样返回False
  • 含在被认为是alpha，所以，此函数不能作为区分英语字符还是汉子的表示。区分中英文请使用unicode码。
  • 注意使用区别，防止被坑。

• isdigit, isnumeric, isdecimal 三个判断数字的函数

  • 此类函数不建议使用，在后期是否是数字使用正则表达式判断。

# isalpha 案例
# 以下三个都不是的，因为有除了字母以外的空格等
s1 = "落花人独立，微雨燕双飞。"
s2 = "benbeiba is friend of baberbeng"
s3 = "Tu is the 1.st"

print(s1.isalpha())
print(s2.isalpha())
print(s3.isalpha())

False
False
False

内容判断类

• startweith/endswith：是否是以xxx开头或者结尾

  • 检测某个字符串是否以某个子串开头，常用三个参数
  • suffix ：被检查的字符串必须有
  • start：检查一个范围开始开始
  • end：检查一个范围结束结束

• islower/isupper:判断字符串是否是大写或者小写

# 案例,字符串中的字母大小写是不一样的。
dana = "Liu Dana"
xiaojing = "Xiao Jing"

s = "Liu Dana really love wang xiaojing"

print(s.startswith(dana))
print(s.endswith(xiaojing))

True
False

s1 = "Hua love"
s2 = "Hualove"
s3 = "hualove"
# s4 包含空格，但是空格不影响结果。忽略
s4 = "hua love"
s5 = "华爱"

print(s1.islower())
print(s2.islower())
print(s3.islower())
print(s4.islower())
#汉字字符串无大小写概念
print(s5.islower())
print(s5.isupper())


False
False
True
True
False
False

操作类函数

• format：格式化用的
• strip：这个函数主要作用是删除字符串两边的空格，其实这个函数允许你去定义删除字符串两边的哪个字符，只不过如果不指定的话默认是空格。同样还有lstrip和rstrip，此处的l和r分别表示的是左边和右边，即删除字符串左边或者右边指定字符，默认空格。需要注意的是，此处删除不是删除一个，是指从头开始符合条件的连续字符。
• join: 这个函数主要对字符串进行拼接。他需要一个可以叠戴的内容作为参数（迭代的概念，此处理解为列表），功能是把可迭代的字符串拼接在一起中间使用调用字符串作为分隔符。

c = "DDDD love huaaaa "
#是否成功删除两边空格不能观察出来
print(c.strip(),end="------")
print()
print(c.strip('D'), end="------")

DDDD love huaaaa------
 love huaaaa ------

# join案例

s1 = "$"
s2 = "_"
s3 = " "
ss = ["Li ","love","wa","Xiao"]
print(s1.join(ss))
print(s2.join(ss))
print(s3.join(ss))

list列表

• Python中的内置类型
  • str
  • list
  • tuple
  • set
  • dict
• 一组有序数据做成的序列
  • 数据有先后顺序
  • 数据可以不是一类数据
• list 的创建
  • 直接创建，用中括号创建，内容直接使用英文逗号隔开
  • 使用list创建
  • 列表包含单个字符串的时候是一个特例

# 直接复制创建列表
L1 = [1,2,3,4]
# list中的数据可以不是一个类型
L2 = [1,2,3,"Hua","华"]
print(L1)
print(L2)

[1, 2, 3, 4]
[1, 2, 3, 'Hua', '华']

#创建列表的第二种方式
L3 = list()
print(L3)
print(type(L3))

[]
<class 'list'>

内置函数的概念

• help：帮助函数
• type：显示变量类型
• id：显示变量的id
• print：打印

# list 创建的特例演示

s = "Z qh"

#想创建一个质保函s一个字符串的列表
L1 = list(s)
#此种情况使用 L1 = [s]
print(type(L1))
print(L1)

<class 'list'>
['Z', ' ', 'q', 'h']

列表的常见操作

• 访问
  • 使用下表操作，也叫索引
  • 列表的元素索引是从0开始
• 切片操作
  • 对列表进行任意一段的截取
  • 截取之后，创建一个新的列表

L1 = [34,45,56,78,2]
# 使用下标访问
# 记住IndexError是下标出现问题
print(L1[15])


---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-21-8235951f9d6a> in <module>()
      1 L1 = [34,45,56,78,2]
      2 # 使用下标访问
----> 3 print(L1[15])

IndexError: list index out of range

# 切片操作需要注意取值范围，左包括右不包括

L1 = [1,2,3,4,5,6,7,8,9,10]

# 下面结果说明，切片之后生成的是一个全新的列表
# 通过内置函数id可以判断出切片是否生成了一个全新的列表
# id的作用是用来判断两个变量是否是一个变量
print(L1[1:6])

L2 = L1[0:10]
print(id(L1))
print(id(L2))


# 切片下标可以为空
print(L1[:4])
print(L1[2:])
print(L1[:])

[2, 3, 4, 5, 6]
51425488
51425608
[1, 2, 3, 4]
[3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 分片可以控制增长幅度，默认增长幅度为1
print(L1[::1]) #等于print(L1{:})
print(L1[::2])

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 3, 5, 7, 9]

# 下标可以超出范围，超出后不在考虑多余下表内容
print(L1[:100])

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 下标值，增长夫妇可以为负数
# 为负数，表明顺序是从右往左
# 规定：数组最后一个数字的下标是 -1

#下面例子为空，因为默认是从左往右移动
print(L1[-2:-5])

#使用负数下标打印 9 8 7
print(L1[-2:-5:-1])

# 使用负数下标打印 7 8 9
print(L1[-4:-1:1])

[]
[9, 8, 7]
[7, 8, 9]

tuple（元组）

• 可以理解成一个不允许更改的列表

# tuple 的创建

# 1.直接使用小括号创建
ta = ()
print(type(ta))

# 当用小括号创建一个元组tuple的时候

tb = (100)
print(type(tb))
tc = (100,)
print(type(tc))
td = (100, 200, 300)
print(type(td))

# 2.直接使用逗号
ta = 100,
print(type(ta))
tb = 100, 200, 300, #后面可以跟逗号
print(type(tb))

# 3.使用tuple定义

ta = tuple()
print(ta)

li = [1, 2, 3, 'hua']
tb = tuple(li)#要求tuple参数必须可以迭代
print(tb)
print(li)

<class ‘tuple’>
<class ‘int’>
<class ‘tuple’>
<class ‘tuple’>
<class ‘tuple’>
<class ‘tuple’>
()
(1, 2, 3, ‘hua’)
[1, 2, 3, ‘hua’]

tuple其余特征跟list基本一致

• 有序 ，可已使用下标访问
• 可以访问不可以被修改
• 元素可以使任意类型

# tuple 索引操作
la = ["i","love","hua"]
print(la)
ta = tuple(la)
print(ta[2])

[‘i’, ‘love’, ‘hua’]
hua

# tuple 的切片操作
print(ta[:])
print(ta[:2])
print(ta[-1::-1])

(‘i’, ‘love’, ‘hua’)
(‘i’, ‘love’)
(‘hua’, ‘love’, ‘i’)

# 元组的相加
ta = 100, 200, 300
tb = ("I", "love", "hua")
tc = ta + tb
print(tc)

(100, 200, 300, ‘I’, ‘love’, ‘hua’)

# tuple 乘法

tc = tb * 2
print(tc)

(‘I’, ‘love’, ‘hua’, ‘I’, ‘love’, ‘hua’)

# tuple 成员检测
print(tb)

if "hua" in tb:
    print("不爱")
    
if "love" not in tb:
    print("对的")

(‘I’, ‘love’, ‘hua’)
不爱

# 元组遍历

for i in tb:
    print(i)

I
love
hua

# 元组的嵌套，元组里面放元组
ta = ((10, 20, 30), ("I", "love", "hua"), (100, 200, 300))
# 嵌套元组的访问
#1.双层循环访问
for i in ta:
    print(i)
    for j in i:
        print(j)
        
#2.使用单层循环访问
for i,j,k in ta:
    print(i, j, k)
# 上面访问有一个规定，即i，j，k要根元组的元素个数对应
for i,j,k,q in ta:
    print(i, j, k, q)

(10, 20, 30)
10
20
30
('I', 'love', 'hua')
I
love
hua
(100, 200, 300)
100
200
300
10 20 30
I love hua
100 200 300
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-46-4014e47fedee> in <module>()
     12     print(i, j, k)
     13 # 上面访问有一个规定，即i，j，k要根元组的元素个数对应
---> 14 for i,j,k,q in ta:
     15     print(i, j, k, q)

ValueError: not enough values to unpack (expected 4, got 3)

# 常用元组函数
ta = (1, 2, 3, 4, 5, 6, 87, 95, 1, 1, 1)
# len：长度
print(len(ta))
# max：最大值
print(max(ta))
#min:最小值
print(min(ta))
#count:对某一元素计数
print(ta.count(1))
#index:某一元素所在位置
print(ta.index(1))

11
95
1
4
0

# tuple 的特殊用法
a = 100
b = "hua"
# 要求对a，b值进行互换
# 此种用法是python的独门秘籍】
print(a,b)
a, b = b, a
print(a,b)

100 hua
hua 100

set 集合

• 跟数学中集合概念一致
• 内容无序，内容不重复

# 集合的定义

# 1、通过set关键字
sa = set()
print(sa)
li = [1,2,3,4,5,6,7,8,9,48,456,46464,1,2,3,4,5,6]
sb = set(li)
print(sb)

# 2、使用大括号定义

sc = {1,2,3,1,2,3,464,46646}
print(sc)



set()
{46464, 1, 2, 3, 4, 5, 6, 7, 8, 9, 456, 48}
{1, 2, 3, 464, 46646}

# in操作

if 2 in sc:
    print(222)
if 223 in sc:
    print(444)
    
for i in sc:
    print(i)

222
1
2
3
464
46646

# 集合的另一种遍历

sa  = {(1,2,3), (4,5,6), ("I", "love", "hua")}
for i,j,k in sa:
    print(i,j,k)

I love hua
4 5 6
1 2 3

# 集合的生成式

sa = {1,2,3,4,5,6,7,8,9,10}

# 利用sa生成一个sb

sb = {i for i in sa}
print(sb)

sc = {i for i in sa if i % 2 == 0}
print(sc)

# 双重for循环
# 把sa中的每一个元素的平方值生成一个新的集合
# 1、用一个for
sd = { i**2 for i in sa}
print(sd)
# 2、用两个for
se = { m*n for m in sa for n in sa}
print(se)
print(len(se))

{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
{2, 4, 6, 8, 10}
{64, 1, 4, 36, 100, 9, 16, 49, 81, 25}
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 24, 25, 27, 28, 30, 32, 35, 36, 40, 42, 45, 48, 49, 50, 54, 56, 60, 63, 64, 70, 72, 80, 81, 90, 100}
42

# 集合的内置函数
# len：长度
print(len(se))
# max/min:最值
# add：向集合中添加
sa = {1,2,3,4,8}
print(sa.add(7))
print(sa)

# clear 清空

42
None
{1, 2, 3, 4, 7, 8}

# 删除操作
# remove 和 discard 的区别

print(sa)
sa.remove(2)
print(sa)

# remove 删除的值不在集合报错
sa.remove(2)

{1, 3, 4, 7, 8}
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-71-f63816c5664b> in <module>()
      3 
      4 print(sa)
----> 5 sa.remove(2)
      6 print(sa)
      7 

KeyError: 2

# 删除操作
# remove 和 discard 的区别

print(sa)
sa.discard(2)
print(sa)

# discard 删除的值不在集合不会报错
sa.discard(2)
print(sa)

{1, 3, 4, 7, 8}
{1, 3, 4, 7, 8}
{1, 3, 4, 7, 8}

# pop 弹出集合的一个内容
# 删除的内容是随机的
# 删除内容没啥规律，随机

sa = {1,2,3,4,5,6,7}
print(sa)
sa.pop()
print(sa)

{1, 2, 3, 4, 5, 6, 7}
{2, 3, 4, 5, 6, 7}

# 集合的数学操作

sa = {1,2,3,4,5,6}
sb = {5,6,7,8,9,0}

# intersection ：交集
# sa 和 sb 的交集
print(sa.intersection(sb))

# difference ：差集
print(sa.difference(sb))
# 差集的另一种表示
print(sa - sb)

# union :并集
print(sa.union(sb))
#并集的另一种表示形式，是不行的
print(sa + sb)


{5, 6}
{1, 2, 3, 4}
{1, 2, 3, 4}
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-80-fb7ae8f7dea7> in <module>()
     16 print(sa.union(sb))
     17 #并集的另一种表示形式
---> 18 print(sa + sb)

TypeError: unsupported operand type(s) for +: 'set' and 'set'

frozenset 冰冻集合

• 不允许修改的集合

# 案例
print(sa)
sb = frozenset(sa)
print(sb)

{1, 2, 3, 4, 5, 6}
frozenset({1, 2, 3, 4, 5, 6})