我要评论Python入门08——字符串类型补充、列表类型、元组类型、字典类型
文章目录
列表类型
基本使用
1、用途
按照索引存放多个任意类型的值，索引反映的是位置/顺序
2、定义方式
在[]内用逗号分割开多个任意类型的元素
l=[111.1,'aaa',[222,333]]
print(type(l))
数据类型转换
res = list('hello')
print(res) # ['h', 'e', 'l', 'l', 'o']
res = list({'k1':'sa','k2':123})
print(res) # ['k1', 'k2']
3、常用操作+内置的方法
优先掌握的操作：
按索引存取值(正向存取+反向存取)
即可存也可以取可以改值
l1 = [11,22,33,44,55]
print(l1[0])
#print(l1[9]) # 报错
print(l1[-1])
print(id(l1))
l1[0]=00
print(l1)
print(id(l1))
d = {'k1': 2}
print(d['k1'])
d['kkkk'] = 2222
print(d) # {'k1': 2, 'kkkk': 2222}
d['k1'] = 1
print(d) # {'k1': 1, 'kkkk': 2222}
列表不能加值只能改值，字典可以加值改值
切片(顾头不顾尾，步长)
l1 = [11, 22, 33, 44, 55]
l2 = l1[2:4]
print(l2)
l2 = l1[:]
print(l2)
深浅copy
l1 = [11, 22, 33, 44, 55, [66, 77]]
2.1 浅拷贝copy 只拷贝第一层
l2 = l1[:]
l2 = l1.copy()
示范1
print(l2)
l1[0] = 10000
print(l1)
print(l2)
示范
l1[-1][0] = 000
print(l1)
print(l2)
l1 = [11, 22, [66, 77]]
l2 = l1.copy()
print(id(l1[0]),id(l1[1]),id(l1[2])) # 4379491280 4379491632 140259394917184
print(id(l1[0]),id(l1[1]),id(l1[2])) # 4379491280 4379491632 140259394917184
from copy import deepcopy
l3 = deepcopy(l1)
print(id(l3[0]),id(l3[1]),id(l3[2]))
l1[2][0] = 999
print(l1)
print(l2)
print(l3)
了解
res = l1[-1:-4:1]
print(res) # []
res = l1[-1:-4:-1]
print(res) # [55, 44, 33]
res = l1[::-1]
print(res) # [55, 44, 33, 22, 11]
长度(len)
print(len([1, 2, 3]))
成员运算in和not in
l1 = [111,22,[66,77]]
print([66,77] in l1)
# print(66 in 11)
print(66 not in l1)
追加
l1 = [11,222]
l1.append(33)
print(l1)
l1.append([44,555])
print(l1)
删除
l1 = [11, 222, [1, 2]]
6.1 万能删除del 没有返回值
del l1
print(l1) # 报错
6.2 指定元素删除,没有返回值
res = l1.remove([1, 2])
print(l1)
print(res) # None
6.3 指定索引删除，有返回值，代表的是取走操作
res = l1.pop(1) # 索引值
print(l1) # [11, [1, 2]]
print(res) # 222
循环
l1 = [11, 222, [1, 2]]
for x in l1:
print(x)
需要掌握的操作：(下面有更详细的)
l1 = [111,222,333]
l1.clear()
print(l1) # []
print(l1.count(44444))
l2=[444,555]
for item in l2:
l1.append(item)
l1.extend(l2)
print(l1)
l1 = [111,222,333,333,333]
res = l1.index(333)
print(res)
l1 = [111,222,'aaa','bbb']
l1.reverse()
l1=l1[::-1]
print(l1)
# l1 = [111,222,'aaa','bbb'] # 报错
l1 = [444,555,333,777,1]
l1.sort(reverse=True)
print(l1) # 从大到小排列
需要掌握操作
l = [1, 'aaa', 'bbb','aaa','aaa']
1、l.count()
print(l.count('aaa')) # 3
print(l.count('aaaaaaaaa')) # 找不到返回0
2、l.index()
print(l.index('aaa'))
print(l.index('aaaaaaaaa')) # 找不到报错
3、l.clear() # 清空
l.clear()
print(l)
4、l.reverse():不是排序，是将列表倒过来
l = [1, 'egon','alex','lxx']
l.reverse()
print(l) # ['lxx', 'alex', 'egon', 1]
5、l.sort(): 列表内元素必须是同种类型才可以排序
l=[11,-3,9,2,3.1]
l.sort() # 默认从小到大排，称之为升序
l.sort(reverse=True) # 从大到小排，设置为降序
print(l)
l=[11,'a',12]
l.sort()
l=['c','e','a']
l.sort()
print(l)
了解：
字符串可以比大小，按照对应的位置的字符依次pk
字符串的大小是按照ASCI码表的先后顺序加以区别，表中排在后面的字符大于前面的
print(‘a’>‘b’)
print(‘abz’>‘abcdefg’) # 先a跟a比，比不出换下一个直到比出为止
了解：
列表也可以比大小,原理同字符串一样,但是对应位置的元素必须是同种类型
l1=[1,‘abc’,‘zaa’]
l2=[1,‘abc’,‘zb’]
print(l1 < l2)
补充
1、队列：FIFO,先进先出
l=[]
入队操作
l.append('first')
l.append('second')
l.append('third')
print(l)
出队操作
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))
2、堆栈：LIFO,后进先出
l=[]
入栈操作
l.append(‘first’)
l.append(‘second’)
l.append(‘third’)
print(l)
出队操作
print(l.pop())
print(l.pop())
print(l.pop())
该类型总结
存一个值or存多个值
多个
有序or无序
有序
可变or不可变（1、可变：值变，id不变。可变== 不可hash
2、不可变：值变，id就变。不可变==可hash）
可变
元组类型
基本使用
1、用途
按照索引存放多个任意类型的值，索引反映的是位置/顺序
2、定义方式
在()内用逗号分隔开多个任意类下的值/元素
t=(10)
print(type(t)) # <class ‘int’>
强调：当元组内只有一个元素时，必须加逗号
t=(10,)
print(type(t)) # <class 'tuple'>
t = (10, 1.1, 'aaa', [11, 22])
print(t[-1][0])
t[0] = 11111 # 报错
t = (11, 22, [33, 44])
print(id(t[0]), id(t[1]), id(t[2]))
t[2][0] = 33333333
print(t)
print(id(t[0]), id(t[1]), id(t[2])) # 不可变类型
类型转换
3、常用操作+内置的方法
优先掌握的操作：
1、按索引取值(正向取+反向取)：只能取
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
5、循环
该类型总结
存一个值or存多个值
存多个值
有序or无序
有序
可变or不可变（1、可变：值变，id不变。可变== 不可hash
2、不可变：值变，id就变。不可变==可hash）
不可变类型
字典类型
基本使用
1、用途
按key:value的形式存放多个任意类型的value,key反映的是value的属性
2、定义方式
在{}内用逗号分隔开多个key:value, 其中value可以是任意类型
而key必须是不可变的类型，通常是字符串类型
d = {'k1':111,'k2':222,'k3':333,'k3':444} #key值重复只保留一个
print(d) # {'k1': 111, 'k2': 222, 'k3': 444}
d={1:'aaa',3.1:'bbb',[1,2]:'ccc'}
print(type(d))
类型转换
l=[('name','egon'),('age',18),['gender','male']]
res = dict(l)
print(res)
d = dict(x=1,y=2,z=3)
print(d)
空字典 {}默认是字典类
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}
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]
47d.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)
该类型总结
存一个值or存多个值
存一个值
有序or无序
无序
可变or不可变（1、可变：值变，id不变。可变== 不可hash 2、不可变：值变，id就变。不可变==可hash）
不可变类型
字符串类型补充
1、find,rfind,index,rindex,count
x = 'hello sa sas sa sa'
res=x.find('sa')
print(res)
res= x.find('sa123')
res=x.rfind('sa')
print(res)
res=x.find('sa',0,3)
print(res)
res = x.index('sa123') # 找不到则报错
print(res)
2、center,ljust,rjust,zfill
x = 'sa'
res=x.center(50,'*')
print(res)
print(x.ljust(50,'*'))
print(x.rjust(50,'*'))
print(x.zfill(50))
3、expandtabs
print('hello\tworld'.expandtabs(1))
4、captalize、sawpcase、title
print('hello world sa'.expandtabs())
print('')
5、is其他系列
6、is数字系列
在python3中
num1 = b’4’ # bytes
num2 = u’4’ # unicode,python3中无需加u就是unicode
num3 = ‘四’ # 中文数字
num4 = ‘Ⅳ’ # 罗马数字
isdigt:bytes,unicode
print(num1.isdigit()) # True
print(num2.isdigit()) # True
print(num3.isdigit()) # False
print(num4.isdigit()) # False
isdecimal:uncicode
bytes类型无isdecimal方法
print(num2.isdecimal()) # True
print(num3.isdecimal()) # False
print(num4.isdecimal()) # False
isnumberic:unicode,中文数字,罗马数字
bytes类型无isnumberic方法
print(num2.isnumeric()) # True
print(num3.isnumeric()) # True
print(num4.isnumeric()) # True
三者不能判断浮点数
num5 = '4.3'
print(num5.isdigit())
print(num5.isdecimal())
print(num5.isnumeric())
最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
该类型总结:
存一个值or存多个值
一个
有序or无序
有序
可变or不可变（1、可变：值变，id不变。可变== 不可hash 2、不可变：值变，id就变。不可变==可hash）
不可变
本文地址：https://blog.csdn.net/chongaiyatou/article/details/107320141
您可能感兴趣的文章:
如您对本文有疑问或者有任何想说的，请点击进行留言回复，万千网友为您解惑！
网友评论