Python中的基本数据类型

一、数字(int): 整形，浮点

 整数类型定义的时候变量名后面直接跟数字，数字类型是不可变数据类型

>>> age = 20
>>> type(age)

>>>

数字类型的基本操作

#数字的操作类型主要在程序中起到一个判断作用
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

二、字符串（str）

定义字符串的时候需要用引号引起来,可以用单，双，三引号，三引号多表示多行字符串，这样就可以省掉“\n”换行符换行。

>>> name = "alex"
>>> type(name)

>>>

字符串的基本操作主要有：copy，拼接，查找，统计，检测，切片，大小写等。这里需要注意字符串是不可变类型，上述操作并没有改变原来的字符串，只是创建了一个新的字符串，原来的字符串任然在内存中！

1、copy 复制

a = "alex"
b = a
print(a,b)
alex alex

2、拼接

a = "alex"
b = "egon"
print(a + b)
#alexegon

这里也可以用join来实现字符串的拼接效果，可以指定连接符号如（？， —，*) 之类的，当然也可以是空格!

a = "alex"
b = "egon"
print(a.join(b))
#ealexgalexoalexn

3、查找，获取对象的下标

这里的查找是按照下标索引进行的，用到index

>>> a = 'alex'
>>> a.index('l')
1
>>> a.index('a')#返回值是0，下标是从0开始的
0
>>> a.index('A')#找不到会报错
Traceback (most recent call last):
  File "", line 1, in 
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、检测

 >>> name = "alex"#检测’l‘有没有在name里面，返回布尔值
 >>> "l"in name
 True
 >>> num = "12345678"
 >>> num.isdigit()#检测“num”是不是由整形数字组成，浮点数都不行
 True
 >>> name.isidentifier()#检测name是否可以被用来做变量名
 True
 >>> name.find("l")#检测能否从name中找到“l”,找到返回1，找不到返回-1这点和index是 有区别的
 1
 >>> name.find('N')
 -1
 >>> name.index('N')#找不到报错
 Traceback (most recent call last):
   File "", line 1, in 
 ValueError: substring not found
 >>> name.index("l")
 1
 >>>
	

7、大小写

 >>> name = "I am alex"
 >>> name.swapcase()#大小写互换
 'i AM ALEX'
 >>> name.capitalize()#首字母大写，其它都小写
 'I am alex'
 >>> name.upper()#全部大写
 'I AM ALEX'
 >>> name.lower()#全部小写
 'i am alex'
 >>>

8、移除空格“strip”，替换“replace”，分割“split，format格式化输出的三种玩法

 >>> name = "     alex"
 >>> print(name.strip())
 alex
 #replace 替换
 >>> name='alex say :i have one tesla,my name is alex'
 >>> name.replace("alex","SB",1)#替换第一个就写1
 'SB say :i have one tesla,my name is alex'
 >>>
 #split分割
 >>> name = "a*b*c*gh*kjk*"
 >>> name.split('*')#以*为分割符号
 ['a', 'b', 'c', 'gh', 'kjk', '']
 >>> name = "h*b*c*gh*gj*hkjhj"
 >>> name.split('*')
 ['h', 'b', 'c', 'gh', 'gj', 'hkjhj']
 >>>
 
 #format的三种玩法
 >>> res = '{},{},{}'.format("egon",18,"male")
 >>> print(res)
 egon,18,male
 >>> res = "{1},{0},{1}".format("egon",18,"male")#中括号里面是索引
 >>> print(res)
 18,egon,18
 >>> res = "{0}{1}{2}".format("egon",18,"male")
 >>> print(res)
 egon18male
 >>> res = "{name} {age} {sex}".format(sex="male",name = "egon",age=18)
 >>> print(res)
 egon 18 male

字符串还有很多操作方法，不详细举例了，见一下代码。还有更多 的用法可以直接help（str）

str.startswith(prefix[,start[,end]]) #是否以prefix开头 
str.endswith(suffix[,start[,end]]) #以suffix结尾 
str.isalnum() #是否全是字母和数字，并至少有一个字符 
str.isalpha() #是否全是字母，并至少有一个字符 
str.isdigit() #是否全是数字，并至少有一个字符 
str.isspace() #是否全是空白字符，并至少有一个字符 
str.islower() #S中的字母是否全是小写 
str.isupper() #S中的字母是否便是大写 
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、访问，根据索引

  >>> info= ["name","age","hobbies","sex",1,2,3,"height"]
  >>> info[0]#访问列表中第一个元素
  'name'
  >>> info[1]#访问列表中第二个元素
  'age'
  >>> info[-1]#访问列表中最后一个元素
  'height'
  >>> info[-2]#访问列表中倒数第二个元素
  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、增加，删除，修改，查找

 >>> info = {"name":"egon","age":18}
 >>> info["sex"]="male"#直接添加
 >>> info
 {'name': 'egon', 'age': 18, 'sex': 'male'}
 
 
 #这里的setdefault 如果key存在，返回已存在的值不修改，如不存在则创建,也可算作一种添加的方法吧
 >>> info.setdefault("hobby","girls")
 'girls'
 >>> info
 {'name': 'egon', 'age': 18, 'sex': 'male', 'hobby': 'girls'}
 >>>info = {'name': 'egon', 'age': 18, 'sex': 'male', 'hobby': 'girls'}
 >>> info.setdefault("age",20)
 18
 >>> info
 {'name': 'egon', 'age': 18, 'sex': 'male', 'hobby': 'girls'}
 >>>
 
 
 
 #指定删除pop(),返回对应的值，并把这个值从字典中移除。
 >>> info={'name': 'egon', 'age': 18, 'sex': 'male', 'hobby': 'girls'}
 >>> info.pop("hobby")
 'girls'
 >>> info
 {'name': 'egon', 'age': 18, 'sex': 'male'}
 >>>>>> info.popitem()#删除任意键值对，因为字典是无序的。
 ('sex', 'male')
 >>> info
 {'name': 'egon', 'age': 18}
 >>> info.popitem()
 ('age', 18)
 >>> info
 {'name': 'egon'}
 >>>
 
 
 
 #修改，直接修改
 >>> info = {"name":"egon","age":18}
 >>> info["age"]=20
 >>> info
 {'name': 'egon', 'age': 20}
 >>>
 
 
 
 #查找
 >>> info={'name': 'egon', 'age': 20}
 >>> "name"in info#成员运算符判断，返回布尔值
 True
 >>> info.get("name")#get查找字典中的key,key不存在返回默认值“None”
 'egon'
 >>> info["name"]#直接查找，根据“key”
 'egon'
 >>>

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访问  ：字典（映射类型）