python(四)-容器

目录

python常见容器

字符串

字符串的遍历

 索引

切片

查找元素

修改元素

列表

查找列表元素

列表的遍历

添加元素

删除元素

修改元素

查找元素

排序操作

元组

查找元素

元组的遍历

字典

获取键值对

添加元素

删除元素

修改元素

查找元素

---

python常见容器

（1）字符串：使用双引号引起来的内容；
（2）列表：使用[ ]表示的内容；     --可变类型
（3）元组：使用( )表示的内容；
（4）字典：使用{ }表示，内部元素是键值对。    --可变类型

字符串

变量名 = "内容"

 例

（1）使用双引号表示一个公司名称；

（2）使用单引号表示公司名称；

（3）分别输出变量的类型结果；

（4）思考1：使用字符串与一个数值拼接，会怎样？

（5）思考2：一段使用引号表示的字符串中，还有引号，该怎么处理？

str1 = "博创科技"
print(type(str1)) # <class 'str'>


str2 = '博创科技'
print(type(str2)) # <class 'str'>

s1 = "hello"+"world" # helloworld
print(s1)

s2 = "hello"+666    # 报错


s2 = "hello"+"666"
print(s2) # hello666


s3 = "hello"+str(666)
print(s3) # hello666

字符串的遍历

（1）定义一个字符串变量，内容为：ABCDEF；

（2）使用for循环来遍历元素；

使用for循环

# 1.定义字符串
strs = "ABCDEF"
# 2.使用for遍历
for temp in strs:
    print(temp)

使用while遍历

# 3.使用while遍历
strs = "ABCDEF"
i = 0
while i < (len(strs) -1):
    print(strs[i])
    i += 1

 索引

索引值是从0开始计算的.len(s):返回变量s的长度或元素个数

例

（1）定义一个存有HelloWorld的字符串变量；

（2）获取变量中的H和W；

（3）获取变量的总长度；

（4）思考：如何获取变量的最后一个元素d。

# 1.定义变量
strs = "HelloWorld"
# 2.获取元素
print(strs[0])    #  H
print(strs[5])    #  W

# 3.长度
print(len(strs))  # 10

# 4.访问最后一个元素
# 正常
print(strs[9])   # d
print(strs[len(strs)-1])  # d

# 逆向
print(strs[-1])  # d

切片

切片指的是：截取字符串中的一部分内容。

[起始, 结束)

[起始:结束:步长]

例

（1）定义一个字符串变量，内容为：HelloIpython；

（2）截取索引值1到5之间的内容；

（3）截取索引值2到结尾的内容；

（4）截取索引值2到倒数第2个的内容；

（5）截取起始处到索引值为3的内容；

（6）截取索引1到8且每隔2个字母截取一下内容；

（7）截取索引2到10且每隔3个截取一下内容。

# 1.定义变量
strs = "Hellopython"
# 2
print(strs[1:5])  # ello
# 3
print(strs[2:12]) # llopython
# 4
print(strs[2:-2]) # llopyth
# 5
print(strs[0:3]) # Hel
# 6
print(strs[1:8:2]) # elpt
# 7.
print(strs[2:10:3]) # lph

查找元素

字符串的查找方法指的是查找元素（或子串）在字符串内容的索引位置。

函数名	含义
find(sub)	检测sub是否包含在字符串中，如果是，则返回sub所在开始的索引，否则返回-1。
index(sub)	与find()类似，只不过当sub在字符串中不存在时，会报错误。
rfind(sub)	从右往左找子串在字符串的某个索引。
count(sub)	计算sub在字符串中出现的总次数。

 例

（1）定义一个字符串变量，内容为：hello world and itcast and java and Python；

（2）分别使用find()和index()函数来查看and所在位置；

（3）思考1：如果查找不存在的内容666，效果如何？

（4）思考2：若要从右往左查找and，该怎么做？若还要获取and出现的总次数呢？

# 1.定义字符串
name = "hello world and itcast and java and Python"

# 2.and -find()  index()
print(name.find("and")) # 12
print(name.index("and")) # 12

# 3.对比find  index
print(name.find("666"))  # -1
print(name.index("666"))  # 报错

