Python基础数据类型汇总

本篇文章主要记录Python常用的的6个数据类型及其基础用法，包含数值类型（Number）、字符串（String）、元组（Tuple）、列表（List）、字典（Dictionary）、集合（Sets）。

一、数值类型（Number）

1、数据类型
整型（int）、长整型（long）、浮点型（float）、复数类型（complex）
2、数值运算符
加（+）、减（-）、乘（*）、除（/）、整除（//）、取余（%），指数（**）

二、字符串（String）

1、数据类型

字符（str），使用单引号、双引号包裹内容：a=‘1a’;b=“bag”;
使用三单引号和三双引号可以跨行、支撑巨长的内容：c=“”“asddfdsf”“”;d=‘’‘dscdscd’‘’。

2、下标和切片

（1）下标索引

下标在Python中的概念就是编号的意思,字符串、元组、列表都会经常用到下标的概念,我们可以根据下标找到它们所对应的元素，下标是从0开始的。

name = 'zhangsan'
print(name[2]) # z
print(name[0]) # a

（2）切片

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
切片的语法: [起始:结束:步长]

name = 'abcdef'
print(name[0:3]) # 取 下标0~2 的字符
#运行结果:abc
name = 'abcdef'
print(name[3:5]) # 取 下标为3、4 的字符
#运行结果 :de
name = 'abcdef'
print(name[2:]) # 取 下标为2开始到最后的字符
#运行结果:cdef

# 支持负数
name = ' abcdef!
print(name[1:-1]) # 取 下标为1开始 到 最后第2个 之间的字符
#运行结果:bcde

3、基础用法

（1）拼接：

• {}、%s、%d

a = '123'
b = '456'
print(a+b)   #'123456'
print("%sadcs%d" % ("y",15))   # yadcs15
#%s 表示字符串占位符（有些版本不能使用）
#%d 表是整数占位符
print("{}sddwdwxsc{}".format("ee","rr"))   #{}表示占位

（2）分割

• split() 方法

用于将一个字符串按照指定的分隔符拆分成多个子字符串。如果不指定分隔符，split() 方法默认使用空格作为分隔符。

a = 'qwerty'
#按照固定字符e切分
print(a.split("e"))   #['qw', 'rty']

• splitlines() 方法

用于将字符串按照换行符拆分成多个行，并将每行作为一个字符串存储在列表中。

s = "ok\ngood\nnice"
print( s.splitlines()) #['ok', 'good', 'nice']

（3）替换

• replace()方法

可以用来替换字符串中的指定子串。它接受两个参数，第一个参数是要被替换的子串，第二个参数是替换后的新子串。

a = "ab"
t = a.replace("a","b")  #把所有a替换为b
print(t) # bb

• sub()方法

使用re模块进行正则表达式替换：如果需要进行更加复杂的字符串替换，可以使用re模块中的sub()函数。sub()函数接受三个参数，第一个参数是要匹配的正则表达式，第二个参数是替换后的新子串，第三个参数是要被替换的原字符串。

import re
string = "Hello, World!"
new_string = re.sub(r"Hello", "Hi", string)
print(new_string)  # 输出：Hi, World!

（4）判断

• startswith()方法

用于判断字符串是否以指定的前缀开头。语法str.startswith(strs[, start[, end]])其中，str代表要判断的字符串，strs代表指定的前缀，start和end为可选参数，表示判断的字符串范围。该方法返回一个布尔值，如果字符串以指定的前缀开头，则返回True，否则返回False。

str = 'Hello World'
print(str.startswith('Hello')) # True
print(str.startswith('World',2)) # False
print(str.startswith('e',1)) # True

• endswith()方法

用于 判断某一个字符串的结尾是否是使用的指定的字符结尾。语法str.endswith(strs[,start[, end]])，str代表要判断的字符串，strs代表指定的结尾，start和end为可选参数，表示判断的字符串范围

