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

 

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、按索引取值(正向取+反向取) :只能取
python学习 day05
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 assignment
View Code
3.2、切片(顾头不顾尾,步长)
msg='hello world'
res=msg[0:3:1] #[0:3:1] 0代表从字符串第一位索引,3代表截止到第三位,1代表步长。
python学习 day05
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 olleh
View Code
3.3、长度len
msg='hello world'
print(len(msg))
#输出结果如下:
11 #指的是该字符串的长度,包括里面的空格

3.4、成员运算in和not in:判断一个子字符串是否存在于大字符串中;not in 代表取反
python学习 day05
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
True
View Code
3.5、移除空白strip: 用来去除字符串左右两边的字符,不指定默认去除的是空格
python学习 day05
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:针对有规律的字符串,按照某种分隔符切成列表
python学习 day05
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
python学习 day05
print('******egon***********'.strip('*'))   #去除两边的‘*’
print('******egon***********'.lstrip('*'))   #去除左边的'*
print('******egon***********'.rstrip('*'))  #去除右边的‘*’
#输出结果如下:        
egon
egon***********
******egon          #用于移除字符串头尾指定的字符(默认为空格或换行
                             #   符)或字符序列。
View Code
2、lower,upper,title
python学习 day05
print('Abc123 cde'.lower())    #字符串里的字符都小写
print('Abc123 cde'.upper())   #字符串里的字符都大写
print('Abc123 cde'.title())      #字符串里的单词第一个字符大写
#输出结果如下:
abc123 cde
ABC123 CDE
Abc123 Cde     
View Code
3、startswith,endswith
python学习 day05
msg='alex is dsb'
print(msg.startswith('alex'))
print(msg.endswith('b'))
#输出结果如下: 
True       
True             #startswith() 方法用于判断字符串是否以指定前缀开头,如果
                      是则返回 True,否则返回 False
                   #endswith() 方法用于判断字符串是否以指定后缀结尾,如果
                      是则返回True,否则返回False。
View Code
4、format的三种玩法
python学习 day05
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 1818
View Code

format使用拓展:

python学习 day05
#通过位置
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) #十六进制12
View Code
5、split,rsplit
python学习 day05
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学习 day05
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
python学习 day05
print('123123'.isdigit()) # 如果字符串是由纯数字组成的,则返回True
print('123123  '.isdigit())     #此时存在空格,返回False
print('123123asdf'.isdigit())
print('12312.3'.isdigit())
#输出结果
True
False
False
False
View Code

 

 

了解的部分:头疼,不想看

python学习 day05
# 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是个体化扩编。
python学习 day05
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']

总结:
存多个值

有序

可变









































 

 






































































































































  

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

  

 

 

上一篇:JAVAEE学习day05学习,数组


下一篇:python学习day05