Python学习第3弹——序列、列表、元组、字典、集合

在Python中，赋给变量的值是什么类型就决定了变量的类型。
int() —— 整型
float() —— 浮点型
str() —— 字符串类型
hex() —— 整数转换成十六进制字符串
int() —— 整数转换成八进制字符串

序列

序列是一块用于存放多个值的连续内存空间，并且按一定顺序排列，可以通过索引取值。

索引

索引（index）就是一个编号。
1、索引从 0 开始计数。

string = ("失望之酒，希望之杯")
print(string[1])   # 输出“望”字

2、索引可以是负数，且从 -1 开始。

string = ("失望之酒，希望之杯")
print(string[-2])   # 输出“之”字

切片

切片用于从序列中取出一部分。
sname[start🔚step]
sname 序列名称
start 切片的起始值（包括）
end 切片的结束值（不包括）
step 切片的步长

nba = ['语文','数学','英语','物理','化学','生物']
print(nba[0:3])  # 输出 ['语文', '数学', '英语']

序列相加

只能是同类型的序列相加：
列表 + 列表
元组 + 元组
字符串 + 字符串

序列乘法

序列 * 乘数 = 重复 n 次的序列

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

“要检查的元素 in 序列”

nba = ['语文','数学','英语','物理','化学','生物']
print('语文' in nba)  # 输出 True

nba = ['语文','数学','英语','物理','化学','生物']
print('语文' not in nba)  # 输出 False

计算序列的长度、最大值和最小值

计算序列的长度——len()

number = [1,2,3,4,5]
print('列表的长度：', len(number))  # 输出 5

string = '我学Python'
print(len(string))  # 输出 8

返回序列的最大元素——max()

返回序列的最小元素——min()

列表（list）

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

列表的创建和删除

列表的创建

1、使用赋值运算符直接创建列表
列表名称 = [元素1,元素2,…,元素n]
2、创建空列表
empty = []
3、创建数值列表
每个元素都是数字类型。

列表的删除

del 列表名称
但是，Python会自动删除不用的列表，释放内存空间。

访问列表元素

1、直接使用print()函数输出
2、索引
3、切片

eg：输出“每日一贴”

import datetime   # 导入日期时间类
mot = ['今天星期一：\n坚持下去不是因为我很坚强，而是因为我别无选择。',
       '今天星期二：\n含泪播种的人一定会笑着收获。',
       '今天星期三：\n做对的事情比把事情做对重要。',
       '今天星期四：\n命运给予我们的不是希望之酒，而是机会之杯。',
       '今天星期五：\n不要等到明天，明天太遥远，今天就行动。',
       '今天星期六：\n求知若饥，虚心若愚。',
       '今天星期日：\n成功属于那些从不说“不可能”的人。'
       ]
day = datetime.datetime.now().weekday()  # 获取当前的星期（0-6的数值）
print(mot[day])  # 输出每日一贴

遍历列表

1、直接使用for循环
for item in 列表名称： # 输出item（列表元素内容）

print('高中必修课排名：')
lesson = ['语文','数学','英语','物理','化学','生物']
for item in lesson:
    print(item)  # 输出每门课程的名称

2、使用for循环和enumerate()函数
for index,item in enumerate(列表名称)：
# 输出index（列表索引）和item（列表元素内容）

print('高中必修课程：')
lesson = ['语文','数学','英语','物理','化学','生物']
for index,item in enumerate(lesson):
    print(index,item)   # 从0开始排

print('高中必修课程：')
lesson = ['语文','数学','英语','物理','化学','生物']
for index,item in enumerate(lesson):
    print(index+1,item)   # 从1开始排

eg：分两列显示2017~2018赛季NBA西部联盟前八名球队

print('\n2017~2018赛季NBA西部联盟排名：\n')
team = ['火箭','勇士','开拓者','雷霆','爵士','鹈鹕','马刺','森林狼']
for index,item in enumerate(team):
    if index%2 == 0:
        print(item + "\t\t",end='')   # 不换行输出
    else:
        print(item + "\n")            # 换行输出

添加、修改和删除列表元素

添加元素

添加元素1——append ()追加元素

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

添加元素2——insert ()指定位置

