知识点概要：

一、变量值的可变不可变类型
不可变：数字型，字符串型
可变：列表，字典

二、字符串的相关操作
1、字符串是有索引的，可以按照字符串来实现正取和反取，只能取，不能改
2、切片：str[起始:末尾:步长] 顾头不顾尾 ；正切，反切
3、len()方法
4、成员运算 in 与 not in
5、strip()方法 rstrip()方法 lstrip()方法
6、切分split：针对有规律的字符串，按照某种分隔符切成列表
rsplit 从右边开始
7、format的3种玩法：
'{name} is {what} is {how}'.format(name='aa',what='bb',how='cc')
'{} is {} is {}'.format('adf','bb','cc')
'{1} is {1} is {0} {1}'.format('aa','bb')
8、循环 for i in str:
print(i)
9、lower() upper() 方法，转化为小写、大写
10、stratswith 与 endswith 用来判断字符串是否以什么开头、结尾
11、replace方法 replace(old, new , count)
12、isdigital方法 如果字符串是由纯数字组成的，则返回True
13、find,rfind,index,rindex,count
14、center,ljust,rjust,zfill
15、captalize,swapcase,title
16、isdigit isdecimal isnumeric
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成

二、列表
1、按索引存取值(正向存取+反向存取)：即可存也可以取， 强调强调强调！！！:对于不存在的索引会报错
2、切片(顾头不顾尾，步长)
3、长度
4、成员运算in和not in

5、追加 append() insert()
6、删除 del pop() remove()
l.remove(指定要删除的那个元素),没有返回值
l.pop(指定要删除的那个元素的索引),返回刚刚删掉的那个元素
7、循环 for
8、extend()方法

字符串

# ======================================基本使用======================================
# 1、用途：记录描述性质的状态

# 2、定义方式：在单引号、双引号、三引号内包含一串字符串
msg='hello' # msg=str('hello')

# 数据类型转换：所有类型都可以被str转成字符串类型
# res=str([1,2,3])
# print(res,type(res))

# 3、常用操作+内置的方法
#优先掌握的操作：(*****)
#3.1、按索引取值(正向取+反向取) ：只能取
# msg='hello'
# print(msg[0],type(msg[0]))
# print(msg[-1])
# print(msg[-2])
s
# msg[0]='H' # 只能取

#3.2、切片(顾头不顾尾，步长)
# msg='hello world'
# res=msg[0:3:1] # 0 1 2
# print(res)
# print(msg)

# res=msg[:]
# res=msg[::2] # 0 2 4 6 8 10
# print(res)

msg='hello world'
# res=msg[-1:-12:-1]
# res=msg[-1::-1]
res=msg[::-1]
# print(res)

#3.3、长度len
# msg='hello world'
# print(len(msg))

#3.4、成员运算in和not in:判断一个子字符串是否存在于大字符串中
msg='kevin is dsb'

# print('kevin' in msg)
# print('dsb' in msg)
# print('aaa' not in msg)
# print(not 'aaa' in msg)

#3.5、移除空白strip: 用来去除字符串左右两边的字符，不指定默认去除的是空格
# msg=' he llo '
# res=msg.strip()
# print(res,id(res))
# print(msg,id(msg))

# print('******eg**on*****'.strip('*'))

# print('***+-\/***egon#@$*****'.strip('*+-\/#@$'))

# name=input('username>>>: ').strip() # name='egon '
# pwd=input('password>>>: ').strip()

# if name == 'egon' and pwd == '123':
# print('login successful')
# else:
# print('输错了。。。')

#3.6、切分split：针对有规律的字符串，按照某种分隔符切成列表
info='egon:18:male'
# res=info.split(':')
# print(res,type(res))
# print(res[0],res[1])

# cmd='get|a.txt|33333'
# print(cmd.split('|',1))

# 用:号作连接符号将纯字符串的列表拼接成一个字符串
l=['egon', '18', 'male'] # 'egon:18:male'
# res=l[0]+':'+l[1]+':'+l[2]
res=':'.join(l)
# print(res)

#3.7、循环
# for item in 'hello':
# print(item)

#需要掌握的操作
#1、strip,lstrip,rstrip
# print('******egon***********'.strip('*'))
# print('******egon***********'.lstrip('*'))
# print('******egon***********'.rstrip('*'))

#2、lower,upper
# print('Abc123'.lower())
# print('Abc123'.upper())

#3、startswith,endswith
# msg='alex is dsb'
# print(msg.startswith('alex'))
# print(msg.endswith('b'))

#4、format的三种玩法
# res='my name is %s my age is %s' %('egon',18)
# print(res)

# res='my name is {name} my age is {age}'.format(age=18,name='egon')
# print(res)

# 了解
# res='my name is {} my age is {}'.format('egon',18)
# res='my name is {0}{1} my age is {1}{1}{1}{1}'.format('egon',18)
# print(res)

#5、split,rsplit
# msg='a:b:c:d'
# print(msg.split(':',1))
# print(msg.rsplit(':',1))

