基本数据类型及内置方法二

基本数据类型及内置方法

列表

用途：用于存一个或者多个不同类型的值

定义方法：通过中括号存值，每个值之间通过逗号进行分隔

使用方法：

优先掌握的知识点：

1、索引取值（正反都可以），不仅可以取还可以存

l1 = [1, 2, 3, 4,5]
print(l1[2])
l1[2] = 222
print(l1)

3
[1, 2, 222, 4, 5]

2、索引切片

l1 = [1, 2, 3, 4,5]
print(l1[1:4])

[2, 3, 4]

3：append():追加值，只能添加到列表的最后一位，一次性只能添加一个值

l1 = [1, 2, 3, 4, 5]
l1.append(10000)
print(l1)
l1.append([9, 0])
print(l1)

[1, 2, 3, 4, 5, 10000]
[1, 2, 3, 4, 5, 10000, [9, 0]]

4、insert（）：插入值，通过索引指定插入的位置

l1 = [1, 2, 3, 4, 5]
l1.insert(3,999)
print(l1)

[1, 2, 3, 999, 4, 5]

5、extend（）

l1 = [1, 2, 3, 4, 5]
l1.extend([6,7,8])
print(l1)

[1, 2, 3, 4, 5, 6, 7, 8]

6、remove：指定值删除，比较彻底

l1 = [1, 2, 3, 4, 5]
l1.remove(1)
print(l1)

[2, 3, 4, 5]

7、pop（）：不传值，默认从最后开始删，指定索引删值，pop是有返回值的

l1 = [1, 2, 3, 4, 5]

val = l1.pop(2)
print(l1)
print(val)

[1, 2, 4, 5]
3

列表的内置方法：

count:统计当前列表内指定元素的个数

l1 = ['sean', 'egon', 'tank', 'sean']
print(l1.count('sean'))

2

index：获取当前指定元素的索引值，还可以指定查找范围

l1 = ['sean', 'egon', 'tank', 'sean']
print(l1.index('sean',1,4))

3

sort：排序，在原列表上进行排序操作

l1 = ['sean', 'egon', 'tank', 'sean']
l2 = [2, 1, 4, 6, 8, 3, 5, 6]
l2.sort(reverse=True)
print(l2)
l1.sort()
print(l1)
l3 = sorted(l2,)  # python的内置函数，在排序时生成了一个新列表，原数据不变
print(l3)

[8, 6, 6, 5, 4, 3, 2, 1]
['egon', 'sean', 'sean', 'tank']
[1, 2, 3, 4, 5, 6, 6, 8]

clear()：清空列表数据

l3=[1, 2, 3, 4, 5, 6, 6, 8]
l3.clear()
print(l3)

[]

队列：先进先出

l1 = []
l1.append(1)
l1.append(2)
l1.append(3)
print(l1)
l1.pop(0)
print(l1)
l1.pop(0)
l1.pop(0)
print(l1)

[1, 2, 3]
[2, 3]
[]

堆栈：先进后出

l1 = []
l1.append(1)
l1.append(2)
l1.append(3)
print(l1)
l1.pop()
print(l1)
l1.pop()
print(l1)
l1.pop()
print(l1)


[1, 2, 3]
[1, 2]
[1]
[]

元组的基本方法

用途：存储多个不同类型的值（不能存可变类型）

定义方式：用过小括号存储数据，数据与数据之间通过逗号分隔，（值不能被改变）

​ #定义容器类型的时候，如果里面只有一个值，在值得后面加上一个逗号

​ #在元组中如果不加，就是字符串

t1 = ('a', 'b', 'c', 'a')  # t1 = tuple(('a','b'))
print(t1)
print(type(t1))

('a', 'b', 'c', 'a')
<class 'tuple'>

常用方法：

1、索引取值（正取，反取）

2、索引切片

3、成员运算in，not in

4、len()

t1 = ('a', 'b', 'c', 'a')
print(t1[0:2])
print(t1.count('a'))
print(t1.index('a',1))

('a', 'b')
2
3

类型总结：

有序or无序：有索引，有序

可变or不可变：不可变

存一个值or存多个值：存多个值

字典（dict）基本方法

用途：

定义方式：通过大括号来存储数据，通过key：value来定义键值对数据，每个键值对中间通过逗号分隔

key：一定是一个不可变类型

value：可以是任意类型

d1 = {(1,2):[1,2]}

字典的三种定义方式：

1、

d1 = {'name':'egon', 'age':84}

2、

d2 = dict({'name':'egon'})

3、

zip:

l1 = ['name', "age"]
l2 = ['egon',18]
z1 = zip(l1,l2)
print(dict(z1))

{'name': 'egon', 'age': 18}

常用方法：

1、优先掌握的

​ 1:按照key：value映射关系取值（可存可取）

​ 2：成员运算in，not in #默认判断key

​ 3：len() #获取当前字典中键值对的个数

