python学习 day05
一、可变不可变类型
1. 可变类型：值改变，但是id不变，证明就是在改变原值，是可变类型
L =['a','b','c','d']
print(id(L))
L[0]='A' # 给列表L第一项元素重新赋值
print(L)
print(id(L))
#输出结果如下：
30237320
['A', 'b', 'c', 'd']
30237320
SRE实战 互联网时代守护先锋，助力企业售后服务体系运筹帷幄！一键直达领取阿里云限量特价优惠。
2. 不可变类型：值改变，但是id也跟着变，证明是产生了新的值，是不可变类型
x=11
print(id(x))
x=22
print(id(x))
#输出结果如下：
8791546520720
8791546521072
二、数字类型
1.整型
（1）、用途：记录年龄、等级、数量
（2）、定义方式
age = 10 # age=int(10)
（3）数据类型转换：只能将纯数字的字符串转成int
x=int('123123')
print(x,type(x)
#输出结果如下：
123123 <class 'int'>
x=int('12.3')
#输出结果如下
ValueError: invalid literal for int() with base 10: '12.3'
2.浮点型float
(1、用途：记录身高、薪资、体重
(2)、定义方式
salary = 10.1 # salary=float(10.1)
(3)数据类型转换: 只能将包含小数的字符串转成float
x=float('3.1')
print(x,type(x))
#输出结果如下：
3.1 <class 'float'>
总结；数字类型是不可变类型，同时只能存一个值
三、字符串类型
1、用途：记录描述性质的状态
2、定义方式：在单引号、双引号、三引号内包含一串字符串
msg='hello' # msg=str('hello')
小点：
数据类型转换：所有类型都可以被str转成字符串类型
res=str([1,2,3]) print(res,type(res)) #输出结果如下： [1, 2, 3] <class 'str'>
3、常用操作+内置的方法（掌握程度*****）
3.1、按索引取值(正向取+反向取) ：只能取
msg='hello' print(msg[0],type(msg[0])) #取其第一个字符，打印其的类型 print(msg[-1]) #从最后第一项索引字符 print(msg[-2]) #从最后第二项索引字符 #输出结果如下： h <class 'str'> o l msg[0]='H' # 只能取，不能用 #输出结果如下： 'str' object does not support item assignmentView Code
3.2、切片(顾头不顾尾，步长）
msg='hello world'
res=msg[0:3:1] #[0:3:1] 0代表从字符串第一位索引，3代表截止到第三位，1代表步长。
msg='hello world' res=msg[0:3:1] # 0 1 2 print(res) print(msg) #输出结果如下： hel hello world msg='hello world' res=msg[:] #不指名两端位置，默认索引全部 res=msg[::2] # 0 2 4 6 8 10，此时步长为2 print(res) #输出结果如下： hlowrd msg='hello world' res=msg[-1:-12:-1] # 代表从最后一项开始索引，步长为往左走一步 #res=msg[-1::-1] 同上 #res=msg[::-1] 同上 print(res) #输出结构如下： dlrow ollehView Code
3.3、长度len
msg='hello world'
print(len(msg))
#输出结果如下:
11 #指的是该字符串的长度，包括里面的空格
3.4、成员运算in和not in:判断一个子字符串是否存在于大字符串中；not in 代表取反
msg='kevin is dsb' print('kevin' in msg) print('b' in msg) print('aaa' not in msg) print(not 'aaa' in msg) #输出结果如下： 即只要里面含有该片段的字符，即为True True True True TrueView Code
3.5、移除空白strip: 用来去除字符串左右两边的字符，不指定默认去除的是空格
msg=' he llo ' res=msg.strip() #.strip()默认去除字符串两边的空格 print(res,id(res)) print(msg,id(msg)) #输出结果如下： he llo 31293600 #去除两边空格后的结果，中间空格没去除 he llo 31912776 #原始输出的结果，发现Id改变了，即字符串是不 可变类型 print('***+-\/***eg*on#@$*****'.strip('*+-\/#@')) print('***+-\/***eg*on#@$*****'.strip('*+-\/#$@')) #输出结果如下： eg*on#@$ #当.strip()里指定要去除的字符时，看该字符串左右是否存在 eg*on #要去除的字符，如果存在，即抹去;不存在，保留View Code
3.6、切分split：针对有规律的字符串，按照某种分隔符切成列表
info='egon:18:male' res=info.split(':') #split(self,sep,maxsplit) 即（分隔符，最大分割数 ） print(res,type(res)) # 当不知道分割数时，默认走完 print(res[0],res[1]) #输出结果如下： ['egon', '18', 'male'] <class 'list'> egon 18 cmd='get|a.txt|33333' print(cmd.split('|',1)) #此时指定分割数为1，则从左往右分割一个'|'成为 #输出结果如下： #列表即可 ['get', 'a.txt|33333']View Code
小点：将其他类型转变为字符串
用:号作连接符号将纯字符串的列表拼接成一个字符串
K=['egon', '18', 'male'] # 想达到 'egon:18:male'
res=K[0]+':'+K[1]+':'+K[2] #原始方法
res=':'.join(K) #便捷方法 #'sep'.join.(sep) 'sep'指的是分隔符，可以为空;（sep）指的是要连接的元素序列、字符串、字典、元组、列表
print(res) #即将字符串、元组、列表中的元素以指定的字符（分隔符）连接生产一个新的字符串
#输出结果如下：
egon:18:male
3.7、循环
for item in 'hello':
print(item)
#输出结果如下：
h
e
l
l
o
以下为需要掌握的操作：
1、strip,lstrip,rstrip
print('******egon***********'.strip('*')) #去除两边的‘*’ print('******egon***********'.lstrip('*')) #去除左边的'* print('******egon***********'.rstrip('*')) #去除右边的‘*’ #输出结果如下： egon egon*********** ******egon #用于移除字符串头尾指定的字符（默认为空格或换行 # 符）或字符序列。View Code
2、lower,upper，title
print('Abc123 cde'.lower()) #字符串里的字符都小写 print('Abc123 cde'.upper()) #字符串里的字符都大写 print('Abc123 cde'.title()) #字符串里的单词第一个字符大写 #输出结果如下： abc123 cde ABC123 CDE Abc123 CdeView Code
3、startswith,endswith
msg='alex is dsb' print(msg.startswith('alex')) print(msg.endswith('b')) #输出结果如下： True True #startswith() 方法用于判断字符串是否以指定前缀开头，如果 是则返回 True，否则返回 False #endswith() 方法用于判断字符串是否以指定后缀结尾，如果 是则返回True，否则返回False。View Code
4、format的三种玩法
res='my name is %s my age is %s' %('egon',18) print(res) #输出结果如下： my name is egon my age is 18 #此处是占位符的原始使用 #以下为format的使用 res = 'my name is {name} my age is {age}'.format(age=18, name='egon') print(res) #输出结果如下： my name is egon my age is 18 #了解 res='my name is {} my age is {}'.format('egon',18) print(res) #输出结果如下： my name is egon my age is 18 res='my name is {0}{1} my age is {1}{1}'.format('egon',18) print(res) #输出结果如下： my name is egon18 my age is 1818View Code
format使用拓展：
#通过位置 print '{0},{1}'.format('chuhao',20) print '{},{}'.format('chuhao',20) print '{1},{0},{1}'.format('chuhao',20) #通过关键字参数 print '{name},{age}'.format(age=18,name='chuhao') class Person: def __init__(self,name,age): self.name = name self.age = age def __str__(self): return 'This guy is {self.name},is {self.age} old'.format(self=self) print str(Person('chuhao',18)) #通过映射 list a_list = ['chuhao',20,'china'] print 'my name is {0[0]},from {0[2]},age is {0[1]}'.format(a_list) #my name is chuhao,from china,age is 20 #通过映射 dict b_dict = {'name':'chuhao','age':20,'province':'shanxi'} print 'my name is {name}, age is {age},from {province}'.format(**b_dict) #my name is chuhao, age is 20,from shanxi #填充与对齐 print '{:>8}'.format('189') # 189 print '{:0>8}'.format('189') #00000189 print '{:a>8}'.format('189') #aaaaa189 #精度与类型f #保留两位小数 print '{:.2f}'.format(321.33345) #321.33 #用来做金额的千位分隔符 print '{:,}'.format(1234567890) #1,234,567,890 #其他类型 主要就是进制了，b、d、o、x分别是二进制、十进制、八进制、十六进制。 print '{:b}'.format(18) #二进制 10010 print '{:d}'.format(18) #十进制 18 print '{:o}'.format(18) #八进制 22 print '{:x}'.format(18) #十六进制12View Code
5、split,rsplit
u="www.doiido.com" #使用默认空格符来分割 print(u.split()) #输出结果为： ['www.doiido.com'] #以‘.’为分割符 print(u.split('.')) #输出结果： ['www', 'doiido', 'com'] #分割0次 print(u.split('.',0)) #输出结果为 ['www.doiido.com'] #分割一次 print(u.split('.',1)) #输出结果为： 'www', 'doiido.com'] #分割两次 print(u.split('.'2)) #输出结果 ['www', 'doiido', 'com'] str： 表示为分隔符，默认为空格，但是不能为空('')。若字符串中没有分隔符，则把整个字符串作为列表的一个元素 num：表示分割次数。如果存在参数num，则仅分隔成 num+1 个子字符串，并且每一个子字符串可以赋给新的变量 [n]： 表示选取第n个分片 rsplit 待续View Code
6、replace
Python replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。 msg='apple appld cppld' print(msg.replace('p','q')) #输出结果 aqqle aqqld cqqld #当不指定第三个参数时，会全部替换 print(msg.replace('p','q',4)) #当指定第三个参数时，结果如下 aqqle aqqld cppld #此时只替换了4次View Code
7、isdigit
isdigit() 方法检测字符串是否只由数字组成。如果字符串只包含数字则返回 True 否则返回 False
print('123123'.isdigit()) # 如果字符串是由纯数字组成的，则返回True print('123123 '.isdigit()) #此时存在空格，返回False print('123123asdf'.isdigit()) print('12312.3'.isdigit()) #输出结果 True False False FalseView Code
了解的部分：头疼，不想看
# 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())View Code
总结：
存一个值
不可变
例如：通过索引只能取值，不能用该值，strip改变不了原始的状态。
四、列表类型
1、用途：按照位置记录多个值，索引对应值
2、定义方式：在[]内用逗号分隔开多个任意类型的值
l=['a',11,11.3,] # l=list(['a',11,11.3,])
数据类型转换:但凡能够被for循环遍历的数据类型都可以传给list，被其转换成列表
res=list('123')
print(res)
#输出结果 ['1', '2', '3']
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)) #30171848
l[0]='A'
print(l) #['A', 'b', 'c', 'd', 'e']
print(id(l)) #30171848 此时说明列表是可变类型
强调强调强调！！！:对于不存在的索引会报错
print(l[5]) # list index out of range
dic={"k1":111} #原始字典
dic['k2']=2222 #加上一个键值对
print(dic) #结果为 {'k1': 111, 'k2': 2222} 证明可存
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
print('a'not in l) #False
print(1 not in l) #True
3.5、追加与insert
l=['a','b','c','d','e']
l.append('xxx')
l.append('yyy') #append()将添加的元素加入最后一个位置
print(l) #'a', 'b', 'c', 'd', 'e', 'xxx', 'yyy']
l.insert(0,'xxxx') # 指定位置，添加
print(l) #['xxxx', 'a', 'b', 'c', 'd', 'e', 'xxx', 'yyy']
3.6、删除
del是一种通用的删除操作，没有返回值
l=['a','bbb','c','d','e']
del l[0]
print(l) #['bbb', 'c', 'd', 'e']
dic={'k1':1}
del dic['k1']
print(dic) #{} 把键删了，对应的值也消失，此时只剩下空的dict
l.remove(指定要删除的那个元素),没有返回值
l=['a','bbb','c','d','e']
res=l.remove('bbb') #删除‘bbb’,同时给res赋值
print(l) #['a', 'c', 'd', 'e']
print(res) #None res明显为空
2.pop(指定要删除的那个元素的索引),返回刚刚删掉的那个元素
l=['a','bbb','c','d','e']
l.pop(-1) #删除‘e’
res=l.pop(1) #给res赋值为l删除‘bbb’后的列表，同时自身删除'bbb'
print(l) #['a', 'c', 'd']
print(res) #bbb
3.7 循环
l=['a','b','c','d','e']
for item in l:
print(item)
#输出结果为：
a
b
c
d
e
队列与堆栈
# 队列：先进先出 堆栈:先进后出（后进先出）
# l=[] l=[]
# # 入队 入队
# l.append('first')
# l.append('second')
# l.append('third')
# print(l)
# # 出队 出队
# print(l.pop(0)) print(l(pop(-1）)
# print(l.pop(0)) print（l(pop(-1))
# print(l.pop(0)) print(l(pop(-1))
需要掌握的操作： append和extend的区别
l=['aaa','bb',345]
l.clear() #删除所有
print(l) #[]
l.append([1,2,3]) #加上集合[1,2,3]
print(l) #[[1,2,3]]
l=[1,2,3,4]
l.append([5,6,7])
print(l) #[1,2,3,4,[5,6,7]]
l=[1,2,3,4]
l.extend（[5,6,7]）
print(l) #[1,2,3,4,5,6,7]
extendextend将它的参数视为 list，extend的行为是把这两个list接到一起,append是将它的参数视为element，作为一个整体添加上去的。
append是整建制地追加，extend是个体化扩编。
append()方法使用 首先看官方文档中的描述： list.extend(L) Extend the list by appending all the items in the given list; equivalent to a[len(a):] = L. 翻译成汉语就是： 通过将所有元素追加到已知list来扩充它，相当于a[len(a):]= L 举个例子，更能明白这句话 >>> la [1, 2, 3] >>> lb ['qiwsir', 'python'] >>> la.extend(lb) >>> la [1, 2, 3, 'qiwsir', 'python'] >>> lb ['qiwsir', 'python'] 如果有两个list，一个是la，另外一个lb，将lb追加到la的后面，也就是把lb中的所有元素加入到la中， 即让la扩容。看代码 >>> la = [1,2,3] >>> b = "abc" >>> la.extend(b) >>> la [1, 2, 3, 'a', 'b', 'c'] >>> c = 5 >>> la.extend(c) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'int' object is not iterable 原来，如果extend(str)的时候，str被以字符为单位拆开，然后追加到la里面。如果extend的对象是数值型，则报错。 所以，extend的对象是一个list，如果是str，则python会先把它按照字符为单位转化为list再追加到已知list。 >>> la [1, 2, 3, 'a', 'b', 'c'] >>> lb ['qiwsir', 'python'] >>> la[len(la):]=lb >>> la [1, 2, 3, 'a', 'b', 'c', 'qiwsir', 'python'] 为什会出现输入la，运行后 [1, 2, 3, 'a', 'b', 'c', 'qiwsir', 'python'] 因为 list.extend(L) 等效于 list[len(list):] = L， L是待并入的list。 extend（）方法使用 >>> new = [1,2,3] >>> lst = ['python','qiwsir'] >>> lst.extend(new) >>> lst ['python', 'qiwsir', 1, 2, 3] >>> new [1, 2, 3] 通过extend函数，将[1,2,3]中的每个元素都拿出来，然后塞到lst里面，从而得到了一个跟原来的对象元素不一样的列表，后面的比原来的多了三个元素。 还要关注一下，从上面的演示中可以看出，lst经过extend函数操作之后，变成了一个貌似“新”的列表。这句话好像有点别扭，“貌似新”的，之所以这么说，是因为对“新的”可能有不同的理解。不妨深挖一下。 >>> new = [1,2,3] >>> id(new) 3072383244L >>> lst = ['python', 'qiwsir'] >>> id(lst) 3069501420L 用id()能够看到两个列表分别在内存中的“窝”的编号。 >>> lst.extend(new) >>> lst ['python', 'qiwsir', 1, 2, 3] >>> id(lst) 3069501420L 注意到没有？虽然lst经过extend()方法之后，比原来扩容了，但是，并没有离开原来的“窝”，也就是在内存中，还是“旧”的，只不过里面的内容增多了。相当于两口之家，经过一番云雨之后，又增加了一个小宝宝，那么这个家是“新”的还是“旧”的呢？角度不同或许说法不一了。 这就是列表的一个重要特征：列表是可以修改的。这种修改，不是复制一个新的，而是在原地进行修改。 其实，append()对列表的操作也是如此，不妨用同样的方式看看。 说明：虽然这里的lst内容和上面的一样，但是，我从新在shell中输入，所以id会变化。也就是内存分配的“窝”的编号变了。 >>> lst = ['python','qiwsir'] >>> id(lst) 3069501388L >>> lst.append(new) >>> lst ['python', 'qiwsir', [1, 2, 3]] >>> id(lst) 3069501388L 显然，append()也是原地修改列表。 如果，对于extend()，提供的不是iterable类型对象，会如何呢？ >>> lst.extend("itdiffer") >>> lst ['python', 'qiwsir', 'i', 't', 'd', 'i', 'f', 'f', 'e', 'r'] 它把一个字符串"itdiffer"转化为['i', 't', 'd', 'i', 'f', 'f', 'e', 'r']，然后将这个列表作为参数，提供给extend，并将列表中的元素塞入原来的列表中。 >>> num_lst = [1,2,3] >>> num_lst.extend(8) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'int' object is not iterable 这就报错了。错误提示中告诉我们，那个数字8，是int类型的对象，不是iterable的。 这里讲述的两个让列表扩容的函数append()和extend()。从上面的演示中，可以看到他们有相同的地方： 都是原地修改列表 既然是原地修改，就不返回值 原地修改没有返回值，就不能赋值给某个变量。 >>> one = ["good","good","study"] >>> another = one.extend(["day","day","up"]) #对于没有提供返回值的函数，如果要这样，结果是： >>> another #这样的，什么也没有得到。 >>> one ['good', 'good', 'study', 'day', 'day', 'up'] 那么两者有什么不一样呢？看下面例子： >>> lst = [1,2,3] >>> lst.append(["qiwsir","github"]) >>> lst [1, 2, 3, ['qiwsir', 'github']] #append的结果 >>> len(lst) 4 >>> lst2 = [1,2,3] >>> lst2.extend(["qiwsir","github"]) >>> lst2 [1, 2, 3, 'qiwsir', 'github'] #extend的结果 >>> len(lst2) 5 append是整建制地追加，extend是个体化扩编。 extend将它的参数视为 list，extend的行为是把这两个list接到一起，append是将它的参数视为element，作为一个整体添加上去的。 List里可以有任意的数据类型，所以，要分清这俩函数的区别。View Code
sort的使用：只有在类中中所有元素都是同种类型的情况下才能用sort排序
l=[1,3,2]
l.sort(reverse=True) #相反的是True,即从小到大打印
print(l) #[3, 2, 1]
l=['z','d','a']
l.sort()
print(l) #['a', 'd', 'z']
总结：
存多个值
有序
可变
更多精彩
