Python字符串

十，字符串

字符串的定义与输入

在python中，用引号引起来的都是字符串。还有input函数输入的，str函数转换的

示例

?

1 2 3 4 5 6 7 8 9

string1 = "hello" string2 = 'hello' string3 = """hello python""" string4 = '''hello world''' string5 = input("input anything: ") string6 = str(18) print(isinstance(string1, str))

?

1	isinstance判断数据类型返回True或者False

字符串的拼接

以下三种方式拼接字符串

?

1 2 3 4 5 6

name = "张三" age = "23" str1 = "==="+name+"===" str2 = "===%s==="%(name) str3 = "==={}===".format(name) print(str1, str2, str3)

  字符串的下标

字符串,列表，元组都属于序列，所以都会有下标

什么是下标

 

 

 示例：将字符串遍历打印

?

1 2 3

str1 = "Hello Python" for i in str1:     print(i,end=" ")

示例: 将字符串遍历打印,并对应打印出下标

?

1 2 3

str1 = "Hello Python" for i, j in enumerate(str1):     print(i, j)

输出

?

1 2 3 4 5 6 7 8 9 10 11 12

0 H 1 e 2 l 3 l 4 o 5  6 P 7 y 8 t 9 h 10 o 11 n

字符串的切片，倒序

字符串,列表，元组都属于序列，所以都可以切片　

?

1 2 3 4 5 6 7 8

str1 = "abcdefg" print(str1[0:3]) # 取第1个到第3个字符(注意：不包含第4个字符即下标为3的字符) abc print(str1[2:5]) # 取第3个到第5个字符(注意：不包含第6给字符即下标为5的字符) cde print(str1[0:-1]) # 取第1个到倒数第2个(注意：不包含最后一个) 针对此例等同于[0:6] print(str1[1:]) # 取第2个到最后一个 print(str1[:]) # 全取 同str1或者str1[0:7] print(str1[0:5:2]) # 取第1个到第5个，但是步长为2 print(str1[::-1]) # 倒序

　小结：

下标：类似一个字符串里的字符编号，通过下标可以轻松找到第N给字符

　　循环遍历“可以通过遍历打印字符

　　切片：可以通过下标得到字符串一定范围的字符

 

字符串的常见操作

示例

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

abc = "hello,nice to meet you"   print(len(abc))  # 调用len()函数来计算长度 print(abc.__len__())  # 使用字符串的__len__方法来计算字符串的长度 print(abc.capitalize())  # 整个字符串的首字母大写 print(abc.title())  # 每个单词的首字母大写 print(abc.upper())  # 全大写 print(abc.lower())  # 全小写 print("ABCDabcd".swapcase())  # 大小写互换   print(abc.center(50, "*"))  # 一共50个字符，字符串放中间，不够的两边补* print(abc.ljust(50, "*"))   # 一共50个字符，字符串放左边，不够的两边补* print(abc.rjust(50, "*"))   # 一共50个字符，字符串放右边，不够的两边补*   print(" haha\n".strip())    # 删除字符串左边和右边的空格和换行 print(" haha\n".lstrip())   # 删除字符串左边的空格和换行 print(" haha\n".rstrip())   # 删除字符串右边的空格和换行   print(abc.endswith("you"))  # 判断字符串是否已you结尾 返回True或者False print(abc.startswith("hello"))  # 判断字符串是否以hello开头   print(abc.count("e"))   # 统计字符串e出现了多少次   print(abc.find("nice"))  # 找出nice在字符串的第1个下标，找不到返回-1 print(abc.rfind("e"))   # 找出最后一个e字符串的下标,找不到返回-1 print(abc.index("nice"))    # 与find类似,区别是找不到会有异常(报错) print(abc.rindex("e"))  # 与rfind类似，区别是找不到会有异常(报错)

 

判断字符格式

?

1 2 3 4 5 6 7

print(abc.isalnum())    # 是否为数字字母混合（可以有大写字母小写字母数字任意组合） print(abc.isalpha())    # 是否全为字母 print(abc.isdecimal()) print(abc.isdigit()) print(abc.islower())    # 是否小写 print(abc.isnumeric()) print(abc.isspace())    # 是否全部是空格

　　示例

使用input输入字符判断输入的是数字 纯大写字母，纯小写字母，大小写混合还是其他

?

1 2 3 4 5 6 7 8 9 10 11 12

char = input("输入") if char.isdigit():     print("是你输入的是数字") elif char.isalpha():     if char.isupper():         print("输入的是大写")     elif char.islower():         print("输入的是小写")     else:         print("输入的是大小写混合") else:     print("输入的是其他")

　　

数字,字符串,元组是不可变类型.下面的操作可以替换字符串的值，但原字符串没有改变。　

?

1 2 3 4

aaa = "hello world,itcast" bbb = aaa.replace('l', 'L', 2)  # 从左到右把小写l替换成大写L ，最多替换2个 print(aaa)  # 原值不变 print(bbb)  #  改变的值赋值给了bbb变量,这里打印的是替换后的值