d1 = {'name': 'egon', 'age': 73}
print(d1['name'])
print(d1['age'])
d1['name'] = 'tank'
d1['gender'] = 'male'
print(d1)
print('egon' in d1)

egon
73
{'name': 'tank', 'age': 73, 'gender': 'male'}
False

内置方法

get：获取直指定key的值，如果值不存在，默认返回None，可以通过第二个参数修改默认返回的内容

d1 = {'name': 'egon', 'age': 73}
print(d1.get('gender'))
print(d1.get('gender','male'))

None
male

key、values、keys

d1 = {'name': 'egon', 'age': 73}
print(d1.keys())  # 返回所有的key
print(d1.values())  # 返回所有的值
print(d1.items())  # 返回所有的键值对，返回值是列表套元组，每一个键值对都是存在元组

dict_keys(['name', 'age'])
dict_values(['egon', 73])
dict_items([('name', 'egon'), ('age', 73)])

d1 = {'name': 'egon', 'age': 73}
for key in d1.keys():
    print(key)
for value in d1.values():
    print(value)
for key,value in d1.items():
    print(key,value)
key,value = ("name",'age')

name
age
egon
73
name egon
age 73

pop：删除：指定key进行删除，有返回值，返回为对应的value

d1 = {'name': 'egon', 'age': 73}
a = d1.pop('name')
print(d1)
print(a)

{'age': 73}
egon

popitem()：随机弹出一个键值对，有返回值，返回只是一个元组

d1 = {'name':'egon', 'age': 73,'gender':'male','a':"1"}
d1.popitem()
print(d1)

{'name': 'egon', 'age': 73, 'gender': 'male'}

update：用新字典替换旧字典

d1 = {'name':'egon', 'age': 73,'gender':'male','a':"1"}
d1.update({"b":'2'})
print(d1)
d1.update({'name':'tank'})
print(d1)

{'name': 'egon', 'age': 73, 'gender': 'male', 'a': '1', 'b': '2'}
{'name': 'tank', 'age': 73, 'gender': 'male', 'a': '1', 'b': '2'}

fromkeys:生成一个新字典，第一个参数（列表），它会以第一个参数中各个元素为key，以第二个参数为值，组成一个新字典

print(dict.fromkeys([1,2,3],['ke','k1']))

{1: ['ke', 'k1'], 2: ['ke', 'k1'], 3: ['ke', 'k1']}

setdefault：key不存在新增键值对，有返回值，返回新增value，key存在返回对应的value

d1 = {'name':'egon', 'age': 73,'gender':'male','a':"1"}
print(d1.setdefault('name',1))
print(d1)

egon
{'name': 'egon', 'age': 73, 'gender': 'male', 'a': '1'}

字典类型总结：

有序or无序：无序

可变or不可变：可变类型

存一个值or存多个值：存多个值

集合基本方法

用途：去重，关系运算

定义方式：通过大括号存储数据，每个元素通过逗号分隔

定义空集合：必须使用set()来定义

l1 = []

s1 = ""

d1 = {}

ss1 = set()

合集：|

交集：&

差集：-

对称差集：^

1、集合中不可能出现两个相同的元素

python_student = {'egon', 'jason', 'tank', 'owen', 'egon'}
linux_student = {'frank', 'alex', 'egon'}
go_student = {'egon'}
print(python_student)

{'owen', 'tank', 'egon', 'jason'}

python_student = {'egon', 'jason', 'tank', 'owen', 'egon'}
linux_student = {'frank', 'alex', 'egon'}
go_student = {'egon'}
print(python_student | linux_student)
print(python_student & linux_student)
print(python_student - linux_student)
print(linux_student - python_student)
print(python_student ^ linux_student)
print(python_student > go_student)
print(python_student < linux_student)
{'frank', 'tank', 'owen', 'alex', 'jason', 'egon'}
{'egon'}
{'jason', 'tank', 'owen'}
{'alex', 'frank'}
{'tank', 'owen', 'alex', 'frank', 'jason'}
True
False

l1 = [1, 2, 3, 1, 2, 9, 1, 5, 6, 7]
print(l1)

s1 = set(l1)
print(s1)
print(type(s1))
l2 = list(s1)
print(l2)
print(type(l2))

[1, 2, 3, 1, 2, 9, 1, 5, 6, 7]
{1, 2, 3, 5, 6, 7, 9}
<class 'set'>
[1, 2, 3, 5, 6, 7, 9]
<class 'list'>

python_student = {'egon', 'jason', 'tank', 'owen', 'egon'}
for i in python_student:
    print(i)
    
egon
owen
tank
jason

集合的类型总结

有序or无序：无序

可变or不可变：不可变

存一个值or存多个值：存多个值

基本数据类型总结

存一个:整型、浮点型、字符串

存多个值：列表、元组、字典、集合

可变or不可变： 可变：；列表，字典 不可变：整型、浮点型、字符串、元组、集合

有序or无序： 有序：字符串、列表、元组

无序：字典、集合

占用空间： 字典 列表 元组 集合 字符串 数字类型