一、列表
因为Python中没有数据类型,所有Python中没有标准意义上的数组。列表就是Python中加强版的数组,可以存储各种类型的数据。
列表的索引操作类似数组,如list[0][0]列表同样适用
(一)创建列表
member=['a','b','c','d']
创建元素复杂的列表
member=['a',123,3.14,['c','d']]
创建空列表
empty=[]
(二)向列表中添加元素
member.append(元素)方法添加元素,每次只能添加一个
member.extend(列表)方法扩展列表,每次添加的是一个列表,本质是将两个列表合并为一个列表
member=['a',123,3.14,['c','d']]
member.extend([123,456])
member.insert(索引,元素)方法插入元素,在列表的一个位置插入元素,索引是从0开始的
(三)从列表删除元素
member.remove(元素)方法删除,不需要知道元素在哪个位置,删除搜索到的第一个。不存在的话会报错。
del member[1]函数,del不是member的内部方法,像是一个释放内存的析构函数,可以用del member直接删除整个列表
member.pop()方法,弹出member列表中的最后一个元素。列表长度-1,最后一个元素被删除,有返回值。
(四)列表分片Slice
利用索引值,每次我们可以从列表获取一个元素,但是我们总是贪心的,如果一次性需要获取多个元素,有没有办法实现呢?利用列表分片,我们可以简单的实现这个要求。
>>> member=['a','b','c','d','e']
>>> member[1:3]
输出:['b', 'c']
分片是对原列表一部分的复制而不是剪切,分片产生的新列表不会影响原列表。
分片可以简写,从0开始的话,可以写成member[:3],到结尾的话可以写成member[1:]。
用member[:]可以获得对原列表的一个拷贝,产生的新列表与原列表无关。
如果直接使用list1=list2,则list1只是对list2产生了一个索引值,指向同一块内存。list1会随着list2的变化而变化。
(五)列表的操作符
1、比较运算符
列表可以进行大小的比较
>>> a=[1,2,3]
>>> b=[0]
>>> a>b
True
>>> list1=[123]
>>> list2=[234]
>>> list1>list2
False
2、+号运算符
列表可以用+号拼接,相当于extend()方法。但是建议使用extend()方法使代码更规范。但是直接用+添加元素是违规的,如:
>>> list1+'1'
Traceback (most recent call last):
File "<pyshell#9>", line 1, in <module>
list1+'1'
TypeError: can only concatenate list (not "str") to list
因为+号两边的数据类型要一致,在程序中+号一边是列表,一边是字符串,所以不能添加,可以改为list1+['1'],类似extend()
3、*乘号运算符
用list1*3会输出三次list1
>>> list1=['a','b','c']
>>> list1*3
['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']
>>> list1
['a', 'b', 'c']
用list1*=3,会将list1扩展三倍
>>> list1=['a','b','c']
>>> list1*=3
>>> list1
['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']
4、in判断元素是否在列表内
>>> list1=[1,2,3,4,5]
>>> 3 in list1
True
>>> 6 not in list1
True
但是in只能判断列表的第一层,不能深入,如下:
>>> list2=[1,2,3,[4,5]]
>>> 4 in list2
False
因为4是在列表中的列表中,所以无法判断,in只能判断一层列表。
(六)列表的内置函数
使用dir(list)命令就可以查看列表的所有内置函数
member.count(元素)方法,统计元素在member中出现了几次。
member.index(元素)方法,该元素出现的第一个位置;member.index(元素,起始位置,结束位置),在区间里搜索元素存在的位置。
member.reverse()方法,没有参数,翻转列表。
member.sort()方法,对列表进行排序。默认是从小到大排序。member.sort(func,key,reverse),func指定排序算法,key是和算法搭配的关键字,reverse是指定排序顺序。reverse=True,为从大到小排序。
二、元组
元组是限制了权限的列表。因为列表的自由度太高。元组中的内容是不可变的,也是不可以随意删除和排序的。除了元组不能改变,其他的方法元组和列表完全一样。
(一)创建和使用一个元组
因为元组是加了限制的列表,所以两者的使用方法很相似
>>> tuple1=(1,2,3,4,5,6,7,8)
>>> tuple1[1]
2
>>> tuple1[:5]
(1, 2, 3, 4, 5)
>>> tuple2=tuple1[:]
>>> tuple2
(1, 2, 3, 4, 5, 6, 7, 8)
元组内容不可变,改变元组的元素的值会报错
>>> tuple1[1]=5
Traceback (most recent call last):
File "<pyshell#11>", line 1, in <module>
tuple1[1]=5
TypeError: 'tuple' object does not support item assignment
创建元组的关键是","而不是(),如下,用括号创建的元素并不是元组类型而是整型
>>> temp=(1)
>>> type(temp)
<class 'int'>
正确的创建方法如下,逗号才是关键
>>> temp=1,2,3
>>> type(temp)
<class 'tuple'>
创建只有一个元素的元组,一定要在后面加上逗号,如type=(1,)或者type=1,才会是一个元组
创建一个空元组temp=()
temp=()
(二)更新和删除一个元组
1、更新元组
要想在元组中插入一个新的元素就需要重新构造一个元组,如下:
>>> temp=('a','b','d','e')
>>> temp=temp[:2]+('c',)+temp[2:]
>>> temp
('a', 'b', 'c', 'd', 'e')
实际上temp已经指向了一个新的元组,以前的元组没有指向了,一段时间后Python的回收机制会自动销毁没有指向的数组的内存。注意:在第二行中('c',)中的逗号一定不能忘。逗号表明它是一个元组。
2、删除元组
像列表一样删除一个元组中的元素是不可能的,可以像上面的方法那样删除一个元组的元素。
可以直接删除一个元组用del temp,Python中有回收机制会自动回收内存,一般不用手动释放删除整个元组。
三、字符串
字符串类似于元组,它一旦定义好了,元素不能修改。字符串的操作和元组是一样的
(一)字符串的常用操作函数
capitalize() | 把字符串的第一个字符改为大写 |
casefold() | 把整个字符串的所有字符改为小写 |
center(width) | 将字符串居中,并使用空格填充至长度width的新字符串 |
count(sub[,start[,end]]) | 返回sub在字符串里边出现的次数,start和end参数表示范围,可选。 |
encode(encoding='utf-8',errors='strict') | 以encoding指定的编码格式对字符串进行编码。 |
endswith(sub[,start[,end]]) | 检查字符串是否以sub子字符串结束,如果是返回True,否则返回False.start和end参数表示范围,可选。 |
expandtabs([tabsize=8]) | 把字符串中的tab符号(\t )转换为空格,如不指定参数,默认的空格数是tabsize=8。 |
find(sub[,start[,end]]) | 检测sub是否包含在字符串中,如果有则返回索引值,否则返回-1,start和end参数表示范围,可选。 |
index(sub[,start[,end]]) | 跟find方法一样,不过如果sub不在string中会产生一个异常。 |
isalnum() | 如果字符串至少有一个字符并且所有字符都是字母或数字则返回True ,否则返回False. |
isalpha() | 如果字符串至少有一个字符并且所有字符都是字母则返回True,香则返回False. |
isdecimal() | 如果字符串只包含十进制数则返回True,否则返回False. |
isdigit() | 如果字符串只包含数字则返回True,否则返回False. |
islower() | 如果字符串中至少包含一个区分大小写的字符,并且这些字符都是小写,则返回True,否则返回False. |
isnumeric() | 如果字符串中只包含数字字符,则返回True,否则返回False. |
isspace() | 如果字符串中只包含空格,则返回True,否则返回False。 |
istitle() | 如果字符串是标题化(所有的单词都是以大写开始,其余字母均小写),则返回True,否则返回False。 |
isupper() | 如果字符串中至少包含一个区分大小写的字符,并且这些字符都是大写,则返回True,否则返回False。 |
join(sub) | 以字符串作为分隔符,插入到sub中所有的字符之间。 |
ljust(width) | 返回一个左对齐的字符串,并使用空格填充至长度为width的新字符串。 |
lower() | 传换字符串中所有大写字符为小写。 |
lstrip() | 去掉字符串左边的所有空格 |
partition(sub) | 找到子字符串sub,把字符串分成一个3元组( pre_sub,sub,fol_sub ),如果宁符串中不包含sub则返回(‘原字符串”, , ) |
replace(old,new[,count]) | 把字符串中的old子字符串替换成new子字符串,如果count指定,则替换不超过count次。 |
rfind(sub[,startt[,end]]) | 类似于find0方法,不过是从右边开始查找。 |
rindex(sub[,start[,end]]) | 类似于index()方法,不过是从右边开始。 |
rjust(width) | 返回一个右对齐的字符串,并使用空格填充至长度为width的新字符串。 |
rpartition(sub) | 类似于partition()方法,不过是从右边开始查找。 |
rstrip() | 删除字符串末尾的空格。 |
split(sep=None, maxsplit=-1) | 不带参数默认是以空格为分隔符切片字符串,如果maxsplit参数有设置,则仅分隔maxsplit个子字符串,返回切片后的子字符串拼接的列表。 |
splitlines(([keepends])) | 按照‘\n’分隔,返回一个包含各行作为元素的列表,如果keepends参数指定,则返回前keepends行。 |
startswith(prefix[,start[,end]]) | 检查字符串是否以prefix开头,是则返回True,否则返回False。start和end参数可以指定范围检查,可选。 |
strip([chars]) | 删除字符串前边和后边所有的空格,chars参数可以定制删除的字符,可选。 |
swapcase() | 翻转字符串中的大小写。 |
title() | 返回标题化(所有的单词都是以大写开始,其余字母均小写)的字符串。 |
translate(table) | 根据table的规则(可以由str.maketrans(‘a’,‘b’)定制)转换字符串中的字符。 |
upper() | 转换字符串中的所有小写字符为大写。 |
zfill(width) | 返回长度为width的字符串,原字符串右对齐,前边用0填充。 |
(二)格式化字符串
关键字format,使用如下:
>>> "{0} is {1} {2}".format("She","is","gril")
'She is is gril'
1、位置参数
括号中是数字0,1,2...用来占位,如上面的代码
2、关键字参数
指定关键字来代替,如下面:
>>> "{a} is {b} {c}".format(a="She",b="is",c="gril")
'She is is gril'
如果关键字参数和位置参数一起使用,位置参数一定要在所有的关键字参数前面
3.格式化符号
>>> '{0:.1f}{1}'.format(27.658,'GB')
'27.7GB'
“:”表示格式化的开始,用四舍五入保留一位小数输出。
符号 | 说明 |
---|---|
%c | 格式化字符及其ASCII码 |
%s | 格式化字符串 |
%d | 格式化整数 |
%o | 格式化无符号八进制数 |
%x | 格式化无符号十六进制数 |
%X | 格式化无符号十六进制数(大写) |
%f | 格式化定点数,可指定小数点后的经度 |
%e | 用科学计数法格式化定点数 |
%E | 作用同%e,用科学计数法格式化定点数 |
%g | 根据值的大小决定使用%f或%e |
%G | 作用同%g,根据值的大小决定使用%f或者%e |
格式化输出演示:
#%c字符
>>> '%c %c %c'%(97,98,99)
'a b c'
#%s字符串
>>> '%s'%'abcd'
'abcd'
#%d整数
>>> '%d+%d=%d'%(4,5,4+5)
'4+5=9'
#%o八进制数
>>> "%o"%10
'12'
#%十六进制数
>>> '%x'%10
'a'
>>> '%X'%10
'A'
#%%f浮点数,默认保留6位小数
>>> '%f'%3.14
'3.140000'
>>> '%e'%3.14
'3.140000e+00'
>>> '%g'%3.14
'3.14'
格式化操作符辅助指令
符号 | 说明 |
---|---|
m.n | m是显示的最小总宽度,n是小数点后的位数 |
- | 用于左对齐 |
+ | 在正数前面显示加号+ |
# | 在八进制数前面显示零(' 0'),在十六进制数前面显示'0x'或‘0X’ |
0 | 显示的数字前面填充‘0’取代空格 |
代码演示
>>> '%5.1f'%3.14
' 3.1'
>>> '%10d'%5
' 5'
>>> '%.2e'%3.14
'3.14e+00'
>>> '%-10d'%5
'5 '
>>> '%+d'%5
'+5'
>>> '%+d'%-5
'-5'
>>> '%#o'%10
'0o12'
>>> '%#x'%10
'0xa'
>>> '%010d'%5
'0000000005'
四、序列
列表、元组和字符串的共同点:
1.都可以通过索引得到每一个元素一默认索引值总是从0开始
2.可以通过分片的方法得到一个范围内的元素的集合
3.有很多共同的操作符(重复操作符、拼接操作符、成员关系操作符)
(一)list()把一个可迭代对象转换为列表
用help(list)命令可以查看list的所有方法。
>>> a='I live in China'
>>> a=list(a)
>>> a
['I', ' ', 'l', 'i', 'v', 'e', ' ', 'i', 'n', ' ', 'C', 'h', 'i', 'n', 'a']
>>> b=(1,1,2,3,5,8,13,21,34)
>>> b=list(b)
>>> b
[1, 1, 2, 3, 5, 8, 13, 21, 34]
tuple()和str()和list() 的用法一样。
(二)常用内置方法
int()、float()
len()函数,返回一个元素的长度
min()/max()函数,返回序列中的最小/大值,字符串使用的是ASCII码。要保证序列中的数据类型是统一的。
sum(iterable[,start=0])函数,返回序列iterable和可选参数start的总和,只能计算数字,不能计算字符,如下:
>>> tuple1=(1,2,3)
>>> sum(tuple1)
6
>>> sum(tuple1,1)
7
sorted()函数,返回一个排序。和方法list.sort()一样。
reversed()函数,将序列倒序。返回的是一个迭代器。
>>> tuple1=(1,2,3)
>>> reversed(tuple1)
<reversed object at 0x000001715C4D6B80>
>>> list(reversed(tuple1))
[3, 2, 1]
enumerate()函数。枚举,生成索引值和实际值的新序列。如下:
>>> enumerate(list1)
<enumerate object at 0x000001715BF73340>
>>> list(enumerate(list1))
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
zip()函数,返回由两个列表各个参数对应位置组成的新元组。如下:
>>> list1=['a','b','c','d']
>>> list2=[1,2,3,4,5,6,7,8]
>>> zip(list1,list2)
<zip object at 0x000001715BF73340>
>>> list(zip(list1,list2))
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]