向列表的指定位置添加元素。
列表1.insert(索引，新元素)

添加元素3——extend ()添加列表

列表名称.extend (seq)

修改元素——赋值实现

删除元素

根据索引删除 —— del语句

根据值删除 —— remove ()

列表1.remove (‘字符串’)

对列表进行统计计算

count () —— 获取指定元素出现次数

列表名称.count (obj)

index () —— 获取指定元素首次出现时的下标

列表名称.index (obj)

sum () —— 求和

sum (列表名称)
sum (列表名称,start) # 统计结果加上start指定的数

对列表进行排序

使用列表对象的sort ()方法——原列表元素顺序改变

列表名称.sort (key=None, reverse=False)

grade = [89,98,90,76,100]
print('原来的成绩：',grade)
grade.sort()
print('升序的成绩：',grade)

原来的成绩： [89, 98, 90, 76, 100]
升序的成绩： [76, 89, 90, 98, 100]

list = ['cat','Tom','Angela','pet']
print('原列表：', list)
list.sort()
print('升序列表：', list)

原列表： [‘cat’, ‘Tom’, ‘Angela’, ‘pet’]
升序列表： [‘Angela’, ‘Tom’, ‘cat’, ‘pet’]
# 先排列首字母为大写字母的，后小写字母

list = ['cat','Tom','Angela','pet']
print('原列表：', list)
list.sort(key=str.lower)
print('升序列表：', list)

原列表： [‘cat’, ‘Tom’, ‘Angela’, ‘pet’]
升序列表： [‘Angela’, ‘cat’, ‘pet’, ‘Tom’]
原列表： [‘cat’, ‘Tom’, ‘Angela’, ‘pet’]
升序列表： [‘Angela’, ‘cat’, ‘pet’, ‘Tom’]
# 不区分首字母大小写的升序排列

使用内置的sorted ()函数——原列表元素顺序不变

sorted (列表名称, key=None, reverse=False)

列表推导式

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

list = [ 表达式 for 循环变量 in range()函数 ]

list1 = [i*i for i in range(2,11,2)]
print(list1)

输出：[4, 16, 36, 64, 100]

newlist = [ 表达式 for 循环变量 in list ]

price = [500,600,888,1002,345]
sale = [0.5*i for i in price]
print(sale)

输出：[250.0, 300.0, 444.0, 501.0, 172.5]

newlist = [ 表达式 for 循环变量 in list if condition ]

price = [500,600,888,1002,345]
sale = [i for i in price if i>800]
print(sale)

输出：[888, 1002]

元组（tuple）

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

元组的创建和删除

元组的创建

1、使用赋值运算符直接创建元组
元组名称 = ( 元素1,元素2,…,元素n )
2、创建空元组
empty = ()
3、创建数值元组
每个元素都是数字类型。

元组的删除

del 元组名称
但是，Python会自动回收不用的元组。

访问元组的元素

1、直接使用print()函数输出
2、索引
3、切片

修改元组元素

元组是不可变的，不能对单个元素进行修改，可以对整个元组重新赋值。

lesson1 = ('语文','数学','英语','物理','化学','生物')
lesson2 = ('政治','历史','地理')
lesson = lesson1 + lesson2
print(lesson)

输出：(‘语文’, ‘数学’, ‘英语’, ‘物理’, ‘化学’, ‘生物’, ‘政治’, ‘历史’, ‘地理’)

lesson1 = ('语文','数学','英语','物理','化学','生物')
lesson2 = ('政治',)
lesson = lesson1 + lesson2
print(lesson)

输出：(‘语文’, ‘数学’, ‘英语’, ‘物理’, ‘化学’, ‘生物’, ‘政治’)

遍历元组

1、直接使用for循环

for item in 元组名称：

# 输出item（列表元素内容）

print('高中必修课排名：')
lesson = ('语文','数学','英语','物理','化学','生物')
for item in lesson:
    print(item)  # 输出每门课程的名称

2、使用for循环和enumerate()函数
for index,item in enumerate(列表名称)：
# 输出index（列表索引）和item（列表元素内容）

print('高中必修课程：')
lesson = ('语文','数学','英语','物理','化学','生物')
for index,item in enumerate(lesson):
    print(index,item)   # 从0开始排

