python的基本数据类型包括：
数字（int）
布尔值（bool）
字符串（str）
集合（set）
列表（list）
元组（tuple）
字典（dict）

数字（int）

数字类型包括：浮点型（float）、整数型（int）、长整型（long）、复数型（complex）

用int函数将字符串按指定进制转换为整数：

>>> int('111')          #默认按十进制装换
111

>>> int('111',2)        #按二进制转换
7

>>> int('111',8)        #按八进制转换
73

>>> int('111',16)       #按十六进制转换
273

整数转换为对应进制字符串：

>>> bin(666)          #转换为二进制字符串
'0b1010011010'

>>> oct(666)         #转换为八进制字符串
'0o1232'

>>> hex(666)         #转换为十六进制字符串
'0x29a'

字符串（str）

python字符串常量可用多种方式表达：
-单引号：’hello’
-双引号：”hello”
-三引号：”’hello”’
-带r或R前缀：r’hello’、R’hello’
-带u或U前缀：u’hello’、U’hello’

字符串的创建：

>>> x=str('hello')       #创建字符创对象
>>> x
'hello'

>>> type(x)              #检测字符串对象类型
<class 'str'>

转义字符：

字符串的基本操作：

>>> len('hello')                 #求字符串的长度
5
#---------------------
>>> x='hello'                    #包含的判断性
>>> 'a' in x
False
>>> 'h' in x
True
#---------------------
>>> 'h''e''l''l''o'              #字符串的连接
'hello'
>>> 'he'+'llo'           
'hello'
>>> 'hello'*3
'hellohellohello'
#---------------------
>>> for i in 'hell':print(i)     #字符串的迭代
h
e
l
l
#---------------------
>>> x="hello"                    #索引
>>> x[0]
'h'
>>> x[-1]
'o'
#---------------------
>>> x="hello"                    #分片
>>> x[0]
'h'
>>> x[-1] 
'o'
>>> x="hello"
>>> x[1:3]
'el'
>>> x[1:]
'ello'
>>> x[:3]
'hel'
>>> x[:-1] #除最后一个字符，其余全部返回
'hell'
>>> x[:] #返回全部字符
'hello'

>>> x="123456789"
>>> x[1:7:2]
'246'
>>> x[::2]
'13579'
>>> x[7:1:-2]
'864'
>>> x[::-1] #将字符串反序返回
'987654321'

字符串转换：

#将整数转换为字符串
>>> str(123)       
'123'

 #将浮点数转换为字符串
>>> str(1.23)     
'1.23'

#将复数转换为字符串
>>> str(1+2j)      
'(1+2j)'

字符串的方法：

#将字符串第一个字母大写，其余为小写

>>> 'hello'.capitalize()
'Hello'
#---------------------
#将字符串的字母全部转成小写

>>> 'Hello world'.lower()
'hello world'
#---------------------
#将字符串的字母全部转成大写

>>> 'Hello world'.upper()
'HELLO WORLD'
#---------------------
#查找子字符串出现的次数

>>> 'hello,hello'.count('el')
2
#---------------------
#判断字符串是否以‘xxx’开头

>>> 'hello'.startswith('h')
True
#---------------------
#判断字符串是否以‘xxx结尾’

>>> 'hello'.endswith('o')
True
#---------------------
#查找子字符串返回第一次出现位置的偏移量

>>> x='hellohello'
>>> x.find('lo')
3
>>> x.find('lo',2)
3
>>> x.find('loo')#没找到时返回-1
-1
#---------------------
#查找子字符串返回最后一次出现位置的偏移量

>>> 'hellohello'.rfind('lo')
8
#---------------------
#与find()方法相同，只是未找到子字符串时产生ValueError异常

>>> x='hellohello'
>>> x.find('lo',2)
3
>>> x='hellohello'
>>> x.index('lo')
3
>>> x.index('lo',2)
3
>>> x,index('loo')
Traceback (most recent call last):
  File "<pyshell#19>", line 1, in <module>
    x,index('loo')
NameError: name 'index' is not defined
#---------------------
#字符串格式化，将字符串用{}定义的替换预一次用参数表示

