2、Python中使用字符串、List、元祖、集合和字典

本文介绍了Python中字符串的基本定义、常用操作,如拼接、查找和切片,以及列表的定义、元素操作、元组的不可变特性、集合的无重复元素和集合运算,还有字典的键值对存储与操作。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

目录

字符串

定义

常用方法

List列表

List定义

元组使用

集合

使用字典



字符串

定义

字符串类型是一种结构化的、非标量类型,所以会有一系列的属性和方法。

数值类型是标量类型,也就是说这种类型的对象没有可以访问的内部结构;

#单引号
s1 = 'hello, world!'
#双引号
s2 = "hello, world!"
# 以三个双引号或单引号开头的字符串可以折行
s3 = """
hello, 
world!
"""
print(s1, s2, s3, end='')

常用方法

1、+运算符

实现字符串重复拼接

s1 = 'hello ' * 3
print(s1) # hello hello hello

2、innot in

判断一个字符串是否包含另外一个字符串。

s2 = 'Hello world'
print(s1) # hello hello hello world
print('ll' in s2) # True
print('good' in s2) # False
print('good' not in s2) # True

3、字符串切片

以用[][:]运算符从字符串取出某个字符或某些字符(切片运算)

str2 = 'abc123456'
# 从字符串中取出指定位置的字符(下标运算)
print(str2[2]) # c
# 字符串切片(从指定的开始索引到指定的结束索引)
#从位置2-5
print(str2[2:5]) # c12
print(str2[2:]) # c123456
print(str2[2::2]) # c246
print(str2[::2]) # ac246
print(str2[::-1]) # 654321cba
print(str2[-3:-1]) # 45

4、字符串处理

str1 = 'hello, world!'

# 通过内置函数len计算字符串的长度
print(len(str1)) # 13

# 获得字符串首字母大写的拷贝
print(str1.capitalize()) # Hello, world!

# 获得字符串每个单词首字母大写的拷贝
print(str1.title()) # Hello, World!

# 获得字符串变大写后的拷贝
print(str1.upper()) # HELLO, WORLD!

# 从字符串中查找子串所在位置
print(str1.find('or')) # 8
print(str1.find('shit')) # -1

# 与find类似但找不到子串时会引发异常
# print(str1.index('or'))
# print(str1.index('shit'))

# 检查字符串是否以指定的字符串开头
print(str1.startswith('He')) # False
print(str1.startswith('hel')) # True

# 检查字符串是否以指定的字符串结尾
print(str1.endswith('!')) # True
# 将字符串以指定的宽度居中并在两侧填充指定的字符
print(str1.center(50, '*'))

# 将字符串以指定的宽度靠右放置左侧填充指定的字符
print(str1.rjust(50, ' '))
str2 = 'abc123456'

# 检查字符串是否由数字构成
print(str2.isdigit())  # False

# 检查字符串是否以字母构成
print(str2.isalpha())  # False

# 检查字符串是否以数字和字母构成
print(str2.isalnum())  # True
str3 = '  jackfrued@126.com '
print(str3)

# 获得字符串修剪左右两侧空格之后的拷贝
print(str3.strip())

List列表

List定义

列表(list),也是一种结构化的、非标量类型,它是值的有序序列,每个值都可以通过索引进行标识,定义列表可以将列表的元素放在[]中,多个元素用,进行分隔,可以使用for循环对列表元素进行遍历,也可以使用[][:]运算符取出列表中的一个或多个元素。

定义列表代码:

#列表定义
list1 = [1, 3, 5, 7, 100]
print(list1) # [1, 3, 5, 7, 100]

# 乘号表示列表元素的重复
list2 = ['hello'] * 3
print(list2) # ['hello', 'hello', 'hello']

# 计算列表长度(元素个数)
print(len(list1)) # 5