str = 'Hello World'
print(str.endswith('ld')) # True
print(str.endswith('ld',0,11)) # True
print(str.endswith('e',3)) # False

• in 与 not in

in 右侧的内容里，是否包含了左侧的内容。 包含返回真，不包含返回假。
not in 右侧的内容里是否不包含左侧的内容。不包含返回真，包含返回假。
in 与 not in 可以放在任何允许添加条件判断的位置。如while 、if 等。

a = 'ddffww'
print("dd"  in  a) #  True 判断a字符串是不是包含dd
print("dd"  not in  a) #  False  判断a字符串是不是不包含dd

（5）查找

• find()
  检测 str 是否包含在 字符串 中，如果是返回开始的索引值，否则返回-1。

a= 'he11o world mm'
a.find("mm") #运行结果为:12

• index()
  跟find0 方法一样，只不过如果 str 不在字符串中会报一个异常

a= 'he11o world mm'
a.index("mm") #运行结果为:12

• count()
  返回 str在start和end之间在字符串里面出现的次数

a= 'he11o world mm'
a.count("m") #运行结果为:2

（6）大小写

capitalize() 把字符串第一个字符大写
title() 把字符串中的每个单词的首字母大写
lower() 把字符串里面所有大写转小写
upper() 把字符串里面所有小写转大写

（7）对齐

ljust() 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
rjust() 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
center() 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串

（8）去除空格

lstrip()删除字符串左边的空白字符
rstrip() 删除字符串末尾的空白字符
strip() 删除字符串两端的空白字符

三、列表（List）

1、数据类型

列表（list）是一种有序的集合，可以随时添加和删除其中的元素，写在方括号之间、用逗号分隔开的数值列表。列表内的项目不必全是相同的类型。

2、列表特性：

不限数据长度、可存储任意类型数据、从前往后的顺序、支持切片和索引

3、常见操作

（1）列表的长度

len()函数可以获得列表中元素的个数。

a = ['we','you','me']
print(len(a))  # 3

（2）列表的访问

用索引来访问列表中每一个位置的元素，索引是从0开始的。当索引超出了范围时，Python会报一个IndexError 错误，要确保索引不要越界，记得最后一个元素的索引是 len(classmates) - 1。如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素，以此类推，可以获取倒数第2个、倒数第3个。

a = ['we','you','me']
print(a[0])  # we you
print(a[2])  # me
print(a[-1])  # me

（3）列表的切片

切片：根据下标的范围获取一部分数据，比如: 列表，字符串均可以使用切片。
切片的使用格式数据：[起始下标:结束下标:步长]，注意起始下标默认0， 结束下标是不包含， 步长默认是1。

a=['small', 'we', 'app', 'you', 'me', 'big']
# 使用切片的方式获取一部分数据
result = a[1:4:1]
print(result)  #['we', 'app', 'you']
#前三个
result = a[0:3]
print(result)  #['small', 'we', 'app']
result = a[:3]
print(result) #['small', 'we', 'app']

（4）添加元素 （append、extend、insert）

• append()
  append()追加，给列表后面追加一个元素。

a = ['we','you','me']
a.append("to")
print(a)  #['we', 'you', 'me', 'to']
a.append("['1','2']")
print(a)  #['we', 'you', 'me', 'to', "['1','2']"]

• extend()
  extend（）拓展，通过 extend 可以将另一个集合中的元素逐一添加到列表中

a=['we','you','me']
a.append("to")
print(a)  #['we', 'you', 'me', 'to']
a.extend(['1','2'])
print(a)  #['we', 'you', 'me', 'to', '1', '2']

• insert()
  insert(index,value)插入，在指定位置插入元素，index要插入列表中的位置，value要插入的元素的值，index小于0默认插入最前方，index大于最大索引默认插入最后方。

