字符串、列表、元组、字典

字符串

• 双引号或者单引号中的数据，就是字符串

字符串输入
之前在学习input的时候，通过它能够完成从键盘获取数据，然后保存到指定的变量中；
注意：input获取的数据，都以字符串的方式进行保存，即使输入的是数字，那么也是以字符串方式保存。

#字符串
name = "Hello Python"
print(name)
#字符串输入
username = input("请输入姓名：")
print(username)

列表

append() 在列表的末尾添加一个元素

clear() 删除列表中的所有元素

copy() 返回列表的副本

count() 返回具有指定值的元素数量。

extend() 将列表元素（或任何可迭代的元素）添加到当前列表的末尾

index() 返回具有指定值的第一个元素的索引

insert() 在指定位置添加元素

pop() 删除指定位置的元素

remove() 删除具有指定值的项目

reverse() 颠倒列表的顺序

sort() 对列表进行排序

len(list)列表元素个数

max(list)返回列表元素最大值

min(list)返回列表元素最小值

list(seq)将元组转换为列表

x in s 如果 s 中的某项等于 x 则结果为 True，否则为 False

x not in s 如果 s 中的某项等于 x 则结果为 False，否则为 True

#列表初始化
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
#列表的遍历
#print(namesList[0])
#print(namesList[1])
#print(namesList[2])
print(namesList) #['xiaoWang', 'xiaoZhang', 'xiaoHua']
#s 从 i 到 j 的切片
print(namesList[0:1]) #['xiaoWang']
#del s[i:j:k]从列表中移除 s[i:j:k] 的元素
print(namesList[0:1:2]) #['xiaoWang']
del namesList[0:1:2]
print(namesList[0:1:2]) #['xiaoZhang']
#使用for循环
# for name in namesList:
#     #print(name)
#     print("")
#使用while循环
len = len(namesList)
i = 0
# while i < len:
#     print(namesList[i])
#     i+=1
#添加元素
#通过append可以向列表添加元素
namesList.append("xiaoLi")
print(namesList) #['xiaoZhang', 'xiaoHua', 'xiaoLi']
# for name in namesList:
#     print(name)
print("-----------")
#删除最后一个元素
namesList.pop()
# for name in namesList:
#     print(name)
print(namesList) #['xiaoZhang', 'xiaoHua']
print("-----------")
#根据元素的值进行删除
namesList.remove("xiaoZhang")
# for name in namesList:
#     print(name)
print(namesList) #['xiaoHua']
#添加集合
#通过extend可以将另一个集合中的元素逐一添加到列表中
namesList.extend(namesList)
#返回具有指定值的元素数量
print(namesList.count("xiaoLi")) # 0
print(namesList.count("xiaoHua"))# 2
# for name in namesList:
#     print(name)

print("-----------")
#删除列表中的所有元素
namesList.clear()
namesList = [1,8,1,3,3,4,5,7]
#求和
print(sum(namesList))     # 输出：32
#对列表进行排序
namesList.sort()
print(namesList)#[1, 1, 3, 3, 4, 5, 7, 8]
# for s in namesList:
#     print(s)
#颠倒列表的顺序
namesList.reverse()
print("-----------")
# for s in namesList:
#     print(s)
print(namesList) #[8, 7, 5, 4, 3, 3, 1, 1]
print("-----------")
#如果 s 中的某项等于 x 则结果为 True，否则为 False
print(1 in namesList)#True
print(10 in namesList) #False
print("-----------")
#如果 s 中的某项等于 x 则结果为 False，否则为 True
print(10 not in namesList) #True
print(1 not in namesList) #False
print("-----------")
print(namesList)# [8, 7, 5, 4, 3, 3, 1, 1]
print("-----------")
#s的最小项
print(min(namesList)) #1
#s 的最大项
print(max(namesList))# 8
#x 在 s 中出现的总次数
print(namesList.count(1))# 2
#在由 i 给出的索引位置将 x 插入 s (等同于 s[i:i] = [x])
namesList.insert(5, 5)
print(namesList) #[8, 7, 5, 4, 3, 5, 3, 1, 1]


#字符串
name = "Hello Python"
print(name)
#字符串输入
username = input("请输入姓名：")
print(username)

元组

Python的元组与列表类似，不同之处在于元组的元素不能修改,元组使用小括号,列表使用方括号,元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"
print(tup1) #('physics', 'chemistry', 1997, 2000)
print(tup2) #(1, 2, 3, 4, 5)
print(tup3) #('a', 'b', 'c', 'd')

