python数据分析--- ch6-7 python容器类型的数据及字符串

1. Ch6–容器类型的数据

1.1 序列

序列(sequence)是一种可迭代的、元素有序的容器类型的数据。

1.1.1 序列的索引操作

squ = 'hello'
print(squ[0])
print(squ[-1])
print(squ[-5])

output
h
o
h

print(squ[1:3])
print(squ[0:5:2])

output
el
hlo

1.1.2 加和乘操作

print(squ*2)
squ1=(1,3,5,7)
squ1*2

output
hellohello
(1, 3, 5, 7, 1, 3, 5, 7)

print('hello'+','+'world')
print(squ1+squ1)
squ2 = 'world'
print(squ+squ2)

output
hello,world
(1, 3, 5, 7, 1, 3, 5, 7)
helloworld

1.1.3 切片操作

print(squ[0:3])
print(squ[:3])
print(squ[0:-1])

output
hel
hel
hell

print(squ[:-1:2])
print(squ[:5:2])

output
hl
hlo

1.1.4 成员测试

print('h'in squ)
print('H'in squ)
print('H'not in squ)

output
True
False
True

1.2 列表

1.2.1 创建列表

list1 = list('hello')
print(list1)
list2 = list((2,3,4,5,6))
print(list2)
list3 = []
print(type(list3))
list4 = [2,3,4,5,6]
print(list4)

output
[‘h’, ‘e’, ‘l’, ‘l’, ‘o’]
[2, 3, 4, 5, 6]
<class ‘list’>
[2, 3, 4, 5, 6]

1.2.2 追加元素

list4.append(80)#添加单个元素
list4

output
[2, 3, 4, 5, 6, 80]

list5 = list4+[90,100,200]#添加多个元素
print(list5)
list4.extend([90,100,200])
print(list4)

output
[2, 3, 4, 5, 6, 80, 90, 100, 200]
[2, 3, 4, 5, 6, 80, 90, 100, 200]

1.2.3 插入元素

list6 = [1,2,3,4]
list6.insert(2,80)
print(list6)

output
[1, 2, 80, 3, 4]

1.2.4 替换元素

list6[1]=100
print(list6)

output
[1, 100, 80, 3, 4]

1.2.5 删除元素

list6.remove(80)
print(list6)

output
[1, 100, 3, 4]

list6.append(100)
print(list6)

output
[1, 3, 4, 100, 100, 100]

list6.remove(100)
print(list6)

output
[1, 3, 4, 100, 100]

1.2.6 列表排序

默认排序、逆序排序、自定义排序、多关键字排序

• 1.sorted() 函数：这是Python中最常用的排序工具，它可以对列表进行排序，并且返回一个新的排序后的列表。默认情况下，sorted()函数按照元素的自然顺序进行排序，但也可以指定key函数来进行复杂的排序。

• 2.list.sort() 方法：与sorted()不同，list.sort()方法会直接修改原列表，而不是创建一个新的列表。这个方法也有一个key参数，允许指定自定义的排序规则。

• 3.逆序排序：可以通过在sorted()或list.sort()中设置参数来实现逆序排序。

• 4.自定义排序规则：可以通过提供key函数来实现自定义的排序规则。例如，可以根据元素的长度、元素中的某个属性等进行排序。

• 5.多关键字排序：可以同时使用多个排序关键字，Python会根据这些关键字的优先级进行排序。

numbers = [3, 1, 4, 1, 5, 9, 2, 6]

（1）sorted() 函数

这是Python中最常用的排序工具，它可以对列表进行排序，并且返回一个新的排序后的列表。默认情况下，sorted()函数按照元素的自然顺序进行排序，但也可以指定key函数来进行复杂的排序。

# 1.使用sorted()进行默认排序
sorted_num = sorted(numbers)
print(sorted_num)

output
[1, 1, 2, 3, 4, 5, 6, 9]

numbers

output
[3, 1, 4, 1, 5, 9, 2, 6]

（2）list.sort() 方法

与sorted()不同，list.sort()方法会直接修改原列表，而不是创建一个新的列表。这个方法也有一个key参数，允许指定自定义的排序规则。

