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) #检测字符串对象类型
转义字符：
| 转义字符 | 说明 | 转义字符 | 说明 |
|---|---|---|---|
| \\ | 反斜杠 | \n | 换行符 |
| \' | 单引号 | \" | 双引号 |
| \a | 响铃符 | \b | 退格符 |
| \r | 回车符 | \r | 换页符 |
| \t | 水平制表符 | \v | 垂直制表符 |
| \0 | Null，空字符串 | \ooo | 八进制值表示的ASCII码对应字符 |
| \xhh | 十六进制值表示的ASCII码对应字符 |
字符串的基本操作：
>>> 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 "", line 1, in
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({})
集合运算：
#定义集合
>>> 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>> {1,2} 基本操作：
#创建集合
>>> 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 "", line 1, in
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 "", line 1, in
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 "", line 1, in
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 "", line 1, in
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 "", line 1, in
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......