Python基础：字符串，列表，元组的创建与使用

字符串:

Python中的字符串（string）是一种不可变的序列，用于表示文本数据。在Python中，我们可以使用单引号或双引号来创建一个字符串。

以下是创建字符串的方式：

使用单引号 '：

str1 = 'Hello, World!'
print(str1) #Hello, World!

使用双引号 "：

str2 = "Hello, World!"
print(str2) #Hello, World!

也可以使用三重引号 ‘’’ 或 “”" 创建跨越多行的字符串：

str3 = '''Hello,
World!'''
print(str3)  #Hello,
             #World!

字符串是不可变的，因此不能修改字符串的子串，例如下面的代码会引发错误：

str = 'Hello, World!'
str[0] = 'h' #TypeError: 'str' object does not support item assignment

字符串支持通过索引和切片来访问其子串：

str = 'Hello, World!'
print(str[0]) #H
print(str[0:5]) #Hello

字符串也支持一些常见的操作，比如连接两个字符串：

str1 = 'Hello,'
str2 = 'World!'
str3 = str1 + ' ' + str2
print(str3) #Hello, World!

或者使用字符串格式化来插入变量值：

name = 'John'
age = 30
print('My name is %s and I am %d years old.' % (name, age)) #My name is John and I am 30 years old.

字符串也提供了许多方法，例如 find() 方法可以用于查找子串的位置：

str = 'Hello, World!'
print(str.find('World')) #7

strip() 方法可以用于删除字符串前后的空白字符：

str = '  Hello,    World!   '
print(str.strip()) #Hello,    World!

另外，len() 函数可以用于获取字符串的长度：

str = 'Hello, World!'
print(len(str)) #13

总之，字符串是在Python中处理文本数据的核心对象之一。Python字符串提供了丰富的操作和方法，可以方便地处理和操作文本数据。

实例：

#字符串查找
word = 't'
str_01 = 'python'
zfc = str_01.find(word)
print(zfc)

#字符串替换
str_02 ='All things Are difficilt before they Are easy.'
tihuan = str_02.replace('Are','are')   #不指定替换次数（全部替换）
print(tihuan)

#字符串的分割
str_02 ='All things Are difficilt before they Are easy.'
print(str_02.split())       #以空格作为分隔符
print(str_02.split('a'))    #以字母a作为分隔符
print(str_02.split('e',2))  #以字母e作为分隔符，并分割2次

#字符串的拼接
symbol = '*'
world = 'python'
print(symbol.join(world))
#加号拼接法
a = 'py'
b = 'thon'
print(a+b)

#计算字符串中小写字母的数量
shuru = str(input('请输入一行字符：'))
sum_zimu = 0    #统计英文字母个数
for i in range(len(shuru)):     #利用字符在ASCLL码中的位置逐个统计
    if 'a' <=shuru[i] <= 'z':
        sum_zimu +=1
print('小写字母个数为：%d' % sum_zimu)

列表：

Python中的列表（list）是一种可变序列，可以存储任意类型的数据，包括数字、字符串、列表、元组和字典等对象。与元组不同，列表可以修改，我们可以在列表中添加、删除或更新元素。

下面是创建列表的方式：

使用中括号 []：

lst = [1,2,3,4,5]
print(lst) #[1, 2, 3, 4, 5]

使用内置函数list()：

tpl = (1,2,3,4,5)
lst = list(tpl)
print(lst) #[1, 2, 3, 4, 5]

一个列表可以包含不同类型的元素，甚至可以嵌套其他的列表和元组：

lst = [1, 'hello', [2, 3], (4, 5)]
print(lst) #[1, 'hello', [2, 3], (4, 5)]

列表是可变的，因此可以随时修改该列表中的元素。可以使用索引来访问单个元素：

lst = [1,2,3,4,5]
print(lst[0]) #1

可以使用切片操作来访问多个元素：

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

可以通过 append() 方法将新元素添加到列表末尾：

lst = [1,2,3,4,5]
lst.append(6)
print(lst) #[1, 2, 3, 4, 5, 6]

可以使用 insert() 方法将新元素插入到列表中的任意位置：

lst = [1,2,3,4,5]
lst.insert(2, 'hello')
print(lst) #[1, 2, 'hello', 3, 4, 5]

可以使用extend()方法用于列表中批量加多个数据，在列表尾部插入数据：

lst = [1, 2, 3, 4, 5]
lsts = [7, 8, 9]
lst.extend(lsts)
print(lst)  # [1, 2, 3, 4, 5, 7, 8, 9]
print(lsts)  # [7, 8, 9]

