基本数据类型

# int float complex
# i=10
# print(bin(i))
# print(i.bit_length())
# print(int(‘a‘,base=16))#得到其所对应的进制数
# print(int(‘0011‘,base=2))

# f=12.1
# print(f.as_integer_ratio())#(int,int)两数相除得f
# a,b=f.as_integer_ratio()
# print(a/b)
# print(f.hex())#浮点数的16进制表示
# print(f.fromhex(‘0x1.8333333333333p+3‘))
# print(f.is_integer())

# c=3+4j
# print(c.conjugate())#共轭
# print(c.real)
# print(c.imag)

#str
#索引与切片
# s=‘alexwusir‘
# print(s[0])
# print(s[-1])
# print(s[0:-1])
# print(s[1:])
# print(s[:-2])
# print(s[:])
# print(s[0:5:2])#[首:尾:步长] 顾头不顾尾
# print(s[::-1])
# print(s[4:0:-1])


# s=‘alexWusiralex‘

# print(s.capitalize())
# print(s.upper())
# print(s.lower())
# print(s.casefold())
# print(s.swapcase())

# print(s.startswith(‘a‘))
# print(s.startswith(‘a‘,1,3))
# print(s.endswith(‘x‘))
# print(s.endswith(‘x‘,4))

# print(s.find(‘e‘))
# print(s.find(‘z‘))#找不到返回-1
# print(s.index(‘e‘))
# print(s.index(‘z‘))#找不到报错ValueError

# print(s.center(20))
# print(s.center(20,‘*‘))
# print(s.ljust(20,"*"))
# print(s.rjust(20,‘*‘))
# print(s.zfill(20))

# print(s.count(‘a‘))
# print(s.count(‘a‘,2,8))
# print(s.replace(‘al‘,‘wu‘,1))


# s=‘  *alex3wusir yuan * %  ‘#各分隔(特殊字符或数字)部分首字母大写
# print(s.title())

# print(s.strip())
# print(s.strip(‘*% ‘))
# print(s.lstrip(‘ *‘))
# print(s.rstrip(‘ %*‘))

# s=‘ttalexnt‘
# print(s)
# print(s.strip())

# s=‘alex:egon:yuan:wusir‘
# print(s.split(‘:‘))
# print(s.split(‘:‘,2))#按几个指定字符分隔
# l=s.split(‘:‘)
# print(‘:‘.join(l))
# print(s.partition(‘:‘))#分割成三部分
# print(s.rpartition(‘:‘))


# s=‘alexnwusirnyuannegon‘
# print(s.splitlines(True))#按n分割,保留换行符
# print(s.splitlines(False))


# s1=‘姓名：{}，年龄：{} 爱好{}‘.format(‘alex‘,20,‘IT‘)
# s2=‘姓名：{2}，年龄：{0} 爱好{1}‘.format(20,‘IT‘,‘alex‘)
# s3=‘姓名：{name}，年龄：{age} 爱好{hobby}‘.format(name=‘alex‘,age=20,hobby=‘IT‘)
# dic={‘name‘:‘alex‘,‘age‘:20,‘hobby‘:‘IT‘}
# s4=‘姓名：{name}，年龄：{age} 爱好{hobby}‘.format(**dic)
# s5=‘姓名：{name}，年龄：{age} 爱好{hobby}‘.format_map(dic)
# s6=‘I am {:s},age {:d}‘.format(‘alex‘,20)
# s7=‘{:b},{:o},{:d},{:x},{:X},{:%}‘.format(15,15,15)
# print(s1,s2,s3,s4,s5,s6,s7,sep=‘n‘)


# s=‘alextwusir‘
# print(s.expandtabs())
# print(s.expandtabs(6))

# s=‘中国‘
# print(s.encode(‘utf-8‘))
# s1=s.encode(‘utf-8‘)
# print(s1.decode(‘utf-8‘))

# s=‘12abc28‘
# s=‘中国‘
# print(s.isalnum())#数字或字母
# print(s.isalpha())#字母,汉字

# s=‘2‘
# s=‘二‘
# s=‘②‘
# print(s.isdecimal())
# print(s.isdigit())
# print(s.isnumeric())

# s=‘This Is A Title‘
# print(s.istitle())
#
# s=‘  ‘
# print(s.isspace())

# s=‘abctbcnd‘
# print(s.isprintable())

# s=‘alexWusir‘
# print(s.islower())
# print(s.isupper())

# s=‘1234yuan‘
# print(str.maketrans(‘1234‘,‘yuan‘))#{49: 121,50: 117,51: 97,52: 110}
# m=str.maketrans(‘1234‘,‘yuan‘)
# print(s.translate(m))#yuanyuan

# s=‘def‘
# s=‘_abc‘
# print(s.isidentifier())#是否是标识符（变量，关键字等）

#range
# for i in range(1,11,2):
#     print(i)

# for i in range(10,-1,-2):
#     print(i)

# s=‘abcporndef‘
# if ‘porn‘ in s:
#     print(‘有敏感词汇‘)
#
# print(len(s))
# for i in s:
#     print(i)

#list索引与切片
# li=[‘alex‘,12,[1,2],‘yuan‘,23,True,None]#可嵌套
# print(li[0])
# print(li[-1])
# print(li[2][1])
# print(li[1:5:2])

