字符串剩余,列表类型,元组类型,字典类型

一.字符串剩余

find:查找某个值在字符串中第一次出现的位置

x = "hello egon egon egon"
res=x.find("egon")
# res=x.find("egon123") # -1代表没有找到
print(res)

rfind:从右往左开始找某个值在字符串中第一次出现的位置

x = "hello egon egon egon"
res=x.rfind("egon")
print(res)

index:查找某个值在字符串中第一次出现的位置,找不到报错

x = "hello egon egon egon"
res = x.index("egon123") # 找不到则报错
print(res)

center,ljust,rjust,zfill

x = "egon"
res=x.center(50,'*')
print(res)

print(x.ljust(50,"*"))
print(x.rjust(50,"*"))
print(x.zfill(50))
print(x.rjust(50,"0"))

expandtabs:控制’\t’代表的空格数

print("hello\tworld".expandtabs(1))

captalize,swapcase,title

print("hello world egon".capitalize())
print("aBcDeF".swapcase())
print("hello world egon".title())

is其他

name='egon123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成

name="aaainputbbbbb"
print(name.isidentifier())

name="abc123"
print(name.islower())
print(name.isupper())

name="     "
print(name.isspace())

name="My Name Is Egon"
print(name.istitle())

is数字系列
在python3中

num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字

#1、 bytes、unicode
# print(num1.isdigit())
# print(num2.isdigit())
# print(num3.isdigit())
# print(num4.isdigit())


# 2、unicode、中文数字、罗马数字
# print(num2.isnumeric())
# print(num3.isnumeric())
# print(num4.isnumeric())

# 3、unicode
# print(num2.isdecimal())
# print(num3.isdecimal())
# print(num4.isdecimal())

总结:

存一个值
有序
不可变(可哈希)

二.列表类型

1.用途:

按照索引存放多个任意类型的值,索引反映的是位置/顺序

2.定义方式:

在[]内用逗号分隔开多个任意类型的元素

l = [111,1.1,'aaa',[222,333]] # l=list([111,1.1,'aaa',[222,333])
print(type(l))

数据类型转换

res = list('hello')
print(res)
res1 = list({'k1':1,'k2':2,'k3':3})
print(res1)  # ['k1', 'k2', 'k3']

3.常用操作+内置的方法

优先掌握的操作

按索引存取值(正向存取+反向存取):既可以取也可以改值,不能加值

l1=[11,22,33,44,55]
print(l1[0])
# print(l1[10])  # 报错,索引超出范围
print(l1[-1])
# 列表是可变类型,修改列表内的值id不变
print(id(l1))  # 2806146704640
l1[0] = 100
print(id(l1))  # 2806146704640

# l1[5] = 1111  # 报错,列表不能通过索引修改值

切片(顾头不顾尾,步长)

l1 = [11,22,[66,77]]
res = l1[0:2]
print(res)  # [11, 22]

浅copy

# 根据索引拷贝整个列表,相当于.copy()/浅拷贝操作
# 浅拷贝只是拷贝了内存地址
l1 = [11,22,[66,77]]
# l2 = l1[:]
l2 = l1.copy()
# l1 和 l2的id一致
print(id(l1[0]),id(l1[1]),id(l1[2]))
print(id(l2[0]),id(l2[1]),id(l2[2]))
# 此步骤改的是不可变类型,l1中的0号索引与值11解绑,改为绑定11111111
# l2中的0号索引内存地址是不变的,因此l2中的第一个值没有改
l1[0]=11111111
print(l1)  # [11111111, 22, [66, 77]]
print(l2)  # [11, 22, [66, 77]]
# 此步骤改的是二级列表,是可变类型,只是二级列表中的值改了,二级列表的内存地址是不变的
# 因此l2中的二级列表中的值也跟着l1改了
# l1[2][0]=88
# print(l1)  # [11, 22, [88, 77]]
# print(l2)  # [11, 22, [88, 77]]

深copy:

# 深拷贝是把二级列表拷贝之后重新开辟空间存入
from copy import deepcopy
l1 = [11,22,[44,55]]
l2 = deepcopy(l1)
print(id(l1[0]),id(l1[1]),id(l1[2]))
print(id(l2[0]),id(l2[1]),id(l2[2]))

# 因此修改l1二级列表中的值,l2二级列表中的值不会跟着改变

# 140704434407392 140704434407744 2586872489792
# 140704434407392 140704434407744 2586872490368
l1[2][0]=66666
print(l1)  # [11, 22, [66666, 55]]
print(l2)  # [11, 22, [44, 55]]

长度len()

l1=[11,22,[66,77]]
print(len(l1))

成员运算in 和 not in

l1 = [11,22,[66,77]]
print(11 in l1)
print(66 not in l1)

append():向列表的末尾添加值

l1 = [11,22]
l1.append(33)
print(l1)

insert():根据索引添加值

