Python入门之序列操作

一、字符串

字符串是不可变对象，所以以下操作若发生字符串变动都是产生新的字符串

1、字符串的拼接（+）

字符串拼接运用 + 运算符

var1 = "hello"
var2 = "world"
print(var1+var2)  # helloworld

2、字符串截取

通过索引获取或通过切片方式获取子字符串

var1 = "hello world"
print(var1[2])          # l 
print(var1[-1])         # d
print(var1[1:5])        # ello
print(var1[1:])         # ello world
print(var1[:-1])        # hello worl
print(var1[-3:-1])      # rl

3、替换

使用replace()方法可以实现字符串中某个子串的替换

var1 = "hello world"
print(var1.replace("l", "k"))   # hekko workd
print(var1.replace("lo", "kk"))   # helkk world

4、大小写转换

使用upper()和lower()方法可以将字符串中的所有字符转换为大写或小写字母

var1 = "Hello World"
print(var1.upper())     # HELLO WORLD
print(var1.lower())     # hello world

5、字符串分割

使用split()方法可以将字符串按照指定分隔符进行拆分。

var1 = "Hello World"
print(var1.split(" "))  	# ['Hello', 'World']

衍生出 rsplit() 方法可以从右往左分割

6、去除首尾字符

使用strip()方法可以取出字符串首尾指定字符，默认为去除所有空字符（空格，换行符等）

var1 = "**Hello**World**"
print(var1.strip("*"))  # Hello**World

衍生出 lstrip() 方法和 rstrip() 方法分别是去除左边和去除右边的指定字符串。

7、查找子字符串

1、使用find() 方法查找子字符串在此字符串的索引位置，如果此字符串不包含子字符串返回-1。
2、使用index() 方法查找子字符串在此字符串的索引位置,如果此字符串不包含子字符串则会报错。
3、使用count() 方法此字符串中包含子字符串的个数。

var1 = "**Hello**World**"
print(var1.find("He"))      # 2

print(var1.index("He"))    # 2

print(var1.count("l"))   # 3

str类提供的方法有很多这里不做赘述，更多的方法自行查看官方文档和方法注释

二、列表

列表（list）是可变数据类型，列表中的元素可以是任意类型。

1、创建

my_list = []  # 创建空列表
my_list = [1, 2, 3]  # 创建包含三个元素的列表
my_list = list("hello")  # 将字符串转换为列表，结果为 ['h', 'e', 'l', 'l', 'o']

2、增

2.1 append()

append方法向列表末尾添加单个元素。

my_list = ['h', 'e', 'l', 'l', 'o']

my_list.append("w")
print(my_list)  #  ['h', 'e', 'l', 'l', 'o', 'w']

2.2 extend()

extend方法将序列中所有元素添加到列表后面。

my_list = ['h', 'e', 'l', 'l', 'o']

my_list.extend([1])
print(my_list)  #  ['h', 'e', 'l', 'l', 'o', 'w']

2.3 insert()

extend方法在指定位置插入元素。

my_list = ['h', 'e', 'l', 'l', 'o']

my_list.insert(1, "h")  #  ['h', 'h', 'e', 'l', 'l', 'o']

3、查

3.1 切片和索引

my_list = ['h', 'e', 'l', 'l', 'o']
print(my_list[0])  # 输出第一个元素，结果为 'h'
print(my_list[-1])  # 输出最后一个元素，结果为 'o'
print(my_list[1:4])  # 输出第二个到第四个元素，结果为 ['e', 'l', 'l']
print(my_list[::2])  # 输出每隔一个元素的元素，结果为 ['h', 'l', 'o']

3.2 index()

index 方法可以查找指定元素在列表中的索引。如果有存在多个一样的元素，只会返回离查找指定的开始位置最近的那个索引。如果要查找的元素不存在于列表中则会报错。

my_list = ['h', 'e', 'l', 'l', 'o', 'h', 'e', 'l', 'l', 'o']

print(my_list.index("h"))  # 0
print(my_list.index('o', 4))  # 7

4、删

4.1 del

del 关键字可以删除指定位置的元素或整个列表

my_list = ['h', 'e', 'l', 'l', 'o', 'h', 'e', 'l', 'l', 'o']

del(my_list[3])  # ['h', 'e', 'l', 'o', 'h', 'e', 'l', 'l', 'o']

4.2 remove()

remove方法可以删除指定元素，如果指定元素在列表中存在多个则只删除最前面的那个。

my_list = ['h', 'e', 'l', 'l', 'o', 'h', 'e', 'l', 'l', 'o']