# 下标(索引)运算
print(list1[0]) # 1
print(list1[4]) # 100
# print(list1[5])  # IndexError: list index out of range
print(list1[-1]) # 100
print(list1[-3]) # 5
list1[2] = 300
print(list1) # [1, 3, 300, 7, 100]

# 通过循环用下标遍历列表元素
for index in range(len(list1)):
    print(list1[index])

# 通过for循环遍历列表元素
for elem in list1:
    print(elem)

# 通过enumerate函数处理列表之后再遍历可以同时获得元素索引和值
for index, elem in enumerate(list1):
    print(index, elem)

向列表中添加元素:

list1 = [1, 3, 5, 7, 100]

# 添加元素,向末尾添加元素
list1.append(200)

#参数1:指定插入位置,参数2:指定值
list1.insert(1, 400)

#集合合并
list1 += [1000, 2000, 5000]
print(list1) # [1, 400, 3, 5, 7, 100, 200, 1000, 2000]

列表移除元素:

# 先通过成员运算判断元素是否在列表中,如果存在就删除该元素
if 3 in list1:
	list1.remove(3)
if 1234 in list1:
    list1.remove(1234)
print(list1) # [1, 400, 5, 7, 100, 200, 1000, 2000]

# 从指定的位置删除元素
list1.pop(0)
list1.pop(len(list1) - 1)
print(list1) # [400, 5, 7, 100, 200, 1000]

# 清空列表元素
list1.clear()

切片操作

fruits = ['grape', 'apple', 'strawberry', 'waxberry']
fruits += ['pitaya', 'pear', 'mango']
# 列表切片
fruits2 = fruits[1:4]
print(fruits2) # apple strawberry waxberry
# 可以通过完整切片操作来复制列表
fruits3 = fruits[:]
print(fruits3) # ['grape', 'apple', 'strawberry', 'waxberry', 'pitaya', 'pear', 'mango']
fruits4 = fruits[-3:-1]
print(fruits4) # ['pitaya', 'pear']
# 可以通过反向切片操作来获得倒转后的列表的拷贝
fruits5 = fruits[::-1]
print(fruits5) # ['mango', 'pear', 'pitaya', 'waxberry', 'strawberry', 'apple', 'grape']

列表排序:

list1 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
list2 = sorted(list1)

# sorted函数返回列表排序后的拷贝不会修改传入的列表
# 函数的设计就应该像sorted函数一样尽可能不产生副作用
list3 = sorted(list1, reverse=True)

# 通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序
list4 = sorted(list1, key=len)
print(list1)
print(list2)
print(list3)
print(list4)

# 给列表对象发出排序消息直接在列表对象上进行排序
list1.sort(reverse=True)
print(list1)

元组使用

定义:

Python中的元组与列表类似也是一种容器数据类型,可以用一个变量(对象)来存储多个数据,不同之处在于元组的元素不能修改。

把多个元素组合到一起就形成了一个元组,所以它和列表一样可以保存多条数据。

代码:

# 定义元组
t = ('张三', 52, True, '北京')
print(t)

# 获取元组中的元素
print(t[0])
print(t[3])

# 遍历元组中的值
for member in t:
    print(member)

# 重新给元组赋值
# t[0] = '王大锤'  # TypeError
# 变量t重新引用了新的元组原来的元组将被垃圾回收
t = ('王大锤', 20, True, '云南昆明')
print(t)

# 将元组转换成列表
person = list(t)
print(person)

# 列表是可以修改它的元素的
person[0] = '李四'
person[1] = 25
print(person)

# 将列表转换成元组
fruits_list = ['apple', 'banana', 'orange']
fruits_tuple = tuple(fruits_list)
print(fruits_tuple)

为什么要是用元祖?

元组中的元素是无法修改,多线程环境中属于线程安全,可以省掉处理同步开销,函数返回多个值时,可以使用元祖。

元组在创建时间和占用的空间上面都优于列表。

集合

Python中的集合跟数学上的集合是一致的,不允许有重复元素,而且可以进行交集、并集、差集等运算。

