数据类型转换¶

# 将字符串转换成布尔值

bool(""),bool("1")

(False, True)

# 数字字符串转化成数字

int("998")

998

字符串处理¶

# 字符串可进行加+运算和*运算

"1"+"2" # 1和2拼接

'12'

"2"*2  # 两个2拼接

'22'

字符串的索引与切片¶

索引即下标,初始值为0¶

a = "1234567"

a[0]

'1'

a[-1]

'7'

a[7] # 索引越界抛出异常

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-10-8be90b1d10e7> in <module>()
----> 1a[7] # 索引越界抛出异常

IndexError: string index out of range

切片就是通过索引截取字符串的一段,形成新的字符串¶

a = "1234567"

a[0:3] # 从第0个到第3个元素,不包含第3个

'123'

a[0:-1] # -1是最后一个,不包含最后一个

'123456'

a[0:] # 全部

'1234567'

a[:]  # 全部

'1234567'

a[0:5:2] # 加步长

'135'

a[5:0:-2] # 如果索引由前向后，步数是负数或者索引由后向前，步数是正数则不会打印

'642'

字符串的相关函数¶

# 字符串是不可变数据类型,他调用方法会返回一个新的字符串

大小写¶

a = "my Name"

# capitalize()首字母大写

a.capitalize()

'My name'

# 函数不会改变原字符串

a

'my Name'

# swapcase()大小写反转

a.swapcase()

'MY nAME'

# title()每个单词的首字母大写

a.title()

'My Name'

# upper()全部大写

a.upper()

'MY NAME'

# lower()全部小写

a.lower()

'my name'

编辑¶

# center(n,"*") # 内同居中,总长度为n,长度不足n两边填充*,字符串长度超过n不会改变

a = "me"

a.center(6,"*")

'**me**'

a.center(1,"*")

'me'

删除两端内容¶

a = "     me    "

# lstrip()删除字符串前端空白

a.lstrip()

'me    '

# rstrip()删除字符串后端空白

a.rstrip()

'     me'

# strip()删除字符串两端空白

a.strip()

'me'

# 上面三个函数默认删除空白,可以指定删除的内容

name = "ni shi shuai bi shi ni"

name.strip("nish ") # 删除字符串两端的"n","i","s","h "直至中断

'uai b'

查找字符串中的元素¶

# find()返回的找到的元素的索引，如果找不到返回-1

name.find("wo")

-1

name.find("ni")  # 只返回第一个找到的索引

0

name.find("ni",3,) # 指定起始位置

20

name.find("ni",3,10) # 起始位置,终止为止

-1

# index() 返回的找到的元素的索引，找不到报错。

name.index("wo")

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-57-a1f9511612c6> in <module>()
----> 1name.index("wo")

ValueError: substring not found

name.index("ni")

0

name.index("ni",3,)

20

name.index("ni",3,10)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-60-961dc9ce91e1> in <module>()
----> 1name.index("ni",3,10)

ValueError: substring not found

字符串切割¶

#split()以指定元素分割，最终形成一个列表，此列表不含有这个分割的元素。
# 且以字符串中第一个元素分割时，会产生一个空字符串。

a = "abcacbbacabc"

a.split("ab")

['', 'cacbbac', 'c']

a.split("ab",1) # 指定分割次数

['', 'cacbbacabc']

a.rsplit("ab",1) # 从后向前分割,指定分割次数

['abcacbbac', 'c']

字符串替换¶

a = "abcacbbacabc"

a.replace("ab","AB") # 默认全部替换

'ABcacbbacABc'

a.replace("ab","AB",1) # 指定替换次数

'ABcacbbacabc'

字符串中元素出现的次数¶

a = "abcacbbacabc"

a.count("ab")

2

a.count("ab",2) # 指定起始位置

1

a.count("ab",2,5) # 起始位置,终止位置

0

字符串的判断¶

a = "123abc"

b = "123_abc"

c = "abcdef"

d = "123456"

# isalnum() 检查是否字符串由字母或数字组成

a.isalnum(),b.isalnum(),c.isalnum(),d.isalnum()

