Python基础学习3（数值、字符串、列表思维导图，字符串、列表相关函数操作）

 字符串相关函数操作：

1、查找计算
①find:
作用：查找子串索引(下标)位置
格式：find(sub,start=0,end=len(str))
参数：参数1-sub，需要检索的字符串
      参数2-start，检索的起始位置，可省略，默认0
      参数3-end，检索的结束位置，可省略，默认len(str)
返回值：
     找到了---> 指定索引，整型
    找不到---> -1

②rfind：功能同find，区别在于---从右往左查找

③index：
作用：获取子串索引位置
格式：index (sub, start=0,end=len(str))
参数：参数1-sub，需要检索的字符串
    参数2-start，检索的起始位置，可省略，默认0
    参数3-end，检索的结束位置，可省略，默认len(str)
返回值：
    找到了---> 指定索引，整型
    找不到---> 异常
注意：从左到右进行查找，找到后立即停止

④rindex：功能同index，区别在于---从右往左查找

⑤count：
作用：计算某个子字符串的出现个数
格式：count(sub，start=0,end=len(str))
参数：    参数1-sub，需要检索的字符串
    参数2-start，检索的起始位置，可省略，默认0
    参数3-end，检索的结束位置，可省略，默认len(str)
返回值：子字符串出现的个数，整型

2、转换
①replace：
作用：使用给定的新字符串替换原字符串中的旧字符串
格式：replace(old, new[,count])
参数：    参数1-old，需要被替换的旧字符串
    参数2-new，替换后的新字符串
    参数3-count，替换的个数，可省略，表示替换全部
返回值：替换后的结果，字符串
注意：并不会修改原字符串本身

②capitalize
作用：将字符串首字母变为大写
格式：capitalize()
参数：无
返回值：首字符大写后的新字符串
注意：并不会修改原字符串本身

③title
作用：将字符串每个单词的首字母变为大写
格式：title()
参数：无
返回值：每个单词首字符大写后的新字符串
注意：并不会修改原字符串本身

④lower
作用：将字符串每个字符都变为小写
格式：lower()
参数：无
返回值：全部变为小写后的新字符串
注意：并不会修改原字符串本身

⑤upper
作用：将字符串每个字符都变为大写
格式：upper()
参数：无
返回值：全部变为大写后的新字符串
注意：并不会修改原字符串本身

