python数据类型大全(变量、字符串、列表、元组、字典、集合)

文章目录

• ​​一、变量​​

• ​​`1.1.常用方法`​​
• ​​`1.2.变量的三种赋值方式`​​

• ​​二、字符串​​

• ​​`2.1.定义`​​
• ​​`2.2.特殊字符`​​

• ​​2.2.1.转义特殊字符​​

• ​​`2.3.字符串格式化操作`​​
• ​​`2.4.字符串方法`​​

• ​​a.字符串截取​​
• ​​b.字符串查找​​
• ​​c.字符串的分割及替换​​
• ​​d.字符串修饰​​
• ​​e.字符串变形​​
• ​​f.字符串判断​​
• ​​g.字符串拼接​​

• ​​三、列表​​

• ​​`3.1.定义`​​
• ​​`3.2.增删改查`​​
• ​​`3.3.list函数`​​
• ​​`3.4.列表切片`​​
• ​​`3.5.列表解析`​​
• ​​`3.6.列表方法`​​

• ​​获取列表的下标和值​​

• ​​四、元组​​

• ​​`4.1.元组的定义`​​
• ​​`4.2.元组的优点`​​
• ​​`4.3.定义元组`​​
• ​​`4.4.tuple函数`​​

• ​​五、字典​​

• ​​`5.1.字典的定义`​​
• ​​`5.2.字典的特点`​​
• ​​`5.3.字典的基本操作`​​
• ​​`5.4.字典方法`​​

• ​​a.创建值相同的字典​​
• ​​b.遍历字典​​
• ​​c.字典推导式​​

• ​​六、集合​​

• ​​`6.1.集合的定义`​​
• ​​`6.2.集合基本操作`​​
• ​​`6.3.去重操作`​​

• ​​七、数据类型对比​​

参考视频：https://edu.51cto.com/lesson/331752

一、变量

​​1.1.常用方法​​

type(变量名)           #查看变量类型
print(id(name))     #查看变量的内存地址  
del(name)           #删除变量name

​​1.2.变量的三种赋值方式​​

name = 'qixiang'        #传统赋值
name = user = 'qixiang'     #链式赋值
name,age = 'qixiang',18     #序列解包赋值

二、字符串

​​2.1.定义​​

字符串是一个有序的、不可修改的、以引号包围的序列

​​2.2.特殊字符​​

"\"转义符    #取消特殊含义的字符或者作续行符
"\n"      #换行符
"\t"      #水平制表符，相当于Tab键

2.2.1.转义特殊字符

>>> wpath=r'c:\tmp\nm'
>>> print(wpath)
c:\tmp\nm

​​2.3.字符串格式化操作​​

%s    #字符串占位符
%d    #数字占位符
%f    #浮点型占位符
%.2f  #保留小数点后两位

#print('%s age is %d' % ('tom', 18))
print(f"{name} age is {age}")   #推荐使用

​​2.4.字符串方法​​

a.字符串截取

包头不包尾，从左往右

name = 'abcdef'
print(len(name))      #取字符串长度
print(name[0])        #取第一个字符a
print(name[1:3])      #取字符bc
print(name[0:5:2])      #每隔一位截取，结果ace
print(name[:2])       #ab
print(name[3:])       #def
print(name[-2:])      #保留最后两个字符,ef
print(name[:])        #abcdef
print(name[::2])      #ace
print(name[-1])       #f
print(name[::-1])     #反转字符串，fedcba
print(name[4:1:-1])

b.字符串查找

str = 'Hello World'
print(str.count('o'))       # 统计字符o的个数
print(str.find('z'))        # 找不到返回-1
print(str.find('o'))        # 从左往右，返回第一个字符o的下标4
print(str.rfind('o'))       # 从右往左，返回第一个字符o的下标7
print(str.index('o'))       # 从左往右，返回第一个字符o的下标4
print(str.index('z'))       # 找不到抛出异常

c.字符串的分割及替换

str = 'Hello World'
print(str.partition('o'))   #以字符o进行分割，('Hell', 'o', ' World')
str = 'Hello\nWorld'
print(str.splitlines())     #按行分割，用于处理文本，['Hello', 'World']
>>> hi.split()          # 默认以空格进行切割
['hello', 'world']
>>> 'hello.tar.gz'.split('.')   # 以点作为分隔符切割
['hello', 'tar', 'gz']

