python学习记录——容器篇

容器

字符串

下标（索引）

# 下表也称为是索引，是一个整型数字，可以是正数，也可以是负数
# 正数下标是从0开始的，表示第一个字符，-1表示最后一个字符
my_str = 'hello'
 h   e   l   l   o
 0   1   2   3   4
-5  -4  -3  -2  -1
# 下标的使用语法  变量[下标]
print(my_str[0])  # h
print(my_str[1])  # e

print(my_str[-1])  # o
print(my_str[-3])  # l

# len()函数可以得到字符串的长度
print(len(my_str))  # 5
# 使用正数下标表示字符串最后一个元素
print(my_str[len(my_str)-1])  # o
# 使用负数下标表示字符串最后一个元素
print(my_str[len(my_str)*1])  # o

切片

切片是指对操作的对象截取一部分的操作。字符串、列表、元组都支持切片操作。

切片的语法：[起始:结束:步长]

注意：选取的区间从“起始”位开始，到“结束”前一位结束（不包含结束位本身），步长表示选取间隔。

my_str[:]  得到和原来一样的字符串
my_str[::-1]  得到和原来顺序相反的字符串，即字符串的逆置

# 切片可以获取一段数据，多个数据；下标（索引）只能获得一个数据
# 切片语法： 变量[start:end:step],会得到一个新的字符串
# start 开始位置的下标
# end 结束位置的下标，不包含end 对应的下标
# step 步长，下标之间的间隔，默认是1
my_str = 'hello'
my_str1 = my_str[2:4:1]  # ll

# step 如果是1，即默认值，可以不写
my_str2 = my_str[2:4]  # ll

# end位置不写，表示是len()，即可以取到最后一个元素
my_str3 = my_str[2:]  # llo

# start 位置也可以省略不写，表示是0，即下标为0的位置开始
my_str4 = my_str[:3]  # hel

# start和end也可以都不写，但是冒号需要写
my_str5 = my_str[:]  # hello

print(my_str[-4:-1])  # ell
print(my_str[3:1])  # 没有数据

# 步长可以是负数
print(my_str[3:1:-1])  # ll

print(my_str[::-1])  # 字符串的逆置，olleh

print(my_str[::2])  # 0 2 4 hlo my_str[0:5:2]

字符串常见操作

如有字符串mystr = 'hello world itcast and itcastcpp'，以下是常见的操作

<1>find&rfind

find()检测 str 是否包含在 mystr中，如果是返回开始的索引值，否则返回-1

my_str = 'hello world itcast and itcastcpp'

# find() 在字符串中查找是否存在某个字符串
# my_str.find(sub_str, start, end)
# sub_str: 要在字符串中查找的内容，类型为str
# start: 开始位置，从哪里开始查找，默认是0
# end: 结束的位置，查找到哪里结束，默认是len()
# 返回值：方法的执行结果是什么，如果找到sub_str，返回sub_str在my_str中的位置的正数下标
# 如果没有找到，返回-1

index = my_str.find('hello')  # 0
print(index)
# 从下标为3的位置，开始查找字符串 hello
print(my_str.find('hello', 3))  # -1
print(my_str.find('itcast'))  # 12
print(my_str.find('itcast', 15))  # 23
# rfind() right find() 从右边（后边）开始查找
print(my_str.rfind('itcast'))  # 23

<2>index$rindex

index()跟find()方法一样，只不过如果str不在 mystr中会报错。

rindex()跟rfind()一样，只不过找不到子串就报错。

mystr.index(str, start=0, end=len(mystr))

<3>count

返回 str在start和end之间 在 mystr里面出现的次数

# count(sub_str, start, end) 统计出现的次数
print(my_str.count('aaaa'))  # 0
print(my_str.count('hello'))  # 1
print(my_str.count('itcast'))  # 2
print(my_str.count('itcast', 20))  # 1

<4>replace

把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次.

# my_str.replace(old_str, new_str, count)  字符串的替换，将 my_str 中的 old_str 替换成 new_str
# old_str：将要被替换的字符串
# new_str：新的字符串，要被替换成的字符串
# count：替换的次数，默认是全部替换
# 返回值：得到一个新的字符串，不会改变原来的字符串

my_str = 'hello world itcast and itcastcpp'

my_str1 = my_str.replace('itcast', 'itheima')

print('my_str :', my_str)  # my_str : hello world itcast and itcastcpp
print('my_str1 :', my_str1)  # my_str1 : hello world itheima and itheimacpp