print('高中必修课程：')
lesson = ('语文','数学','英语','物理','化学','生物')
for index,item in enumerate(lesson):
    print(index+1,item)   # 从1开始排

eg：分两列显示2017~2018赛季NBA西部联盟前八名球队

print('\n2017~2018赛季NBA西部联盟排名：\n')
team = ('火箭','勇士','开拓者','雷霆','爵士','鹈鹕','马刺','森林狼')
for index,item in enumerate(team):
    if index%2 == 0:
        print(item + "\t\t",end='')   # 不换行输出
    else:
        print(item + "\n")            # 换行输出

元组推导式

和列表推导式相似，只是将[ ]换成( )。

import random   # 导入随机数模块
randomnumber = (random.randint(10,100) for i in range(10))
print(randomnumber)

输出：<generator object at 0x0000000000649DE0>
得到一个生成器对象，若要想得到一个元组，需要用tuple ()函数进行转换。

import random   # 导入随机数模块
randomnumber = (random.randint(10,100) for i in range(10))
print(tuple(randomnumber))

输出：(41, 74, 35, 32, 40, 16, 71, 56, 83, 99)

元组和列表的区别

字符串

拼接字符串

student_1 = '学生甲：你叫什么名字？'
student_2 = '学生乙：我叫乙。'
print(student_1 + '\n' + student_2)

学生甲：你叫什么名字？
学生乙：我叫乙。

计算字符串长度

string1 = '人生苦短，我用Python！'
print(len(string1))
print(len(string1.encode()))   # 计算UTF-8编码的字符串长度（每个汉字占3个，英文占1个）
print(len(string1.encode('gbk')))   # 计算GBK编码的字符串长度（每个汉字占2个）

输出：
14
30
22

截取字符串

str1 = "人生苦短，我用Python！"
print(str1[2])   # 获取第3个字符
print(str1[:5])  # 从左边开始截取5个字符
print(str1[5:])  # 从第6个字符截取
print(str1[2:5]) # 截取第3到第5个字符
print(str1[:5:2])  # 指定步长

输出：
苦
人生苦短，
我用Python！
苦短，
人苦，

p1 = '你知道我的生日吗？'
print('甲说：“',p1,'”')
p2 = '告诉我你的身份证号码。'
print('乙说：“',p2,'”')
idcard = '123456199006277890'
print('甲说：“',idcard)
birthday = idcard[6:10] + '年' + idcard[10:12] + '月' + idcard[12:14] + '日'
print('乙说：“你是'+birthday+'出生的，所以你的生日是'+birthday[5:]+'。”')

甲说：“ 你知道我的生日吗？ ”
乙说：“ 告诉我你的身份证号码。 ”
甲说：“ 123456199006277890
乙说：“你是1990年06月27日出生的，所以你的生日是06月27日。”

分割字符串

列表名称 = str. split (sep, maxsplit)
其中：
sep 是分隔符，可以是 空格、换行符“\n”’、制表符“\t”
maxsplit 是分割次数，-1表示没有限制，能分割多少就分割多少

str1 = '@张国荣 @梅艳芳 @王祖贤'
list1 = str1.split(' ')   # 用空格分隔字符串
for item in list1:
    print(item[1:])   # 输出每个好友，并去掉 @ 符号

张国荣
梅艳芳
王祖贤

合并字符串

strnew = string. join (iterable)
其中：string表示合并时的分隔符；iterable可迭代对象可以是列表。元组。

list1 = ['张国荣', '梅艳芳', '王祖贤']
str1 = ' @'.join(list1)   # 用空格和 @ 进行连接
at = '@' + str1
print('您想@的好友为：', at)

您想@的好友为： @张国荣 @梅艳芳 @王祖贤

检索字符串

count () —— 获取一个字符串出现次数

字符串名称. count (‘要检索的字符串’, 起始位置, 结束位置)
后两个可以缺省。

index () —— 获取指定元素首次出现时的下标（不存在时抛出异常）

字符串名称. index (‘要检索的字符串’, 起始位置, 结束位置)
后两个可以缺省。

find () —— 获取一个字符串在另一个字符串中首次出现时的下标

字符串名称. find (‘要检索的字符串’, 起始位置, 结束位置)
后两个可以缺省。

