python中常用数据类型及其使用方法

原创已于 2025-05-20 22:17:47 修改 · 1k 阅读

19 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#python #java #前端

于 2025-05-13 16:25:43 首次发布

1. 字符串（str）

1.1 独有功能方法

（1）str_sample.startswith("str") -> bool 。判断字符串以“xx”开头，返回True或False

（2）str_sample.endswith("str") -> bool 。判断字符串以“xx”结尾，返回True或False

（3）str_sample.isdecimal("str") -> bool 。判断字符串是否为10进制整数，返回True或False

（4）str_sample.isdigital("str") -> bool 。判断字符串是否为整数（包含其他特殊字符类型的数字，比如①），返回True或False

（5）str_sample.strip() -> str。去除字符串两边的空白字符（包含空格、制表符、换行符等）

其中也可制定去除两边的特定字符，比如str_sample.strip("s")，去除两边的s字符。

（6） str_sample.upper() ->str 。将字符串全部转换为大写，返回一个新的字符串。

（7）str_sample.lower() ->str 。将字符串全部转换为小写，返回一个新的字符串。

（8）str_sample.replace("old","new") ->str 。将字符串中的old字符替换为new字符串。

（9）str_sample.split() -> list 。将字符串按默认空白符分隔，返回一个列表。

其中也可指定分隔符，比如str_sample.split("!")。

还能够制定切割次数，比如str_sample.split("!"，1)，表示按照！只切割1次。

（10）str_sample.rsplit() -> list 。表示从右往左找，按照制定的分隔符来切割。这种应用场景在找文件类型时，常常使用。比如:file_name = "/user/test/test.file.txt"

(11) 字符串拼接。" ".join(iterable) ,表示用空格来拼接可迭代对象（常用的是列表）形成一个字符串。

（12）字符串转换为字节类型。一般在将字符串写入文件时需要转换。

比如data = "测试"，newdata = data.encode("utf-8")

str_sample = "i am a sample"
str_sample.startswith("i")   #返回True
str_sample.endswith("le")    #返回True

str_sample = "345"
str_sample.isdecimal()    #返回True

str_sample = "③⑤"
str_sample.isdecimal()    #返回False
str_sample.isdigit()      #返回True

str_sample = " I LOVE Zoey! "
new = str_sample.strip()       #返回"I LOVE Zoey!"

str_sample1 = " I LOVE Zoey!!"
new1 = str_sample1.strip("!")   #返回" I LOVE Zoey"


str_sample1 = " I LOVE Zoey!!"
new2 = str_sample1.upper()      #返回" I LOVE ZOEY!!"
new3 = str_sample1.lower()      #返回" i love zoey!!"
new4 = str_sample1.replace("Zoey","Jolin")   " I LOVE Jolin!!"

new5 = str_sample1.split()      #返回列表["I","LOVE","Zoey!!"]
new6 = str_sample1.split("!")   #返回列表[" I LOVE Zoey","",""]
new7 = str_sample1.split("!"，1) #返回列表[" I LOVE Zoey","!"]

file_name = "/user/test/test.file.txt"
file_type = file_name.rsplit(".",1)[-1]   #返回结果是"txt"

list_temp = ["i","love","zoey"]
str1 = "*".join(list_temp)   #返回结果"i*love*zoey"

1.2 公共功能方法

（1）字符串相加：字符串 + 字符串

（2）字符串相乘：字符串*整数

（3）计算字符串长度：len(str) -> int ，返回字符串长度的整数

（4）获取字符串的字符和索引。message[0],message[1]

（5）字符串的切片，[start:end:step] 。注意:字符串的切片、获取索引值均不改变原字符串的值！

s1 = "test1"
s2 = "test2"

s3 = s1 + s2  #返回结果test1test2
s4 = s1 * 2   #返回结果test1test1

t = len(s1)   #返回5
value1 = s1[1]  #返回e

for a in s1:
   print(a)      #依次打印"t","e","s","t","1"

value2 = s1[0:2]  #返回te ，包含前索引，不包含后索引
value3 = s1[:3]   #返回tes，前面的0可以省略
value4 = s1[2:]   #返回st1
value5 = s1[::2]  #返回ts1，隔一个取值

