python 中字符串函数

# 3、python 中字符串函数
# 1)capitalize()：首字符大写
# str1 = 'python'
# str2 = 'python_hello'
# print(str1.capitalize())    #结果 Python  capitalize()时函数，首字符大写
# print(str1.title())         #结果 Python 首字符大写
# print(str2.capitalize())     #结果 Python_hello  这个函数只会首字符大写
# print(str2.title())          #结果 Python_Hello  连接再一起的首字符大写

# 2）count()：统计具体字符出现的次数
# str1 = 'python_hello'
# print(str1.count('h'))     #结果 2    #统计h字符的个数

# 3）join()：把集合中的字符按自定义的分隔符连接在一起
# str1 = 'python'
# print('*'.join(str1))    #结果 p*y*t*h*o*n  用*号分隔符连接python这个字符串


# 4）split()：把字符串通过指定标识符进行分割
# str1 = 'python'
# print(str1.split('a'))   #结果 ['python']  指定的字符a 不在str1这个字符里面，则返回一个列表，
#                          # 把整个字符作为这个列表的元素
# print(str1.split('t'))   # 结果 ['py', 'hon']  指定的字符t在str1这个字符里面，则返回一个列表
                         #且把这个分割符去掉，分成两个列表元素

# 练习题
#s = 'py thon'   转化成python
# s = 'py thon'
# s1 = s.split(' ')     #['py','thon']
# # print(s1[0]+s1[1])   #字符串 是可以相加，整型不能相加
# for i in s1:
#     print(i,end='')      #end= 不换行

# 通过所学的知识把python_hello 转为PythonHello
# str1 = 'python_hello'
# str2 = str1.title().split('_')
# print(str2[0]+str2[1])
# for i in str2:
#     print(i,end='')


# 5）strip(ab)：删除字符串开头和结尾有a或b的字符
# str1 = 'abcdabcdba'
# print(str1.strip('ab'))   #结果 cdabcd 删除开头和结果有啊或b的字符

# 6)lstrip(ab)：删除字符串开头有ab序列字符
# str1 = 'abcdabcdba'
# print(str1.lstrip('ab'))   #结果 cdabcdba   删除开头是a或b的字符
# print(str1.lstrip('ba'))   #结果 cdabcdba

# 7)rstrip(ab)：删除字符串结尾有ab序列字符
# str1 = 'abcdabcdba'
# print(str1.rstrip('ab'))    #结果 abcdabcd 删除结尾是a或b的字符

# 8)startswith()：判断字符串是否以什么开始
# str1 = 'python'
# print(str1.startswith('p'))   #True 判断字符串以p开始
# print(str1.startswith('1'))   #False 判断字符串以1开始

# 9)endswith()：判断字符串是否以什么结束
# str1 = 'python'
# print(str1.endswith('n'))   #True
# name = input('请入您要上传的文件')
# if name.endswith('.txt'):       #这里注意冒号
#     print('上次成功')
# else:
#     print('上传失败')

# 10)find()/rfind()：字符串查询find()是左边开始查，rfind()从右边开始查，结果
# 显示下标
# str1 = 'python'
# print(str1.find('p'))    #结果 0 下标就是索引
# print(str1.rfind('n'))   #结果 5 一般是正索引

# 11)replace()：replace(substring,newstring,max) substring表示被替换的字
# 符串,newstring要替换字符串,max表示替换的次数
# str1 = 'pythonpython'
# print(str1.replace('p','y',1))   #结果yythonpython 把字符串中p用y只替换一次，
# print(str1.replace('p','y'))    #结果 yythonyython，如果没有max 全部替换

# 12)lower()：方法转换字符串中所有大写字符为小写
# str1 = 'PYTHON'
# str2 = 'PYthon'
# print(str1.lower())      #结果 python
# print(str2.lower())      #结果 python

# 13)upper()：将字符串中的所有小写字符转换为大写字母输出
# str1 = 'python'
# str2 = 'PYTHON'
# print(str1.upper())     #结果 PYTHON
# print(str1.upper())     #结果 PYTHON

# 14)isdigit()：判断字符串中是否全为数字
# str1 = '123ab'
# str2 = '123'
# str3 = 123      #不是字符串
# print(str1.isdigit())    #False
# print(str2.isdigit())   #ture

# 15)isalpha()：判断字符串中是否全为字母
# str1 = '123ab'
# str2 = 'abc'
# print(str1.isalpha())    #False
# print(str2.isalpha())     #ture

