Python Day5-字符串-操作-常用函数-遍历

1.字符串拼接

方法一： ’ '.join()方法

a = [‘a’,‘b’,‘c’,‘d’]
content =’’
content=’’.join(a)
print content

方法二：用替换占位符

a = [‘a’,‘b’,‘c’,‘d’]
content =’’
content=’%s%s%s%s’% tuple(a)
print content

方法三： =+ （效率低）

a=‘a’
b=‘b’
c=‘c’
d=‘d’
content =’’
content= a+b+c+d
print content

2.字符串截取

s = ‘ILovePython’
print s[0] #从左往右截取结果：I
print s[-1] #从右往左截取加‘-’号结果:n
print s[1:5] #范围截取从下标1截取到下标5 结果：Love

3.字符串替换

方法一：用replace方法替换
a=‘Hello World’
a=a.replace(‘World’,‘python’)
print a

方法二:用正则表达式替换

a=‘Hello World’
import re
strinfo = re.compile(‘World’)
b = strinfo.sub(‘python’,a)
print b

4.获取字符串的长度 len方法

a=‘Hello World’
print len(a)

5.分割字符串 split 方法

str = ‘a,b,c,d’
strlist = str.split(’,’)

6.内置函数操作

内置函数操作：len()
输入，输出：
s = input(“请输入字符串：”)
s1 = “%dgh%.2fjkl%s”
s2 = “23456”
print(s1,s2,2) #多输出
print(s1,s2,end=";")#换行
py2 print s1,s2
print(s1%(123,3.14,“456”))
print(round(3.1465926,2))

7.Python 切片

 print(s[9])print(s[0:5])print(s[:5])print(s[1:])print(s[:])print(s[0:5:2])print(s[-1:-10:-1])print(s[8:-1:-1])

Python切片是对一个列表取其部分元素获得一个子序列的常见操作，切片操作的返回结果类型与被切片的对象一致。要创建一个已有列表的切片，通过指定切片的第一个列表元素和最后一个列表元素的索引号即可。

其基本语法如下：
list_slice = source_list[start: end :step]

其中，
source_list：被切片的源列表
list_slice：切片后生成的子序列列表
start：切片起始索引位置，省略则从头开始
end：切片结束索引位置，省略则切至列表末尾
step：切片步长，可选参数，表示每N个元素取一个，默认为1

*** 注意：
1、切片和range()函数一样，Python会自动到达所指定切片结束索引位置的前面一个元素停止。
2、负数索引返回离列表末尾相应间隔的元素。列表末尾元素的索引是从-1开始的。***

例如：

my_menu = ['fish','pork','pizza','carrot']
print(my_menu[1:4:2]) #开始索引为1，结束索引为4，每2个取一个的第一个
print(my_menu[:3])  #结束索引位置，其他默认
print(my_menu[2:])  #开始索引位置，其他默认
print(my_menu[-3:]) #负索引开始位置，其他默认输出结果：
[‘pork’,‘carrot’]
[‘fish’,‘pork’,‘pizza’]
[‘pizza’,‘carrot’]
[‘pork’,‘pizza’,‘carrot’]

8.Python 自带函数

1.count()函数

描述：统计字符串里某个字符出现的次数。可以选择字符串索引的起始位置和结束位置。

语法：str.count(“char”, start,end) 或 str.count(“char”) -> int 返回整数

str —— 为要统计的字符(可以是单字符，也可以是多字符)。
star —— 为索引字符串的起始位置，默认参数为0。
end —— 为索引字符串的结束位置，默认参数为字符串长度即len(str)。

程序示例：

str = "i love python,i am learning python"
print(str.count("i")) #star 和end 为默认参数
print(str.count("i",2)) # star值为2，end值为默认参数
print(str.count("i",2,5)) #star值为2，end值为5
print(str.count("am"))  #多字符统计程序运行结果：
3
2
0
1

2.isalpha()函数

描述：检测字符串是否只由字母组成。

语法：str.isalpha() -> bool 返回值为布尔类型（True,False）

