[TOC]

基本数据结构

下标

使用下标（也称为索引）来访问字符串、列表、元组等序列类型中的单个元素
正向下标从最左边的元素开始计数，以0为起始点
负向下标从最右边的元素开始计数，以-1为最右边的元素的下标

正向下标:    0       1       2       3       4       5
字符串:     'P'     'y'     't'     'h'     'o'     'n'
负向下标:   -6      -5      -4      -3      -2      -1

s = 'python'
# 访问字符串的第三个元素
print(s[2]) # ---输出元素为 t
print(s[-4]) # ---输出元素为 t

字符串str

字符串切片

从字符串中提取部分字符，选取的区间是左开右闭：从起始位开始，到结束位的前一位，不包含结束位本身

string[start:stop:step]

*   start：可选参数，表示切片开始位置的下标（包含），不写的话默认是从头开始

*   stop：必填参数，表示切片结束位置的下标（不包含）

*   step：可选参数，表示步长，不写的话默认为1

s = "Hello, world!"
print(s[:5])  # 输出 "Hello"，从索引0开始到4结束

print(s[7:])   # 输出 "world!"，从索引7开始到字符串末尾，符号和空格也占位

print(s[::2])  # 输出 "Hlo ol!"，步长为2，从字符串开始到最后，每隔一个字符取一个

print(s[-5:-1])  # 输出"orld"，倒序截取，从-5个字符

find()

str.find() 方法用于检测字符串中是否包含子字符串

字符串序列.find(子字符串，开始位置下标,结束位置下标)

str.find(substring,start,end)

*   如果find()内指定了start和end范围，则返回子字符串第一次出现的位置（下标），否则返回 -1

*   start 开始位置下标和end 结束位置下标可以省略，表示在整个字符串序列中查找

text = "Hello, world! Welcome to the Python programming world."

# 查找子字符串 "world"
position = text.find("world")
print(position)  # 输出 7，返回的是子串在字符串当中开始位置的索引

# 查找子字符串 "world"，但只在索引位置 20 后面查找
position = text.find("world", 20)
print(position)  # 输出 48

# 查找子字符串 "world"，但在索引位置 20 到 30 之间查找
position = text.find("world", 20, 30)
print(position)  # 输出 -1，因为在给定的范围内没有找到 "world"

replace()

str.replace()方法用于将字符串中的某个子串替换成另一个子串

字符串序列.replace(旧子串,新子串,替换次数)

str.repalce(old,new,count)

*   count：可选参数，默认为-1，表示替换所有匹配的子串

*   替换次数如果超出子串出现的次数，则替换次数为该子串出现的次数

text = "hello world, hello python"
new_text = text.replace("hello", "hi")
print(new_text)  # 输出: hi world, hi python，字符串内所有的子字符串hello都替换为hi

# 如果只想替换第一次出现的 "hello"
new_text = text.replace("hello", "hi", 1)
print(new_text)  # 输出: hi world, hello pyhon

# 替换次数超过了子串的次数
new_text = text.replace("hello", "hi", 3)
print(new_text)  # 输出: hi world, hi pyhon，只替换hi子串出现的2次次数

split()

str.split()方法用于根据指定的分隔符将一个字符串分割成多个子字符串，并返回一个这些子字符串组成的列表
如果没有指定分隔符，默认情况下它会按照空白字符进行分割

字符串序列.split(分隔符,最大拆分次数)

string.split(separator, maxsplit)

*   separator：可选参数，如果省略该参数或传入 None，则以空白字符作为分隔符

*   maxsplit：可选参数，用于指定最多分割几次，默认为-1，表示拆分所有匹配的分隔符

*   如果分割字符是原有字符串中的子串，分割后则会丢失该子串

text = "Hello, World! How are you?"

# 使用逗号作为分隔符拆分字符串
words = text.split(", ")
print(words)  # 输出：['Hello', 'World! How are you?']，拆分为2个字符串

