【笔记】Python基础学习（二）

四、元组和列表 1、序列的 *** 作

• 字符串的索引值计算同样适合元组和列表

  • 序列索引值从左到右从0开始递增；每个索引值代表一个元素
  • 序列索引值从右到左从-1开始递减；每个索引值代表一个元素

• 元组

  • 小括号（）表示，括号里面可以设置任意数据类型的元素，每个元素使用英文逗号分隔

• 列表

  • 中括号[ ]表示，括号里面可以设置任意元素，每个元素使用英文逗号分隔

# 元组的定义
tuple = (1, '这是字符串', ['这个列表'], ('这是元组'))
# 列表的定义
list = [1, '这是字符串', ['这个列表'], ('这是元组')]

1.1 元素截取

• 元素截取方法

# start是开始索引	start必须在end左边，否则会返回一个空序列
# end是结束索引
# step是步长	1表示从左到右，-1表示从右到左，默认间隔为1,

str[start,end,step]
list[start,end,step]
tuple[start,end,step]

number = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(number[:5:1])
print(number[:-5:-1])

[1, 2, 3, 4, 5]
[10, 9, 8, 7] 

1.2 相加与相乘

• 序列的相加与相乘通过算术运算符【+】和【*】实现同一数据类型的运算
• 仅支持字符串、元组和列表

tuple1 = (1, 2, 3, 4, 5)
tuple2 = (6, 7, 8, 9, 0)
list1 = (1, 2, 3, 4, 5)
list2 = (6, 7, 8, 9, 0)

print('元组相加：', tuple1 + tuple2)
print('元组相乘：', tuple1 * 2)
print('元组相加：', list1 + list2)
print('元组相乘：', list1 * 2)