a=['we','you','me']
a.insert(1,'app')
print(a)  #['we', 'app', 'you', 'me']
a.insert(10,'big')
print(a) #['we', 'app', 'you', 'me', 'big']
a.insert(-10,'small') #['small', 'we', 'app', 'you', 'me', 'big']
print(a)

（5）修改元素

修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改。

a=['we','you','me']
print(a)  #['we', 'you', 'me']
a[1]='xx'
print(a)  #['we', 'xx', 'me']

（6）查找元素

查找，看指定的元素是否存在。

• in 和 not in
  in (存在)，如果存在那么结果为 true，否则为 false
  not in (不存在)，如果不存在那么结果为true，否则 false

a=['we','you','me']
print( "we" in a )  #True
print( "we" not  in a ) #False

• index()
  如果元素在列表中，返回元素的索引，不在列表中会报异常

a=['we','you','me']
print(a.index("we"))  #0，返回索引 
print(a.index("ss"))  # 报异常

• count()
  返回元素在列表里面出现的次数

a=['we','you','me','we']
print(a.count("we")) #2

（7）删除元素（del、pop、remove、clear）

• del
  del根据下标进行删除

 a=['we','you','me','we']
del a[1]
print(a) #['we', 'me', 'we']

• pop()
  pop()删除最后一个元素

a=['we','you','me']
print(a.pop()) # me 返回删除数据
print(a) #['we', 'you']

• remove()
  remove()根据元素的值进行删除

a=['we','you','me']
a.remove('you') 
print(a) #['we', 'me']

• clear()
  clear()清除列表元素

a=['we','you','me']
a.clear()
print(a) #[]

（8）列表的遍历

• 使用for循环
  为了更有效率的输出列表的每个数据，可以使用循环来完成。

a=['we','you','me']
for i in a:
    print(i)
# 输出结果:
# we
# you
# me

• 使用while循环

 a=['we','you','me']
length = len(a)
i=0
while i<length:
    print(a[i])
    i+=1
# 输出结果:
# we
# you
# me

（9）其他

• copy()
  copy()拷贝，表示原样拷贝一份数据。

a=['we','you','me']
b=a.copy()
print(a) #['we', 'you', 'me']
print(b) #['we', 'you', 'me']

• reverse()
  reverse()逆序，用于倒序排列列表中的元素。

a=['we','you','me']
a.reverse()
print(a) #['me', 'you', 'we']

• sort()
  sort()函数，用于对列表进行排序。

a=['we','you','me']
a.sort() #默认reverse=False
print(a) #['me', 'we', 'you']
a.sort(reverse=True)
print(a) #['you', 'we', 'me']

四、元组（Tuple）

1、数据类型

(1)定义一个空的tuple

t=()
type(t) #tuple

(2)定义一个只有1个元素的tuple

t1=(1)
type(t1) # int
t2=(1,)  #tuple
type(t2)

t1=(1)定义的不是tuple，是1这个数字，这是因为括号()既可以表示tuple，又可以表示数学公式中的小括这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。所以，只有1个元素的tuple定义时必须加一个逗号t2=(1,)，来消除歧义。

2、元组的特性

元组是另一种有序列表，tuple和list 非常类似，但是 tuple一经定义、不能修改，不限长度，是从前往后的顺序，由单元素组成的集合。

3、常见操作

（1）查找元素

index()

（2）计数

count()

4、元组和列表的区别

（1）定义和特性不同

元组是不可变的序列，使用圆括号（）表示。它可以包含任意类型的元素，如整数、字符串、浮点数等。由于元组是不可变的，一旦创建后，其元素不能被修改、添加或删除。元组是用于存储不可变数据的理想选择，它具有固定长度和不可变性的特点。

列表是可变的序列，使用方括号[]表示。与元组不同，列表的元素可以被修改、添加或删除。列表也可以包含不同类型的元素，并且长度可以动态调整。列表是用于存储可变数据的优选数据结构，它提供了更大的灵活性。

（2）操作和性能不同

