数字型：

一、整型int

　　作用：年纪，等级，身份证号，qq号等整型数字相关
　　定义：age=10 #本质age=int(10)

? 数据类型转换：只能将纯数字的字符串转换成int

? 常用操作+内置的方法：普通加减乘除运算

二、浮点型float

　　作用：薪资，身高，体重，体质参数等浮点数相关

? 定义：salary=3000.3 #本质salary=float(3000.3)

? 数据类型转换：只能将带有小数点的字符串转换成float

? 常用操作+内置的方法：普通加减乘除运算

? 数字型总结：只能存一个值，并且值不可变

三、字符串

? 作用：记录描述事物性质的状态

? 定义：在单引号、双引号、三引号内，由一串字符组成

? msg=‘hello‘ # msg=str(‘hello‘)

? 数据类型转换：所有类型数据都可以被str转换成字符串类型

? 常用操作+内置的方法(背记背记背记)：

? 1、按索引取值(正向取+反向取) ：只能取（负号【-】为反向取值）

? 索引取值用【】

? msg=‘hello‘
? print(msg[0],type(msg[0]))
? print(msg[-1])
? print(msg[-2])

? # msg[0]=‘H‘ # 只能取 不能存入

? 2、切片(顾头不顾尾，步长)

? 切片也是索引故用【】

? msg=‘hello world‘
? res=msg[0:3:1] # 0 1 2 #0=起始位 3=结束位 1=步长
? print(res) #hel
? print(msg) #hello world

? res=msg[:] 默认为取全部 #hello world

? res=msg[::2] #取 0 2 4 6 8 10 步长为2 #hlowrd

? 倒序切片

? msg=‘hello world‘ -1开始数共-12位
? res=msg[-1:-12:-1] 倒序从-1开始计位 #dlrow olleh
? res=msg[-1::-1] 结束位为空默认取全部 #dlrow olleh
? res=msg[::-1] 步长为-1即默认为倒序切片 #dlrow olleh
? print(res)

? 3、长度len

? msg=‘hello world‘ 字符串中输出变量值有几个字符
? print(len(msg)) #11

? 4、成员运算in和not in：判断一个子字符串是否存在于大字符串中

? msg=‘kevin is dsb‘

? print(‘kevin‘ in msg) #True
? print(‘dsb‘ in msg) #True
? print(‘aaa‘ not in msg) #True
? print(not ‘aaa‘ in msg) #True

? 5、移除空白strip：用来去除字符串左右两边的字符，不指定默认去除的是空格

? msg=‘ he llo ‘
? res=msg.strip()
? print(res,id(res)) #he llo 1432718898040
? print(msg,id(msg)) #he llo 1432718128376

        print('******eg**on*****'.strip('*')) 去除*号 #eg**on
        print('***+-\/***egon#@$*****'.strip('*+-\/#@$')) 去除*+-\/#@$号

? name=input(‘username>>>: ‘).strip() # name=‘egon ‘ 去除无意输入得空格
? pwd=input(‘password>>>: ‘).strip() 以防止系统识别为错误

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

? 6、切分split：针对有规律的字符串，按照某种分隔符切成列表

? info=‘egon:18:male‘
? res=info.split(‘:‘) 以：为切分符号切分成列表，可加步长
? print(res,type(res)) #[‘egon‘, ‘18‘, ‘male‘] <class ‘list‘>
? print(res[0],res[1]) #egon 18

? cmd=‘get|a.txt|33333‘
? print(cmd.split(‘|‘,1)) ||||为切分点，1为切几分 # [‘get‘, ‘a.txt|33333‘]

? 用:号作连接符号将纯字符串的列表拼接成一个字符串
? l=[‘egon‘, ‘18‘, ‘male‘] # ‘egon:18:male‘
? res=l[0]+‘:‘+l[1]+‘:‘+l[2]
? res=‘:‘.join(l) jion可以代替上面一种落后得复杂代码
? print(res) #egon:18:male

? 7、循环

? for item in ‘hello‘: 每次循环输入一个字母
print(item)

需要掌握的操作

        1、strip,lstrip,rstrip
        print('******egon***********'.strip('*'))  #egon 去除所有*
        print('******egon***********'.lstrip('*')) #egon***********  去除左边*
        print('******egon***********'.rstrip('*')) #******egon 去除右边*

? 2、lower,upper
? print(‘Abc123‘.lower()) 全部变小写 #abc123
? print(‘Abc123‘.upper()) 全部变大写 #ABC123

? 3、startswith,endswith

? msg=‘alex is dsb‘
? print(msg.startswith(‘alex‘)) 从..开始 开始的字符串一一对应即可 True
? print(msg.endswith(‘b‘)) 以..结束 倒序字符串一一对应即可 True

? 4、format的三种玩法（传值）

? res=‘my name is %s my age is %s‘ %(‘egon‘,18)
? print(res) #my name is egon my age is 18

? res=‘my name is {name} my age is {age}‘.format(age=18,name=‘egon‘)
? print(res) #my name is egon my age is 18 赋值即key=value

? res=‘my name is {} my age is {}‘.format(18,‘egon‘) {}不赋值则默认顺序填充
? print(res) #my name is egon my age is 18

? 了解

? res=‘my name is {0}{1} my age is {1}{1}{1}{1}‘.format(‘egon‘,18)
? print(res) #my name is egon18 my age is 18181818

