Python笔记(1)

五、序列、列表、元组、字典与集合

序列

序列(常见的序列包括字符串、列表、元组等)是一个用于存储多个值的连续空间，每个值都对应一个整数的编号，称为索引。索引又有正向递增索引和反向递减索引之分：

 切片操作的语法结构：序列[start:end:step]，其中start为切片的开始索引（包含）、end为切片的结束索引（不包含）、step为步长（若省略则默认为1）。

例如：

x='helloworld'
x1=x[0:5:2]#切片操作从索引0开始，到索引5结束（不包含5），步长为2
print(x1)

其结果为：hlo

若省略切片开始的位置，则默认从0开始，如：

x='helloworld'
# x1=x[0:5:2]#切片操作从索引0开始，到索引5结束（不包含5），步长为2
# print(x1)
x1=x[:5:2]
print(x1)

其结果也为：hlo

若省略结束位置，则默认到序列的最后一个元素（包含最后一个元素）。

常用操作符/函数：

x in s：如果x是s的元素，则结果为True，否则结果为False

x not in s:如果x不是s的元素，结果为True，否则结果为False

len(s)：序列s中元素的个数（即序列长度）

max(s)：序列s中元素的最大值

min(s)：序列s中元素的最小值

s.index(x)：序列s中第一次出现元素x的位置

s.count(x)：序列s中出现x的个数

列表

列表是指一系列的按特定顺序排列的元素组成；是python中内置的可变序列；在python中使用[ ] 定义列表，元素与元素之间使用英文的逗号隔开，列表中的元素可以是任意的数据类型。

列表的创建方式有两种：

1、直接使用[ ]创建列表，语法结构如下：

列表名=[element1,element2,....elementN]

2、使用内置函数list()创建列表，语法结构如下：

列表名=list(序列)

下面给出列表的一些基本特性和操作：

1.创建列表：

my_list = [1, 2, 3, 'apple', 'banana']

2.访问元素：

使用索引访问列表中的元素，索引从0开始，负数索引表示从末尾开始倒数。

print(my_list[0])    # 输出：1
print(my_list[-1])   # 输出：'banana'

3.切片：

使用切片操作可以获取列表的子序列。

sub_list = my_list[1:4]  # 获取索引1到3的元素，不包括索引4

 4.修改元素：

可以通过索引直接修改列表中的元素。

my_list[2] = 'orange'#此时列表中的3被替换为orange

5.添加元素：

使用'append()'方法在列表末尾添加元素；使用'insert()'方法在指定位置插入元素。

my_list = [1, 2, 3, 'apple', 'banana']
my_list.append(4)
#其运行结果为：my_list = [1, 2, 3, 'apple', 'banana'，4]

my_list = [1, 2, 3, 'apple', 'banana']
my_list.insert(2,'grape')
#其运行结果为：my_list = [1, 2,'grape', 3, 'apple', 'banana']

6.删除元素：

使用remove()方法通过值删除元素；使用del语句通过索引删除元素。使用del 列表名，可以删除整个列表。

my_list.remove('apple')
del my_list[1]

7.长度和成员检查：

使用len()函数获取列表的长度；使用in关键字检查元素是否存在于列表中。

my_list = [1, 2, 3, 'apple', 'banana']
#my_list.insert(2,'grape')
length = len(my_list)
is_present = 'orange' in my_list

print(length)
print(is_present)

8.列表运算：

列表支持拼接和重复操作。

combined_list = my_list + [5, 6]
repeated_list = my_list * 3

9.迭代：

列表可以通过循环遍历其中的元素。

#使用遍历循环for遍历列表元素
for item in my_list:
    print(item)
#使用for循环，range()函数，len()函数，根据索引进行遍历
for i in range(0,len(my_list)):
    print(my_list[i])

 补充列表的相关操作方法：

my_list.clear()：清楚列表my_list中所有元素

my_list.pop(index)：将列表my_list中第index位置的元素删除

my_list.reverse(x)：将列表my_list中的元素反转

my_list.copy()：拷贝列表my_list中的所有元素，生成一个新的列表

列表生成式：

一般语法结构如下：

new_list = [expression for item in iterable if condition]

• expression是对每个 item执行的表达式，用于生成新的列表元素。
• item 是迭代的变量，代表可迭代对象（如列表、元组、字符串等）中的每个元素。
• iterable 是可迭代对象，提供了要遍历的元素集合。
• condition 是一个可选的条件，用于过滤元素。只有满足条件的元素才会包含在新列表中。

以下是一些具体的例子，以帮助理解列表生成式的用法：

1.生成一个数字范围的平方数列表：

squares = [x**2 for x in range(10)]
# 输出：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

 2.筛选出偶数的平方数列表：

even_squares = [x**2 for x in range(10) if x % 2 == 0]
# 输出：[0, 4, 16, 36, 64]

3.将字符串列表转换为大写形式：

words = ['apple', 'banana', 'cherry']
upper_words = [word.upper() for word in words]
# 输出：['APPLE', 'BANANA', 'CHERRY']

元组

