python学习第八天

一、字符串的其常用操作与内置方法

1.1、find,rfind,index,rindex,count
x = "hello egon egon egon"
res=x.find("egon")
res=x.find("egon123") # -1代表没有找到

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

res=x.find("egon",0,3)#指定查找范围
print(res)

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

2.2、center,ljust,rjust,zfill
print(x.center(20,"*"))
print(x.ljust(20,"*"))
print(x.rjust(20,"*"))
print(x.zfill(20))
运行结果：
********egon********
egon****************
****************egon
0000000000000000egon

1.3、expandtabs
print("hello\tworld".expandtabs(1))
print("hello\tworld".expandtabs())
运行结果：
hello world
hello   world

1.4、captalize,swapcase,title
print("hello world".capitalize())
print("aBcDeF".swapcase())
print("hello world egon".title())
运行结果：
Hello world
AbCdEf
Hello World Egon

1.5、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())
运行结果：
True
True
False
False
2）unicode、中文数字、罗马数字
#print(num1.isnumeric())#报错
print(num2.isnumeric())
print(num3.isnumeric())
print(num4.isnumeric())
运行结果：
True
True
True
3）unicode
#print(num1.isdecimal())#报错
print(num2.isdecimal())
print(num3.isdecimal())
print(num4.isdecimal())
运行结果：
True
False
False

1.6、is其他
name='egon123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
运行结果:
True
False

name="aaainputbbbbb"
print(name.isidentifier())#字符串是否有关键字
运行结果：
True

name="abc123"
print(name.islower())
print(name.isupper())
运行结果：
True
False

name="     "
print(name.isspace())
运行结果：
True

name="My Name Is Egon"
print(name.istitle())
运行结果：
True

二、列表的常用操作与内置方法

2.1、用途：按照索引存放多个任意类型的值，索引反映的是位置/顺序

2.2、定义方式：在[]内用逗号分割开多个任意类型的元素
l=[111,1.1,"aaa",[2222,3333]]  # l=list([111,1.1,"aaa",[2222,3333]])
print(type(l))

数据类型转换:只要能被for循环的值读可以传给list，进行数据类型转换
res=list("hello")
print(res)
运行结果：
['h', 'e', 'l', 'l', 'o']

res=list({"k1":1,"k2":2,"k3":3})
print(res)
运行结果：
['k1', 'k2', 'k3']

2.3、常用操作+内置的方法
2.3.1 优先掌握的操作：
(1)、按索引存取值(正向存取+反向存取)：即可以取也可以改值,但不能加值
列表只能按照索引取或者改，不能新加值，而字典可以按照key为其新加值
l1 = [11,22,33,44,55]
print(l1[0])
print(l1[10])#报错
print(l1[-1])
print(id(l1))
l1[0] = 100
print(id(l1))

l1[5] = 11111 #报错，不能加值
字典可以加值
d = {'k1':2}
d['kkkk']=22222
print(d)

(2)、切片(顾头不顾尾，步长)
l1 = [11,22,[66,77]]
res=l1[2:4]
print(res)
print(l1)

(2.1)浅copy：
l1 = [11,22,[66,77]]
#l2=l1[:]
l2=l1.copy()

print(id(l1[0]),id(l1[1]),id(l1[2]))
print(id(l2[0]),id(l2[1]),id(l2[2]))
运行结果：
140730908002272 140730908002624 1635034884416
140730908002272 140730908002624 1635034884416

l1[0] = "aaa"
l1[1] = "bbb"
l1[2] = "ccc"
print(l1)
print(l2)
运行结果：
['aaa', 'bbb', 'ccc']
[11, 22, [66, 77]]

l1[0] = "aaa"
l1[1] = "bbb"
l1[2][0] = 8888
print(l1)
print(l2)
运行结果：
['aaa', 'bbb', [8888, 77]]
[11, 22, [8888, 77]]