　　字符串和列表转换操作

?

1 2 3

print("root:x:0:0".split(":"))  # 以:为分隔符,分割成列表 print("root:x\n:0:0".splitlines()) # 以\n为分隔符，分割成列表 print(" ".join(['df','-h']))    # 把列表元素以引号内分隔符合成字符串

　　

十一，列表-list

列表是一种基本的序列数据结构（字符串和元组也属于序列）

列表是一种可变值的数据类型

列表的创建

使用中括号括起来，里面的数据称为元素。可以放同类型数据，也可以放不同类型数据，但通常是同类型。

?

1 2	name_list = ["张三", "李四", "王五", "马六"] print(name_list)

列表的下标

列表下标和字符串一样

示例

?

1 2	name_list = ["张三", "李四", "王五", "马六"] print(name_list)

　　输出

?

1 2 3 4

0 张三 1 李四 2 王五 3 马六

列表的切片，倒序

示例

?

1 2 3 4

name_list = ["张三", "李四", "王五", "马六"] print(name_list[::-1])  #通过切片倒序 输出['马六', '王五', '李四', '张三'] name_list.reverse() #通过reverse操作倒序，并且直接改变原数据序列 返回为None print(name_list)

列表的常见操作

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

name_list.append("王麻子")     # 在列表最后增加一个元素 print(name_list) name_list.insert(2, "王麻子")  # 插入到列表，变成第3个，原列表第3个变成第4给以此类推 print(name_list) name_list[0] = "张三丰"    # 修改元素 print(name_list) name_list.remove("王麻子") # 删除，只会删除匹配的第一个元素 print(name_list) name_list.pop() # 删除最后一个元素 print(name_list) name_list.pop(2) # 删除小标为2的元素即第3个元素 print(name_list) # del name_list   # 删除整个列表，相当于没有定义整个列表 print(name_list.index("张三丰"))   # 找出对应元素的下标 name_list.reverse() # 反转列表 print(name_list) name_list.sort()    # 排序列表，按ASCII编码排序 print(name_list) name_list.clear()   # 清空列表但是不删除列表 print(name_list)

列表合并

?

1 2 3 4 5

list1 = ["haha", "hehe", "heihei"] list2 = ["xixi", "hoho"] list1.extend(list2) # 类似于字符串相加 # list1 += list2 print(list1)

双列表和列表嵌套

?

1 2 3 4 5 6 7 8 9

# 双列表 name_list = ["zhangsan", "lisi", "wangwu", "maliu"] salary = [18000, 16000, 20000, 15000] for i in range(name_list.__len__()):     print("{}的月收入为{}元".format(name_list[i].ljust(10, " "), salary[i])) # 列表嵌套 emp = [["zhangsan", 18000], ["lisi", 16000], ["wangwu", 20000], ["maliu", 15000]] for i in range(emp.__len__()):     print("{}的月收入为{}元".format(emp[i][0].ljust(10, " "), emp[i][1]))

十二,元组

元组相当于只读的列表,因为只读所以没有append remove修改等操作

它只有两个操作方法 count index

元组，字符串，列表都属于序列，所以元组也可以切片

元组的创建

?

1 2 3 4 5 6 7

tuple1 = (1, 2, 3, 4, 5) print(type(tuple1)) print(tuple1.index(3)) print(tuple1.count(1)) print(tuple1[2:5])   tuple1[4] = 2   # 修改元组会报错

十三,字典

字典:是一种key:value(键值对)类型的数据，它是无序的（没有像列表那样的索引,下标).它是通过key来找value 底层就是hash表,查找速度快;如果key相等,会自动去重(去掉重复值)

 字典的创建

?

1 2 3 4 5 6 7 8 9

dict1 = {     'stu01': "zhangsan",     'stu02': "lisi",     'stu03': "wangwu",     'stu04': "maliu" } print(type(dict1)) print(len(dict1)) print(dict1)

字典的常见操作

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

# 增 dict1["stu05"] = "tianqi"   # 类似修改，key存在就修改，如果key不存在就增加 print(dict1) # 改 dict1["stu04"] = "马六" print(dict1) # 查 print(dict1["stu01"]) # 存在返回该key对应的value 如果key不存在会返回keyerror错误 print(dict1.get("stu01")) # 存在返回该key对应的value 如果key不存在会返回None # 删 dict1.pop("stu05")  # 删除这条 也可以del dict1["stu05"]来删除 print(dict1) dict1.popitem()     # 删除显示的最后一条 print(dict1) dict1.clear()   # 清空字典内容 print(dict1) del dict1   # 删除字典 print(dict1)

其他操作

?

1 2 3 4

print(dict1.keys()) # 打印所有keys print(dict1.values())   # 打印所有value print(dict1.items())    # 字典转换成列表套元组 输出为dict_items([('stu01', 'zhangsan'), ('stu02', 'lisi'), ('stu03', 'wangwu')]) # 上面三种可以使用for循环遍历

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

