基本数据类型:
(1)数字(int): 整形，浮点
整数类型定义的时候变量名后面直接跟数字，数字类型是不可变数据类型
>>> age = 20 >>> type(age) <class 'int'> >>>
数字类型的基本操作
#数字的操作类型主要在程序中起到一个判断作用 num1=b'4' #bytes num2=u'4' #Unicode #python3中不用管，可以忽略 num3='四' #中文数字 num4='Ⅳ' #罗马数字 #isdigt #作用就是判断是否是数字，一般就用isdigt就搞定了 print(num1.isdigit()) #True print(num2.isdigit()) #True print(num3.isdigit()) #False print(num4.isdigit()) #False #isdecimal:uncicode #bytes类型无isdecimal方法 print(num2.isdecimal()) #True print(num3.isdecimal()) #False print(num4.isdecimal()) #False #isnumberic:unicode,中文数字,罗马数字 #bytes类型无isnumberic方法 print(num2.isnumeric()) #True print(num3.isnumeric()) #True print(num4.isnumeric()) #True
数字类型操作
(2)字符串（str）:
定义字符串的时候需要用引号引起来,可以用单，双，三引号，三引号多表示多行字符串，这样就可以省掉“ ”换行符换行。
>>> name = "alex" >>> type(name) <class 'str'> >>>
字符串的基本操作主要有：copy，拼接，查找，统计，检测，切片，大小写等。这里需要注意字符串是不可变类型，上述操作并没有改变原来的字符串，只是创建了一个新的字符串，原来的字符串任然在内存中！
1，copy 复制
1 a = "alex" 2 b = a 3 print(a,b) 4 alex alex
2，拼接
1 a = "alex" 2 b = "egon" 3 print(a + b) 4 #alexegon
这里也可以用join来实现字符串的拼接效果，可以指定连接符号如（？， —，*) 之类的，当然也可以是空格!
1 a = "alex" 2 b = "egon" 3 print(a.join(b)) 4 #ealexgalexoalexn
3,查找，获取对象的下标
这里的查找是按照下标索引进行的，用到index
>>> a = 'alex' >>> a.index('l') 1 >>> a.index('a')#返回值是0，下标是从0开始的 0 >>> a.index('A')#找不到会报错 Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: substring not found >>>
4，统计 这里用到count
>>> name = 'alex' >>> name.count('l')#统计name中l的个数 1 >>>
5,切片 这里是按照索引来切的，切片就是取一个范围
>>> word = "keep doing" >>> word[6:10]#注意使用中括号来做取值范围，顾头不顾尾，不包含10 'oing' >>> word[5:9] 'doin' >>>
6，检测
1 >>> name = "alex"#检测’l‘有没有在name里面，返回布尔值 2 >>> "l"in name 3 True 4 >>> num = "12345678" 5 >>> num.isdigit()#检测“num”是不是由整形数字组成，浮点数都不行 6 True 7 >>> name.isidentifier()#检测name是否可以被用来做变量名 8 True 9 >>> name.find("l")#检测能否从name中找到“l”,找到返回1，找不到返回-1这点和index是 有区别的 10 1 11 >>> name.find('N') 12 -1 13 >>> name.index('N')#找不到报错 14 Traceback (most recent call last): 15 File "<stdin>", line 1, in <module> 16 ValueError: substring not found 17 >>> name.index("l") 18 1 19 >>>
7，大小写
1 >>> name = "I am alex" 2 >>> name.swapcase()#大小写互换 3 'i AM ALEX' 4 >>> name.capitalize()#首字母大写，其它都小写 5 'I am alex' 6 >>> name.upper()#全部大写 7 'I AM ALEX' 8 >>> name.lower()#全部小写 9 'i am alex' 10 >>>
8，移除空格“strip”，替换“replace”，分割“split，format格式化输出的三种玩法
1 >>> name = " alex" 2 >>> print(name.strip()) 3 alex 4 #replace 替换 5 >>> name='alex say :i have one tesla,my name is alex' 6 >>> name.replace("alex","SB",1)#替换第一个就写1 7 'SB say :i have one tesla,my name is alex' 8 >>> 9 #split分割 10 >>> name = "a*b*c*gh*kjk*" 11 >>> name.split('*')#以*为分割符号 12 ['a', 'b', 'c', 'gh', 'kjk', ''] 13 >>> name = "h*b*c*gh*gj*hkjhj" 14 >>> name.split('*') 15 ['h', 'b', 'c', 'gh', 'gj', 'hkjhj'] 16 >>> 17 18 #format的三种玩法 19 >>> res = '{},{},{}'.format("egon",18,"male") 20 >>> print(res) 21 egon,18,male 22 >>> res = "{1},{0},{1}".format("egon",18,"male")#中括号里面是索引 23 >>> print(res) 24 18,egon,18 25 >>> res = "{0}{1}{2}".format("egon",18,"male") 26 >>> print(res) 27 egon18male 28 >>> res = "{name} {age} {sex}".format(sex="male",name = "egon",age=18) 29 >>> print(res) 30 egon 18 male
字符串还有很多操作方法，不详细举例了，见一下代码。还有更多 的用法可以直接help（str）
1 str.startswith(prefix[,start[,end]]) #是否以prefix开头 2 str.endswith(suffix[,start[,end]]) #以suffix结尾 3 str.isalnum() #是否全是字母和数字，并至少有一个字符 4 str.isalpha() #是否全是字母，并至少有一个字符 5 str.isdigit() #是否全是数字，并至少有一个字符 6 str.isspace() #是否全是空白字符，并至少有一个字符 7 str.islower() #S中的字母是否全是小写 8 str.isupper() #S中的字母是否便是大写 9 str.istitle() #S是否是首字母大写的 #以上返回时布尔值True str.ljust(width,[fillchar]) #输出width个字符，str左对齐，不足部分用fillchar填充，默认的为空格。 str.rjust(width,[fillchar]) #右对齐 str.center(width, [fillchar]) #中间对齐 str.zfill(width) #把str变成width长，并在右对齐，不足部分用0补足 str.replace(oldstr, newstr, [count]) #把str中的oldstar替换为newstr，count为替换次数。这是替换的通用形式，还有一些函数进行特殊字符的替换 str.strip([chars]) #把str中前后chars中有的字符全部去掉，可以理解为把str前后chars替换为None str.lstrip([chars]) #把str前面的去掉 str.rstrip([chars]) #把str后面的去掉 str.expandtabs([tabsize]) #把str中的tab字符替换没空格，每个tab替换为tabsize个空格，默认是8个 str.split([sep, [maxsplit]]) #以sep为分隔符，把str分成一个list。maxsplit表示分割的次数。默认的分割符为空白字符 str.splitlines([keepends]) #把str按照行分割符分为一个list，keepends是一个bool值，如果为真每行后而会保留行分割符。 str.maketrans(from, to) #返回一个256个字符组成的翻译表，其中from中的字符被一一对应地转换成to，所以from和to必须是等长的。 str.translate(table[,deletechars]) # 使用上面的函数产后的翻译表，把S进行翻译，并把deletechars中有的字符删掉。需要注意的是，如果str为unicode字符串，那么就不支持 deletechars参数，可以使用把某个字符翻译为None的方式实现相同的功能。此外还可以使用codecs模块的功能来创建更加功能强大的翻译表。
（三），列表：
列表是常见的数据类型，用中括号[]定义，可以存多个任意类似的值，列表和字符串一样都是有序排列的，可以用切片和索引的方式访问数据，并且列表是可变数据类型。
创建一个列表
info= ["name",''age","hobbies","sex",1,2,3,"height"]本质上就是info = list(["name",''age","hobbies","sex",1,2,3,"height"])
字符串可以转换成列表，list在把字符串转换成列表的时候，会把字符串用for循环迭代一下，然后将字符串的每一个值当做list的元素。
>>> name = "alex" >>> li = list(name) >>> li ['a', 'l', 'e', 'x'] >>>
列表的基本操作有：索引（访问），切片，扩展，删除，追加，统计，长度，获取下标等。
1，访问，根据索引
1 >>> info= ["name","age","hobbies","sex",1,2,3,"height"] 2 >>> info[0]#访问列表中第一个元素 3 'name' 4 >>> info[1]#访问列表中第二个元素 5 'age' 6 >>> info[-1]#访问列表中最后一个元素 7 'height' 8 >>> info[-2]#访问列表中倒数第二个元素 9 3
2，切片
>>> info= ["name","age","hobbies","sex",1,2,3,"height"] >>> info[1:3]#取1到3之间的值，包括1不包括3，顾头不顾尾 ['age', 'hobbies'] >>> info[1:-1]#取1到最后一个之间的值 ['age', 'hobbies', 'sex', 1, 2, 3] >>> info[0:3]#取第一个到第三个之间的值 ['name', 'age', 'hobbies'] >>> info[:3]#效果同上，0可以省略掉 ['name', 'age', 'hobbies'] >>> info[3:]#取3到最后的值 ['sex', 1, 2, 3, 'height'] >>> info[1:8:2]#每隔2步取一个值，取1到8之间的值，这里的2是步长，当然也可以用3做步长，默认步长是1 ['age', 'sex', 2, 'height'] >>>
3，追加，插入，扩展
>>> info= ["name","age","hobbies","sex",1,2,3,"height"] >>> info.append("girls")#append添加默认是末尾位置 >>> info ['name', 'age', 'hobbies', 'sex', 1, 2, 3, 'height', 'girls'] >>> info.insert(1,"apple")#insert可以根据索引在指定位置添加 >>> info ['name', 'apple', 'age', 'hobbies', 'sex', 1, 2, 3, 'height', 'girls'] >>> x =["lenovo","apple","mac"] >>> info.extend(x)#extend用于在列表末尾一次性追加另一个序列中的多个值 >>> info ['name', 'apple', 'age', 'hobbies', 'sex', 1, 2,3, 'height', 'girls', 'lenovo', 'apple', 'mac'] >>>
4，修改
>>> x =["lenovo","apple","mac"] >>> x[0]="HUAWEI"#通过下标直接修改 >>> x ['HUAWEI', 'apple', 'mac'] >>>
5，删除
>>> x =["lenovo","apple","mac"] >>> del x[1]#根据下标删除 >>> x ['lenovo', 'mac'] >>> x.remove("mac")#指定元素删除 >>> x ['lenovo'] >>> x =["lenovo","apple","mac"] >>> x.pop()#删除最后一个元素 'mac' >>> x =["lenovo","apple","mac"] >>> x.pop(0)#根据下标删除，有返回值 'lenovo' >>> x =["lenovo","apple","mac"] >>> x.clear()#清除所有 >>> x []
6，统计 个数（count），长度（len）
>>> x =["lenovo","apple","mac","lenovo","boys","girls"] >>> x.count("lenovo")#统计列表中“lenovo”的个数 2 >>> x =["lenovo","apple","mac","lenovo","boys","girls"] >>> len(x)#统计列表中元素的总长度（总个数） 6
7，排序&翻转
>>> x =["lenovo","apple","mac","lenovo","boys","girls",23,"Alex","HUWEI"] >>> x[-3]="23"#不是同类型不能排序，转换成str类型 >>> x.sort()#排序顺序数字>大写>小写 >>> x ['23', 'Alex', 'apple', 'boys', 'girls', 'lenovo', 'lenovo', 'mac'] >>> x =["lenovo","apple","mac","lenovo","boys","girls","23","Alex"] >>> x.reverse()#翻转 >>> x ['Alex', '23', 'girls', 'boys', 'lenovo', 'mac', 'apple', 'lenovo']
8. 获取下标
>>> x =["lenovo","apple","mac","lenovo","boys","girls","23","Alex"] >>> x.index("lenovo")#只返回第一个元素的下标 0 >>>
还有成员运算in ，not in和字符串是一样的方法
（四）字典
字典是一种映射型的数据类型，每个元素成对出现，即key- value,每对元素key 和 value“：”冒号分开，元素之间用逗号隔开，整个字典包括子在{}中。
字典中的“key”必须是不可变类型，“value”则可以是任意类型，如果出现一个“key”被多个“value”赋值，那么值为最后一个被赋的值，字典是可变数据类型，并且是无序的。所有不可变的数据类型都可以作为字典中的key,例如数字，字符串，元祖。字典的基本操作包括 创建，增加，删除，修改，查找，遍历，更新，in or not in 等。
1，创建
#用fromkeys创建一个字典 >>> dic = ["name","age","sex"] >>> dict = dict.fromkeys(dic)#以序列dic中元素做字典的键，value为字典所有键对应的初始值 >>> dic ['name', 'age', 'sex']#value对应值为None,不显示 >>> dict = dict.fromkeys(dic,"123")#设置默认值value为“123” >>> dict {'name': '123', 'age': '123', 'sex': '123'} >>>
2,增加，删除，修改，查找
1 >>> info = {"name":"egon","age":18} 2 >>> info["sex"]="male"#直接添加 3 >>> info 4 {'name': 'egon', 'age': 18, 'sex': 'male'} 5 6 7 #这里的setdefault 如果key存在，返回已存在的值不修改，如不存在则创建,也可算作一种添加的方法吧 8 >>> info.setdefault("hobby","girls") 9 'girls' 10 >>> info 11 {'name': 'egon', 'age': 18, 'sex': 'male', 'hobby': 'girls'} 12 >>>info = {'name': 'egon', 'age': 18, 'sex': 'male', 'hobby': 'girls'} 13 >>> info.setdefault("age",20) 14 18 15 >>> info 16 {'name': 'egon', 'age': 18, 'sex': 'male', 'hobby': 'girls'} 17 >>> 18 19 20 21 #指定删除pop(),返回对应的值，并把这个值从字典中移除。 22 >>> info={'name': 'egon', 'age': 18, 'sex': 'male', 'hobby': 'girls'} 23 >>> info.pop("hobby") 24 'girls' 25 >>> info 26 {'name': 'egon', 'age': 18, 'sex': 'male'} 27 >>>>>> info.popitem()#删除任意键值对，因为字典是无序的。 28 ('sex', 'male') 29 >>> info 30 {'name': 'egon', 'age': 18} 31 >>> info.popitem() 32 ('age', 18) 33 >>> info 34 {'name': 'egon'} 35 >>> 36 37 38 39 #修改，直接修改 40 >>> info = {"name":"egon","age":18} 41 >>> info["age"]=20 42 >>> info 43 {'name': 'egon', 'age': 20} 44 >>> 45 46 47 48 #查找 49 >>> info={'name': 'egon', 'age': 20} 50 >>> "name"in info#成员运算符判断，返回布尔值 51 True 52 >>> info.get("name")#get查找字典中的key,key不存在返回默认值“None” 53 'egon' 54 >>> info["name"]#直接查找，根据“key” 55 'egon' 56 >>>
3,遍历(循环输出）
dic = {"name":"alex","age":18,"sex":"male"}
for key in dic.keys():
print(key,end=" ")
# name age sex
for value in dic.values():
print(value,end=" ")
# alex 18 male
for item in dic.items():
print(item,end=" ")
#('name', 'alex') ('age', 18) ('sex', 'male')
4，更多
>>> info = {"name":"egon","age":18,"sex":"male"}
>>> info.keys()#循环取key
dict_keys(['name', 'age', 'sex'])
>>> info.values()#循环取value
dict_values(['egon', 18, 'male'])
>>> info.items()#循环取键值对
dict_items([('name', 'egon'), ('age', 18), ('sex', 'male')])
len(dict) #计算字典元素个数
str(dict) #输出字典可打印的字符串表示，数据类型会发生改变
dict.clear() # 清空词典所有条目
>>> info = {"name":"alex"}#将字典info中的键值更新到dic
>>> dic = {"age":18}
>>> info.update(dic)
>>> info
{'name': 'alex', 'age': 18}
>>>
（五），元祖
元祖和字符串一样都是不可修改的，用（）小括号括起来，元素使用逗号隔开。注意当元祖中只有一个元素的时候，要加上逗号，不然就变成字符串了。
元祖的基本操作方法有 统计，查找，嵌套修改，切片，in ，not in，
1，统计
>>> tuple = ("alex","egon","hello","apple","alex","alex") >>> tuple.count("alex")#统计元素“alex”的个数 3 >>> len(tuple)#统计元素个数 6 >>>
2，查找
>>> tuple = ("alex","egon","hello","apple","alex","alex") >>> tuple.index("alex")#查找元素在元祖中的位置，多个重复元素只返回第一个的位置 0 >>> tuple[1]#根据索引查找元素 'egon' >>>
3,嵌套修改
#列表的元素是不可以更改的，但元素的元素就有可能是可以更改的 >>> tuple = ("alex","egon","hello","apple",["world",{"name":"lesheng"}]) >>> tuple[4].append(0) >>> tuple ('alex', 'egon', 'hello', 'apple', ['world', {'name': 'lesheng'}, 0]) >>> tuple = ("alex","egon","hello","apple",["world",{"name":"lesheng"}]) >>> tuple[4][1]["name"]="egon" >>> tuple ('alex', 'egon', 'hello', 'apple', ['world', {'name': 'egon'}]) >>>
（六）集合
集合是一个无序，不重复，每个元素必须是不可变类型的数据组合，主要作用有去重和关系运算。
a = b | c#求合集 ， union等同| a = b & c#求交集 ， intersection等同& a = b - c#求差集 ， difference等同- a = b^ c#求对称差集 symmetric_difference(求对称差集)
基本操作
s.add('x') # 添加一项 s.update([10,37,42]) # 在s中添加多项 s.remove(1) #删除一项 len(s) #set 的长度 x in s #测试 x 是否是 s 的成员 x not in s #测试 x 是否不是 s 的成员
数据类型总结：
按照存值对象分：
单个：数字，字符串
多个：列表，字典，元祖
按照可变不可变分：
可变（不可hash）： 列表，字典
不可变（可hash）：数字，字符串，元祖
按访问顺序分：
顺序访问 ： 字符串，列表，元祖（序列类型）
key访问 ： 字典 （映射类型）