一、列表
列表中各元素间是有序的,属于序列类型。列表可以进行元素的 添加,删除,查找,替换 等操作。列表长度没有限制,不需要定义长度,列表中的元素类型可以不同,可以是 字母,数字,集合,列表,元组,字符串等。
1.list()函数
描述:可以将其它的组合数据类型转化为列表类型,或生成一个空列表。
语法:list() -> new empty list 返回一个空列表
list(iterable) -> new list initialized from iterable’s items 返回一个新列表
iterable —— 要转换的组合数据类型。
程序示例:
ls = list() #创建一个空列表。
st = {1,2,3,"a"} #集合类型
d = {1:"a",2:"b"} #字典类型
t = (1,2,3,"b") #元组类型
s = "厉害了,我的国!" #字符串类型
#将集合,字典,元组,字符串 类型转化为列表类型
ls1 =list(st)
ls2 =list(d)
ls3 =list(t)
ls4 =list(s)
print(ls)
print(ls1)
print(ls2)
print(ls3)
print(ls4)
程序运行结果:
[]
[1, 2, 3, 'a']
[1, 2]
[1, 2, 3, 'b']
['厉', '害', '了', ',', '我', '的', '国', '!']
2.append()函数
描述:在列表ls最后(末尾)添加一个元素object
语法:ls.append(object) -> None 无返回值
object —— 要添加的元素。可以添加 列表,字典,元组,集合,字符串等。
程序示例:
ls1 = [1,2,3,4,5,6]
ls2 = [1,2,3,4,5,6]
ls1.append(12)
#可以添加列表,字典,元组,集合,字符串等
ls2.append([1,"a"]) #添加列表
ls2.append({2:"a",3:"hj"}) #添加字典
ls2.append((1,"k",3)) #添加元组
ls2.append({"1","2","h"}) #添加集合
ls2.append("123abc") #添加字符串
print(ls1.append(12)) #无返回值
print(ls1) #append()函数的操作对象是原列表。
print(ls2)
程序运行结果:
None
[1, 2, 3, 4, 5, 6, 12, 12]
[1, 2, 3, 4, 5, 6, [1, 'a'], {2: 'a', 3: 'hj'}, (1, 'k', 3), {'2', '1', 'h'}, '123abc']
3.clear()函数
描述:删除列表ls中的所有元素。
语法: ls.clear() -> None 返回值为空
程序示例:
ls = [1,2,3,"4",5,"a"]
ls.clear() #删除列表中的所有元素。
print(ls.clear()) #无返回值
print(ls) #返回的ls为空列表。
程序运行结果:
None
[]
4. copy()函数
描述:生成一个新列表,复制ls中的所有元素。
语法: ls.copy() -> list 返回一个列表
程序示例:
ls = [1,2,3,[4,5,6]]
lt = ls.copy() #lt复制ls中的所有元素
ls.clear() #删除ls所有元素,lt中的元素没有被删除。
lk = ls #这不是复制,而是给列表ls新关联一个引用,即增加一个别名,ls和lt指向同一个内存地址。
print(id(ls),id(lk))
print(lt)
print(ls)
程序运行结果:
2161190907400 2161190907400
[1, 2, 3, [4, 5, 6]]
[]
发现一个有趣的现象:
无论是修改原列表ls的内嵌套列表的元素,还是修改复制列表lt的内嵌套列表元素。列表ls和列表lt的内嵌套列表元素都将改变。
但修改列表ls或列表lt的其它非嵌套元素,都不改变对方相应的元素。
程序示例1:
ls = [1,2,3,[4,5,6]]
lt = ls.copy() #lt复制ls中的所有元素
ls[0] = "a" #对变列表ls中的第一个元素进行修改
ls[3][0] = "a" #对列表ls中第四个元素的第一个元素进行修改
print(lt) #列表lt的第一个元素不变,但第四个元素的第一个元素发生改变。
print(ls)
程序运行结果:
[1, 2, 3, ['a', 5, 6]]
['a', 2, 3, ['a', 5, 6]]
程序示例2:
ls = [1,2,3,[4,5,6]]
lt = ls.copy()
lt[0] = "a" #对变列表lt中的第一个元素进行修改
lt[3][0] = "a" #对列表lt中第四个元素的第一个元素进行修改
print(lt)
print(ls) #列表ls的第一个元素不变,但第四个元素的第一个元素发生改变。
程序运行结果:
['a', 2, 3, ['a', 5, 6]]
[1, 2, 3, ['a', 5, 6]]
程序示例3:
:深层复制方法
import copy
ls = [1,2,3,[7,"b",9],"a"]
lt1 = copy.deepcopy(ls) #深层复制。
lt2 = copy.copy(ls) #浅层复制
ls[3][1] = "abc123" #改变原列表ls中内嵌套列表[7,"b",9] 中的“b”元素。深层复制的lt1列表对应位置元素不改变,但浅层复制改变。
print(ls)
print("深层复制:",lt1)
print("浅层复制:",lt2)
程序运行结果:
[1, 2, 3, [7, 'abc123', 9], 'a']
深层复制: [1, 2, 3, [7, 'b', 9], 'a']
浅层复制: [1, 2, 3, [7, 'abc123', 9], 'a']
总结:ls.copy() 函数只能 copy 一层,即copy()复制是浅复制。
5. count()函数
描述:统计列表ls中value元素出现的次数
语法:ls.count(value) -> integer 返回一个整数
value —— 要统计的value元素。
程序示例:
ls = [1,2,3,5,4,5,5,5,5,"python"]
print(ls.count(5)) #统计列表ls中 5 出现的次数
print(ls.count(0)) #列表ls中无0元素
print(ls.count("python")) #统计列表ls中 "python" 出现的次数。
程序运行结果:
5
0
1
6. extend()函数
描述:在列表ls末尾添加一个列表iterable。
语法:ls.extend(iterable) -> None 无返回值
iterable —— 要添加的列表。可以是整个列表iterable,也可以是列表iterable的一部分。
程序示例1:
ls = [1,2,"a",[4,5,"a"]]
lt = [1,"abc","b",[1,2]]
ls.extend(lt) #返回值为空,将列表lt的元素添加到列表ls末尾。
print(ls.extend(lt))
print(ls)
print(lt) #列表lt元素不变
程序运行结果:
None
[1, 2, 'a', [4, 5, 'a'], 1, 'abc', 'b', [1, 2], 1, 'abc', 'b', [1, 2]]
[1, 'abc', 'b', [1, 2]]
程序示例2:
ls = [1,2,"a",[4,5,"a"]]
lt = [1,"abc","b",[1,2]]
ls.extend(lt[0:3]) #返回值为空,将列表lt中的 1, 'abc', 'b' 添加到列表ls末尾。
print(ls)
print(lt) #列表lt元素不变
程序运行结果:
[1, 2, ‘a’, [4, 5, ‘a’], 1, ‘abc’, ‘b’]
[1, ‘abc’, ‘b’, [1, 2]]
6.0 index()函数
描述:列表ls中第一次出现元素value的位置。
语法: ls.index(value, start, stop) -> integer 返回一个整数
value —— 要查找的元素。
star —— 索引的起始位置。
stop —— 索引的结束位置。
[star,stop)
程序示例:
ls = [1,2,3,"a",3,5,"a",5,[1,7,"b"]]
print(ls.index("a")) #返回列表ls中"a"第一次出现的位置。
print(ls.index("a",4)) #索引的起始位置为下标为4的元素,索引范围为 3, 5, 'a', 5, [1, 7, 'b'
print(ls.index("a",4,8)) #索引的起始位置为下标为4的元素,结束位置为下标为7的元素。索引范围 3, 5, 'a', 5
print(ls.index(3))
print(ls[8].index("b")) #返回列表ls内嵌套列表[1,7,"b"]中"b"第一次出现的位置
print(ls.index(0)) #列表ls无0,报错
程序运行结果:
3
6
6
2
2
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-64-c3f3008df73b> in <module>()
5 print(ls.index(3))
6 print(ls[8].index("b")) #返回列表ls内嵌套列表[1,7,"b"]中"b"第一次出现的位置
----> 7 print(ls.index(0)) #列表ls无0,报错
ValueError: 0 is not in list
7.insert()函数
描述:在列表第index位置,添加元素object。
语法: ls.insert(index, object)
index —— 元素object插入列表ls的位置。
objece —— 将要添加的元素。可以是列表,元组,字典,集合,字符串等。
程序示例1:
ls = [1,2,"a",["a",5,8]]
ls.insert(3,"b")#在列表ls下标为3的位置插入元素 1
ls.insert(3,1) #在列表ls下标为3的位置插入元素 "b"
ls[5].insert(0,"acv") #在列表ls的内嵌套列表["a",5,8],下标为0的位置插入字符串"acv"
print(ls)
程序运行结果:
[1, 2, 'a', 1, 'b', ['acv', 'a', 5, 8]]
程序示例2:
ls = [1,2,3]
ls.insert(0,[1,2,3]) #插入列表
ls.insert(0,(1,2,3)) #插入元组
ls.insert(0,{1:"a",2:"b"}) #插入字典
ls.insert(0,{1,2,3}) #插入集合
print(ls)
程序运行结果:
[{1, 2, 3}, {1: 'a', 2: 'b'}, (1, 2, 3), [1, 2, 3], 1, 2, 3]
7. pop()函数
描述:将列表ls中第index项元素取出,并从列表ls中删除该元素。若果省略index,则默认删除列表最后(末尾)一个元素,并返回该元素。
语法: ls.pop(index) -> item 返回删除的项
index —— 要取出并删除的元素下标的序数。
程序示例:
ls = [1,2,"a","y",[1,2,3],"b"]
print(ls.pop(0)) #取出下标为0的元素,并从列表ls中删除。
print(ls.pop(3))
print(ls.pop()) #默认取出列表ls最后一个元素,并删除。
print(ls) #列表中的 1 [1,2,3] "b" 元素已被删除。
程序运行结果:
1
[1, 2, 3]
b
[2, 'a', 'y']
8. remove()函数
描述:将列表ls中出现的第一个元素value删除。
语法:ls.remove(value) -> None 返回值为空
value ———— 要删除的元素。
程序示例:
ls1 = [1,2,"a",3,1,1,55,"a,1"]
ls2 = [1,2,"a",3,1,1,55,"a,1"]
ls1.remove(1) #删除ls1中第一次出现的元素 1
ls2.remove("a") ##删除ls2中第一次出现的元素 "a"
print(ls1.remove(1)) #返回值为空
print(ls1)
print(ls2)
程序运行结果:
None
[2, 'a', 3, 1, 55, 'a,1']
[1, 2, 3, 1, 1, 55, 'a,1']
也可以使用python的保留字 del 对列表的元素或部分片段进行删除
语法:
① del <列表变量>[索引序列号]
② del <列表变量>[索引起始位置 :索引结束位置]
③ del <列表变量>[索引起始位置 :索引结束位置:步长]
程序示例:
ls1 = [1,2,3,4,"a",[1,2,3],5,6]
ls2 = [1,2,3,4,"a",[1,2,3],5,6]
ls3 = [1,2,3,4,"a",[1,2,3],5,6]
del ls1[0] #删除列表ls1中下标为0的元素
print(ls1)
del ls1[2:] #删除列表ls1中 起始下标为2,到结尾的元素
print(ls1)
del ls2[2:6] #删除列表ls2中 起始下标为2,终止下标为6 之间的元素。
print(ls2)
del ls3[1:6:2] #起始位置为2,终止位置为6,步长为2
print(ls3)
程序运行结果:
[2, 3, 4, 'a', [1, 2, 3], 5, 6]
[2, 3]
[1, 2, 5, 6]
[1, 3, 'a', 5, 6]
10. reverse()函数
描述:将列表ls中的元素反转。
语法:ls.reverse()
程序示例:
ls1 = [1,2,3,4,5,6,7,8,9]
ls1.reverse() #将列表ls1反转输出
print(ls1)
ls2 = [2,5,8,9,4,1,2,6,2,1,3]
ls2.sort(reverse=True) #ls2.sort()默认将列表ls2按从小到大的序数排列。reverse=True 使排序后的列表反转,reverse=False 则不反转
print(ls2)
程序运行结果:
[9, 8, 7, 6, 5, 4, 3, 2, 1]
[9, 8, 6, 5, 4, 3, 2, 2, 2, 1, 1]
11. sort()函数
描述:将列表ls中的同类元素按大小进行排序,默认从小到大排序。
语法: ls.sort(key=None, reverse=False) -> None 返回值为空
key —— 接受一个函数,且该函数只有一个返回值
reverse —— 排序规则,即排序是否反转。默认为False 不反转(升序),True 则反转(降序)。
程序示例:
ls1 = [5,2,1,6,9,55,2,8,10]
ls2 = [(1,2),(3,5),(55,1),(6,0)]
ls3 = ["a","z","A","y","g"]
ls4 = [1,6,2,"a","z","h"]
ls1.sort() #默认升序排序
print(ls1)
def f(n):
return n[1] #对元组的第二个元素进行升序排序
ls2.sort(key=f)
print(ls2)
ls3.sort(reverse=True) #降序排序
print(ls3)
ls4.sort() #会报错,列表ls4中元素种类不同。
print(ls4)
程序运行结果:
[1, 2, 2, 5, 6, 8, 9, 10, 55]
[(6, 0), (55, 1), (1, 2), (3, 5)]
['z', 'y', 'g', 'a', 'A']
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-123-7a42b5fc86f8> in <module>()
15 print(ls3)
16
---> 17 ls4.sort()
18 print(ls4)
TypeError: unorderable types: str() < int()
二、元祖
Python的元组与列表类似,不同之处在于元组的元素不能修改。元组中的元素也不能被删除,但可以删除整个元组
元组使用小括号,列表使用方括号。
元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。
如下实例:
#coding=utf-8
tup1 = ('C', 'C++', 2014, 2015);
tup2 = (1, 2, 3, 4, 5);
tup3 = ('a', 'b', 'c', 'd');
#创建空元组
tup4 = ();
访问元组
#coding=utf-8
tup1 = ('C', 'C++', 2014, 2015);
tup2 = (1, 2, 3, 4, 5);
tup3 = ('a', 'b', 'c', 'd');
#创建空元组
tup4 = ();
print 'tup1[0]: ', tup1[1];
print 'tup2[1:5]: ', tup2[1:5];
删除元组
del tup4;
无关闭分隔符
任意无符号的对象,以逗号隔开,默认为元组,如下实例:
print 'hello', -2.24, 3+5.6j, 'wolrd';
x, y = 5, 6;
print " x , y : ", x,y;
实例结果:
hello -2.24 (3+5.6j) wolrd
x , y : 5 6
元组内置函数
Python元组包含了以下内置函数
序号 方法及描述
1 cmp(tuple1, tuple2)
比较两个元组元素。
2 len(tuple)
计算元组元素个数。
3 max(tuple)
返回元组中元素最大值。
4 min(tuple)
返回元组中元素最小值。
5 tuple(seq)
将列表转换为元组。
三、string
下标与切片
str[下标],从左向右0→+,从右向左-1→
str[起始:结束:步长],范围包首不包尾
>>> str="0123456789" #定义一个字符串,从0到9,共10个元素
>>> str[0] #取出0号下标的元素
'0'
>>> str[10] #尝试取出10号下标的元素
Traceback (most recent call last):
File "<pyshell#6>", line 1, in <module>
str[10]
IndexError: string index out of range
#报错,下标越界,不存在str[10]
>>> str[9] #下标从左向右数,第一个为0号下标,第N个元素下标为N-1
'9'
>>> str[-1] #下标从右向左数,第一个为-N号下标,倒数最后一个为-1
'9'
>>> str[-10]
'0'
常见方法
查找
.find(str),str存在字符串中返回下标索引值,不存在返回-1
.rfind(str),str存在字符串中,查找顺序为从右向左,其它与find一样
.index(str),存在返回下标索引值,不存在报异常
.rindex(str),存在返回下标索引值,查找顺序为从右向左,其它与index一样
.count(str[,起始,结束]),查找指定字符串中该字符出现的总次数
>>> str='123aaabcdeeff' #定义一个字符串用于测试字符串方法的使用
>>> str.find(0) #尝试查询整数0是在于字符串中的下标
Traceback (most recent call last):
File "<pyshell#7>", line 1, in <module>
str.find(0)
TypeError: must be str, not int
#字符串操作,查询操作对象必须为字符串类型,所以元素应用‘’标识
>>> str.find('1') #查询字符1在指定字符串中首次出现的下标
0 #返回的下标为0
>>> str.find('a') #查询字符a在指定字符串中首次出现的下标
3 #返回的下标为3
>>> str.rfind('a') #反向查询(即从末尾向前查询),字符a首次出现在字符串中的下标
5 #返回的下标为5
>>> str.index('0') #使用index查询时,字符不存在时,会报错
Traceback (most recent call last):
File "<pyshell#11>", line 1, in <module>
str.index('0')
ValueError: substring not found
>>> str.find('0') #使用find查询时,不存在返回-1
-1
>>> str.rindex('a') #使用rindex反向查询
5
>>> str.count('a') #使用count查询指定字符出现的总共次数
3
>>> str.count('f')
2
>>> str.count('a',0,3) #使用count时,可以指定范围,第一个数字指定起始位置,
0 #第二个数字指定 结束范围,查询范围包含起始位,不包含结束位
>>> str.count('a',1,5)
2
>>> str.find('abcde') #操作对象为字符串,传入参数也是一个字符串,并不一定是一个字符
5 #可以是字母数字以及中文
替换
.replace(str1,str2 [,n] ),将字符串中所有的str1替换为str2,n可指定最多替换的次数
>>> str='123aaabcdeeff'
>>> str.replace('a','s') #不指定替换次数,将会全部替换
'123sssbcdeeff'
>>> str.replace('a','s',1) #指定次数时,仅替换指定次数个,替换顺序为从前向后
'123saabcdeeff'
>>> str.replace('a','s',2)
'123ssabcdeeff'
分割
.split(str[,n]),以str为分隔符(分割后丢失),将字符串分割为多个字符串,n可指定最多的分割次数
.partition(str),已指定字符做为一个部分,分割两边,生成三部分的字符串
>>> str='123123123' #定义一个字符串,用于测试
>>> str.split('2') #使用split进行分割
['1', '31', '31', '3'] #分割后指定的分割符消失,生成多个字符串的列表
>>> str.partition('2') #使用partition进行分割
('1', '2', '3123123') #仅进行一次分割,分割后制定的分割符单独成为一部分
>>> str='abc\nabc\nabc\nabc' #定义一个包含行符的字符串
>>> print(str) #打印输出测试
abc
abc
abc
abc
>>> str.splitlines() #使用splitlines进行分割,生成一个列表,每一行数据为一个元素
['abc', 'abc', 'abc', 'abc']
大小写格式化
.capitalize(),将字符串第一个首字母大写(其它都小写)
.title(),将字符串中所有单词首字母大写(其它都小写)
.lower()转换所有大写字符为小写
.upper()转换所有小写字符为大写
>>> str="abcABC defDEF hijHIJ klMN" #定义一个包含大小写的字符串用于测试
>>> str.capitalize() #将字符串首字母进行大写
'Abcabc defdef hijhij klmn'
>>> str.title() #将所有单词首字母进行大写
'Abcabc Defdef Hijhij Klmn'
>>> str.lower() #将字符串中所有字母小写
'abcabc defdef hijhij klmn'
>>> str.upper() #将字符串中所有字母大写
'ABCABC DEFDEF HIJHIJ KLMN'
对齐格式化
.ljust(width)返回一个原字符串左对齐,并默认使用空格补充至长度为width的字符串
.rjust(width)返回一个原字符串右对齐,并默认使用空格补充至…
.center(width) 返回一个原字符居中,并使用空格补充至width长度的新字符串
#默认使用空格补充长度,显示不够明显,所以为了突出效果,指定使用了*补充
str1=' abcde '
print(str1.ljust(20,'*')) #左对齐,指定长度为20
str2=' abcde '
print(str2.rjust(20,'*')) #右对齐,指定长度为20
str3=' abcde '
print(str3.center(20,'*')) #居中对齐,指定长度为20
#执行结果
# abcde **********
# ********* abcde
清除空白字符
.lstrip(),删除左侧的空白字符
.rstrip(),删除末尾的空白字符
.strip(),删除两端的空白字符
>>> str=' abc '
>>> str.lstrip() #删除左侧空格
'abc '
>>> str.rstrip() #删除右侧空格
' abc'
>>> str.strip() #删除两侧空格
'abc'
>>>
检查
.startswith(str),检查字符串是否以指定字符开头,是则返回Turn,否则返回False
.endswith(str),检查字符串是否以指定字符结尾,是则返回Turn,否则为False
.isalpha(),检查字符串是否都是字母,是返回Turn,否则返回False
.isdigit(),检查字符串是否只包含数字,是返回Turn,否则返回False
.isalnum(),检查字符串是否都是字母或数字,是返回Turn,否则返回False
.isspace(),检查字符串是否只包含空格,是返回Turn,否则返回False
>>> str0='0123abcd'
>>> str1='12345'
>>> str2='abcdef'
>>> str3=' '
>>> str0.startswith('0') #检查是否包含指定字符串,是则返回True
True
>>> str0.startswith('6') #不包含则返回Flace
False
>>> str0.endswith('0') #检查是否以指定字符串结束,不是返回Flace
False
>>> str0.endswith('d') #是则返回True
True
>>> str1.isalnum() #检测指定字符串是否全是字母和数字组成
True
>>> str2.isalpha() #检测指定字符串是否全为字母
True
>>> str0.isdigit() #检测指定字符串是否全是数字
False
>>> str3.isspace() #检测指定字符串是否全为空格
True