由于元组是不可变的，因此它的操作相对有限。对于元组，我们可以通过索引访问元素，切片获取子元组，以及使用内置函数进行基本操作，如计算长度和查找元素。元组的不可变性使得它在处理简单数据结构时更加高效。

列表支持与元组相同的操作，并且还提供了丰富的方法来修改和操作元素。我们可以使用索引和切片对列表进行访问和修改，还可以使用append()、insert()和remove()等方法在列表中添加和删除元素。列表的可变性使得它在需要频繁修改和操作数据时更加方便。

在处理大型数据集或需要频繁修改数据时，使用列表可能会更加高效。然而，如果需要确保数据的不可变性或避免意外的修改，使用元组是更好的选择。

（3） 使用场景和适用性不同

元组适用于表示一组固定的数据项，例如坐标点、日期和时间等。元组还可以用于函数返回多个值的情况，因为它可以保证返回的数据的不可变性。

列表适用于需要频繁修改和操作数据的场景。它可以用于存储和处理动态的数据集，如用户列表、待办事项等。列表还可以通过循环和列表解析进行高效的遍历和处理。

根据实际需求选择元组或列表是很重要的。如果数据不需要修改或者需要保持不可变性，那么选择元组是合适的。如果数据需要频繁修改或者需要添加、删除元素，那么选择列表更为合适。

（4）内存占用和性能不同

元组在内存中占用的空间更小，这是因为元组的长度固定，不需要额外的内存来进行动态扩展或收缩。因此，在存储大量数据时，元组相对于列表具有更小的内存占用。

列表则需要更多的内存空间来处理动态的添加、删除操作。当列表需要动态扩展时，Python会为其分配更多的内存空间，以确保能够容纳更多的元素。这可能导致在处理大型数据集时，列表占用更多的内存。

在性能方面，元组的不可变性使得其操作更加高效。由于元组的长度不可变，因此访问元素的速度更快。而列表的可变性可能导致一些额外的开销，例如重新分配内存和更新索引等操作。因此，在需要高性能和较小内存占用的场景下，元组可能是更好的选择。

（5）元组和列表都可以存储多个值

元组和列表都允许我们将多个数据项组合在一起，并且可以通过索引来访问其中的特定项。无论是元组还是列表，都可以包含任意类型的数据，例如整数、浮点数、字符串等等。

（6）元组和列表都可以通过索引进行访问

在Python中，索引从0开始，因此我们可以使用索引来获取元组或列表中的特定项。例如，对于一个元组t和一个列表l，我们可以通过t[0]和l[0]来获取它们的名列前茅个元素。通过索引，我们可以对元组和列表中的特定项进行修改或操作。

（7）元组和列表都支持切片操作

切片是一种通过指定起始索引、结束索引和步长来获取子序列的方法。通过使用切片，我们可以从元组或列表中获取一个连续的子集。例如，对于一个元组t和一个列表l，我们可以使用t[1:3]和l[1:3]来获取它们的第二个和第三个元素。

（8）元组和列表都是可迭代的

这意味着我们可以使用循环结构（如for循环）来遍历元组或列表中的每个元素。通过迭代，我们可以方便地对元组或列表中的每个元素进行处理或操作。

五、字典（Dictionary）

1、数据类型

dict字典是另一种可变容器模型，且可存储任意类型对象。

2、字典的特性

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号()分割，整个字典包括在花括号{}中。

3、常见操作

（1）修改元素

• 改变字典的值
  字典的每个元素中的数据是可以修改的，只要通过 key 找到，即可修改。

t={'name' : 'yy' ,'id' :100,'sex' :'女'}
print(t['name'])  #yy
t['name']='linlin'
print(t)  #{'name': 'linlin', 'id': 100, 'sex': '女'}

• 改变字典的键
  与改变一个键的值不同，不能简单地将键重新分配给一个新的值。相反，需要用新的键和旧的值创建一个新的键-值对，然后删除旧的键-值对。可以使用pop()方法来删除旧的键值对，再添加新的。

