进制转换 
转10进制 int 2参数 value 进制参数
转进制    转2进制  bin() 
　　　　　 转8进制  oct() 
　　　　　 转16进制    hex()

id
float

定义 1.'' 　　2."" 　　3.''' 　　'''
有序
长度    len
增: 格式化  %s %d  
　　format
　　　　　　位置占位    索引占位    关键字传参
　　join    前面元素 组合后面列表各个参数
删: 去除字符 strip,lstrip,rstrip
改: 切片 split rsplit    列表
　　replace    修改对象 修改内容 修改次数默认无 从左往右
　　center    ljust    rjust    总数量 填充元素
　　zfill    
　　captalize    swapcase    title    
　　文本首字母大写    大小写转换    首字母大写
　　lower    upper
　　全小写    全大写
　　expendtabs    改变tab的占格数
查: 索引取值 []取值
　　坐标的思路
　　前2个确定范围 最后一个可添加的选择取的方向和大小
　　顾头不顾尾
　　startswith    endswith
　　find    rfind    可限定范围 找不到 -1
　　index    和find不同限定范围没找到会报错
　　count    统计出现数量
　　isdigit
　　in    not in

长度　　len
成员运算    in          not in
增:    
append    添加在最后面
insert    在指定位置添加,其他往后移
extend    数据展开后一一往后添加
删:    
del    删除索引位置对应的数据也可以删除表,没有返回值
remove    删除指定元素没没有返回值
pop    默认删除最后一个,但会有返回值
        也可以以索引为指定依据
改:    列表对象[索引]=
查:    for循环迭代 
索引取值 []取值
坐标的思路
前2个确定范围 最后一个可添加的选择取的方向和大小
顾头不顾尾

一：基本使用：tuple1 用途：记录多个值，当多个值没有改的需求，此时用元组更合适

2 定义方式：在()内用逗号分隔开多个任意类型的值
t=(1,1.3,'xx',('a','b'),[1,2]) #t=tuple((1,1.3,'xx',('a','b'),[1,2]))
print(t,type(t))
t1=tuple('hello')
print(t1)

3 常用操作+内置的方法
#优先掌握的操作：1、按索引取值(正向取+反向取)：只能取
t=('egon',123,['a','b'])
print(id(t[0]))
print(id(t[1]))
print(id(t[2]))

t[2][0]='A'
print('='*50)
print(id(t[0]))
print(id(t[1]))
print(id(t[2]))
t[0]='EGON'

t[2]='xxxx'
t[2][0]='A'
print(t)

2、切片(顾头不顾尾，步长)
t=(1,2,3,4,5)
print(t[0:3])
print(t)

3、长度

4、成员运算in和not in

5、循环
for item in ('a','b','c'):
    print(item)

需要掌握的操作
t=('a','b','c','a')
print(t.count('a'))
print(t.index('a',1,10))
print(t.index('xxx',1,10))

二：该类型总结1 存多个值2 有序3 不可变

不可变类型=》可hash类型
可变类型 =》不可以hash类型

一：基本使用dict
1 用途：记录多个值，每一个值都对应的key用来描述value的作用
 2 定义方式：在{}内用逗号分隔开多 个key:value，其中value可以是任意类型，而key必须是不可变的类型，通常情况下应该str类型
dic={0:'aaa',1:'bbb',2:'cccc'} # dic=dict({0:'aaa',1:'bbb',2:'cccc'})
print(dic,type(dic))
print(dic[0])

dic={[1,2]:'aaa'}
dic={(1,2):'aaa'}
print(dic[(1,2)])

# 用法一：
dic=dict(x=1,y=2,z=3)
print(dic)

# 用法二：
userinfo=[
['name','egon'],
['age',18],
['sex','male']
]
d={}
for k,v in userinfo: # k,v=['name', 'egon']
# print(k,v)
d[k]=v
print(d)

# d=dict(userinfo)
# print(d)

# 3 常用操作+内置的方法
#优先掌握的操作：
#1、按key存取值：可存可取
dic={'name':'egon'}
print(dic['name'])
dic['name']='EGON'
print(dic)
dic['age']=18
print(dic)

#2、长度len
dic={'name':'egon','age':18,'name':'EGON','name':'XXXX'}
print(dic)
print(len(dic))

#3、成员运算in和not in:字典的成员运算判断的是key
dic={'name':'egon','age':18,}
print(18 in dic)
print('age' in dic)

#4、删除
dic={'name':'egon','age':18,}
# 通用
del dic['name']
print(dic)
del dic['xxx'] ##key不存在则报错


res=dic.pop('age') #删除key对应的value,并返回value
print(dic)
print(res) #
dic.pop('xxx') #key不存在则报错

res=dic.popitem()
print(dic)
print(res)