# 16)isalnum()：判断字符串当中是否全都为数字，全为字母，或者数字字母组合
# 返回布尔值：True和False
# str1 = 'python12'
# str2 = 'python'
# str3 = '1234'
# str4 = 'python#'
# print(str1.isalnum())     #ture
# print(str2.isalnum())    #ture
# print(str3.isalnum())    #ture
# print(str4.isalnum())    #False


# 17)istitle()：判断字符串中首字母是否为大写，其他是否为小写，其他不为小写则为否
# str1 = 'Python'
# str2 = 'python'
# str3 = 'PYthon'
# print(str1.istitle())     #True
# print(str2.istitle())    #False
# print(str3.istitle())    #False

# 18)isupper()/islower():is开头的就是判断一个字符串是否展示为都是大写或者都是小写
# str1 = 'PYTH   #TrueON'
# # str2 = 'python'
# # print(str1.isupper())    #True
# # print(str2.islower())


# 4、python 中的列表  []表示 list
# 1）第一种方式定义列表
# list1 = ['dcs','多测试','123',88]
# print(list1)          #打印结果['dcs', '多测试', '123', 88]
# print(type(list1))     #<class 'list'> 数据类型是list

# 2）第二种定义方法
# str1 = 'dcs'
# list1 = list(str1)     #把字符串转化为列表
# list2 = list('test')   #把字符串转化为列表
# print(list1)        #['d', 'c', 's']
# print(list2)        #['t', 'e', 's', 't']

# 3）列表中的函数和方法
# 1、索引取值和赋值
# test = 'duoceshi'
# list1 = list(test)
# print(list1)          #['d', 'u', 'o', 'c', 'e', 's', 'h', 'i']
# print(list1[2])      # 结果o
# list1[2] = 'dcs'     #索引赋值把dcs这个字符串赋给list1索引为2的值
# print(list1)        #['d', 'u', 'dcs', 'c', 'e', 's', 'h', 'i']

# 2、切片赋值
# test = 'duoceshi'
# list1 = list(test)
# list1[2:] = 'dcs'     #切片赋值，把list1索引为2及后面的元素全部替换成dcs
# print(list1)      #['d', 'u', 'd', 'c', 's']

# 4）append 函数 添加元素
# list1 = ['dcs','多测试','123',88]
# list1.append('test')
# print(list1)    #['dcs', '多测试', '123', 88, 'test'] 往list1这个列表添加一个test元素。默认加在末尾
# list1.append(125)
# print(list1)    #['dcs', '多测试', '123', 88, 'test', 125]

# 5）extend函数：连接两个列表
# list1 = ['dcs','多测试','123',88]
# list2 = [126,'test']
# list3 = '999'      #字符串
# list1.extend(list2)      #拼接list1和list2
# print(list1)          #['dcs', '多测试', '123', 88, 126, 'test']

# list1.extend(list3)     #extend 可以拼接列表和字符串不能拼接整型
# print(list1)         #['dcs', '多测试', '123', 88, '9', '9', '9']

# 注意：
# extend与append方法的相似之处在于都是将新接收到参数放置到已有列表 的后面
# append方法可以接收任意数据类型的参数，并且追加到list尾部
# extend方法一般和列表还有字符串进行拼接，不能拼接整型


# 6）insert(index,value)函数：在指定位置插入一条数据
# list1 = ['dcs','多测试','123',88]
# list1.insert(0,66)
# print(list1)         #[66, 'dcs', '多测试', '123', 88]

# 7）remove函数：移除元素
# list1 = ['dcs','多测试','123',88]
# list1.remove(88)      #['dcs', '多测试', '123']
# list1.remove('dcs')
# print(list1)        #['多测试', '123']
# 注意：如果列表有多个相同元素，移除时会移除最前面那个


# 8）索引删除值 del
# list1 = ['dcs','多测试','123',88]
# del list1[2]
# print(list1)    #['dcs', '多测试', 88]   删除索引为2 的值
# del list1[2:]
# print(list1)      #['dcs', '多测试']

# 9）index函数：在列表中查找元素所对应的索引值
# list1 = ['dcs','多测试','123',88]
# print(list1.index(88))       #结果 3   查找列表中元素88对应的索引值

# 10）sort函数：实现列表的升序排列
# list1 = [1,5,3,6,2,7]
# list2 = [1,4,5,8,2,'a','A']
# list3 = ['a','A','B','bf','AF']
# list1.sort()
# print(list1)       #[1, 2, 3, 5, 6, 7]
# list2.sort()
# print(list2)        #如果列表中都是数字可以排数，如果类表中含有数字和字符串不能排序
# list3.sort()
# print(list3)     #['A', 'AF', 'B', 'a', 'bf']  如果列表都是字符串那就按照ASCII进行排序