# 2.使用list.sort()进行默认排序
numbers.sort()
print(numbers)

output
[1, 1, 2, 3, 4, 5, 6, 9]

（3）逆序排序

可以通过在sorted()或list.sort()中设置参数reverse来实现逆序排序。

# 使用sorted()进行逆序排序
reverse_num = sorted(numbers,reverse=True)
print(reverse_num)

output
[9, 6, 5, 4, 3, 2, 1, 1]

# 使用list.reverse()进行逆序排序
numbers.reverse()
print(numbers)

output
[9, 6, 5, 4, 3, 2, 1, 1]

（4）自定义排序规则

可以通过提供key函数来实现自定义的排序规则。例如，可以根据元素的长度、元素中的某个属性等进行排序。

# 假设有一个字符串列表，我们想根据字符串的长度进行排序
strings = ['apple','kiwi','banana','cherry','grape']
sorted_str = sorted(strings)
print(sorted_str)
sorted_str1 = sorted(strings,key=len)
print(sorted_str1)

output
[‘apple’, ‘banana’, ‘cherry’, ‘grape’, ‘kiwi’]
[‘kiwi’, ‘apple’, ‘grape’, ‘banana’, ‘cherry’]

（5）多关键字排序

可以同时使用多个排序关键字，Python会根据这些关键字的优先级进行排序。

# 假设有一个字典列表，我们想先根据年龄升序，然后根据名字的字典序进行排序
people = [
    {'name': 'Alice', 'age': 30},
    {'name': 'Bob', 'age': 25},
    {'name': 'Lucky', 'age': 30},
    {'name': 'Lily', 'age': 18},
]

sorted_people = sorted(people,key=lambda p:(p['age'],p['name']))
print(sorted_people)

output
[{‘name’: ‘Lily’, ‘age’: 18}, {‘name’: ‘Bob’, ‘age’: 25}, {‘name’: ‘Alice’, ‘age’: 30}, {‘name’: ‘Lucky’, ‘age’: 30}]

1.2.7 列表内容提取

索引访问、切片操作、遍历列表、列表推导式、条件筛选、map函数

• 1.索引访问：可以通过列表的索引来访问或提取特定的元素。Python的索引从0开始，负数索引从列表末尾开始。

• 2.切片操作：切片可以用来提取列表中的一段连续元素。切片的语法是[start:stop:step]，其中start是切片开始的索引，stop是切片结束的索引（不包括该索引的元素），step是步长，表示每次跳过的元素数量。

• 3.遍历列表：可以使用循环结构（如for循环）或enumerate()函数来逐个访问列表中的元素，从而进行内容提取。

• 4.列表推导式：列表推导式是一种优雅且简洁的创建列表的方法，可以用来根据已有列表生成新的列表，同时实现内容的提取和转换。

• 5.条件筛选：可以使用条件表达式结合遍历或列表推导式、filter()函数来提取满足特定条件的元素。

• 6.map函数：使用map函数可以将一个函数应用于列表的所有元素，从而实现对列表内容的提取、转换或过滤。

（1）索引访问

可以通过列表的索引来访问或提取特定的元素。Python的索引从0开始，负数索引从列表末尾开始。

# 假设有一个数字列表
numbers1 = [10, 20, 30, 40, 50]

# 提取第一个元素
first_num = numbers1[0]
print(first_num)
# 提取最后一个元素
last_num = numbers1[-1]
print(last_num)

output
10
50

（2）切片操作

切片可以用来提取列表中的一段连续元素。切片的语法是[start:stop:step]，
其中start是切片开始的索引，stop是切片结束的索引（不包括该索引的元素），step是步长，表示每次跳过的元素数量。

# 使用切片提取列表中的一段元素
sliced_num = numbers1[1:4]
print(sliced_num)

output
[20, 30, 40]

sliced_num1 = numbers1[:3]
print(sliced_num1)

sliced_num2 = numbers1[2:]
print(sliced_num2)
sliced_num3 = numbers1[2:len(numbers1)]
print(sliced_num3)