元组是python中内置的不可变序列(没有增、删、改等一系列操作)；在python中使用（）定义元组，元素与元素之间使用英文的逗号隔开；元组中只有一个元素的时候，逗号也不能省略。

元组的创建方式有两种：

1.使用（）直接创建元组，语法结构如下：

元组名=(element1,element2,...elementN)

2.使用内置函数tuple()创建元组，语法结构如下：

元组名=tuple(序列)

以下是元组的一些基本特性和操作：

1.创建元组：

my_tuple = (1, 2, 'apple', 'banana')

2.访问元素：

使用索引访问元组中的元素。索引从0开始，负数索引表示从末尾开始倒数。

print(my_tuple[0])    # 输出：1
print(my_tuple[-1])   # 输出：'banana'

3.切片：

使用切片操作可以获取元组的子序列。

sub_tuple = my_tuple[1:3]  # 获取索引1到2的元素，不包括索引3

 4.不可变性质：

元组一旦创建就不能被修改。无法添加、删除或修改元组中的元素。

my_tuple[2] = 'orange'  # 会引发 TypeError

5.长度和成员检查：

使用len()函数获取元组的长度；使用in关键字检查元素是否存在于元组中。

length = len(my_tuple)
is_present = 'orange' in my_tuple

6.元组解包：

元组可以通过解包的形式将其元素分配给多个变量。

a, b, c, d = my_tuple

7.元组拼接：

使用’+‘运算符可以将两个元组拼接起来。

tuple1 = (1, 2, 3)
tuple2 = ('apple', 'banana')
combined_tuple = tuple1 + tuple2

元组和列表的区别：

字典

字典是一种无序、可变的数据类型，用于存储键-值对。每个键必须是唯一的，但是值可以是任意类型的对象，包括数字、字符串、列表、元组等。字典使用花括号{ }表示，键和值之间使用冒号：分割，键-值对之间使用英文逗号分隔（当key相同时，value进行覆盖）。

字典类型的创建方式：

1.直接使用{}创建字典，语法结构如下：

d={key1:value1,key2:value2,....}

2.使用内置函数dict()创建字典，语法结构如下：

dict(key1=value1,key2=value2......)

以下是字典的一些基本特性和操作：

1.创建字典：

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}

2.访问元素：

使用键来访问字典中值。

print(my_dict['name'])  # 输出：'John'
print(my_dict['age'])   # 输出：30

3.添加和修改元素：

通过指定新的键来添加新的键-值对；通过已有的键来修改对应的值。

my_dict['gender'] = 'Male'  # 添加新的键-值对
my_dict['age'] = 31         # 修改值

4.删除元素：

使用del语句删除指定键-值对；使用pop()方法删除指定键，并返回对应的值。

del my_dict['city']  # 删除键为'city'的键-值对
popped_value = my_dict.pop('age')  # 删除键为'age'的键-值对，并返回对应的值

5.获取所有键和值：

使用keys()方法获取所有键；使用value()方法获取所有值；使用items()方法获取所有键-值对。

all_keys = my_dict.keys()
all_values = my_dict.values()
all_items = my_dict.items()

6.长度和成员检查：

使用len()函数获取字典的键-值对数量；使用in关键字检查键是否存在于字典中。

length = len(my_dict)
is_present = 'name' in my_dict

7.嵌套字典：

字典中的值也可以是字典，形成嵌套结构。

nested_dict = {'person': {'name': 'Alice', 'age': 25}}

常用操作方法：

my_dict.keys()：获取所有key数据

my_dict.values()：获取所有value数据

my_dict.pop(key,default)：key存在则获取相应的value，同时删除该键-值对，否则获取默认值

my_dict.popitem()：随即从字典中获取一个键值对，结果为元组类型，同时将该键值对从字典中删除

my_dict.clear()：清空字典中所有的键值对

字典生成式：

d={key:value for item in range}

import random
d={item:random.randint(1,100)for item in range(4)}
print(d)

集合

python中的集合与数学中集合的概念一致，是一个无序的不重复元素列表；集合只能存储不可变数据类型；使用{}定义；与列表、字典一样，都是python中的可变数据类型。

集合的创建方式有两种：

1.直接使用{}创建集合，语法结构如下：

s={element1,element2,....elementN}

2.使用内置函数set()创建集合，语法结构如下：

s=set(可迭代对象)

以下是集合的一些基本特性和操作：

1.创建集合：

my_set = {1, 2, 3, 4, 5}

2.添加元素：

使用add()方法添加单个元素；使用update()方法添加多个元素。

my_set.add(6)
my_set.update([7, 8, 9])

3.删除元素：

使用remove()方法删除指定元素，如果元素不存在，会引发KeyError；使用discard()方法删除指定元素，但如果元素不存在，不会引发错误；使用pop()方法随机删除并返回一个元素。

my_set.remove(3)
my_set.discard(10)
popped_element = my_set.pop()

4.集合运算：

集合支持交集、并集、差集等运算。

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
intersection = set1 & set2  # 交集
union = set1 | set2        # 并集
difference = set1 - set2   # 差集