基础数据类型总结

Posted 2020-11-02 qiujie

一、数字类型

　　一、int

　　　　不可变数据类型（可哈希）

　　　　数字主要是用于计算用的

　　二、bool

　　　　不可变数据类型（可哈希）

　　　　布尔值值分为两种：True ，False ，就是反应条件的正确与否

　　　　　　真 1 True

　　　　　　假 0 False

　　　　　　int-->str str(int)

　　　　　　str-->int int(str)

　　　　　　int--->bool 0 代表false 非零代表True

　　　　　　str--->bool 非空 为True ，空字符串就是False

　　　　　　bool-->str 无意义 ，很少用到

　　三、float

　　　　不可变数据类型（可哈希）

　　　　小数数字运算

　　四、complex

　　　　不可变数据类型（可哈希）

　　　　复数运算

二、序列类型

　　一、str

　　　　不可变数据类型（可哈希）

　　　　1、索引和切片

#索引与切片 s[起始索引:截止索引:步长]
s = ‘老男孩是最好的培训机构‘
#索引
s1 = s[0]   
print(s1)   # 老
s2 = s[2]
print(s2)   # 孩
#切片  顾头不顾腚
s4 = s[0:3]
print(s4)   # 老男孩
s41 = s[:3]
print(s41)  # 老男孩
s6 = s[:]   # 老男孩是最好的培训机构
print(s6)
#步长
s7 = s[:5:2]    # 老孩最
print(s7)
s8 = s[:7:3]    # 老是的
print(s8)
# 反向步长
s7 = s[-1:-5:-1]    # 构机训培
print(s7)

　　　　2、字符串常用方法

s = ‘laonanHai‘
# 1、*** 首字母大写，其他字母小写
s1 = s.capitalize()
print(s1)   # Laonanhai

# 2、***全部大写，全部小写
s2 = s.upper()
s3 = s.lower()
print(s2,s3)    # LAONANHAI laonanhai
code = ‘aeQu‘.upper()
your_code = input(‘请输入验证码‘).upper()
if your_code == code:
    print(‘验证码输入成功‘)
# 3、 * 居中center
s4 = s.center(30)
print(s4)
s4 = s.center(30,‘*‘)
print(s4)

# 4、**大小写翻转
s5 = s.swapcase()
print(s5)   # LAONANhAI
s = ‘alex wusir*laonanhai2taibai‘
# 5、每个单词的首字母大写(非字母隔开)
s6 =s.title()
print(s6)   # Alex Wusir*Laonanhai2Taibai

s = ‘alexlaonanhai‘
# 6、***判断以什么为开头，以什么为结尾。
# startswith endswith()
s7 = s.startswith(‘a‘)
s71 = s.startswith(‘al‘)
s72 = s.startswith(‘alex‘)
s73 = s.startswith(‘alex‘)
s74 = s.startswith(‘l‘, 4)
print(s74)  # True
print(s7,s71,s72,s74)   # True True True True
s = ‘  laonanhai ‘
s = ‘\nlaonanhai\t‘
# 7、***去除首尾的空格，换行符，tab
# 去除左边的空格，换行符，tab   lstrip()
# 去除右边的空格，换行符，tab   rstrip()
#strip（）
print(s)
print(s.strip())
print(s.lstrip())
print(s.rstrip())
name = input(‘请输入用户名：‘).strip()
if name == ‘alex‘:
    print(666)
s = ‘,laoxnanhaialexl‘
print(s.strip(‘,lax‘))  # oxnanhaiale
s = ‘alexex‘
# 8、*** find  index 通过元素找索引
print(s.find(‘e‘))  # 2
print(s.find(‘e‘,3))    # 4(从索引3开始)
print(s.find(‘A‘))  # -1
# print(s.index(‘A‘)) #执行报错
s = ‘alexex‘
# 9、*** count 寻找元素出现的个数 可切片
print(s.count(‘e‘)) # 2
print(s.count(‘ex‘))    # 2
a1=‘ladsfaldfakd000lsd32320‘
ret3 = a1.count("a") # 可切片
print(ret3) # 3
# 10、***replace 替换
s = ‘将发生多了范德萨发范德萨回复‘
s1 = s.replace(‘范德萨‘, ‘小粉嫩‘)
print(s1)   # 将发生多了小粉嫩发小粉嫩回复
s2 = s.replace(‘范德萨‘, ‘小粉嫩‘,1)
print(s2)   # 将发生多了小粉嫩发范德萨回复
s3 = s.replace(‘范德萨‘, ‘sb‘)
print(s3)   # 将发生多了sb发sb回复