#6、replace
# msg='kevin is kevin is hahahah'
# res=msg.replace('kevin','sb',1)
# print(res)

#7、isdigit
# print('123123'.isdigit()) # 如果字符串是由纯数字组成的，则返回True
# print('123123 '.isdigit())
# print('123123asdf'.isdigit())
# print('12312.3'.isdigit())

# score=input('>>>>: ').strip() #score='asdfasdfasfd'
# if score.isdigit():
# score=int(score)
#
# if score >= 90:
# print('优秀')
# else:
# print('小垃圾')
# else:
# print('必须输入纯数字')

# 了解的操作
#1、find,rfind,index,rindex,count
# print('123 ke123ke'.find('ke'))
# print('123 ke123ke'.rfind('ke'))
# print('123 ke123ke'.index('ke'))
# print('123 ke123ke'.rindex('ke'))

# print('123 ke123ke'.find('xxxx'))
# print('123 ke123ke'.index('xxxx'))
# print('123 ke123ke'.count('ke',0,6))

#2、center,ljust,rjust,zfill
# print('egon'.center(50,'*'))
# print('egon'.ljust(50,'*'))
# print('egon'.rjust(50,'*'))

# print('egon'.rjust(50,'0'))
# print('egon'.zfill(50))

#3、captalize,swapcase,title
# print('abcdef dddddd'.capitalize())
# print('abcAef dddddd'.swapcase())
# print('abcAef dddddd'.title())

#4、is数字系列
num1=b'4' #bytes
num2='4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字

# bytes与阿拉伯数字组成的字符串
# print(num1.isdigit())
# print(num2.isdigit())
# print(num3.isdigit())
# print(num4.isdigit())

# 阿拉伯数字组成的字符串
# print(num2.isdecimal())
# print(num3.isdecimal())
# print(num4.isdecimal())

# 阿拉伯数字\中文\罗马组成的字符串
# print(num2.isnumeric())
# print(num3.isnumeric())
# print(num4.isnumeric())

#5、is其他

# ======================================该类型总结====================================
# 存一个值

# 有序

# 不可变
# msg=' hello '
# msg.strip()
# print(msg)

列表

# ======================================基本使用======================================
# 1、用途：按照位置记录多个值，索引对应值

# 2、定义方式：在[]内用逗号分隔开多个任意类型的值
l=['a',11,11.3,] # l=list(['a',11,11.3,])

# 数据类型转换:但凡能够被for循环遍历的数据类型都可以传给list，被其转换成列表
# res=list('hello')
# res=list(123)
# print(res)

# res=list({'a':1,'b':2,'c':3}) # []
# print(res)

# 3、常用操作+内置的方法
#优先掌握的操作：
#3.1、按索引存取值(正向存取+反向存取)：即可存也可以取
l=['a','b','c','d','e']
# print(l[0])
# print(l[-1])
# print(id(l))
# l[0]='A'
# print(id(l))

# 强调强调强调！！！:对于不存在的索引会报错
# l[5]='AAAA'

# dic={"k1":111}
# dic['k2']=2222
# print(dic)

#3.2、切片(顾头不顾尾，步长)
# l=['a','b','c','d','e']
# print(l[1:4])
# print(l[::-1])

#3.3、长度
# l=['a','b','c','d','e']
# print(len(l))

#3.4、成员运算in和not in
# l=['a','b','c','d','e']
# print('a' in l)

#3.5、追加与insert
# l=['a','b','c','d','e']
# l.append('xxx')
# l.append('yyy')
# print(l)

# l.insert(0,'xxxx')
# print(l)

#3.6、删除
l=['a','bbb','c','d','e']

# del是一种通用的删除操作，没有返回值
# del l[0]
# print(l)

# dic={'k1':1}
# del dic['k1']
# print(dic)

# l.remove(指定要删除的那个元素),没有返回值
# res=l.remove('bbb')
# print(l)
# print(res)

# l.pop(指定要删除的那个元素的索引),返回刚刚删掉的那个元素
# l=['a','bbb','c','d','e']
# l.pop(-1)
# res=l.pop(1)
# print(l)
# print(res)

#3.7、循环
# l=['a','b','c','d','e']
# for item in l:
# print(item)

# 练习：
# 队列：先进先出
# l=[]
# # 入队
# l.append('first')
# l.append('second')
# l.append('third')
# print(l)
# # 出队
# print(l.pop(0))
# print(l.pop(0))
# print(l.pop(0))

# 堆栈：后进先出

# 需要掌握的操作
l=['aaa','bb',345]
# l.clear()
# l.append([1,2,3])

# for i in [1,2,3]:
# l.append(i)
# l.extend([1,2,3])

# l.reverse()

# 只有在类中中所有元素都是同种类型的情况下才能用sort排序
# l=[1,3,2]
# l.sort(reverse=True)

l=['z','d','a']
l.sort()
print(l)

# ======================================该类型总结====================================
# 存多个值

# 有序

# 可变