print("stu01" in dict1) # 判断键是否在字典中，返回True或者False print(list(dict1))  # 以列表方式列出key   for i in dict1.items():     print(i)    # 循环键值对 返回的是元组 需要得到对应的key即value使用下标0 1即可                 #  ('stu01', 'zhangsan')                 #  ('stu02', 'lisi')                 #  ('stu03', 'wangwu')   dict1.setdefault("stu08", "老八") # 有这个key，则不改变；没有这个key，则增加这个key和value print(dict1) # 以上操作类似下面的判断 # if "stu08" in dict1: #     pass # else: #     dict1["stu08"] = "老八"

　　练习：打印所有value为2的key

?

1 2 3 4 5 6 7 8 9

dict1 = {     "张三": 2,     "李四": 3,     "王五": 4,     "马六": 2 } for i in dict1.items():     if i[1] == 2:         print(i[0])

　　解析：items返回的是键值对的元组

字典练习

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

city={     "北京": {         "东城": "景点",         "朝阳": "娱乐",         "海淀": "大学",     },     "深圳": {         "罗湖": "老城区",         "南山": "IT男聚焦",         "福田": "华强北",     },     "上海": {         "黄埔": "xxxx",         "徐汇": "xxxx",         "静安": "xxxx",     } }   # 1,打印北京东城区的说明(也就是打印出"景点") print(city["北京"]["东城"]) # 输出字符串 景点 # 2,修改北京东城区的说明，改为"故宫在这" city["北京"]["东城"] = "故宫在这" print(city["北京"]["东城"]) # 3,增加北京昌平区及其说明 city["北京"]["昌平"] = "北京郊区" print(city) # 4,修改北京海淀区的说明，将大学改为"清华","北大","北邮"3个大学的列表 city["北京"]["海淀"] = ["清华", "北大", "北邮"] print(city) # 5,在大学列表增加一个"北影" city["北京"]["海淀"].append("北影") print(city) # 6,循环列出北京的区名,并在前面显示序号，以1开始 for index, i in enumerate(city["北京"]):     print(index+1, i) # 7,循环打印除北京海淀区的大学，并在前面显示序号,以1开始 for index, i in enumerate(city["北京"]["海淀"]):     print(index+1, i)

十四，集合

集合和字典一样都是使用大括号.但集合没有value，相当于只有字典的key

字符串,列表和元组属于序列，是有序的，但集合是无序的，所以不能通过下标来查询和修改元素。

集合的特点

1，天生去重

2，可以增删

3，可以方便的求交集，并集，补集

集合图示

 

 集合常见操作

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

set1 = {1, 4, 7, 5, 9, 6} set2 = set([2, 4, 5, 9, 8]) print(set1) print(set2)   # 交集 两个集合相同元素集合 print(set1.intersection(set2)) print(set1 & set2) print(set1.isdisjoint(set2))   # 并集 两个集合所有元素集合 print(set1.union(set2)) print(set1 | set2)   # 补集 集合1去除交集元素剩余元素集合 print(set1.difference(set2)) print(set1-set2) print(set2.difference(set1)) print(set2-set1)   # 对称差集  集合并集去除集合交集元素 print(set1.symmetric_difference(set2)) print(set1 ^ set2) print(set2 ^ set1) # 子集    一个集合是否完全包含另外一个集合 set3 = set([4, 5]) print(set3.issubset(set1)) print(set1.issuperset(set3))   # 集合的增加删除操作   # 集合的增加操作 set1.add(88)    # 增加一个 print(set1) set1.update([168, 998]) # 增加多个 print(set1)   # set1.remove(88)   # 删除一个元素，如果没有会报错 set1.discard(666)  # 删除一个元素， 存在删除，不存在不报错 返回None print(set1) print(set1)

　　练习

　　集合练习.py

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

math = ["张三", "田七", "李四", "马六"] english = ["李四", "田七", "王五", "陈八"] art = ["张三", "田七", "陈八", "赵九"] music = ["赵九", "田七", "李四", "马六"]   # 1,同时选修了math和music的人 print(set(math) & set(music)) # 2,同时选修了math,music,english的人 print(set(math) & set(music) & set(english)) # 3,同时选修了4门课的人 print(set(math) & set(music) & set(english) & set(art))   # 找出同时选修了任意1种课程的人，任意2种课程的人,任意3种课程的人，任意4种课程的人 # 把所有列表相加成一个列表 list1 = math + english + art + music # 定义一个空字典用于保存人名以及选修课数量 人名为key 选修课数为value dict1 = {} # 循环遍历列表，使用count参数统计人名在列表种出现的次数 # 如果出现的次数大于1则把 人名作为key 次数作为value写入到字典中 for i in list1:     if list1.count(i) > 0:         dict1[i] = list1.count(i)   for i in dict1.items():     if i[1] == 1:         print("{}选修了1门课".format(i[0]))     elif i[1] == 2:         print("{}选修了2门课".format(i[0]))     elif i[1] == 3:         print("{}选修了3门课".format(i[0]))     else:         print("{}选修了4门课".format(i[0])) print(dict1)