output
[10, 20, 30]
[30, 40, 50]
[30, 40, 50]

（3）遍历列表

• 基本循环遍历：可以使用循环结构（如for循环）来逐个访问列表中的元素，从而进行内容提取。
• 使用enumerate()函数：如果你需要在遍历时获取元素的索引，可以使用 enumerate() 函数。

# 遍历列表并打印每个元素
for num in numbers1:
    print(num)

output
10
20
30
40
50

# 使用enumerate遍历列表，并打印索引和元素
for index,num in enumerate(numbers1):
    print(f'Index:{index},Value:{num}')

output
Index:0,Value:10
Index:1,Value:20
Index:2,Value:30
Index:3,Value:40
Index:4,Value:50

（4）列表推导式

列表推导式是一种优雅且简洁的创建列表的方法，可以用来根据已有列表生成新的列表，同时实现内容的提取和转换。

for num in numbers:
    if num%2==0:
        print(num)
        
for index,num in enumerate(numbers):
    if num%2==0:
        print(f"Index:{index},Value:{num}")

output
6
4
2
Index:1,Value:6
Index:3,Value:4
Index:5,Value:2

# 示例1：使用列表推导式提取偶数元素
even_numbers = [num for num in numbers if num%2==0]
print(even_numbers)

output
[6, 4, 2]

# 示例2：
# 列表推导式可以用一行代码完成循环和条件判断的操作，使得代码更加简洁和易于理解。
records = [
    {'id': 1, 'status': 'success'},
    {'id': 2, 'status': 'fail'},
    {'id': 3, 'status': 'success'},
    {'id': 4, 'status': 'fail'},
    {'id': 5, 'status': 'success'},
    {'id': 6, 'status': 'fail'},
    # ... 更多记录
]

# 使用列表推导式提取状态为'success'的记录
success_records = [x for x in records if x['status']=='success']
print(success_records)

output
[{‘id’: 1, ‘status’: ‘success’}, {‘id’: 3, ‘status’: ‘success’}, {‘id’: 5, ‘status’: ‘success’}]

（5）条件筛选

可以使用条件表达式结合遍历或列表推导式、filter()函数来提取满足特定条件的元素。

numbers2 = [-3,-2,-1,0,1, 2, 3, 4, 5, 6]

# 使用for循环筛选出正数
res = []
for n in numbers2:
    if n>0:
        res.append(n)
print(res)

output
[1, 2, 3, 4, 5, 6]

# 条件表达式结合遍历：提取大于3的元素
res1 = [n for n in numbers2 if n>3]
print(res1)

output
[4, 5, 6]

# 使用filter()筛选出奇数
odd_nums = list(filter(lambda x:abs(x%2)==1,numbers2))
print(odd_nums)

output
[-3, -1, 1, 3, 5]

（6）map函数

使用map函数可以将一个函数应用于列表的所有元素，从而实现对列表内容的提取、转换或过滤。

# 示例1：使用map函数将每个元素转换为字符串
str_number =list( map(str,numbers2))
print(str_number)

output
[‘-3’, ‘-2’, ‘-1’, ‘0’, ‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’]

# 示例2：使用map()和filter()筛选出列表元素乘以2后能被3整除的数
res3 = list(filter(lambda x: x%3==0,map(lambda x:x*2, numbers2)))
print(res3)

output
[-6, 0, 6, 12]

1.3 元组

1.3.1 创建元组

tp1 = tuple([21,32,43,54])
print(type(tp1))

tp2=(21,32,43,54)
print(type(tp2),tp2)

lst3 = list(tp2)
print(type(lst3),lst3)

set3 = set(tp2)
print(type(set3),set3)

output
<class ‘tuple’>
<class ‘tuple’> (21, 32, 43, 54)
<class ‘list’> [21, 32, 43, 54]
<class ‘set’> {32, 43, 21, 54}

1.3.2 元组拆包

tp3 = (102,'张三')
print(tp3)
s_id,s_name = tp3
print(s_id)
print(s_name)

output
(102, ‘张三’)
102
张三