# 11、***** split 分割  str ---> list
s = ‘alex wusir taibai‘
print(s.split())    # [‘alex‘, ‘wusir‘, ‘taibai‘]
s1 = ‘alex,wusir,taibai‘
print(s1.split(‘,‘))    # [‘alex‘, ‘wusir‘, ‘taibai‘]
s2 = ‘alexawusirataibai‘
print(s2.split(‘a‘))    # [‘‘, ‘lex‘, ‘wusir‘, ‘t‘, ‘ib‘, ‘i‘]
s3 = ‘alexawusirataibai‘
print(s3.split(‘a‘,1))  # 分割次数  [‘‘, ‘lexawusirataibai‘]


# 12、***** format 格式化输出
#三种用法
#第一种用法：
s = ‘我叫{}，今年{}，爱好{}‘.format(‘MT‘,18,‘母牛‘)
#第二种用法
s = ‘我叫{0}，今年{1}，爱好{2}，我依然叫{0},今年还是{1}‘    .format(‘MT‘,18,‘母牛‘)
#第三种 键值对
s = ‘我叫{name}，今年{age}，爱好{hobby}‘.format(age=18, name=‘MT‘, hobby=‘闷儿‘)
name=‘123a‘
# 13、字符串由字母或数字组成，字符串只由字母组成，字符串只由数字组成
print(name.isalnum()) # 字符串由字母或数字组成  True
print(name.isalpha()) # 字符串只由字母组成    False
print(name.isdigit()) # 字符串只由数字组成    False
if name.isdigit():
    name = int(name)
    print(name,type(name))
else:
    print(‘您输入的由非数字元素‘)
# 14、casefold
# 用法：S.casefold()
# 意义：lower() 方法只对ASCII编码，也就是‘A-Z’有效，对于其他语言（非汉语或英文）中把大写转换为小写的情况只能用 casefold() 方法
# 用法:
s = ‘aBBex ‘
print(s.casefold())  # abbex
# 15、expandtabs
# 用法：S.expandtabs(tabsoze=8)
# 意义：把字符串中的 tab 符号(‘\t‘)转为空格，tab 符号(‘\t‘)默认的空格数是 8。
# 从头开始数，数到第一个\t正好为8个空格，不足则补空格，如果还有\t，接着从第一个\t数到第二个\t仍然为8个空格，以此类推直到最后一个\t结束。
# 用法
S = "this is\tstring example....wow!!!"
print("原始字符串: " + S)    #原始字符串: this is    string example....wow!!!
print("替换 \\t 符号: " + S.expandtabs())   #替换 \t 符号: this is string example....wow!!!
print("使用16个空格替换 \\t 符号: " + S.expandtabs(16))  #使用16个空格替换 \t 符号: this is         string example....wow!!!

　　二、list

　　　　可变数据类型（不可哈希）

　　　　注：对于list，在循环一个列表时，最好不要进行删除的动作（一旦删除，索引会随之改变），容易出错。

　　　　1、索引、切片、步长

li = [‘alex‘,123,True,(1,23,34,‘wusir‘),[2412,234,‘xiaomin‘],{‘name‘:‘alex‘}]
#索引、切片、步长
print(li[0]) # alex
print(li[2]) # True
print(li[:4]) # [‘alex‘, 123, True, (1, 23, 34, ‘wusir‘)]
print(li[3:1:-1]) # [(1, 23, 34, ‘wusir‘), True]

　　　　2、增

# 1、append 在列表最后加入元素,结果没有返回值，直接修改列表
li.append(‘alex‘)
print(li) # [1, ‘a‘, ‘b‘, ‘a‘, 2, 3, ‘老男孩‘, ‘alex‘]
li.append([1,2,3])
print(li) # [1, ‘a‘, ‘b‘, ‘a‘, 2, 3, ‘老男孩‘, ‘alex‘, [1, 2, 3]]
# 2、insert 插入 可以按索引插入
li.insert(2,‘sb‘)
print(li) # [1, ‘a‘, ‘sb‘, ‘b‘, ‘a‘, 2, 3, ‘老男孩‘, ‘alex‘, [1, 2, 3]]
# 3、extend 迭代添加，到最后
li.extend(‘214‘)
print(li) # [1, ‘a‘, ‘sb‘, ‘b‘, ‘a‘, 2, 3, ‘老男孩‘, ‘alex‘, [1, 2, 3], ‘2‘, ‘1‘, ‘4‘]
li.extend([1,2,‘ab‘])
print(li) # [1, ‘a‘, ‘sb‘, ‘b‘, ‘a‘, 2, 3, ‘老男孩‘, ‘alex‘, [1, 2, 3], ‘2‘, ‘1‘, ‘4‘, 1, 2, ‘ab‘]

