Python学习-基础篇(二)

前言

本篇包含：序列的应用(列表、元组、字典、集合)

四、序列的应用

序列

序列是一块用于存放多个值的连续内存空间，并且按一定顺序排列，可以通过索引取值。
1.索引
索引->编号->下标
从0开始计数
索引可以是负数(从-1开始)

元素1 元素2 元素3 元素4
0      1     2    3
-4    -3    -2   -1

>>> string = "一言既出，驷马难追。"
>>> print(string[1])
言
>>> print(string[-2])
追

2.切片(分片)

sname[start : end : step]
#sname：列表名称
#start：起始值(包括)
#end：结束值(不包括)
#step：步长

>>> student = ["小明","赵四","小赵","李明","张张","李华","王强"]
>>> print(student[1:5])
['赵四', '小赵', '李明', '张张']
>>> print(student[0:5:2])
['小明', '小赵', '张张']
>>> print(student[5]) #只有end并省略:就变成了索引
李华
>>> print(student[:5])
['小明', '赵四', '小赵', '李明', '张张']
>>> print(student[:])
['小明', '赵四', '小赵', '李明', '张张', '李华', '王强']
>>> print(student[5:])
['李华', '王强']

3.序列相加
序列1+序列2=序列1 序列2
只能是同类型的序列相加，如：列表+列表、元组+元组、字符串+字符串

>>> stu1 = ["小明","赵四","小赵","李明"]
>>> stu2 = ["张张","李华","王强"]
>>> stu = stu1+stu2
>>> print(stu)
['小明', '赵四', '小赵', '李明', '张张', '李华', '王强']

4.乘法
序列*乘数=重复n次的序列

>>> number = [1,2,3]
>>> print(number*3)
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> emptylist = [None]*5 #初始化列表长度
>>> print(emptylist)
[None, None, None, None, None]

5.检查某个元素是否是序列的成员

value in sequence
#value：要检查的元素
#sequence：序列

>>> content = [1,2,3,4,"小明","李华"]
>>> print(2 in content)
True
>>> print("小明" in content)
True
>>> print(6 in content)
False
>>> print("小王" not in content)
True

6.计算序列的长度、最大值和最小值
计算序列的长度：len()
计算序列的最大值：max()
计算序列的最小值：min()
将序列转换为列表：list()
将序列转换为字符串：str()
计算列表之中元素和：sum
对元素进行排序：sorted()
反转序列元素：reversed()
把序列组合为索引序列：enumerate()

>>> number = [25,6,32,88,22]
>>> print(len(number))
5
>>> print(max(number))
88
>>> print(min(number))
6
>>> string = "我学Python"
>>> print(len(string))
8

1、列表(list)

[元素1,元素2,...,元素n]

列表是可变序列，列表可以放入：整数、实数、布尔值、字符串、序列、对象
1.列表的创建和删除
创建列表
（1）使用赋值运算符直接创建列表

listname = [元素1,元素2,...,元素n]

（2）创建空列表

listname = []

（3）创建数值列表

listname = [数值1,数值2,...,数值n]

#跳一跳
>>> list(range(2,21,2))
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

删除列表

del listname

Python自带垃圾回收机制会自动销毁不用的列表，所以即使我们不手动将其删除，Python也会自动将其回收。
2.访问列表元素
访问列表元素，即获取列表的内容。有三种方法：
（1）直接使用print()函数输出
（2）索引
（3）切片
3.遍历列表
（1）直接使用for循环

for item in listname:
    #输出item

（2）使用for循环和enumerate()函数
enumerate()函数获取索引值，也就是下标

for index,item in enumerate(listname):
    #输出index和item

print("成绩排名：")
student = ["小明","赵四","小赵","李明","张张","李华","王强"]
for index,item in enumerate(student):
    print(index+1,item)

4.添加、修改和删除列表元素
添加元素
（1）追加元素：append()、insert()

列表1.append(新元素)=列表1中的元素,新元素