tp3 = ([102,106,108],['张三','李四','王五'])
print(tp3)
s_id,s_name = tp3
print(s_id)
print(s_name)

output
([102, 106, 108], [‘张三’, ‘李四’, ‘王五’])
[102, 106, 108]
[‘张三’, ‘李四’, ‘王五’]

1.4 集合

1.4.1 创建集合

set1 = {20,15,10,30,20,15}
set1

output
{10, 15, 20, 30}

1.4.2 修改集合

# set1.add(10)
# print(set1)
# set1.clear()

set1.add(20)
print(set1)

output
{20}

1.4.3 集合的操作

并集、交集、差集和对称差集等

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

# 交集（intersection）
print(set1&set2)
print(set1.intersection(set2))

output

{3, 4}

# 并集（union）
print(set1|set2)
print(set1.union(set2))

output
{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6}

# 差集（difference）
print(set1-set2)
print(set1.difference(set2))

output
{1, 2}
{1, 2}

print(set2-set1)
print(set2.difference(set1))

output
{5, 6}
{5, 6}

# 对称差集（symmetric difference）：两集合中交集之外的元素
print(set1^set2)

output
{1, 2, 5, 6}

1.5 字典

1.5.1 字典的创建

在Python中，可以使用一对花括号 {} 来创建一个字典，或者使用内置的dict()函数来创建一个字典。字典由键-值对(key-value pairs)组成，每个键都唯一且不可变（通常是字符串或数字），对应一个值。以下是一些示例：

# 创建一个空字典
empty_dict = {}
print(empty_dict)
print(type(empty_dict))

output
{}
<class ‘dict’>

# 创建一个包含三个键，值为空列表的字典
subject_scores={
    "小红":None,
    "小明":None,
    "小亮":None,
}
print(subject_scores)

output
{‘小红’: None, ‘小明’: None, ‘小亮’: None}

# 创建一个包含三个键值对的字典
subject_scores={
    "小红":90,
    "小明":80,
    "小亮":95,
}
print(subject_scores)

output
{‘小红’: 90, ‘小明’: 80, ‘小亮’: 95}

# 通过 dict() 函数创建字典
empty_dict1 = dict()
print(empty_dict1)

subject_scores1=dict(小红=90,小明=80,小亮=95)
print(subject_scores1)

output
{}
{‘小红’: 90, ‘小明’: 80, ‘小亮’: 95}

# 使用列表推导式创建字典
students = ["小红","小明","小亮"]
scores = [90,80,95]
subject_scores2={students[i]:scores[i] for i in range(len(students))}
print(subject_scores2)

output
{‘小红’: 90, ‘小明’: 80, ‘小亮’: 95}

1.5.2 字典内容的提取

在Python中，字典（dictionary）是一种内置的数据结构，用于存储键（key）和值（value）的对应关系。字典的键（key）必须是唯一的，而值（value）则可以是任何数据类型。以下是字典内容的键（key）和值（value）的提取方法：

my_dict = {"小明":269,"小红":243,"小亮":227}
print(my_dict)

output
{‘小明’: 269, ‘小红’: 243, ‘小亮’: 227}

# 提取所有键（keys）：使用 `keys()` 方法可以获取字典中所有的键。
keys = my_dict.keys()
print(keys)

output
dict_keys([‘小明’, ‘小红’, ‘小亮’])

# 提取所有值（values）：使用 `values()` 方法可以获取字典中所有的值。
values = my_dict.values()
print(values)

output
dict_values([269, 243, 227])

# 提取键值对（items）：使用 `items()` 方法或字典的 `items` 属性可以获取字典中的所有键值对。

# 使用 items() 方法
items1  = my_dict.items()
print(items1)
print(list(items1)[0])

output
dict_items([(‘小明’, 269), (‘小红’, 243), (‘小亮’, 227)])
(‘小明’, 269)

for k,v in items1:
    print('names = ',k)
    print('scores = ', v)

output
names = 小明
scores = 269
names = 小红
scores = 243
names = 小亮
scores = 227