# 4.从右往左    right
print(name.rfind("and"))  # 32
print(name.rindex("and"))  # 32
# 总次数
print(name.count("and"))   # 3

注意:

输出的是字符串的第一个下标位置,

find()函数若没找到想要的内容,输出-1,而index()函数是报错.

修改元素

字符串的修改方法，指的是修改字符串中的数据。

函数名	含义
replace(old, new)	用于将字符串中的old内容替换成new内容。
split(sep)	使用指定内容sep来对字符串进行切割。
strip()	用于去掉字符串前后的空白内容。

例

（1）定义一个字符串变量，内容有： hello python big data ；

（2）将变量中的空格替换为666；

（3）使用空格、字符a来分别分割字符串；

（4）去掉字符串的前后空白内容。

# 1.定义字符串
str1 = "hello python big data"

# 2.替换
ret1 = str1.replace(" ","666")
print(ret1)

# 3.切割
ret2 = str1.split("a")
print(ret2)

# 4.去掉空白
strs = "  hello python big data    "
result1 = strs.lstrip()
result2 = result1.rstrip()
print(result2)

列表

变量名 = [元素1,元素2,元素3,...]

例

（1）定义一个列表变量1，用于存放几个知名大学名称；

（2）定义一个列表变量2，用于存放某学生的姓名、年龄、存款、是否男生等信息；

（3）思考：要把字符串Python转换为列表list类型的值，该怎么做？

# 1.定义列表变量：相同类型
lists = ["南京大学","南开大学","南昌大学","东南大学"]  # 数组
print(type(lists))

# 2.不同类型的数据元素
data = ["孙悟空",38,1000000,True]
print(type(data))   # 列表中可以存放多种不同类型的数据

# 3.思考: list()
strs = "Python"
result = list(strs)
print(result) 

查找列表元素

例

（1）获取知名大学名称列表变量的元素总个数；

（2）获取列表变量的第1个和第3个位置对应的元素值；

（3）思考：若直接访问不存在的第100个元素值，会怎样？

lists = ["南京大学","南开大学","南昌大学","东南大学"]
# 获取总个数
print(len(lists))  # 4
# 访问元素
print(lists[0])  # 南京大学
print(lists[2])  # 南昌大学

# 问题
print(lists[100])
# 注意: 当直接通过 变量名[索引值] 访问元素时, 记得索引值不允许超过最大索引值。  -报错！

列表的遍历

例

（1）定义一个列表变量，用于存放水果信息，内容为：苹果、香蕉、西瓜、菠萝等；

（2）使用for循环来遍历元素；

使用for循环遍历

# 1.定义列表变量
datas = ["苹果","香蕉","西瓜","菠萝"]
# 2.遍历
for temp in datas:
    print(temp)

使用while循环遍历

datas = ["苹果","香蕉","西瓜","菠萝"]
# 遍历
i = 0
while i < len(datas):
    print(datas[i])
    i += 1

添加元素

函数名	含义
append(x)	用于在列表结尾处，添加数据内容x。
insert(index, x)	用于在列表索引index处，新增一个元素x。
extend(x)	用于给列表添加另一个列表的所有元素内容，并形成一个完整列表。

例

（1）定义一个列表变量，存放内容：中国、美国、英国、俄罗斯；

（2）在列表结尾处添加元素：德国；

（3）在元素美国后添加元素：日本；

（4）思考：若要在列表变量的结尾处，再新增元素：100、200、300，该怎么做？

# 1.定义列表的变量
country_list = ["中国","美国","英国","俄罗斯"]  # 可变类型
print(f"原始数据:{country_list}")

# 2.在列表结尾添加元素
country_list.append("德国")
print(country_list)

# 3.在元素美国后边添加元素
country_list.insert(1,"日本")
print(country_list)

# 4.批量添加
lists = [100,200,300]
country_list.extend(lists)
print(country_list)

删除元素

函数名	含义
remove(x)	删除列表元素值x。
del 变量名[索引]	根据索引值，删除列表的某个元素。

例

（1）定义一个列表变量，存放内容：中国、美国、英国、俄罗斯；