列表对象提供了insert()方法向列表的指定位置插入元素

列表1.insert(索引值,新元素)

insert()方法没有append()方法执行效率高

student = ["小明","赵四","小赵","李明"]
student.append("我是append添加的")
print(student)
student.insert(1,"我是insert添加的")
print(student)

（2）添加列表：extend()
一个列表的全部元素添加到另一个列表中

listname.extend(seq)

oldlist = ["小明","赵四","小赵","李明"]
newlist = ["张飞","李华"]
oldlist.extend(newlist)
print(oldlist)

修改元素

list = ["长亭外","古道边","一行白鹭上青天"]
list[2] = "芳草碧莲天"
print(list)

删除元素
（1）根据索引删除：del

list = ["长亭外","古道边","一行白鹭上青天"]
print("删除前：",list)
del list[2]
print("删除后：",list)

（2）根据元素值删除：remove()

list = ["长亭外","古道边","一行白鹭上青天"]
print("删除前：",list)
list.remove("一行白鹭上青天")
print("删除后：",list)

5.对列表进行统计计算
获取指定元素出现的次数：count()
获取指定元素首次出现的索引值(下标)：index()
统计数值列表各元素的和：sum()

listname.count(obj)
listname.index(obj)
sum(iterable[,start]) #将统计结果加上start所指定的数，没有默认0

>>> grade = [89,86,69,59,92]
>>> print(sum(grade))
395
>>> print(sum(grade,5))
400

6.对列表进行排序
（1）使用列表对象的sort()方法
使用sort()方法实现排序后，原列表中的元素顺序改变

listname.sort(key=None,reverse=False)
#key=str.lower排序不区分大小写
#reverse=False按升序排序

grade = [89,86,69,59,92,85]
print("原列表",grade)
grade.sort() #进行升序排序
print("升序：",grade)

animal = ["cat","Dog","panda","Tiger"]
print("原动物列表",animal)
animal.sort()
print("升序：",animal)

（2）使用内置的sorted()函数
使用sorted()函数实现排序后原列表的元素顺序不变

sorted(iterable,key=None,reverse=False)

7.列表推导式
列表推导式可以快速生成一个列表，或者根据某个列表生成满足指定需求的列表。

list = [Expression for var in range]

生成随机数的模块：random模块

#生成一个长度为10的随机数列表
#通过循环实现
import random #导入生成随机数的模块
list1 = [] #定义一个空列表
for i in range(10):
    list1.append(random.randint(20,100))
print(list1)
#通过列表推导式实现
import random #导入生成随机数的模块
list2 = [random.randint(20,100) for i in range(10)]
print(list2)

根据列表生成指定需求的列表

newlist = [Expression for var in list]

price = [1000,800,600,750,900]
sale = [int(i*0.5) for i in price]
print("原价：",price)
print("打折后：",sale)

从列表中选择符合条件的元素组成新的列表

newlist = [Expression for var in list if condition]

price = [1000,800,600,750,900]
sale = [i for i in price if i>800]
print("原价：",price)
print("大于800元的：",sale)

8.二维列表的使用
列表类似于一维数组；二维列表类似于二维数组

listname = [[元素1,...,元素n],...,[元素1,...,元素n]]

2、元组(tuple)

和列表类似，把[]换成()。且不能对单个元素像列表那样直接修改。

(元素1,元素2,...,元素n)

列表是不可变序列，元组可以放入：整数、实数、布尔值、字符串、序列、对象
1.元组的创建和删除
创建元组
（1）使用赋值运算符直接创建元组

tuplename = (元素1,元素2,...,元素n)

>>> verse1 = ("我学Pyhon")
>>> print(verse1,type(verse1))
我学Pyhon <class 'str'>
>>> verse2 = ("我学Pyhon",)
>>> print(verse2,type(verse2))
('我学Pyhon',) <class 'tuple'>

（2）创建空元组

tuplename = ()

