老男孩学习day08

最新推荐文章于 2025-12-05 17:02:52 发布

原创最新推荐文章于 2025-12-05 17:02:52 发布 · 165 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#python

本周内容：

day01
    字符串剩余
    列表常用操作及内置方法
    元组常用操作及内置方法
    字典常用操作及内置方法

day02
    集合类型的常用操作及内置方法
    字符编码***
    文件处理基本处理

day03
    文件的打开模式
        rwa
        tb
        +
    文件操作的其他方法

day04
    文件的高级部分
        文件的指针移动
        文件的修改

    函数的基本使用


day5：
    函数的参数
    函数的返回值

1.字符串剩余

1、find,rfind,index,rindex,count

x = "hello egon egon egon"
res=x.find("egon")
res=x.find("egon123") # -1代表没有找到
print(res)
res=x.rfind("egon")
print(res)
res=x.find("egon",0,3)
print(res)
res = x.index("egon123") # 找不到则报错
print(res)

2、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"))

3、expandtabs

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

4、captalize,swapcase,title

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

5、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())

6、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())


======================================该类型总结====================================
存一个值

有序

不可变

x="hello"
x[0]="H"

2.列表类型

基本使用

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

2、定义方式：在[]内用逗号分割开多个任意类型的元素

l=[111,1.1,"aaa",[2222,3333]]  # l=list([111,1.1,"aaa",[2222,3333]])
print(type(l))

数据类型转换
res=list("hello")
res=list({"k1":1,"k2":2,"k3":3})
print(res)

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

3.1 优先掌握的操作：
1、按索引存取值(正向存取+反向存取)：即可以取可以改值,不能加值

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：

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]))
l1[0] = "aaa"
l1[1] = "bbb"
l1[2] = "ccc"
l1[2][0] = 8888
print(l2)
from copy import deepcopy
l3=deepcopy(l1)
print(id(l3[0]),id(l3[1]),id(l3[2]))
l1[2][0]=6666
print(l1)
print(l3)

示范1：

l1[0]=1000
print(l1)
print(l2)

示范2：

l1[-1][0]=666
print(l1)
print(l2)

了解：

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)

l1.insert(1,"aaa")
print(l1)

6、删除

l1=[11,222,[1,2]]

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

del l1[0]
print(l1)

6.2 指定元素删除,没有返回值，代表的是单纯的删除

res=l1.remove([1,2])
print(l1)
print(res)

6.3 指定索引删除，有返回值，代表的是取走操作

res=l1.pop(1)
print(l1)
print(res)

7、循环

l1=[11,222,[1,2]]
for x in l1:
    print(x)

===============3.2 需要掌握的操作：

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

print(l1.count(333333333))

l2=[444,555]
for item in l2:
l1.append(item)
l1.extend(l2)
l1.extend("hello")
print(l1)

l1=[11,22,333,333,333,]
res=l1.index(333,0,2)
res=l1.index(444)
print(res)

l1=[11,22,"aaa",'bbb']
l1.reverse()
l1=l1[::-1]
print(l1)

l1 = [11, 22, "aaa", 'bbb']
l1 = [-3,99,12,-5,93]
l1.sort(reverse=True)
print(l1)

3.什么是元组？

元组就是一个不可变的列表
基本使用
1、用途: 按照索引存放多个任意类型的值，索引反应的是位置/顺序

2、定义方式：在()内用逗号分隔开多个任意类下的值/元素

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

强调:当元组内只有一个元素时，必须加逗号

t=(10,)
print(type(t))

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

t[0]=11111
t[-1]=333333

t=(11,22,[33,44])
print(id(t[0]),id(t[1]),id(t[2]))

t[2][0]=333333333
print(t)
print(id(t[0]),id(t[1]),id(t[2]))

t=(11,22)  # t=tuple(...)
print(type(t))

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

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

3、常用操作+内置的方法
优先掌握的操作：
1、按索引取值(正向取+反向取)：只能取

t=(10,1.1,"aaa",[11,22])
print(t[0])

2、切片(顾头不顾尾，步长)

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

3、长度

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

4、成员运算in和not in

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

5、循环

for x in t:
    print(x)

需要掌握的操作：

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

存多个值
有序
不可变（1、可变：值变，id不变。可变不可hash 2、不可变：值变，id就变。不可变可hash）

======================================

3.字典类型

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

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)

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、常用操作+内置的方法
==========>优先掌握的操作：
1、按key存取值：可存可取

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

2、长度len

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

3、成员运算in和not in

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

4、删除

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

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

del d['k1']
print(d)

6.2 随机删,返回一个元组

res=d.popitem()
print(d)
print(res)

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

res=d.pop('k1')
print(d)
print(res)

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)

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)