my_str2 = my_str.replace('itcast', 'itheima', 1)  # 替换一次
print('my_str2 :', my_str2)  # my_str2 : hello world itheima and itcastcpp

<5>split

以 str 为分隔符切片 my_str，如果 count 有指定值，则仅分隔count次，分隔出 count +1 个子字符串。

也有rsplit，从右分隔

my_str.split(',')是常见的写法

my_str = 'hello world itcast and itcastcpp'

# my_str.split(sub_str, count)  将 my_str 字符串按照 sub_str 进行切割
# sub_str:按照什么内容切割字符串,默认是空白字符，空格，tab键
# count:切割count次，默认是全部切割
# 返回值:列表[]

result = my_str.split()  # 按照空白字符，全部切割
print(result)  # ['hello', 'world', 'itcast', 'and', 'itcastcpp']

print(my_str.split('itcast'))  # ['hello world ', ' and ', 'cpp']
print(my_str.split('itcast', 1))  # 切割一次，['hello world ', ' and itcastcpp']
print(my_str.rsplit('itcast', 1))  # 切割一次，['hello world itcast and ', 'cpp']

<6>join

将 mystr 插入到 str 中每个元素之间,构造出一个新的字符串

mystr.join(str)

# my_str.join(可迭代对象)
# 可迭代对象：str，列表（join需要列表中的每一个数据都是字符串类型），元组等
# 将 my_str 这个字符串添加到可迭代对象的两个元素之间
# 返回值：一个新的字符串,不会改变原字符串的值

my_str = '_'.join('hello')  # 会把 _ 加入到hello每两个元素之间
print(my_str)  # h_e_l_l_o
print('_*_'.join('hello'))  # h_*_e_*_l_*_l_*_o

# 定义列表
my_list = ['hello', 'cpp', 'python']
print('_'.join(my_list))  # hello_cpp_python
print(' '.join(my_list))  # hello cpp python

字符串常用操作(课外阅读)

<1>capitalize

把字符串的第一个字符大写

mystr.capitalize()

<2>title

把字符串的每个单词首字母大写

>>> a = "hello itcast"
>>> a.title()
'Hello Itcast'

<3>startswith

检查字符串是否是以 hello 开头, 是则返回 True，否则返回 False

mystr.startswith(hello)

<4>endswith

检查字符串是否以obj结束，如果是返回True,否则返回 False.

mystr.endswith(obj)

<5>lower

转换 mystr 中所有大写字符为小写

mystr.lower()        

<6>upper

转换 mystr 中的小写字母为大写

mystr.upper()

<7>ljust

返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串

mystr.ljust(width)

<8>rjust

返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串

mystr.rjust(width)

<9>center

返回一个原字符串居中,并使用空格填充至长度 width 的新字符串

mystr.center(width)   

<10>lstrip

删除 mystr 左边的空白字符

mystr.lstrip()

<11>rstrip

删除 mystr 字符串末尾的空白字符

mystr.rstrip()

<12>strip

删除mystr字符串两端的空白字符

>>> a = "\n\t itcast \t\n"
>>> a.strip()
'itcast'

<13>rfind

类似于 find()函数，不过是从右边开始查找.

mystr.rfind(str, start=0,end=len(mystr) )

<14>rindex

类似于 index()，不过是从右边开始.

mystr.rindex( str, start=0,end=len(mystr))

<15>partition

把mystr以str分割成三部分,str前，str和str后

mystr.partition(str)

<16>rpartition

类似于 partition()函数,不过是从右边开始.

mystr.rpartition(str)

<17>splitlines

按照行分隔，返回一个包含各行作为元素的列表

mystr.splitlines()  

<18>isalpha

如果 mystr 所有字符都是字母 则返回 True,否则返回 False

mystr.isalpha()  

<19>isdigit

如果 mystr 只包含数字则返回 True 否则返回 False.

mystr.isdigit()

<20>isalnum

如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False

mystr.isalnum()  

<21>isspace

如果 mystr 中只包含空格，则返回 True，否则返回 False.

mystr.isspace()   

列表

列表的定义和基本使用

# 列表 是python中的一种数据类型，可以存放多种数据，列表中的数据可以是任意不同类型的
# 列表 list，定义使用[]进行定义