字符串中至少有一个字符且所有字符都是字母则返回 True,否则返回 False。

# print(s1.isalpha())
程序示例：
str1 = "python" #全为字母
str2 = " python" #存在空格
str3 = "123"  #全为数字
str4 = "python666"   #字母和数字的组合
print(str1.isalpha())
print(str2.isalpha())
print(str3.isalpha())
print(str4.isalpha())程序运行结果：
True
False
False
False

3.upper()函数

描述：将字符串中的所有小写字母转换为大写字母。

语法： str.upper() -> str 返回字符串

# print(s1.upper().)
程序示例：
str1 = "i love python"  #全为小写字母
str2 = "I Love Python"  #所有单词首字母大写
print(str1.upper())
print(str2.upper())
程序运行结果：
I LOVE PYTHON
I LOVE PYTHON

4.lower()函数

描述：将字符串中的所有大写字母转换为小写字母。

注意： lower()函数和casefold()函数的区别：lower() 方法只对ASCII编码，即‘A-Z’有效，对于其它语言中把大写转换为小写的情况无效，只能用 casefold() 函数。

语法：str.lower() -> str 返回字符串

程序示例：
# print(s1.lower())
str1 = "I Love Python"
str2 = "Groß - α" #德语 大写α
print(str1.casefold())
print(str1.lower())
print(str2.casefold())
print(str2.lower())
程序运行结果：
i love python
i love python
gross - α
groß - α

5.replace()函数：解决替换问题：

描述：返回字符串str的副本，所有old子字符串被替换为new字符串。

语法：str.replace(old, new, count) -> str 返回字符串str的副本

old —— 将被替换的子字符串。
new —— 新子字符串，用于替换old子字符串。
count —— 替换的次数，默认全部替换。

程序示例：
# print(s.replace("天","hi",1))
s = "i love python python "
print(s.replace("o","w")) #默认字符串中的全部"o" 全部替换为"w"
print(s.replace("o","w",2)) #只替换掉前两个子字符串 "o"
print(s.replace("python","c++"))  #子字符串可以是多个字符。
print(s.replace("python","c++",1))
程序运行结果：
i lwve pythwn pythwn
i lwve pythwn python
i love c++ c++
i love c++ python

6.join()函数

描述：将iterable变量的每一个元素后增加一个str字符串。

语法： str.join(iterable) -> str 返回字符串即：返回一个以str作为分隔符，将iterable中的各元素合并连接成一个新的字符串。

str——分隔符。可以为空。
iterable—— 要连接的变量，可以是字符串，元组，字典，列表等。

 # print(s.join(s1))
程序示例：
#对列表进行操作
l = ["1","2","3"]
print(" ".join(l)) #以空格为分隔符
print(",".join(l)) #以逗号为分隔符#对字符串进行操作
str = "python"
print(" ".join(str)) #以空格为分隔符
print(",".join(str)) #以逗号为分隔符#对字典进行操作
d = {"a":1,"b":2,"c":3}
print(" ".join(d)) #以空格为分隔符
print(",".join(d)) #以逗号为分隔符#对元组进行操作
s = ("1","2","3")
print(" ".join(s)) #以空格为分隔符
print(",".join(s)) #以逗号为分隔符程序运行结果：
1 2 3
1,2,3p y t h o n
p,y,t,h,o,nb c a
b,c,a1 2 3
1,2,3

7.strip()函数-解决字符串两端：

描述：从字符串str中去掉在其左右两边chars中列出的字符。

注：chars传入的是一个字符数组，编译器去除两端所有相应的字符，直到出现第一个在chars中不匹配的字符。详看示例。
语法： str.strip(chars) -> str 返回一个新的字符串

chars —— 要去除的字符默认为空格或换行符。

# print(s.strip(','))
程序示例：
str = "123456789321"
print(str.strip("123")) #除去123，对于字符串str右边，1 在 "123"中去除，2在"123"中去除，同理3也去除，但9不在"123"中,去除结束
str1 = "my name is ymyyyy"
print(str1.strip("my"))  #"my" 无空格，字母n前的空格不去掉。
print(str1.strip("my ")) #"my "有空格，所以str1左边字母n前的空格被去掉。程序运行结果：
456789name is
name is