（2）使用remove()删除元素：英国；

（3）使用del删除元素：美国；

# 1.定义列表的变量
country_list = ["中国","美国","英国","俄罗斯"]
print(country_list)
print(f"原始长度:{len(country_list)}")

# remove()删除
country_list.remove("英国")
print(country_list)
print(f"删除后的长度:{len(country_list)}")

# del 删除
del country_list[1]
print(country_list)

修改元素

函数名	含义
变量名[索引] = 值	根据索引值，来修改列表中的某个元素值。

例

（1）定义一个列表变量，存放内容：中国、美国、英国、俄罗斯；

（2）将中国修改为中华人民共和国；

（3）修改俄罗斯为Russia；

# 1.定义列表的变量
country_list = ["中国","美国","英国","俄罗斯"]

# 2.修改中国
country_list[0] = "中华人民共和国"
print(country_list)

# 3.修改俄罗斯
country_list[3] = "Russia"
country_list[-1] = "Russia"
print(country_list)

查找元素

函数名	含义
len(s)	返回s的长度或元素个数。
in	判断指定数据是否在某个列表序列中。如果在就返回True，否则返回False。

例

（1）因["192.168.1.15", "10.1.1.100", "172.35.46.128","172.32.24.99"]等IP地址存在恶意访问程序员官网，被列为访问黑名单；

（2）获取黑名单IP列表的长度；

（3）从键盘上输入一个IP地址，并用于判断是否是黑名单IP地址？

# 1.定义ip列表
ip_lists = ["192.168.1.15", "10.1.1.100", "172.35.46.128","172.32.24.99"]

# 2.获取长度
print(len(ip_lists))

# 3.判断是否是黑名单
temp_ip = input("请输入IP地址:")
if temp_ip in ip_lists:
    print("Forbidden 403, 你的行为不检点!!!")
else:
    print("欢迎你!!")

排序操作

函数名	含义
reverse()	将列表进行倒序，即输入顺序与输出顺序相互倒过来。
sort([reverse=False])	对列表进行从小到大排序。当设置reverse=True可改为由大到小排序。

例

（1）定义一个列表变量，存放数据：10、200、20、100、30、0；

（2）将列表数据进行倒序输出；

（3）将列表进行从小到大排序；

（4）思考：若要将列表元素进行从大到小排序，该怎么做呢？

# 1.定义变量
data = [10,200,20,100,30,0]
# 2.倒序
data.reverse()
print(data)
# 3.从小到大排序
data.sort()
print(data)
# 4.从大到小排序
data.sort(reverse=True)
print(data)

元组

变量名 = (元素1,元素2,元素3,...)

例

（1）定义一个元组变量1，用来存放多个数值；

（2）定义一个元组变量2，并存放不同类型的数据；

（3）查看变量类型，

# 1.定义变量1
ts1 = (1,2,3,8,90,)
# 2.定义变量2
ts2 = (True,"男","python",)
# 查看类型
print(ts1)
print(type(ts1)) # <class 'tuple'>
print(type(ts2)) # <class 'tuple'>

查找元素

元组只支持查找,且不支持修改/删除和添加

函数名	含义
元组变量名[索引]	按索引值查找数据。
index(x)	查找某个数据，当数据不存在时会报错，语法和列表、字符串的index()方法相同。
len(x)	表示元组中元素的总个数。
in	用于判断元素是否出现在元组中。

例

（1）定义一个元组变量，内容有：Python、MySQL、Linux、Hadoop；

（2）试着给元组变量添加、删除、修改元素，观察效果；

（3）查找元组中的元素：Python、Linux；

（4）查看元组中的元素总个数；

（5）判断Hello是否存在元组变量中？

# 1.定义变量
source = ("Python","Linux","MySQL","Hadoop",)
# 2.思考: 添加、删除、修改
# source[0] = "大数据"  # 不支持修改
# source.ap  # 不支持添加
# del source[0]  # 不支持删除
# 3.查找
print(source[0]) # Python
print(source[1])  # Linux
# 4.个数
print(len(source))
# 5.是否存在
print("Hello" in source)

