1、以下方式都可以进行赋值
a='hello ' \
'world' *hello world*
b=""
c=''''''
d="""hello
world""" # *hello
world*
输出：
name='Rose'
print('我的名字是%s' % name)
2、下标（索引） 通过下标快速找到对应的数据
s='abcdefg'
print(s[0]) *a*
3、切片（字符串、列表、元组都支持）
序列[开始下标位置:结束下标位置:步长] #左闭右开，包括开始不包括结束 选取方向要一致
s='abcdef'
s[2:5:1] s[2:5] *cde* #默认步长为1
s[2:5:2] *ce*
s[:5] *abcde* #默认从0开始
s[2:] *cdef* #默认选取到最后
s[:] *abcdefg* #全部输出
s[::-1] *gfedcba* # 如果步长为负数，表示倒叙选取
s[-4:-1] *cde* #下表-1表示最后一个数据，依次向前类推
s[-4:-1:-1]
s[-4:-1:1] #不能选取出数据，从-4开始到-1结束，选取方向为从左到右，但是步长-1表示从右往左选取
4、常用操作方法：查找、修改、判断
查找 ：查找子串在字符串中的位置或出现次数
str="hello world and Python and Study"
str.find(子串，开始下标位置，结束下标位置)
str.find('and') #返回第一次找到'and'的开始下标位置，没找到返回-1
str.rfind():功能和find()相同，但查找方向为右侧开始，返回的下标从左开始数
str.index('') #和find类似，但是没找到会直接报错
str.rindex():功能和index()相同，但查找方向为右侧开始，返回的下标从左开始数，也会报错
str.count(字串，开始下标位置，结束下标位置)
str.count('and') #返回子串出现的次数,没出现返回0
修改 ：通过函数的形式修改字符串中的数据
str="hello world and Python and Study"
# 替换
new_str = str.replace(旧子串,新子串,替换次数)
# 替换次数如果不写，默认全部替换 若替换次数大于总出现次数，不会报错，直接全部替换
# 原来的字符串没有改变，修改后的数据是replace的返回值 说明字符串是不可变数据类型
new_str = str.replace('and','he')
# 分割 返回一个列表
str.split(分割字符,num) #num表示分割字符出现的次数，即将来返回数据个数为num+1
list = str.split('and') # 会丢失分割字符
# 合并 合并列表里的字符串数据为一个大字符串
new_str = 子串.join(list)
list=["aa","bb","cc"]
new_str = '...'.join(list)
print(new_str) *aa...bb...cc* #list列表没变
# 大小写转换 原本字符串不变，返回新字符串
# capitalize()：将字符串第一个字符换成大写，其他字符全都小写
new_str = str.capitalize()
# title()：将字符串每个单词首字母转换成大写
new_str = str.title()
# lower()：将字符串中大写转成小写（全部单词）
new_str = str.lower()
# upper()：将字符串中小写转成大写（全部单词）
new_str = str.upper()
# 删除空字符串
#lstrip()：删除字符串左侧空白字符
new_str = str.lstrip()
#rstrip()：删除字符串右侧空白字符
#strip()：删除字符串两侧空白字符
#字符串对齐 如果设置的长度小于原字符长度，则直接输出原字符
#ljust()：返回一个原字符串左对齐，并使用指定字符（默认空格）填充对应长度的新字符串
new_str = str.ljust(长度,填充字符)
#rjust()：返回一个原字符串右对齐，并使用指定字符（默认空格）填充对应长度的新字符串
new_str = str.rjust(长度,填充字符)
#center()：返回一个原字符串居中对齐
str='hello'
print(str.ljust(10,'.')) *hello.....*
判断： 返回结果是布尔类型 可以不指定范围
startswith():检查字符串是否以某个指定子串开头
str.startswith(子串,开始下标位置,结束下标位置)
endswith():检查字符串是否以某个指定子串结尾
str.endswith(子串,开始下标位置,结束下标位置)
str='hello'
print(str.startswith('hel')) *True*
print(str.startswith('hels')) *False*
isalpha():如果字符串中至少有一个字符并且所有的字符都是字母，则返回True
str.isaplpha()
isdigit():如果字符串只包含数字，则返回True
isalnum():如果字符串至少有一个字符并且所有字符都是字母或者数字，则返回
isspace():如果字符串中只包含空白（空格），则返回True
1、查找函数
list=['Tom','Lily','Rose']
list.index(查找的数据,开始下标位置,结束下标位置) #开始与结束可以不写，默认整个列表，返回数据的下标
list.index('Tom') *0*
list.index('TOM') #如果没有这个数据，会报错
list.count('') #统计指定数据在列表中出现的次数
len(list): 公共方法 列表的长度
2、判断数据是否存在（in与not in属于公共操作，字典、元组、字符串都可以运用）
in : 判断指定元素不在列表中，返回布尔类型
'Tom' in list *True*
not in : 判断指定元素不在列表中，不在返回True，否则返回False
3、增加(列表是可变数据类型)
list.append(数据)：在列表结尾追加数据 如果append追加的数据是一个序列，则追加整个序列到列表 没有返回值
list.append([11,22]) *['Tom','Lily','Rose',[11,22]]*
list.extend(数据)：在列表结尾追加数据 如果extend追加的数据是一个序列，则将这个序列的数据逐一添加到列表
list.extend([11,22]) *['Tom','Lily','Rose',11,22]*
list.insert(位置下标,数据)：指定位置新增数据
4、删除
del 目标 或者 del(目标)
del(list[1]) #删除指定下标的元素
del list #将整个列表删除，列表不存在了，系统找不到这个列表了
pop()：删除指定下标的元素，如果不指定下标，默认删除最后一个
会返回被删除的数据
delete_element = list.pop(1)
remove(数据)：移除列表中某个数据的第一个匹配项
list.remove('Rose')
#如果删除的元素在列表中不存在，会报错，说不在列表中，整个程序会异常退出
#可以在删除之前判断一下要删除的元素是否在列表中
if 'Tom' in list : #判断88在不在list中
stu.remove('Tom')
else:
print("Tom不在列表中")
#如果要删除的元素在列表中有多个，而且要全部删除,可以用while循环
list=[1,4,2,3,5,2,3,4,3] #删除3
list.remove(3) #只删除第一个3
print(list)
while 3 in list: #判断3在不在list中 in关键字
list.remove(3)
print(list)
clear()：清空列表，但列表还存在，只是为空列表
5、修改
list[下标] = '数据' #修改指定下标的数据
reverse()：逆置排序
list.reverse()
sort(key=None,reverse=Flase)：排序,默认升序排序
reverse为True 降序，reverse为False 升序
key：列表里有字典，按字典某个key的值进行排序的时候用到
list.sort() list.sort(reverse=Flase)
6、复制
copy()：
new_list = list.copy()
为什么要复制列表数据？
数据来源不容易，非常重要，在修改删除的时候会复制一份再进行操作
等号复制的是地址值
tuple 元组中的元素一旦初始化了就不能被修改了,数据可以是不同类型
#元组中的元素不可以增加和删除 append insert pop remove
#如果元组里面有列表，修改列表里的数据则是支持的
tuple=(1,2,3,4) #多个数据元组
tuple=(1,) #单个数据元组，不加,会变成int型变量
index()：查找某个数据，如果数据存在返回对应的下标值，否则报错
print(tuple.index(''))
count()：统计某个数据在元组中出现的次数
print(tuple.count(''))
len()：统计元组中数据的个数
len(tuple)
# 使用下表法访问元组
for x in range(len(t)):
print(t[x])
# 什么时候使用元组？ 我们的数据不希望被别人修改
dict 数据存储以键值对的方式进行存储 键：值 （key:value）
# 字典数据与数据顺序没有关系，即字典不支持下标，数据顺序变化前后能使用同一的标准查找数据
创建空字典：
dict_1={}
dict_1 = dict() #使用函数创建
dict ={'key1':10,'key2':100}
获取某个键对应的值
print(dict['key1'])
print(dict['key3']) 会报错
print(dict.get('key2'))
print(dict.get('key3'))# 会显示None,不会报错
查找：
dict.get(key,默认值)：如果当前查找的key不存在则返回第二参数（默认值），如果省略第二个参数，则返回None
dict.keys()：查找字典中所有的key，返回一个可迭代对象（即可以遍历的对象）
print(dict.keys()) *dict_keys(['key1','key2'])*
dict.values()：查找字典中所有的value，返回一个可迭代对象（即可以遍历的对象）
print(dict.values()) *dict_values([10,20])*
dict.items()：：查找字典中所有的键值对，返回一个可迭代对象，里面数据是元组，元组数据1是字典的key，元组数据2是key对应的值
print(dict.items()) *dict_items([('key1',10),('key2',100)])*
添加：
dict['key3']=20
print(dict) *{'key1': 10, 'key2': 100, 'key3': 20}*
dict['key3']=200
print(dict) *{'key1': 10, 'key2': 100, 'key3': 200}*
# 如果键不存在，则是添加键值对，如果键存在，则是修改
删除：
del(dict)：删除字典，字典不存在了，之后调用会报错
del dict['key1'] 删除指定键值对，如果键值对不存在，会报错
clear()：清空字典
拆包：
for key，value in dict.items:
print(f'{key}={value}')
字典中的键所对应的值的可以为任意数据类型
# 找到b1
d = {'key1':"lisi",
'key2':[1,2,3],
'key3':{
'a1':10,
'a2':[10, 20],
'a3':{
'b1':100
}
}
}
print(d.get('key3').get('a3').get('b1'))
print(d['key3']['a3']['b1'])
集合里面没有重复的数据(去重功能)；数据没有顺序，不支持下标操作
# 创建集合使用{}或者set(),如果创建空集合，只能使用set()
set = {10,20,30,40}
print(set) *{40, 10, 20, 30}*
set = {10,20,30,40,30,20,10}
print(set) *{40, 10, 20, 30}*
set = set('abcdefg')
print(set) *{'a', 'f', 'b', 'd', 'c', 'e', 'g'}*
#添加：
set = {10,20,30,40}
add()：增加单一元素
set.add(100) *{100, 40, 10, 20, 30}* #添加的位置不确定
set.add(20) *{40, 10, 20, 30}*
set.add([10,20]) 会报错，不能添加序列
update()：增加序列
set.update([10,50,70,90]) *{70, 40, 10, 50, 20, 90, 30}*
set.update(100) 会报错，不能添加单一数据
#删除：
remove()：删除集合中指定的数据，如果数据不存在则报错
discard()：删除集合中指定的数据，数据不存在也不会报错
pop(): 随机删除集合中的某个数据，并返回这个数据
#查找：
in：
not in：
1、运算符
+ 合并 字符串、列表、元组
* 复制 字符串、列表、元组
in 元素是否存在 字符串、列表、元组、字典
not in 元素是否不存在 字符串、列表、元组、字典
2、公共方法
len() 计算容器中元素的个数
del或del() 删除
max() 返回容器中元素最大值
min() 返回容器中元素最小值
range(start,end,step) 生成从start到end的数字，步长为step，供for循环使用
enumerate() 函数用于将一个可遍历的数据对象（列表、等）组合为一个索引序列，同时列出数据和数据下标，一般用在for循环当中
enumerate(可遍历对象,start=0) #start参数用来设置遍历数据的下标的起始值，默认为0
返回对象是元组，元组第一个数据是下标，第二个数据是值
list=['a','b','c']
for i in range(list):
print(i)
*
(0,a)
(1,b)
(2,c)
*
3、容器类型转换 元组、列表、集合
tuple()：
list()：
set()：
列表、字典、集合
1、列表推导式：用一个表达式创建一个有规律的列表或控制一个有规律的列表
list=[i for i in range(10)] #读写从for循环开始，for左侧填写返回值
#创建0~10之间的偶数列表(带if)
list = [i for i in range (10) if i % 2 == 0]
#多for循环列表推导式
list = [(i,j) for i in range(1,3) for j in range(3)]
2、字典推导式：快速合并列表为字典或提取字典中目标数据
# 创建字典：key为1~5，value为key的平方
dict = {i:i**2 for i in range(1,5)}
# 合并两个列表为字典
list1 = [1,2,3]
list2 = [1,4,9]
dict = {list1[i]:list2[i] for i in range(len(list1))}
如果两个list长度不一样，len()统计多的数据列表个数会报错，按数据少的不会报错
# 提取字典中的目标数据
dict = {1:1,2:4,3:9,4:16,5:25}
dict1={key:value for key,value in dict.items if value > 20} #提取值大于20的字典数据
3、集合推导式
list = [1,1,2]
set = {i**2 for i in list} *{1,4}* 集合去重功能
此笔记为在B站观看传智博学谷教学视频所记
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