可以使用 remove() 方法从列表中删除元素：

lst = [1,2,3,4,5]
lst.remove(3)
print(lst) #[1, 2, 4, 5]

可以使用 pop() 方法从列表中删除一个元素，并返回该元素的值：

lst = [1,2,3,4,5]
print(lst.pop()) #5
print(lst) #[1, 2, 3, 4]

可以使用 sort() 方法将列表中的元素排序：

lst = [4, 2, 1, 3, 5]
lst.sort()    # 升序排列列表中的元素
print(lst) #[1, 2, 3, 4, 5]
lst.sort(reverse=True)    # 降序排列列表中的元素
print(lst) #[5, 4, 3, 2, 1]

可以使用clear()方法清空列表：

a = [1, 2, 3, 4, 5]
a.cleaar()
print(a)    # []

总之，列表的主要特点是可变性，因此可以用来存储和操作需要随时更新的数据。与元组相比，列表具有更大的灵活性和功能。

实例：

'''
shopping_list = []
# 往购物清单里添加两个商品
shopping_list.append("键盘")
shopping_list.append("键帽")
# 往购物清单里移除一个商品
shopping_list.remove("键帽")
# 往购物清单里移除两个商品
shopping_list.append("音响")
shopping_list.append("电竞椅")
# 更改购物清单的第二个商品
shopping_list[1] = "硬盘"

# print(shopping_list)
# print(len(shopping_list))
# print(shopping_list[0])

# 定义一个价格列表
price = [799, 1024, 200, 800]
# 获取最高的价格
max_price = max(price)
# 获取最低的价格
min_price = min(price)
# 获取从低到高排序好的价格列表
sorted_price = sorted(price)
print(max_price)
print(min_price)
print(sorted_price)
'''

list01 = [21,25,21,23,22,20]
list01.append(31)   #用append()方法追加一个数字31到列表尾部
print(list01)

lsit02 = [29,33,30] #用extend()方法追加一个新的列表到列表的尾部
list01.extend(lsit02)
print(list01)

print(list01[0])    #查找第一个元素，正向索引
print(list01[-1])   #查找最后一个元素，反向索引

#用index()方法查找下标（索引位置）
print(list01.index(31)) #查找31元素的下标（索引位置）
list01.insert(2,'09')   #将元素’09‘，插入到lise01中索引为2的位置
print(list01)

#删除列表元素
list03 = ['p','y','t','h','o','n']
#用del()方法删除指定元素，
del list03[0]   #删除索引为0的元素
print(list03)
list03.remove('y')  #移除匹配到的第一个’e‘
print(list03)
#pop()方法用于移除列表的某个元素，若未指定具体元素就移除最后一个元素
print(list03.pop()) #移除列表中的最后一个元素，并返回。
print(list03.pop(1))    #移列表中索引为1的元素
print(list03)
#clear()用法用于清空列表
list03.clear()
print(list03)

元组：

Python中的元组（tuple）是一个不可变的序列，它可以存储任意类型的数据，包括字符串、数字、列表、元组和字典等对象。元组与列表非常相似，但是元组一旦创建就不能被修改。

下面是创建元组的方式：

使用圆括号 ()：

tup = (1,2,3,4,5)
print(tup)  #(1, 2, 3, 4, 5)

使用内置函数tuple()：

lst = [1,2,3,4,5]
tup = tuple(lst)
print(tup) #(1, 2, 3, 4, 5)

元组是不可变的，因此不能对元组进行任何修改，例如下面的语句会引发错误：

tup[0] = 0
# TypeError: 'tuple' object does not support item assignment

可以在元组中使用下标来访问元素：

tup = (1,2,3,4,5)
print(tup[0]) #1

元组也支持切片操作：

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

可以使用in 和 not in 运算符来判断元素是否存在于元组中：

tup = (1,2,3,4,5)
if 3 in tup:
    print('3 exists in the tuple')

元组还支持一些内置的方法，包括 count() 和 index()。count() 方法用于计算特定元素在元组中的出现次数，而 index() 方法则返回特定元素在元组中的位置。

tup = (1,2,3,4,5,5,5)
print(tup.count(5)) #3

tup = (1,2,3,4,5)
print(tup.index(3)) #2

总之，元组的主要特点是不可变性。因此，我们可以使用它们来存储一些重要但不希望被修改的数据，例如程序的配置信息、常量或元数据等。