l1 = [11,22]
l1.insert(1,'aaa')
print(l1)

del:万能删除,没有返回值,代表的是单纯的删除

l1 = [11,22,[33,44]]
del l1[0]
print(l1)

remove():指定元素删除,没有返回值,代表的是单纯的删除

l1 = [11,22,[33,44]]
res=l1.remove([33,44])
print(l1)
print(res)

pop:指定索引删除,有返回值,代表的是取走值,不指定索引,默认删除最后一个

l1 = [11,22,[33,44]]
res = l1.pop(1)
print(l1)
print(res)

循环

l1 = [11,22,[33,44]]
for i in l1:
	print(i)

需要掌握的操作

clear():清空列表

l1 = [11,22,33]
l1.clear()
print(l1)

count(n):统计括号内参数n在序列内出现的次数

l1 = [11,22,33,33,33]
print(l1.count(33))
print(l1.count(333333))  # 没有此参数返回0

extend:迭代追加元素

l1 = [11,22]
l2 = [33,44]
l1.extend(l2)
print(l1)  # [11, 22, 33, 44]

index(n):查找参数n在序列中第一次出现的位置,找不到就报错

l1 = [11,22,333,333,333]
res = l1.index(333,0,3)
#res = l1.index(444)  # 报错
print(res)

reverse:反转列表

l1 = [11,22,'aaa','bbb']
l1.reverse()
# l1=l1[::-1]  # 此操作也可反转列表
print(l1)

sort:排序(默认从小到大)

l1 = [-3,99,12,-5,93]
l1.sort()
print(l1)
l1.sort(reverse=True)
print(l1)

总结:

存多个值
有序
可变类型(不可哈希):值变,id不变

三.元组类型

元组就是一个不可变的列表

1.用途:

按照索引存放多个任意类型的值,索引反映的是位置/顺序

2.定义方式:

在()内用逗号分隔开多个任意类型的值/元素

t = (10)
print(type(t))  # <class 'int'>
# 强调:当元组内只有一个元素时,必须加逗号
t = (10,)  # t = tuple((10,))
print(type(t))  # <class 'tuple'>

t = (10,1.1,'aaa',[11,22])
print(t[-1][0])

# 错误示范:元组内的值不可以修改
# t[0]=11111
# t[-1]=3333

类型转换
tup(所有可以被for循环遍历的类型)

# 定义空元组
t = ()
print(t)

3.常用操作+内置的方法

优先掌握的操作

按索引取值(正向取+反向取):只能取

t = (10,1,1,'aaa')
print(t[0])

切片(顾头不顾尾,步长)

t = (11,22,33,44,55)
print(t[0:3])

长度

t = (11,22,33,44,55)
print(len(t))

成员运算in 和 not in

t = (11,22,33,44,55)
print(11 in t)

循环

for x in t:
	print(x)

需要掌握的操作

count
index

总结:

存多个值
有序
不可变(可哈希类型):值变,id也变

四.字典类型

1.用途:

按key:values的形式存放多个任意类型的value,key反映的是value的属性

2.定义方式:

在{}内用逗号分隔开多个key:value,其中value可以是任意类型,而key必须是不可变带的类型,通常是字符串类型

# key重复,只保留一个
d = {'k1':111,'k1':222,'k1':333}
print(d)

类型转换

l = [('name','egon'),('age',18),['gender','male']]
res= dict(l)
print(res)

d = dict(x=1,y=2,z=3)
print(d)

空字典

d = {}
print(type(d))

dic={}.fromkeys(["name",'age',"gender"],None)
# dic={}.fromkeys("hello",None)
print(dic)

3.常用操作+内置的方法

优先掌握的操作

按key取值:可存可取

d={'k1':111}
print(d['k1'])
d['k2']=222
print(d)

长度

d={'k1':111,'k2':222}
print(len(d))

成员运算in 和 not in

d={'k1':111,'k2':222}
print('k1' in d)
print(111 in d)

del: 万能删除，没有返回值，代表的是单纯的删除

d={'k1':111,'k2':222}

del d['k1']
print(d)

popitem:随机删除,返回一个元组

d={'k1':111,'k2':222}
res=d.popitem()
print(d)
print(res)

pop:指定key删除，有返回值，代表的是取走操作

d={'k1':111,'k2':222}
res=d.pop('k1')
print(d)
print(res)

键keys()，值values()，键值对items()

>>> d={'k1':111,'k2':222}
>>> d.keys()
['k2', 'k1']
>>> d.values()
[222, 111]
>>> d.items()
[('k2', 222), ('k1', 111)]

循环

d={'k1':111,'k2':222}
for k in d:
    print(k)

for v in d.values():
    print(v)

for k,v in d.items():
    print(k,v)

keys=[]
for k in d:
    keys.append(k)

keys=list(d.keys())
print(keys)

总结:

存多个值
无序
可变(不可哈希)