python 列表，元祖，字典，集合

1.1python列表的概述

列表的定义：列表是一个有序的，可修改的，元素以逗号分隔，以中括号包围的序列。

1.2 python 列表的定义

1 lis = []
2 print(type(lis),lis)
3 输出：<class 'list'> []

列表中的每个元素的类型都可以互不相同，并且可以嵌套使用，列表中所放置的变量是不受类型约束的，可以是任意类型

lis = [1,2,3,'srt',['a','b'],'123']
print(type(lis),lis)
输出：<class 'list'> [1, 2, 3, 'srt', ['a', 'b'], '123']

1.3列表的操作

列表的添加

append 追加，在列表的末尾插入元素

L = [1,2,3]
L.append(4)
print(L)
输出：[1, 2, 3, 4]

insert 将指定元素插入到对应的索引位上，注意负索引

L = [1,2,3]
L.insert(0,'1')
print(L)
输出：['1', 1, 2, 3]

extend 将指定序列的元素依次追加到列表的尾部（合并）

L = [1,2,3]
L.extend('abc')
print(L)
输出：[1, 2, 3, 'a', 'b', 'c']

列表的删除

pop 弹出，返回并删除指定索引位上的数据，默认删除索引为-1的数据

L = [1,2,3]
L.pop(0)
print(L)
输出：[2, 3]

remove 从左往右删除一个指定的元素

L = [1,2,3,'a']
L.remove('a')
print(L)
输出：[1, 2, 3]

del 删除整个列表或列表的数据，del是python内置功能不是list独有的

L = [1,2,3,'a']
del L
print(L)
输出：NameError: name 'L' is not defined

列表的查找
count 计数，返回要计数元素在列表中出现的个数

L = [1,2,3,'a']
print(L.count(1))
输出：1

index 查找，从左往右返回查找到的第一个指定元素的索引，如果没有找到，报错。

L = [1,2,3,'a']
print(L.index('a'))
输出：3

in 查找元素是否在列表中，在输出true,否则false

L = [1,2,3,'a']
print(1 in L)
输出：True

列表的排序
reverse 顺序倒序

L = [1,2,3,'a']
L.reverse()
print(L)
输出：['a', 3, 2, 1]

sort 按照ascii码表进行排序

L = [1,2,3]
L.sort()
print(L)
输出：[1, 2, 3]
注意：列表内不同数据类型之间，不能相互比较。否则会出错

 

2.1元祖的概述

元祖的定义：不可修改的，以逗号分隔，以小括号包围的序列，可以通过()，tuple()函数定义。
不能修改，只有在定义的一瞬间可以修改。
元祖是我们列表的只读版本

元祖的优点：
由于元祖不可变，所以遍历元祖比列表要快（较小的性能提升）
由于元祖不可变，所以元祖的数据被‘写保护’，一些软件比较重要的数据都是用元祖存储的

创建元祖

tuple = ('1','2',3)
print(tuple,type(tuple))
输出：('1', '2', 3) <class 'tuple'>

 

关于tuple的定义还有一些特殊的规则
在定义包含0个元素的tuple时，直接使用小括号。
在定义包含1个元素的tuple时，需要在后面加一个括号。
为什么会出现这种情况呢？，Python中的（）同样也表示数学运算的一个基本符号，比如(1+1)*2
所以这就和元组的这个小括号产生了歧义，当元组中只有一个元素，而又没有逗号的时候，它会把这
元素运算出来，这个小括号会被Python解释器识别为一个运算符号，所以得到的是那个元素本身的数据类型

访问元组
元组的‘序列’类型相关操作与List基本一样，下标从0开始，支持索引、切片等读取方式，但不支持修改。

tuple = ('1','2',3)
print(tuple[0],tuple[1])
输出：1 2

 

修改元组
说明：Python中不允许修改元组的数据，包括不能删除其中的元素。

tuple函数
tuple函数的功能与list函数基本上一样的，以一个序列作为参数并把它转换为元组，如果参数是元组，那么该参数就会被原样返回。

L = [1,2,3]
tuple = tuple(L)
print(tuple)
输出：(1, 2, 3)

 

元组是不可变的，也就是说，元组中的元素在被赋值后不能改变。但是，如果元素本身是一个可变数据类型的列表，那么其嵌套项可以被改变。

num = (1,2,['a','b'])
num[2].append('c')
print(num)
输出：(1, 2, ['a', 'b', 'c'])

 

2.2python元祖的方法