（3）创建数值元组

tuplename = (数值1,数值2,...,数值n)

#跳一跳
>>> tuple(range(2,21,2))
(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

删除元组

del tuplename

2.访问元组元素
和列表类似。
3.修改元组元素
不能对单个元素像列表那样利用索引值直接修改。

coffeename = ('蓝山','卡布奇诺','摩卡','麝香猫')
print("我是原来的",coffeename)
coffeename = ('蓝山','卡布奇诺','摩卡','拿铁')
print("我是修改后的",coffeename)
newcoffeename = ('麝香猫',)
allcoffeename = coffeename + newcoffeename
print("我是添加后的",allcoffeename)

4.元组推导式
快速生成元组。类似于列表推导式

tuple = (Expression for var in range)

import random #导入生成随机数的模块
tuple1 = (random.randint(20,100) for i in range(10))
print(tuple1)

得到生成器对象

import random #导入生成随机数的模块
tuple1 = (random.randint(20,100) for i in range(10))
print(tuple(tuple1)) #使用tuple()函数进行转换

使用tuple()函数进行转换，得到元组

输出元组元素的值

#通过for循环
import random #导入生成随机数的模块
tuple1 = (random.randint(20,100) for i in range(10))
for i in tuple1:
    print(i,end=' ')
    
#通过__next__()方法
import random #导入生成随机数的模块
tuple1 = (random.randint(20,100) for i in range(10))
#print(tuple1.__next__()) #输出第1个元素
#print(tuple1.__next__()) #输出第2个元素
#......
for j in range(10):
    print(tuple1.__next__(),end=' ')

对生成器对象访问之后，生成器对象就不存在了。若还想使用生成器对象，需要重新生成

import random #导入生成随机数的模块
tuple1 = (random.randint(20,100) for i in range(10))
print(tuple(tuple1))
#通过for循环
for i in tuple1:
    print(i,end=' ')

5.元组与列表的区别
相同点：
（1）都属于序列。
（2）都可以按照一定的顺序存放一组元素，且元素类型不受限制。

不同点：
（1）列表属于可变序列(随时添加、修改或删除)；元组属于不可变序列(不能添加、修改和删除元素，可以整体替换)。
（2）都支持切片操作。列表可以访问、修改元组中的元素；元组只能访问元组中的元素。
（3）列表访问速度慢；元组访问速度快。
（4）列表不能作为字典的键；元组可以作为字典的键。

3、字典(dictionary)

键->下标
字典是可变序列

dictionary = {'key1':'value1','key2':'value2',...,'keyn':'valuen'}

key必须唯一，value可以不唯一。
1.字典的创建和删除
创建字典
（1）创建字典的四种方式
方式一：

>>> dictionary = {'che':'车','chen':'陈','chi':'吃','cheng':'称'}
>>> print(dictionary)
{'che': '车', 'chen': '陈', 'chi': '吃', 'cheng': '称'}

方式二：

>>> dictionary = dict(che = '车',chen = '陈',chi = '吃',cheng = '称')
>>> print(dictionary)
{'che': '车', 'chen': '陈', 'chi': '吃', 'cheng': '称'}

方式三：

key = ['che','chen','chi','cheng'] #音节索引列表
value = ['车','陈','吃','称'] #汉字列表
zip1 = zip(key,value) #转换为zip对象
#zip()函数可以把两个列表对应位置的元素组合为一个元组，并且返回一个zip对象
print(zip1)
word = dict(zip1) #转换为字典
print(word)

方式四：

key = ('che','chen','chi','cheng') #音节索引元组
#key = ['che','chen','chi','cheng'] 错误，列表不能作为字典的键
value = ['车','陈','吃','称'] #汉字列表
dictionary = {key:value}
print(dictionary)

（2）创建空字典

>>> word1 = {}
>>> print(word1)
{}
>>> word2 = dict()
>>> print(word2)
{}

（3）使用dict的fromkeys()方法，创建值为空的字典

key = ['che','chen','chi','cheng']
dictionary = dict.fromkeys(key)
print(dictionary)

删除字典

#删除字典
del dictionary
#清除字典中的所有元素
dictionary.clear()

2.通过键值对访问字典
（1）dict[键]

key = ['che','chen','chi','cheng'] #音节索引列表
value = ['车','陈','吃','称'] #汉字列表
dictionary = dict(zip(key,value)) #转换字典
print(dictionary['che'] if 'chei' in dictionary else '字典里没有这个字！')

（2）get()方法

dictionary.get(key,[default])

key = ['che','chen','chi','cheng'] #音节索引列表
value = ['车','陈','吃','称'] #汉字列表
dictionary = dict(zip(key,value)) #转换字典
print(dictionary.get('che','查无此字'))
#指定的键不存在时，不会抛出异常，返回None(指定默认值则返回默认值)

3.遍历字典

dictionary = {'che':'车','chen':'陈','chi':'吃','cheng':'称'}
#输出可遍历的元组列表
print(dictionary.items())
#items()方法，返回可遍历的元组列表，每个元组即是键和值
print("\n")
#通过for循环，输出每个元组
for item in dictionary.items():
    print(item)
print("\n")
#通过for循环，输出键和值
for key,value in dictionary.items():
    print(key,"的汉字是",value)
print("\n")
#输出键
for key in dictionary.keys():
    print(key)
print("\n")
#输出值
for value in dictionary.values():
    print(value)

4.添加、修改和删除字典元素
添加字典元素

dictionary[key] = value

修改字典元素

dictionary[key] = value

删除字典元素

del dictionary[key]

dictionary = {'che':'车','chen':'陈','chi':'吃','cheng':'称'}
print("原字典：",dictionary)
dictionary["wang"] = "王" #添加元素
print("添加后：",dictionary)
dictionary["wang"] = "网" #修改元素
print("修改后：",dictionary)
del dictionary["wang"] #删除元素
print("删除后：",dictionary)

5.字典推导式
与列表推导式类似

{键值表达式:值表达式 for循环}

import random #导入生成随机数的模块
randomdict = {i:random.randint(20,100) for i in range(10)}
print(randomdict)

4、集合(set)

可变集合set；不可变集合frozenset。
用于保存不重复元素，最好的应用是去重。
不支持索引
集合是可变序列

set = {元素1,元素2,...,元素n}

1.集合的创建
（1）使用赋值运算符直接创建集合

setname = {元素1,元素2,...,元素n}

>>> python = {"小明","赵四","小赵","李明","张张","李华","王强"} #选择pyhon学生名字集合
>>> print(python,type(python))
{'小明', '李华', '李明', '小赵', '王强', '赵四', '张张'} <class 'set'>

（2）创建空集合

#创建空集合
setname = set()

set()还可以将列表、元组等可迭代对象转换为集合
2.集合的添加和删除
添加元素

setname.add(element)
#element不能是列表、元组等可迭代对象

删除元素
（1）删除一个指定元素：remove()

setname.remove(元素名称)

（2）随机删除一个元素：pop()

setname.pop()

（3）删除全部元素：clear()

setname.clear()

删除集合

del setname

3.集合的交集、并集和差集运算

python = {"小明","赵四","小赵","李明","王强"} #选择Pyhon学生名字集合
java = {"赵四","小赵","张张","李华"} #选择Java学生名字集合
print("选择Pyhon学生名字:",python)
print("选择Java学生名字:",java)
print("交集运算",python & java) #既选择Pyhon又选择Java学生名字
print("并集运算",python | java) #参与选课的全部学生名字
print("差集运算",python - java) #选择Python但没有选择Java学生名字

5、列表、元组、字典、集合的区别

后记

学习Python序列的应用(列表、元组、字典、集合)之后，了解并练习了列表、元组、字典、集合的一些常用操作。感觉收获很大，继续学习@_@