Foreword
Python data type is mainly int, float, string, list, tuple, dict, set, bool, bytes. Next int and float collectively referred to as the digital type.
1. Data Type Summary
Divided by the size of storage space occupied by (low to high)
数字
字符串
集合：无序，即无需存索引相关信息， 可变
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改Distinguished according to the number of stored-value
数字，字符串 # 标量／原子类型
列表，元组，字典，集合 # 容器类型Distinguished by the variable immutable type
列表，字典，集合 # 可变 -->不可hash
数字，字符串，元组 # 不可变-->可hash，不可变类型对象在自己的生命周期中内置有哈希值，所以可哈希的对象可以通过哈希值进行对比，也可以作为字典的键值和作为set函数的参数，可以使用__hash__()方法查看Access order to distinguish
字典 # key值访问（映射类型）
字符串，列表，元组 # 顺序访问（序列类型）2. Digital Type
#整型int
作用：年纪，等级，身份证号，qq号等整型数字相关
定义：
age=10 #本质age=int(10)
注意：使用int()进行强制类型转换时，如果对象不是纯数字，那么就会报错，比如int('11.11')
#浮点型float
作用：薪资，身高，体重，体质参数等浮点数相关
salary=3000.3 #本质salary=float(3000.3)
注意：float强制类型转换时，float('11')--》11.0
#整型、浮点型进行的运算（如果参与运算的元素有浮点型，那么结果肯定是浮点型）
print(8/3) # 除 2.6666666666666665
print(8/.2) # 除 40.0
print(8/0.2) # 除 40.0
print(8//5) # 整除 1
print(8.0//5) # 整除 1.0
print(8*3) # 乘法 24
print(8.0*3) # 乘法 24.0
print(2**3) # 次方 8
print(2.0**3) # 次方 8.0
#二进制，十进制，八进制，十六进制
#长整形（了解）
在python2中（python3中没有长整形的概念）：
>>> num=2L
>>> type(num)
<type 'long'>
#复数（了解）
>>> x=1-2j
>>> x.real
1.0
>>> x.imag
-2.0 3. string type
#作用：名字，性别，国籍，地址等描述信息
#定义：在单引号\双引号\三引号内，由一串字符组成
name='sybil'
name="sybil"
name='''sybil'''
#优先掌握的操作：
#1、按索引取值(正向取+反向取) ：只能取，索引不存在时会报错
s = 'abcd'
s[0] --> 'a'
s[-2] --> 'c'
#2、切片(顾头不顾尾，步长)
s = '01234'
s[0:3] --> '012'
s[0:300] -> '01234'#索引溢出并不会报错，而是返回字符串最大长度的值
#s[start:end:step] #start不写默认从头开始，end不写默认至到结束,setp默认为1，也可以是负数
#字符串切片同列表切片类似，当步长为正数时，start<end才能取到值；步长为负数时，start>end才能取到值;注意，如果步长<0，当start不写时，表示在结束位置（@代表start位置： 01234@）；end不写时，表示在头的位置。（@代表end位置： @01234）。(sybil的想法：实际上step<0时，将start和end的值调换，然后顾尾不顾头，之后反转即可)
print(s[:]) # 01234
print(s[0:3]) # 0123
print(s[3:]) # 34
print(s[3:3]) # ''
print(s[3:1]) # ''
print(s[0::-1]) # 0
print(s[:0:-1]) # 4321
print(s[:3:-1]) # 4
print(s[:3:1]) # 012
print(s[0:3:-1]) # ''
print(s[3:0:-1]) # 321
print(s[-4:0:-1]) # 1
#3、长度len
s = 'abcd'
len(s) #返回字符串的长度 4
#4、成员运算in和not in
s = 'abcd'
'a' in s --> True
'a' not in s --> False
#5、移除空白strip（默认是空白字符：换行、tab、空格等，可以一次指定去除多个字符）
s=' ab cd '
s.strip() --> 'ab cd' #默认是过滤左右两边的空白字符，中间的无法去除
s = '* ab#cd *#'
s.strip('* #') --> 'ab#cd' #可以指定多个要去除的字符，但同样只能去除左右两边的
#6、切分split（默认是以空白字符切分，可以使用第二个参数指定切分的次数）
s = 'sybil:18:female'
print(s.split(':')) # ['sybil', '18', 'female']
s1 = 'sybil:18:female'
print(s.split(':', 1)) # ['sybil', '18:female']
s2 = 'sybil 18 female'
print(s2.split()) # ['sybil', '18', 'female']
#7、循环
s = 'sybil'
for item in s:
print(i, end=' ') # s y b i l
#其余操作
#1、lstrip,rstrip 使用同strip一样
s = '**sy bil*#'
print(s.rstrip('*#')) # **sy bil 只去除右边的字符
print(s.lstrip('*')) # sy bil*# 只去除左边的字符
#2、lower,upper
s = 'Sybil66'
print(s.upper()) # SYBIL66 将字符串中的字母全变为大写
print(s.lower()) # sybil66 将字符串中的字母全变为小写
#3、startswith,endswith
s = 'Sybil66'
print(s.startswith('S')) # True 判断字符串是否以S开头
print(s.startswith('Sy')) # True 判断字符串是否以Sy开头
print(s.endswith('7')) # False 判断字符串是否以7结束
print(s.endswith('77')) # False 判断字符串是否以77结束
#4、format的三种玩法
res='{} {} {}'.format('egon',18,'male') # egon 18 male
res='{1} {0} {1}'.format('egon',18,'male') # 18 egon 18
# egon 18 male
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)
#5、split,rsplit 使用同split一样
s = 'sybil:18:female'
print(s.rsplit(':', 1)) # ['sybil:18', 'female']
print(s.lsplit(':', 1)) # ['sybil', 18:female']
#6、join 将列表中 的元素按指定字符拼接为字符串
res = ['sybil', '18', 'female']
print('@'.join(res)) # sybil@18@female
#7、replace 字符串中指定子序列替换为想要的元素
s = 'sybil:18:female'
print(s.replace(':', '@')) # sybil@18@female
print(s.replace(':', '@', 1)) # sybil@18:female
#1、find,rfind,index,rindex,count find同index最大的区别是index找不到会报错，而find是返回-1
s = 'onebyone'
print(s.find('n')) # 1
print(s.find('z')) # -1
print(s.rfind('n')) # 6
print(s.index('n')) # 1
print(s.rindex('n')) # 6
print(s.count('n')) # 2
#2、center,ljust,rjust,zfill
s = 'two'
print(s.center(9, '*')) # ***two***
print(s.ljust(9, '*')) # two******
print(s.rjust(9, '*')) # ******two
print(s.zfill(9)) # 000000two
#3、expandtabs 将字符串的中tab制表符以空格显示，默认tabsize=8
s = 'moon\tcake'
print(len(s.expandtabs())) # moon cake
#4、captalize,swapcase,title
s = 'moon cake'
print(s.capitalize()) # Moon cake 首字母大写
print(s.swapcase()) # MOON CAKE 大小写翻转
print(s.title()) # Moon Cake 每个单词的首字母大写
#5、is数字系列
#在python3中
num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字
#isdigt:bytes,unicode
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
#三者不能判断浮点数
num5='4.3'
print(num5.isdigit()) # False
print(num5.isdecimal()) # False
print(num5.isnumeric()) # False
#6、is其他
name = 'sybil'
print(name.isalnum()) # True 判断字符串是否只包含字母或数字
print(name.isalpha()) # True 判断字符串是否只包含字母
print(name.isidentifier()) # True 判断变量名是否合法
print(name.islower()) # True 判断字符串包含的字母是否都是小写
print(name.isupper()) # False 判断字符串包含的字母是否都是大写
print(name.isspace()) # False 判断字符串是否只由空格组成
print(name.istitle()) # False 判断是否字符串中的每个单词首字母都是大写
print('Go 23Ahead'.istitle()) # True4. List
#作用：多个装备，多个爱好，多门课程，多个女朋友等
#定义：[]内可以有多个任意类型的值，逗号分隔
fruit_list=['apple','pear'] #本质fruit_list=list([...])
l=list('abc') # ['a', 'b', 'c']
# 使用list()时，相当于for循环将可迭代对象中的值依次取出append至一个列表
l2=list({'x':1,'y':2,'z':3}) # ['x', 'y', 'z']
#优先掌握的操作：
#1、按索引存取值(正向存取+反向存取)：即可存也可以取，索引不存在时报错
l = [0, 1, 2, 3, 4, 5]
print(l[2]) # 2
print(l[-4]) # 2
l[0] = 6
print(l) # [6, 1, 2, 3, 4, 5]
#2、切片(顾头不顾尾，步长)，同字符串的切片方法一样
l = [0, 1, 2, 3, 4, 5]
print(l[::-1]) # [5, 4, 3, 2, 1, 0] 列表翻转
print(l[0:3]) # [0, 1, 2]
print(l[0::-1]) # [0]
print(l[0:4:2]) # [0, 2]
#3、长度
l = [0, 1, 2, 3, 4, 5]
print(len(l)) # 6
#4、成员运算in和not in
l = [0, 1]
print(0 in l) # True
print(0 not in l) # False
#5、追加append 会将参数当做一个值来追加至列表的末尾
l = [0, 1]
l.append(2)
l.append('abc')
l.append([3, 4])
print(l) # [0, 1, 2, 'abc', [3, 4]]
#6、追加extend
l = [1, 2]
l.extend('34') # 会将可迭代对象中的元素依次追加至列表末尾
print(l)
#7、删除 有三种方式：del remove pop clear清空列表
l = [0, 1, 2]
del l[0] # 根据索引删除值，索引不存在时报错，且没有返回值
print(l) # [1, 2]
l = [0, 1, 2, 'a']
res = l.remove('a') # 指定要删除的元素，不存在时报错
print(res) # 删除成功时返回None
print(l) # [0, 1, 2]
l = [0, 1, 2, 'a']
res = l.pop() # 默认删除列表末尾的元素，并返回删除的值
print(res, l) # a [0, 1, 2]
res2 = l.pop(0) # 可以指定索引，索引不存在时报错
print(res2, l) # 0 [1, 2]
l = [2, 1, 4]
l.clear() # 删除列表中所有元素，无返回值
print(l) # []
#8、循环
l = [1, 2, 3, 4]
for i in l:
print(i, end=' ') # 1 2 3 4
#9、insert 指定索引前插入值
l = [1, 2]
l.insert(0, 'a') # ['a', 1, 2]
print(l)
l.insert(1, 'b')
print(l)
l.insert(-1, 'c')
print(l)
#10、reverse 翻转列表
l = [2, 1, 5]
l.reverse()
print(l) # [5, 1, 2]
#11、sort 排序
l = [2, 1, 5]
l.sort() #默认升序排序
print(l) # [1, 2, 5]
l.sort(reverse=True) #降序排序
print(l) # [5, 2, 1]
#12、count 统计元素个数 index 返回元素索引，如果元素不存在则报错
l = [1, 2, 1, 2]
print(l.count(2)) # 2
print(l.index(2)) # 1
# 使用index获取索引时，使用start, stop参数时，同列表的切片使用方法一样顾头不顾尾，如果该区间内不存在想获取的元素会报错
print(l.index(2, 0, 2)) # 1
#13、copy 复制列表，不过只是值复制
l = [1, 2, 3]
l2 = l.copy()
print(l2) # [1, 2, 3]
print(l == l2) # True 这意味它们其实是同一个列表5. tuple
#作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读
#定义：与列表类型比，只不过[]换成()
age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))
t1 = tuple('hello') # ('h', 'e', 'l', 'l', 'o')
#优先掌握的操作（下列方法同列表的一样，此处不描述）：
#1、按索引取值(正向取+反向取)：只能取
#2、切片(顾头不顾尾，步长)
#3、长度
#4、成员运算in和not in
#5、循环
#6、count 统计元素个数 index 返回元素索引，如果元素不存在则报错
# 注意
#1、如果元组只有一个元素时，一定要加个逗号
t = (4)
t2 = (4, )
print(t, type(t)) # 4 <class 'int'>
print(t2, type(t2)) # (4,) <class 'tuple'>
#2、元组是不可变类型，改变他的元素时会报错，但是可以修改元素的元素
t = (1, [1, 2], 'a')
t[1][0] = '@'
print(t) # (1, ['@', 2], 'a')
6. Dictionary
#作用：存多个值,key-value存取，取值速度快
#定义：key必须是不可变类型，value可以是任意类型
info={'name':'egon','age':18,'sex':'male'} #本质info=dict({....})
或
info=dict(name='egon',age=18,sex='male')
或
info=dict([['name','egon'],('age',18)])
#优先掌握的操作：
#1、按key存取值：可存可取
dic = {'name': 'sybil', 'skill': 'fly'}
print(dic['name']) # 'sybil'
dic['skill'] = 'magic'
print(dic) # {'name': 'sybil', 'skill': 'magic'}
#字典可以使用get方法取值，如果key不存在不会报错，默认是返回None，可以自定义
dic = {'name': 'sybil', 'skill': 'fly'}
print(dic.get('age', '该Key不存在')) # 该Key不存在
dic['age'] # 直接报错
#2、长度len 返回字典中键值对的个数
dic = {'name': 'sybil', 'skill': 'fly'}
print(len(dic)) # 2
#3、成员运算in和not in 判断的都是key
dic = {'name': 'sybil', 'skill': 'fly'}
print('name' in dic) # True
print('fly' in dic) # False
#4、删除 del pop popitem
dic = {'name': 'sybil', 'skill': 'fly'}
del dic['skill'] # key不存在时会报错，没有返回值，企图print时会报语法错误
print(dic) # {'name': 'sybil'}
#pop删除key对应的value，并返回value，key不存在时报错
print(dic.pop('name')) # 'sybil'
print(dic) # {'skill': 'fly'}
# popitem随机删除一个键值对，并返回该键值对元组，如果字典为空时使用则报错
print(dic.popitem()) # ('skill', 'fly')
print(dic) # {'name': 'sybil'}
#5、键keys()，值values()，键值对items()，得到的结果是字典的一些对象，可以使用list强转或者for循环取值等
dic = {'name': 'sybil', 'skill': 'fly'}
print(dic.keys()) # dict_keys(['name', 'skill'])
print(dic.values()) # dict_values(['sybil', 'fly'])
print(dic.items()) # dict_items([('name', 'sybil'), ('skill', 'fly')])
#6、循环 默认就是取字典的key
dic = {'name': 'sybil', 'skill': 'fly'}
for k in dic:
print(k, end=' ') # name skill
#7、fromkeys 创建一个字典，第一个参数是可迭代对象，其中的的元素作为字典的key，第二个参数是所有key对应的value。
dic = {}
s = 'ab'
dic = dic.fromkeys(s, 1)
print(dic) # {'a': 1, 'b': 1}
#如果fromkeys第二个参数是可变类型：比如说列表，
#那么所有key对应的value的内存地址都一样，即共用一个列表，一个变全都变
dic = {}
l = ['name', 'skill']
dic = dic.fromkeys(l, [])
print(dic) # {'name': [], 'skill': []}
dic['name'].append('sybil')
print(dic) # {'name': ['sybil'], 'skill': ['sybil']}
#8、update与setdefault，更新字典，参数可以是字典或者是可以解压赋值出两个值的可迭代对象如：[['name', 'cc'], ['age', 18]]
#update 如果Key存在则修改对应的value，如果不存在则增加对应的key:value
dic = {'name': 'sybil', 'skill': 'fly'}
new_dic = {'name': 'cc', 'age': 18}
dic.update(new_dic)
print(dic) # {'name': 'cc', 'skill': 'fly', 'age': 18}
# setfault 如果key存在则不进行任何操作，否则增加key:value，两种情况下都会返回key对应的value
dic = {'name': 'sybil', 'skill': 'fly'}
print(dic.setdefault('name', 'cc')) # sybil
print(dic) # {'name': 'sybil', 'skill': 'fly'}
print(dic.setdefault('age', '18')) # 18
print(dic) # {'name': 'sybil', 'skill': 'fly', 'age': '18'}
7. collection
#作用：去重，关系运算，
#定义集合:
集合：在{}内用逗号分隔开的多个值
集合的元素遵循三个原则：
1：每个元素必须是不可变类型(可hash，可作为字典的key)
2: 没有重复的元素
3：无序
注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
#优先掌握的操作：
#1、长度len
s = {'a', 'b', 'c'}
print(len(s)) # 3
#2、成员运算in和not in
s = {'a', 'b', 'c'}
print('a' in s) # True
print('a' not in s) # False
#3、|合集
pythons = {'x', 'y', 'z'}
linux = {'x', 'y', 'a'}
print(pythons | linux) # {'a', 'z', 'y', 'x'}
#4、&交集
pythons = {'x', 'y', 'z'}
linux = {'x', 'y', 'a'}
print(pythons & linux) # {'y', 'x'}
#5、-差集
pythons = {'x', 'y', 'z'}
linux = {'x', 'y', 'a'}
print(pythons - linux) # {'z'}
print(linux - pythons) # {'a'}
#6、^对称差集
pythons = {'x', 'y', 'z'}
linux = {'x', 'y', 'a'}
print(pythons ^ linux) # {'z', 'a'}
#7、==
s1 = {1, 2}
s2 = {2, 1}
print(s1 == s2) # True
#8、父集：>,>=
s1 = {1, 2, 3}
s2 = {2, 1}
print(s1 > s2) # True s1是s2的子集
#9、子集：<,<=
s1 = {1, 2, 3}
s2 = {2, 1}
print(s2 < s1) # True
print(s1 <= s2) # False
#10、add与update
s = {1, 2}
s.add(3)
s.add(('a', 'b')) #类似列表的append方法，不过插入位置不定，因为是无序的
print(s) # {1, 2, 3, ('a', 'b')}
s.update('45') #类似列表的extend方法，可迭代对象中的元素必须是不可变类型，否则会报错
print(s) # {1, 2, 3, '4', '5', ('a', 'b')}
#11、删除集合的值 pop remove discard
# pop 随机删除集合的一个值，并返回该值，如果集合为空则报错
s = {1, 2, 3}
print(s.pop()) # 1
print(s) # {2, 3}
# remove 单纯的删除,返回值为None，值不存在会报错
s = {1, 2}
print(s.remove(1)) # None
print(s) # {2}
# discard 删除值，返回值为None，如果值不存在也是返回None
s = {1, 2}
print(s.discard(1)) # None
print(s.discard(4)) # 值不存在时返回None
print(s) # {2}