? 5、split,rsplit（切分）

        msg='a:b:c:d'
        print(msg.split(':',1)) 1为步长，左至右切分一个 #['a', 'b:c:d']

? print(msg.rsplit(‘:‘,1)) 右至左切分一个 # [‘a：b:c‘, ‘d‘]

? 6、replace（替换）

? msg=‘kevin is kevin is hahahah‘
? res=msg.replace(‘kevin‘,‘sb‘,1) 1=替换个数
? print(res) #sb is kevin is hahahah

? 7、isdigit（判断是否为纯数字）

? print(‘123123‘.isdigit()) # True 如果字符串是由纯数字组成的，则返回True
? print(‘123123 ‘.isdigit()) #Flase 出现空格
? print(‘123123asdf‘.isdigit()) #Flase 出现字母
? print(‘12312.3‘.isdigit()) #Flase 出现小数点

? score=input(‘>>>>: ‘).strip() #score=‘asdfasdfasfd‘ （举例说明求证）
? if score.isdigit():
score=int(score)

       if score >= 90:
          print('优秀')
      else:
          print('小垃圾')
    else:
        print('必须输入纯数字')

===========================字符串类型总结==============================
        只能存一个值

        有序

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

四、列表类型

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

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

? 数据类型转换:但凡能够被for循环遍历的数据类型都可以传给list，被其转换成列表
? res=list(‘hello‘) #[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘]
? res=list(123) 整型不能被转换成列表
? print(res)

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

? 3、常用操作+内置的方法

? 优先掌握的操作：
? 3.1、按索引存取值(正向存取+反向存取)：即可存也可以取
l=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
? print(l[0]) #a
? print(l[-1]) #e
? print(id(l)) #1885572047752
? l[0]=‘A‘ id改变说明可以存
print(id(l)) #2254437098376

? 强调强调强调！！！:对于不存在的索引会报错

? l[5]=‘AAAA‘

? dic={"k1":111}
? dic[‘k2‘]=2222 字典是可以添加索引的
? print(dic)

? 3.2、切片(顾头不顾尾，步长)

? l=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
? print(l[1:4]) #[‘b‘, ‘c‘, ‘d‘]
? print(l[::-1]) #[‘e‘, ‘d‘, ‘c‘, ‘b‘, ‘a‘] 列表亦可倒序切片

? 3.3、长度

? l=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
? print(len(l)) #5

? 3.4、成员运算in和not in

? l=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
? print(‘a‘ in l) True

? 3.5、append（追加）与insert（插入）

? l=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
? l.append(‘xxx‘)
? l.append(‘yyy‘)
? print(l) #‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘xxx‘, ‘yyy‘]

? l=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]

? l.insert(0,‘xxxx‘) 0=插入的位置
? print(l) #[‘xxxx‘, ‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]

? 3.6、删除（del、remove）

? l=[‘a‘,‘bbb‘,‘c‘,‘d‘,‘e‘]
? del是一种通用的删除操作，没有返回值
? del l[0] 0=删除的位置
? print(l) #[‘bbb‘, ‘c‘, ‘d‘, ‘e‘]

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

? l.remove(指定要删除的那个元素),没有返回值

? l=[‘a‘,‘bbb‘,‘c‘,‘d‘,‘e‘]
? res=l.remove(‘bbb‘)
? print(l) #[‘a‘, ‘c‘, ‘d‘, ‘e‘]
? print(res) #None

? l.pop(指定要删除的那个元素的索引),返回刚刚删掉的那个元素

? l=[‘a‘,‘bbb‘,‘c‘,‘d‘,‘e‘]
? l.pop(-1)
? res=l.pop(1)
? print(l) #[‘a‘, ‘c‘, ‘d‘]
? print(res) #bbb

? 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) #[‘first‘, ‘second‘, ‘third‘]
? 出队
? print(l.pop(0)) #first
? print(l.pop(0)) #second
? print(l.pop(0)) #third

? 堆栈：后进先出
? l=[]
? 入队
? l.append(‘first‘)
? l.append(‘second‘)
? l.append(‘third‘)
? print(l) #[‘first‘, ‘second‘, ‘third‘]
? 出队
? print(l.pop(-1)) #first
? print(l.pop(-1)) #second
? print(l.pop(-1)) #third

? 需要掌握的操作

? l=[‘aaa‘,‘bb‘,345]
? l.clear() #清除列表中的值
? l.append([1,2,3]) #在列表中追加值
? print(l) #[[1, 2, 3]]

? l=[‘aaa‘,‘bb‘,345]
? for i in [1,2,3]:
l.append(i)
? l.extend([1,2,3])
? print(i) #3
? print(l) #[‘aaa‘, ‘bb‘, 345, 1, 2, 3, 1, 2, 3]

? l.reverse():只有在类中中所有元素都是同种类型的情况下才能用sort排序

? l=[1,3,2]
? l.sort(reverse=True) sort是将类中元素从小到大排序，reverse是倒序
? print(l) #[1, 2, 3]

? l=[‘z‘,‘d‘,‘a‘]
? l.sort()
? print(l) #[‘a‘, ‘d‘, ‘z‘]

python第五天

原文：https://www.cnblogs.com/fuwei8086/p/10580817.html