8. lstrip()函数

描述：从字符串str中去掉在其左边chars中列出的字符。

注：chars传入的是一个字符数组，编译器去除两端所有相应的字符，直到出现第一个在chars中不匹配的字符。详看示例。

语法：str.lstrip(chars) -> str 返回一个新的字符串

chars —— 要去除的字符默认为空格或换行符。

# print(s.lstrip(','))
程序示例：
str1 = "bacjabck123kluabc"
print(str1.lstrip("abc"))  #只去掉左边的"bac",左边第4个字符j不在"abc"中，去除结束
str2 = "12578asdfgh12"
print(str2.lstrip("12")) #只去掉字符串str2左边的 12程序运行结果：
jabck123kluabc
578asdfgh12

9.rstrip()函数

描述：从字符串str中去掉在其右边chars中列出的字符。

注：chars传入的是一个字符数组，编译器去除两端所有相应的字符，直到出现第一个在chars中不匹配的字符。详看示例。。

语法：str.rstrip(chars) -> str 返回一个新的字符串

chars —— 要去除的字符默认为空格或换行符。

# print(s.rstrip(','))
程序示例：
str1 = "abcjabck123kluabcca"
print(str1.rstrip("abc"))  #只去掉右边的"abcca",右边第6个字符u不在"abc"中，去除结束
str2 = "12asdfgh11112"
print(str2.rstrip("12")) #只去掉字符串str2右边的 11112
程序运行结果：
abcjabck123klu
12asdfgh

10.split()函数

描述：拆分字符串。通过指定分隔符sep对字符串进行分割，并返回分割后的字符串列表。

语法： str.split(sep=None, maxsplit=-1) -> list of strings 返回字符串列表或str.split(sep=None, maxsplit=-1)[n]

