python08-数据类型-列表-字符串-字典-内置方法

今日学习

  1. 列表内置方法
  2. 字典内置方法
  3. 元组内置方法
  4. 集合内置方法
  5. 可变类型与不可变类型

列表的内置方法

列表的内置方法不会产生新的值，而是修改.

增删改查占据程序90%以上的核心操作

方法名称 用法
append() 该方法用于再列表末尾添加新的对象，无返回值，直接修改原列表
insert() 用于将指定对象插入指定位置，无返回值，直接插入原列表
extend() z在列表末尾追加一个序列中的值，必须是支持for循环的数据类型
del 通用方法，删除操作,通过列表索引删除即可
remove() 移除操作，指定数据，进行删除，遇见重复数据，只删除第一个
pop() 删除指定索引位置并返回索引位置的元素，如果不确定，括号内不填写，默认删除最后一个
clear() 清空整个列表
count() 统计某个数值出现的次数
sort() 排序 默认升序
index() 查看列表元素中的索引位置

  • append

    l1 = ['jason', 'kevin', 'oscar', 'tony', 'jerry']
res = l1.append('owen')              
print(res,l1) 
None  ['jason', 'kevin', 'oscar', 'tony', 'jerry', 'owen']

  • insert

    l1.insert(0, '插队')
print(l1)
['插队', 'jason', 'kevin', 'oscar', 'tony', 'jerry']

----------------#扩展列表----------------------------------
new_l1 = [11, 22, 33, 44, 55]
new_l2 = [1, 2, 3]  # [1, 2, 3, 11, 22, 33, 44, 55]
#第一种方法
for i in new_l1:
    new_l2.append(i)
print(new_l2)
#第二种
print(new_l2+new_l1)

#第三种
new_l1.extend(new_l2)  # 括号里面必须是支持for循环的数据类型   for循环+append()
print(new_l1)
-----------------结果--------------------
[1, 2, 3, 11, 22, 33, 44, 55]

  • del

    new_l1 = [11, 11, 22, 33, 44, 55]
new_l2 = [1, 2, 3]  # [1, 2, 3, 11, 22, 33, 44, 55]
###删除操作del
del new_l1[0]
print(new_l1)
-------结果-----------
[11, 22, 33, 44, 55]

  • remove

    new_l1 = [11, 11, 22, 33, 44, 55]

new_l1.remove(11)      #移除11，当遇见重复数据时只移除第一个
print(new_l1)
-------------结果-------------
[11, 22, 33, 44, 55]

  • pop

    new_l1 = [11, 11, 22, 33, 44, 55]
rep = new_l1.pop(0)
print(rep,new_l1)
[11, 22, 33, 44, 55]

  • clear

    new_l1 = [11, 11, 22, 33, 44, 55]
new_l1.clear()
print(new_l1)
----------结果-----------
[]

  • count

    new_l1 = [11, 11, 22, 33, 44, 55]
# count 统计数据
print(new_l1.count(11))
----------结果---------------
2

  • sort

    new_l2 = [2, 1, 3, 6, 5]
new_l2.sort()          #升序
new_l2.sort(reverse=True) #降序
print(new_l2)      
----------结果---------------
[6, 5, 3, 2, 1]

  • index

    new_l2 = [2, 1, 3, 6, 5]
print(new_l2.index(2))
-----执行结果------------
0

可变与不可变类型

为什么字符串调用内置方法是产生新的值 列表调用内置方法是改变自身

new_l2 = [2, 1, 3, 6, 5]
print(id(new_l2))
new_l2.append(10)
print(id(new_l2), new_l2)
--------------执行结果------------------
2282054340160                #值改变，内存地址可以不变
2282054340160 [2, 1, 3, 6, 5, 10]

--------------------- ---
2.不可变类型		str  int  float
	值改变(内置方法) 内存地址肯定变
    	  s1 = '$hello$'
        print(id(s1))
        s1 = s1.strip('$')
        print(id(s1))
      	
        ccc = 666
        print(id(ccc))
        ccc = 990
        print(id(ccc))