print(str.replace('H','w'))   #把所有的H替换为w,wello World

d.字符串修饰

str = 'for'
print(str.center(20,'*'))       # ********for*********
print(str.ljust(10))            #左对齐，占10个位置
print(str.zfill(10))            #从左至右填充，不足用0补齐，0000000for
str = '{} is {}'
print(str.format('for','cool')) #将参数按顺序传给前面的大括号,for is cool
'   \thello world!\n   '.strip()      # 去除字符串两端空白字符
'   \thello world!\n   '.lstrip()     # 去除字符串左边空白字符

e.字符串变形

str = 'Hello'
print(str.upper())      #小写变成大写，HELLO
print(str.lower())      #大写变成小写，hello
print(str.swapcase())   #大小写互换，hELLO
print('hello,world'.title())      #以非字母划分，字符串首字母大写，Hello,World
print('hello,world'.capitalize())   #字符串首字母大写，Hello,world
print('hello \t world'.expandtabs(10))  #制表符强制替换为10个空格（默认8个），hello      world

f.字符串判断

print('123ab'.isalnum())        # 判断是否只有数字或字母
print('abc'.isalpha())          # 判断是否只有字母
print('123'.isdigit())          # 判断是否只有数字
print('HELLO'.isupper())        # 判断是否只有大写字母
print('hello world'.startswith('h'))    # 判断是否由h开头
print('hello world'.endswith('d'))      # 判断是否由d结尾

if not username.strip():    #判断是否为空
  print("用户名不能为空")

g.字符串拼接

a = 'I '
b = 'Love '
c = 'You'
d = a + b + c
print(d)        #结果为：I Love You

三、列表

​​3.1.定义​​

列表是一个有序的，可修改的，元素以逗号分割，以中括号包围的序列
列表中的元素可重复

​​3.2.增删改查​​

alist = ['唐三', '小舞']
alist.append('沐白')          # 在列表后面追加元素
alist.insert(0, '唐昊')       # 在下标为0的位置插入元素，之后的元素整体往后移，当元素很多时，占用内存较多，不推荐该方法

blist = ['魂师', '大魂师']
alist.extend(blist)           # 扩展列表，追加到后面
clist = alist + blist         # 列表相加，赋值给新列表
alist.pop()                   # 默认弹出最后一个元素
alist.pop(3)                  # 弹出下标为3的元素
clist.remove('魂师')          # 从左往右，删除第一个匹配的元素
del alist                     # 删除列表
clist[1] = '小三'             # 修改下标为1的元素
print(clist.count('小三'))    # 统计某个元素的个数
print(clist.index('大魂师'))  # 查找元素的下标值，从左往右，匹配第一个
print(clist[-1])              # 获取列表最后一个元素
print('唐昊' in clist)        # 查找是否在列表中，在返回True，不在返回False
clist.reverse()               # 列表反转
list1 = [4,12,6,1]
list1.sort()                  # 按ASCII码排序

blist = alist.copy()      # 将alist的值拷贝一份后，赋值给blist
blist.clear()           # 清空列表

>>> alist = [2, '5', 4 , 1, 3]
>>> alist.sort(key=int, reverse=True)   #key仅仅用在比较时
>>> alist
['5', 4, 3, 2, 1]

​​3.3.list函数​​

a = 'abc'
b = list(a)             # 把字符串转换为列表
c = ''.join(b)          # 把列表转成字符串
a = [1, 2, 3]
# c = ''.join(a)                # 会报错，数字列表不能直接转为字符串
c = ''.join(str(i) for i in a)      # 先把列表中的数字转为单个字符串，再拼接为完整字符串

​​3.4.列表切片​​

参考字符串截取

​​3.5.列表解析​​

