容器
容器就是存储数据的东西, 同时Python为了方便我们对容器中的数据进行增加删除修改查询专门提供了相应的方法便于我们操作
1，字符串的格式
双引号或者单引号中的数据，就是字符串
2，下标和索引
所谓“下标”，就是编号，就好比超市中的存储柜的编号，通过这个编号就能找到相应的存储空间中存储的东西
name = 'abcdef'
print(name[0])
print(name[1])
print(name[2])
结果:
a
b
c
3 ，切片
切片: 切片是指对操作的对象截取其中一部分的操作. 比如想要取字符串"888666@qq.com"中的QQ号的时候就可以使用切片
切片的语法：[起始:结束:步长]
注意：选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，步长表示选取间隔的长度
s = 'Hello World!'
print(s[4])
print(s)
print(s[:]) # 取出所有元素（没有起始位和结束位之分），默认步长为1
print(s[1:]) # 从下标为1开始，取出 后面所有的元素（没有结束位）
print(s[:5]) # 从起始位置开始，取到 下标为5的前一个元素（不包括结束位本身）
print(s[:-1]) # 从起始位置开始，取到 倒数第一个元素（不包括结束位本身）
print(s[-4:-1]) # 从倒数第4个元素开始，取到 倒数第1个元素（不包括结束位本身）
print(s[1:5:2]) # 从下标为1开始，取到下标为5的前一个元素，步长为2（不包括结束位本身）
4，字符串的常见操作
查找 find()
语法：字符串序列.find(子串, 开始位置下标, 结束位置下标)
mystr = "hello world and itcast and itheima and Python"
print(mystr.find('and')) # 12
print(mystr.find('and', 15, 30)) # 23
print(mystr.find('ands')) # -1
index()
语法：字符串序列.index(子串, 开始位置下标, 结束位置下标)
mystr = "hello world and itcast and itheima and Python"
print(mystr.index('and')) # 12
print(mystr.index('and', 15, 30)) # 23
print(mystr.index('ands')) # 报错
修改replace()
语法：字符串序列.replace(旧子串, 新子串, 替换次数)
mystr = "hello world and itcast and itheima and Python"
# 结果：hello world he itcast he itheima he Python
print(mystr.replace('and', 'he'))
# 结果：hello world he itcast he itheima he Python
print(mystr.replace('and', 'he', 10))
# 结果：hello world and itcast and itheima and Python
print(mystr)
分割split()
语法：字符串序列.split(分割字符, num)
mystr = "hello world and itcast and itheima and Python"
# 结果：['hello world ', ' itcast ', ' itheima ', ' Python']
print(mystr.split('and'))
# 结果：['hello world ', ' itcast ', ' itheima and Python']
print(mystr.split('and', 2))
# 结果：['hello', 'world', 'and', 'itcast', 'and', 'itheima', 'and', 'Python']
print(mystr.split(' '))
# 结果：['hello', 'world', 'and itcast and itheima and Python']
print(mystr.split(' ', 2))
注意：如果分割字符是原有字符串中的子串，分割后则丢失该子串。
总结示例
str1 = " asesc d sad sad"
# 将字符串通过空格切片
print(str1.split(" "))
# 去除空格（但是我没看到效果）
print(str1.strip())
# 将所有字母都换成大写
print(str1.upper())
# 将所有字母都换成小写
print(str1.lower())
# 两个字母之间通过-进行连接
print('-'.join(str1))
# 返回第一个发现的下标
print(str1.find("s"))
# 返回第一个索引的下标
print(str1.index('s'))
# 查找符合的字符串，返回索引下标
li1 = 'sder'
print(li1.index('er'))
# 判断是否是字母
print(str1.isalpha())
# 判断字符串是否是纯数字
print(str1.isdigit())
# 统计括号内出现的次数
print(str1.count("s"))
# 不会将原字符串更换掉，而是返回一个新的字符串
print(str1.replace("s", "a"))
结果：
['', 'asesc', 'd', 'sad', 'sad']
asesc d sad sad
ASESC D SAD SAD
asesc d sad sad
-a-s-e-s-c- -d- -s-a-d- -s-a-d
2
2
2
False
False
4
aaeac d aad aad
扩展字符串操作
- capitalize
把字符串的第一个字符大写
mystr.capitalize() - title
把字符串的每个单词首字母大写
a = “hello itcast”
a.title()
‘Hello Itcast’
- startswith
检查字符串是否是以 hello 开头, 是则返回 True，否则返回 False
mystr.startswith(hello) - endswith
检查字符串是否以obj结束，如果是返回True,否则返回 False.
mystr.endswith(obj) - lower
转换 mystr 中所有大写字符为小写
mystr.lower() - upper
转换 mystr 中的小写字母为大写
mystr.upper() - ljust
返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
mystr.ljust(width) - rjust
返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
mystr.rjust(width) - center
返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
mystr.center(width) - lstrip
删除 mystr 左边的空白字符
mystr.lstrip() - rstrip
删除 mystr 字符串末尾的空白字符
mystr.rstrip() - strip
删除mystr字符串两端的空白字符
a = “\n\t itcast \t\n”
a.strip()
‘itcast’
- rfind
类似于 find()函数，不过是从右边开始查找.
mystr.rfind(str, start=0,end=len(mystr) ) - rindex
类似于 index()，不过是从右边开始.
mystr.rindex( str, start=0,end=len(mystr)) - partition
把mystr以str分割成三部分,str前，str和str后
mystr.partition(str) - rpartition
类似于 partition()函数,不过是从右边开始.
mystr.rpartition(str) - splitlines
按照行分隔，返回一个包含各行作为元素的列表
mystr.splitlines() - isalpha
如果 mystr 所有字符都是字母 则返回 True,否则返回 False
mystr.isalpha() - isdigit
如果 mystr 只包含数字则返回 True 否则返回 False.
mystr.isdigit() - isalnum
如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False
mystr.isalnum() - isspace
如果 mystr 中只包含空格，则返回 True，否则返回 False.
mystr.isspace()
列表（list）
1，列表的定义
语法：list1=[1,2,3,“str”,“True”,“我的”]
列表可以包含不同数据类型的元素
2，访问列表元素print(list1[1]),结果为2（列表的索引是从0开始的）
下标不能超过索引的范围否则会产生错误，
下标值可以为负值，表示由列表的最后一个向前取值“-1”表示最后一个元素
2，列表的循环遍历
1，使用for循环
names_list = ['xiaoWang','xiaoZhang','xiaoHua']
for name in names_list:
print(name)
2，使用while循环
names_list = ['xiaoWang','xiaoZhang','xiaoHua']
length = len(names_list)
i = 0
while i<length:
print(names_list[i])
i+=1
列表的相关操作
1， 添加元素("增"append, extend, insert)
通过append可以向列表添加元素
通过extend可以将另一个集合中的元素逐一添加到列表中
nsert(index, object) 在指定位置index前插入元素object
li2 = ['asd', 'asddff', '23', 12, 3, 324, 54]
print(type(li2))
print(li2)
# 在列表的末尾添加元素
li2.append('sd')
print(li2)
# 在第三个位置的前面插入后面的元素，相当于插入第三位后面的向后移动
li2.insert(3, '1')
print(li2)
# 扩展列表
li2.extend(['asd', 'we', 'ds'])
print(li2)
# 将列表中的元素变成三倍
li2 = li2 * 3
print(li2)
2，修改元素
修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改
A = ['xiaoWang','xiaoZhang','xiaoHua']
#修改元素
A[1] = 'xiaoLu'
3，查找元素("查"in, not in, index, count)
in, not in
python中查找的常用方法为： * in（存在）,如果存在那么结果为true，否则为false * not in（不存在），如果不存在那么结果为true，否则false
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: 'a' is not in list
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0
4，删除元素("删"del, pop, remove)
列表元素的常用删除方法有： * del：根据下标进行删除 * pop：删除最后一个元素 * remove：根据元素的值进行删除
li2 = ['asd', 'asddff', '23', 12, 3, 324, 54]
# 根据索引查找移除找到的第一个元素
print(li2)
li2.remove(3)
print(li2)
# 默认弹出最后一个元素,可以根据下标索引弹出对应元素
li2.pop(0)
print(li2)
li2.pop()
li2.pop(3)
print(li2)
# 清空列表中的所有元素
li2.clear()
print(li2)
# 删除任何对象
li4 = [1, 2, 34, 45, 56, 67, 45, 5, 2, 5, 4]
del li4[0]
print(li4)
结果：
['asd', 'asddff', '23', 12, 3, 324, 54]
['asd', 'asddff', '23', 12, 324, 54]
['asddff', '23', 12, 324, 54]
['asddff', '23', 12]
[]
[2, 34, 45, 56, 67, 45, 5, 2, 5, 4]
5.排序(sort, reverse)
方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。
li4 = [1, 2, 34, 45, 56, 67, 45, 5, 2, 5, 4]
# 将列表中的元素反转一下split[::-1]也可以做到
li4.reverse()
print(li4)
# 将列表中的元素正序排列,从小到大
li4.sort()
print(li4)
# 将列表中的元素倒叙排列,从大到小
li4.sort(reverse=True)
print(li4)
列表推导式
作用：用一个表达式创建一个有规律的列表或控制一个有规律列表。
列表推导式又叫列表生成式。
li8 = [1, 2, 34, 45, 56, 67, 45, 5, 2, 5, 4]
# 遍历输出li8的数值中的偶数
li7 = [i for i in li8 if i%2==0]
print(li7)
# 遍历输出li8的所有值
li9 = [i for i in li8]
print(li9)
# 双层循环遍历输出
li10 = [i for i in li8 for j in li8 if i%2==0]
print(li10)
#统计一共复制了多少次
print(li10.count(4))
结果：
[2, 34, 56, 2, 4]
[1, 2, 34, 45, 56, 67, 45, 5, 2, 5, 4]
[2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]
11
元组（tuple）
1，使用场景？
思考：如果想要存储多个数据，但是这些数据是不能修改的数据，怎么做？
答：列表？列表可以一次性存储多个数据，但是列表中的数据允许更改。一个元组可以存储多个数据，元组内的数据是不能修改的。
2，定义元组
元组特点：定义元组使用小括号，且逗号隔开各个数据，数据可以是不同的数据类型。
# 注意：如果定义的元组只有一个数据，那么这个数据后面也好添加逗号，否则数据类型为唯一的这个数据的数据类型
t4 = (1,)
print(type(t4))
# 统计元组中1出现的次数
print(t4.count(1))
# 统计1再元组中的索引位置
print(t4.index(1))
3，元组的常见操作
元组转换为列表
list1 = list(tuple1)，将元组转换为列表
list1.append(1)，就可以在列表总添加元素了
列表转换为元组
index()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index方法相同。
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.index('aa')) # 0
count()：统计某个数据在当前元组出现的次数。
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.count('bb')) # 2
len()：统计元组中数据的个数。
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(len(tuple1)) # 4
注意：元组内的直接数据如果修改则立即报错
tuple1 = ('aa', 'bb', 'cc', 'bb')
tuple1[0] = 'aaa'
字典（dict）
1，定义字典
字典类似于我们通过联系人名字查找地址和联系人详细情况的地址簿
语法格式：
字典名称={键1：值1，键2：值2，……}
各元素之间使用，逗号隔开，键和值之间使用：冒号隔开
dict = {“张一”：123，“张二”：456，“张三”：789}
2，字典的基本使用
若访问不存在的键，则会报错：
# 定义方法：大括号抱起来的多个元素，元素之间用逗号分隔，每个元素是key-value键值对
# k-v之间用冒号分割
dict1 = {"name":"xiuer","age":18}
print(dict1)
print(dict1["name"])
print(dict1.keys())
print(dict1.values())
3，字典的常见操作
1，查看元素
info = {'name':'吴彦祖','age':18}
print(info['age']) # 获取年龄
# print(info['sex']) # 获取不存在的key，会发生异常
print(info.get('sex')) # 获取不存在的key，获取到空的内容，不会出现异常
2，修改元素
字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
new_id = input('请输入新的学号')
info['id'] = int(new_id)
print('修改之后的id为%d:'%info['id'])
3，添加元素
# print('id为:%d'%info['id'])#程序会终端运行，因为访问了不存在的键
newId = input('请输入新的学号')
info['id'] = newId
print('添加之后的id为:%d'%info['id'])
4，删除元素
对字典进行删除操作，有一下几种： * del * clear()
# key存在是修改，不存在就是添加
dict1["sex"]="男"
print(dict1)
# 删除字典中的key值
del dict1["num"]
print(dict1)
#删除指定元素，指定元素的key值删除
dict1.pop("name")
print(dict1)
# 清空字典内容
dict1.clear()
print(dict1)
5，pop(key[,default])
删除字典给定键key所对应的值，返回值为被删除的值。key值必须给出否则返回default值
6，popitem()
随机返回并删除字典中的一堆键和值（一般删除末尾对）
字典操作扩展内容
1. get()
语法
字典序列.get(key, 默认值)
注意：如果当前查找的key不存在则返回第二个参数(默认值)，如果省略第二个参数，则返回None。
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.get('name'))
>> Tom
print(dict1.get('id', 110))
>>> 110
print(dict1.get('id'))
>>> None
2. keys()
显示所有的key值
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.keys())
>>>dict_keys(['name', 'age', 'gender'])
3. values()
显示所有的value值
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.values())
>>>dict_values(['Tom', 20, '男'])
4. items()
显示所有的键值对(key-value形式)
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.items())
>>>dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])
集合(set)
集合是一个无序不重复元素的序列。我们可以使用大括号{}或者set（）函数创建集合，但需要注意的是：创建一个空集合必须使用set（）而不是大括号{}，因为大括号也能用来创建一个空字典
1,定义集合的语法格式：
集合名称={值1，值2，值3，……}
或者 set（值）
thisset=set(“张三”，“张思”，“张五”)
thisset.add(“王六”)
2，集合update方法。把要传入的元素拆分，作为个体传入集合中
语法：s.update(元素)
thisset.update({1,2,3,4})
等于直接在前面添加
3，移除元素
语法：s.remove(元素)
4，计算集合元素个数
语法：len（集合名）
5,清空集合
语法：s.clear()
6，判断元素是否在集合中存在
语法：元素 in 集合
7，集合的操作符号，数学符号
# 定义：用大括号包起来的多个元素，元素之间用逗号分割，元素可以是多种数据类型
s1 = {}
print(type(s1))
s1 = {1,2,3,5,5,6,6,3,4,5,7}
print(s1)
# 自动去重和无序列
s2 = {'dsf',2134,'234',34,'234','abc','z'}
print(s2)
# 布尔值True在这里相当于1，False相当于0会出现哪个不确定
s3 = {True,True,1,1,0,0,0,False,False,2,'xiuer'}
print(s3)
s4 = set(li2)
print(s4)
print(len(s4))
扫一扫
699
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