#list转元组
lst = [1, 2, 3]
tup = tuple(lst)
print(tup)  # 输出：(1, 2, 3)
#字符串转元组
s = "Python"
tup2 = tuple(s)
print(tup2)  # 输出：('P', 'y', 't', 'h', 'o', 'n')
#元组中的元素可以通过索引访问，索引从0开始。
print(tup2[0]) #P
#负索引从-1开始，表示从末尾向前数。
print(tup2[-2]) #o
#元组可以使用 + 操作符合并
tup1 = (1, 2, 3)
tup2 = (4, 5, 6)
tup3 = tup1 + tup2
print(tup3)  # 输出：(1, 2, 3, 4, 5, 6)
# 使用 * 操作符重复
tup4 = tup1 * 3
print(tup4)  # 输出：(1, 2, 3, 1, 2, 3, 1, 2, 3)
tup = (1, 2, 3, 4, 5)
#可以使用 in 和 not in 操作符检查元素是否存在于元组中
print(3 in tup)     # 输出：True
print(6 not in tup) # 输出：True

tup = (1, 2, 3, 4, 5)
# 返回元组的长度
print(len(tup))     # 输出：5
# 返回元组中的最大值
print(max(tup))     # 输出：5
# 返回元组中的最小值
print(min(tup))     # 输出：1
#返回元组中所有元素的和（适用于数字元组）
print(sum(tup))     # 输出：15
#返回元组的排序副本（结果为列表）
print(sorted(tup))  # 输出：[1, 2, 3, 4, 5]
#返回元素 x 在元组中出现的次数。
print(tup.count(1)) # 1
# 返回元素 x 在元组中第一次出现的索引
print(tup.index(2)) # 1
#由于元组是不可变的，因此可以用作字典的键。而列表是可变的，不能用作字典的键。
d = {(1, 2): "a", (3, 4): "b"}
print(d[(1, 2)])  # 输出："a"
print(d[(3, 4)])  # 输出："b"
#元组常用于传递函数的多个参数。函数可以接受元组作为参数，并解包元组中的元素
def func(a, b, c):
    print(a, b, c)
tup = (1, 2, 3)
func(*tup)  # 输出：1 2 3
#元组常用于函数返回多个值。函数可以返回一个元组，并在调用时解包返回的元组。
def func():
    return 1, 2, 3
a, b, c = func()
print(a, b, c)  # 输出：1 2 3
#元组可以存储不同类型的元素，常用于固定结构的数据。例如，一个包含名称、年龄和地址的元组。
person = ("John", 25, "1234 Elm St")
name, age, address = person
print(f"Name: {name}, Age: {age}, Address: {address}")# 输出：Name: John, Age: 25, Address: 1234 Elm St
#元组的优点
#不可变性：元组的不可变性使得它们在多线程环境中是安全的，可以避免数据竞争
tup = (1, 2, 3)
# 无法修改元组中的元素
# tup[0] = 10  # 这行代码会引发错误 TypeError: 'tuple' object does not support item assignment
# 性能：元组的创建和访问速度比列表快，因为它们是不可变的，不需要额外的内存开销
import timeit
t1 = timeit.timeit("(1, 2, 3)", number=1000000)
t2 = timeit.timeit("[1, 2, 3]", number=1000000)
print(f"元组创建时间: {t1}")
print(f"列表创建时间: {t2}")
#哈希特性：元组可以作为字典的键，因为它们是不可变的，这在某些数据结构中非常有用
d = { (1, 2): "a", (3, 4): "b" }
print(d[(1, 2)])  # 输出："a"
#元组的缺点
#不可变性：虽然不可变性是一个优点，但在需要修改元素的情况下，它可能成为一个限制
#功能限制：与列表相比，元组不支持许多列表的方法，例如 append()、remove() 等，这在某些操作中可能不方便
lst = [1, 2, 3]
lst.append(4)
print(lst)  # 输出：[1, 2, 3, 4]
tup = (1, 2, 3)
#tup.append(4)  # 这行代码会引发错误  AttributeError: 'tuple' object has no attribute 'append'
#元组使用场景
#元组常用于存储不同类型的数据，例如数据库记录。一条记录的不同字段可以用元组存储
record = ("John Doe", 30, "Engineer")
name, age, profession = record
print(f"Name: {name}, Age: {age}, Profession: {profession}")# 输出：Name: John Doe, Age: 30, Profession: Engineer
#在某些情况下，配置项可以用元组存储，因为它们是不可变的，不会被意外修改
config = (800, 600)
# config[0] = 1024  # 这行代码会引发错误
print(config)  # 输出：(800, 600)
#在多线程环境中，使用元组可以避免数据竞争和修改问题
import threading
def worker(data):
    print(data)
data = (1, 2, 3)
threads = [threading.Thread(target=worker, args=(data,)) for _ in range(5)]
for t in threads:
    t.start()
for t in threads:
    t.join()
#嵌套元组 元组可以包含其他元组作为元素，这使得它们可以用于表示复杂的数据结构
nested_tup = (1, (2, 3), (4, (5, 6)))
print(nested_tup[1])  # 输出：(2, 3)
print(nested_tup[2][1])  # 输出：(5, 6)
#元作为数据表 在处理数据库或表格数据时，元组常用于表示行数据
rows = [
    (1, "John", "Doe"),
    (2, "Jane", "Smith"),
    (3, "Emily", "Jones")
]
for row in rows:
    print(row)
