在python中print表示的数据类型是_python之数据类型

每一种计算机语言都有自己的数据类型，但大多数计算机语言的数据类型都基本一致，下来我们来看看python中的数据类型

int数字，运算

就是用来计算的，定义方式就是 ：变量名 = 数值

方法也不多，就记住 bit_length() 当十进制用二进制表示时，最少使用的位数

v = 9 #定义一种整型的数据类型

data = v.bit_length() #判断该数值转化为二进制需要的最小位数

print(data)

布尔值bool，判断

布尔值就两种：True，False。就是判断条件的正确与否，其实所有的计算机语言都有bool值，基本一致。

真 1 True。

假 0 False。

str字符串，存储少量的信息数据，操作简单，便于传输

在python里，""(双引号)''(单引号)都是用来标识字符串的， 字符串就是由字母数字，下划线，其他字符组成的，用引号引起来的就是字符串，需要注意的是：字符串是有序的，从前往后是0开始，从后往前是从-1开始。

我们：我们来看一下字符串的具体用法：

字符串的索引与切片。

索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。 字符串是有序的，从前往后是0开始，从后往前是从-1开始， 首个切片从0开始，即0可以省略，如果是想取到整个字符串，则可以写为s[:]，单 个空格也是一个字符，只要是对字符串进行了操作，就会产生一个新的字符串

步长，步长为一定的数值，是有规律的取出

[起始索引: 截至索引 :步长]会有三个参数，前两个是你取的字符串，最后一个参数，就是你每隔几个字符串再去一个字符串

如果你想要反向取出字符串，即需要添加步长，步长为负值

s = 'Nice to meet you 999!'

print(s[2])

print(s[6])

print(s[7])

切片就是通过索引(索引：索引：步长)截取字符串的一段，形成新的字符串(但是切片的区间是半开区间，左闭右开)。

s = 'Nice to meet you 999!'

print(s[3:9])

print(s[0:-1]) #默认到最后

print(s[0:10:2]) # 反向步长

print(s[11:0:-2]) #反向加步长

print(a[0:]) #默认到最后

字符串常用方法：

关于字母的大小写转换

s = 'nice* to* meet you 999!'

print(s.capitalize()) #首字母大写 Nice* to* meet you 999!

print(s.swapcase()) #大小写翻转 NICE* TO* MEET YOU 999!

print(s.title()) #每个单词的首字母大写 Nice* To* Meet You 999!

print(s.upper()) #NICE* TO* MEET YOU 999! 全部小写转大写

print(s.lower()) #nice* to* meet you 999! 全部大写转小写

内同居中，总长度，空白处填充

s1 = 'aaa'

print(s1.center(20, '*')) #********aaa*********

统计字符串中的元素出现的个数

s = '*nice* to* meet you 999!*'

print(s.count('e', 0, -1)) #统计字符串中的元素出现的个数。 3

去掉字符串中的特殊字符，分割

split分割,默认以空格进行分割，分割后的结果是一个列表,也可以规定以什么进行分割，也可以设置分割几次

strip默认去除左边的空格，换行符，tab键

s = '*nice* to* meet you 999!*'

print(s.split("*")) #结果变为了列表 ['nice', ' to', ' meet you 999!']

print(s.lstrip("*")) #nice* to* meet you 999!* #去掉左边

print(s.rstrip("*")) #*nice* to* meet you 999! #去掉右边

print(s.strip()) #nice to meet you 999! #都去

判断开头结尾，返回结果布尔值

s = '*nice* to* meet you 999!*'

print(s.startswith('k', 0, -1)) #False

print(s.endswith('9', 0, -1)) #True

寻找字符串中的元素是否存在

s = '*nice* to* meet you 999!*'

print(s.index('you', 0, -1)) # 返回的找到的元素的索引，找不到报错。15

print(s.find('you', 0, -1)) # 15 返回的找到的元素的索引，如果找不到返回-1

replace替换

从头开始进行替换，(字符串原有的字符串，新的替换的字符串，替换的次数)

s = '*nice* to* meet you 999!*'

print(s.replace("999", "too")) #nice* to* meet you too!

is系列

s = '*nice* to* meet you 999!*'

print(s.isdigit()) #False

print(s.isalpha()) #False

print(s.isalnum()) #False

默认将一个tab键变成8个空格，如果tab前面的字符长度不足8个，则补全8个，

# 如果tab键前面的字符长度超过8个不足16个则补全16个，以此类推每次补全8个。

s = '*nice* to* meet you 999!*'

print(s.expandtabs())

join加入，形成新的字符串

print('*'.join('meet')) #m*e*e*t

tuple元组，只读列表，不能更改数据

元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。以()进行定义

list列表，存放大量数据，存储不同类型的数据，大量数据放在列表中便于操作

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

列表是可变数据类型，所以可以进行增删改查

l = ['I', 'like', 'you', '*', 999, ['dear', 'love']]

l.append('too') #增加到最后

print(l) #['I', 'like', 'you', '*', 999, ['dear', 'love'], 'too']

l.insert(5, 'me') #按照索引去增加

print(l) #['I', 'like', 'you', '*', 999, 'me', ['dear', 'love'], 'too']

l.extend('abc') #迭代的去增，将里面的元素分开(里面的元素是以逗号进行分割，列表，是#将列表的每一个元素分别以一个元素进行添加)

print(l) #['I', 'like', 'you', '*', 999, 'me', ['dear', 'love'], 'too', 'a', 'b', 'c']

增

#改 按照索引修改,即只是把该索引的位置重新赋值，覆盖之前的数据

l = ['I', 'like', 'you', '*', 999, ['dear', 'love']]

