Python 数据类型方法(1)

目录

1.序列类型通用方法

2.字符串方法

---

1.序列类型通用方法

序列类型指的就是可以通过下标访问的数据 : 字符串 , 列表 , 集合 , 元组 , 字典

1.1 len()

len()  用于计算序列的长度

返回值是数值,表示当前序列一共有几个数据

print(len("abcds"))   #字符串长度
print(len([1,2,3,4])) #列表长度
print(len((1,2,34,5)))#元组长度
print(len({'name':'ouwen'})) #字典中键值对的数量
print(len({1,2,34})) #集合中元素的长度

输出结果:

5
4
4
1
3

1.2 max()

max() 用于检索序列中的最大元素,需要注意

5345
5345
5345
6

的是检索的值必须是数值或者数值类型字符串

返回值是序列中的最大值

print(max([1,2,3,4,5345,345,345,3]))  #列表
print(max((1,2,3,4,5345,345,345,3)))  #元组
print(max({1,2,3,4,5345,345,345,3}))  #集合
print(max('123456'))       #字符串

输出结果:

5345
5345
5345
6

1.3 min()

找最小值,和 max() 刚好相反

print(min([1,2,3,4,5345,345,345,3]))  #列表
print(min((1,2,3,4,5345,345,345,3)))  #元组
print(min({1,2,3,4,5345,345,345,3}))  #集合
print(min('123456'))       #字符串

输出结果:

1
1
1
1

1.4 sum()

计算元素之和,必须是数值,字符串都不行

sum() 适用于  列表 , 元组 , 集合

print(sum([1,2,3,4,5]))  #列表
print(sum((1,2,3,4,5)))  #元组
print(sum({1,2,3,4,5}))  #集合

输出结果:

15
15
15

2.字符串方法

2.1 str.join(ite) 

2.1.1 语法:

join  是 Python 中字符串的内置方法 ，用于将可迭代对象（如列表、元组、集合、字符串等 ）中

的元素连接成一个字符串。

-  str  ：是一个字符串，作为连接时的分隔符 ，用来分隔  ite 中的每个元素。比如  ","  表示用逗号

分隔，  ""  表示无分隔直接连接。

-  ite  ：是要进行连接操作的可迭代对象，其中的元素必须都是字符串类型（若不是，需先转换

）。

2.1.2 原理:

#str.join()
print('-'.join(['2021','1','1'])) #列表
print('-'.join('abcde'))  #字符串
print('-'.join(('2021','1','1'))) #元组
print('-'.join({'2021','1','1'}))  #集合
print('-'.join({'name':'ouwen','age':'18'}))  #字典

输出结果:

2021-1-1
a-b-c-d-e
2021-1-1
1-2021
name-age

2.2 str.replace(old,new[ , count])

2.2.1 语法:

str.replace(old,new[ , count])  :  用于字符串替换,返回值是替换后的新字符

old : 需要替换的值

new : 替换后的新值

count : 替换几个值,默认是全部替换

2.2.2原理:

#str.replace(old,new[,count])
txt = '大家好我是一个大聪明,我非常的聪明'
#要求:将字符串里面的 聪明 改为 笨蛋
print(txt.replace('聪明','笨蛋'))
#要求:只需要替换 第一个笨蛋
print(txt.replace('聪明','笨蛋',1))

输出结果:

大家好我是一个大笨蛋,我非常的笨蛋
大家好我是一个大笨蛋,我非常的聪明

2.3 str.strip/lstrip/rstrip

str.strip/lstrip/rstrip  : 去除字符串两边或者某个方向的指定字符   l:左边  r:右边 

2.3.1 原理:

user_name = '  用户名  '
#去除左右两边的空格
print(user_name.strip('  '))
#去除左边的空格
print(user_name.rstrip('  '))
#去除右边的空格
print(user_name.lstrip('  '))

输出结果:

用户名用户名
用户名  

2.4 str.lower()/upper()

str.lower()/upper()  :  将字符串中的英文全部转换为大写(upper)或者小写(lower)

2.4.1 原理:

txt = 'abcDEF'print(txt.upper())
print(txt.lower())

输出如果:

ABCDEF
abcdef

2.5 str.split()

2.5.1 语法:

str.split(sep=None, maxsplit=-1)  :

-  sep （可选）：分隔符（如  , 、 - 、空格等），默认值为  None （按任意空白符分割，连续空白

视为一个分隔符）。

-  maxsplit （可选）：最大分割次数，默认值为  -1 （无限制）。

str.rsplit(sep=None, maxsplit=-1)  : 从右往左切割

1. 默认分割（按空白符）

s = "hello world python"
print(s.split())  # 输出: ['hello', 'world', 'python']

- 无参数时，按空格、制表符（ \t ）、换行符（ \n ）等空白符分割，自动忽略连续空白。
 
2. 指定分隔符

s = "a,b,c,d"
print(s.split(','))  # 输出: ['a', 'b', 'c', 'd']（按逗号分割）

3. 限制分割次数