# 使用空格作为分隔符拆分字符串
words = text.split()
print(words)  # 输出：['Hello,', 'World!', 'How', 'are', 'you?']，拆分为5个字符串

# 使用空格作为分隔符拆分字符串，最多拆分 2 次
words = text.split(" ", 2)
print(words)  # 输出：['Hello,', 'World!', 'How are you?']，拆分为3个字符串

# 使用are作为分隔符拆分字符串
words = text.split("are")
print(words)  # 输出：['Hello, World! How ', ' you?']，are丢失

strip()

strip()方法用于删除字符串两端的指定字符
lstrip()：删除字符串左侧指定字符
rstrip()：删除字符串右侧指定字符

字符串序列.strip(指定字符)

string.strip(chars)

text = "   Hello, World!   "

# 删除字符串两端的空白字符
new_text = text.strip()
print(new_text)  # 输出：Hello, World!

# 删除字符串两端的指定字符
new_text = text.strip("Hello, !")
print(new_text)  # 输出：World

startswith()

statrswith()方法用于检查字符串是否以指定子串开头，是返回True，否则返回False

字符串序列.startswith(子串,开始位置下标，结束位置下标)

string.startswith(prefix,start,end)

text = "Hello, World!"
print(text.startswith('Hell'))  # 输出为True，开头匹配Hello
print(text.startswith('Hello,5,-1'))  # 输出为False，5号索引开始到结尾不匹配Hello开头

endswith()

endswith()方法用于检查字符串是否以指定子串结尾，是返回True，否则返回False

字符串序列.endswith(子串,开始位置下标，结束位置下标)

string.endswith(prefix,start,end)

text = "Hello, World!"
print(text.endswith('!'))  # 输出为True，结尾匹配！
print(text.endswith('old!,0,7'))  # 输出为False，0号索引开始到7号索引不匹配old!结尾

字符串反转

使用字符串切片，步长为-1时可以用来反转一个序列或者从序列的末尾开始访问元素
[::-1]表示从序列的开始到结束，步长为-1，即反向遍历整个序列

text = "Hello, World!"
reversed_text = text[::-1]
print(reversed_text)  # 输出：!dlroW ,olleH

列表list

index()

index()用来返回数据所在位置的下标,除了用于列表，也可用于字符串和元祖
如果查找的元素不在序列中，则会返回ValueError 异常
如果列表或字符串中有重复的元素或子串，index() 方法只会返回第一个匹配项的索引

列表序列.index(数据，开始位置的下标，结束位置的下标)

list.index(element,start,end)

*   element：要查找的元素
*   start：可选参数，查找的起始位置，默认为0
*   end：查找的结束位置，默认为列表的末尾
*   当指定 start 和 end 参数时，index() 方法会在 [start, end) 范围内查找，即包括 start 但不包括 end

my_list = ['apple', 'banana', 'cherry', 'date', 'fig']
print(my_list.index('cherry'))  # 输出：2

# 查找从位置 1 开始到位置 4 结束的子列表中 'banana' 的位置
index_of_banana = my_list.index('banana', 1, 4)
print(index_of_banana)  # 输出：1

# 查找从此那个1到4结束的子列表中 'fig' 的位置
index_of_fig = my_list.index('fig', 1, 4)
print(index_of_fig)  # 输出：ValueError: 'fig' is not in list 。fig所处位置为第4，不在列表内，结束位置为4不包括4

# 查找列表中重复元素的索引
list1 = ['apple', 'banana', 'cherry', 'banana', 'date', 'fig']
print(list1.index('banana'))  # 输出：1，只返回第一个元素的索引

count()

count()：统计指定数据在当前列表中出现的次数，除了用于列表，也可用于字符串和元祖
count() 方法不会改变原始序列的内容，只是返回计数的结果
如果要计数的元素或子字符串不存在于序列中，count() 方法将返回 0

列表序列.count(数据)

list.count(element)

fruits = ['apple', 'banana', 'apple', 'orange', 'banana', 'banana']
print(fruits.count('banana')) # 输出：3