startwith () —— 检查字符串是否以指定字符串开始

字符串名称. startwith (‘要检索的字符串’, 起始位置, 结束位置)
后两个可以缺省。

endwith () —— 检查字符串是否以指定字符串结束

字符串名称. endwith (‘要检索的字符串’, 起始位置, 结束位置)
后两个可以缺省。

字母的大小写转换

字符串名称. lower () -—— 大写转小写
字符串名称. upper () —— 小写转大写

去除字符串的空格和特殊字符

特殊字符：\t \n \r
字符串名称. strip (‘字符串’) —— 用于截掉字符串两边的空格或指定字符
字符串名称. lstrip (‘字符串’) —— 用于截掉字符串左边的空格或指定字符
字符串名称. rstrip (‘字符串’) —— 用于截掉字符串右边的空格或指定字符

格式化字符串 —— 使用字符串对象的format ()方法

str. format (args)
其中：
str 是模板，格式为：
{ index : fill align sign # width . precision type }

template = '编号： {:0>9s}\t公司名称：{:s}\t官网：http://www.{:s}.com'   # 模板
context1 = template.format('7','百度','baidu')
context2 = template.format('8','明日科技','mingrisoft')
print(context1)
print(context2)

编号： 000000007 公司名称：百度 官网：http://www.baidu.com
编号： 000000008 公司名称：明日科技 官网：http://www.mingrisoft.com

eg：format 格式化不同的数值类型数据

import math     # 导入数学模块
print('以货币形式显示： ￥{:,.2f}元'.format(1251+3950))   # 以货币形式显示
print('{0:.1f}用科学计数法表示： {0:E}'.format(120000.1))     #用科学计数法显示
print('π 取5位小数： {:.5f}'.format(math.pi))     # 输出小数点后5位
print('{0:d}的十六进制是： {0:#x}'.format(100))    # 十六进制显示
print('天才是由{:.0%}的灵感，加上{:.0%}的汗水。'.format(0.01,0.99))

以货币形式显示： ￥5,201.00元
120000.1用科学计数法表示： 1.200001E+05
π 取5位小数： 3.14159
100的十六进制是： 0x64
天才是由1%的灵感，加上99%的汗水。

使用正则表达式分割字符串

正则表达式是一种用来匹配字符串的强有力的武器。设计思想是用一种描述性的语言来给字符串定义一个规则，凡是符合规则的字符串，就认为它“匹配”，否则就不匹配。

行定位符

^ 表示开始
$ 表示结束

元字符

限定符

匹配字符串

import re
re. match (pattern, string, [flags])

替换字符串

流程控制语句

if…elif…else…

print('在古希腊神话中，玫瑰集爱与美于一身。人们常用玫瑰来表达爱情。\n送不同朵数的玫瑰花代表的含义也不同。')
number = int(input('输入您想送几朵玫瑰花，小婕会告诉您含义：'))
if number==1:
    print('1朵：你是我的唯一！')
elif number==3:
    print('3朵：I love you！')
elif number == 10:
    print('10朵：十全十美！')
elif number==99:
    print('99朵：天长地久！')
elif number==108:
    print('108朵：求婚！')
else:
    print('小婕也不知道了，可以考虑送1朵、3朵、10朵、99朵、108朵呦！')

循环语句

for循环

range ()函数，用于生成一系列连续整数。
range (start, end, step)

print('计算1+2+3+…+100的结果为：')
result = 0      # 保存累加结果的变量
for i in range(101):
    result += i
print(result)

计算1+2+3+…+100的结果为：
5050

for i in range(1,10,2):
    print(i)

1
3
5
7
9

for i in range(1,10,2):
    print(i,end=' ')

1 3 5 7 9

while循环

print('今有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二，问几何？\n')
none = True     # 作为循环条件的变量
number = 0      # 计数变量
while none:
    number += 1     # 计数加1
    if number%3==2 and number%5==3 and number%7==2:
        print('答曰：这个数是',number)
        none = False  # 若无，循环一直进行

今有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二，问几何？

答曰：这个数是 23

循环嵌套

eg：输出九九乘法表

for i in range(1,10):   # 控制行数
    for j in range(1,i+1):      # 输出与行数相等的列数
        print(str(j)+'×'+str(j)+'='+str(j*i)+'\t',end='')
    print('')   # 换行

break语句——完全跳出循环

print('今有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二，问几何？\n')
for number in range(100):
    print(number)
    if number%3==2 and number%5==3 and number%7==2:
        print('答曰：这个数是',number)
        break  # 跳出循环

今有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二，问几何？

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
答曰：这个数是 23

continue语句——终止本次循环，继续下次循环

字典（dictionary）

dictionary = { ‘key1’ : ‘value1’ , ‘key2’ : ‘value2’ , … , ‘keyn’ : ‘valuen’ }

字典的创建和删除

字典的创建

1、使用赋值运算符直接创建元组

word = {'chi':'吃', 'che':'车', 'cheng':'称'}      # 创建一个字典
print(word)

2、列表的转换
dict ( zip ( list1, list2) )

key = ['chi', 'che', 'cheng']       # 音节索引列表
value = ['吃', '车', '称']     # 汉字列表
zip1 = zip(key,value)      # 转换为zip对象
print(zip1)
word = dict(zip1)       # 转换为字典
print(word)

3、键值对

dictionary = dict(chi='吃',che='车',cheng='称')
print(dictionary)

4、dict对象的fromkeys ()方法

key = ['chi', 'che', 'cheng']       # 音节索引
dictionary = dict.fromkeys(key)
print(dictionary)

字典的删除

1、del 字典名称
2、字典名称. clear () —— 删除字典元素

访问字典元素

通过键值对访问——字典名称[key]

word = {'chi':'吃', 'che':'车', 'cheng':'称'}      # 创建一个字典
print(word['chi'] if 'chi' in word else '字典里没有这个字')

吃

通过字典对象的get ()访问——字典名称. get ( key, [defalt] )

遍历字典

1、通过items和for循环

sign = {'绮梦':'水瓶座','冷伊一':'射手座','香凝':'双鱼座','黛兰':'双子座'}
for item in sign.items():
    print(item)

输出元组：
(‘绮梦’, ‘水瓶座’)
(‘冷伊一’, ‘射手座’)
(‘香凝’, ‘双鱼座’)
(‘黛兰’, ‘双子座’)

sign = {'绮梦':'水瓶座','冷伊一':'射手座','香凝':'双鱼座','黛兰':'双子座'}
for key,value in sign.items():
    print(key,value)

输出键值对：
绮梦 水瓶座
冷伊一 射手座
香凝 双鱼座
黛兰 双子座

sign = {'绮梦':'水瓶座','冷伊一':'射手座','香凝':'双鱼座','黛兰':'双子座'}
for key in sign.keys():
    print(key)

输出键列表：
绮梦
冷伊一
香凝
黛兰

sign = {'绮梦':'水瓶座','冷伊一':'射手座','香凝':'双鱼座','黛兰':'双子座'}
for value in sign.values():
    print(value)

输出值列表：
水瓶座
射手座
双鱼座
双子座

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

字典名称 [ key ] = value

del 字典名称 [ key ]

字典推导式

和列表推导式相似，只是将[ ]换成{ }。

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

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

输出：
{1: 80, 2: 84, 3: 76, 4: 48}

name = ['绮梦','冷伊一','香凝','黛兰']           # 保存名字的列表
sign = ['水瓶座','射手座','双鱼座','双子座']     # 保存星座的列表
dict = {i:j for i,j in zip(name,sign)}        # 字典推导式
print(dict)

输出：
{‘绮梦’: ‘水瓶座’, ‘冷伊一’: ‘射手座’, ‘香凝’: ‘双鱼座’, ‘黛兰’: ‘双子座’}

集合（set）

用于保存不重复的元素，最好的应用是去重。

集合的创建

{ 元素1，元素2，……，元素n }
空集合：set ()
可以通过set ()函数将列表转换为集合

集合的添加和删除

集合的添加

集合名称. add ( 元素 )

集合的删除

remove () 删除一个指定元素
pop () 随机删除一个元素
clear () 删除全部元素

集合的交、并、差集运算

交集：既选择A又选择B
并集：选择A和B，去除重复
差集：选择A但没有选择B

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