my_list.remove("o")  # ['h', 'e', 'l', 'l', 'h', 'e', 'l', 'l', 'o']

4.3 pop()

pop方法删除指定索引的元素并返回其值

my_list = ['h', 'e', 'l', 'l', 'o', 'h', 'e', 'l', 'l', 'o']

print(my_list.pop(1))  # e
print(my_list)  # ['h', 'l', 'l', 'o', 'h', 'e', 'l', 'l', 'o']

4.4 clear()

clear方法清空列表中所有元素

my_list = ['h', 'e', 'l', 'l', 'o', 'h', 'e', 'l', 'l', 'o']

my_list.clear()
print(my_list)  # []

5、改

5.1 用索引修改元素

my_list = ['h', 'e', 'l', 'l', 'o', 'h', 'e', 'l', 'l', 'o']

my_list[1] = 1
print(my_list) # ['h', 1, 'l', 'l', 'o', 'h', 'e', 'l', 'l', 'o']

5.2 用切片修改元素

my_list = ['h', 'e', 'l', 'l', 'o', 'h', 'e', 'l', 'l', 'o']

my_list[1:3] = (1, 2)  
print(my_list)  # ['h', 1, 2, 'l', 'o', 'h', 'e', 'l', 'l', 'o']

6、排序 sort()

sort方法将列表元素按一定顺序排列。其中有个reverse参数，这个参数默认为False，当其为True时，列表倒序排列。

my_list = ['h', 'e', 'l', 'l', 'o', 'h', 'e', 'l', 'l', 'o']

my_list.sort()
print(my_list)  # ['e', 'e', 'h', 'h', 'l', 'l', 'l', 'l', 'o', 'o']

7、翻转 reverse()

reverse方法将列表中的元素前后翻转。