>>> 'My name is {0},age is{1}'.format('Jayss',20)
'My name is Jayss,age is20'
>>> 'My name is {name},age is{age}'.format_map({'name':'Jayss','age':20})
'My name is Jayss,age is20'
#---------------------
#由数字或字母组成时返回True

>>> '123'.isalnum()
True
>>> '123abc'.isalnum()
True
>>> '123&abc'.isalnum()
False
#---------------------
#字符串字符全部是字母时返回True

>>> 'Hello'.isalpha()
True
>>> 'Hello&Hello'.isalpha()
False
#---------------------
#字符串字符全部是大写字母时返回True

>>> 'HELLO'.isupper()
True
>>> 'Hello'.isupper()
False
#---------------------
#字符串字符全部是小写字母时返回True

>>> 'hello'.islower()
True
>>> 'Hello'.islower()
False
#---------------------
#字符串字符全部是数字时返回True

>>> '123'.isdecimal()
True
>>> '123abc'.isdecimal()
False

集合

唯一、无序、不可改变

创建集合：

#直接使用集合常量
>>> x={1,2,3}
>>> x
{1, 2, 3}

#用集合常量做参数创建集合对象
>>> set({1,2,3})
{1, 2, 3}

#用列表常量做参数创建集合对象
>>> set([1,2,3])
{1, 2, 3}

#用字符串常量做参数创建集合对象
>>> set('123')
{'1', '2', '3'}

#创建空集合
>>> set()
set()
>>> type({})
<class 'dict'>

集合运算：

#定义集合
>>> x={1,2,'a','b'}
>>> y={3,4,'c','d'}

#求集合中元素的个数
>>> len(x)
4

#判断元素是否属于集合
>>> 'a' in x
True

#求差集
>>> x - y
{1, 2, 'a', 'b'}

#求并集
>>> x|y
{1, 2, 3, 'd', 4, 'c', 'a', 'b'}

#求求交集
>>> x&y
set()

#求对称差
>>> x^y
{1, 2, 3, 'd', 4, 'c', 'a', 'b'}

#比较运算符可用于判断子集或超集关系
>>> x<y
False
>>> {1,2}<x
True

基本操作：

#创建集合

>>> x={1,2}
>>> x
{1, 2}
#---------------------
#复制集合对象

>>> y=x.copy()
>>> y
{1, 2}
#---------------------
#危机和添加一个元素

>>> x.add('abc')
>>> x
{'abc', 1, 2}
#---------------------
#危机和添加多个元素
>>> x.update({'a','b'})
>>> x
{1, 2, 'abc', 'a', 'b'}
#---------------------
#从集合中删除指定元素

>>> x.remove('abc')
>>> x
{1, 2, 'a', 'b'}
#---------------------
#从集合中删除指定元素

>>> x.discard('a')
>>> x
{1, 2, 'b'}
#---------------------
#从集合中随机删除一个元素并返回该元素

>>> x.pop()
1
>>> x
{2, 'b'}
#---------------------
#删除集合中的全部元素

>>> x.clear()
>>> x
set()

冻结集合：

冻结集合是一个不可改变的集合，可作为其它集合的元素

#创建冻结集合
>>> x=frozenset([1,2,3])
>>> x          #冻结集合的打印格式与普通集合不同
frozenset({1, 2, 3})

#创建普通集合
>>> y=set([4,5])
>>> y
{4, 5}

#将冻结集合作为元素加入另一集合
>>> y.add(x)
>>> y
{frozenset({1, 2, 3}), 4, 5}

#为冻结集合添加元素，报错
>>> x.add(123)
Traceback (most recent call last):
  File "<pyshell#143>", line 1, in <module>
    x.add(123)
AttributeError: 'frozenset' object has no attribute 'add'

列表

有序、可变、可直接修改

创建列表：

#创建一个空列表对象
>>> []
[]
>>> list()
[]

#不同类型数据创建列表对象
>>> [1,'a',(1,2,3),[1,2,3]]
[1, 'a', (1, 2, 3), [1, 2, 3]]

#迭代对象创建列表对象
>>> list('abcdef')
['a', 'b', 'c', 'd', 'e', 'f']

#用连续整数创建列表对象
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

#用元组创建列表对象
>>> list((1,2,3))
[1, 2, 3]

基本操作：

