正文

数据类型内置方法：列表/元组/集合(代码片段)

gongjingyun123--  gongjingyun123--  2022-12-13  486

关键词：

list列表类型内置方法

作用:多个装备、多个爱好、多门课程，甚至是多个女朋友
定义方式:[]内用逗号隔开，可以有多个任意数据类型的元素

friends_list = ['longzeluola'，'canglaoshi'，'qiaobenai'，'nick']
lis = list('abcd')

方法:

优先掌握

索引取值(正向取值+反向取值）即可取又可存

#list之索引取值
name_list='nick','jason','tank','sean'
name_list[0]='nick handsome'
#name_list[1000]='tank handsome'    #报错

print(f"name_list[0]:name_list[0]")

name_list[0]:name_list[0]

切片

#list之切片
name_list=['nick','jason','tank','jick']

print(name_list[0:3:2])                  ----->'nick','tank'

长度len

#list之长度
name_list=['nick','jason','tank','jick']

print(len(name_list))                    ------>4

append追加值

# list之追加值
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.append('tank handsome' )

print(name_list)      
           ------->['nick', 'jason', 'tank', 'jick', 'tank handsome']

成员运算in和not in

# list之成员运算in和not in
name_list = ['nick', 'jason', 'tank', 'sean']

print('tank handsome' in name_list )      ----->Fslse
print('nick handsome' not in name_list)      ------>true

for循环

# list之循环
name_list = ['nick', 'jason', 'tank', 'sean']

for name in name_list:
    print(name)            
nick
jason
tank
jick

删除del

# list之删除
name_list = ['nick', 'jason', 'tank', 'sean']
del name_list[2]

print(name_list)                ---->['nick', 'jason', 'jick']

需要掌握

count计数

# list之count()
name_list = ['nick', 'jason', 'tank', 'sean']

print(name_list.count('tank'))        ------>1

remove 如果删除对象不存在则报错，按照指定的元素删除

# list之remove()
name_list = ['nick', 'jason', 'tank', 'sean']

print(name_list.remove('tank'))     ------>        None
print(name_list)          ----->['nick', 'jason', 'sean']

reverse 反转列表

# list之reverse()
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.reverse()

print(name_list)         ------>['sean', 'tank', 'jason', 'nick']

pop 默认删除最后一个值，删除指定索引的值

# list之pop()，pop()默认删除最后一个元素
name_list = ['nick', 'jason', 'tank', 'sean']

print(name_list.pop(1))           ----->jason

print(name_list)            ----->['nick', 'tank', 'sean']

insert 在索引前面加入一个值

# list之insert()
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.insert(1,'handsome')

print(name_list)    --->['nick', 'handsome', 'jason', 'tank', 'sean']

sort 排序列表

# list之sort()，使用sort列表的元素必须是同类型的
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.sort()

print(name_list)        --->['jason', 'nick', 'sean', 'tank']
name_list.sort(reverse=True)    
print(name_list)      ------->['tank', 'sean', 'nick', 'jason']

index 获取指定元素的索引，但是只会获取第一次

# list之index()
name_list = ['nick', 'jason', 'tank', 'sean']

print(name_list.index('nick'))           ---->0

copy 复制

# list之copy()
name_list = ['nick', 'jason', 'tank', 'sean']

print(name_list.copy())      --->['nick', 'jason', 'tank', 'sean']

extend 扩展，把extend里的列表的元素添加到原列表中

# list之extend()
name_list = ['nick', 'jason', 'tank', 'sean']
name_list2=['nick handsome' ]
name_list.extend(name_list2)

print(name_list)  
               -->['nick', 'jason', 'tank', 'sean', 'nick handsome']

clear 清除列表/清空列表

# list之clear()
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.clear()

print(name_list)      ------->[]

多个值or一个值 :多个值

有序or无序:有序

hobby_list = ['read', 'run', 'girl']
print(f'first:id(hobby_list)')           --->4522187016
hobby_list[2] = ''
print(f'second:id(hobby_list)')         ---->4522187016

可变or不可变:可变数据类型

元组类型内置方法

作用: 类似于列表，可以存不可以取
定义方式: 在()内可以有多个任意类型的值，逗号分隔元素

friends_tuple = ('longzeluola'，'canglaoshi'，'qiaobenai'，'nick')
tup = tuple('abcd')

方法
1. 索引取值(无法更改)
2. 切片（顾头不顾尾，步长）
3. 长度 len
4. 成员运算 in 和not in
5. for循环
6. count
7. index
多个值or一个值:多个值
有序or无序:有序
可变or不可变:无可变不可变这一说

列表可变的原因是：索引所对应的值的内存地址是可以改变的

元组不可变得原因是：索引所对应的值的内存地址是不可以改变的，或者反过来说，只要索引对应值的内存地址没有改变，那么元组是始终没有改变的。

字典类型内置方法

作用:当列表存在很多值的时候，列表会显得很乱，所以就有了字典。多用于存的值表示的是不同的状态时，例如存的值有姓名、年龄、身高、体重、爱好。
定义方式:内用逗号分隔开多个键值对key：value的值，value可以是任意数据类型，而key通常应该是字符串类型，但是key必须为不可变类型。

nick_info_dict = 
'name':'nick'，
'height':180，
'weight':140，
'hobby_list':['read'，'run'，'music'，'fishing'，'programming'，'coding'，'debugging']


for k，v in nick_info_dict.items():
    print(k，v)

name nick
height 180
weight 140
hobby_list [‘read‘, ‘run‘, ‘music‘, ‘fishing‘, ‘programming‘, ‘coding‘, ‘debugging‘]

方法

按键取值：可存可取

# dic之按key存取值
dic = 'a': 1, 'b': 2

print(f"first dic['a']: dic['a']")
dic['a'] = 3

print(f"second dic['a']: dic['a']")

first dic[‘a‘]: 1
second dic[‘a‘]: 3

长度：
```
?```
print(len(dic))
```

键keys() / 值values(）/ 键值对items()

# dic之键keys()、值values()、键值对items()，python2中取出的是列表（鸡蛋）；python3中取出的是元组（鸡）
dic = 'a': 1, 'b': 2

print(f"dic.keys(): dic.keys()")
print(f"dic.values(): dic.values()")
print(f"dic.items(): dic.items()")

dic.keys(): dict_keys([‘a‘, ‘b‘])
dic.values(): dict_values([1, 2])
dic.items(): dict_items([(‘a‘, 1), (‘b‘, 2)])

for循环

# dic之循环
# dic是无序的，但是python3采用了底层优化算法，所以看起来是有序的，但是python2中的字典是无序
dic = 'a': 1, 'b': 2, 'c': 3, 'd': 4

for k, v in dic.items():  # items可以换成keys()、values()
    print(k, v)

a 1
b 2
c 3
d 4

成员运算in 和 not

# dic之成员运算in和not in
dic = 'a': 1, 'b': 2

print(f"'a' in dic: 'a' in dic")
print(f"1 in dic: 1 in dic")

‘a‘ in dic: True
1 in dic: False

删除del

# dic之删除del
dic = 'a': 1, 'b': 2
del dic['a']

print(f"dic.get('a'): dic.get('a')")

dic.get(‘a‘): None

需要掌握
1. fromkeys 来自键值，默认把给定列表内的元素取出来当成key，然后使用一个默认value新建一个字典
```
# dic之fromkeys()
dic = dict.fromkeys(['name', 'age', 'sex'], None)

print(f"dic: dic")
```
dic: ‘name‘: None, ‘age‘: None, ‘sex‘: None

2. setdefault    如果字典中有该key的话，则key对应的值不变：如果没有，则增加

   ```python
   # dic之setdefault()，有指定key不会改变值；无指定key则改变值
   dic = 'a': 1, 'b': 2
   
   print(f"dic.setdefault('a'): dic.setdefault('a',3)")
   print(f"dic: dic")
   print(f"dic.setdefault('c'): dic.setdefault('c',3)")
   print(f"dic: dic")
   ```

   dic.setdefault('a'): 1
   dic: 'a': 1, 'b': 2
   dic.setdefault('c'): 3
   dic: 'a': 1, 'b': 2, 'c': 3

3. get 如果键不存在，返回不会报错，可以给默认值

   ```python
   # dic之get()
   dic = 'a': 1, 'b': 2
   
   print(f"dic.get('a'): dic.get('a')")
   print(f"dic.get('c'): dic.get('c')")
   ```

   dic.get('a'): 1
   dic.get('c'): None

4. update  有就更新，没有就添加

   ```python
   # dic之update()
   dic1 = 'a': 1, 'b': 2
   dic2 = 'c': 3
   dic1.update(dic2)
   
   print(f"dic1: dic1")
   ```

   dic1: 'a': 1, 'b': 2, 'c': 3

多个值or一个值:多个值,值可以是多个类型，key必须是不可变类型，通常应该是不可变类型中的字符串类型
有序or无序:无序
可变or不可变:可变数据类型

集合类型内置方法

作用:存多个值，为了集合之间做运算，由于集合内的元素无序且集合元素不可重复，因此集合可以去重，但是去重后的集合会打乱原来元素的顺序。
定义方式:内用逗号分隔开多个元素，每个元素必须是不可变类型。

s = set()

s = 1，2，3，4，5，1

方法:

优先掌握
1. 去重
2. 并集 | ,union
```
# str之|并集
pythoners = 'jason', 'nick', 'tank', 'sean'
linuxers = 'nick', 'egon', 'kevin'

print(f"pythoners|linuxers: pythoners|linuxers")
print(f"pythoners.union(linuxers): pythoners.union(linuxers)")
```
  pythoners|linuxers: ‘egon‘, ‘tank‘, ‘kevin‘, ‘jason‘, ‘nick‘, ‘sean‘
  pythoners.union(linuxers): ‘egon‘, ‘tank‘, ‘kevin‘, ‘jason‘, ‘nick‘, ‘sean‘
3. 交集 & intersection
4. 差集 -difference
5. 对称差集 ^symmetric_difference
6. 父集 >&emsp；>=issuperset
7. 子集 <&emsp；<=issubset
8. ==

需要掌握

add（）

# set之add()
s = 1, 2, 'a'
s.add(3)

print(s)

1, 2, 3, ‘a‘

difference_update

# str之difference_update()
pythoners = 'jason', 'nick', 'tank', 'sean'
linuxers = 'nick', 'egon', 'kevin'
pythoners.difference_update(linuxers)

print(f"pythoners.difference_update(linuxers): pythoners")

pythoners.difference_update(linuxers): ‘tank‘, ‘jason‘, ‘sean‘

isdisjoint 是否不联合

# set之isdisjoint()，集合没有共同的部分返回True，否则返回False
pythoners = 'jason', 'nick', 'tank', 'sean'
linuxers = 'nick', 'egon', 'kevin'
pythoners.isdisjoint(linuxers)

print(f"pythoners.isdisjoint(linuxers): pythoners.isdisjoint(linuxers)")

pythoners.isdisjoint(linuxers): False

remove # 值不存在会报错

# set之remove()
s = 1, 2, 'a'
s.remove(1)

print(s)

2, ‘a‘

discard # 放弃，删除，不会报错

# set之discard()
s = 1, 2, 'a'
# s.remove(3)  # 报错
s.discard(3)

print(s)

1, 2, ‘a‘

多个值or一个值:多个值，且值为不可变类型
有序or无序:无序
可变or不可变:可变数据类型

数据类型总结

一个值	多个值
整型/浮点型/字符串	列表/元祖/字典/集合/

有序	无序
字符串/列表/元祖	字典/集合

可变	不可变
列表/字典/集合	整型/浮点型/字符串

拷贝

==拷贝/浅拷贝/深拷贝都是针对可变类型数据而言的==

l1 = ['a'，'b'，'c'，['d'，'e'，'f']]
l2 = l1

l1.append('g')

print(l1)  # ['a'，'b'，'c'，['d'，'e'，'f']，'g']
print(l2)  # ['a'，'b'，'c'，['d'，'e'，'f']，'g']

如果l2是l1的拷贝对象，则l1内部的任何数据类型的元素变化，则l2内部的元素也会跟着改变，因为可变类型值变id不变

浅拷贝

import copy


l1 = ['a'，'b'，'c'，['d'，'e'，'f']]
l2 = copy.copy(l1)

l1.append('g')

print(l1)  # ['a'，'b'，'c'，['d'，'e'，'f']，'g']
print(l2)  # ['a'，'b'，'c'，['d'，'e'，'f']]

l1[3].append('g')

print(l1)  # ['a'，'b'，'c'，['d'，'e'，'f'，'g']，'g']
print(l2)  # ['a'，'b'，'c'，['d'，'e'，'f'，'g']]

如果l2是l1的浅拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，则l2会跟着改变

深拷贝

import copy


l1 = ['a'，'b'，'c'，['d'，'e'，'f']]
l2 = copy.deepcopy(l1)

l1.append('g')

print(l1)  # ['a'，'b'，'c'，['d'，'e'，'f']，'g']
print(l2)  # ['a'，'b'，'c'，['d'，'e'，'f']]

l1[3].append('g')

print(l1)  # ['a'，'b'，'c'，['d'，'e'，'f'，'g']，'g']
print(l2)  # ['a'，'b'，'c'，['d'，'e'，'f']]

如果l2是l1的深拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，l2也不会变，即l2永远不会因为l1的变化而变化

```

列表元组字典与集合(代码片段)

一、列表　　序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字-它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。Python有6个序列的内置类型，但最常见的是列表和元组。序列都可以进行的操作... 查看详情

数据类型内置方法(代码片段)

目录数据类型内置方法总结数字类型内置方法整型int()浮点型float()字符串类型内置方法列表类型内置方法元组类型内置方法字典类型内置方法集合类型内置方法数据类型总结拷贝深浅拷贝数据类型内置方法总结数字类型内置方法... 查看详情

元组类型内置方法(代码片段)

元组类型的内置方法1.用途?可以存多个数据2.定义?（）内可以有多个任意类型的值，用逗号隔开，元组是不可变的列表name_tuple=('jack','alex','peiqi')name_tuple[0]='nick'#元素不能修改，会报错3.常用操作很内置方... 查看详情

p2总复习(代码片段)

目录0531总复习数据类型内置方法整形类型内置方法浮点型类型内置方法字符串类型内置方法优先掌握需要掌握了解列表类型内置方法优先掌握需要掌握元组类型内置方法优先掌握字典类型内置方法优先掌握需要掌握集合类型内... 查看详情

详解python数据类型：字符串列表元组字典集合(代码片段)

这篇文章主要介绍了Python列表(list)、字典(dict)、字符串(string)基本操作小结,本文总结了最基本最常用的一些操作,需要的朋友可以参考下python字符串/列表/字典互相转换Python列表操作得到列表中的某一个值删除列表的第一个值在列... 查看详情

详解python数据类型：字符串列表元组字典集合(代码片段)

（字符串列表字典元组集合）的常用内置方法(代码片段)

一、字符串：lis=‘mynameismaple‘res=lis.count(‘m‘)#计算字符串内相同字符的个数print(res)lis=‘mynameismaple‘res=lis.split(‘‘)#按照制定的分隔字符，分隔开多个字符串，存放到一个列表中print(res)lis=‘mynameismaple‘res=lis.strip(‘‘)#将字... 查看详情

python内置数据类型与方法(代码片段)

序列类型包括列表、元组和范围（range）以及字符串，序列类型的对象有一些共同的操作，如操作符运算、切片操作等。1.list类型与操作1.1玩转索引列表（list）类型的对象可以通过list（）函数来创建。如果list（）函数没有传入... 查看详情

基础_列表(代码片段)

...中内置的有序、可变序列。列表中元素可以是不同类型的数据类型，包括整型，浮点型，字符串，列表，字段，元组，集合等。列表方法中包含了‘增删改查’等基础方法。创建列表1list=[]#创建空列表2new_student=[‘hamin... 查看详情

复合数据类型，英文词频统计(代码片段)

...，字典，集合分别如何增删改查及遍历。列表：对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项；可以使用del语句来删除列表的的元素；元组：元组可以使用下标索引来访问元组中的值；元组中的元素值... 查看详情

python开发--14元组类型内置方法(代码片段)

文章目录一.作用1.元组与列表2.元组的作用二.定义方式元组不可变解析三.常用操作+内置方法🐼优先掌握的操作(*********)1.按照索引取值(正向取+反向取):只能取2.切片(顾头不顾尾+步长)3、长度:.len()4、成员运算int和not... 查看详情

第6天数据类型之元组，字典，集合(代码片段)

...一个情况，也就是为了防止一些不必要的bug，一些重要的数据别人是可以读取的，但是不能够进行更改，这个时候我们就需要用到元组了。对于列表而言，python中对于元祖的存储相对来说更为存储空间的。（因为它不必再像列表... 查看详情

元组及内置方法(代码片段)

...样，不同的是列表里面可以改而元组不可以（元组中可变类型可以改其中的值）元组怎么定义的在()内可以有多个任意类型的值，逗号分隔元素#1.直接定义获得test_tuple=("zcy",)test_tuple1=("zcy",20,["play","eat"])#2.利用tuple()方法转换列表t... 查看详情

组合数据类型，英文词频统计(代码片段)

练习总结列表，元组，字典，集合的联系与区别列表，元组，字典是有顺序的，而集合是没顺序的列表是以方括号形式表示，元组是以圆括号表示，字典以花括号表示，集合则是以[()]的形式表示列表是可变对象,它支持在原处修... 查看详情

列表及元组(代码片段)

一.列表的介绍:列表是Python数据类型之一,其他编程语言也有类似的数据类型.比如JS中的数组,java中的数组等等,他是以[]括起来,每个元素用 ‘,‘ 隔开,而且可以存放各种数据类型1lst=[1,"lx","我是",[1,‘我‘,"长时间啊"],("我... 查看详情

复合数据类型，英文词频统计(代码片段)

...#列表list=[‘a‘,‘b‘,‘hello‘,1]#增第一在列表后方添加数据第二为在对应的下边插入数据list.append(2)list.insert(0,‘0‘)print(list)#删删除对应下标的列表中的数据dellist[2]print(list)#改修改对应下标的列表中的数据list[2]=‘hi‘print(list)... 查看详情

列表字典元组集合

...（同种属性）2、定义方式：在[]内用逗号分隔开多个任意类型的值类型转换定义列表实际上是借用list（）方法生成列表，可以将其他类型转化为列表，如字符串元组，字典集合 3、常用操作+内置的方法1、按索引存取值(正向... 查看详情

正文

数据类型内置方法：列表/元组/集合(代码片段)

list列表类型内置方法

优先掌握

元组类型内置方法

列表可变的原因是：索引所对应的值的内存地址是可以改变的

字典类型内置方法

集合类型内置方法

数据类型总结

拷贝

浅拷贝

深拷贝

列表元组字典与集合(代码片段)

数据类型内置方法(代码片段)

元组类型内置方法(代码片段)

p2总复习(代码片段)

详解python数据类型：字符串列表元组字典集合(代码片段)

详解python数据类型：字符串列表元组字典集合(代码片段)

详解python数据类型：字符串列表元组字典集合(代码片段)

（字符串列表字典元组集合）的常用内置方法(代码片段)

python内置数据类型与方法(代码片段)

基础_列表(代码片段)

复合数据类型，英文词频统计(代码片段)

python开发--14元组类型内置方法(代码片段)

第6天数据类型之元组，字典，集合(代码片段)

元组及内置方法(代码片段)

组合数据类型，英文词频统计(代码片段)

列表及元组(代码片段)

复合数据类型，英文词频统计(代码片段)

列表字典元组集合