"""
my_list = ['h', 'e', 'l', 'l', 'o', 'h', 'e', 'l', 'l', 'o']

my_list.reverse()  
print(my_list) # ['o', 'l', 'l', 'e', 'h', 'o', 'l', 'l', 'e', 'h']

8、长度 len()

len方法获取列表长度

my_list = ['h', 'e', 'l', 'l', 'o', 'h', 'e', 'l', 'l', 'o']

print(len(my_list))  # 10

9、统计元素个数 count()

使用count方法可以得到指定元素在列表中的个数

my_list = ['h', 'e', 'l', 'l', 'o', 'h', 'e', 'l', 'l', 'o']

print(my_list.count("l"))

三、元组

元组操作与列表类似，不过由于它是不可变类型，所以列表中对元素修改等原地修改的操作不能用于元组。

1、创建

可以使用圆括号 () 或 tuple() 函数来创建一个空元组或包含元素的元组。

# 创建空元组
my_tuple = ()  
my_tuple = tuple()


my_tuple = (1,)  # 创建只包含一个元素的元组
my_tuple = tuple("可迭代对象")

2、访问（查）

可以使用索引或切片操作来访问元组中的元素，跟列表用法一样。

3、解包

可以使用元组解包来将元组中的元素赋值给多个变量。元组解包可以通过将变量列表放在等号左边，并将元组放在等号右边来实现。

my_tuple = (1, 2, 3)

a, b, c = my_tuple
print(a)  # 1
print(b)  # 2
print(c)  # 3

4、其他操作

4.1 index()

index方法，功能及用法跟列表一致。

4.2 count()

count方法功能及用法跟列表一致。

4.3 len()

通用的len方法，用法参照列表节点中介绍。

四、字典

1、创建

# 创建空字典
my_dict = dict()  
my_dict = {}

# 初始化字典
my_dict = {1: "python", 2: "C", 3: "C++", 4: "C#"}

2、访问

可以使用键来访问字典中的值。如果键不存在，则会抛出KeyError异常。

my_dict = {1: "python", 2: "C", 3: "C++", 4: "C#"}
print(my_dict[1])  # python

3、添加和修改

可以使用赋值语句来添加或修改字典中的元素。

my_dict = {1: "python", 2: "C", 3: "C++", 4: "C#"}
my_dict[5] = "java"

print(my_dict)  # {1: 'python', 2: 'C', 3: 'C++', 4: 'C#', 5: 'java'}

my_dict[5] = "PHP"
print(my_dict)  # {1: 'python', 2: 'C', 3: 'C++', 4: 'C#', 5: 'PHP'}

4、删除

4.1 可以使用del语句来删除字典中的元素。

my_dict = {1: "python", 2: "C", 3: "C++", 4: "C#"}
del my_dict[3]
print(my_dict)  # {1: 'python', 2: 'C', 4: 'C#'}

4.2 pop()

pop方法接受一个key参数，移除指定键值对并返回值。

my_dict = {1: "python", 2: "C", 3: "C++", 4: "C#"}
print(my_dict.pop(4))  # 'C#'
print(my_dict)  # {1: 'python', 2: 'C', 3: 'C++'}

4.3 popitem() （3.7往后版本）

popitem 方法移除最后一个键值对

my_dict = {1: "python", 2: "C", 3: "C++", 4: "C#"}
print(my_dict.popitem())  # (4, 'C#')
print(my_dict)  # {1: 'python', 2: 'C', 3: 'C++'}

5、其他方法

5.1 update()

传入的字典通过映射方式修改源字典。

my_dict = {1: "python", 2: "C", 3: "C++", 4: "C#"}
print(my_dict.update({4: "PHP", 5: "C#"}))  # (4, 'C#')
print(my_dict)  # {1: 'python', 2: 'C', 3: 'C++', 4: 'PHP', 5: 'C#'}

5.2 fromkeys()

语法：dict.fromkeys( _item,_value)
该方法功能是创建一个新字典，字典的键是参数item的元素，所有的值都是value

print(dict.fromkeys(["1", "2"], "python"))
{'1': 'python', '2': 'python'}

5.3 setdefault()

语法：dict.setdefault(_k,_v)
如果key不在字典中，则使用default值插入key。
如果key在字典中，则返回key的值，否则返回默认值。

my_dict = {1: "python", 2: "C", 3: "C++", 4: "C#"}
print(my_dict.setdefault(1, "0"))  # (4, 'C#')  # python

5.4 keys()

返回字典中所有键的列表。

my_dict = {1: "python", 2: "C", 3: "C++", 4: "C#"}
print(my_dict.keys())  # dict_keys([1, 2, 3, 4])

5.5 values()

返回字典中所有值的列表。

my_dict = {1: "python", 2: "C", 3: "C++", 4: "C#"}
print(my_dict.values())  # dict_values(['python', 'C', 'C++', 'C#'])

5.6 items()

返回字典中所有键值对的元组列表。

my_dict = {1: "python", 2: "C", 3: "C++", 4: "C#"}
print(my_dict.items())  # dict_items([(1, 'python'), (2, 'C'), (3, 'C++'), (4, 'C#')])

5.6 get()

语法：get(key, default=None)
返回指定键的值，如果键不存在则返回默认值。

my_dict = {1: "python", 2: "C", 3: "C++", 4: "C#"}
print(my_dict.get(1))  # python
print(my_dict.get(5, "JAVA"))  # JAVA

五、集合

1、创建

可以使用花括号或者set()函数来创建集合

my_set = {1, 2, 3}  # 创建包含三个元素的集合
my_set = set([1, 2, 3])  # 使用列表创建集合

2、添加

可以使用 add() 方法向集合中添加单个元素，使用 update() 方法向集合中添加多个元素。

my_set = {1,2,3}
my_set.add(4)
print(my_set)  # {1, 2, 3, 4}

my_set.update([4,8,7,6,5])
print(my_set)  # {1, 2, 3, 4, 5, 6, 7, 8}

3、删除

可以使用 remove() 或 discard() 方法。remove方法删除的元素如果不存在则会报错，discard方法则不会报错

my_set = {1, 2, 3, 4, 5, 6, 7, 8}
my_set.remove(4)  # python
print(my_set)  # {1, 2, 3, 5, 6, 7, 8}

my_set.discard(6)
print(my_set)  # {1, 2, 3, 5, 7, 8}

4、集合操作

集合支持常见的集合操作，如并集、交集、差集和对称差等。可以使用相应的方法或运算符来执行这些操作。

set1 = {1, 2, 3}
set2 = {3, 4, 5}

union_set = set1.union(set2)  # 并集，结果为 {1, 2, 3, 4, 5}
intersection_set = set1.intersection(set2)  # 交集，结果为 {3}
difference_set = set1.difference(set2)  # 差集，结果为 {1, 2}
symmetric_difference_set = set1.symmetric_difference(set2)  # 对称差，结果为 {1, 2, 4, 5}

print(set1 | set2)  # 并集，结果为 {1, 2, 3, 4, 5}
print(set1 & set2)  # 交集，结果为 {3}
print(set1 - set2)  # 差集，结果为 {1, 2}
print(set1 ^ set2)  # 对称差，结果为 {1, 2, 4, 5}