#求长度

>>> len([])
0
>>> len([1,2,3])
3
#---------------------
#合并

>>> [1,2]+[3,4]
[1, 2, 3, 4]
#---------------------
#重复

>>> [1,2]*3
[1, 2, 1, 2, 1, 2]
#---------------------
#迭代

>>> x=[1,2,(1,2,3),[1,2,3]]
>>> for i in x :print(i)
1
2
(1, 2, 3)
[1, 2, 3]
#---------------------
#关系判断

>>> 2 in [1,2,3]
True
>>> 'a' in [1,2,3]
False
#---------------------
#索引

>>> x=[1,2,['a','b','c']]
>>> x[0]
1
>>> x[2]
['a', 'b', 'c']
>>> x[2][1]
'b'
>>> x[0]=11      #修改第一个列表对象
>>> x
[11, 2, ['a', 'b', 'c']]
#---------------------
#分片

>>> x=list(range(10))      #创建列表对象
>>> x
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x[2:5]                 #返回分片列表
[2, 3, 4]
>>> x[:5]
[0, 1, 2, 3, 4]
>>> x[2:]
[2, 3, 4, 5, 6, 7, 8, 9]
>>> x[2:2:7]
[]
>>> x[2:5]='abc'           #通过分片替换多个对象
>>> x
[0, 1, 'a', 'b', 'c', 5, 6, 7, 8, 9]
#---------------------
#矩阵

>>> x=[[1,2,3],[4,5,6],[7,8,9]]
>>> x[0]
[1, 2, 3]
>>> x[0][0]
1

常用方法：

#添加单个对象：append()

>>> x=[1,2,3]
>>> x.append('abc')
>>> x
[1, 2, 3, 'abc']
#---------------------
#添加多个对象：extend()

>>> x=[1,2,3]
>>> x.extend(['a','b'])    #添加多个对象时，需要以列表为整体
>>> x
[1, 2, 3, 'a', 'b']
>>> x.extend('abc')        #使用extend添加单个字符串时，会被拆分
>>> x
[1, 2, 3, 'a', 'b', 'a', 'b', 'c']
#---------------------
#插入对象：insert()

>>> x=[1,2,3]
>>> x.insert(1,'abc')      #1表示插入的偏移位置
>>> x
[1, 'abc', 2, 3]
#---------------------
#按值删除对象：remove()，若有重复，则删除第一个

>>> x=[1,2,2,3]
>>> x.remove(2)
>>> x
[1, 2, 3]
#---------------------
#按位置删除：pop()

>>> x=[1,2,3,4,5,6]
>>> x.pop()    #删除并返回最后一个对象
6
>>> x
[1, 2, 3, 4, 5]
>>> x.pop(1)    #删除并返回偏移量为1的对象
2
>>> x
[1, 3, 4, 5]
#---------------------
#用del语句删除

>>> x=[1,2,3,4,5,6]
>>> del x[0]      #删除第一个对象
>>> x
[2, 3, 4, 5, 6]
>>> del x[2:4]     #删除偏移量为2、3的对象
>>> x
[2, 3, 6]
#---------------------
#删除全部对象：clear()

>>> x=[1,2,3]
>>> x.clear()
>>> x
#---------------------
#复制列表：copy()，只是复制一维列表（没有真正复制到里面的列表内容）

>>> x=[1,2,3]
>>> y=x.copy()
>>> y
[1, 2, 3]
#深复制：追根溯源（要导入copy模块）copy.deepcopy()
#---------------------
#列表排序：sort()（全为数字则从小到大排序，全为字符串则按字典书序排序，若包含多种类型则出错）

>>> x=[1,3,5,8,2]                      #对全为数字列表排序
>>> x.sort()
>>> x
[1, 2, 3, 5, 8]
>>> x=['b','a','ddd','abc','AB','BA']  #对全为字符串列表排序
>>> x.sort()
>>> x
['AB', 'BA', 'a', 'abc', 'b', 'ddd']    #对全为字符串列表排序
>>> x=['abc','123']
>>> x.sort()
>>> x
['123', 'abc']
>>> x=[1,2,3,'abc']                    #对混合类型列表排序时，报错
>>> x.sort()
Traceback (most recent call last):
  File "<pyshell#90>", line 1, in <module>
    x.sort()
