首页  思维导图  详情



 



基础数据类型汇总

2022-04-01 11:50:43   0  举报





仅支持查看

基础数据类型汇总

模板推荐

作者其他创作

大纲/内容

list

why

'1 True alex' 像这样的字符串，我如果通过切片或者其他方法将1 True alex取出来，他也只能是字符串，但是我想要得到数字的1，布尔值 的True,必须还要转化，是不是很麻烦，对于字符串来说，我只能存储少量的单一的(字符串类型)的数据，不方便，python给咱们也提供了一 '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' }] 列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是536870912个元素64位python的限制是11 52921504606846975个元素。而且列表是有序的，有索引值，可切片，方便取值。

how

1.可用于索引切片

1= ['太白，[1,2,3,], "Wusir,女神] prit(I[1])# [1,2, 3] print([-1]) #女神’ print([1:3]) # [1,1 2, 3], 'WuSir] prit:(::2) # [太白，"Wusir] prit(-1:-4:- 1)# [女神，"Wusir,[1, 2, 31]1

2.列表的操作方法

增

append

给列表最后一个位置追加元素

|= [1,2, 'a'] l.append(666) print()# [1, 2, 'a', 666]

insert

插入在列表指定位置插入相应的元素

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

extend

迭代追加，在列表最后迭代追加数据

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

删

pop

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

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

remove

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

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

clear

清空列表

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

del

索引删除元素

Jai[1白，alxe, "Wusir, 女神1 del 1[2]x print) #[太白; alx,女神]

切片删除元素

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

切片加步长删除元素

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

改

按照索引改值

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

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

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

按照切片加步长改值，必须一一对应

I=「!太白alere Wusir,女神] l:2] =‘对应 pinto #[对，alxe,应，女神]

查

按照索引查找

按照切片查找

for遍历

1= [太白'，[1,2, 3, ], 'WuSir',女神] fori in |: print(i)

where

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

tuple

why

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

what

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

how

可以索引切片（加步长）

元组的操作方法

“改”

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

查

可以索引切片（加步长）查找

循环遍历

其他操作方法

index

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

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

count

获取元素在元组里出现的数量

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

where

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

dict

why

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

what

先给大家说- -下可变与不可变的数据类型的分类: 不可变(可哈希)的数据类型: int, str, bool, tuple。 可变(不可哈希)的数据类型: list, dict, set。 字典是Python语言中唯一的映射类型。他是以{}括起来，里面的内容是以键值对的形式储存的: 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这个键，就增加键值对 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) #没有height此键，则添加 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}

clear

清空字典

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

del

通过键删除键值对

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

删除整个字典

del dic

改

通过键值对直接改

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

update

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[keys](没有会报错)

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)])

循环遍历

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

where

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

int

why

主要是数字的计算、运算。

what

就是咱们平时用的1,2,3，4,5,6...

how

+ - * / ** // ...

where

需要用到的计算，计时等等

bool

why

程序中有时会判断条件的成立与不成立，作为if或while的条件

what

bool值包括True False

how

1 > 2 and 3 < 4 等逻辑判断，或者一些空数据转化为True 或 False等

where

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

str

why

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

what

str : name = ‘chuxin’

how

对字符串进行操作不会改变原字符串！

1.可以用于索引、切片

2.字符串的操作方法

strip

创建一个新的字符串：默认去除字符串两边的空格、换行符、制表符。

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

lstrip

创建一个新的字符串，默认去除字符串左边的空格、换行符、制表符

rstrip

创建一个新的字符串，默认去除字符串右边的空格、换行符、制表符

split

str ----> list

返回一个列表，默认以空格分割，可设置分割次数

str1 = '123|456|789' print(str1.split('|')) # ['123','456','789']

rsplit

从右往左分割

join

list ----> str(这个方法非常好,不只是将列表转化为字符串一个功能)

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

s1 = 'chuxin' s2 = '_'.join(s1) print(s2)  # 'c_h_u_x_i_n' lst1 = ['123', 'qwe', '@#'] lst2 = '|'.join(lst1) print(lst2)  # '123|qwe|@#'

replace

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

name = 'I am chuxin' new_name = name.replace('chuxin', 'SB') print(new_name) # 'I am SB'

format

格式化输出

ret = '{}{}{}'.format('name','age',123) ret = '{1}{1}{2}'.format('name','age',123) ret = '{name}{age}{sex}'.format(age=123,name='ruan',sex='male')

encode

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

count

计算某个元素出现的次数

s = 'chuxin' print(s.count('x'))

index

通过元素找索引，找到第一个就返回，找不到就报错

ret = 'zxc123' print(ret.index('1'))

find

从左到右通过元素查找索引，找到第一个就返回，找不到就返回-1

ret = 'zxc123' print(ret.find('1'))

upper

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

s1 = 'zxc' s2 = s1.upper() print(s2)  # 'ZXC'

lower

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

s1 = 'ZXC' s2 = s1.upper() print(s2)  # 'zxc'

isalpha

判断字符串是否全部为字母

s1 = '初xin' print(s1.isalpha) # True

isdecimal

检测字符串是否全部为十进制数字组成

islanum

检测字符串是否全部为数字和字母组成，返回True或者False

startswith

判断字符串是否为某个指定字符开头，可以切片，返回True或者False

endswith

判断字符串是否为某个指定字符结尾，可以切片，返回True或者False

capitalize

创建一个开头大写其余字母小写的新字符串

center

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

where

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

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