目录
3.2.2 子序列(slice切片)——使用索引获取中间的一段
3.2.6 长度、最大值和最小值(len()、max()、min()三个全局函数)
3.1 序列简介
序列——是一种包含多项数据的数据结构。
3.1.1 Python的序列
常见类型:字符串、列表、元组等。
3.1.2 创建列表和元组
语法:
- 创建列表:[元素1,元素2,.....]
- 创建元组:(元素1,元素2,.....)
例如:
#使用方括号定义列表
my_list = ['春眠不觉晓,','处处闻啼鸟。','夜来风雨声,','花落知多少。']
print(my_list)
#使用圆括号定义元组
my_tuple = ('春眠不觉晓,','处处闻啼鸟。','夜来风雨声,','花落知多少。')
print(my_tuple)
3.2 列表和元组的通用用法(不涉及改变元组的操作)
3.2.1 通过索引使用元组
它们的索引都是从0开始,并支持负数索引。列表的索引相当于一个变量,元组的元素相当于一个常量。
例如:
#*****************************
#***程序名称:index_test.py
#***程序功能:使用列表和元组的元素
#***编写日期:2019-2-12
#*****************************
a_tuple = ('crazyit',20,5.6,'fkit',-17)
print(a_tuple)
#访问第1个元素
print(a_tuple[0])
#访问第2个元素
print(a_tuple[1])
#访问倒数第1个元素
print(a_tuple[-1])
#访问倒数第2个元素
print(a_tuple[-2])
3.2.2 子序列(slice切片)——使用索引获取中间的一段
语法格式:[start:end:step]
例如:
#*****************************
#***程序名称:slice_test.py
#***程序功能:使用start、end获取元组中间一段的用法(叫切片或分片)
#***编写日期:2019-2-12
#*****************************
a_tuple = ('crazyit',20,5.6,'fkit',-17)
#访问从第2个到第4个(不包含)的所有元素
print(a_tuple[1:3])
#访问从倒数第3个到倒数第1个(不包含)的所有元素
print(a_tuple[-3:-1])
#访问从第2个到倒数第2个(不包含)的所有元素
print(a_tuple[1:-2])
#访问从倒数第3个到第5个(不包含)的所有元素
print(a_tuple[-3:4])
b_tuple = (1,2,3,4,5,6,7,8,9)
#访问从第3个到第9个(不包含)、间隔为2的所有元素
print(b_tuple[2:8:2])
#访问从第3个到第9个(不包含)、间隔为3的所有元素
print(b_tuple[2:8:3])
#访问从第3个到倒数第2个(不包含)、间隔为2的所有元素
print(b_tuple[2:-2:2])
3.2.3 加法
注意:列表只能和列表相加;元组只能和元组相加;元组不能直接和列表相加。
例如:
#*****************************
#***程序名称:plus_test.py
#***程序功能:元组和列表的加法运算
#***编写日期:2019-2-12
#*****************************
a_tuple = ('crazyit',20,-1.2)
b_tuple = (127,'crazyit','fkit',3.33)
#计算元组相加
sum_tuple = a_tuple + b_tuple
print(sum_tuple) #('crazyit',20,-1.2,127,'crazyit','fkit',3.33)
print(a_tuple) #a_tuple并没有改变
print(b_tuple) #b_tuple并没有改变
#两个元组相加
print(a_tuple + (-20,-30))
#下面代码报错:元组和列表不能直接相加
#print(a_tuple + [-20,-30])
a_list = [20,30,50,100]
b_list = ['a','b','c']
#计算列表相加
sum_list = a_list + b_list
print(sum_list) #[20,30,50,100,'a','b','c']
print(a_list + ['fkit']) #[20,30,50,100,'fkit']
3.2.4 乘法
列表和元组的乘法:把它们所包含的元素重复N次。
例如:
#*****************************
#***程序名称:multiple_test.py
#***程序功能:元组和列表的乘法运算
#***编写日期:2019-2-13
#*****************************
role_Hp = ('生命',20)
#执行元组乘法
mul_Hp = role_Hp * 3
print(mul_Hp)
#执行列表乘法
role_Hit = ['攻击',2]
mul_Hit = role_Hit * 3
print(mul_Hit)
另:
#*****************************
#***程序名称:translate.py
#***程序功能:对元组和列表同时进行加法、乘法运算。
#例如:把用户输入的日期翻译成英文表示的形式——就是添加英文的'第'后缀。
#***编写日期:2019-2-13
#*****************************
#同时对元组使用加法、乘法
order_endings = ('st','nd','rd')+('th',)*17+('st','nd','rd')+('th',)*7+('st',)
#将会看到st、nd、rd、17个th、st、nd、rd、7个th、st
#为了表示只有一个元素的元组,必须在唯一的元组元素之后添加英文逗号。
print(order_endings)
day = input("输入日期(1-31):")
#将字符串转成整数
day_int = int(day)
print(day + order_endings[day_int - 1])
3.2.5 in运算符
——用于判断列表或元组是否包含某个元素。
例如:
a_tuple = ('两个黄鹂鸣翠柳','一行白鹭上青天',100)
print(100 in a_tuple) #True
print(2 in a_tuple) #False
print('门泊东吴万里船' not in a_tuple) #True
3.2.6 长度、最大值和最小值(len()、max()、min()三个全局函数)
例如:
#*****************************
#***程序名称:func_test.py
#***程序功能:Python提供了内置的len()、max()、min()全局函数
#来获取元组或列表的长度、最大值和最小值。
#要求:传递给max()、min()函数的元组、列表的元素必须是相同类型且可以比较大小。
#***编写日期:2019-2-13
#*****************************
#元素都是数值的元组
a_tuple = (20,10,-2,15.2,102,50)
#计算最大值
print('a_tuple的最大值:',max(a_tuple))
#计算最小值
print('a_tuple的最小值:',min(a_tuple))
#计算长度
print('a_tuple的长度:',len(a_tuple))
#元素都是字符串的列表
b_list = ['crazyit','fkit','Python','Kotlin']
#计算最大值(依次比较每个字符的ASCII码值,先比较第一个字符,再比较第一个字符,若相同,再比较第二个,以此类推)
print('b_list的最大值:',max(b_list))
#计算最小值
print('b_list的最小值:',min(b_list))
#计算长度
print('b_list的长度:',len(b_list))
3.2.7 序列封包和序列解包
——序列封包:程序把多个值赋给一个变量时,Python会自动将多个值封装成元组。这种功能被称为序列封包。(多对一)
——序列解包:程序允许将序列(元组或列表等)直接赋值给多个变量,序列的各元素会被依次赋值给每个变量(要求序列的元素个数和变量个数相等)。这种功能被称为解包。(一对多)
上代码看的明白:
#*****************************
#***程序名称:seq_packing.py
#***程序功能:示范序列封包和序列解包的功能
#***编写日期:2019-2-13
#*****************************
#序列封包:将10,20,30封装成元组后赋值给vals
vals = 10,20,30
print(vals)
print(type(vals))
#输出元组vals的第2个元素的值
print(vals[1])
a_tuple = tuple(range(1,10,2))
#序列解包:将a_tuple元组的各元素依次赋值给a,b,c,d,e变量
a,b,c,d,e = a_tuple
print(a,b,c,d,e)
a_list = ['fkit','crazyit']
#序列解包:将a_list序列的各元素依次赋值给a_str、b_str变量
a_str,b_str =a_list
print(a_str,b_str)
#将10,20,30依次赋值给x,y,z(多对多)
x,y,z = 10,20,30
print(x,y,z)
#将y,z,x依次赋值给x,y,z(交换变量的值)
x,y,z = y,z,x
print(x,y,z)
#first、second保存前两个元素,rest列表包含剩余的元素
first,second,*rest = range(10)
print(first)
print(second)
print(rest)
#last保存最后一个元素,begin保存前面剩下的元素
*begin,last = range(10)
print(begin)
print(last)
#first保存第一个元素,last保存最后一个元素,middle保存中间剩下的元素
first,*middle,last = range(10)
print(first)
print(middle)
print(last)
3.3 使用列表
3.3.1 创建列表
(1)list()函数:用于将元组、区间(range)等对象转换为列表。
(2)tuple()函数:用于将列表、区间等对象转换为元组。
例如:
#*****************************
#***程序名称:list_test.py
#***程序功能:list()函数可用于将元组、区间(range)等对象转换为列表
#***编写日期:2019-2-13
#*****************************
a_tuple = ('crazyit',20,-1.2)
#将元组转换成列表
a_list = list(a_tuple)
print(a_list)
#使用range()函数创建区间(range)对象
a_range = range(1,5)
print(a_range) #rang(1,5)
#将区间转换成列表
b_list = list(a_range)
print(b_list) #[1,2,3,4]
#创建区间时还指定了步长
c_list = list(range(4,20,3))
print(c_list) #[4,7,10,13,16,19]
#*****************************
#***程序名称:tuple_test.py
#***程序功能:tuple()函数可用于将列表、区间(range)等对象转换为元组。
#***编写日期:2019-2-13
#*****************************
a_list = ['crazyit',20,-1.2]
#将列表转换成元组
a_tuple = tuple(a_list)
print(a_tuple)
#使用range()函数创建区间(range)对象
a_range = range(1,5)
print(a_range)
#将区间转换成元组
b_tuple = tuple(a_range)
print(b_tuple)
#创建区间时还指定了步长
c_tuple = tuple(range(4,20,3))
print(c_tuple) #[4,7,10,13,16,19]
3.3.2 增加列表元素
(1)append()方法:把传入的参数追加到列表的最后面。即可接受单个值,也可接受元组、列表等,但该方法只是把元组、列表当成当个元素,形成在列表中嵌套列表、嵌套元组的情形。
(2)extend()方法:不将被追加的列表当成一个整体,只是追加列表中的元素。
(3)insert()方法:在列表中间增加元素,要指定将元素插入到列表的哪个位置。
例如:
#*****************************
#***程序名称:append_test.py
#***程序功能:append()方法把传入的参数追加到列表的最后面
#*** extend()方法只追加列表中的元素不将被追加的列表当成一个整体。
#*** insert()方法将元素插入指定的位置。
#***编写日期:2019-2-13
#*****************************
a_list = ['crazyit',20,-2]
#追加元素
a_list.append('fkit')
print(a_list) #['crazyit',20,-2,'fkit']
a_tuple = (3.4,5.6)
#追加元组,元组被当成一个元素
a_list.append(a_tuple)
print(a_list) #['crazyit',20,-2,'fkit',(3.4,5.6)]
#追加列表,列表被当成一个元素
a_list.append(['a','b'])
#使用extend()方法
b_list = ['a',30]
#追加元组中的所有元素
b_list.extend((-2,3.1))
print(b_list) #['a',30,-2,3.1]
#追加列表中的所有元素
b_list.extend(['C','R','A'])
print(b_list) #['a',30,-2,3.1,'C','R','A']
#追加区间中的所有元素
b_list.extend(range(97,100))
print(b_list) #['a',30,-2,3.1,'C','R','A',97,98,99]
#使用列表的insert()方法,将元素插入列表的指定位置
c_list = list(range(1,6))
print(c_list)
#在索引3处插入字符串
c_list.insert(3,'CRAZY')
print(c_list) #[1,2,3,'CRAZY',4,5]
#在索引3处插入元组,元组被当成一个元素
c_list.insert(3,tuple('CRAZY'))
print(c_list) #[1,2,3,('C','R','A','Z','Y'),'CRAZY',4,5]
3.3.3 删除列表元素
(1)del语句:删除列表的元素、变量。
(2)remove方法:根据元素本身来执行删除列表元素的操作。该方法只删除第一个找到的元素,如果找不到该元素,该方法将会引发ValueError错误。
(3)clear()方法:用于清空列表的所有元素。
例如:
#*****************************
#***程序名称:delete_test.py
#***程序功能:delete语句删除列表元素
#***编写日期:2019-2-14
#*****************************
a_list = ['crazyit',20,-2.4,(3,4),'fkit']
#删除第3个元素
del a_list[2]
print(a_list)
#删除第2个到第4个(不包含)元素
del a_list[1:3]
print(a_list)
b_list = list(range(1,10))
#删除第3个到倒数第2个(不包含)元素,间隔为2
del b_list[2:-2:2]
print(b_list) #[[1, 2, 4, 6, 8, 9]
#删除第3个到第5个(不包含)元素,间隔为2
del b_list[2:4]
print(b_list) #[1, 2, 8, 9]
name = 'crazyit'
print(name) #NameError
#删除name变量
del name
#print(name)
#remove()方法删除列表元素
c_list = [20,'crazyit',30,-4,'crazyit',3.4]
#删除第一次找到的30
c_list.remove(30)
print(c_list)
#删除第一次找到的'crazyit'
c_list.remove('crazyit')
print(c_list)
#clear()方法清空列表的所有元素
c_list.clear()
print(c_list)
3.3.4 修改列表元素
(1)通过索引对列表赋值,既可以使用正数索引,也可以使用负数索引。
(2)对列表中空的slice赋值,变为列表插入元素。
(3)将列表其中一段赋值为空列表,变为了从列表中删除元素。
(4)使用字符串赋值,Python自动把字符串当成列表处理,其中每个字符都是一个元素。
(5)如果使用slice语法赋值,并指定step参数,则要求所赋值的列表元素个数与所替换的列表元素个数相等。
例如:
#*****************************
#***程序名称:update_test.py
#***程序功能:修改列表元素
#***编写日期:2019-2-14
#*****************************
a_list=[2,4,-3.4,'crazyit',23]
#对第三个元素赋值
a_list[2]='fkit'
print(a_list) #输出[2,4,'fkit','crazyit',23]
#对倒数第2个元素赋值
a_list[-2]=9527
print(a_list) #输出[2,4,'fkit',9527,23]
b_list=list(range(1,5))
print(b_list)
#将第2个到第4个(不包含)元素赋值为新列表的元素
b_list[1:3]=['a','b']
print(b_list)
#如果对列表中空的slice赋值,就变成为列表插入元素
#将第3个到第3个(不包含)元素赋值为新列表的元素,就是插入元素
b_list[2:2]=['x','y']
print(b_list) #将输出[1, 'a','x','y','b', 4]
#将第3个到第6个(不包含)元素赋值为空列表,就是删除元素
b_list[2:5]=[]
print(b_list) #将输出[1, 'a', 4]
#Python会自动将str分解成序列
b_list[1:3]='Charlie'
print(b_list) #将输出[1, 'C','h','a','r','l','i','e']
c_list=list(range(1,10))
#指定step为2,被赋值的元素有4个,因此用于赋值的列表也必须有4个元素
c_list[2:9:2]=['a','b','c','d']
print(c_list) #将输出[1, 2, 'a', 4, 'b', 6, 'c', 8, 'd']
3.3.5 列表的其他常用方法
(1)count():用于统计列表中某个元素出现的次数。
(2)index():用于判断某个元素在列表中出现的位置。
(3)pop():用于将列表当成“栈”使用,实现元素出栈功能。
(4)reverse():用于将列表中的元素反向存放。
(5)sort(key,reverse):用于对列表元素排序。
例如:
#*****************************
#***程序名称:count_test.py
#***程序功能:count()统计列表中某个元素出现的次数
#***编写日期:2019-2-14
#*****************************
a_list = [2,30,'a',[5,30],30]
#计算列表中30出现的次数
print(a_list.count(30))
#计算列表中[5,30]出现的次数
print(a_list.count([5,30]))
#*****************************
#***程序名称:index_test.py
#***程序功能:index()定位列表中某个元素出现的位置
#***编写日期:2019-2-14
#*****************************
a_list = [2,30,'a','b','crazyit',30]
#定位元素30出现的位置
print(a_list.index(30))
#从索引2开始,定位元素30出现的位置
print(a_list.index(30,2))
#在索引1到索引4之间定位元素30出现的位置,若找不到该元素,出现ValueError错误
print(a_list.index(30,1,4))
#*****************************
#***程序名称:stack_test.py
#***程序功能:pop()实现元素的出栈功能——先入后出(FILO)
#***编写日期:2019-2-14
#*****************************
stack = []
#向栈中入栈3个元素
stack.append('fkit')
stack.append('crazyit')
stack.append('Charlie')
print(stack) #输出['fkit', 'crazyit', 'Charlie']
#第一次出栈:最后入栈的元素被移出栈
print(stack.pop()) #返回出栈的元素Charlie
print(stack) #['fkit', 'crazyit']
#再次出栈
print(stack.pop()) #返回出栈的元素crazyit
print(stack) #['fkit']
#*****************************
#***程序名称:reverse_test.py
#***程序功能:reverse()方法会将列表中的所有元素的顺序反转
#***编写日期:2019-2-14
#*****************************
a_list = list(range(1,8))
#将a_list列表元素反转
a_list.reverse()
print(a_list) #[7, 6, 5, 4, 3, 2, 1]
#*****************************
#***程序名称:sort_test.py
#***程序功能:sort()方法对列表中的所有元素的进行排序
#***编写日期:2019-2-14
#*****************************
a_list = [3,4,-2,-30,14,9.3,3.4]
#对列表元素排序
a_list.sort()
print(a_list) #[-30, -2, 3, 3.4, 4, 9.3, 14]
b_list = ['Python','Swift','Ruby','Go','Kotlin','Erlang']
#对列表元素排序,默认按字符串包含的字符的编码来比较大小
b_list.sort()
print(b_list) #['Erlang', 'Go', 'Kotlin', 'Python', 'Ruby', 'Swift']
#指定key为len,指定使用len函数对集合元素生成比较大小的键
#也就是按字符串的长度比较大小
b_list.sort(key=len)
print(b_list) #['Go', 'Ruby', 'Swift', 'Erlang', 'Kotlin', 'Python']
#指定反向排序
b_list.sort(key=len,reverse=True) #reverse参数用于执行是否需要反转排序
print(b_list) #['Erlang', 'Kotlin', 'Python', 'Swift', 'Ruby', 'Go']
3.4 使用字典
——字典是Python提供的一种常用的数据结构,用于存放具有映射关系的数据。
3.4.1 字典入门
由于字典中的key是非常关键的数据,而且程序需要通过key来访问value,因此字典中的key不允许重复。
3.4.2 创建字典
(1)使用花括号({})语法来创建字典;
(2)使用dict()函数创建字典。
3.4.3 字典的基本用法(对字典的操作都是基于key的)
(1)通过key访问value;
(2)通过key添加key-value对;
(3)通过key删除key-value对;
(4)通过key修改key-value对;
(5)通过key判断指定key-value对是否存在。(使用in或not in 运算符)
3.4.4 字典的常用方法
(1)clear():清空字典中的所有键值对,字典变为空字典。
#*****************************
#***程序名称:clear_basic.py
#***程序功能:clear()用于清空字典中所有的key-value对
#***编写日期:2019-2-14
#*****************************
cars = {'BMW':8.5,'BENS':8.3,'AUDI':7.9}
print(cars)
#清空cars的所有key-value对
cars.clear()
print(cars)
(2)get():根据key获取value,相当于方括号的增强版。
#*****************************
#***程序名称:get_basic.py
#***程序功能:get()根据key来获取value
#***编写日期:2019-2-14
#*****************************
cars = {'BMW':8.5,'BENS':8.3,'AUDI':7.9}
#获取BMW对应的value
print(cars.get('BMW'))
print(cars.get('PORSCHE'))
#print(cars['PORSCHE']) #KeyError
(3)update():使用一个字典所包含的键值对来更新已有的字典。
cars = {'BMW':8.5,'BENS':8.3,'AUDI':7.9}
cars.update({'BMW':4.5,'PORSCHE':9.3})
print(cars) #输出{'BMW': 4.5, 'BENS': 8.3, 'AUDI': 7.9, 'PORSCHE': 9.3}
(4)items()、keys()、values()分别用于获取字典中的所有key-value对、所有key、所有value。Python不希望用户直接操作这几个方法,但可通过list()函数吧它们转换成列表。
cars = {'BMW':8.5,'BENS':8.3,'AUDI':7.9}
#获取字典中的所有key-value对,返回一个dict_items对象
ims = cars.items()
print(type(ims)) #<class 'dict_items'>
#将dict_items转换成列表
print(list(ims)) #[('BMW', 8.5), ('BENS', 8.3), ('AUDI', 7.9)]
#访问第2个key-value对
print(list(ims)[1]) #('BENS', 8.3)
#获取字典中所有的key,返回一个dict_keys对象
kys = cars.keys()
print(type(kys)) #<class 'dict_keys'>
#将dict_keys转换成列表
print(list(kys)) #['BMW', 'BENS', 'AUDI']
#访问第2个key
print(list(kys)[1]) #BENS
#获取字典中的所有的value,返回一个dict_values对象
vals = cars.values()
#将dict_values转换成列表
print(type(vals)) #<class 'dict_values'>
print(list(vals)) #[8.5, 8.3, 7.9]
#访问第2个value
print(list(vals)[1]) #8.3
(5)pop():该方法用于获取指定key对应的value,并删除这个key-value对。
cars = {'BMW':8.5,'BENS':8.3,'AUDI':7.9}
print(cars.pop('AUDI')) #7.9
print(cars) #{'BMW': 8.5, 'BENS': 8.3}
(6)popitem():该方法用于随机弹出字典中的一个key-value对。
#*****************************
#***程序名称:popitem_test.py
#***程序功能:随机弹出字典中的一个key-value对
#实际上popitem()方法总是弹出底层存储的最后一个key-value
#***编写日期:2019-2-15
#*****************************
cars = {'BMW':8.5,'BENS':8.3,'AUDI':7.9}
print(cars)
#弹出字典底层存储的最后一个key-value对
print(cars.popitem()) #('AUDI', 7.9)
print(cars) #{'BMW': 8.5, 'BENS': 8.3}
#将弹出项的key赋值给k,value赋值给v
k,v=cars.popitem()
print(k,v) #BENS 8.3
(7)setdefault():该方法用于根据key来获取对应的value的值。
cars = {'BMW':8.5,'BENS':8.3,'AUDI':7.9}
#设置默认值,该key在dict中不存在,新增key-value对
print(cars.setdefault('PORSCHE',9.2)) #9.2
print(cars)
#设置默认值,该key在dict中存在,不会修改dict内容
print(cars.setdefault('BMW',3.4)) #8.5
print(cars)
(8)fromkeys():该方法使用给定的多个key创建字典,这些key对应的value默认都是None;也可以额外传入一个参数作为默认的value。
#使用列表创建包含两个key的字典
a_dict=dict.fromkeys(['a','b'])
print(a_dict) #{'a': None, 'b': None}
#使用元组创建包含两个key的字典
b_dict=dict.fromkeys((13,17))
print(b_dict) #{13: None, 17: None}
#使用元组创建包含两个key的字典,指定默认值的valuec
c_dict=dict.fromkeys((13,17),'good')
print(c_dict) #{13: 'good', 17: 'good'}
3.4.5 使用字典格式化字符串
#在字符串模板中使用key
temp = '书名是:%(name)s,价格是:%(price)010.2f,出版社是:%(publish)s'
book = {'name':'疯狂Python讲义','price':88.9,'publish':'电子社'}
#使用字典为字符串模板中的key传入值
print(temp % book)
book = {'name':'疯狂Kotlin讲义','price':78.9,'publish':'电子社'}
#使用字典为字符串模板中的key传入值
print(temp % book)