TypeError: '<' not supported between instances of 'str' and 'int'
#---------------------
#反转对象顺序：reverse()

>>> x=[1,2,3]
>>> x.reverse()
>>> x
[3, 2, 1]

元组

有序、不可改变、不可添加也不可删除

创建元组：

#创建空的元组对象
>>> ()
()
>>> tuple()
()

#创建一个对象的元组（逗号不能少）
>>> (1,)
(1,)

#用字符串创建元组，可迭代对象均可用于创建元组
>>> tuple('hello')
('h', 'e', 'l', 'l', 'o')

#用解析结构创建元组
>>> tuple(i*2 for i in range(5))
(0, 2, 4, 6, 8)

基本操作：

#求长度

>>> len((0,1,2,3,4,5))
6
#---------------------
#合并

>>> (1,2)+('a','b')+(2.45,)
(1, 2, 'a', 'b', 2.45)
#---------------------
#重复

>>> (1,2)*3
(1, 2, 1, 2, 1, 2)
#---------------------
#迭代

>>> for x in (1,2.5,'hello',[1,2]):print(x)
1
2.5
hello
[1, 2]
#---------------------
#关系判断

>>> 'a' in ('a','b','c')
True
#---------------------
#索引和分片

>>> x=tuple(range(10))
>>> x
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> x[1]
1
>>> x[-1]
9
>>> x[3:6]
(3, 4, 5)
>>> x[1:7:2]
(1, 3, 5)
#---------------------
#矩阵

>>> x=((1,2,3),(4,5,6),(7,8,9))
>>> len(x)
3
>>> x[0]
(1, 2, 3)
>>> x[0][1]
2

常用方法：

#返回指定值在元组出现的次数：count()

>>> x=(1,2)*3
>>> x
(1, 2, 1, 2, 1, 2)
>>> x.count(1)
3
>>> x.count(3)
0
#---------------------
#查找元组中指定的值：index()

>>> x=(1,2,3)*3
>>> x
(1, 2, 3, 1, 2, 3, 1, 2, 3)
>>> x.index(2)          #默认查找全部元组
1
>>> x.index(2,2)        #从偏移量2到元组末尾中查找
4
>>> x.index(2,2,7)      #在范围[2:7]内查找
4
>>> x.index(5)          #若元组找不到指定值，报错
Traceback (most recent call last):
  File "<pyshell#68>", line 1, in <module>
    x.index(5)
ValueError: tuple.index(x): x not in tuple

字典

无序、长度不可变、可添加也可删除

创建字典：

#创建空字典
>>> {}
{}
>>> dict()
{}

#创建字典
>>> {'name':'jayss','age':20}
{'name': 'jayss', 'age': 20}

基本操作：

#求长度

>>> x={'name':'jayss','age':20}
>>> len(x)
2
#---------------------
#关系判断（判断的是键）

>>> x={'name':'jayss','age':20}
>>> 'name' in x
True
>>> 'sex' in x
False
>>> 'jayss' in x
False

#---------------------
#索引

#通过键来索引映射的值
>>> x={'name':{'jayss':'male','ella':'female'},'age':20}
>>> x['name']
{'jayss': 'male', 'ella': 'female'}
>>> x['name']['jayss']
'male'
#通过索引修改映射值
>>> x=dict(name='jayss',age=20)
>>> x
{'name': 'jayss', 'age': 20}
>>> x['age']=21
>>> x
{'name': 'jayss', 'age': 21}
#通过索引删除键值对
>>> x={'name':'jayss','age':20}
>>> del x['age']
>>> x
{'name': 'jayss'}

常用方法：

#删除全部字典对象：clear()
>>> x={'name':'jayss','age':20}
>>> x.clear()
>>> x
{}
#---------------------
#复制字典对象：copy()

