序列-功能总览
一. list
1. 列表的定义
列表序列名称 = [列表中的元素1, 列表中的元素2, 列表中的元素3, …]
list = [ "apple" , "banana" , "pear" ]
print ( list )
print ( type ( list ) )
['apple', 'banana', 'pear']
<class ‘list’>
2. list的操作方法
①. 增
编号 函数 作用 1 append() 增加指定数据到列表中 2 extend() 列表结尾追加数据,如果数据是一个序列,则将这个序列的数据逐一添加到列表 3 insert() 指定位置新增数据
Ⅰ. append()
在列表的尾部追加元素
list1 = [ 'apple' , 'banana' , 'pineapple' , 'banana' ]
list1. append( "pear" )
print ( list1)
['apple', 'banana', 'pineapple', 'banana', 'pear']
Ⅱ. extend()
list1 = [ 'apple' , 'banana' ]
list2 = [ 'pineapple' , 'banana' ]
list1. extend( list2)
print ( list1)
list1. extend( "grape" )
print ( list1)
['apple', 'banana', 'pineapple', 'banana']
['apple', 'banana', 'pineapple', 'banana', 'g', 'r', 'a', 'p', 'e']
参数必须是个容器
list1 = [ 'apple' , 'banana' ]
list1. extend( 3 )
print ( list1)
TypeError: 'int' object is not iterable
Ⅲ. insert()
insert参考
list1 = [ 'apple' , 'banana' ]
list1. insert( 1 , "pear" )
print ( list1)
['apple', 'pear', 'banana']
②. 删
编号 函数 作用 1 del list[i] 删除列表中的某个元素 2 pop() 删除指定下标的数据(默认为最后一个),并返回该数据 3 remove() 移除列表中某个数据的第一个匹配项,没有则报错 4 clear() 清空列表,删除列表中的所有元素,返回空列表。
Ⅰ. del list[i]
list1 = [ 'apple' , 'banana' , "pear" ]
del list1[ 0 ]
print ( list1)
['banana', 'pear']
Ⅱ. pop()
list1 = [ 'apple' , 'banana' , "pear" , "grape" ]
p1 = list1. pop( )
print ( p1)
p2 = list1. pop( 0 )
print ( p2)
print ( list1)
grape
apple
['banana', 'pear']
Ⅲ. remove()
list1 = [ 'apple' , 'apple' , 'banana' , "pear" , "grape" ]
list1. remove( "apple" )
print ( list1)
['apple', 'banana', 'pear', 'grape']
Ⅳ. clear()
list1 = [ 'apple' , 'apple' , 'banana' , "pear" , "grape" ]
list1. clear( )
print ( list1)
[]
③. 改
编号 函数 作用 1 list[i] = val 修改列表中的某个元素 2 reverse() 将数据序列进行倒叙排列 3 sort() 对列表序列进行排序
Ⅰ. list[i] = val
list1 = [ 'apple' , 'apple' , 'banana' , "pear" , "grape" ]
list1[ 1 ] = "peach"
print ( list1)
['apple', 'peach', 'banana', 'pear', 'grape']
Ⅱ. reverse()
list1 = [ 'apple' , 'apple' , 'banana' , "pear" , "grape" ]
list1. reverse( )
print ( list1)
['grape', 'pear', 'banana', 'apple', 'apple']
Ⅲ. sort()
list1 = [ 'apple' , 'apple' , 'banana' , "pear" , "grape" ]
list2 = [ 1 , 5 , 3 , 9 , 7 ]
list1. sort( )
list2. sort( )
print ( list1)
print ( list2)
['apple', 'apple', 'banana', 'grape', 'pear']
[1, 3, 5, 7, 9]
④. 查
编号 函数 作用 1 val = list[i] 获取列表中的某个元素 2 index() 指定数据所在位置的下标 3 count() 统计指定数据在当前列表中出现的次数 4 in 判断指定数据在某个列表序列,如果在返回True,否则返回False 5 not in 判断指定数据不在某个列表序列,如果不在返回True,否则返回False 6 len() 计算列表中元素个数 7 max() 返回列表中元素最大值 8 min() 返回列表中元素最小值
Ⅰ. val = list[i]
list1 = [ 'apple' , 'banana' , 'pineapple' ]
print ( list1[ 1 ] )
banana
Ⅱ. index()
list1 = [ 'apple' , 'banana' , 'pineapple' ]
print ( list1. index( "banana" ) )
1
Ⅲ. count()
list1 = [ 'apple' , 'banana' , 'pineapple' , 'banana' ]
print ( list1. count( "banana" ) )
print ( list1. count( "apple" ) )
2
1
Ⅳ. in
list1 = [ 'apple' , 'banana' , 'pineapple' , 'banana' ]
print ( "banana" in list1)
print ( "pear" in list1)
True
False
Ⅴ. not in
list1 = [ 'apple' , 'banana' , 'pineapple' , 'banana' ]
print ( "banana" not in list1)
print ( "pear" not in list1)
False
True
Ⅵ. len()
list1 = [ 1 , 2 , 3 , 4 ]
print ( len ( list1) )
4
Ⅶ. max()
list1 = [ 1 , 2 , 3 , 4 ]
print ( max ( list1) )
4
Ⅷ. min()
list1 = [ 1 , 2 , 3 , 4 ]
print ( min ( list1) )
1
3. 列表的切片
list1 = [ 'apple' , 'apple' , 'banana' , "pear" , "grape" ]
print ( list1[ 1 : 3 ] )
['apple', 'banana']
4. 列表的循环遍历
list1 = [ 'apple' , 'apple' , 'banana' , "pear" , "grape" ]
for i in list1:
print ( i)
apple
apple
banana
pear
grape
5. 列表拆包
list1 = [ 1 , 2 , 3 , 4 ]
a, b, c, d = list1
print ( a)
print ( b)
print ( c)
print ( d)
1
2
3
4
6. 列表合并与复制
list1 = [ 1 , 2 , 3 , 4 ]
list2 = [ 5 , 6 , 7 , 8 ]
print ( list1 + list2)
print ( list1 * 2 )
[1, 2, 3, 4, 5, 6, 7, 8]
[1, 2, 3, 4, 1, 2, 3, 4]
7. 列表的嵌套
"""
classes = ['第一个班级','第二个班级','第三个班级']
一班:['张三', '李四']
二班:['王五', '赵六']
三班:['田七', '孙八']
"""
students = [ [ '张三' , '李四' ] , [ '王五' , '赵六' ] , [ '田七' , '孙八' ] ]
print ( students[ 0 ] )
print ( students[ 0 ] [ 1 ] )
['张三', '李四']
李四
8. enumerate()
list1 = [ 1 , 2 , 3 , 4 ]
for key, value in enumerate ( list1) :
print ( key, ":" , value)
0 : 1
1 : 2
2 : 3
3 : 4
二. tuple
1. 元组的定义
定义元组使用小括号 ,且使用逗号 隔开各个数据,数据可以是不同的数据类型 元组可以存储多个数据且元组内的数据是不能修改的
① 多个数据元组
tuple1 = ( 1 , 2 , 3 )
② 单个数据元组
tuple1 = ( 1 , )
2. tuple的操作方法
①. 增
②. 删
③. 改
④. 查
编号 函数 作用 1 val = tuple[i] 根据索引下标 查找元素 2 index() 查找某个数据,如果数据存在返回对应的下标,否则报错,语法和列表、字符串的index方法相同 3 count() 统计某个数据在当前元组出现的次数 4 in 元素是否存在 5 not in 元素是否不存在 6 len() 计算元组中元素个数 7 max() 返回元组中元素最大值 8 min() 返回元组中元素最小值
Ⅰ. val = tuple[i]
nums = ( 10 , 20 , 30 )
print ( nums[ 2 ] )
30
Ⅱ. index()
nums = ( 10 , 20 , 30 )
print ( nums. index( 10 ) )
0
Ⅲ. count()
nums = ( 10 , 20 , 30 , 20 , 30 )
print ( nums. count( 10 ) )
print ( nums. count( 20 ) )
1
2
Ⅳ. in
t1 = ( 1 , 2 , 3 , 4 )
print ( 1 in t1)
print ( 5 in t1)
True
False
Ⅴ. not in
t1 = ( 1 , 2 , 3 , 4 )
print ( 1 not in t1)
print ( 5 not in t1)
False
True
Ⅵ. len()
t1 = ( 1 , 2 , 3 , 4 )
print ( len ( t1) )
4
Ⅶ. max()
t1 = ( 1 , 2 , 3 , 4 )
print ( max ( t1) )
4
Ⅷ. min()
t1 = ( 1 , 2 , 3 , 4 )
print ( min ( t1) )
1
3. 元组的切片
nums = ( 10 , 20 , 30 , 20 , 30 )
print ( nums[ 0 : 3 ] )
(10, 20, 30)
4. 元组的循环遍历
nums = ( 10 , 20 , 30 , 20 , 30 )
for i in nums:
print ( i)
10
20
30
20
30
5. 元组拆包
t1 = ( 1 , 2 , 3 , 4 )
a, b, c, d = t1
print ( a)
print ( b)
print ( c)
print ( d)
1
2
3
4
6.元组的合并与复制
t1 = ( 1 , 2 , 3 , 4 )
t2 = ( 5 , 6 , 7 , 8 )
print ( t1 + t2)
print ( t1 * 2 )
(1, 2, 3, 4, 5, 6, 7, 8)
(1, 2, 3, 4, 1, 2, 3, 4)
7. enumerate()
t1 = ( 1 , 2 , 3 , 4 )
for key, value in enumerate ( t1) :
print ( key, ":" , value)
0 : 1
1 : 2
2 : 3
3 : 4
三. set
1. 集合的定义
天生去重 无序
① 定义一个集合
s1 = { 10 , "aplle" , 30 , "pear" , 30 }
② 定义一个空集合
s1 = set ( )
2. set的操作方法
①. 增
编号 函数 作用 1 add() 向集合中增加一个元素(单一) 2 update() 向集合中增加序列类型的数据(字符串、列表、元组、字典)
Ⅰ. add()
s1 = { 10 , 20 , 30 , 40 , 50 }
s1. add( 60 )
s1. add( 70 )
print ( s1)
{70, 40, 10, 50, 20, 60, 30}
Ⅱ. update()
s1 = { 10 , 20 , 30 , 40 , 50 }
list1 = [ 60 , 70 ]
s2 = ( 80 , 70 )
str1 = "hello"
s1. update( list1)
s1. update( s2)
s1. update( str1)
print ( s1)
{'o', 70, 40, 10, 'h', 80, 50, 'e', 20, 'l', 60, 30}
②. 删
编号 函数 作用 1 remove() 删除集合中的指定数据,如果数据不存在则报错。 2 discard() 删除集合中的指定数据,如果数据不存在也不会报错。 3 pop() 随机删除集合中的某个数据,并返回这个数据。 4 clear() 清空集合,删除集合中的所有元素,返回空集合
Ⅰ. remove()
s1 = { 10 , 20 , 30 , 40 , 50 }
s1. remove( 10 )
print ( s1)
{40, 50, 20, 30}
Ⅱ. discard()
s1 = { 10 , 20 , 30 , 40 , 50 }
s1. discard( 10 )
print ( s1)
{40, 50, 20, 30}
Ⅲ. pop()
s1 = { 10 , 20 , 30 , 40 , 50 }
s1. pop( )
print ( s1)
{10, 50, 20, 30}
Ⅳ. clear()
s1 = { 10 , 20 , 30 , 40 , 50 }
s1. clear( )
print ( s1)
set()
③. 改
④. 查
编号 函数 作用 1 in 判断某个元素是否在集合中,如果在,则返回True,否则返回False 2 not in 判断某个元素不在集合中,如果不在,则返回True,否则返回False 3 len() 计算集合中元素个数 4 max() 返回集合中元素最大值 5 min() 返回集合中元素最小值
Ⅰ. in
s1 = { 10 , 20 , 30 , 40 , 50 }
print ( 10 in s1)
print ( 70 in s1)
True
False
Ⅱ. not in
s1 = { 10 , 20 , 30 , 40 , 50 }
print ( 10 not in s1)
print ( 70 not in s1)
False
True
Ⅲ. len()
s1 = { 10 , 20 , 30 , 40 , 50 }
print ( len ( s1) )
5
Ⅳ. max()
s1 = { 10 , 20 , 30 , 40 , 50 }
print ( max ( s1) )
50
Ⅴ. min()
s1 = { 10 , 20 , 30 , 40 , 50 }
print ( max ( s1) )
10
3. 集合的循环遍历
s1 = { 1 , 2 , 3 }
for i in s1:
print ( i)
1
2
3
4. 集合的拆包
s1 = { 10 , 20 , 30 , 40 , 50 }
a, b, c, d, e = s1
print ( a)
print ( b)
print ( c)
print ( d)
print ( e)
40
10
50
20
30
4. 集合中的交集,并集与差集特性
s1 = { 10 , 20 , 30 , 40 , 50 }
s2 = { 40 , 50 , 60 , 70 , 80 }
print ( s1 & s2)
print ( s1 | s2)
print ( s1 - s2)
{40, 50}
{70, 40, 10, 80, 50, 20, 60, 30}
{10, 20, 30}
5. enumerate()
s1 = { 10 , 20 , 30 , 40 }
for key, value in enumerate ( s1) :
print ( key, ":" , value)
0 : 40
1 : 10
2 : 20
3 : 30
四. dict
1. 字典的定义
① 定义一个字典
dict1 = { 'name' : 'Tom' , 'age' : 20 , 'gender' : '男' }
② 定义一个空字典
dict1 = { }
dict2 = dict ( )
2. dict的操作方法
①. 增
编号 函数 作用 1 dict[key] = val 如果key存在则修改这个key对应的值;如果key不存在则新增此键值对
Ⅰ. dict[key] = val
dict1 = { }
dict1[ 'name' ] = 'Tom'
dict1[ 'age' ] = 20
dict1[ 'gender' ] = '男'
print ( dict1)
{'name': 'Tom', 'age': 20, 'gender': '男'}
②. 删
编号 函数 作用 1 del dict[key] 删除指定元素 2 pop(key) 删除指定key下的数据,并返回该数据 ,key错则报错 2 clear() 清空字典中的所有key
Ⅰ. del dict[key]
dict1 = { 'name' : 'Tom' , 'age' : 20 , 'gender' : '男' }
del dict1[ "name" ]
print ( dict1)
{'age': 20, 'gender': '男'}
Ⅱ. pop()
dict1 = { 'name' : 'Tom' , 'age' : 20 , 'gender' : '男' }
print ( dict1. pop( "name" ) )
Tom
Ⅲ.clear()
dict1 = { 'name' : 'Tom' , 'age' : 20 , 'gender' : '男' }
dict1. clear( )
print ( dict1)
{}
③. 改
编号 函数 作用 1 dict[key] = val 如果key存在则修改这个key对应的值;如果key不存在则新增此键值对
Ⅰ. dict[key] = val
dict1 = { 'name' : 'Tom' , 'age' : 20 , 'gender' : '男' }
dict1[ "name" ] = "Bob"
print ( dict1)
{'name': 'Bob', 'age': 20, 'gender': '男'}
④. 查
编号 函数 作用 1 val = dict[key] 2 get(key, 默认值) 根据字典的key获取对应的value值,如果当前查找的key不存在则返回第二个参数(默认值),如果省略第二个参数,则返回None 3 keys() 以列表返回一个字典所有的键 4 values() 以列表返回字典中的所有值 5 items() 以列表返回可遍历的(键, 值) 元组数组 6 in 元素是否存在 7 not in 元素是否不存在 8 len() 计算字典中元素个数 9 max() 返回字典中键值最大值 10 min() 返回字典中键值最小值
Ⅰ. val = dict[key]
dict1 = { 'name' : 'Tom' , 'age' : 20 , 'gender' : '男' }
print ( dict1[ "name" ] )
Tom
Ⅱ. get(key, 默认值)
dict1 = { 'name' : 'Tom' , 'age' : 20 , 'gender' : '男' }
print ( dict1. get( "name" ) )
print ( dict1. get( "name1" , "未找到" ) )
print ( dict1. get( "name1" ) )
Tom
未找到
None
Ⅲ. keys()
dict1 = { 'name' : 'Tom' , 'age' : 20 , 'gender' : '男' }
print ( dict1. keys( ) )
dict_keys(['name', 'age', 'gender'])
Ⅳ. values()
dict1 = { 'name' : 'Tom' , 'age' : 20 , 'gender' : '男' }
print ( dict1. values( ) )
dict_values(['Tom', 20, '男'])
Ⅴ. items()
dict1 = { 'name' : 'Tom' , 'age' : 20 , 'gender' : '男' }
print ( dict1. items( ) )
dict_items([(‘name’, ‘Tom’), (‘age’, 20), (‘gender’, ‘男’)])
Ⅵ. in
dict1 = { 'name' : 'Tom' , 'age' : 20 , 'gender' : '男' }
print ( "name" in dict1)
True
Ⅶ. not in
dict1 = { 'name' : 'Tom' , 'age' : 20 , 'gender' : '男' }
print ( "name" not in dict1)
False
Ⅷ. len()
dict1 = { 'name' : 'Tom' , 'age' : 20 , 'gender' : '男' }
print ( len ( dict1) )
3
Ⅸ. max()
dict1 = { 'name' : 'Tom' , 'age' : 20 , 'gender' : '男' }
print ( max ( dict1) )
name
Ⅹ. min()
dict1 = { 'name' : 'Tom' , 'age' : 20 , 'gender' : '男' }
print ( min ( dict1) )
age
3.字典的循环查询
dict1 = { 'name' : 'Tom' , 'age' : 20 , 'gender' : '男' }
for key, val in dict1. items( ) :
print ( key, ":" , val)
name : Tom
age : 20
gender : 男
4. 字典的拆包
dict1 = { 'name' : 'Tom' , 'age' : 20 , 'gender' : '男' }
a, b, c = dict1
print ( a)
print ( b)
print ( c)
name
age
gender
5. enumerate()
dict1 = { 'name' : 'Tom' , 'age' : 20 , 'gender' : '男' }
for key, value in enumerate ( dict1) :
print ( key, ":" , value)
0 : name
1 : age
2 : gender
五. 序列类型之间的相互转换
str1 = "hello"
list1 = [ 'a' , 'b' , 'c' , 'd' ]
tuple1 = ( 10 , 20 , 30 )
set1 = { 10 , 20 , 30 , 40 }
dict1 = { 'name' : '白龙马' , 'age' : 23 }
print ( "list" + "*" * 20 )
print ( list ( str1) )
print ( list ( tuple1) )
print ( list ( set1) )
print ( list ( dict1) )
print ( "tuple" + "*" * 20 )
print ( tuple ( str1) )
print ( tuple ( list1) )
print ( tuple ( set1) )
print ( tuple ( dict1) )
print ( "set" + "*" * 20 )
print ( set ( str1) )
print ( set ( tuple1) )
print ( set ( list1) )
print ( set ( dict1) )
print ( "dict" + "*" * 20 )
list********************
['h', 'e', 'l', 'l', 'o']
[10, 20, 30]
[40, 10, 20, 30]
['name', 'age']
tuple********************
('h', 'e', 'l', 'l', 'o')
('a', 'b', 'c', 'd')
(40, 10, 20, 30)
('name', 'age')
set********************
{'o', 'e', 'h', 'l'}
{10, 20, 30}
{'c', 'b', 'd', 'a'}
{'name', 'age'}
dict********************
六. 列表集合字典推导式
推导式comprehensions(又称解析式),是Python的一种独有特性。推导式是可以从一个数据序列构建另一个新的数据序列(一个有规律的列表或控制一个有规律列表)的结构体。 共有三种推导:列表推导式、集合推导式、字典推导式。
1. 列表推导式
变量名 = [表达式 for 变量 in 列表] 变量名 = [表达式 for 变量 in 列表 if 条件] 变量名 = [表达式 for 变量 in 列表 for 变量 in 列表]
list1 = [ i * 2 for i in range ( 10 ) ]
print ( list1)
list2 = [ i for i in range ( 10 ) if i % 2 == 0 ]
print ( list2)
list3 = [ ( i, j) for i in range ( 1 , 3 ) for j in range ( 0 , 3 ) ]
print ( list3)
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
[0, 2, 4, 6, 8]
[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
2. 集合推导式
list1 = [ 1 , 1 , 2 ]
set1 = { i ** 2 for i in list1}
print ( set1)
{1, 4}
3. 字典推导式
dict1 = { i: i ** 2 for i in range ( 1 , 6 ) }
print ( dict1)
list1 = [ 'name' , 'age' , 'gender' ]
list2 = [ 'Tom' , 20 , 'male' ]
dict2 = { list1[ i] : list2[ i] for i in range ( len ( list1) ) }
print ( dict2)
counts = { 'MBP' : 268 , 'HP' : 125 , 'DELL' : 201 , 'Lenovo' : 199 , 'ACER' : 99 }
dict3 = { key: value for key, value in counts. items( ) if value >= 200 }
print ( dict3)
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
{'name': 'Tom', 'age': 20, 'gender': 'male'}
{'MBP': 268, 'DELL': 201}