代码:

# 创建集合的字面量语法
set1 = {1, 2, 3, 3, 3, 2}
print(set1)
print('Length =', len(set1))

# 创建集合的构造器语法(面向对象部分会进行详细讲解)
set2 = set(range(1, 10))
set3 = set((1, 2, 3, 3, 2, 1))
print(set2, set3)

# 创建集合的推导式语法(推导式也可以用于推导集合)
set4 = {num for num in range(1, 100) if num % 3 == 0 or num % 5 == 0}
print(set4)

向集合添加元素和从集合删除元素:

set1.add(4)
set1.add(5)
set2.update([11, 12])
set2.discard(5)
if 4 in set2:
    set2.remove(4)
print(set1, set2)
print(set3.pop())
print(set3)

集合的成员、交集、并集、差集等运算

# 集合的交集、并集、差集、对称差运算

#交集:取元素相同值
print(set1 & set2)
# print(set1.intersection(set2))

#并集:取所有元素合集
print(set1 | set2)
# print(set1.union(set2))

#差集:set1中在set2没有的值集合
#print(set1) #{1, 2, 3, 4, 5}
#print(set2) #{1, 2, 3, 6, 7, 8, 9, 11, 12}
print(set1 - set2) #{4, 5}
# print(set1.difference(set2))

#取没有相同元素集合
print(set1 ^ set2) #{4, 5, 6, 7, 8, 9, 11, 12}
# print(set1.symmetric_difference(set2))

# 判断子集和超集
print(set2 <= set1)
# print(set2.issubset(set1))
print(set3 <= set1)
# print(set3.issubset(set1))
print(set1 >= set2)
# print(set1.issuperset(set2))
print(set1 >= set3)
# print(set1.issuperset(set3))

使用字典

定义:

字典是另一种可变容器模型,Python中的字典跟我们生活中使用的字典是一样一样的,它可以存储任意类型对象,与列表、集合不同的是,字典的每个元素都是由一个键和一个值组成的“键值对”,键和值通过冒号分开。

代码:

# 创建字典的字面量语法
scores = {'骆昊': 95, '白元芳': 78, '狄仁杰': 82}
print(scores)

# 创建字典的构造器语法
items1 = dict(one=1, two=2, three=3, four=4)

# 通过zip函数将两个序列压成字典
items2 = dict(zip(['a', 'b', 'c'], '123'))

# 创建字典的推导式语法
items3 = {num: num ** 2 for num in range(1, 10)}
print(items1, items2, items3)

# 通过键可以获取字典中对应的值
print(scores['骆昊'])
print(scores['狄仁杰'])
# 对字典中所有键值对进行遍历
for key in scores:
    print(f'{key}: {scores[key]}')

# 更新字典中的元素
scores['白元芳'] = 65
scores['诸葛王朗'] = 71
scores.update(冷面=67, 方启鹤=85)
print(scores)
if '武则天' in scores:
    print(scores['武则天'])
print(scores.get('武则天'))
# get方法也是通过键获取对应的值但是可以设置默认值
print(scores.get('武则天', 60))
# 删除字典中的元素
print(scores.popitem())
print(scores.popitem())
print(scores.pop('骆昊', 100))
# 清空字典
scores.clear()
print(scores)

关于推导式使用下篇博文展示。

