首页  思维导图  详情

基础数据类型

2020-12-28 11:18:58   1  举报





AI智能生成

基础数据类型

作者其他创作

大纲/内容

list

why

"1 True alex" 像这样的字符串，我如果通过切片或者其他方法将1 True alex取出来，他也只能是字符串，但是我想要得数字的说，我只能存储少量的单一的（字符串类型）的数据，不方便，python给咱们也提供了一类数据类型，他能承载多种数据，这类数据类型被称作容器类型可以存储大量的数据。列表就属于容器类的数据类型。

what

<div>列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且里面可以存放各种数据类型比如： li=["alex",123,True,(1,2,3,"wusir"),[1,2,3,"小明",],{"name":"alex}] 列表相比于字符串，不仅可以存储不同的数据类型，而且可以存储大量数据，32位python的限制是536870912个元素，64位python的限制是1152921504606846975个元素。而且列表是有序的，有索引值的，可切片，方便取值。 </div>

how

1、可用于索引切片

l=["太白"，[1,2,3],"wusir","女神"] print(l[1]) #[1,2,3] print(1[-1] #"女神" print(l[1:3]  #[[1,2,3],"wusir:] print(l[::2])  #["太白","wusir"] print([-1:-4：-1）   #["女神","wusir",[1,2,3]]

2、列表的操作方法

增

append

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

l=[1,2,"a"] l.append(666) print(l)  #[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

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

1= [太白'，'alex, 'WuSir',女神'] ret = l.pop(1) print(ret,I) # alex [太白"，"WuSir,女神']

remove

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

I= [太白'，'alex', 'WuSir',女神] L.remove("alex) print() # [太白'，'WuSir',女神']

clear

清空列表

1= [太白; alex, Wusir,女神] l.clear0 ! print() # []

del

按照索引|删除该元素

I= [太白'，'alex', 'WuSir', '女神] del I[2] print() # [太白'，'alex,女神']

切片删除该元素

I= [太白'，'alex', 'WuSir', '女神] del [1:] print() # [太白"]

切片(步长删除该元素

I = [太白，'alex', 'WuSir',女神] del I[:2] print() # ['alex', 女神]

改

按照索引改值

|= [太白'，'alex', 'WuSir', '女神] [0]='男神' print() # [男神'，'alex, 'WuSir',女神]

按照切片改值(迭代着增加)

|= [太白'，'alex', 'WuSir', '女神] I[1:3] = 'abcdefg' print() # [太白'，'a', 'b', 'C', 'd','e', 'f,'g', '女神]

按照切片(步长)改值(必须--对应)

|= [太白，'alex', 'WuSir', '女神] I[:2] = '对应' print() # [对"，'alex', "应，女神']

查

按照索引查值

按照切片步长)查值

for循环查值

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

其他操作方法

index

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

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

count

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

1=['太白'，'太白，'WuSir',吴超] print(l.count(太白"))#2

sort

默认从小到大排列

I= [7,4,8,9,1,2,3,5, 6] L.sort(） print(l)#[1, 2,3, 4,5,6, 7,8, 9]

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

I= [7,4,8,9,1,2,3,5, 6] l.sort(reverse= True) print()# [9,8, 7,6,5,4,3,2, 1]

reverse

反转列表

|= [太白'，'alex', 'WuSir',‘吴超] I.reverse(） print(l) # [吴超"，'WuSir', 'alex', '太白]

copy

浅copy

where

当你程序中需要设置大量有序的数据时，需要考虑列表

tupel

why

对于容器型数据类型list,无论谁都可以对其增删改查,那么有一些重要的数据放在list中是不安全的，所以需要一种容器类的数据类型存放重要的 数据，创建之初只能查看而不能增删改，这种数据类型就是元祖。

what

元组也是Python的基础数据类型之一，是以() 括起来，里面的元素可以放所有数据类型，例如: tu=( 'alex' ,123,Ture,(1,2,3,' wusir' ),[1,23,' 小明’]{ 'name' : alex' })元素以逗号隔开，元组也称作只读列表，元组里面的元组不能 更改，只能查看，读取(当然是儿子不能改，孙子可以改)。

how

1.可以索引切片(步长)

2.元组的操作方法

改

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

查

1.可以索引切片(步长)

2.可以for循环查询

其他操作方法

index

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

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

count

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

tu= (太白，太白，'WuSir',‘吴超) print(tu.count('太白")) # 2

where

当程序中需要设置些重要的数据，这些数据不想让其他人更改，只能查看时，可以将数据存放在元组中

dict

why

what

1.列表可以存储大量的数据类型，但是如果数据量大的话，他的直询速度比较量。 2,列表只能按照顺序存储，数据与数据之间关联性不强 解决上面的问题，这就需要dict字典。 所以咱们需要引入一种容器型的数据类型，

先给大家说一下可变与不可变的数据类型的分类: 不可变(可哈希)的数据类型: int, str, bool, tuple。 可变(不可哈希)的数据类型: list, dict, set. 字典是Python语言中唯一的映射类型。他是以0括起来，里面的内容是以键值对的形式储存的: Key:不可变(可哈希)的数据类型. Value:任意数据，包括对象等... 如: dic = {'name':'alex'; 'age':56, 'py8期:[晓梅，方胜君"]， 真':True, (1,2,3):元祖} 字典一般储存的是大量的关联性比较强的数据，3.5包括3.5版本之前，字典是无序的，3.6之后，创建字典时按照初始顺序排列 字典的查询速度非常快。

how

增

通过键值对直接增加

setdefault

dic = {name':‘太白"，'age': 18} print(diod # (name:"太白",。没有height此键，则添加 'age': 18, height:175} pisedelee nebaryge有此键则不变 printdic # {'name:太白: age; 18, hegt: 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之后为删除最后一个，有返回值

clear

del

改

通过键值对直接改

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

update

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

dic = {name':“太白，'age': 18} dic.update(sex='男; height=175) print(did # (name': '太白，'age: 18, 'sex: 男; heigt: 175)

dic= {'name':‘太白，'age': 18} dic.update((1, 'a),(2, "b),(3,‘),(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](没有此键会报错)

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.keys0) # dict keys(['name', 'age'])

values

dic二(name':“太白，'age': 18) piticialuel # dict vlues(太白，18)

items

dic= (name: '太白; 'age':18) pntte tenio # did ti(Cae EI)(age,18)

利用for循环

dic = {'name': '太白，'age': 18} for key in dic: print(key) for k,v in dic.items0: 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

where

当你的程序需要设置大量的关系型数据，并且要求查询速度时，你需要考虑字典

int

why

主要是用数字的运算，计算

what

就是咱们认识的数字1，2，3，4，5.....

how

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

where

需要用到计算，计数等时

bool

why

程序中有时需要判断等式或者不等式的对错，作为if 或者while等判断条件真假。

what

boo值: True False.

how

1>2and3<4等逻相判断，或者些空数据(转化ool值为Fale)等。

where

般会用于一些语句的条件判断。

str

why

程序-般都是和数据打交道，大量的数据存储在数据库，缓存，文件等，但是程序需要将这些数据提取出来，处理，加工，这些提取出来的数据， 在程序中往往是以字符串的形式存在，字符串-般存储一些相对少量的数据。

what

how

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

1,可以用于索引，切片。

s1 =太白金星666' #索引从左至右，从零开始 #按照索3 |取值 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)

2,字符串的操作方法(带颜色的标为重要方法)

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. expandtabs0) # ta

isdecimal

检测该字符串只包含+进制的字符(这些都不可以: 3.14,三，参，)。

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

isnumeric

检测该字符串只包含十进制的字符(小数不可以: 3.14, 这些都可以:三参)。

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

isidentifier

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

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

islower

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

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

isprintable

判斯放字符申中的所有字符是否是可印的好符(含有换行符，制表符等这些字符都会返回Fake含有空格近回True,)

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

partition

对字符串按照指定字符进行分割，返回一个元组(分隔符前面的元素,“分隔符;分隔符后面的元素)。

s1 =‘日天太白,吴超’ print(s1.partition(,)) # (日天;，”'太白，吴超")

isspace

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

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

istitle

判断组成该字符串的标题内容是否是首字母大写(如果满足规定的标题(非字符隔开的每个单词理解为标题)全部都是首字母大写，则返回Tru e)。

s1 = 'Alex' s2 = 'Alex Wusir*Barry2Ritian' print(s1.istitle0) # True print(s2.istitle0) # True

isupper

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

ljust

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

s1 = 'barry' print(s1.ljust(20,'*")) # barry*************

rjust

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

maketrans

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

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)) # htp://ww3n2logs.3om/jin xin/titles/759977.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=‘太白金星' prits((20)) # 0000000 000太白金星

capitalize

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

s1 = 'taiBai' print(s1.capitalize0) # Taibai

swapcase

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

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

center

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

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

startswith

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

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

endswith

判断该字符串以某个字符或者某些字符为结尾，并相可以切片，返回的是boo值

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

isalpha

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

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

isalnum

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

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

isdifit

检测波字符电或yes类型是否只包含t进制的字符这些都不可以: 3.14.三叁，但是可以检测bytes类型)。

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

upper

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

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

lower

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

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

find

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

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

rfind

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

index

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

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

rindex

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

count

计算某个元素出现的次数。

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

strip

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

usernamne = inut(请输入姓名: )strpo if username == 'taibai': print(登录成功")

lstrip

创建一个新的字符串:默认去除原字符串左(前)端的换行符，制表符，空格。

rstrip

创建- -个新的字符串:默认去原除字符串右(前)端的换行符，制表符，空格

split

str ---> list

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

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

rsplit

从右往左分割

splitlines

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

s1 = 'a\tb\nc\nd\ne' print(s1.splitlines0) # ['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' 1 = ['alex', 'wusir', '太白"] s12 = _'join(1) print(s12) # 'alex wusir太白'

replace

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

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

format

格式化输出

res='{} } 0' .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类型。

where

需要存储少量的数据，读取文件数据，数据库数据时，等

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