# 输出：
# (1, "John", "Doe")
# (2, "Jane", "Smith")
# (3, "Emily", "Jones")
# 多变量交换
# 元组可以用于交换多个变量的值，而不需要临时变量。
# 嵌套元组元组作为数据表多变量交换
a, b = 1, 2
a, b = b, a
print(a, b)  # 输出：2 1

与列表的比较
1、不可变性：元组是不可变的，而列表是可变的
2、性能：元组的性能通常比列表好，因为它们不需要额外的内存开销
3、功能：列表有更多的方法和操作符，例如 append()、remove() 等
与集合的比较
1、顺序：元组是有序的，而集合是无序的
2、不可变性：元组是不可变的，而集合是可变的
3、重复元素：元组允许重复元素，而集合不允许重复元素

字典

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key:value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

#键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一
from email.policy import default
from functools import cmp_to_key

tinydict = {'a': 1, 'b': 2, 'b': '3'}
print(tinydict['b']) #3
print(tinydict)# {'a': 1, 'b': '3'}

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print(tinydict['Name']) #Zara
print(tinydict['Age']) #7
#如果用字典里没有的键访问数据，会输出错误如下：
#print(tinydict['Age1']) #KeyError: 'Age1'

#修改字典 向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对
tinydict['Age'] = 18
print(tinydict['Age']) #18
#删除字典元素 能删单一的元素也能清空字典，清空只需一项操作
del tinydict['Name']  # 删除键是'Name'的条目
print(tinydict)
tinydict.clear()  # 清空字典所有条目
print(tinydict) #{}
#不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First','Class': 'Last'}
print(tinydict)
#键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行
#tinydict = {['Name']: 'Zara', 'Age': 7}
#print(tinydict['Name']) #TypeError: unhashable type: 'list'
tinydict.clear()
tinydict = {'a': 1, 'b': 2, 'b': '3'}
#计算字典元素个数，即键的总数。
print(len(tinydict))#2
#输出字典可打印的字符串表示。
print(str(tinydict))#{'a': 1, 'b': '3'}
#返回输入的变量类型，如果变量是字典就返回字典类型。
print(type(tinydict))#<class 'dict'>
#以列表返回可遍历的(键, 值) 元组数组
print(tinydict.items())#dict_items([('a', 1), ('b', '3')])
#以列表返回一个字典所有的键
print(tinydict.keys())#dict_keys(['a', 'b'])
#以列表返回一个字典所有的键
print(tinydict.values())#dict_values([1, '3'])
#d.popitem()随机从字典中取出一个键值对，以元组(key, value)形式返回。取出后从字典中删除这个键值对。
print(tinydict.popitem())#('b', '3')
print(tinydict)#{'a': 1}
tinydict1 = {'a','3'}
#把字典dict2的键/值对更新到dict里
tinydict = {'Name': 'Zara', 'Age': 7}
tinydict2 = {'Sex': 'female' }
tinydict.update(tinydict2)
print ("Value : %s" %  tinydict)#Value : {'Name': 'Zara', 'Age': 7, 'Sex': 'female'}

Python字符串、元组、列表、字典互相转换的方法

#1、字典
dict = {'name': 'Zara', 'age': 7, 'class': 'First'}
#字典转为字符串，返回：<type 'str'> {'age': 7, 'name': 'Zara', 'class': 'First'}
print(type(str(dict)), str(dict))
#字典可以转为元组，返回：('age', 'name', 'class')
print(tuple(dict))
#字典可以转为元组，返回：(7, 'Zara', 'First')
print(tuple(dict.values()))
#字典转为列表，返回：['age', 'name', 'class']
print(list(dict))
#字典转为列表
print(dict.values)
#2、元组
tup=(1, 2, 3, 4, 5)
#元组转为字符串，返回：(1, 2, 3, 4, 5)
print(tup.__str__())
#元组转为列表，返回：[1, 2, 3, 4, 5]
list1 = list(tup)
print(list1)
#元组不可以转为字典
#3、列表
nums=[1, 3, 5, 7, 8, 13, 20];
#列表转为字符串，返回：[1, 3, 5, 7, 8, 13, 20]
print(str(nums))
#列表转为元组，返回：(1, 3, 5, 7, 8, 13, 20)
print(tuple(nums))
#列表不可以转为字典
#4、字符串
#字符串转为元组，返回：(1, 2, 3)
print(tuple(eval("(1,2,3)")))
#字符串转为列表，返回：[1, 2, 3]
print(list(eval("(1,2,3)")))
#字符串转为字典，返回：<type 'dict'>
print(type(eval("{'name':'ljq', 'age':24}")))