Résumé des types de données en Python

1. Types entiers

Dans Python2, il existe des types entiers et des types entiers longs, mais dans Python3, le type entier long a été annulé et classé comme types entiers.

Les entiers en Python peuvent être représentés sous des formes binaires, octales, décimales et hexadécimales

Vous pouvez utiliser la méthode suivante pour convertir les décimales en d'autres formes

>>> print(bin(10))           --------->  把十进制转化为二进制
0b1010>>> print(oct(10))           --------->  把十进制转化为八进制
0o12>>> print(hex(10))           --------->  把十进制转化为十六进制0xa>>> print(hex(100))0x64

二、浮点型

浮点型数就是小数，因为用科学计数法表示小数时，小数点的位置是可以变化的，所以称为浮点数。在计算机中，整数永远是准确的，而浮点数在四舍五入的过程中却有可能产生误差。小的浮点数可以直接写，但是对于位数很多的浮点数，就必须用科学计数法来表示。把10用e表示，如1.03乘10的9次方，就要写成1.03e9

三、字符串类型

定义在引号里面的整体称为字符串，是由一个个字符构成的

引号可以是单引号，双引号，三引号，多引号...(在Python中，单引号和双引号没有区别）

字符串的常用操作：

Python为字符串内置了很多种方法，方便处理需求

1..strip()    作用是移除空白，可以在（）中指定移除的字符，默认为空格

x='*****abc*****'
print(x.strip('*'))

运行结果为：abc

2..capitalize()   作用是首字母大写

x='hello world'
print(x.capitalize())

运行结果为：Hello world

3.upper（）       作用是所有字母都大写,相反的lower（）的作用是所有字母小写

x='hello world'
print(x.upper())

运行结果为：HELLO WORLD

4..center(self，width,fillchar)       作用是把字符放中间，左右用指定的字符填充至指定的字符长度

x='hello world'
print(x.center(30,'*'))

 运行结果为：*********hello world*********

5..count　　    作用是统计字符串中某一字符出现的次数，可以指定范围

x='hello world'
print(x.count('l',0,10))       命令的作用是统计“hello world”中第1到11个字符中，‘l’出现的次数
运行结果为：3

6..startswith()      以..开头
　　x='hello world'
　　print(x.startswith('a'))       判断x是否以‘a’开头，如果是，结果为True,如果不是，结果为False

　.endswith()         以..结尾

7..find（）          寻找，如果结果不为负数，则成功。会返回目标字符在字符串中的位置
　　　　　　　　　　　　　find()和index()的区别是如果找不到对象，find（）会返回-1，index（）会报错

8..format　　　　　　　　格式化字符串（先举个小例子，后续博客中会详细介绍）
　　x='myname:{},age:{},sex:{}'
   print(x.format('zhang',18,'male'))
　　
　 运行结果为：myname:zhang,age:18,sex:male

9..index()   查看某个字符的索引，如果超出范围会报错
　　x='hello world'
　　print(x[1])           ------>e
　　print(x[4])           ------>o
　　print(x[-1])          ------>d     倒着数
　　print(x.index('w'))    --------->6   查看某一字符在在字符串中的索引

　　字符串的切片操作：print(x[1:3])     -------->el    取x中第1,2个字符
　　　　切片也可以加步长：print(x[1:5:2])   ------->el   取x中第1,2,3,4个字符，但是每两个字符取一次，也就是取第1,3个字符 　　

10..isdigit()     查看字符串是否为整数，是则输出True，否则输出False
　　x='hello world'
　　print(x.isdigit())
　　
　　False

11..replace      替换

   x='hello world'
   print(x.replace('e','E'))        #不止可以替换字符，也可以替换字符串

 运行结果为：hEllo world

12..split()         默认以空格为分隔符分割成几部分，当然也可以指定字符作为分隔符
　　
　　x='hello:world:today:is:a:goodday'
   print(x.split(':'))

　　运行结果为：['hello', 'world', 'today', 'is', 'a', 'goodday']

13..issupper()    判断是否全部为大写
　　.islower()     判断是否全部为小写
　　.isspace()     判断是否为空格
　　.istitle()     判断是否首字母大写

14..ljust()       左对齐
　　.rjust()       右对齐

15..swapcase()    大小写反转
　　.title()       首字母大写

四、列表 list

　列表中可以存放各种数据类型，以逗号分割开，每个位置存放一个元素

1.列表的特性：可以存放多个值，每个值对应一个索引值

　　　　　　　列表中的值可变

　　　　　　　按从左到右的顺序定义列表元素，下标从0开始，是有序的

2.列表的创建

l=['abc','123',12]　　　　　     　------>['abc', '123', 12]

l=list('abc123')　　　　　　　　　------>['a', 'b', 'c', '1', '2', '3']

l=list(['abc','123',12])               ------->['abc', '123', 12]

 

3.列表的常用操作

1）索引

l=['abc','123',12,[3,'e',5]]

print(l[0])          -------->abc

print(l[2]) 　　　---------->12

print(l[3][2])     ----------->5

2) 切片