len()

len()可以获取列表的长度，即列表中数据的个数

lst = [1, 2, 3, 4, 5]
print(len(lst))  # 输出：5

增加

append()

append()：列表尾部增加数据
append() 方法只接受单个参数，并将其作为一个整体添加到列表的末尾
如果参数本身是一个列表或元组，那么整个列表或元组将被作为一个元素添加

列表序列.append(数据)

list_name.append(item)

list1 = [1, 2, 3]
list2 = [4, 5, 6]
print(list1.append(list2))  # 输出：[1, 2, 3, [4, 5, 6]]

insert()

insert()：指定位置新增数据
append() 只能在列表的末尾添加元素，而 insert() 允许你在列表中的任意位置插入元素

列表序列.insert(位置下标，数据)

list_name.insert(index,item)

letters = ['a', 'b', 'c', 'd']
letters.insert(2, 'z')  # 在索引 2 的位置插入 'z'
print(letters)  # 输出：['a', 'b', 'z', 'c', 'd']

extend()

extend()：列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一加入到列表中

列表序列.extend(数据)

list_name.extend(iterable)

first_list = [1, 2, 3]
second_list = ['a', 'b', 'c']
first_list.extend(second_list)
print(first_list)  # 输出：[1, 2, 3, 'a', 'b', 'c']

删除

del()

del()：一个语句，非函数和方法。用于从程序中删除对象的引用，从而让Python的垃圾回收机制有机会释放不再需要的内存

# 删除变量
x = 10
print(x)  # 输出：10
del x
# print(x)  # 这里会抛出NameError，因为x已经被删除了

# 删除列表中的元素
my_list = [1, 2, 3, 4, 5]
del my_list[2]  # 删除索引为2的元素
print(my_list)  # 输出：[1, 2, 4, 5]

remove()

remove()：用于移除列表中第一个匹配指定值的元素
如果列表中不存在这样的元素，remove() 方法会抛出一个 ValueError 异常

列表序列.remove(数据)

list.remove(value)

fruits = ['apple', 'banana', 'cherry', 'date', 'banana']
fruits.remove('banana')
print(fruits)  # 输出: ['apple', 'cherry', 'date', 'banana']

numbers = [1, 2, 3]
numbers.remove(4)  # 这将抛出 ValueError: list.remove(x): x not in list

pop()

删除指定下标的数据（默认为最后一个），并返回该数据

列表序列.pop(下标)

item = list.pop(index)

fruits = ['apple', 'banana', 'cherry']
last_fruit = fruits.pop()
print(last_fruit)  # 输出: 'cherry'
print(fruits)      # 输出: ['apple', 'banana']

修改

修改指定下标数据

my_list = [10, 20, 30, 40, 50]
# 修改第三个元素为35
my_list[2] = 35
print(my_list)  # 输出: [10, 20, 35, 40, 50]

reverse()

reverse()：反转列表元素顺序，直接在原地修改列表，而不是返回一个新的列表
reverse() 只能用于列表，不能用于字符串、元组或其他序列类型

列表序列.reverse()

list_name.reverse()

numbers = [1, 2, 3, 4, 5]
numbers.reverse()
print(numbers)  # 输出: [5, 4, 3, 2, 1]

sort()

sort()：对列表中的元素进行排序。它可以按照升序（默认）或降序排列列表中的元素

列表.sort(key=None,reverse=False)

numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
numbers.sort()
print(numbers)  # 输出: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

# 按降序排序
numbers.sort(reverse=True)
print(numbers)  # 输出: [9, 6, 5, 5, 5, 4, 3, 3, 2, 1, 1]

# 使用 key 参数按绝对值排序
numbers = [-5, -1, 2, -3, 4]
numbers.sort(key=abs)
print(numbers)  # 输出: [-1, 2, -3, 4, -5]

join()

join()：一个字符串的方法，用于将一个包含字符串元素的可迭代对象（如列表或元组）连接成一个单独的字符串
每个元素之间会插入调用 join 的字符串作为分隔符