>>> [5 + i for i in range(1, 11)]
[6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
>>> ['192.168.1.%s' % i for i in range(1,5)]
['192.168.1.1', '192.168.1.2', '192.168.1.3', '192.168.1.4']
>>> [i for i in range(10) if i % 2 ==0]
[0, 2, 4, 6, 8]

​​3.6.列表方法​​

获取列表的下标和值

alist = ['a', 'b', 'c']
for index, value in enumerate(alist):
  print(index, value)

四、元组

​​4.1.元组的定义​​

元组是有序的，不可修改的，以逗号分割，以小括号包围的序列，可通过()和tuple()函数定义

不能修改，只有在定义的一瞬间可以修改

元组就是一个静态列表

​​4.2.元组的优点​​

由于元组不可以修改，因此遍历元组要比列表快

元组不可变，因此元组中的数据被“写保护”，用于存储比较重要的数据

​​4.3.定义元组​​

t1 = (1, 2, 'a', 'b')       # 定义一个元组
t1 = ()                     # 定义一个空元组
t1 = (1,)                   # 定义单元素元组

​​4.4.tuple函数​​

alist = ['a', 1]
t1 = tuple(alist)       # 列表转为元组
str = 'hello'
t1 = tuple(str)         # 把字符串转为元组
print(''.join(t1))      # 把元组拼接为字符串

五、字典

​​5.1.字典的定义​​

字典是无序的、可修改的、元素呈键值对形式、以逗号分割、以大括号包围的数据类型

​​5.2.字典的特点​​

字典是无序的，没有索引值，以键取值

字典的键唯一且不可修改

​​5.3.字典的基本操作​​

info = {'name': 'tom', 'age': '18'}  # 定义一个字典
print(info.get('name'))              # 获取name的值
print(info.get('name1', 'bob'))      # 没有name1则使用默认值bob
info['addr'] = 'beijing'             # 有则修改，无则添加
del info['age']                      # 删除某一键值对

print(info.keys())                # 返回一个包含字典所有key的列表
print(info.values())              # 返回一个包含字典所有value的列表
info.setdefault('addr')           # 设置默认，如果键存在，返回值；不存在，创造键，默认值为None
info.update({'like': '篮球'})       # 更新指定键的内容，如果键不存在，则创建键值对
print(info.items())               # 返回字典键值呈元组形式
print(len(info))                  # 计算键值对的个数

info.pop('addr')          # 弹出指定的键值对
info.popitem()           # 随机弹出一个键值对
info.clear()             # 清空字典

​​5.4.字典方法​​

a.创建值相同的字典

>>> bdict = {}.fromkeys(['jerry', 'tom', 'bob'], 20)
>>> bdict
{'jerry': 20, 'tom': 20, 'bob': 20}

b.遍历字典

### 不推荐
>>> for key, val in adict.items():
...    print(key, val)
### 推荐
for i in adict:
  print(i, adict[i])

c.字典推导式

>>> {k:v for k, v in {'name': 'tom', 'age': '18'}.items()}
{'age': '18', 'name': 'tom'}

六、集合

​​6.1.集合的定义​​

集合是一组无序不重复的元素集合

创建一个空集合必须用set(),而不是{ }

集合分为不可变集合forzenset和可变集合set

集合和字典都是无序的，字典的key和集合元素都是不可变的、不能重复的。因此，集合就像是一个没有value的字典

​​6.2.集合基本操作​​

>>> aset = set('abc')
>>> bset = set('bcd')
>>> aset & bset       # 交集
{'c', 'b'}
>>> aset | bset       # 并集
{'c', 'b', 'a', 'd'}
>>> aset ^ bset       #对称差集，并集-交集
{'a', 'd'}
>>> aset.isdisjoint(bset)     #没有交集返回True
False
>>> aset - bset       # 差补，在aset中有，bset中没有
{'a'}
>>> aset.add('new')    # 将new作为整体添加到集合
>>> aset
{'new', 'a', 'c', 'b'}
>>> aset.update('new')    # 将序列对象中的每个元素逐一添加到集合
>>> aset
{'new', 'c', 'a', 'n', 'w', 'b', 'e'}
>>> aset.remove('new')        # 删除一项,没有会报错
>>> print(aset.discard('dd'))   #没有不会报错，返回None
None
>>> aset.pop()        #随机删除一项，并打印
b
>>> s1.issuperset(s2)     # s1是s2的超集吗？
>>> s2.issubset(s1)     # s2是s1的子集吗？

​​6.3.去重操作​​

>>> num_list = [randint(1, 20) for i in range(10)]
>>> num_list
[1, 7, 19, 13, 18, 16, 19, 15, 9, 19]
>>> list(set(num_list))
[1, 7, 9, 13, 15, 16, 18, 19]

七、数据类型对比