### Python 中关于元组字典的练习题 以下是几个涉及 Python 元组字典的经典练习题及其解答: #### 练习题 1:统计字符串中的大小写字母数量 编写一个函数 `fun`,接收一个字符串参数,返回一个元组 `(upper_count, lower_count)`,其中第一个值表示大写字母的数量,第个值表示小写字母的数量。 ```python def fun(x): upper_count = 0 lower_count = 0 for item in x: if item.isupper(): upper_count += 1 elif item.islower(): lower_count += 1 else: continue return upper_count, lower_count result = fun('ehllo WROLD') print(result) # 输出应为 (5, 5)[^1] ``` --- #### 练习题 2:创建菜单字典并打印键值对 通过用户输入动态创建一个菜单字典 `menu_dict`,其键为食物名称,值为其对应的价格。最后分别打印所有的键值。 ```python menu_dict = {} while True: try: food = input("请输入食物名称(单独回车结束):") if not food.strip(): # 如果输入为空,则退出循环 break price = int(input("请输入价格:")) menu_dict[food] = price except ValueError: print("输入有误,请重新输入!") for k in menu_dict.keys(): # 打印所有键 print(f"食物名称: {k}") for v in menu_dict.values(): # 打印所有值 print(f"价格: {v}") ``` 此代码片段展示了如何利用异常处理机制来捕获非法输入,并实现动态构建字典的功能[^2]。 --- #### 练习题 3:查找特定模式的元素 给定三个容器(列表元组字典),找出以字母 `'a'` 或 `'A'` 开头且以 `'c'` 结尾的所有元素。 ```python li = ["alec", "aric", "Alex", "Tony", "rain"] tu = ("alec", "aric", "Alex", "Tony", "rain") dic = {'k1': "alex", 'k2': 'aric', "k3": "Alex", "k4": "Tony"} list1 = list(tu) list2 = list(dic.values()) newlist = li + list1 + list2 results = [] for i in newlist: stripped_i = i.strip() if (stripped_i.startswith('a') or stripped_i.startswith('A')) and stripped_i.endswith('c'): results.append(stripped_i) print(results) # 输出 ['alec', 'aric', 'alec', 'aric', 'aric'][^3] ``` --- #### 练习题 4:去除重复项的方法比较 提供两种方法用于从列表中去除重复项,一种基于字典去重,另一种基于集合去重。 ##### 方法一:使用字典去重 ```python a_list = [1, 1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 3, 5, 2] a_dic = {key: 0 for key in a_list} ans = list(a_dic.keys()) print(ans) # 输出 [1, 2, 3, 4, 5, 6, 7][^4] ``` ##### 方法使用集合去重 ```python a_list = [1, 1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 3, 5, 2] ans = list(set(a_list)) print(ans) # 输出可能顺序不同,如 [1, 2, 3, 4, 5, 6, 7][^4] ``` --- #### 练习题 5:将数值分类存储到字典中 将一组整数分为两类,一类存入字典一个键对应的值列表中,另一类存入另一个键对应的值列表中。 ```python data = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90] dictionary = {} greater_than_66 = [] less_than_66 = [] for value in data: if value > 66: greater_than_66.append(value) elif value < 66: less_than_66.append(value) dictionary['k1'] = greater_than_66 dictionary['k2'] = less_than_66 print(dictionary) # 输出 {'k1': [77, 88, 99, 90], 'k2': [11, 22, 33, 44, 55]}[^5] ``` --- #### 练习题 6:模拟购物程序 设计一个简单的购物车功能,允许用户选择商品加入购物车,并判断总金额是否超出预算。 ```python goods = [ {"name": "电脑", "price": 1999}, {"name": "鼠标", "price": 10}, {"name": "游艇", "price": 20}, {"name": "美女", "price": 998}, ] total_assets = int(input("请输入您的总资产:")) shopping_cart = {} cart_total_price = 0 for idx, product in enumerate(goods, start=1): shopping_cart[idx] = product["name"] print(shopping_cart) while True: choice = int(input("请选择要购买的商品编号(输入0结束选购):")) if choice == 0: break selected_product_name = shopping_cart.get(choice) if selected_product_name is None: print("无效的选择,请重新输入!") continue selected_product_price = next(item["price"] for item in goods if item["name"] == selected_product_name) cart_total_price += selected_product_price print(f"已将{selected_product_name}加入购物车,总价目前为{cart_total_price}") if cart_total_price > total_assets: print("余额不足,无法完成购买!") else: print("购买成功!感谢惠顾!")[^5] ``` --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值