separator = 'some string'
result = separator.join(iterable)

*   separator 是你想要用作分隔符的字符串
*   iterable 是一个包含字符串元素的可迭代对象，如列表或元组
*   join() 方法返回一个新的字符串，其中包含 iterable 中的所有元素，每个元素之间由 separator 字符串分隔。

# 使用列表
words_list = ['Hello', 'world', '!']
sentence = ', '.join(words_list)
print(sentence)  # 输出: Hello, world, !

# 使用元组
words_tuple = ('Python', 'is', 'awesome')
phrase = ' '.join(words_tuple)
print(phrase)  # 输出: Python is awesome

列表的循环遍历

for循环

适用于绝大多数情况，最简单直观

my_list = ['apple', 'banana', 'cherry']
for item in my_list:
    print(item)

enumerate()

如果还需要知道当前元素的索引，可以使用 enumerate() 函数

for index, value in enumerate(my_list):
    print(f"Index: {index}, Value: {value}")

# 输出类似以下的结果：
Index: 0, Value: apple
Index: 1, Value: banana
Index: 2, Value: cherry

while循环

很少使用，需要控制更复杂的循环条件时可以使用

index = 0
while index < len(my_list):
    print(my_list[index])
    index += 1

列表嵌套

列表嵌套指的是一个列表里面包含了其他的子列表

nested_list = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print(nested_list[0][2])  # 输出: 3

列表推导式

使用一行代码简单快速的创建一个列表

[表达式 for 变量 in 列表] 或者 [表达式 for 变量 in 列表 if 条件]

new_list = [expression for item in iterable if condition]

*   expression: 这是你想要添加到新列表中的项的表达式，通常涉及当前循环变量 item
*   item: 是可迭代对象 iterable 中的每一个元素
*   iterable: 可以被迭代的对象，如列表、元组、集合、字符串
*   if condition: 这是可选部分，用于过滤 iterable 中的元素，只有满足条件的元素才会被添加到新列表中。

# 创建一个列表，其中只包含1到10之间既是偶数又大于5的数字：
result = [num for num in range(1, 11) if num > 5 and num % 2 == 0]
print(result)  # 输出: [6, 8, 10]

# 有两个列表，想要创建一个新列表，其中包含所有可能的配对：
list_a = [1, 2, 3]
list_b = ['a', 'b']
pairs = [(x, y) for x in list_a for y in list_b]
print(pairs)  # 输出: [(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b'), (3, 'a'), (3, 'b')]

如果想要加入 if...else 条件时，列表推导式的语法变为：

[表达式真 if 变量 else 表达式假 for 变量 in 列表]

[expression_if_true if condition else expression_if_false for x in iterable]

*   expression_if_true 和 expression_if_false 分别是在条件为真和为假时要使用的表达式
*   标准的 Python 列表推导式只允许一个 if-else 结构，无法直接嵌套多个独立的 if-else

# 对于 numbers 列表中的每一个元素 num，如果 num 大于 0，则 num 被乘以 2；否则，num 保持不变

numbers = [-1, 2, -3, 4, -5]
result = [num * 2 if num > 0 else num for num in numbers]
print(result)  # 输出: [-1, 4, -3, 8, -5]

如果需要使用多个if语句，列表推导式的语法变为：

[表达式 for 变量 in 列表 if 条件1 and 条件2]

[expression for item in iterable if condition1 and condition2 and ...]

numbers = [1, 2, 3, 4, 5, 6, -2, -4]
filtered_numbers = [num for num in numbers if num > 0 and num % 2 == 0]
print(filtered_numbers)  # 输出: [2, 4, 6]

元组tuple

元祖与列表类似，只是元组内数据不支持修改，列表是允许的