3、填充压缩
①ljust
作用：根据指定字符(1个），将原字符串填充够指定长度
l：表示原字符串靠左
格式：ljust(width,fillchar)
参数：    参数1-width，指定结果字符串的长度
    参数2-fillchar，如果原字符串长度<指定长度时，填充过去的字符
返回值：填充完毕的结果字符串
注意：不会修改原字符串，填充字符的长度为1，只有原字符串长度<指定结果长度时才会填充

②rjust、center类似ljust

③lstrip
作用：移除所有原字符串指定字符(默认为空白字符)
l：表示从左侧开始移除
格式：lstrip (chars)
参数：参数-chars，需要移除的字符集，表现形式为字符串
返回值：移除完毕的结果字符串
注意：不会修改原字符串

④rstrip：类似lstrip

4、分割拼接
①split
作用：将一个大的字符串分割成几个子字符串
格式：split(sep,maxsplit)
参数：参数1-sep，分隔符
    参数2-maxsplit，最大的分割次数，可省略，有多少分割多少
返回值：分割后的子字符串，组成的列表；list列表类型
注意：并不会修改原字符串本身

②partition
作用：根据指定的分隔符，返回(分隔符左侧内容，分隔符，分隔符右侧内容)
格式：partition(sep)
参数：参数-sep，分隔符
返回值：如果查找到分隔符，（分隔符左侧内容,分隔符,分隔符右侧内容），tuple类型；如果没有查找到分隔符，(原字符串，"","")，tuple类型
注意：不会修改原字符串，从左侧开始查找分隔符

③splitlines
作用：按照换行符(\r,\n)，将字符串拆成多个元素,保存到列表中
格式：splitlines (keepends)
参数：参数-keepends，是否保留换行符，bool类型
返回值：被换行符分割的多个字符串，作为元素组成的列表，list类型
注意：不会修改原字符串
④join
作用：根据指定字符串，将给定的可送代对象，进行拼接，得到拼接后的字符串
格式：join(iterable)
参数：iterable，可迭代的对象，字符串，元组，列表
返回值：拼接好的新字符串

5、判定
①isalpha
作用：字符串中是否所有的字符都是字母，不包含该数字、特殊符号、标点符号等等，至少有一个字符
格式：isalpha()
参数：无
返回值：是否全是字母，bool 类型

②isdigit
作用：字符串中是否所有的字符都是数字，不包含该字母、特殊符号、标点符号等等，至少有一个字符
格式：isdigit()
参数：无
返回值：是否全是数字，bool 类型

③isalnum
作用：字符串中是否所有的宇符都是数字或者字母，不包含该特殊符号、标点符号等等，至少有一个字符
格式：isalnum ()
参数：无
返回值：是否全是数字或者字母，bool 类型

④isspace
作用：字符串中是否所有的字符都是空自符，包括空格、缩进、换行等不可见转义符，至少有一个字符
格式：isspace()
参数：无
返回值：是否全是空白符，bool类型

⑤startswith
作用：判定一个字符串是否以某个前缀开头
格式：startswith(prefix,start=0,end=len(str))
参数：参数1-prefix，需要判定的前缀字符串
    参数2-start，判定起始位置
    参数3-end，判定结束位置
返回值：是否以指定前缀开头，bool 类型

⑥endswith
作用：判定一个字符串是否以某个后缀结尾
格式：endswith(suffix, start=0,end=len(str))
参数：参数1-suffix，需要判定的后缀字符串
    参数2-start，判定起始位置
    参数3-end，判定结束位置
返回值：是否以指定后缀结尾，bool 类型

 列表相关函数操作：

'''列表常用操作'''
'''------增加操作------'''
#   append，往列表中,追加一个新的元素在列表的最后
# nums = [1, 2, 3, 4]
# nums.append(5)
# print(nums)  #[1, 2, 3, 4, 5]
# nums.append("ab")
# print(nums)  # [1, 2, 3, 4, 5, 'ab']

#   insert，往列表中,追加一个新的元素在指定索引前面
# nums = [1, 2, 3, 4]
# nums.insert(1, 5)
# print(nums)  # [1, 5, 2, 3, 4]
# nums.insert(1,"ab")
# print(nums)  # [1, 'ab', 5, 2, 3, 4]

#   extend，往列表中,扩展另外一个可迭代序列
# nums = [1, 2, 3, 4]
# nums2 = ["a", "b"]
# nums3 = "ab"
# nums.extend(nums2)
# print(nums)  # [1, 2, 3, 4, 'a', 'b']
# nums.extend(nums3)
# print(nums)     # [1, 2, 3, 4, 'a', 'b', 'a', 'b']

#   乘法运算
# print(["a"]*3)  # ['a', 'a', 'a']
# print(["a"] * ["a"])    # TypeError: can't multiply sequence by non-int of type 'list'

#   加法运算
# n1 = [1, 2, 3]
# n2 = ["a", "b"]
# print(n1+n2)    # [1, 2, 3, 'a', 'b']
# n3 = "ab"
# print(n1 + n3)  # TypeError: can only concatenate list (not "str") to list

'''------删除操作------'''
# del，可以删除一个指定元素(对象)
# nums = [1, 2, 3, 4, 5]
# del nums[2]
# print(nums)  # [1, 2, 4, 5]
# del nums
# print(nums)  # NameError: name 'num' is not defined ，地址数据都删除等于没写

# pop，移除并返回列表中指定索引对应元素
# nums = [1, 2, 3, 4, 5]
# result = nums.pop(3)
# print(result, nums)  # 4 [1, 2, 3, 5]

# remove，移除列表中指定元素，从左往右
# nums = [1, 2, 3, 4,2,  5]
# result = nums.remove(3)
# print(result, nums)  # None [1, 2, 4, 2, 5]
# nums.remove(2)
# print(nums)  # [1, 4, 2, 5]

# nums = [1, 2, 2, 2, 3, 4, 2]
# for num in nums:
#     if num == 2:
#         nums.remove(2)
# print(nums)  # [1, 3, 4, 2] ，此方法不可以移除所有2

'''------修改操作------'''
# 当我们以后想要操作一个列表当中的某个元素时，一定是通过这个索引(下标)，来操作指定元素
# nums = [1, 2, 3, 4, 5]
# # nums[5] = 6
# # print(nums)  # IndexError: list assignment index out of range
# nums[2] = 6
# print(nums)  # [1, 2, 6, 4, 5]

'''------查询操作------'''
# 获取单个元素
# nums = [1, 2, 3, 4, 5]
# print(nums[3])  # 4

# 获取元素索引,从左到右
# nums = [1, 2, 3, 4, 5]
# print(nums.index(3))  # 2
# nums2 = [3, 4, 5, 6, 7, 5, 8, 9]
# print(nums2.index(5, 3))  # 5

# count，获取指定元素个数
# nums = [3, 4, 5, 6, 7, 5, 8, 9]
# print(nums.count(5))  # 2

# 获取多个元素,切片操作
# nums = [3, 4, 5, 6, 7, 5, 8, 9]
# print(nums[:])  # [3, 4, 5, 6, 7, 5, 8, 9]
# print(nums[1:4:])  # [4, 5, 6]
# print(nums[1:7:2])  # [4, 6, 5]
# print(nums[::-1])  # [9, 8, 5, 7, 6, 5, 4, 3]

'''------遍历操作------'''
# 根据元素遍历
# values = ["a", "b", "a", "d"]
# for v in values:
#     print(v)

# 根据索引进行遍历
# values = ["a", "b", "a", "d"]
# indexs = range(len(values))
# for index in  indexs:
#     print(index,values[index])

# 枚举对象
# values = ["a", "b", "a", "d"]
# print(list(enumerate(values)))  # [(0, 'a'), (1, 'b'), (2, 'a'), (3, 'd')]
# # 遍历整个的枚举对象(枚举对象,可以直接被遍历)
# # for index, val in enumerate(values):
# #     print(index, val)
# for index, val in enumerate(values, 1):  #索引从1开始
#     print(index, val)

'''------迭代------'''
# # 迭代器和可迭代对象不一样
# l = [1, 2, 3, 4, 5]
# # 1、创建一个迭代器对象
# it = iter(l)
# # next()
# print(next(it))  # 1
# print(next(it))  # 2
# print(next(it))  # 3
# print(next(it))  # 4
# print(next(it))  # 5
# print(next(it))  #StopIteration
# # 可使用迭代器遍历

'''------额外操作------'''

# 判定，in 、not in
# cmp()函数，比较,python3中无，python3中直接用比较运算符
# 排序
# result = [1, 4, 6, 8]
# print(sorted(result))  # [1, 4, 6, 8]
# s = [("sz ", 18), ("sz2", 20), ("sz1", 17), ("sz3", 15)]
# print(sorted(s))  # [('sz ', 18), ('sz1', 17), ('sz2', 20), ('sz3', 15)]
# def getKey(x):
#     return x[1]
# print(sorted(s, key=getKey, reverse=True)) # [('sz2', 20), ('sz ', 18), ('sz1', 17), ('sz3', 15)]

# 列表对象排序
# l = [1, 3, 2, 6, 4, 5]
# l.sort()
# print(l)  # [1, 2, 3, 4, 5, 6]

# 乱序
# import random
# l = [1, 2, 3, 4, 5]
# res = random.shuffle(l)
# print(res, l)  # None [5, 3, 2, 1, 4]

#  反转
# l.reverse()改变l本身，切片操作反转不改变l本身