#5、键keys()，值values()，键值对items() 注意python2与python3之间的区别
dic={'name':'egon','age':18,}
print(dic.keys())
l=[]
for k in dic.keys():
l.append(k)
print(l)
print(list(dic.keys()))
print(dic.values())
print(list(dic.values()))
print(dic.items())
print(list(dic.items()))

 

#6、循环
dic={'name':'egon','age':18,'sex':'male'}

for k in dic.keys():
print(k,dic[k])

for k in dic:
print(k,dic[k])

for v in dic.values():
print(v)

for k,v in dic.items():
print(k,v)

#8 dic.get()
dic={'name':'egon','age':18,'sex':'male'}
dic['xxx']
v=dic.get('name')
print(v)

v=dic.get('xxx')
print(v)

# 需要掌握的操作

#dic.fromkeys()的用法:
l=['name','age','sex']
dic={'name':None,'age':None,'sex':None}
dic={}
for k in l:
dic[k]=None
print(dic)

dic=dic.fromkeys(l,None)
print(dic)

old_dic={'name':'egon','age':18,'sex':'male'}
new_dic={'name':'EGON','x':1,'y':2}
old_dic.update(new_dic)
print(old_dic)

# setdefault:有则不动/返回原值,无则添加/返回新值
dic={'name':'egon','age':18}
res=dic.setdefault('name','EGON') # 字典中已经存在key则不修改,返回已经存在的key对应的value
print(dic)
print(res)

res=dic.setdefault('sex','male') # 字典不存在key则添加"sex":"male",返回新的value
print(dic)
print(res)

# update:把字典dict2的键/值对更新到dict里

dict = {'Name': 'Zara', 'Age': 7}
dict2 = {'Sex': 'female' }
dict.update(dict2)
print "Value : %s" %  dict

以上实例输出结果为：

Value : {'Age': 7, 'Name': 'Zara', 'Sex': 'female'}

二：该类型总结
1 存多个值
2 无序
3 可变

一：基本使用:set1 用途: 关系运算,去重2 定义方式: 在{}内用逗号分开个的多个值集合的三大特性:2.1 每一个值都必须是不可变类型2.2 元素不能重复2.3 集合内元素无序

s={1,3.1,'aa',(1,23),} # s=set({1,3.1,'aa',(1,23),})
print(s,type(s))

s={1,1,1,1,1,1,1,1,1,2,3}
print(s)

s={'a','b','c'}
s[0]

s=set('hello')
print(s)
print(set(['a','b','c',[1,2]]))

3 常用操作+内置的方法
pythons={'李二丫','张金蛋','李银弹','赵铜蛋','张锡蛋','alex','oldboy'}
linuxs={'lxx','egon','张金蛋','张锡蛋','alex','陈独秀'}
取及报名python课程又报名linux课程的学员:交集
print(pythons & linuxs)
print(pythons.intersection(linuxs))

取所有报名老男孩课程的学员:并集
print(pythons | linuxs)
print(pythons.union(linuxs))

取只报名python课程的学员: 差集
print(pythons - linuxs)
print(pythons.difference(linuxs))

取只报名linux课程的学员: 差集
print(linuxs - pythons)
print(linuxs.difference(pythons))

取没有同时报名两门课程的学员:对称差集
print(pythons ^ linuxs)
print(pythons.symmetric_difference(linuxs))

是否相等
s1={1,2,3}
s2={3,1,2}
print(s1 == s2)

父集:一个集合是包含另外一个集合
s1={1,2,3}
s2={1,2}
print(s1 >= s2)
print(s1.issuperset(s2))

s1={1,2,3}
s2={1,2,4}
print(s1 >= s2)

子集
s1={1,2,3}
s2={1,2}
print(s2 <= s1)
print(s2.issubset(s1))

需要掌握操作
s1={1,2,3}
s1.update({3,4,5})
print(s1)

s1={1,2,3}
res=s1.pop()
print(res)

s1={1,2,3}
res=s1.remove(3) #单纯的删除,返回值为None
print(s1)

s1={1,2,3}
s1.add(4)
print(s1)

s1={1,2,3}
s2={1,2}
s1.difference_update(s2) #s1=s1.difference(s2)
print(s1)

s1={1,2,3}
res=s1.discard(3) ##单纯的删除,返回值为None
print(s1)
print(res)
s1.remove(444444) #删除的元素不存在则报错
s1.discard(444444) #删除的元素不存在不会报错


s1={1,2,3}
s2={1,2,4}
print(s1.isdisjoint(s2)) #如果两个集合没有交集则返回True

s1={1,2,3}
s2={4,5,6}
print(s1.isdisjoint(s2)) #如果两个集合没有交集则返回True

二：该类型总结1 存多个值2 无序3 set可变
s={1,2,3}
print(id(s))
s.add(4)
print(id(s))

集合去重局限性1、无法保证原数据类型的顺序2、当某一个数据中包含的多个值全部为不可变的类型时才能用集合去重