　　　　3、删

li = [1, ‘a‘, ‘sb‘, ‘b‘, ‘a‘, 2, 3, ‘老男孩‘, ‘alex‘, [1, 2, 3], ‘2‘, ‘1‘, ‘4‘, 1, 2, ‘ab‘]
# 1、remove 按元素删除
li.remove(‘a‘)
print(li) #[1, ‘sb‘, ‘b‘, ‘a‘, 2, 3, ‘老男孩‘, ‘alex‘, [1, 2, 3], ‘2‘, ‘1‘, ‘4‘, 1, 2, ‘ab‘]
# 2、pop 按索引删除,默认删除最后一个，返回值是删除的元素
print(li.pop()) # ab
print(li) #[1, ‘sb‘, ‘b‘, ‘a‘, 2, 3, ‘老男孩‘, ‘alex‘, [1, 2, 3], ‘2‘, ‘1‘, ‘4‘, 1, 2]
print(li.pop(2)) # b
print(li) #[1, ‘sb‘, ‘a‘, 2, 3, ‘老男孩‘, ‘alex‘, [1, 2, 3], ‘2‘, ‘1‘, ‘4‘, 1, 2]
# 3、clear 清空列表内容
li.clear()
print(li) #[]
# 4、del 删除列表或者切片删除
li = [1,2,4,6]
# del li
print(li) # 列表不存在了
li = [1,‘a‘,‘b‘,‘a‘,2,3,‘老男孩‘]
# 切片删除，可以按步长删除
del li[3:]
print(li)   # [1, ‘a‘, ‘b‘]
li = [1,‘a‘,‘b‘,‘a‘,2,3,‘老男孩‘]
del li[:3:2]
print(li) # [‘a‘, ‘a‘, 2, 3, ‘老男孩‘]

　　　　4、改

# 1、按照索引改
li = [1,‘a‘,‘b‘,‘a‘,2,3,‘老男孩‘]
li[0] = ‘abc‘
print(li) # [‘abc‘, ‘a‘, ‘b‘, ‘a‘, 2, 3, ‘老男孩‘]
li[0] = [‘abc‘,123,‘eta‘]
print(li) # [[‘abc‘, 123, ‘eta‘], ‘a‘, ‘b‘, ‘a‘, 2, 3, ‘老男孩‘]
# 2、按照切片去改
li[:3] = ‘sb‘
print(li) # [‘s‘, ‘b‘, ‘a‘, 2, 3, ‘老男孩‘]
li[:2] = [‘sb‘]
print(li) # [‘sb‘, ‘a‘, 2, 3, ‘老男孩‘]

　　　　5、查

li = [‘sb‘, ‘a‘, 2, 3, ‘老男孩‘]
# 1、查看，切片步长查看
print(li[0]) # sb
print(li[:2]) # [‘sb‘, ‘a‘]
print(li[::2]) # [‘sb‘, 2, ‘老男孩‘]
# 2、for 循环
for i in li:
    print(i)
# sb
# a
# 2
# 3

　　　　6、其他操作

# 1、sort从小到大，正向排序
li = [23,21,43,1,54]
li.sort()
print(li) # [1, 21, 23, 43, 54]
# 2、从大到小，反向排序
li.sort(reverse =True)
print(li) # [54, 43, 23, 21, 1]
# 3、翻转
li.reverse() # [1, 21, 23, 43, 54]
# 4、长度 len
print(len(li)) # 5
print(li) #[1, 21, 23, 43, 54]
# 5、count
li = [‘t‘,2342,‘t‘,‘safs‘,‘sadfast‘,‘eawt‘]
print(li.count(‘t‘)) # 2
#index 通过元素找索引
print(li.index(‘t‘)) # 0    没有找到报错
# 6、join用字符串做一个连接符
#连接可迭代对象中的每一个元素，形成一个新的字符串
s = ‘xxoo‘.join(‘sb‘)
print(s) # sxxoob
l1 = [‘wusir‘,‘taibai‘]
print(‘ ‘.join(l1)) # wusir taibai
print(‘‘.join(l1)) # wusirtaibai

 