#例一
>>> x={'name':'jayss','age':20}
>>> y = x
>>> x,y
({'name': 'jayss', 'age': 20}, {'name': 'jayss', 'age': 20})
>>> y['name']='ella'
>>> x,y
({'name': 'ella', 'age': 20}, {'name': 'ella', 'age': 20})
>>> y is x
True
#例二
>>> x={'name':'jayss','age':20}
>>> y=x.copy()
>>> x,y
({'name': 'jayss', 'age': 20}, {'name': 'jayss', 'age': 20})
>>> y['name']='ella'
>>> x,y
({'name': 'jayss', 'age': 20}, {'name': 'ella', 'age': 20})
>>> y is x
False
#---------------------
#返回键key映射的值：get(key[,default])，如果键值不存在则返回空值，可用default指定不存在的返回值

>>> x={'name':'jayss','age':20}
>>> x.get('name')          
'jayss'
>>> x.get('sex')
>>> x.get('sex','xxx')
'xxx'
#---------------------
#删除键并返回映射值：pop(key[,default]),若键值不存在则返回default，未指定default则会报错

>>> x={'name':'jayss','age':20}
>>> x.pop('age')            #删除键并返回映射值
20
>>> x
{'name': 'jayss'}
>>> x.pop('sex','xxx')      #删除不存在的键
'xxx'
>>> x.pop('sex')            #删除不存在的键，未指定default参数，报错
Traceback (most recent call last):
  File "<pyshell#39>", line 1, in <module>
    x.pop('sex')
KeyError: 'sex'
#---------------------
#删除并返回键值对元组：popitem(),空字典调用该方法会产生KeyError错误

>>> x={'name':'jayss','age':20}
>>> x.popitem()        #删除并返回键值对元组
('age', 20)
>>> x                  #x中剩余一个键值对
{'name': 'jayss'}
>>> x.popitem()        #删除并返回键值对元组
('name', 'jayss')
>>> x
{}
>>> x.popitem()        #删除为空的字典，报错
Traceback (most recent call last):
  File "<pyshell#38>", line 1, in <module>
    x.popitem()
KeyError: 'popitem(): dictionary is empty'
#---------------------
#返回映射值或者为字典添加键值对：setdefault(key[,default])

>>> x={'name':'jayss','age':20}
>>> x.setdefault('name')      #返回指定键的映射值
'jayss'
>>> x.setdefault('sex')       #键不存在，为字典添加键值对，映射值默认为None
>>> x
{'name': 'jayss', 'age': 20, 'sex': None}
>>> x.setdefault('hobby','sleep')  #添加键值对
'sleep'
>>> x
{'name': 'jayss', 'age': 20, 'sex': None, 'hobby': 'sleep'}
#---------------------
#为字典添加键值对：update(other)

>>> x={'name':'jayss','age':20}
>>> x.update({'sex':'male'})      #添加键值对
>>> x
{'name': 'jayss', 'age': 20, 'sex': 'male'}
>>> x.update(name='Mike')         #修改映射值
>>> x
{'name': 'Mike', 'age': 20, 'sex': 'male'}
>>> x.update(hobby='sleep')      #添加键值对
>>> x
{'name': 'Mike', 'age': 20, 'sex': 'male', 'hobby': 'sleep'}

字典视图：

#返回键值对视图：items()

>>> x={'name':'jayss','age':20}
>>> y=x.items()          #返回键值对视图
>>> y
dict_items([('name', 'jayss'), ('age', 20)])
>>> for i in y:print(i)  #迭代键值对视图
('name', 'jayss')
('age', 20)
#---------------------
#返回字典中所有键的视图：keys()

>>> x={'name':'jayss','age':20}
>>> y=x.keys()
>>> y
dict_keys(['name', 'age'])
#---------------------
#返回字典中所有值的视图：values()

>>> x={'name':'jayss','age':20}
>>> y=x.values()
>>> y
dict_values(['jayss', 20])
#---------------------
#键视图的集合操作

>>> x={'name':'jayss','age':20}      #创建x字典
>>> kx=x.keys()      #返回x的键视图
>>> kx
dict_keys(['name', 'age'])
>>> y={'name':'ella','age':19}       #创建y字典
>>> ky=y.keys()      #返回y的键视图
>>> ky
dict_keys(['name', 'age'])
>>> kx-ky      #求差集
set()
>>> kx|ky      #求并集
{'age', 'name'}
>>> kx&ky      #求交集
{'age', 'name'}
>>> kx^ky      #求对称差集
set()

欢迎学术交流

WeChat……