(True, False, True, True)

# isalpha() 检查字符串只由字母组成

a.isalpha(),b.isalpha(),c.isalpha(),d.isalpha()

(False, False, True, False)

# isdigit() 检查字符串只由数字组成

a.isdigit(),b.isdigit(),c.isdigit(),d.isdigit()

(False, False, False, True)

# endswith('xxx',x,y) endswith 判断是否以xxx结尾 顾头不顾腚

c.endswith('def')

True

c.endswith('c',1,3)

True

# startswith("xxx",1,4)   #startswith 判断是否以开头

c.startswith('abc')

True

c.startswith('bc',1)

True

字符串的长度¶

a = "0123456"

len(a) # 元素个数而不是最大索引值

7

格式化输出¶

使用%格式化¶

"His name is %s"%("V") # 字符串

'His name is V'

"His name is %r"%("V") # 原始数据

"His name is 'V'"

"He is %d years old"%(20) # 整数

'He is 20 years old'

"His height is %f m"%(1.75) # 浮点数

'His height is 1.750000 m'

"His height is %.2f m"%(1.75) # 保留指定位小数

'His height is 1.75 m'

"Name:%10s Age:%8d Height:%8.2f"%("V",20,1.75) # 指定占位符宽度

'Name:         V Age:      20 Height:    1.75'

"Name:%-10s Age:%-8d Height:%-8.2f"%("V",20,1.75) # 指定占位符宽度,左对齐

'Name:V          Age:20       Height:1.75    '

"I'm %(c)s. I have %(l)d yuan." % {'c':'V','l':1} # 使用字典传值

"I'm V. I have 1 yuan."

format()函数¶

# 使用占位符{}代替占位符%

"{},{}".format("wei",18) # #通过位置替换有多少个{}就要传递多少参数

'wei,18'

"{1},{0},{1}".format("wei",18,) 
#通过参数的索引替换{}，可以接受不限个参数，参数索引不能超出

'18,wei,18'

"{name},{age}".format(name="wei",age=18) #通过关键字传参，

'wei,18'

# 传递列表中的元素
p=['wei',18]
'{0[0]},{0[1]}'.format(p) # 0是第一个参数

'wei,18'

#传递字典中的元素
p={"name":"wei","age":18}
'{0[name]},{0[age]}'.format(p)

'wei,18'

# 填充与对齐
#^，<,>分别是居中，左对齐，右对齐。后面带长度
#:后面是填充的字符，只能是一个字符，不指定默认使用空格

"{:>8}".format("1")

'       1'

"{:0>8}".format("1")

'00000001'

"{:0^8}".format("1")

'00010000'

# 精度

"{:.2f}".format(3.1415926) # .2表示小数点后两位，f表示float

'3.14'

# 进制

"{:b}".format(10)# 二进制

'1010'

"{:d}".format(10)# 十进制

'10'

"{:o}".format(10)# 八进制

'12'

"{:x}".format(10)# 十六进制

'a'

# 千分位分隔符

"{:,}".format(21312324234)

'21,312,324,234'

re模块,正则匹配¶

import re

re.findall()和re.finditer()¶

# re.findall接收表达式和字符串，返回所有满足匹配条件的结果放在列表里
# re.finditer同re.findall，不过re.fanditer将返回一个包含匹配信息的对象放在一个迭代器中。
# 调用group()方法可以得到匹配的字符串

re.findall("a","an apple") # 正则表达式,字符串

['a', 'a']

re.finditer("a","an apple")

<callable_iterator at 0x1b50526c0f0>

for i in re.finditer("p","an apple"):
    print(i)

<_sre.SRE_Match object; span=(4, 5), match='p'>
<_sre.SRE_Match object; span=(5, 6), match='p'>

for i in re.finditer("p","an apple"):
    print(i.group())

p
p

# findall()的优先级查询

re.findall("www\.(baidu|oldboy)\.com","www.baidu.com") 
# findall会优先把匹配结果组里内容返回，如果想要匹配结果，取消权限即可

['baidu']