----------执行结果-----------------
1362889995824
1362896842224
1362895411856
1362895411632

元组内置方法tuple

tuple与list列表类似，同样可以保存多个任意类型的元素，但是与list的不同之处，tuple的元素不能修改，元组相当于不可改变的列表，用于记录多个固定不允许修改的值，单纯取数据

  • 类型转换

    支持for循环的数据类型都可以转给元组

    t1 = ()  # tuple
print(type(t1))
t2 = (1)  # int
print(type(t2))
t3 = (11.11)  # float
print(type(t3))
t4 = ('jason')  # str
print(type(t4))

    #int
t1 = (1)  # tuple
print(type(t1))
--------------------结果-------------
<class 'int'>

#元组
t1 = (1,)  # tuple
print(type(t1))
----------------结果------------------
<class 'int'>
                         
总结：
当元组内只有一个数据值的时候 逗号不能省略
如果省略了 那么括号里面是什么数据类型就是什么数据类型
建议:编写元组 逗号加上 哪怕只有一个数据
    (111, )  ('jason', )
ps:以后遇到可以存储多个数据值的数据类型 如果里面只有一个数据 逗号也趁机加上

    只可以查询

    # t1 = (11, 22, 33, 44, 55, 66)
# 1.索引相关操作
# 2.统计元组内数据值的个数
# print(len(t1))
# 3.查与改
# print(t1[0])  # 可以查
# t1[0] = 222  # 不可以改
"""元组的索引不能改变绑定的地址"""
# t1 = (11, 22, 33, [11, 22])
# t1[-1].append(33)
# print(t1)  # (11, 22, 33, [11, 22, 33])

字典内置方法dict

  # 类型转换(了解即可)
  # print(dict([('name', 'jason'), ('pwd', 123)]))
  # print(dict(name='jason', pwd=123))
  '''字典很少涉及到类型转换 都是直接定义使用'''
  
  info = {
      'username': 'jason',
      'pwd': 123,
      'hobby': ['read', 'run']
  }
  """
  K是对V的描述性性质的信息一般是字符串    K其实只要是不可变类型都可以
  """
  # 1.字典内k:v键值对是无序的
  # 2.取值操作
  # print(info['username'])  # 不推荐使用 键不存在会直接报错
  # print(info['xxx'])  # 不推荐使用 键不存在会直接报错，用get取值
  #############################################################
  --------------------------正确取值---------------------------------------------
  # print(info.get('username'))  # jason
  # print(info.get('xxx'))  # None
  # print(info.get('username', '键不存在返回的值 默认返回None'))  # jason
  # print(info.get('xxx', '键不存在返回的值 默认返回None'))  # 元素不存在，做自定义 键不存在返回的值 默认返回None
  # print(info.get('xxx', 123))  # 123
  # print(info.get('xxx'))  # None
  
  ---------------------- 3.统计字典中键值对的个数-----------------------------
  # print(len(info))
  # 4.修改数据
  # info['username'] = 'jasonNB'          键存在则是修改
  # print(info)
  
  ---结果----
  {'username': 'jasonNB', 'pwd': 123, 'hobby': ['read', 'run']}
  
  ------------------------新增数据------------------------------------------
  # 5.新增数据
  info['salary'] = 6                    键不存在则是新增
  info['class'] = 3
  print(info)  # {'username': 'jason', 'pwd': 123, 'hobby': ['read', 'run'], 'salary': 6}
  ---------结果--------------
  {'username': 'jason', 'pwd': 123, 'hobby': ['read', 'run'], 'salary': 6, 'class': 3}
  
  ----------------------删除数据-----------------------------------------------
  # 方式1
  # del info['username']
  # print(info)
  --------结果--------------
  {'pwd': 123, 'hobby': ['read', 'run']}
  
  # 方式2
  res = info.pop('username')
  print(info, res)
  --------结果--------------
  {'pwd': 123, 'hobby': ['read', 'run']} jason
  
  # 方式3
  info.popitem()  # 随机删除
  print(info)
  --------结果--------------
  {'username': 'jason', 'pwd': 123}
  
  # 7.快速获取键 值 键值对数据
  print(info.keys())  # 获取字典所有的k值 结果当成是列表即可
  --------结果------------------------
  dict_keys(['username', 'pwd', 'hobby'])
  
  print(info.values())  # 获取字典所有的v值 结果当成是列表即可
  --------结果------------------------
  dict_values(['jason', 123, ['read', 'run']])
  
  print(info.items())  # 获取字典kv键值对数据 组织成列表套元组
  --------结果------------------------
  dict_items([('username', 'jason'), ('pwd', 123), ('hobby', ['read', 'run'])])
  
  
  -------------------# 8.修改字典数据   键存在则是修改  键不存在则是新增---------------------
  info.update({'username':'jason123'})
  print(info)
  info.update({'xxx':'jason123'})
  print(info)
  
  -----------------# 9.快速构造字典  给的值默认情况下所有的键都用一个值----------------------
  res = dict.fromkeys([1, 2, 3], None)
  print(res)
  --------结果------------------------
  {1: None, 2: None, 3: None}
  
  例子2：
  new_dict = dict.fromkeys(['name', 'pwd', 'hobby'], [])  # {'name': [], 'pwd': [], 'hobby': []}
  #ew_dict['name'] = [] 
  new_dict['name'].append(123)
  new_dict['pwd'].append(123)
  new_dict['hobby'].append('read')
  print(new_dict)
  ------------结果----------------------------
  {'name': ['jason', 123, 'read'], 'pwd': ['jason', 123, 'read'], 'hobby': ['jason', 123, 'read']}
  
  
  # res = dict.fromkeys([1, 2, 3], 234234234234234234234)
  # print(id(res[1]))
  # print(id(res[2]))
  # print(id(res[3]))
  # 10.键存在则获取键对应的值 键不存在则设置 并返回设置的新值
  res = info.setdefault('username', 'jasonNB')
  print(res, info)
  res1 = info.setdefault('xxx', 'jasonNB')
  print(res1, info)