2. 列表（list）

列表是一个有序且可变的容器。可以存放多个不同数据类型的元素。

2.1 独有功能方法

（1）追加。list_sample.append("元素")，在原列表末尾追加元素。

（2）批量追加。list_sample.extend(iterable)，在原列表逐个追加可迭代对象（比如列表）

（3）插入。list_sample.insert(index,"元素")，在index位置上插入元素，这个元素的位置就是index

（4）原列表删除元素值。list_sample.remove("元素")，根据值从左向右逐一查找，删除找到的第一个。

（5）根据索引删除。list_sample.pop(index),根据索引号删除元素，默认删除最后一个。

（6）清空原列表。list_sample.clear() ，返回一个空列表[]。

（7）根据值获取索引。list_sample.index("元素")，返回索引值。

list_sample = ["jolin","love"]
list_sample.append("zoey")  #返回["jolin","love","zoey"]

list_sample2 = ["zoey","very","much"]
list_sample.extend(list_sample2)  #返回["jolin","love","zoey","very","much"]

list_sample.insert(0,"haha")  #返回["haha","jolin","love"]

list_remove = ["jolin","love","zoey"]
list_remove.remove["jolin"]   #原列表变更为["love","zoey"]

list_pop = ["jolin","love","zoey"]
temp = list_pop.pop()         #原列表变更为["jolin","love"],temp的值是zoey
temp1 = list_pop.pop(0)       #原列表在上面的基础上变更为["love"],temp1的值是jolin

list_index = ["jolin","love","zoey","very","much"]
if "zoey" in list_index:
     result = list_index.index("zoey")         #先判断是否存在列表中，如果不判断不存在时会报错。返回索引值result = 2

（8）列表的排序方法。list_sample.sort(reverse=False)，默认按照从小到大，reverse=True则表示从大到小排序。还可以用list_sample.sort(key=len)排序，key这里可以用制定的函数方法排序。

注意与sorted(list_sample)的区别。sorted(list_sample)是生成一个新的有序列表，不改变原列表。而list_sample.sort(reverse=False)改变了原列表list_sample

（9）列表翻转倒序。原列表翻转。list_sample.reverse()

注意与list_sample[::-1]的区别。list_sample[::-1]是生成一个新的列表并倒序，不改变原列表。而list_sample.reverse()改变了原列表list_sample

list_sample = [1,9,5,8,2]
list_sample.sort()                #返回[1,2,5,8,9]
list_sample.sort(reverse=True)    #返回[9,8,5,2,1]

list_index = ["jolin","love","zoey","very","much"]
list_index.sort(key=len)          #返回['love', 'zoey', 'very', 'much', 'jolin']

list_sample = [1,9,5,8,2]
list_sample.reverse()             #返回[2,8,5,9,1]

2.2 公共功能方法

（1）列表相加。list1+list2，相当于两个列表拼接，得到一个新列表，原列表不改变。

（2）列表相乘。list1 * 2 ，相当于两个list1列表拼接，得到一个新列表，原列表不改变。

（3）判断元素是否在列表中in。 if "元素" in list1：结果返回True或者False。

（4）获取长度len(list1)

（5）通过索引获取值。list1[0]表示list1列表中第0个元素的值。

（6）切片及步长。同字符串的使用方法。[start:end:step]

2.3 元素类型嵌套

列表是一个容器类型的数据元素。里面的元素可以是多种数据类型，比如字符串、列表、字典等

data = ["jolin",28,["zoey","zhouzhou"],{"name":"zoey","age":28}]
print(data[2][0])               #返回是zoey
print(data[3]["age"])          #返回是28

3. 元组（tuple）

元组是一个有序且不可变的容器。可以存放多个不同数据类型的元素。

data_t = ("jolin",28,["zoey","zhouzhou"],{"name":"zoey","age":28})

建议在元组最后的元素添加一个","，用于标识这个一个元组。

元组不可变的理解：我儿子永远不会变，但我儿子可以长大。

比如上面的元组，data_t[2].append("yingbao")。data_t这个元组就变成