s = "a-b-c-d"
print(s.split('-', 2))  # 输出: ['a', 'b', 'c-d']（最多分割2次）

2.5.2 原理:

#split : 从左往右切割
print('a,b,c,d'.split(','))
print('a-b-c-d'.split('-'))print('a-b-c-d'.split('-',1))
print('a-b-c-d'.split('-',2))#rstrip : 从右往左切割
print('a,b,c,d'.rsplit(','))
print('a,b,c,d'.rsplit(',',2))

输出结果:

['a', 'b', 'c', 'd']
['a', 'b', 'c', 'd']
['a', 'b-c-d']
['a', 'b', 'c-d']
['a', 'b', 'c', 'd']
['a,b', 'c', 'd']

2.6 str.find(sub[, start[, end]])

2.6.1 语法:

str.find(sub[, start[, end]]) : 用于在字符串中查找指定子字符串的位置

-  sub ：必填参数，表示要查找的子字符串。

-  start （可选）：指定开始查找的起始位置索引，默认为0，即从字符串开头开始查找。

-  end （可选）：指定查找的结束位置索引（不包含该位置），默认为字符串的长度，即查找到字

符串末尾。
 
返回值:
 
- 如果找到指定的子字符串，返回子字符串在原字符串中第一次出现的起始位置索引。

- 如果没有找到，则返回 -1。

2.6.2 原理:

txt = 'abcdefgabcabc'
# 找到字符串中b字符所在的下标位置
print(txt.find('b'))
print(txt.find('x'))print(txt.find('a',5))
print(txt.find('a',5,8))

2.7 str.index(sub[, start[, end]]

2.7.1 语法:

str.index(sub[, start[, end]]  : 在Python中， index() 也是字符串的一个常用方法，和 find() 方法

功能有相似之处，但也存在差异

-  sub ：必填参数，代表要查找的子字符串。

-  start （可选）：指定开始查找的起始位置索引，默认值为0，即从字符串开头开始查找。

-  end （可选）：指定查找的结束位置索引（不包含该位置），默认值为字符串的长度，即查找到

字符串末尾。
 
返回值
 
- 当在字符串中找到指定的子字符串时，返回子字符串在原字符串中第一次出现的起始位置索引。

- 当找不到时会报错

2.7.2 原理:

print(txt.index('a'))
print(txt.index('b',1))
print(txt.find('a',5,8))
print(txt.find('x'))

输出结果:

0
1
7
ValueError  #报错

2.7.3 与findf的区别:

- 返回值差异： find() 方法在找不到指定子字符串时返回 -1 ；而 index() 方法在找不到指定子字符

串时会抛出 ValueError 异常。例如：
 

s = "hello world"
print(s.find("java"))  # 输出: -1
print(s.index("java"))  # 会抛出 ValueError: substring not found

 - 应用场景差异：如果只是想简单判断子字符串是否存在，并且希望以一个特定值（ -1 ）表示不

存在的情况，使用 find() 方法更合适；如果确定子字符串一定存在，希望在找到时获取其位置索

引，并且在子字符串意外不存在时让程序抛出异常以便及时发现问题，那么 index() 方法会更符合

需求。

2.8 str.count(sub[, start[, end]])

2.8.1 语法:

str.count(sub[, start[, end]])  : 用于统计指定子字符串在字符串中出现的次数

-  sub ：要统计的子字符串，为必填参数。

-  start （可选）：起始位置索引，默认为0，即从字符串开头开始统计。

-  end （可选）：结束位置索引（不包含该位置），默认为字符串的长度，即统计到字符串末尾。
 
返回值:
 
- 返回指定子字符串在字符串中出现的次数。

- 没有就返回 0

2.8.2 原理:

data = 'aaabbbcccabc'
print(data.count('a'))
print(data.count('x'))

输出结果:

4
0

2.9 str.isdigit()

2.9.1 语法:

str.isdigit()   : 用于判断字符串中的所有字符是否都是纯数字（0 - 9）

返回值:
 
如果字符串中的所有字符都是数字且至少有一个字符，返回 True ；否则，返回 False 。

2.9.2 原理:

s1 = "123"
s2 = "abc"
s3 = "1a2"
s4 = ""
print(s1.isdigit())  
print(s2.isdigit()) 
print(s3.isdigit())  
print(s4.isdigit())

输出如果:

True
False
False
False

2.10 str.isalpha()

2.10.1语法:

str.isalpha()  : 用于判断字符串中的所有字符是否都是纯字母

返回值:
 
如果字符串中的所有字符都是字母且至少有一个字符，返回 True ；否则，返回 False 。

2.10.2 原理:

s1 = "abc"
s2 = "123"
s3 = "a1b"
s4 = ""
print(s1.isalpha()) 
print(s2.isalpha())
print(s3.isalpha())
print(s4.isalpha())  

输出结果:

True
False
False
False

字符串常见的内置函数就讲完了，希望大家能理解，接下来还会讲解列表，元祖，集合有关的内置

函数。希望大家能关注主播，感谢大家的观看！