l=['abc','123',12,'[3,'e',5]]

print(l[1:3])           --------->['123', 12]

注意:切片是读操作，原列表并不会发生改变

3）追加 .append()

l=['abc','123',12,'[3,'e',5]]

l.append('hello')

print(l)   　　　　　　------------>['abc', '123', 12, [3, 'e', 5], 'hello']

默认是把字符加在原列表最后边

4）插入  .insert()

l=['abc','123',12,'[3,'e',5]]

l.insert(0,'hello')

print(l)　　　　　　　------------>['hello', 'abc', '123', 12, [3, 'e', 5]]　

注意：insert()中要指定索引位置，必须指定，否则会报错

5）删除 .pop()

l=['abc','123',12]

l.pop(1)

print(l)　　　　　------------>['abc', 12]

注意：()中可以指定要删除的元素的索引值，默认是最后一个

　　　l.pop()是有返回值的，返回删掉的元素

补充：队列和堆栈

队列是先进先出，可以用append()和pop(0) 或 insert()和pop()模拟

堆栈是先进后出，可以用append()和pop() 或insert()和pop(0)模拟

6）长度 len()

l=[1,2,3]

print(len(l))　　　　---------------------->3

7)循环

l=[1,2,3]

for i in l:

print(i)         　　--------------------->1  2  3

8)包含 in

l=['a','b','c']     

print('b' in l)　　------------------------->True

4.列表的其他操作

1）查看某一元素的索引 .index()

l=['a','b','c']

print(l.index('a'))　　　　------------------>0

2)列表中某个元素的数量 .count()

l=['a','b','c','a']

print(l.count('a))  　　-------------->2

3)追加 .extend() 和append有区别

l=[1,2,3]
l.append(['a','b','c'])
print(l)　　　　-------------->[1, 2, 3, ['a', 'b', 'c']]

l=[1,2,3]
l.extend(['a','b','c'])
print(l)　　　　--------------->[1, 2, 3, 'a', 'b', 'c']

4)按元素删除 .remove 

　注意当目标元素不存在时会报错，且有多个目标元素时只会删一个

l=[1,2,3]
l.remove('a')
print(l)　　　　　　------------->ValueError: list.remove(x): x not in list

5）排序 .sort()   无返回值

l=[3,2,4]
l.sort()
print(l)　　　　----------------->[2, 3, 4]

l=['a','c','d','cd']
l.sort()
print(l)　　　　----------------->['a', 'c', 'cd', 'd']

l.sort(reverse=True) 表示倒序排列

6）反转顺序 .reverse()

 

五、元组 tuple

1)元组的定义

t=('a','b',1,(3,4))

形式与列表相似，只是[]改成了（）

2)元组的特性：

元组元素可以是任意数据类型;

元组是不可变数据类型；

元组的元素可以是列表，列表的元素可以变，虽然列表的元素改变了，但是列表作为元组的一个元素并没有发生变化，所以不影响元组是不可变数据类型这一特点

因为元组是不可变数据类型，所以不存在增删改的功能，元组的方法只有count() 和 index()

3)元组的常用操作有：索引、切片、循环、长度和包含

4)元组和列表的相互转化：　　

t=('a','b',1,2)
l=['f','d',4]

tl=list(tuple(t))
print(tl,type(tl))　　　　---------->['a', 'b', 1, 2] <class &#39;list&#39;>

lt=tuple(list(l))
print(lt,type(lt))　　　　---------->('f', 'd', 4) <class &#39;tuple&#39;>

六、字典 dict

1)字典的定义：

d={'x':1,'y':1234}

2)字典的元素是键值对（key - values）

　字典是一种可变数据类型，其中values可变，但是Key不可变

　需注意：定义字典时，key必须是不可变类型，或者说是可hash类型

3)字典的取值

　字典是无序的，没有索引的概念，通过key来取值 print(d['x']) 就能取到1这个值

　如果key找不到的话会报错，可以用.get(key)   如果找不到key，会打印None，但是不会报错　

4)修改值

　d['x']='s'  --------把原字典改成了{‘x’:'s','y':1234}

5)循环　

d={'name':'zhang','age':18}
print(d.keys())                 #dict_keys(['name', 'age'])
print(d.values())               #dict_values(['zhang', 18])
for i in d:
    print(i)                    #name age  直接遍历字典，打印的是key