集合内置方法set

  • 类型转换

​ 支持for循环的 并且数据必须是不可变类型

主要用于去重和关系运算

'''去重'''
# s1 = {1, 2, 12, 3, 2, 3, 2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4}
# print(s1)  # {1, 2, 3, 4, 5, 12}
----------------------#去重操作------------------------------------
# l1 = ['jason', 'jason', 'tony', 'oscar', 'tony', 'oscar', 'jason']
# s2 = set(l1)
# l1 = list(s2)
# print(l1)


'''关系运算'''
# print({1,2,[1,2,3]})
# print({1,2,{'name':'jason'}})

s1 = {1, 2, 12, 3, 2, 3, 2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4}
print(s1)  
{1, 2, 3, 4, 5, 12}

l1 = ['jason', 'jason', 'tony', 'oscar', 'tony', 'oscar', 'jason']
s2 = set(l1)
l1 = list(s2)
print(l1)
['tony', 'oscar', 'jason']
# 模拟两个人的好友集合
f1 = {'jason', 'tony', 'oscar', 'jerry'}
f2 = {'kevin', 'jerry', 'jason', 'lili'}
# 1.求f1和f2的共同好友
# print(f1 & f2)  # {'jason', 'jerry'}
# 2.求f1/f2独有好友
# print(f1 - f2)  # {'oscar', 'tony'}
# print(f2 - f1)  # {'lili', 'kevin'}
# 3.求f1和f2所有的好友
# print(f1 | f2)  # {'jason', 'kevin', 'lili', 'oscar', 'jerry', 'tony'}
# 4.求f1和f2各自独有的好友(排除共同好友)
# print(f1 ^ f2)  # {'kevin', 'lili', 'tony', 'oscar'}
# 5.父集 子集
# s1 = {1, 2, 3, 4, 5, 6, 7}
# s2 = {3, 2, 1}
# print(s1 > s2)  # s1是否是s2的父集  s2是不是s1的子集
# print(s1 < s2)
posted @ 2022-07-04 18:58  名字长的像一只老山羊  阅读(20)  评论(0)  编辑  收藏  举报