sep —— 分隔符，默认为空格,但不能为空即(")。
maxsplit —— 最大分割参数，默认参数为-1。
[n] —— 返回列表中下标为n的元素。列表索引的用法。

# print(s.split(','))
程序示例：
str1 = "i love python"
str2 = "https://www.baidu.com"
str3 = "script<i love python>script"
str4 = "i \n love \n python"
print(str1.split()) #默认空格分割。
print(str2.split("."))#以"."为分隔符,maxsplit默认为-1
print(str2.split(".",-1)) #maxsplit为-1
print(str2.split(".",1)) #以"."为分隔符,分割一次。
print(str2.split(".")[1]) #分割后，输出列表中下标为1的元素
print(str3.split("<")[1].split(">")[0])
print(str4.split("\n")) #可用于去掉字符串中的"\n" "\t"等程序运行结果：
['i', 'love', 'python']
['https://www', 'baidu', 'com']
['https://www', 'baidu', 'com']
['https://www', 'baidu.com']
baidu
i love python
['i ', ' love ', ' python']

11.encode()函数-解决编码问题：

描述：以指定的编码格式编码字符串，默认编码为 ‘utf-8’。

注：在python中encode和decode分别指编码和解码

语法：str.encode(encoding=‘utf-8’, errors=‘strict’) -> bytes (获得bytes类型对象)

encoding 参数可选，即要使用的编码，默认编码为 ‘utf-8’。字符串编码常用类型有：utf-8,gb2312,cp936,gbk等。
errors 参数可选，设置不同错误的处理方案。默认为 ‘strict’,意为编码错误引起一个UnicodeEncodeError。其它可能值有 ‘ignore’, ‘replace’, 'xmlcharrefreplace’以及通过 codecs.register_error() 注册其它的值。

# print(s.encode("utf-8"))
程序示例：
str1 = "我爱祖国"
str2 = "I love my country"
print("utf8编码：",str1.encode(encoding="utf8",errors="strict")) #等价于print("utf8编码：",str1.encode("utf8"))
print("utf8编码：",str2.encode(encoding="utf8",errors="strict"))
print("gb2312编码：",str1.encode(encoding="gb2312",errors="strict"))#以gb2312编码格式对str1进行编码，获得bytes类型对象的str
print("gb2312编码：",str2.encode(encoding="gb2312",errors="strict"))
print("cp936编码：",str1.encode(encoding="cp936",errors="strict"))
print("cp936编码：",str2.encode(encoding="cp936",errors="strict"))
print("gbk编码：",str1.encode(encoding="gbk",errors="strict"))
print("gbk编码：",str2.encode(encoding="gbk",errors="strict"))程序运行结果：
utf8编码： b'\xe6\x88\x91\xe7\x88\xb1\xe7\xa5\x96\xe5\x9b\xbd'
utf8编码： b'I love my country'
gb2312编码： b'\xce\xd2\xb0\xae\xd7\xe6\xb9\xfa'
gb2312编码： b'I love my country'
cp936编码： b'\xce\xd2\xb0\xae\xd7\xe6\xb9\xfa'
cp936编码： b'I love my country'
gbk编码： b'\xce\xd2\xb0\xae\xd7\xe6\xb9\xfa'
gbk编码： b'I love my country'

12.index()函数

描述：查找字符串中第一次出现的子字符串的位置，可以规定字符串的索引查找范围[star,end)。若无则会报错。

注：index()函数和find()函数类似，但index()函数没有找到子字符串会报错。

语法：str.index(sub, start, end) -> int 返回整数

sub —— 查找的子字符串。
start —— 索引的起始位置，默认为0。
end —— 索引的结束位置，默认为字符串的长度。
[star,end)

# print(s.index("天"))
程序示例：
str = "i love python"
print(str.index("o"))  #默认索引整个字符串
print(str.index("o",4))  #索引 ve python
print(str.index("o",4,12)) #索引 ve pytho
print(str.index("love"))    #索引多个字符
print(str.index("k"))    #索引字符串不存在，报错程序运行结果：
3
11
11
2
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-90-a880e13b1574> in <module>()4 print(str.index("o",4,12)) #索引 ve pytho5 print(str.index("love"))    #索引多个字符
----> 6 print(str.index("k"))ValueError: substring not found

13. find()函数-解决查找指定字符(子字符串)位置问题：

描述：查找字符串中指定的子字符串sub第一次出现的位置，可以规定字符串的索引查找范围。若无则返回 -1。

语法：str.find(sub,start,end) -> int 返回整数

sum —要索引的子字符串。
start —索引的起始位置。默认值为0。
end —索引的结束位置。默认值为字符串长度len(str)。
[start,end) 不包括end。

# print(s.find("真好"))
程序示例：
str = "i love python"
print(str.find("o")) #索引子字符串"o"
print(str.find("0",4))#索引起始位置为4 索引范围为：ve python
print(str.find("o",4,12))#索引起始位置为4,结束位置为12 索引范围为：ve pytho
print(str.find(""))
print(str.find(" "))#返回第一个空格出现的位置。
print(str.find("k")) #索引子字符串"k",不存在，返回-1程序运行结果：
3
-1
11
0
1
-1

14. endswith()函数-解决判断问题(返回bool类型)

描述：判断字符串是否以指定字符或子字符串结尾。

语法：str.endswith(“suffix”, start, end) 或 str[start,end].endswith(“suffix”) 用于判断字符串中某段字符串是否以指定字符或子字符串结尾。

—> bool 返回值为布尔类型（True,False）

suffix — 后缀，可以是单个字符，也可以是字符串，还可以是元组（"suffix"中的引号要省略，常用于判断文件类型）。
start —索引字符串的起始位置。
end — 索引字符串的结束位置。
str.endswith(suffix) star默认为0，end默认为字符串的长度len(str)
注意：空字符的情况。返回值通常为True

# print(s.endswith(".py"))
程序示例：
str = "i love python"
print("1:",str.endswith("n"))
print("2:",str.endswith("python"))
print("3:",str.endswith("n",0,6))# 索引 i love 是否以“n”结尾。
print("4:",str.endswith("")) #空字符
print("5:",str[0:6].endswith("n")) # 只索引 i love
print("6:",str[0:6].endswith("e"))
print("7:",str[0:6].endswith(""))
print("8:",str.endswith(("n","z")))#遍历元组的元素，存在即返回True，否者返回False
print("9:",str.endswith(("k","m")))#元组案例
file = "python.txt"
if file.endswith("txt"):print("该文件是文本文件")
elif file.endswith(("AVI","WMV","RM")):print("该文件为视频文件")
else:print("文件格式未知")程序运行结果：
1: True
2: True
3: False
4: True
5: False
6: True
7: True
8: True
9: False
该文件是文本文件

15.startswith()函数

描述：判断字符串是否以指定字符或子字符串开头。

注意：空字符的情况。返回值通常也为True

语法：str.endswith(“suffix”, start, end) 或str[start,end].endswith(“suffix”) 用于判断字符串中某段字符串是否以指定字符或子字符串结尾。

—> bool 返回值为布尔类型（True,False）

suffix — 后缀，可以是单个字符，也可以是字符串，还可以是元组（"suffix"中的引号要省略）。
start —索引字符串的起始位置。
end — 索引字符串的结束位置。
str.endswith(suffix) star默认为0，end默认为字符串的长度减一（len(str)-1）。

# print(s.startswith(",",1,6))
程序示例：
str = "hello,i love python"
print("1:",str.startswith("h"))
print("2:",str.startswith("l",2,10))# 索引 llo,i lo 是否以“n”结尾。
print("3:",str.startswith("")) #空字符
print("4:",str[0:6].startswith("h")) # 只索引  hello,
print("5:",str[0:6].startswith("e"))
print("6:",str[0:6].startswith(""))
print("7:",str.startswith(("h","z")))#遍历元组的元素，存在即返回True，否者返回False
print("8:",str.startswith(("k","m")))程序运行结果：
1: True
2: True
3: True
4: True
5: False
6: True
7: True
8: False

16. isupper()函数

描述：检测字符串中的字母是否全由大写字母组成。（字符串中可包含非字母字符）。

语法：str.isupper() -> bool 返回值为布尔类型（True,False）

字符串中包含至少一个区分大小写的字符，且所有这些区分大小写的字符都是大写，则返回 True，否则返回 False。

# print(s1.isupper())
程序示例：
str1 = "I LOVE PYTHON"  #全为大写字母
str2 = "i LOVE PYTHON"  #存在小写字母
str3 = "我爱PYTHON"   #存在非字母的字符
print(str1.isupper())
print(str2.isupper())
print(str3.isupper())
程序运行结果：
True
False
True

17. islower()函数

描述：检测字符串中的字母是否全由小写字母组成。（字符串中可包含非字母字符）

语法：str.islower() -> bool 返回值为布尔类型（True,False）

字符串中包含至少一个区分大小写的字符，且所有这些区分大小写的字符都是小写，则返回 True，否则返回 False。

# print(s1.islower())
程序示例：
str1 = "i love python"  #字符串中的字母全为小写
str2 = "我爱python！"  #字符串中的字母全为小写，也存在非字母的字符
str3 = "I love python" #字符串中有大写字符
print(str1.islower())
print(str2.islower())
print(str3.islower())程序运行结果：
True
True
False

18. isdigit()函数

描述：检测字符串是否只由数字组成.

注：能判断“①”，不能判断中文数字。但 isnumeric() 函数可以。

语法： str.isdigit() -> bool 返回值为布尔类型（True,False）

字符串中至少有一个字符且所有字符都是数字则返回 True,否则返回 False。

# print(s2.isdigit())
程序示例：
str1 = "python" #全为字母
str2 = " python" #存在空格
str3 = "123"  #全为数字
str4 = "python666"   #字母和数字的组合
str5 = "一二三四五六七" #中文数字输出False
str6 = "①"
print(str1.isdigit())
print(str2.isdigit())
print(str3.isdigit())
print(str4.isdigit())
print(str5.isdigit())
print(str6.isdigit())程序运行结果：
False
False
True
False
False
True

19.isalnum()函数

语法：str.isalnum() -> bool 返回值为布尔类型（True,False）

str中至少有一个字符且所有字符都是字母或数字则返回 True,否则返回 False

# print(s1.isalnum())
程序示例：
str1 = "i love python 666"  #有空格，不全是字母或数字
str2 = "python" #全为字母
str3 = "123"  #全为数字
str4 = "python666"  #字母和数字的组合
print(str1.isalnum())
print(str2.isalnum())
print(str3.isalnum())
print(str4.isalnum())程序运行结果：
False
True
True
True

20. ljust()函数

描述：返回一个原字符串左对齐,并使用fillchar填充(默认为空格)至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串

语法： str.ljust(width, fillchar) -> str 返回一个新的字符串

width —— 指定字符串的输出长度。
fillchar—— 将要填充的单字符，默认为空格。

# print(s.ljust(15,"*"))
程序示例：
str = "python"
print(str.ljust(30,"*")) #指定宽度为30，填充字符为*
print(str.ljust(30))  #指定宽度为30，填充字符默认为空格
print(str.ljust(30),"1") #对比程序运行结果：
python************************
python
python

21. rjust()函数

描述：返回一个原字符串右对齐,并使用fillchar填充(默认为空格)至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

语法： str.ljust(width, fillchar) -> str 返回一个新的字符串

width —— 指定字符串的输出长度。
fillchar—— 将要填充的单字符，默认为空格。

# print(s.rjust(15,"*"))
程序示例：
str = "python"
print(str.rjust(30,"*")) #指定宽度为30，填充字符为*
print(str.rjust(30))  #指定宽度为30，填充字符默认为空格
print("1",str.rjust(30)) #对比
程序运行结果：
************************pythonpython
1                         python

22.center()函数-解决字符串填充问题：

描述：返回一个长度为width,两边用fillchar(单字符)填充的字符串，即字符串str居中，两边用fillchar填充。若字符串的长度大于width,则直接返回字符串str。

语法：str.center(width , “fillchar”) -> str 返回字符串注意：引号不可省

width —— 指定字符串长度。
fillchar —— 要填充的单字符，默认为空格。

# print(s.center(15,"*"))
程序示例：
str = "i love python"
print(str.center(20,"*")) #指定字符串长度为20 用单字符"*"填充
print(str.center(1,"*")) #指定字符串长度为1，小于原字符串的长度。
print(str.center(20,"8"))
print(str.center(20)) #fillchar 默认为空格程序运行结果：
***i love python****
i love python
888i love python8888i love python

23.python 列表的遍历，列表解析、切片等基础知识

遍历列表

 for i in range(0,len(s)):print(s[i])for i in s:print(i)

l=[1,3,4,5,6,7,8,9]for i in l:print(i)   #循环打印列表中的每个元素

range方法的使用

range(i,j)方法 从i 开始 到j结束 ，不包括j   for i in range(1,5) :print(i) # 1,2,3,4 range(i,j,step)  冲i开始，每次按照step增加步长，到j结束，不包括jfor i in range(1,10,2):    l.append(i)  # 1,3,5,7,9

列表解析：

l=[x**2 for x in range(1,5)]   遍历每个元素，并平方l=[1, 4, 9, 16]l=[x**3 for x in range(1,10,2）] l=[1, 8, 27, 64, 125, 216, 343, 512, 729]生成一个100以内的奇数l=[x for x in range(1,100) if x%2==1]函数 sum() min() max()的使用sum(l)  求l 列表的和max(l) 求l列表中最大值min(l) 求l列表中最小值

切片：

arr=[1,2,3,4,5,6,7,8,9]print(arr[0:4]) #取前面4个元素   1  2  3  4print(arr[1:4]) #取第2 到4个元素  2  3  4 print(arr[:4])   #取前面4个元素  1 2 3 4 print(arr[2:])  #从第3个开始，取到末尾 3 4 5 6 7 8 9print(arr[-3:]) #从到处第3个开始，取到末尾