# 11）sorted函数：实现降序排列
# list1 = [1,5,3,6,2,7]
# print(sorted(list1,reverse=True))     #[7, 6, 5, 3, 2, 1]
# print(sorted(list1,reverse=False))    #[1, 2, 3, 5, 6, 7]


# 12)reverse函数：列表元素反转
# list1 = [1,5,3,6,2,7]
# list1.reverse()
# print(list1)       #[7, 2, 6, 3, 5, 1]

# # 13)pop函数：
# list1 = [1,5,3,6,2,7]
# # print(list1.pop())    #结果 7 ，打印的结果就是被删除的元素，默认删除最后一个
# # print(list1)          #[1, 5, 3, 6, 2] 打印删除侯的结果
# print(list1.pop(0))     #指定索引删除对应的值，删除元素1
# print(list1)           #[5, 3, 6, 2, 7]

# pop 总结：
# 1.默认移除列表最后一个元素,并返回元素的值
# 2.移除指定位置的元素list1.pop(0)表示移除第一个元素
# 3.在列表中pop函数是唯一一个既能改变列表元素又有返回值


# 5、python 中的元组   tuple()
# 1)元组用tuple()来表示
# 定义：元组（tuple）是Python中常用的一种数据结构。元组由不同的元素组成， 每个元素可以存储不同类型的数据，如字符串、数字、
# 甚至元组。元组是'写保护' 的，即元组中元素作为一个整体，创建后不能再做任何修改操作。
# tuple1 = (1,'china','dcs','中国',['dcs',88,'test'])
# print(tuple1)       #(1, 'china', 'dcs', '中国', ['dcs', 88, 'test'])
# print(type(tuple1))  #<class 'tuple'>  数据类型元组

# tuple2 = (1,)
# print(tuple2)            #结果(1,)
# print(type(tuple2))      #<class 'tuple'>  注意：当元组只有一个元素时,后面要加逗号

# 2)元组中索引取值和切片
# tuple1 = (1,'china','dcs','中国',['dcs',88,'test'])
# print(tuple1[2])       #dcs 索引取值
# print(tuple1[2:])      #('dcs', '中国', ['dcs', 88, 'test']) 索引切片

# 3）元组和列表之间的转换
# tuple1 = (1,'china','dcs','中国',['dcs',88,'test'])
# tuple1[0] = 'duo'        #不可以索引赋值
# tuple1.insert(0,66)      #元组也不能插入

# list1 = list(tuple1)    #把元组转换为列表
# print(list1)            #[1, 'china', 'dcs', '中国', ['dcs', 88, 'test']]
# list1[0] = 'duo'        #转换为列表后索引赋值
# tuple2 = tuple(list1)   #把列表转换为元组
# print(tuple2)           #('duo', 'china', 'dcs', '中国', ['dcs', 88, 'test'])
# print(type(tuple2))     #<class 'tuple'>


# 面试题：元组可以被改变吗？
# ==》当元组作为一个整体时，不能被改变，如果转换为列表可以改变
# 如果元组中含有列表元素时可以通过二维数组的方式改变
# tuple1 = (1,'china','dcs','中国',['dcs',88,'test'])
# tuple1[4][2] = 'china'    #前面这个4 是索引取值，后面的2是索赋值
# print(tuple1)       #(1, 'china', 'dcs', '中国', ['dcs', 88, 'china'])

# 总结：元组和列表的区别
# 相同：
# a、都是序列类型的容器对象，可以存放任何类型的数据
# b、支持切片、迭代等操作
# 不同：
# a、list 是可变的对象，元组tuple是不可变的对象
# b、tuple不可变，所以使用tuple可以使代码更安全

# 迭代==>遍历
# tuple1 = (1,'china','dcs','中国',['dcs',88,'test'])
# for i in tuple1:
#     print(i)


# 6、python 中的字典
# 字典用dict = {}
# 字典的定义
# 1）字典（dict）是另一种可变容器模型，且可存储任意类型对象。字典的
# 每个键值key：value对用冒号 : 分割，每个键值对之间用逗号分割，
# 整个字 典包括在大括号 {} 中
# 2）字典同时是无序，字典都是以键值对的形式存在，先键后值，键是唯一 的，
# 值且不唯一 字典表达符：{}

# 1）字典第一定义方法
# dict1 = {'name':'xiaoduan','age':18}
# print(dict1)       #{'name': 'xiaoduan', 'age': 18}
# print(type(dict1))   #<class 'dict'> 数据类型字典