元组的遍历

例

（1）定义一个元组变量，存放几个知名的手机品牌；

（2）分别使用for和while循环遍历元组数据；

for循环遍历

# 1.定义元组变量
phone_lists = ("三星","苹果","OPPO","传音","Mi",)
# 2.遍历元组数据
# for
for temp in phone_lists:
    print(temp)

 while循环遍历

# while
index = len(phone_lists)-1
while index >= 0:
    print(phone_lists[index])
    index -= 1

字典

变量名 = {键1: 值1, 键2: 值2, ...}

例

（1）定义一个字典变量，存放一个学生的信息：姓名、性别、住址、年龄等；

（2）输出并查看字典变量值与类型；

（3）思考1：若给字典变量存放两个性别信息，会怎样？

（4）思考2：若给字典变量再存放一个薪酬，与年龄值相同，会怎样？

# 1.定义字典变量
student = {"name":"欧阳芝","sex":"女","address":"广东广州","age":16}
# 2.查看类型和变量值
print(type(student))  # <class 'dict'>
print(student)
# 3.存放两个性别?  sex  键唯一?
student = {"name":"欧阳芝","sex":"女","address":"广东广州","age":16,"sex":"Female"}
print(student)   # 键是唯一的,如果有多个相同的键, 最后的键会把前面的键所对应的值都给覆盖了
# 4.value多个
student = {"name":"欧阳芝","sex":"女","address":"广东广州","age":16,"salary":16}
print(student)  # 值可以重复

获取键值对

通过键来访问值的方式有两种。方式1：

变量名[键]

当访问不存在的键时，提升稳定性，可使用方式2：

函数名	含义
get(key[, default])	返回指定键key对应的值，若值不在字典中，则返回默认值。

例

（1）定义一个字典变量，存放一个学生的信息：姓名、住址、年龄等；

（2）分别使用不同方式去获取字典的姓名、住址值；

（3）思考：当访问不存在的性别信息时，会怎样？

# 1.定义变量
student = {"name":"欧阳芝","address":"广东广州","age":16,"sex":"Female"}
# 2.获取值
print(student["name"])
print(student["address"])  # 可以通过键来访问值

# 3.访问不存在的值
print(student["phone"])  # 报错
print(student.get("phone"))   # 1. None   2.不报错
print(student.get("sex","女"))

添加元素

变量名[键] = 值

例

（1）定义一个字典变量，存放老师信息：姓名、体重、年龄等；

（2）给老师变量添加一个兴趣爱好；

（3）思考：若给一个空字典添加2个元素，该怎么做？

# 1.定义变量
teacher = {"name":"涛哥","weight":95,"age":40}
print(teacher)
# 2.添加一个元素
teacher["hobby"] = "运动"
print(teacher)

# 3.空字典添加2个元素
teacher = {}
teacher["name"] = "方哥"
teacher["like"] = "爱好工作"
print(teacher)
print(type(teacher))

删除元素

函数名	含义
del 变量名[键]	删除指定元素。
clear()	清空字典的所有元素内容。

例​​​​​​​

（1）定义一个字典变量，存放老师信息：姓名、体重、年龄等；

（2）试着删除字典的体重元素；

teacher = {"name":"涛哥","weight":95,"age":40}
# 1.删除体重
del teacher["weight"]
print(teacher)

修改元素

变量名[键] = 值

例

（1）定义一个字典变量，存放老师信息：姓名、体重、年龄等；

（2）修改字典变量的姓名、体重值。

teacher = {"name":"涛哥","weight":95,"age":40}
# 修改姓名
teacher["name"] = "健哥"
# 修改体重
teacher["weight"] = 110
print(teacher)

查找元素

函数名	含义
get(key[, default])	返回指定键key对应的值，若值不在字典中，则返回默认值。

例​​​​​​​

（1）定义一个字典变量，存放老师信息：姓名、体重、年龄等；

（2）使用两种方式来查看老师的姓名、年龄。

teacher = {"name":"涛哥","weight":95,"age":40}
print(teacher["name"])
print(teacher.get("age"))   # 若报错,则优先考虑使用get()