(2.2)、深copy
from copy import deepcopy
l3=deepcopy(l1)
print(id(l1[0]),id(l1[1]),id(l1[2]))
print(id(l3[0]),id(l3[1]),id(l3[2]))
运行结果：
140730895812576 140730895812928 3222208800960
140730895812576 140730895812928 3222208801472

l1[2][0]=6666
print(l1)
print(l3)
运行结果：
[11, 22, [6666, 77]]
[11, 22, [66, 77]]

示范1：
l1[0]=1000
print(l1)
print(l2)
print(l3)
运行结果
[1000, 22, [66, 77]]
[11, 22, [66, 77]]
[11, 22, [66, 77]]
示范2：
l1[-1][0]=666
print(l1)
print(l2)
print(l3)
运行结果：
[11, 22, [666, 77]]
[11, 22, [666, 77]]
[11, 22, [66, 77]]
了解：
res=l1[-1:-4:-1]
res=l1[::-1]
print(res)


(3)、长度
l1 = [11,22,[66,77]]
print(len(l1))

(4)、成员运算in和not in
l1 = [111,22,[66,77]]
print([66,77] in l1)
print(66 in l1)
print(66 not in l1)

(5)、追加
l1=[11,222]
l1.append(33)#在末尾添加
l1.append(44)
l1.append([55,66])
print(l1)
运行结果：
[11, 222, 33, 44, [55, 66]]

l1.insert(1,"aaa")#可以指定位置添加
print(l1)
运行结果：
[11, 'aaa', 222]

(6)、删除
l1=[11,222,[1,2]]
(6.1) 万能删除，没有返回值，代表的是单纯的删除
del l1[0]
print(l1)
运行结果：
[222, [1, 2]]

(6.2) 指定元素删除,没有返回值，代表的是单纯的删除
res=l1.remove([1,2])
print(l1)
print(res)
运行结果：
[11, 222]
None

(6.3 )指定索引删除，有返回值，代表的是取走操作
res=l1.pop(1)
print(l1)
print(res)
运行结果：
[11, [1, 2]]
222

(7)、循环
l1=[11,222,[1,2]]
for x in l1:
    print(x)
运行结果：
11
222
[1, 2]

2.3.2、需要掌握的操作：
(1)clear()#清空
1=[11,22,333,333,333,]
l1.clear()#清空
print(l1)
运行结果：
[]
(2)count()
print(l1.count(333333333))#计数
print(l1.count(333))
运行结果：
0
3
(3)extend()添加
l1=[]
l2=[444,555]
for item in l2:
#     l1.append(item)
l1.extend(l2)
l1.extend("hello")
print(l1)
运行结果：
[444, 555, 'h', 'e', 'l', 'l', 'o']
(4)index()
l1=[11,22,333,333,333,]
res=l1.index(333,0,2)
res=l1.index(444)
print(res)
(5)reverse()
l1=[11,22,"aaa",'bbb']
l1.reverse()
#l1=l1[::-1]
print(l1)
运行结果：
['bbb', 'aaa', 22, 11]
(6)sort排序
l1 = [11, 22, "aaa", 'bbb']
l1 = [-3,99,12,-5,93]
l1.sort(reverse=True)
print(l1)
[99, 93, 12, -3, -5]
=============================该类型总结====================================
存多个值

有序

可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

三、元组的常用操作与内置方法

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


===================================基本使用======================================
3.1、用途: 按照索引存放多个任意类型的值，索引反应的是位置/顺序

3.2、定义方式：在()内用逗号分隔开多个任意类下的值/元素
t=(10)
print(type(t))

强调:当元组内只有一个元素时，必须加逗号
t=(10,)
print(type(t))

t=(10,1.1,"aaa",[11,22])
print(t[-1][0])
运行结果：
11

t[0]=11111#报错，元组不可变
t[-1]=333333

t=(11,22,[33,44])
print(id(t[0]),id(t[1]),id(t[2]))
运行结果：
140730895812576 140730895812928 2178367776896

t[2][0]=333333333
# print(t)
print(id(t[0]),id(t[1]),id(t[2]))
运行结果：
(11, 22, [333333333, 44])
140730895812576 140730895812928 2178367776896