#增 append extend insert
# li=[‘alex‘,‘LiMing‘,‘LiHua‘]
# li.append(‘wusir‘)
# li.extend([‘egon‘,‘eva_j‘])
# li.extend(‘cd‘)
# li.insert(1,‘===‘)
# print(li)

#删 pop remove clear del
# li.pop()
# s=li.pop(2)#获取删除的值
# li.remove(‘alex‘)
# li.clear()
# del li[0:4:2]
# del li

#改
# li[1]=‘12‘
# li[1]=[1,3]

#切片式修改 有多少该多少
# li[1:3]=‘china‘#
# li[1:3]=[‘c‘,‘h‘,‘i‘,‘n‘,‘a‘]
# print(li)

#查 index
# print(li.index(‘yuan‘))#找不到报错

#排序sort
# li=[30,24,56,98,34]
# li.sort()
# li.sort(reverse=True)

#反转reverse
# li.reverse()
# print(li)

#公共方法
# print(len(li))
# print(li.count(34))

#tuple索引 切片 嵌套
# t=(‘alex‘,[‘yuan‘,34],‘wusir‘)
# print(t[1])
# print(t[2][1])
# print(t[0:3:2])

# t[1]=‘wu‘#一级元素不可改
# t[2][0]=‘egon‘
# print(t)

# print(t.count(‘wusir‘))
# print(t.index(‘alex‘))

# t=(‘alex‘,‘wusir‘,‘egon‘)
# print(‘,‘.join(t))

#dict
# dic={
#     ‘name‘:‘alex‘,
#     ‘age‘:20,
#     ‘hobby‘:[‘football‘,‘basketball‘,‘IT‘],
#     True:None,
#     (1,3):‘tuple‘
# }
# print(dic)

# dic={‘name‘:‘alex‘,‘age‘:20}

#增
#没有则创建 有则覆盖
# dic[‘high‘]=170
# dic[‘age‘]=19

#没有则创建 有则不做任何操作
# dic.setdefault(‘high‘,170)
# dic.setdefault(‘age‘,19)

#删
# print(dic.pop(‘name‘))#按键删 得到键所对应的值
# print(dic.pop(‘high‘,None))#设置返回值
# print(dic.popitem())#随机删 得到元组
# dic.clear()
# del dic[‘name‘]
# del dic

#改 update
# dic[‘age‘]=19
# dic2={‘age‘:29,‘hobby‘:‘IT‘}
# dic.update(dic2)
# dic.update(age=29,hobby=‘IT‘)
# print(dic)

#查
# print(dic.keys(),type(dic.keys()))
# print(dic.values())
# print(dic.items())
# print(dic.get(‘name‘))
# print(dic.get(‘high‘,None))

# dic=dict.fromkeys([‘a‘,‘b‘],2)#为键设置统一的默认值
# print(dic)
# dic[‘a‘]=3
# print(dic)

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

# bool
# print(bool(0))
# print(bool(‘‘))
# print(bool([]))
# print(bool(()))
# print(bool({}))
# print(bool(set()))
# print(bool(None))


#() not and or
# print(2 > 1 and 1 < 4 or 2 < 3 and 9 > 6 or 2 < 4 and 3 < 2)
# print(not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6)

# print(1 or 2)
# print(0 or 2)

# print(1 and 2)
# print(0 and 2)

# print(2 or 1<3)
# print(1<3 or 2)
# print(1>3 or 2)#2

# print(2 and 1<3)
# print(1<3 and 2)
# print(1>3 and 2)#False

#set
# s={‘name‘,‘age‘,(1,2)}

#增
# s.add(‘alex‘)
# print(s)

#更新
# s.update(‘abc‘)
# print(s)

#删除
# s.remove(‘name‘)#按元素 找不到报错
# s.discard(‘name‘)#找不到 不报错
# print(s.pop())#随机删
# s.clear()
# del s

# s1={1,3,4}
# s2={3,4,5,6}
# print(s1&s2)#交集
# print(s1.intersection(s2))
# print(s1|s2)#并集
# print(s1.union(s2))
# print(s1-s2)#差集
# print(s1.difference(s2))
# print(s1^s2)#对称差 #交叉补集
# print(s1.symmetric_difference(s2))

# print(s1.isdisjoint(s2))#如果交集为空返回True

# print(s1<s2)#子集
# print(s1.issubset(s2))
# print(s2>s1)#父集
# print(s2.issuperset(s1))

#不可变集合
# s=frozenset({‘name‘,‘age‘})

ascii
gbk 中文两个字节 
unicode
utf-8 中文3个字节

while True
while 1 效率更高

join
split
find
strip
upper 
lower
replace
format
startswith


append insert extend
remove pop clear del

get update keys values items

类list 通过类创建对象
对象.方法
in操作

tuple  一般写元组的时候，推荐在最后加入,可迭代对象
join方法 将可迭代对象转化为字符串(可迭代对象是由字符串组成的)


字符串 有序 不可修改

列表 有序 可修改

元组 有序 一级元素不可改

可变数据类型 list dict set 不可哈希

不可变数据类型 int str tuple bool 可哈希

dict 键必须是可哈希(不可变数据类型)的 无序

set集合 无序 元素必须是不可变类型 

encode str-->bytes
decode bytes-->str

set去重