data_t = ("jolin",28,["zoey","zhouzhou","yingbao"],{"name":"zoey","age":28})

3.1 独有功能方法

无。

3.2 公共功能方法

（1）元组相加。data1+data2，相当于两个元组拼接，得到一个新元组，原元组不改变。

（2）元组相乘。list1 * 2 ，相当于两个元组拼接，得到一个新元组，原元组不改变。

（3）判断元素是否在元组中in。 if "元素" in data1：结果返回True或者False。

（4）获取长度len(data1)

（5）通过索引获取值。data1[0]表示data1列表中第0个元素的值。

（6）切片及步长。同字符串的使用方法。[start:end:step]

4. 集合（set）

集合是一个无序，可变，不允许数据重复的容器。

无序：表示不可用使用索引来获取值。

可变：s1 = {11,22,33, "jolin"}

s1.add("zoey") #返回s1 = {11,22,33, "jolin","zoey"}

不允许重复： s1.add("jolin") #只会存在一个值"jolin"。

什么时候用：使用集合，其最大的特性就是不重复。只有在这种场景下使用最合适。

注意：定义一个空集合时，不能够使用s1 = {},这表示一个空字典。

定义空集合时，只能s1 = set()，来表示一个空的集合。

4.1 独有功能方法

（1）添加元素add。data.add("元素")

（2）删除元素discard。data.discard("元素")。data.remove(element)也可以。

（3）交集 s1 & s2 。返回集合的元素在s1且在s2中

（4）并集 s1 | s2 。返回集合的元素在s1和s2的并集

（5）差集 s1 - s2 。返回集合的元素在s1中且不在s2中。

data = set()
data.add("test")     #返回data为{"test"}

data1 = {"jolin","love","zoey"}
data2 = {"jolin","enjoy","yingbao"}

data3 = data1 & data2    #返回{"jolin"}
data4 = data1 | data2    #返回{"jolin","love","zoey"，"enjoy","yingbao"}
data5 = data1 - data2    #返回{"love","zoey"}

4.2 公共功能方法

（1）计算集合长度len(data)

（2）通过for循环取值，只能按元素取值，不能用索引。for item in data:

4.3 类型转换

将字符串、元组、字典转换为集合，其主要目的是使用其去重的功能。

v1 = [11,22,33,44,11,22]

v2 = set(v1)       #返回{11,22,33,44}

注意：转换的时候，集合的元素必须是可哈希的。目前包含int，str，bool，tuple。不能是列表和字典。

5. 字典（dict）

字典是无序，键不重复且元素只能是键值对的可变容器。

字典的键必须是可哈希的数据类型：int/bool/str/tuple。一般常用str和int

字典的值可以是任意类型的。

5.1 独有功能方法

（1）获取值：age1 = info.get("age") 获取到的值30

（2）所有的键。data_key = info.keys()

（3）所有的值。data_value = info.values()

info = {
    "age":30
    "name":"zoey"
    "hobby":["跳舞","看电影"]
    "status": "beautiful"
}

data_key = info.keys()       #返回类似的列表 dict_keys(['age', 'name', 'hobby', 'status'])
for k in data_key:
    print(k)                 # 通过循环依次获取键

data_values = info.values()  #返回dict_values([30, 'zoey', ['跳舞', '看电影'], 'beautiful'])

data_items = info.items()    #返回所有键值对，可通过循环取出。一般常用的方式

for key,value in info.items():
    print(key,value)

5.2 公共功能方法

（1）求并集。两个字典合并

（2）获取长度len(info)

（3）判断是否在字典中。

if "age" in info: #默认判断键是否在字典中,等价于if "age" in info.keys()

if "zoey" in info.values(): #判断值是否在字典的值中。

（4）根据键修改、新增值或者删除值。

info = {
    "age":30
    "name":"zoey"
    "hobby":["跳舞","看电影"]
    "status": "beautiful"
}

info["sex"] = "女"      #字典新增了键值对"sex":"女"
print(info)

info["age"] = 31        #修改了age的键值
print(info)

del info["hobby"]      #根据键来删除这个键值对"hobby":["跳舞","看电影"]
info.pop("hobby")      # 也是根据"hobby"来删除。