# 提取特定键的值：使用方括号 `[]` 并提供键名可以获取特定键对应的值。
scores0 = my_dict['小明']
print(scores0)

output
269

# 如果键不存在，将会抛出 KeyError
scores1 = my_dict['小白']
print(scores1)

output
---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

~\AppData\Local\Temp\ipykernel_14716\3599480679.py in <module>
      1 # 如果键不存在，将会抛出 KeyError
----> 2 scores1 = my_dict['小白']
      3 print(scores1)


KeyError: '小白'

# 为了安全地提取特定键的值，可以使用 `get()` 方法，它允许您为不存在的键提供一个默认值。
scores2 = my_dict.get('小白',0)
print(scores2)

output
0

1.5.3 字典的修改

Python中的字典（dict）是一种可变的数据结构，可以轻松地进行修改。这些修改包括添加新的键值对、替换已有的键对应的值、以及删除键值对。
下面是对这三种操作的示例：

（1）添加新的键值对

my_dict[‘new_key’] = ‘new_value’

如果添加的键已经存在于字典中，那么它的值将被新值覆盖。

my_dict = {"小明":269,"小红":243,"小亮":227}
my_dict['小白']=300
print(my_dict)

output
{‘小明’: 269, ‘小红’: 243, ‘小亮’: 227, ‘小白’: 300}
{‘小明’: 269, ‘小红’: 243, ‘小亮’: 227, ‘小白’: 299}

（2）替换已有的键对应的值

如果键已经存在于字典中，你可以直接通过键来赋予它一个新的值。

my_dict['小白']=299
print(my_dict)

（3）删除键值对

你可以使用 del 语句或者 pop() 方法来删除字典中的键值对。

print(f"原字典》》{my_dict}")
del my_dict['小明']
print(f"新字典》》{my_dict}")

output
原字典》》{‘小明’: 269, ‘小红’: 243, ‘小亮’: 227, ‘小白’: 299}
新字典》》{‘小红’: 243, ‘小亮’: 227, ‘小白’: 299}

# 使用pop()方法删除一个键值对，并返回被删除的值
print(f"原字典》》{my_dict}")
my_dict1 = my_dict.pop('小白')
print(my_dict1)
print(f"新字典》》{my_dict}")

output
原字典》》{‘小红’: 243, ‘小亮’: 227, ‘小白’: 299}
299
新字典》》{‘小红’: 243, ‘小亮’: 227}

2. Ch7–字符串

2.1 字符串的表示方式

• 普通字符串：指用单引号(‘’)或双引号(“”)括起来的字符串。
• 原始字符串:
• 长字符串

a = 'hello'
b = "world"
print(a+" "+b)

output
hello world

2.1.1 常用转义符

在Python中，字符串中的转义符用于表示那些无法直接包含在字符串中的字符，或者用于表示特殊的含义。

（1）常用转义符：

print("hello\tworld\tgood\tluck")

output
hello world good luck

print("hello world\ngood luck")

output
hello world
good luck

print("hello world \r good luck")

output
hello world
good luck

print('hello "童鞋"')
print('hello,Tom\'s dog')

output
hello “童鞋”
hello,Tom’s dog

print("hello\\world")

output
hello\world

（2）其它转义符

• Unicode字符 (\u)：表示Unicode字符，后面跟随4个十六进制数字。
• 十六进制字符 (\x)：表示十六进制的字符，后面跟随2个十六进制数字。
• 响铃符 (\a)：发出系统的响铃声。
• 退格符 (\b)：删除光标前的一个字符（在大多数文本输出中不起作用）。
• 空字符 (\0)：表示ASCII码表中的空字符（NULL，值为0）。
• 垂直制表符 (\v)：在字符串中插入一个垂直制表符。

print("\u4F60\u597D")

output
你好

print("\x58")

output
X

print('\a')#cmd窗口操作

output

print("hello\bworld")

output
helloworld

print("hello\vworld\vgood luck")

output
helloworldgood luck

2.1.2 原始字符串

print(r"hello \n world")

output
hello \n world

2.1.3 长字符串

