首页  思维导图  详情

python的基本数据类型以及应用

2020-09-17 14:10:24   0  举报





AI智能生成

python的基本数据类型以及应用

。。

作者其他创作

大纲/内容

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) #按照切片取值[起始索引]:[结尾索引]:[步长] 顾头不顾腚 s6 = s1[0:4] s6 = s1[:5] #从开头取值可以不写0 s7 = s1[5:] #取到最后什么都不写 s8 = s1[:5:2] # 反向取值[起始索引]:[结尾索引]:[负数步长] 顾头不顾腚 s9 = s1[-1:-4:-1] print(s9)

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

title 

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

casefold

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

format_map

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

expandtabs

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

isdecimal

检测该字符串只包含十进制的字符（3.14、三、叁、Ⅲ这一类的不可以）

isnumeric

检测该字符串只包含十进制的字符（小数不可以3.14。三、叁、Ⅲ这些可以）

isidentifier

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

islower

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

isprintable

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

partition

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

isspace

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

istitle

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

isupper

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

ljust

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

rjust

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

maketrans

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

translate

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

rpartition

对字符串按照指定字符(从右边开始数的第一个字符)进行分割，返回一个元组(”分隔符前面的元素;分隔符:分隔符后面的元素)。

zfill

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

capitalize

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

swapcase

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

center

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

startswith

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

endswith

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

isalpha

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

isalnum

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

isdigit

检测该字符串或bytes类型是否只包含十进制的字符(这些都不可以: 3.14,三，叁 ,，但是可以检测bytes类型)。

upper

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

lower

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

find

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

rfind

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

index

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

rindex

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

count

计算某个元素出现的次数

strip

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

lstrip

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

rstrip

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

split

str --> list

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

rsplit   从右往左分割

splitlines

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

join

lst-- str(这个方法非常好，不只是将list转化成str这一个功能)

replace

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

format

格式化输出田

encode

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

why

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

what

这个就是咱们的str: name= 'alex' 或者"alex"

where

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

bool

why

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

what

bool值:True False

how

1 > 2and3< 4等逻辑判断，或者一些空数据(转化成bool值为False)等。

where

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

int

why

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

what

就是数字1，2，3。。。

how

+ - * / % // 。。。

where

需要用到计算，计数等时

list

why

'1 True alex' 像这样的字符串，我如果通过切片或者其他方法将1 True alex取出来，他也只能是字符串，但是我想要得到数字的1，布尔值的True,必须还要转化，是不是很麻烦，对于字符串来说，我只能存储少量的单- -的(字符串类型)的数据，不方便，python给咱们也提供了一类数据类型，他能承载多种数据类型，这类数据类型被称作容器类数据类型可以存储大量的数据。列表就属于容器类的数据类型。

what

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

how

可用于索引切片

1= [太白'，[1,2, 3, ], "WuSir',‘女神] print([1])# [1, 2, 3] print([-1]) #‘女神' print([1:3]) # [1, 2, 3], 'WuSir] print([:2]) # [太白'，'WuSir] print([-1:-4:-1]) # [女神，"WuSir', [1, 2, 3]]

列表的操作方法

增

append

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

insert

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

extend

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

删

pop

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

remove

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

clear

清空列表

del

按照索引删除该元素

切片删除该元素

切片（步长）删除该元素

改

按照索引改值

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

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

查

按照索引查值

按照切片（步长）查值

for循环查值

其它操作方法

index

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

count

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

sort

默认从小到大排列

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

reverse

反转列表

copy

浅copy

where

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

tuple

why

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

what

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

how

可以索引切片（步长）

元组的操作方法

改

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

查

可以索引切片（步长）

可以for循环查询

其他操作方法

index

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

count

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

where

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

dict

why

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

what

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

how

增

通过键值对直接增加

dic= {name':‘太白，"age':18) dic'weight] = 75 #没有weight这个 键，就增加键值对 pintldic)# (name:太白"，'age:18,W eight: 75} dic'name]= bary #有name这个键， 就成了字典的改值 print(dio) # (name': barry', 'age':18, 'w eight': 75}

setdefault

dic = {'name': '太白'，'age': 18} dic.setdefault(height,175) #没有heigh t此键，则添加 print(dic) # {'name':‘太白，'age': 18, 'he ight': 175} dic.setdefault('name','barry') #有此键则 不变 print(dic) # {'name': '太白，'age': 18, 'he ight': 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':‘太白'，'a ge': 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.clear0 print(dic)# 0}

del

通过删除键值对

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

删除整个字典

del dic

改

通过键值对直接改

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

update

源码: ， D.update([E, ]**F) -> None. Upd ate D from dict/iterable E and F. If E is present and has a .keys0 metho d, then does: for kin E: D[k]= E[k] 9f E is present and lacks a .keys0 metho d, then does: fork, vin E: D[k] = v In either case, this is followed by: for k inF: D[k] = F[k]

dic = {'name': '太白，'age': 18} dic.update(sex=男，height=175) print(dic) # {'name': '太白，'age': 18, 'se x':男: "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":" ma le"} dic2 = {"name": alex","weight":75} dic1.update(dic2) print(dic1) # {'name': 'alex', 'age': 18, 's ex': 'male', 'weight': 75} print(dic2) # {'name': 'alex', "weight': 7 5}

查

通过键查询

直接dic[key](没有此键会报错)

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

get

dic= (name':“太白"，'age':18} V= dic.get('name) print(v)#‘太白 V = dic.get(Cname1) print(Vy) # None V= decgetCname2,没有此键) print(v)#没有此键

keys()

dic = {'name': '太白，'age': 18) : print(dic.keys0) # dict_ keys(['name', 'a ge'])

values()

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

items()

dic = {'name': '太白'，'age': 18) : print(dic.items0) # dict_ items([('name', ‘太白"，(age', 18)])

利用for循环

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

常用操作方法

fromkeys

dic= diokelobodt馆 ‘太白"，心:太 pintica#a:太t白",b' 白,"d:“太白") dic = ditromkeky(1, 1, 2, 3)];太白")

copy

浅copy

where

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

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

为什么要 有基础数 据类型?