　　三、tuple

　　　　不可变数据类型（可哈希）

　　　　元组被称为只读列表，即数据可以被查询，但不能被修改，字符串的索引与切片操作同样适用于元组

　　　　注：对于元组：如果只有一个元素，并且没有逗号，此元素是什么数据类型，该表达式就是什么数据类型

tu = ([1,2,3])
tu1 = ([1,2,3],)
print(tu,type(tu))  # [1, 2, 3] <class ‘list‘>
print(tu1,type(tu1))    # ([1, 2, 3],) <class ‘tuple‘>

三、散列类型

　　一、dict

　　　　可变数据类型（不可哈希）

　　　　字典的键：不可变数据类型，字典的值：任意数据类型

　　　　注：在循环字典中，不能增加或者删除此字典的键值对。

# 将字典中含有k元素的键，对应的键值对删除。
dic = {‘k1‘:‘value1‘,‘k2‘:‘value2‘,‘name‘:‘wusir‘}
l1 = []
for i in dic:
    if ‘k‘ in i:
        l1.append(i)
for i in l1:
    del dic[i]
print(dic)

　　　　1、增

# 1、有则覆盖，无则添加
dic[‘hobby‘] = "girl"
print(dic) #{‘name‘: ‘jin‘, ‘age‘: 18, ‘sex‘: ‘male‘, ‘hobby‘: ‘girl‘}
dic["name"] = ‘alex‘
print(dic) #{‘name‘: ‘alex‘, ‘age‘: 18, ‘sex‘: ‘male‘, ‘hobby‘: ‘girl‘}
# 2、setfault添加一个键值对，有则不变，无则添加。
dic.setdefault(‘name‘,‘sb‘)
print(dic) #{‘sex‘: ‘male‘, ‘age‘: 18, ‘name‘: ‘alex‘, ‘hobby‘: ‘girl‘}
dic.setdefault(‘sb‘,‘sb‘)
print(dic) #{‘sb‘: ‘sb‘, ‘age‘: 18, ‘hobby‘: ‘girl‘, ‘name‘: ‘alex‘, ‘sex‘: ‘male‘}
# 3、fromkeys() 函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值 dict.fromkeys(seq[, value]))
dic = dict.fromkeys(‘abc‘,‘alex‘)
print(dic)  #{‘c‘: ‘alex‘, ‘a‘: ‘alex‘, ‘b‘: ‘alex‘}
dic = dict.fromkeys([1,2,3],[])
print(dic)  #{1: [], 2: [], 3: []}
dic[1].append(‘laonanhai‘)
print(dic)  #{1: [‘laonanhai‘], 2: [‘laonanhai‘], 3: [‘laonanhai‘]}

　　　　2、删

dic = {‘sb‘: ‘sb‘,
       ‘age‘: 18,
       ‘hobby‘:‘girl‘,
       ‘name‘: ‘alex‘,
       ‘sex‘: ‘male‘}
# 1、pop 有返回值的删除
print(dic.pop(‘sb‘)) # sb
print(dic) # {‘name‘: ‘alex‘, ‘age‘: 18, ‘sex‘: ‘male‘, ‘hobby‘: ‘girl‘}
print(dic.pop(‘hobby‘)) # girl
print(dic) # {‘sex‘: ‘male‘, ‘name‘: ‘alex‘, ‘age‘: 18}
print(dic.pop(‘a‘,‘没有值‘)) # 如果删除内容不存在后面可以加个返回值结果是没有值
print(dic) # {‘age‘: 18, ‘sex‘: ‘male‘, ‘name‘: ‘alex‘}
print(dic.pop(‘age‘,65))  # 有要删除内容，返回删除内容 18
print(dic) # {‘sex‘: ‘male‘, ‘name‘: ‘alex‘}
# 2、clear 清空
dic.clear()
print(dic) # {}
# 3、del 删除列表，按键值删除键值对
# del dic # 删除字典
# print(dic) # 报错，字典不存在了
dic = {"name":"jin",
       "age":18,
       "sex":"male",
       }
del dic[‘name‘]
print(dic) # {‘sex‘: ‘male‘, ‘age‘: 18}
print(dic.popitem()) # 随机删除，有返回值，返回的是删的内容 (‘sex‘, ‘male‘)
print(dic) # {‘age‘: 18}

　　　　3、改