#在组前加?:即可取消权限
re.findall("www\.(?:baidu|oldboy)\.com","www.baidu.com")

['www.baidu.com']

re.search()和re.match()¶

# re.search函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,
# 如果字符串没有匹配，则返回None。该对象可以 通过调用group()方法得到匹配的字符串,

# re.match同search，不过他是在字符串开始处进行匹配

re.search("a","an apple")

<_sre.SRE_Match object; span=(0, 1), match='a'>

re.search("a","an apple").group()

'a'

re.search("b","an apple") # 返回None

re.search("b","an apple").group()

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-142-4ef12f5302f4> in <module>()
----> 1re.search("b","an apple").group()

AttributeError: 'NoneType' object has no attribute 'group'

re.match("p","an apple") # 匹配开头

re.match("a","an apple")

<_sre.SRE_Match object; span=(0, 1), match='a'>

re.split()分割¶

# 接受一个表达式和一个字符串，用匹配到的字符或字符组中的每一个元素去分割字符串，
# 得到一个列表，也可以传递参数，选择分割次数

re.split('[ab]', 'abcd') # 按a或b分割,先分割a,在分割b

['', '', 'cd']

re.split('[ab]', 'abcd',1) # 分割一次

['', 'bcd']

# split的优先级
# 在匹配部分加上（）之后所切出得结果是不同的，
# 没有（）的没有保留用来切割的元素，但是有（）的能用来切割的元素
# 这个在某些需要保留匹配部分的使用过程是十分重要的

re.split("\d","ef2sf3esq1w21")

['ef', 'sf', 'esq', 'w', '', '']

re.split("(\d)","ef2sf3esq1w21") # 保留了切出来的元素,也有切出来的空格

['ef', '2', 'sf', '3', 'esq', '1', 'w', '2', '', '1', '']

re.sub和re.subn¶

re.sub("\d","h","1g23g4g5g6",1) # 将/d匹配到的元素替换成h,替换一次

'hg23g4g5g6'

re.sub("\d","h","1g23g4g5g6") # 默认全部替换

'hghhghghgh'

# subn(),不止返回一个替换后的字符串,还返回了替换次数

re.subn("\d","h","1g23g4g5g6",1)

('hg23g4g5g6', 1)

re.subn("\d","h","1g23g4g5g6")

('hghhghghgh', 6)

re.compile¶

# 将正则表达式编译成为一个正则表达式对象，再去调用其他方法，参数为待匹配的字符串

obj=re.compile("\d{3}")

obj

re.compile(r'\d{3}', re.UNICODE)

obj.search("123sad124").group()

'123'

obj.findall("123sad124")

['123', '124']

匹配标签¶

# 利用?P<name>的形式给分组起名
# 获取的匹配结果可以直接用group("name")的形式拿到对应的值

ret = re.search("<(?P<name>\w+)>\w+</(?P=name)>","<h1>hello</h1>")

ret

<_sre.SRE_Match object; span=(0, 14), match='<h1>hello</h1>'>

ret.group("name")

'h1'

ret.group()

'<h1>hello</h1>'

# 也可以用\序号来找到对应的组，表示要找到的内容和前面组的内容一致
# 获取的匹配结果可以直接用group(序号)拿到对应的值

ret1=re.search(r"<(\w+)>\w+</\1>","<h1>hello<h1>")

ret.group(1)

'h1'

ret.group()

'<h1>hello</h1>'

瓜田月夜

基础数据类型 -- 字符串

数据类型转换¶

字符串处理¶

字符串的索引与切片¶

索引即下标,初始值为0¶

切片就是通过索引截取字符串的一段,形成新的字符串¶

字符串的相关函数¶

大小写¶

编辑¶

删除两端内容¶

查找字符串中的元素¶

字符串切割¶

字符串替换¶

字符串中元素出现的次数¶

字符串的判断¶

字符串的长度¶

格式化输出¶

使用%格式化¶

format()函数¶

re模块,正则匹配¶

re.findall()和re.finditer()¶

re.search()和re.match()¶

re.split()分割¶

re.sub和re.subn¶

re.compile¶

匹配标签¶

公告