首页  思维导图  详情

python基础数据类型汇总

2020-09-21 10:45:29   0  举报





AI智能生成

python基础数据类型操作方法：列表、元组、字典、字符串、bool

列表，list，练习，设计

操作方法

数据分析

软件开发

作者其他创作

大纲/内容

list（列表）

how

1.可用于索引切片

I = ['太白',[1,2,3,],'WuSir','女神'] print(I[1])  //[1,2,3] print([-1])  //'女神' print([1:3])  //[[1,2,3],'WuSir'] print([::2])  //['太白','WuSir'] print([-1:-4:-1])  //['女神','WuSir',[1,2,3]]

2. 列表的操作方法

增加

append

追加，给列表的最后面追加一个元素

I = [1,2,'a'] I.append(666) print(I)  //[1,2,'a',666]

insert

插入在列表的任意位置插入元素

l = [1,2,'a'] l.insert(1,'太白'] print(l)  //[1,'太白',2,'a]

extend

迭代着追加，在列表的最后面迭代着追加一组数据

l = [1,2,'a'] l.extend('太白a') print(l)

删除

pop

通过索引删除列表中对应的元素，该方法有返回值，返回值为删除的元素

l = ['太白','alex','WuSir','女神'] ret = l.pop(1) print(ret,l)  //alex['太白','WuSir','女神']

remove

通过元素删除列表中该元素

l = ['太白','alex','WuSir','女神'] l.remove('alex') print(l)  //['太白','WuSir','女神']

clear

清空列表

l = ['太白','alex','WuSir','女神'] l.clear() print()  //[]

del

按照索引删除该元素

l = ['太白','alex','WuSir','女神'] del l[2] print(l)  //['太白','alex','WuSir','女神']

切片删除该元素

l = ['太白','alex','WuSir','女神'] del l[1] print(l)  //['太白']

切片（步长）删除该元素

l = ['太白','alex','WuSir','女神'] del l[1:] print(l)  //['alex','女神']

修改

按照索引改值

l = ['太白','alex','WuSir','女神'] l[0] = '男神' print(l)   //['男神','alex','WuSir','女神']

按照切片改值（迭代着增加）

l = ['太白','alex','WuSir','女神'] l[1:3] = 'abcdefg' print(l)  //['太白','a','b','c','d','e','f','g','女神']

按照切片（步长）改值（必须一一对应）

l = ['太白','alex','WuSir','女神'] l[::2] = '对应' print(l)  //['对','alex','应','女神']

查看

按照索引查值

按照切片（步长）查值

for循环查值