l[1] = 'love'

print(l) #['I', 'love', 'you', '*', 999, ['dear', 'love']]#按照切片修改

l[:3] = 'w'#但是这个方式，只是把第一个索引的位置修改

print(l) #['w', '*', 999, ['dear', 'love']]

l[:3] = ['I','very', 'love', 'you']#这样就可以把这些索引的位置可以修改了

print(l) #['I', 'very', 'love', 'you', ['dear', 'love']]

改

l = ['I', 'like', 'you', '*', 999, ['dear', 'love']]#循环去查。

for i inl :print(i)#切片去查

print(l[0])print(l[2:3])print(l[1:9:2]) #['like', '*', ['dear', 'love']]

print(l[9:0:-2]) #[['dear', 'love'], '*', 'like']

查

l = ['I', 'like', 'you', '*', 999, ['dear', 'love']]#删 li.pop() 按照索引删除,默认删除最后一个，返回的删除的内容

l.pop(2)print(l) #['I', 'like', '*', 999, ['dear', 'love']]#remove 删除某部分内容,默认删除一个相对应的元素

l.remove('*')print(l) #['I', 'like', 999, ['dear', 'love']]#del也可以进行切片删除

del l[1:3]print(l)#['I', ['dear', 'love']]#clear清空内容，但是列表还是存在的

l.clear()print(l)#[]#del删除列表，即把列表全部删除，列表也将不存在

dellprint(l) #NameError: name 'l' is not defined

删

其他操作

count(数)(方法统计某个元素在列表中出现的次数)

l = ['I', 'like', 'you', '*']

print(l.count('you'))

index(方法用于从列表中找出某个值第一个匹配项的索引位置)

l = ['I', 'like', 'you', '*']

print(l.index('like'))

sort (方法用于在原位置对列表进行排序)，这个只是字符串类型，里面不能有列表或整形。

l = ['I', 'like', 'you', '*']

l.sort()

print(l)

reverse (方法将列表中的元素反向存放)，这个只是字符串类型，里面不能有列表或整形。

l = ['I', 'like', 'you', '*']

l.reverse()

print(l)

len长度，这个列表的长度

l = ['I', 'like', 'you', '*']

print(len(l))

dict字典，存储关系型数据，以键值对的方式存在，查询数据非常快，以二分法进行查找以{}进行定义，

字典是python中唯一的映射类型，采用键值对(key-value)的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。

字典的值可以是任意数据类型，哈希：每一个数据都有唯一的对应的哈希值。

数据类型分类：

可变数据：list dict set

不可变数据：int bool str tuple

字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典的顺序：

3.5之前，字典是无序的

3.6开始，字典在创建的时候是有序的，按照一定的顺序创建，看起来是有序的

dic = {'name': 'cat', 'age': 2, 'hobby': 'fish'}

dic['dream'] = 'haapy'

print(dic) #以覆盖的形式，有则覆盖 ，无则添加#setdefault,但默认添加的键所对应的值是none,无则添加，有则不变

dic.setdefault('like', 'mmd')print(dic)

dic.setdefault('like', 'dear')print(dic)

增

dic = {'name': 'cat', 'age': 2, 'hobby': 'fish'}

dic1= {'addr': '海边'}

dic.update(dic1)#{'hobby': 'fish', 'age': 2, 'name': 'cat', 'addr': '海边'}

改

dic = {'name': 'cat', 'age': '2', 'hobby': 'fish'}print(dic['name']) #如果没有该键，则会报错

print(dic.get('name'))#如果没有该键的话，就会返回none

for key indic:print(key +dic[key])for k, v indic.items():print(k, v)print(dic.items())

查

dic = {'name': 'cat', 'age': '2', 'hobby': 'fish'}

dic.pop('hobby') #pop根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值

print(dic)

dic.popitem()#随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回

print(dic)

dic.clear()#清空字典

print(dic)del dic

删

其他操作：

dic = {'name': 'cat', 'age': '2', 'hobby': 'fish'}

item=dic.items()print(item,type(item))#这个类型就是dict_items类型，可迭代的，#dict_items([('name', 'cat'), ('age', '2'), ('hobby', 'fish')])

keys=dic.keys()print(keys, type(keys))#dict_keys(['name', 'age', 'hobby'])

values=dic.values()print(values, type(values))#dict_values(['cat', '2', 'fish'])

set集合

按有序无序分类

数字

字符串

集合：无序，即无序存索引相关信息

元组：有序，需要存索引相关信息，不可变

列表：有序，需要存索引相关信息，可变，需要处理数据的增删改

字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

其他(for，enumerate，range)

for循环：用户按照顺序循环可迭代对象的内容。for循环就是来迭代那些可迭代的对象的。

msg = '老男孩python是全国范围内最好的python培训机构'

for item in msg:

print(item)

li = ['alex','银角','女神','egon','太白']

for i in li:

print(i)

dic = {'name':'太白','age':18,'sex':'man'}

for k,v in dic.items():

print(k,v)

enumerate：枚举，对于一个可迭代的(iterable)/可遍历的对象(如列表、字符串)，enumerate将其组成一个索引序列，利用它可以同时获得索引和值。

li = ['alex','银角','女神','egon','太白']

for i in enumerate(li):

print(i)

for index,name in enumerate(li,1):

print(index,name)

for index, name in enumerate(li, 100): # 起始位置默认是0，可更改

print(index, name)

range：指定范围，生成指定数字。

for i in range(1,10):

print(i)

for i in range(1,10,2): # 步长

print(i)

for i in range(10,1,-2): # 反向步长

print(i)