元组相加： (1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
元组相乘： (1, 2, 3, 4, 5, 1, 2, 3, 4, 5)
元组相加： (1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
元组相乘： (1, 2, 3, 4, 5, 1, 2, 3, 4, 5)

1.3 检测元素是否存在

• 检测某个元素是否存在序列中，可以使用**【in】或【not in】**，适用于字符串、元组、列表、集合、字典
• 对于字符串，只能检测字符串类型的元素是否在字符串中；否则会报异常
• 对于元组和列表，所有的数据类型都可以进行判断是否存在
• 对于集合，只能检测数字类型、字符串、元组是否在集合中；否则报异常TypeError
• 对于字典，只能检测数字类型和字符串类型是否存在于字典中

2、元组的 *** 作 2.1 元组定义和说明

• 元组定义

  • 小括号（）表示，括号里面可以设置任意数据类型的元素，每个元素使用英文逗号分隔

• 元组说明

  • 元组定义后，便无法对元组中的元素进行增加、修改和删除 *** 作，只能读取其中元素

2.2 基本 *** 作

• 虽然不能对元组中的元素增删改，但是可以对元组中的元素进行读取、截取、元组拼接和删除元组

• 元素访问与截取

  • 元组的元素可以通过索引值来访问和截取

tuple = (1, 2, 3, 4, 5, 6, 7, 8)
print('访问第2个元素：', tuple[2])
print('截取第2个到第5个元素：', tuple[1:4])

• 元组拼接
  • 元组的相加与相乘通过算术运算符【+】和【*】实现，拼接得出的元组是一个全新的数据对象

tuple1 = (1, 2, 3, 4, 5)
tuple2 = (6, 7, 8, 9, 0)
print('元组相加：', tuple1 + tuple2)
print('元组相乘:', tuple1 * 2)

元组相加： (1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
元组相乘: (1, 2, 3, 4, 5, 1, 2, 3, 4, 5)

• 元组删除
  • 使用关键字del实现整个元组的删除 *** 作

tuple11 = (1, 2, 3, 4, 5)
del tuple11
print('删除后的元组：', tuple11)

异常提示：NameError: name 'tuple11' is not defined

2.3 计算序列的长度

• len()函数用于获取字符串、元组、列表、集合和字典的长度，即所有元素的总数量

2.4 最大值和最小值

• max()函数用于从字符串、元组或列表中获取其中元素的最大值（字符串元素比较ASCII码）
• min()函数用于从字符串、元组或列表中获取其中元素的最小值

2.5 累加求和

• sum()函数用于对元组或列表中所有元素进行累加求和，并且其中元素只能是数字类型

2.6 格式转换

• tuple()函数用于将字符串、列表、集合和字典转化成元组格式
• 转元组说明
  • 当字符串转元组时，字符串中的每一个字符将作为元组的一个元素
  • 当列表和集合转元组时，列表和集合的元素作为元组的元素，且数据类型不变
  • 当字典转元组时，只会将字典的键转为元组的元素，字典的值将会省略

2.7 查找元素索引

• index()函数能够查找字符串、元组和列表中某个字符对应的索引值

index(sub,start,end)

# sub:需要查找的元素
# start：开始的索引值，默认为0
# end：结束的索引值，默认为总长度

2.8 计算出现元素次数

• count()函数用于计算某个元素在字符串、元组或列表中出现的次数

# obj代表字符串、元组或列表
# 参数sub代表需要计算出现次数的元素

ojb.count(sub)

3、列表的 *** 作 3.1 列表定义

• 列表
  • 中括号[ ]表示，括号里面可以设置任意元素，每个元素使用英文逗号分隔

3.2 基本 *** 作

• 列表定义后，可以对列表的元素进行访问与截取、增加、修改、删除 *** 作，并且能够对这个列表进行 *** 作

• 元素访问与截取

  • 列表的元素可以通过索引值来访问和截取

list = (1, 2, 3, 4, 5, 6, 7, 8)
print('访问第2个元素：', list[2])
print('截取第2个到第5个元素：', list[1:4])

• 元素修改

  • 通过列表的索引值找到该元素后，对该元素进行重新赋值来改变元素的值

• 列表拼接

  • 列表的相加与相乘通过算术运算符【+】和【*】实现，拼接得出的列表是一个全新的数据对象

list1 = (1, 2, 3, 4, 5)
list2 = (6, 7, 8, 9, 0)
print('元组相加：', list1 + list2)
print('元组相乘:', list1 * 2)

列表相加： (1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
列表相乘: (1, 2, 3, 4, 5, 1, 2, 3, 4, 5)

• 删除列表元素或列表
  • 使用关键字del 可以删除列表元素或列表

list1 = [1,2,3,4]
del list1[1]	# 删除列表某个元素
del list1		# 删除列表

3.3 列表新增单个元素

• append()函数在列表末端添加一个新的元素（列表特有函数方法）

# list代表列表对象
# obj代表添加到列表的元素

list.append(obj)

3.4 列表插入元素

• insert()函数在列表中的某个位置插入一条新的数据（列表特有函数方法）

# list代表列表对象
# 参数index代表列表中某个元素的索引值
# 参数object代表需要插入的元素

list.insert(index,object)

3.5 列表新增多个元素

• extend()函数在列表末尾一次性追加另外一个序列中的多个元素
• extend()函数可以将字符串、元组、列表和集合的每一个元素添加到列表中，对于字典只能添加键，值会忽略去掉

# list代表列表
# 参数seq代表需要新增的元素

list.extend(seq)

3.6 列表移除元素

• pop()函数用于移除列表中的某个元素，并返回已移除元素的值，默认移除最后一个元素
• pop()函数还能用于集合和字典
  • 集合使用pop()函数时，不需要设置参数，将随机移除集合中的某个元素
  • 字典使用pop()函数时，需要设置参数K，K是字典某个key

# list代表列表
# 参数obj代表需要移除元素的索引值，默认值为-1，即列表的最后一个元素

list.pop(obj=-1)

3.7 列表移除元素

• remove()函数用于移除列表中的某个元素，存在多个相同元素时，移除索引值最小的元素
  • remove()函数不会返回删除元素，删除成功后返回None
  • remove()函数删除不存在元素时，报异常【x not in list】

# list代表列表
# 参数obj代表需要移除元素

list.remove(obj)

3.8 列表反转

• reverse()函数将列表的元素进行倒序排列；列表特有函数
• 使用了reverse()函数后，原列表的排序发生改变；如果不想改变原列表的排序，可以使用索引值访问方式反转：list[::-1]

# list代表列表
list.reverse()

3.9 列表排序

• sort()函数将列表的元素按照一定规则进行排序，并且改变列表原有的元素排序
  • sort()函数不设置任何参数，就以元素的ASCII码大小进行升序排列
  • sort()函数设置了参数key，就以参数key的方式进行排序

# list代表列表
# 参数key是用来进行比较的元素
# 参数reverse是排序规则，True为降序；False为升序（默认）

list.sort(key=None,reverse=False)

• sorted()函数是对字符串、元组、集合和字典进行排序；它不会改变原数据的排序方式
  • sorted()函数将排序后的结果以列表表示，并不会改变原有数据的数据结构
  • sorted()函数设有参数key和reverse，参数使用方式和sort()的参数相同
  • sorted()函数对字典进行排序时，只会对键（key）值排序，字典值将会被忽略

3.9 清空列表

• clear()函数用于清空列表、集合和字典的所有元素，并返回空列表、空集合和空字典

3.10 复制列表

• copy()函数只能复制列表、集合和字典的数据类型，且只能实现浅拷贝

3.11 格式转换

• list()函数用于将字符串、元组、集合和字典转换为列表格式

• 转列表说明

  • 当字符串转列表时，字符串中的每一个字符将作为列表的一个元素
  • 当元组和集合转列表时，元组和集合的元素作为列表的元素，且元素数据类型不变
  • 当字典转列表时，只会将字典的键转为列表的元素，字典的值将会省略

五、集合和字典 1、集合的创建与 *** 作

• 集合定义
  • 集合是一个无序的不重复元素序列，可以使用大括号【{ }】或者set( )函数创建
  • 创建一个空集合只能用set( )函数；大括号【{ }】不能创建空集合，因为大括号【{ }】创建的是字典

# 创建集合
set1 = {1, 'py2', (1, 2)}
print(set1)

# 使用set()函数创建集合
set2 = set('python')
print(set2)

# 创建空集合
set3 = set()
print(set3)

1.1 集合添加元素

• add( )函数可以在已有的集合中添加一个新的元素；它是集合特有的函数方法
  • 集合中添加的元素类型只能是数字、字符串或元组

# set代表集合对象
# obj代表添加到集合的元素

set.add(obj)

set1 = {1, 'py2', (1, 2)}
set1.add('hello')
print('新增元素hello:', set1)
set1.add(111)
print('新增元素111:', set1)
set1.add((5, 6))
print('新增元素(5,6):', set1)

----------集合添加元素----------
新增元素hello: {1, 'hello', (1, 2), 'py2'}
新增元素111: {1, 'hello', (1, 2), 'py2', 111}
新增元素(5,6): {1, 'hello', (1, 2), 'py2', 111, (5, 6)}

• update( )函数添加元素时可支持Python中所有数据
  • 因为集合中添加元素只能是数字、字符串或元组；所以使用update( )函数添加列表、集合或字典时，Python会自动将它们转化成数字、字符串或元组

set1 = {1, 'py2', (1, 2)}
set1.update([3, 4])
print('新增元素[3,4]:', set1)
set1.update({5, 6})
print('新增元素{5, 6}:', set1)
set1.update([(7, 8), 9])
print('新增元素[(7, 8), 9]:', set1)
set1.update('A', 'B')
print('新增元素"A","B":', set1)

----------集合使用update()添加元素----------
新增元素[3,4]: {1, 3, (1, 2), 4, 'py2'}
新增元素{5, 6}: {1, 3, (1, 2), 4, 5, 6, 'py2'}
新增元素[(7, 8), 9]: {1, 3, (1, 2), 4, 5, 6, 9, 'py2', (7, 8)}
新增元素"A","B": {1, 3, (1, 2), 4, 5, 6, 9, 'py2', 'A', 'B', (7, 8)}

1.2 集合删除元素

• pop( )函数随机删除集合的某个元素
• remove( )和discard( )函数通过传入参数来删除集合中的指定元素
• 以上函数每次执行只能删除一个元素
• 当删除不存在的元素时，remove( )提示KeyError异常；discard( )不会提示任何信息

set1 = {1, 'py2', (1, 2)}
set1.pop()
print('使用pop（）删除元素:', set1)
set1 = {1, 'py2', (1, 2)}
set1.remove('py2')
print('使用remove（）删除元素:', set1)
set1 = {1, 'py2', (1, 2)}
set1.discard('py2')
print('使用discard（）删除元素:', set1)

----------集合删除元素----------
使用pop（）删除元素: {'py2', (1, 2)}
使用remove（）删除元素: {1, (1, 2)}
使用discard（）删除元素: {1, (1, 2)}

1.3 获取两个集合的交集

• intersectioon( )函数是对两个或两个以上的集合进行交集计算，计算的结果以新集合表示；它属于集合的特有函数方法

# set1代表新的集合对象
# s1,s2,s3代表两个或两个以上的集合

set1.intersection（s1,s2,s3）

• intersection_update( )函数也是计算多个集合的交集，但计算结果会覆盖原来的集合

1.4 获取两个集合的并集

• union( )函数是对两个或两个以上的集合进行合并到一个新的集合中，存在重复时会执行去重 *** 作

# set1代表新的集合对象
# s1,s2,s3代表两个或两个以上的集合

set1.union(s1,s2,s3)

1.5 获取两个集合的差集

• difference( )函数是对两个或两个以上的集合进行差集计算，即去掉集合中相同元素去掉并保留在一个新的集合中

# set1代表新的集合对象
# s1,s2,s3代表两个或两个以上的集合

set1.defference(s1,s2,s3)

• difference_update( )函数是把两个或两个以上集合相同的元素去掉，仅保留某一个集合剩下的元素并覆盖在原有的集合中
• symmetric_difference( )函数是把两个或两个以上集合相同的元素去掉，保留所有集合剩下的元素，剩下的元素放在新的集合中
• symmetric_difference_update( )函数将两个或两个以上集合相同的元素去掉，保留所有集合剩下的元素并覆盖到某一个集合中

1.6 判断子集

• issubset( )函数用于判断某个集合的所有元素是否都包含在另一个集合中，如果是就返回True，否则返回False

# set1代表某個集合的所有元素，即子集
# s1代表另一个集合

set1.issubset(s1)

set1 = {1, 2, 3, 4}
set2 = {1, 2}
set3 = {(1, 2)}
result = set2.issubset(set1)
print('set2是否为set1的子集：', result)
result = set3.issubset(set1)
print('set3是否为set1的子集：', result)

----------判断子集----------
set2是否为set1的子集： True
set3是否为set1的子集： False

• issuperset( )函数用于判断某个集合的所有元素是否都包含在另一个集合中

set1 = {1, 2, 3, 4}
set2 = {1, 2}
set3 = {(1, 2)}
result = set1.issuperset(set2)
print('set2是否为set1的子集：', result)
result = set1.issuperset(set3)
print('set3是否为set1的子集：', result)

• issubset( )和issuperset( )区别
  • 由子集作为函数调用对象就使用issubset( )
  • 由父集作为函数调用对象就使用issuperset( )

1.7 格式转换

• set( )函数可以将字符串、元组、列表和字典转化为集合
  • 由于元组和列表的元素类型可以是数字、字符串、元组、列表和字典，但是集合的元素类型只能为数字、字符串和元组；
  • 当元组、列表的元素中含有列表和字典时，set( )函数转集合会出现异常TypeError

2、字典的创建与 *** 作

• 字典定义
  • 字典是使用大括号【{ }】表示的，每个元素以键值对【key:value】表示，键值对之间使用冒号分隔，每个键值对使用逗号隔开
  • 字典key必须是不可变数据类型，value可以是任意类型；字典中key都是唯一的，value没有限制

# 创建字典
d = {'key1': 'value1', 'key2': 'value2'}
# 创建空字典
d = {}
# 使用dict()函数创建字典
d = dict(a=1, b=2)

2.1 基本 *** 作

• 读取某个key的value
  • 读取字典某个key的value可以在字典后面加上中括号【[ ]】,在中括号里面填写字典的某个key

d = {'name': 'Tom', 'age': 10}
# 读取key=name的value
print('读取key=name的value:', d['name'])

• 修改或新增键值对
  • 读取某个key的value时，key不在字典里的则会新建键值对

d = {'name': 'Tom', 'age': 10}
# 重新赋值
d['name'] = 'leilei'
print('读取key=name的value:', d['name'])

# 新增键值对address：guangdong
d['address'] = 'guangdong'

• 删除或情况键值对
  • 删除某个键值或者整个字典，使用关键字del；删除后不再保留改字典的内存空间
  • 使用clear( )函数清空字典的键值对

d = {'name': 'leilei', 'age': 10, 'address': 'guagdong'}
# 删除key=address
del d['address']
# 删除整个字典
del d
# 清空字典
d.clear()

2.2 获取键值

• 使用get( )函数可以读取字典的键值对

# dict 字典对象
# key 字典的key
# default 默认为None，key不存在则取default

dict.get(key,default=None)

• setdefault( )函数功能与get( )相似，区别在于key不存在时，会将函数中参数key和default作为新的键值对插入字典

2.3 删除键值对

• pop( )函数能删除某个键值对；如果key不存在时会使用参数default作为删除结果；如没有设置参数default也会提示TypeError

• popitem( )函数在字典中删除最后一个键值对

# dict 字典对象
# key 字典的key

dict.pop(key,[default])

2.4 获取所有键

• keys( )函数可以获取字典中所有键值对的key；它是字典特有的函数方法，只适用于字典对象

# dict 字典对象

dict_keys = dict.keys()

2.5 获取所有值

• values( )函数可以获取字典中所有键值对的value

# dict 字典对象

dict_values = dict.values()

2.6 获取所有键值

• items( )函数是获取字典所有键值对的key和value

# dict 字典对象

dict.items()

2.7 更新字典

• update( )函数将两个字典合并都某个字典里面

# dict 字典对象
d = {'name': 'Tom'}
b = {'age': 10}
d.update(b)

2.8 格式转换

• dict( )函数可以创建字典以外，还可以将特定格式的元组或列表转换成字典格式；其中元组或列表必须是二维格式

list1 = [['home','GZ']]
l_dict = dict(list1)

tuple1 = (('school', 'GZ'),)
t_dict = dict(tuple1)