定义：使用圆括号 () 来创建元组，例如：my_tuple = (1, 'hello', 3.14)
索引：可以使用索引访问元组中的元素，例如：first_element = my_tuple[0]
切片：可以使用切片来获取元组的一部分，例如：sub_tuple = my_tuple[1:3]
不可变性：元组的元素一旦被赋值后就不能改变，尝试修改会引发错误
用途：元组常用于存储相关的数据项，如坐标 (x, y) 或者日期 (year, month, day) 等

# 创建一个元组
coordinates = (10, 20)

# 访问元组中的元素
x = coordinates[0]
y = coordinates[1]

# 输出元组中的元素
print("x =", x)
print("y =", y)

元祖内含有列表或者字典数据，修改列表或字典内数据是支持的

# 创建一个包含列表的元组
my_tuple = ([1, 2, 3], 'hello', 3.14)

# 访问元组中的列表
list_in_tuple = my_tuple[0]

# 修改列表中的数据
list_in_tuple.append(4)
list_in_tuple[0] = 99

# 输出修改后的列表
print(list_in_tuple)  # 输出: [99, 2, 3, 4]

字典dict

字典用{}表示，用于存储键值对集合
字典是无序的，也就是说，元素不会按照特定顺序排列，而是基于键来访问

# 有数据的字典
dict1 = {'name':'jake','age':20,'gender':'男'}
# 空字典
dict2 = {}
# dict()构造函数
dict3 = dict()

增加

直接赋值

字典序列[key] = 值

my_dict = {}  # 创建一个空字典
my_dict['new_key'] = 'new_value'  # 添加一个新的键值对
print(my_dict)  # 输出: {'new_key': 'new_value'}

使用update()方法

update() 方法允许你使用另一个字典或任何可迭代对象来更新现有字典

my_dict = {'key1': 'value1'}
new_items = {'key2': 'value2', 'key3': 'value3'}
my_dict.update(new_items)
print(my_dict)  # 输出: {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

修改字典

修改字典非常简单，只需要指定键并赋新值即可

my_dict['key1'] = 'new_value'  # 修改 'key1' 的值

删除字典元素

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

del my_dict['key1']  # 删除 'key1' 键及其对应的值

如果要清空整个字典，可以使用 clear() 方法

my_dict.clear()  # 清空字典

访问字典

访问字典中的值是通过key来完成的

value = my_dict['key1']  # 返回与 'key1' 关联的值

*   如果键不存在于字典中，上述代码会抛出 KeyError

get()

# 如果当前不存在这个key，则会返回第二个参数自定义的默认值，如果没有第二个参数，则返回默认的None

dict.get(key,默认值)

my_dict = {'name': 'Alice', 'age': 25}

# 获取存在的键
name = my_dict.get('name')
print(name)  # 输出: Alice

# 尝试获取不存在的键，没有提供默认值
city = my_dict.get('city')
print(city)  # 输出: None

# 尝试获取不存在的键，提供默认值
city = my_dict.get('city', 'Unknown')
print(city)  # 输出: Unknown

遍历字典

遍历键

my_dict = {'name': 'Alice', 'age': 25}
for key in my_dict.keys():
    print(key)

遍历值

for value in my_dict.values():
    print(value)

同时遍历键和值

# 使用items()方法遍历字典的键值对
for key, value in my_dict.items():
    print(key, value)

3.基本数据结构

基本数据结构

下标

字符串str

字符串切片

find()

replace()

split()

strip()

startswith()

endswith()

字符串反转

列表list

index()

count()

len()

增加

append()

insert()

extend()

删除

del()

remove()

pop()

修改

修改指定下标数据

reverse()

sort()

join()

列表的循环遍历

for循环

enumerate()

while循环

列表嵌套

列表推导式

元组tuple

字典dict

增加

直接赋值

使用update()方法

修改字典

删除字典元素

访问字典

遍历字典

遍历键

遍历值

同时遍历键和值

相关推荐

2.流程控制

1.变量、运算符

3.基本数据结构

5.文件操作

共有 0 条评论

最新文章

16.异常

25.文件操作

34.函数

43.基本数据结构

52.流程控制

61.变量、运算符

栏目分类