• 1.使用三个单引号 ‘’’ 或三个双引号 “”" 来定义，这两种方式在Python中是等价的。
• 2.使用普通的单引号 ’ 或双引号 "，并在字符串中的适当位置使用反斜杠 \n 进行行续。

str00 = "《咏鹅》 鹅鹅鹅，曲项向天歌。白毛浮绿水，红掌拨清波。"
print(str00)

output
《咏鹅》 鹅鹅鹅，曲项向天歌。白毛浮绿水，红掌拨清波。

str0="
《咏鹅》 
鹅鹅鹅，
曲项向天歌。
白毛浮绿水，
红掌拨清波。
"
print(str0)

output
File “C:\Users\SHEN HL\AppData\Local\Temp\ipykernel_17364\1236353306.py”, line 1
str0="
^
SyntaxError: EOL while scanning string literal

str1="""
《咏鹅》 
鹅鹅鹅，
曲项向天歌。
白毛浮绿水，
红掌拨清波。
"""
print(str1)

***output***
《咏鹅》 
鹅鹅鹅，
曲项向天歌。
白毛浮绿水，
红掌拨清波。

str2 = "《咏鹅》\n 鹅鹅鹅，\n曲项向天歌。\n白毛浮绿水，\n红掌拨清波。"
print(str2)

output
《咏鹅》
鹅鹅鹅，
曲项向天歌。
白毛浮绿水，
红掌拨清波。

2.2 字符串与数字的相互转化

2.2.1 将字符串转换为数字

将字符串转换为数字，可以使用int()和float()实现，如果成功则返回数字，否则引发异常。

int("80")

output
80

float("80.0")

output
80.0

2.2.2 将数字转换为字符串

将数字转换为字符串，可以使用str()函数，str()函数可以将很多类型的数据都转换为字符串。

str(123)

output
‘123’

str(123.456)

output
‘123.456’

2.3 格式化字符串

使用字符串的format()方法，它不仅可以实现字符串的拼接，还可以格式化字符串。

2.3.1 使用占位符

要想将表达式的计算结果插入字符串中，则需要用到占位符({})。

i=9
print("i*i={}".format(i*i))

output
i*i=81

i=9
print("{}*{}={}".format(i,i,i*i))

output
9*9=81

i=9
print("{0}*{0}={1}".format(i,i*i))

output
9*9=81

i=9
print("{n1}*{n1}={n2}".format(n1=i,n2=i*i))

output
9*9=81

i=9
print("{n1}*{n3}={n2}".format(n2=i*i,n1=i,n3=5))

output
9*5=81

2.3.2 格式化控制符

money = 15089.67
name = 'Kitty'
age = 26
print("{}今年{}岁，她的工资是{}".format(name,age,money))

output
Kitty今年26岁，她的工资是15089.67

money = 15089.67
name = 'Kitty'
age = 26
print("{0}今年{1}岁，她的工资是{2:0.1f}".format(name,age,money))

output
Kitty今年26岁，她的工资是15089.7

money = 1508900.67
name = 'Kitty'
age = 26
print("{0:s}今年{1:d}岁，她的工资是{2:e}".format(name,age,money))

output
Kitty今年26岁，她的工资是1.508901e+06

2.4 操作字符串

2.4.1 字符串查找

str5 = "hello world"
print(str5.find('e'))
print(str5.find('l'))
print(str5.find('l',4,8))
print(str5.find('l',4))

output
1
2
-1
9

2.4.2 字符串替换

str6 = "AB-CD-EF-GH"
print(str6.replace('-','#'))

output
AB#CD#EF#GH

str6 = "AB-CD-EF-GH"
print(str6.replace('-','#',2))

output
AB#CD#EF-GH

2.4.3 字符串分割

str7='E://tjfx/ch7/img/7-1.png'#需要在自己的某个路径放一张名为“7-1.png”的图片，否则会报错
file_name = str7.split('.')
save_file = file_name[0]+'.pdf'
print(save_file)

output
E://tjfx/ch7/img/7-1.pdf

str6.split('-')

output
[‘AB’, ‘CD’, ‘EF’, ‘GH’]