元祖的查找：
index 从左往右返回第一个遇到的指定元素的索引，如果没有报错！

num = (1,2,['a','b'])
print(num.index(['a','b']))
输出：2

 

count 返回元祖当中指定元素的个数

num = (1,1,3,4,2,1)
print(num.count(1))
输出：3

 

2.3 Python元组与列表的区别

1,元祖和列表都是有序的，元祖不可修改，列表可以修改

3.3python字典

3.1 python字典的概述
字典是一个无序的，可以修改的，元素呈键值对的形式（这种结构类型通常也被称为映射，或者叫关联数组，也有叫哈希表的），以逗号分割的，以大括号包围的数据类型；

3.2 字典和列表一样，也能够存储多个数据，字典中的值并没有特殊顺序。
列表中找某个元素时，是根据下标进行的，如果下标很多，查找数据不方便。当索引不好用时，使用字典，是你最好的选择。
字典的每个元素由2部分组成，键:值。例如 'name':'班长' ,'name'为键，'班长'为值，字典由键值组成。
由于字典无序，所以我们定义字典和字典生成之后的元素的顺序是不同的；
格式：

info = {'name':'alex','addr':'beijing','age':'18'}
#利用键名获取
s = info['name']
print(s)
输出：alex #注意如果未找到这个键，报错
#get方法
s = info.get('addr')
print(s)
输出：beijing #get方法如果没有找到相应的值，就会输出None，后面也可以带默认的值，工作中常用。

添加
info['hobby'] = 'girl'
print(info)
输出：{'name': 'alex', 'addr': 'beijing', 'age': '18', 'hobby': 'girl'}

修改
info['hobby'] = 'boy'
print(info)
输出：{'name': 'alex', 'addr': 'beijing', 'age': '18', 'hobby': 'boy'} #如果元素中没有hobby这个键，就是添加

删除
del info['name']
print(info)
输出:{'addr': 'beijing', 'age': '18', 'hobby': 'girl'}

 

3.3Python字典的特点

1.因为字典是无序的，所以字典没有索引值；
2.因为字典没有索引值，所以字典以键取值，(字典的键相当于列表的索引)；
3.因为字典以键取值，所以字典的键唯一且不可修改；
4.因为字典的键不可修改，所以列表和字典等可变类型的数据不可以给字典做键。

3.4Python字典的常见操作

keys 返回一个包含字典所有key的列表
values 返回一个包含字典所有value的列表
get 以键取值，如果指定键不存在，默认返回None,可以指定返回内容
setdefault 设置默认，如果键存在，返回值，如果键不存在，创造键，值默认为None，
值也可以自定义setdefault(key,default=None)
update 以字典格式更新指定键的内容，如果键不存在，创建键和值
items 返回字典键值呈元组形式的格式

#keys
info = {'name': 'alex', 'age': 18, 'addr': 'beijing'}
s = info.keys()
print(s,type(s))
输出：dict_keys(['name', 'age', 'addr']) <class 'dict_keys'>

#values
s = info.values()
print(s,type(s))
输出：dict_values(['alex', 18, 'beijing']) <class 'dict_values'>

#setdefault
s = info.setdefault('hobby','girl')
print(info)
#以字典格式更新指定键的内容，如果键不存在，创建键和值
输出：{'name': 'alex', 'age': 18, 'addr': 'beijing', 'hooby': 'girl'}

#update
info.update({'cosplay':'勇士'})
print(info)
输出：{'name': 'alex', 'age': 18, 'addr': 'beijing', 'cosplay': '勇士'}

#items
s = info.items()
print(s)
输出：dict_items([('name', 'alex'), ('age', 18), ('addr', 'beijing')])

 

字典的删除 pop 弹出，返回并删除指定键对应的值
popitem 随机弹出一个键值元组，这里随机的原因是因为字典无序
clear 清空字典

字典的判断 in 判断指定的键是否在字典当中

字典的遍历 for ...in .. 通过for ... in ...:的语法结构，我们可以遍历字符串、列表、元组、字典等数据结构。

#定义一个字典
info = {'name':'龟叔','age':50,'addr':'荷兰'}

#pop方法
print(info.pop('name'),info)
输出：alex {'age': 18, 'addr': 'beijing'}

#popitem
print(info.popitem(),info)
输出：('addr', 'beijing') {'name': 'alex', 'age': 18}

#clear
info.clear()
print(info)
输出：{}

#for...in...
for i in info:
print(i)
输出： name
age
addr

 

转载于:https://www.cnblogs.com/python-info/p/11107134.html