t={'name' : 'yy' ,'id' :100,'sex' :'女'}
t.pop('name') 
print(t) #{'id': 100, 'sex': '女'}
t['names']='yy' 
print(t) #{'id': 100, 'sex': '女', 'names': 'yy'}

（2）添加元素

如果在使用 变量名[‘键’]= 数据 时，这个“键“在字典中，不存在，那么就会新增这个元素，添加新的元素。

t={'id' :100,'sex' :'女'}
t['names']='yy' 
print(t) #{'id': 100, 'sex': '女', 'names': 'yy'}

（3）删除元素

del 删除指定元素
clear()清空整个字典
pop()删除指定元素

t={'name' : 'yy' ,'id' :100,'sex' :'女','address':'浙江杭州'}
del t['name'] 
print(t)  #{'id': 100, 'sex': '女', 'address': '浙江杭州'}
t.pop('id')
print(t)  #{'sex': '女', 'address': '浙江杭州'}
t.clear()
print(t)   #{}

（4）len

测量字典中，键值对的个数

t={'name' : 'yy' ,'id' :100,'sex' :'女','address':'浙江杭州'}
print(len(t))  # 4

（5）keys

返回一个包含字典所有key的列表

t={'name' : 'yy' ,'id' :100,'sex' :'女','address':'浙江杭州'}
print(t.keys())  #dict_keys(['name', 'id', 'sex', 'address'])
print(list(t.keys())) # ['name', 'id', 'sex', 'address']

（6）values

返回一个包含字典所有value的列表

t={'name' : 'yy' ,'id' :100,'sex' :'女','address':'浙江杭州'}
print(t.values())  #dict_values(['yy', 100, '女', '浙江杭州'])
print(list(t.values()))  #['yy', 100, '女', '浙江杭州']

（7）items

返回一个包含所有 (键，值) 元祖的列表

t={'name' : 'yy' ,'id' :100,'sex' :'女'}
print(t.items())  #dict_items([('name', 'yy'), ('id', 100), ('sex', '女')])
print(list(t.items()))  #[('name', 'yy'), ('id', 100), ('sex', '女')]

六、集合（Sets）

1.数据类型

set，可以使用大括号{}或者 set() 函数创建集合，注意: 创建一个空集合必须用 set()而不是{}，因为{}是用来创建一个空字典。

创建一个空Set
y = {}    #类型是字典dict
y = set()  #类型是set
y = set("addp")  # 输出y集合为 {'a', 'p'}
y={"app","apple"} # 输出y集合为{"app","apple"} 

2.集合的特性

集合 (set)是一个无序的不重复元素序列。可以理解成字典的键集合，主要用于集合运算。Set优势: 效率高，运行速度快，效率远高于列表；Set劣势:不限定具体类型，但是元素内容必须是不可变。

3.常见操作

（1）添加数据

集合天然有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进行任何操作。

s1 = {10, 20}
s1.add(100)
s1.add(10)
print(s1)  # {100, 10, 20}

（2）追加数据序列

数据序列是个大类型，包括: list，str，tuple，dict，set

s1 = {10, 20}
# s1.update(100)  # 报错  
s1.update([100, 200]) # 必须是数据序列(str,list,tuple,dict,set)类型 本质是去遍历 然后一一加入
s1.update('abc')
print(s1)
# {100, 200, 10, 'a', 'b', 'c', 20}

（3）删除数据

remove()，删除数据，数据不存在则报错
discard()，删除数据，数据不存在也不报错，相当于没添加
pop()，随机删除数据，并返回该数据

(4)查找数据

in/not in ：返回True 或者False

y={10,20,30}
10 in  y  #True

(5) 集合处理

a= {1,2,3,4}  b={1,3,4,6,7}
a|b #{1,2,3,4,6,7}
a-b #{2,4}
a^b #{2, 6, 7}
a&b#{1,3,4}