for k in d:
    print(k,d[k])               #name zhang   age 18

　因为字典是无序的，所以遍历字典的方法只有 for i in d:这一种

字典的常用方法：

1)清除

d={'x':1}
d.clear()      #清除
print(d)       #{}

2)避免找不到元素报错的情况

d={'x':1}
print(d.get('s'))       #None
print(d('s'))             #报错TypeError: 'dict' object is not callable

3)把键值对转换成元组形式

d={'x':1}
d.items()
for k,v in d.items():
    print(k,v)          #x 1

4)把values转换成列表形式

d={'x':1,'y':2322}
print(list(d.values()))      #把values值转换成列表形式----------->[1, 2322]

5)删除 .pop()

d={'x':1,'y':2322}
d.pop('x')
print(d)                      #{'y': 2322}
print(d.pop('x'))               #1    打印删除的那个值

6)删除 .popitem()  随机删除

d={'x':1,'y':2322}
d.popitem()             #括号里不能跟参数，随机删除
print(d)                #{'x': 1}

7)添加键值对 .setdefault()　　括号里是键值对

d={'x':1}
d.setdefault('s',2)             
print(d)            #{'x': 1, 's': 2}      添加键值对，key和值之间用逗号隔开

8)产生字典的方法

d3=dict(x=5,y=2,z=3)              　　　 #{'x': 5, 'y': 2, 'z': 3}   自动生成字典
d3=dict({'x':1,'y':2})                  #{'x': 1, 'y': 2}
d3=dict([('x',1),('y',2),('z',3)])      #{'x': 1, 'y': 2, 'z': 3}
d3={}.fromkeys(['name','age'],None)     #{'name': None, 'age': None}    None的位置只能有一个值，这种方法只能创建这种类型的
print(d3)

9)更新字典 .update()

d={'name':'alex'}
d1={'name':'alexsb','age':30}
d.update(d1)                    #用d1更新字典d
print(d)                    #{'name': 'alexsb', 'age': 30}

10)长度

d={'name':'zhangcan','age':18,'salary':'100000'}
print(len(d))                   #3
print(len(d.values()))          #3
print(len(d.items()))           #3
print(len(d.keys()))            #3

11)成员运算

d={'name':'zhangcan','age':18,'salary':'100000'}
print('x'in d)                                      #False
print('name'in d)                                   #True
print(18 in d)          　　　　　　　　　　　　　　　　　 #False
print(18 in d.values())        　　　　　　　　　　　　  #True
print('age' in d.keys())     　　　　　　　　　　　　    #True
print(18 in d.items())          　　　　　　　　　　　　 #False
print(('age',18) in d.items()) 　　　　　　　　　　     #True

七、布尔类型

所有的数据类型都自带布尔值（bool）,if 判断时，只有0，None，NULL为False，其他都为True

八、集合（set）
1.集合的定义

　1）集合内的元素必须是唯一的，可以用这个特性来实现‘去重’的功能　　

　　s={'egon',123,123,1,'abf'}
　　print(s)           # {1, 123, 'egon', 'abf'}

　2)集合内的元素必须是可hash的，即不可变的

　3)集合是无序的(无索引)

2.集合的关系运算（符号）

s1={'alex','egon','wupeiqi'}
s2={'alex','egon','zhangcan'}
print(s1 & s2)      #取交集
print(s1 | s2)      #取并集
print(s1-s2)        #差集{'wupeiqi'}
print(s1^s2)        #对称差集{'zhangcan', 'wupeiqi'}

3.集合的常用命令

print(s1.difference(s2))    #差集
print(s1.intersection(s2)) # 交集
print(s1.union(s2))         #并集
print(s1.symmetric_difference(s2))  #{'zhangcan', 'wupeiqi'}对称差集
print(s1.symmetric_difference_update(s2))  #None对称差集并更新回s1
print(s1)                                   #{'zhangcan', 'wupeiqi'}

s1.update(s2)       #并集
print(s1)           #{'zhangcan', 'wupeiqi', 'egon', 'alex'}

s1.add('yuanhao')       #添加元素
print(s1)

s1.discard('alex')          #删除（找不到元素不会报错）
print(s1)

s1.remove('alex')          #删除，但找不到元素会报错

s1.pop()         #括号里不能有东西，随机删除
print(s1)

成员运算：

s3={'a','b','c',1,2,3}
s4={1,2,3}
print(s4.issubset(s3))     #s4是否是s3的子集
print(s3.issuperset(s4))    #s3是否是s4的超集
print(s3.isdisjoint(s4))    #s3和s4是否有交集，有交集---False,没有交集---True

 

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!