l = ['太白','[1,2,3],'WuSir','女神'] for i in l: print(i)

其他操作方法

index

通过元素找索引（可切片），找到第一个元素就返回，找不到该元素就报错

l = ['太白','[1,2,3],'WuSir','女神'] print(l.index('太白'))  //()

count

获取某元素在列表中出现的次数

l = ['太白','太白','WuSir','吴超'] print(l.count('太白'))  //2

sort

默认从小到大排列

l  = [7,4,8,9,1,2,3,5,6] l.sort() print(l)  //[1,2,3,4,5,6,7,8,9]

通过设置参数从大到小排列

l = []

默认从小到大排列

l  = [7,4,8,9,1,2,3,5,6] l.sort() print(l)  //[1,2,3,4,5,6,7,8,9]

reverse

反转列表

l = ['太白','alex','WuSir','吴超'] l.reverse() print(l)  //['吴超','WuSir','alex','太白']

copy

浅copy

只复制框架，框架内容沿用被copy列表

深copy

复制框架与其内部可变内容，不可变元素则沿用元框架中的地址

tuple（元组）

how

可索引切片（步长）

元组的操作方法

改

tu = (1,'太白','['alex',]) //  元组为只读列表，不能增删改其值，只能查，但只对于改来说是相对的。 //  直接属于原组的元素不能改，但是间接属于元祖的原素不一定，比如上面的alex。 //  举个不恰当的例子：儿子不能改，孙子可以改。 tu[-1][0] = '日天' print(tu)

查

可以索引切片（步长）

可以for循环查询

其他操作方法

index

通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错

tu = ('太白','[1,2,3,],'WuSir','女神') print(tu.index('太白'))  //  0

count

获取某元素在列表中出现的次数

tu = ('太白','太白','WuSir','吴超') print(tu.count('太白'))  //  2

dict(字典)

增

通过键值对 直接增加

dic = {'name':'太白','age':18} dic['weight'] = 75  //  没有weight这个键，就增加键值对 print(dic)  //  {'name':'太白','age',':18,'weight':75} dic['name'] = 'barry'  //  有name这个键，就成了字典的改值 print(dic)  //  {'name':'barry','age':18,'weight':75}

setdefault

dic = {'name':'太白','age':18} dic.setdefault('height',175)  //  没有weight这个键，则添加 print(dic)  //  {'name':'太白','age':18,'height':175} dic.setdefault('name','barry')  //  有此键则不变 print(dic)  //  {'name':'太白','age':18,'height':175}

删

pop

通过key删除字典的键值对，有返回值，可设置返回值。

dic =  {'name':'太白','age':18} ret = dic.pop('name') print(ret,dic)  //  太白{'age':18} ret1 = dic.pop('n',None) print(ret1,dic)  //  None{'name':'太白','age':18}

popitem

3.5版本之前，popitem为随机删除，3.6之后为删除最后一个，有返回值

dic = {'name':'太白','age':18} ret = dic.popitem() print(ret,dic)  //  ('age',18){'name':'太白'}

clear

清空字典

dic = {'name':'太白','age':18} dic.clear() print(dic)   //  {}

del

通过键删除键值对

dic = {'name':'太白','age':18} dic.clear() print(dic)  //  {'age':18}

del  dic                      删除整个字典

改

通过键值对直接改

dic = {'name':'太白','age':18} del dic['name'] print(dic)  //  {'age':18}

update

源码： D.update([E, ]**F) -> None. Update D from dict/iterable E and F. If E is present and has a .keys() method, then does: for k in E: D[k] = E[k] If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k]

dic = {'name':'太白','age':18} dic.update(sex='男',height=175) print(dic)  //  {'name':'太白','age':18,'sex':'男','height':175}

dic = {'name':'太白','age':18} dic.update([(1,'a'),(2,'b'),(3,'c'),(4,'d')]) print(dic)  //  {'name':'太白','age':18,1:'a',2:'b',3:'c',4:'d'}

dic1 = {"name":"jin","age":18,"sex":"male"} dic2 = {"name":"alex","weight":75} dic1.update(dic2) print(dic1) # {'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75} print(dic2) # {'name': 'alex', 'weight': 75}

查 

通过键查询

直接dic[key]（没有此键会报错）

dic = {'name': '太白', 'age': 18} print(dic['name']) # 太白

get

dic = {'name': '太白', 'age': 18} v = dic.get('name') print(v) # '太白' v = dic.get('name1') print(v) # None v = dic.get('name2','没有此键') print(v) # 没有此键

keys()

dic = {'name': '太白', 'age': 18} print(dic.keys()) # dict_keys(['name', 'age'])

values()

dic = {'name': '太白', 'age': 18} print(dic.values()) # dict_values(['太白', 18])

items()

dic = {'name': '太白', 'age': 18} print(dic.items()) # dict_items([('name', '太白'), ('age', 18)])

利用for循环

dic = {'name': '太白', 'age': 18} for key in dic: print(key) for k,v in dic.items(): print(k,v)

常用操作方法

fromkeys

dic = dict.fromkeys('abcd','太白') print(dic) # {'a': '太白', 'b': '太白', 'c': '太白', 'd': '太白'} dic = dict.fromkeys([1, 2, 3],'太白') print(dic) # {1: '太白', 2: '太白', 3: '太白'}

copy

浅copy

int（整型）

how

+ - * / % ** // ....

bool（布尔值）

1 > 2 and 3 < 4 等逻辑判断，或者一些空数据（转化成bool值为False）等。

str（字符串）

how

对字符串进行操作会形成一个新的字符串，不会该变原字符串！！！

可用于索引，切片

s1 = '太白金星666' #索引从左至右，从零开始 #按照索引取值 s2 = s1[0] print(s2,type(s2)) s3 = s1[4] print(s3) s4 = s1[-1] print(s4) s5 = s1[-2] print(s5) #按照切片取值[起始索引:结尾索引+1:步长] 顾头不顾腚 s6 = s1[0:4] s6 = s1[:5] # 从开头取值可以不写0 s7 = s1[5:] # 取到最后什么都不写 s8 = s1[:5:2] # 反向取值 [起始索引:结尾索引-1:-步长] 顾头不顾腚 s9 = s1[-1:-4:-1] print(s9)

字符串的操作方法（带颜色的标为重要方法）

title

创建一个新的字符串：字符串非字母元素隔开的每个单词的首字母大写

s = 'alex wusir8taibai*ritian' s4 = s.title() print(s4) # Alex Wusir8Taibai*Ritian

casefold

返回一个新的字符串全部为小写

与lower相似，但是lower只能转换ASCCI码中的字母，而此方法可以转换非中文的其他语言，比如德语，葡萄牙语等。

format_map

格式化输出，可以通过字典的形式。

s = '我的名字：{name}，年龄：{age}' ret = s.format_map({'name':'太白','age':18}) print(ret)

expandtabs

将字符串中的制表符：\t默认转化成8个空格

s = 'ta\ti' print(s.expandtabs()) # ta i

isdecimal

检测该字符串只包含十进制的字符（这些都不可以：3.14，三，叁，III）

# s1 = '0310' # print(s1.isdecimal()) # True # s1 = '3.14' # print(s1.isdecimal()) # False 小数不可以 s1 = '三叁Ⅲ' print(s1.isdecimal()) # False 汉字数字，罗马数字不可以 # s1 = b'0310' # print(s1.isdecimal()) # 报错，bytes类型没有该方法。

isnumeric

检测该字符串只包含十进制的字符（小数不可以：3.14，这些都可以：叁，三，III）

s = '0310' print(s.isnumeric()) # True s = '3.14' print(s.isnumeric()) # False 小数不可以 s1 = '三' s2 = '叁' s3 = 'Ⅲ' print(s1.isnumeric()) # True 汉字数字可以 print(s2.isnumeric()) # True 汉字数字可以 print(s3.isnumeric()) # True 罗马数字可以 s1 = b'0310' print(s1.isnumeric()) # 报错，bytes类型没有该方法。

isidentifier

判断该字符串是否是python中的关键字

s1 = 'def' s2 = 'break' s3 = 'if' print(s1.isidentifier()) # True print(s2.isidentifier()) # True print(s3.isidentifier()) # True

islower

判断该字符串是否全部由小写字母组成

s1 = 'alex' print(s1.islower()) # True

isprintable

判断该字符串中所有字符是否是可打印的字符（含有换行符，制表符等这些字符都会返回False，含有空格返回True）

s1 = '!' s2 = '#' s3 = '太白\t' s4 = '\n太白' s5 = 'barry太' s6 = ' ' print(s1.isprintable()) # True print(s2.isprintable()) # True print(s3.isprintable()) # False print(s4.isprintable()) # False print(s5.isprintable()) # True print(s6.isprintable()) # True

partition

对字符串按照指定字符进行分割，返回一个元组（‘分隔符前面的元素’，‘分隔符’，‘分隔符后面的元素’）

s1 = '日天,太白,吴超' print(s1.partition(',')) # ('日天', ',', '太白,吴超') s1 = '日天,太白,吴超' print(s1.partition(',')) # ('日天', ',', '太白,吴超')

isspace

判断该字符串全部由空格或者制表符或者换行符组成，至少含有一个字符

s1 = ' ' s2 = '\t' s3 = '\n' print(s1.isspace()) print(s2.isspace()) print(s3.isspace())

istitle

判断组成该字符串的标题内容是否是首字母大写（如果满足规定的标题（非字符隔开的每一个单词理解为标题）全部都是首字母大写）

isupper

判断该字符串全部都是大写字母组成，则返回True

ljust

返回一个左对齐并且设置总宽度的字符串填充物默认为空

rjust

返回一个右对齐并且设置总宽度的字符串填充物默认为空

makereans

就是制定一个字符串映射的转换表，需要两个字符串参数，这两个字符串长度必须相同，一一对应

intab = 'abcd' outtab = '1234' str_trantab = str.maketrans(intab,outtab) # str_trantab 就是一个字符串映射的转换表，制定了一个转换规则，需要两个字符串参数， # 这两个字符串长度必须相同，一一对应。 test_str = 'http://www.cnblogs.com/jin-xin/articles/7459977.html' print(test_str.translate(str_trantab)) # http://www.3n2logs.3om/jin-xin/1rti3les/7459977.html

translate

按照maketrans定制的转换表进行相应的转换

intab = 'abc' outtab = '123' deltab = 'xo' # 可设置删除元素也可不设置 str_trantab = str.maketrans(intab,outtab,deltab) test_str = 'http://www.xxooabc.com' print(test_str.translate(str_trantab)) # http://www.123.3m

rpartition

对字符串按照指定字符（从右边开始数的第一个字符）进行分割，返回第一个元组（‘分割前面的元素’，‘分隔符’，‘分割后面的元素’）

zfill

返回指定长度的字符串，原字符串右对齐，前面填充0

s = '太白金星' print(s.zfill(20)) # 0000000000000000太白金星

capitalize

创建一个首字母大写，其余字母小写的新字符串

s1 = 'taiBai'  print(s1.swapcase()) # TAIbAI center

swapcase

创建一个大小写反转的新字符串

s1 = 'taiBai' print(s1.swapcase()) # TAIbAI

center

创建一个新字符串：字符串居中，可设置字符串的长度，并且可以设置填充物

s = '太白金星' print(s.center(20,'*')) # ********太白金星********

startswith

判断该字符串以某个字符串或者某些字符为开头，并且可以切片，返回的就是bool值

s = 'taibai' print(s.startswith('t')) # True print(s.startswith('ta')) # True print(s.startswith('i',2,)) # True

endswith

判断该字符串以某个字符或者某些字符为结尾，并且可以切片，返回时bool值

s = 'taibai' print(s.endswith('i')) # True print(s.endswith('bai')) # True

isalpha

检测字符串是否全部由字母组成

s1 = 'tai白' print(s1.isalpha()) # True 中文也识别。

isalnum

检测该字符串是否由数字或者字母组成。返回bool值

s1 = '1五Ⅰalex中' print(s1.isalnum()) # True 这三种数字，以及中英文都识别为数字或者字母

isdigit

检测该字符串或bytes类型是否只包含十进制的字符（这些都不可以：3.14，三，叁，III，但是可以检测bytes类型）

s = '0310' print(s.isdigit()) # True s = '3.14' print(s.isdigit()) # False 小数不可以 s1 = '三' s2 = '叁' s3 = 'Ⅲ' print(s1.isdigit()) # False 汉字数字不可以 print(s2.isdigit()) # False 汉字数字不可以 print(s3.isdigit()) # False 罗马数字不可以 s1 = b'0310' print(s1.isdigit()) # 不报错，bytes类型有该方法。

upper

创建一个全部大写的新的字符串

s = 'taiBai' print(s.upper()) # TAIBAI

lower

创建一个全部变小写的新的字符串

s = 'TaiBai' print(s.lower()) # taibai

find

从左边开始通过元素找索引（可切片），找到第一个元素就返回，找不到该元素返回-1

# ret6 = a4.find("fjdk",1,6) # print(ret6) # 返回的找到的元素的索引，如果找不到返回-1

rfind

从右边开始通过元素找索引（可切片），找到第一个元素就返回，找不到该元素返回-1

index

通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错

# ret61 = a4.index("fjdk",4,6) # print(ret61) # 返回的找到的元素的索引，找不到报错。

rindex

从右边开始通过元素找索引（可切片），找到第一个元素就返回，找不到该元素报错

count

计算某个元素出现的次数

s = 'taibai'  print(s.count('t')) # 1

strip

创建一个新的字符串：默认去除原字符串前后两端的换行符，制表符，空格

username = input('请输入姓名：').strip() if username == 'taibai': print('登录成功')

lstrip

创建一个新的字符串： 默认去除原字符串左（前）端的换行符，制表符，空格

rstrip

创建一个新的字符串：默认去除原字符串右（前）端的换行符，制表符，空格

split

str --->list

返回一个列表：默认以空格分割，可指定分隔符，可设置分割次数

ss = 'alex;wusir;taibai' print(ss.split(';')) # ['alex', 'wusir', 'taibai']

rsplit

从右往左分割

splitlines

对字符串按照换行符分割，返回一个列表（默认去除分隔符，如果想保存分隔符则设置keepend = True）

s1 = 'a\tb\nc\nd\ne' print(s1.splitlines()) # ['a\tb', 'c', 'd', 'e'] print(s1.splitlines(keepends=True)) # ['a\tb\n', 'c\n', 'd\n', 'e']

join

list--->str（这个方法非常好，，不只是将list转化成str这个功能）

返回一个字符串：对iterable进行遍历，通过你设置的连接符将iterable的每个元素通过你的连接符连接起来形成一个新的字符串

s = 'alex' s1 = '*'.join(s) print(s1) # 'a*l*e*x' l1 = ['alex', 'wusir', '太白'] s12 = '_'.join(l1) print(s12) # 'alex_wusir_太白'

replace

创建一个新的字符串，将原字符串中就内容替换成新内容，默认全部替换

name='alex say :i have one tesla,my name is alex'  print(name.replace('alex','SB',1))

format

格式化输出

res='{} {} {}'.format('egon',18,'male') res='{1} {0} {1}'.format('太白',18,'male') res='{name} {age} {sex}'.format(sex='male',name='太白',age=18)

encode

将字符串转化成bytes类型，默认转化成utf-8的bytes类型

我们人类可以很容易的分清数字与字符的区别，但是计算机并不能呀，计算机虽然很强大，但从某种角度上看又很傻，除非你明确的告诉它，1是数字，“汉”是文字，否则它是分不清1和‘汉’的区别的，因此，在每个编程语言里都会有一个叫数据类型的东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给他。Python中常用的数据类型有多种，int bool str list tuple dict set 等