# 2）字典的第二种定义方法
# test = [('name','xiaoduan'),('age',18)]
# dict1 = dict(test)
# print(dict1)       #{'name': 'xiaoduan', 'age': 18}

# 3)字典中的函数
# 字典的添加
# dict1 = {'name':'xiaoduan','age':18}
# dict1['class'] = 1833     #字典通过键赋值
# print(dict1)      #{'name': 'xiaoduan', 'age': 18, 'class': 1833}

# 字典的覆盖
# dict1 = {'name':'xiaoduan','age':18}
# dict1['age'] = 20
# print(dict1)      #{'name': 'xiaoduan', 'age': 20}

# 4)取出字典中的键
# dict1 = {'name':'xiaoduan','age':18}    #for 是遍历
# for i in dict1.keys():
#     print(i)      #name age

# 5）取出字典中所有的值
# dict1 = {'name':'xiaoduan','age':18}
# for i in dict1.values():
#      print(i)      #xiaoduan 18

# print(dict1['name'])      #xiaoduan  通过键取值

# 6）设置键值对字典进行添加setdefault
# dict1 = {'name':'xiaoduan','age':18}
# dict1.setdefault('class',1833)
# print(dict1)      #{'name': 'xiaoduan', 'age': 18, 'class': 1833}
                 #如果字典中的键存在，用这个函数无效
# 7）删除键对应的值
# dict1 = {'name':'xiaoduan','age':18}
# del dict1['age']    #删除age这个键，对应的值也删除
# print(dict1)        #{'name': 'xiaoduan'}

# del dict1
# print(dict1)     #删除dict1，dict1不存在了

# 8）字典的遍历：for...in...遍历字典
# dict1 = {'name':'xiaoduan','age':18}
# for i in dict1:
#     print(i)           #name age   这里遍历打印出字典的键
#     print(dict1[i])   #i是字典的键，通过键取值 xiaoduan  18

# 9）使用items()完成遍历
# dict1 = {'name':'xiaoduan','age':18}
# for i,j in dict1.items():     #定义两个变量i,j
#     print(i,j)      # name xiaoduan  age 18


# 10)pop(key)函数，删除指定键并返回删除的值
dict1 = {'name':'xiaoduan','age':18}
print(dict1.pop('name'))       #xiaoduan  打印的结果是删除键的值
print(dict1)                   #{'age': 18}  返回删除后的字典

# 11、clear()清空字典所有项
dict1 = {'name':'xiaoduan','age':18}
dict1.clear()
print(dict1)     #{}


# 12、get(key)方法,通过key获取值,当键不存在,返回None
dict1 = {'name':'xiaoduan','age':18}
print(dict1.get('name'))     #xiaoduan
print(dict1['name'])         #xiaoduan

# 13、fromkeys函数可以给具体的键指定值

dict1 = {}.fromkeys(['name','age'])
print(dict1)     #{'name': None, 'age': None}
dict1['name'] = 'test'
print(dict1)

dict1 = {}.fromkeys(['name','age'],'test')
print(dict1)     #{'name': 'test', 'age': 'test'}

dict1 = {'name':'xiaoduan','age':18}
dict1 = {'name':'xiaoduan','age':18}.fromkeys(['class'],1833)
print(dict1)       #{'class': 1833}
# 14、__contains__函数检查字典是否有指定的键，有返回True，没有返回 False
dict1 = {'name':'xiaoduan','age':18}
print(dict1.__contains__('name'))       #True
if dict1.__contains__('class'):
    print('存在此键')
else:
    # dict1['class'] = 1833       #不存在就添加
    dict1.setdefault('class',1833)   #不存在就添加
    print(dict1)        #{'name': 'xiaoduan', 'age': 18, 'class': 1833}
# 15、popitem函数随机返回并删除字典中的键值对(一般删除末尾对) 如果字典已经为空，
# 却调用了此方法，就报出KeyError异常
dict1 = {'name':'xiaoduan','age':18}
print(dict1.popitem())        #('age', 18)   删除的值返回的是tuple 元组
print(dict1)               #{'name': 'xiaoduan'}  删除后的值，还是一个字典

# 16、update函数利用一个字典更新另外一个字典
dict1 = {'name':'xiaoduan','age':18}
dict2 = {'class':1833,'age':20}
dict1.update(dict2)
print(dict1)        #{'name': 'xiaoduan', 'age': 20, 'class': 1833}
                   #如果更新的字典中键存在则覆盖新值