t=(11,22)  # t=tuple(...)
print(type(t))
运行结果：
<class 'tuple'>

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

t=()
print(t)
print(type(t))

3.3、常用操作+内置的方法
3.3.1、优先掌握的操作：
(1)、按索引取值(正向取+反向取)：只能取
t=(10,1.1,"aaa",[11,22])
print(t[0])
运行结果：
10
(2)、切片(顾头不顾尾，步长)
t=(11,22,33,44,55)
print(t[0:3])
运行结果：
(11, 22, 33)
(3)、长度
t=(11,22,33,44,55)
print(len(t))
运行结果：
5
(4)、成员运算in和not in
t=(11,22,33,44,55)
print(11 in t)
运行结果：
True

5)、循环
t=(11,22,33,44,55)
for x in t:
    print(x)
运行结果：
11
22
33
44
55
3.3.2、需要掌握的操作：
t=(11,22,33,44,55)
res=t.index(22)
print(res)
运行结果：
===================================该类型总结====================================
存多个值

有序

不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

四、字典的常用操作 与内置方法

===================================基本使用======================================
4.1、用途：按key:value的形式存放多个任意类型的value，key反映的是value的属性

4.2、定义方式：在{}内用逗号分隔开多个key:value，其中value可以是任意类型,而key必须是不可变的类型，通常是字符串类型
d={'k1':111,'k1':222,'k1':3333}  # key重复，只保留一个
print(d)
d={1:"aaa",3.1:'bbbb',[1,2]:"ccc"}
d={1:"aaa",3.1:'bbbb',():"ccc"}  # d=dict(...)
print(type(d))
print(d[()])

类型转换
l=[("name","egon"),("age",18),["gender","male"]]
res=dict(l)
print(res)
运行结果：
{'name': 'egon', 'age': 18, 'gender': 'male'}

d=dict(x=1,y=2,z=3)
print(d)
运行结果：
{'x': 1, 'y': 2, 'z': 3}

空字典
d={}
print(type(d))
运行结果：
<class 'dict'>

dic={}.fromkeys(["name",'age',"gender"],None)
print(dic)
运行结果：
{'name': None, 'age': None, 'gender': None}

dic={}.fromkeys("hello",None)
print(dic)
运行结果：
{'h': None, 'e': None, 'l': None, 'o': None}

4.3、常用操作+内置的方法
4.3.1、优先掌握的操作：
(1)、按key存取值：可存可取
d={'k1':111}
print(d['k1'])
运行结果：
111
d['k2']=222
print(d)
运行结果：
{'k1': 111, 'k2': 222}

(2)、长度len
d={'k1':111,'k2':222}
print(len(d))
运行结果：
2

(3)、成员运算in和not in
d={'k1':111,'k2':222}
print('k1' in d)
print(111 in d)
运行结果：
True
False

(4)、删除
d={'k1':111,'k2':222}
(4.1) 万能删除，没有返回值，代表的是单纯的删除
del d['k1']
print(d)
运行结果：
{'k2': 222}
(4.2 )随机删,返回一个元组
res=d.popitem()
print(d)
print(res)

(4.3 )指定key删除，有返回值，代表的是取走操作
res=d.pop('k1')
print(d)
print(res)
运行结果：
{'k2': 222}

(5)、键keys()，值values()，键值对items()
"""
>>> d={'k1':111,'k2':222}
>>> d.keys()
['k2', 'k1']
>>> d.values()
[222, 111]
>>> d.items()
[('k2', 222), ('k1', 111)]
"""

(6)、循环
d={'k1':111,'k2':222}
for k in d:
    print(k)
运行结果：
k1
k2

for v in d.values():
    print(v)
运行结果：
111
222

for k,v in d.items():
    print(k,v)
运行结果：
k1 111
k2 222

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

keys=list(d.keys())
print(keys)
运行结果：
['k1', 'k2']
===================================该类型总结====================================
存多个值

无序

可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）