# 定义空列表
my_list = []
print(my_list, type(my_list))  # [] <class 'list'>
my_list1 = list()  # 空列表
print(my_list1, type(my_list1))  # [] <class 'list'>
# 定义带数据的列表，数据元素之间使用逗号隔开
my_list2 = [1, 3.14, True, 'isaac']
print(my_list2, type(my_list2))  # [1, 3.14, True, 'isaac'] <class 'list'>
# 求列表中数据元素的个数，即列表的长度
num = len(my_list2)
print(num)  # 4

# 列表支持下标与切片操作
print(my_list2[1])  # 3.14
print(my_list2[-1])  # isaac

print(my_list2[1:3])  # [3.14, True]

# 下标操作和字符串不同的是：字符串不能使用下标修改其中的数据，但是列表可以,且数据类型任意
my_list2[0] = 18
print(my_list2)  # [18, 3.14, True, 'isaac']

my_list2[-1] = 'hello'
print(my_list2)  # [18, 3.14, True, 'hello']

my_list2[0]='python'
print(my_list2)  # ['python', 3.14, True, 'hello']

列表的遍历

<1>for

<2>while

my_list = ['郭德纲', '于谦', '小岳岳', '孙越']

for i in my_list:  # i 就是列表中的每一个数据
    print(i)
# 郭德纲
# 于谦
# 小岳岳
# 孙越

j = 0  # j 表示下标
while j < len(my_list):
    print(my_list[j])
    j += 1
# 郭德纲
# 于谦
# 小岳岳
# 孙越

向列表中添加数据的方法

<1>append

<2>insert

<3>extend

# 向列表中添加数据的方法，都是直接在原列表中进行添加的，不会返回新的列表
my_list = ['郭德纲', '于谦', '小岳岳', '孙越']
print(my_list)  # ['郭德纲', '于谦', '小岳岳', '孙越']

# 列表.append(数据) 向列表的尾部追加数据
my_list.append('aa')
print(my_list)  # ['郭德纲', '于谦', '小岳岳', '孙越', 'aa']
result = my_list.append(12)  # 不要这样书写。
print(result)  # None 关键字，表示空
print(my_list)  # ['郭德纲', '于谦', '小岳岳', '孙越', 'aa', 12]

# 列表.insert(下标,数据) 在指定的下标位置进行添加数据
my_list.insert(0, 'isaac')
print(my_list)
# print(my_list.insert(5, 3.14)) 不能这样书写，返回的是None

# 列表.extend(可迭代对象) 会将可迭代对象中的数据逐个添加到原列表的末尾
my_list.extend('hel')
print(my_list)  # ['isaac', '郭德纲', '于谦', '小岳岳', '孙越', 'aa', 12, 'h', 'e', 'l']
my_list.extend([1, 'python', 3])
print(my_list)  # ['isaac', '郭德纲', '于谦', '小岳岳', '孙越', 'aa', 12, 'h', 'e', 'l', 1, 'python', 3]

列表中数据查询的操作

<1>index

<2>count

<3>in/not in

my_list = [1, 3.14, 'isaac', False]
# index()  根据数据值，查找元素所在的下标，找到返回元素的下标，没有找到，程序报错
# 列表中没有find方法，只有index()方法
# 查找 3.14 在列表中的下标
num = my_list.index(3.14)
print(num)  # 1

num1 = my_list.index(100)  # 因为数据不存在，程序报错  ValueError: 100 is not in list


# count() 统计出现的次数
num3 = my_list.count(1)
print(num3)  # 1

# in/not in 判断是否存在，存在是True，不存在是False
num4 = 3.14 in my_list
print(num4)  # True

num4 = 3.14 not in my_list
print(num4)  # False

列表中的删除操作

<1>remove

<2>pop

<3>del

my_list = [1, 2, 4, 5, 6, 9]

# 1. 根据元素的数据值删除 remove(数据值),直接原列表中的数据
my_list.remove(4)
print(my_list)  # [1, 2, 5, 6, 9]
my_list.remove(4)  # 因为要删除的数据不存在，程序报错 ValueError: list.remove(x): x not in list

# 2. 根据下标删除
# 2.1 pop(下标) 默认删除最后一个数据，返回删除的内容
num = my_list.pop()  # 删除最后一个数据 9
print(num)  # 9
print(my_list)  # [1, 2, 5, 6]
num = my_list.pop(2)  # 删除下标为2的数据 5
print(num)  # 5
print(my_list)  # [1, 2, 6]
my_list.pop(10)  # 删除的下标不存在，报错 IndexError: pop index out of range