# 1、直接修改
dic = {"name":"jin",
       "age":18,
       "sex":"male",
       }
dic[‘name‘] = ‘sb‘
print(dic) # {‘age‘: 18, ‘sex‘: ‘male‘, ‘name‘: ‘sb‘}
# 2、两个字典的改
dic = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic2.update(dic) # 对dic2进行升级，把dic内容覆盖到dic2中
print(dic2) # {‘weight‘: 75, ‘age‘: 18, ‘sex‘: ‘male‘, ‘name‘: ‘jin‘}
print(dic) # {‘sex‘: ‘male‘, ‘age‘: 18, ‘name‘: ‘jin‘}

　　　　4、查

# 1、直接查找，如果不存在会报错，推荐用get查找
dic = {‘sex‘: ‘male‘, ‘age‘: 18, ‘name‘: ‘jin‘}
print(dic["name"]) # jin
# print(dic[‘sb‘]) # 报错
print(dic.get(‘name‘)) # jin
print(dic.get(‘sb‘)) # None 默认返回None
print(dic.get(‘sb‘,‘123344sdafasd‘)) # 123344sdafasd 可以后面定义返回值

　　　　5、其他操作

# key() values() items()
dic = {‘sex‘: ‘male‘, ‘age‘: 18, ‘name‘: ‘jin‘}
print(dic.keys(),type(dic.keys())) #dict_keys([‘sex‘, ‘name‘, ‘age‘]) <class ‘dict_keys‘>
# 把键放在了一个类似列表的容器中，可循环，可转化为列表
for i in dic.keys():
    print(i)
    # name
    # sex
    # age
# 把键值放在了一个类似列表的容器中，可循环，可转化为列表
for i in dic.values():
    print(i)
    # 18
    # jin
    # male
# 把键值对放在了一个类似列表的容器中，可循环，可转化为列表
for i in dic.items():
    print(i)
    # (‘age‘, 18)
    # (‘name‘, ‘jin‘)
    # (‘sex‘, ‘male‘)
# 特殊类型 dict 转化成list
print(list(dic.keys())) #[‘sex‘, ‘age‘, ‘name‘]

　　二、set

　　　　不重复，无序，它里面的元素是可哈希的。他本身是不可哈希的，他不能作为字典的key。

　　　　作用：1，去重。

　　　　　　　2，数据关系的测试。

# 1、去重
li = [11,11,22,22,33,33,33,44]
li = list(set(li))
print(li)   #[33, 11, 44, 22]
set = {11,22,33,11,22,33,44}
print(set)  #{33, 11, 44, 22}

# 2、增
set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}
set1.add(‘sb‘)
print(set1) #{‘sb‘, ‘barry‘, ‘egon‘, ‘ritian‘, ‘wusir‘, ‘alex‘}
set1.update(‘abc‘)
set1.update([1,2,3])    #迭代的增加
print(set1) #{‘sb‘, 1, 2, 3, ‘barry‘, ‘egon‘, ‘ritian‘, ‘a‘, ‘b‘, ‘wusir‘, ‘alex‘, ‘c‘}

# 3、删
set1.remove(‘sb‘)
print(set1) #{‘c‘, 1, 2, ‘ritian‘, ‘wusir‘, 3, ‘barry‘, ‘b‘, ‘a‘, ‘alex‘, ‘egon‘}

set1.clear()
print(set1) #set()

del set1
# print(set1) #删除了

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
# 4、交集 & intersection
print(set1 & set2)  #{4, 5}
print(set1.intersection(set2))  #{4, 5}
# 5、反交集 ^ symmetric_difference
print(set1^set2)    #{1, 2, 3, 6, 7, 8}
print(set.symmetric_difference(set2)) #{1, 2, 3, 6, 7, 8}
# 6、差集 | union
print(set1 | set2)  #{1, 2, 3, 4, 5, 6, 7, 8}
print(set1.union(set2)) #{1, 2, 3, 4, 5, 6, 7, 8}

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set1.issubset(set2))  # True 子集
print(set2.issuperset(set1))  # True set2 是set1的超集

set1 = {‘barry‘,"wusir"}
set2 = frozenset(set1)  # 把集合变成可哈希的，有序集合
print(set2,type(set2))  # frozenset({‘barry‘, ‘wusir‘}) <class ‘frozenset‘>

 

　　python基础数据类型思维导图：https://www.processon.com/view/link/5ae735c0e4b039625af92020