Python入门08——字符串类型补充、列表类型、元组类型、字典类型

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