# 2.2 del 列表[下标]
del my_list[1:2]  # 删除下标为1~2的数据 2,6
print(my_list)  # [1]
del my_list[10]  # 下标越界，报错 IndexError: list assignment index out of range

注

列表中添加数据，添加的数据后面的数据自动后移

列表中删除数据，删除的数据后面的数据自动前移

列表的排序与逆置

<1>sort

<2>sorted

<3>逆置

# 想要对列表中的数据进行排序，前提是列表中的数据类型是一样的
my_list = [1, 5, 3, 7, 9, 6]

# 列表.sort() 直接在原列表中进行排序
my_list.sort()  # 默认是从小到大排序，即升序
print(my_list)  # [1, 3, 5, 6, 7, 9]
my_list.sort(reverse=True)  # 通过reverse = True,从大到小排序，即降序
print(my_list)  # [9, 7, 6, 5, 3, 1]

# 补充：sorted(列表) 排序，不会在原列表中进行排序，会得到一个新的列表
my_list1 = sorted(my_list)
my_list2 = sorted(my_list, reverse=True)
print(my_list)  # [9, 7, 6, 5, 3, 1]
print(my_list1)  # [1, 3, 5, 6, 7, 9]
print(my_list2)  # [9, 7, 6, 5, 3, 1]

my_list3 = ['a', 'b', 'c', 'd', 'e']
# 逆置
my_list4 = my_list3[::-1]  # 得到一个新的列表
print(my_list3)  # ['a', 'b', 'c', 'd', 'e']
print(my_list4)  # ['e', 'd', 'c', 'b', 'a']

# 在原列表中直接逆置 列表.reverse()
my_list3.reverse()

列表的嵌套

school_names = [['北京大学', '清华大学'],
                ['南开大学', '天津大学', '天津师范大学'],
                ['山东大学', '中国海洋大学']]

print(school_names[1])  # ['南开大学', '天津大学', '天津师范大学']
print(school_names[1][1])  # 天津大学
print(school_names[1][1][1])  # 津

for schools in school_names:
    #print(schools)  # 列表
    for name in schools:
        print(name)
北京大学
清华大学
南开大学
天津大学
天津师范大学
山东大学
中国海洋大学

案例：分配办公室

一个学校，有3个办公室，现在有8位老师等待工位的分配，请编写程序，完成随机的分配

思路：

1.定义老师及办公室 [][][ [], [], [] ]

2.定义老师 [ a b ]

3.抓阄，

for 遍历老师列表：

​ 抓阄

import random

schools = [[], [], []]  # 三个小列表对应三个办公室，对应的下标是0，1，2
teachers = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
for teacher in teachers:
    num = random.randint(0, 2)  # randint是唯一一个包含结束位置的方法  产生的随机数相当于是办公室的下标
    schools[num].append(teacher)  # 将老师名字添加到办公室列表中

print(schools)
i = 1
for office in schools:
    print(f'第{i}号办公室老师人数为{len(office)}个，办公室老师的名字：')
    for teacher in office:
        print(teacher, end=' ')
    print()
    i += 1

元组

Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

定义空元组

# 元组和列表非常相似，都可以存放多个数据，可以存放不同数据类型的数据
# 不同点：列表使用[]定义，元组使用()定义
# 列表中的数据可以修改，元组中的数据不能被修改

my_list = [18, 3.14, True, 'isaac']  # 列表

my_tuple = (18, 3.14, True, 'issac')  # 元组
print(my_tuple, type(my_tuple))  # (18, 3.14, True, 'issac') <class 'tuple'>

# 元组支持下标和切片操作
print(my_tuple[1])  # 3.14

# 定义空元组,没有意义
my_tuple1 = ()
my_tuple2 = tuple()
print(my_tuple1, type(my_tuple1))  # () <class 'tuple'>
print(my_tuple2, type(my_tuple2))  # () <class 'tuple'>

# 定义一个数据元素的元组，数据元素后边，必须有一个逗号
my_tuple3 = (3)
print(my_tuple3, type(my_tuple3))  # 3 <class 'int'>
my_tuple4 = (3,)
print(my_tuple4, type(my_tuple4))  # (3,) <class 'tuple'>

<1>访问元组

元组支持下标与切片操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BAlficG6-1611765091519)(Python学习记录（杂）.assets/Snip20160815_301.png)]

<2>修改元组

说明： python中不允许修改元组的数据，包括不能删除其中的元素。

<3>count, index

index和count与字符串和列表中的用法相同

>>> a = ('a', 'b', 'c', 'a', 'b')
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0