python 数据组 python数据组合类型最大值

 一、序列：列表，元组，字符串，字节序列

# 列表：用于存储其值可变的表

# 元组：用于存储值固定不变的表

# 字符串：包含若干字符的序列数据，s=“123abc”

# 字节序列：包含若干字节的序列数据，s=b”abc”

#

<一>、序列的内置函数
 通过内置函数len()、max()、min()、sum()可以获取序列的长度、所有元素最大值、元素最小值
<二>、序列索引
（1）正序(下标为正整数) 0表示第1个元素，1表示第2个元素，2表示第3个元素，以此类推；
 （2）倒序(下标为负整数) -1表示最后1个元素，-2表示倒数第2个元素，-3表示倒数第3个元素，以此类推
 格式：sequence_name[i]
 <三>、切片操作，适用于列表、元组、字符串、range对象等类型。（在range时总结过）
s=[1,2,3,4,5,6,7,8,9]
print(s[1:4])
##[2, 3, 4]
print(s[::-1]) #从右往左，两个冒号
##[9, 8, 7, 6, 5, 4, 3, 2, 1]
 <四>、序列的连接和重复操作
 通过连接符+可以连接两个序列而形成的新的序列对象。
 通过重复操作符号*可以重复一个序列n次
 <五>、元素索引的获取-index
 使用序列对象的index()方法获取指定元素首次出现的下标，若列表对象中不存在指定元素，则抛出异常
 <六>、可迭代对象，使用内置函数isinstance()可以判定一个对象是否是可迭代的对象。
import collections.abc
print(isinstance((1,2,3),collections.abc.Iterable))
##True
print(isinstance("123",collections.abc.Iterable))
##True
print(isinstance(123,collections.abc.Iterable))
##False
#for循环实现了自动迭代可迭代对象的功能
for i in "123":
    print(i)
<七>、序列的排序操作，内置函数sorted()
# sortd(iterable,key=None,reverse=False)
# 其中，key用于计算比较键值的函数，例如key=str.low
s=(1,2,3,9,56,8,67,1,2,9)
print(sorted(s))
##[1, 1, 2, 2, 3, 8, 9, 9, 56, 67]
<八>、序列封包与解包
#把多个值赋给一个变量时，Python会自动的把多个值封装成元组，称为序列封包
a=1,2,3
print(a)
##(1, 2, 3)
b=[1,2],[3,4],(2,3),'def'
print(b)
##([1, 2], [3, 4], (2, 3), 'def')
 
#序列解包：当一个序列（列表、元组、字符串等）直接赋给多个变量时，会把序列中的各个元素依次赋值给每个变量，要求元素的个数与变量个数相同
a,b,c,d="1234"
print("a={},b={},c={},d={}".format(a,b,c,d))
##a=1,b=2,c=3,d=4
 
#部分序列解包
#当我们在序列解包时，只想解出部分元素时，可以在变量的左边加“ * ”，该变量就会变成列表，保存多个元素
a,b,c,d,e=[*[1,2,3],"de",(4,5)]
print("a={},b={},c={},d={},e={}".format(a,b,c,d,e))
##a=1,b=2,c=3,d=de,e=(4, 5)

二、列表

#使用list()函数将元组、range对象、字符串或其他类型的可迭代对象类型的数据转换为列表。

print(list(range(1,10,2)))

##[1, 3, 5, 7, 9]

print(list((1,2,3)))

#[1, 2, 3]

 

# 列表的大多数方法是无返回值的，即无法赋值。list_name.method(除了pop)

 

#<一>、列表元素的增加的主要方式

# “+”运算符:尾部添加列表，严格意义上来讲，这并不是真的为列表添加元素，而是创建一个新列表。

# “*”运算符：重复增加相同元素

# append函数: 尾部添加整体对象。，无返回值；真正意义上的在列表尾部添加元素，速度较快。

# extend函数: 尾部添加序列，用于在列表末尾一次性追加另一个序列中的多个值

# insert函数: 指定位置添加对象

a=[1,2,3,4]

a.append([4,5,6])

print(a)

##[1, 2, 3, 4, [4, 5, 6]]

b=[1,2,3,4]

b.extend([4,5,6])

print(b)

##[1, 2, 3, 4, 4, 5, 6]



a=[3, 4, 5, 7, 9, 11, 13, 15, 17]

a.insert(3, 6) #在下标为3的位置插入元素6

print(a)

 

 

#<二>、列表元素的删除

#1.del命令删除列表中的指定位置上的元素或对象

a=[3, 4, 5, 7, 9, 11, 13, 15, 17]

del a[1]

print(a)



##[3, 5, 7, 9, 11, 13, 15, 17]

 

#3.使用列表对象的remove()方法删除首次出现的指定元素，如果列表中不存在要删除的元素，则抛出异常。

a_list = [3,5,7,9,7,11]

a_list.remove(7)

print(a_list)

##[3, 5, 9, 7, 11]



# #例题

x=[1,2,1,2,1,1]

for i in x:

    if i==1:

        x.remove(i)

# print(x)

# ##[2, 2, 1]  ,不能完全删除1，要用切片--浅拷贝

x=[1,2,1,2,1,1]

y=x[:]

for i in y:

    if i==1:

        x.remove(i)

print(x)

##[2, 2]

<三>、浅,深拷贝
#copy浅拷贝没有拷贝子对象，所以原始数据改变，子对象会改变。
#深度拷贝, a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的
import copy
alist=[1,2]
d=copy.deepcopy(alist)
print(alist)
##[1, 2]
print(d)
##[1, 2]
alist.append(5)
print(alist)
##[1, 2, 5]
print(d)
##[1, 2]
 
#<列表排序>
#倒序 reverse(永久)   reversed（临时）
#1sort()
 
#正序 sort(永久)  sorted(临时)
# 语法：list.sort( key=None, reverse=False)
# reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
a=[3, 4, 15, 11, 9, 17, 13, 6, 7, 5]
a.sort()
print(a)
##[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
a.sort(reverse=True)
print(a)
##[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
 
 
<四>推导式
#<1>、列表推导式
#########1##########
#格式：[表达式 for 变量 in 列表]
a=[x*x for x in range(10)]
print(a)
##[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
#等价于
a=[]
for x in range(10):
    a.append(x*x)
print(a)
 
#######2#########
#列表推导式—平铺
#基本格式 [表达式 for 变量1 in 列表1 for 变量2 in 变量1 ]
vec=[[1,2,3],[4,5,6],[7,8,9]]
print([num for elem in vec for num in elem])
##[1, 2, 3, 4, 5, 6, 7, 8, 9]
#等价于
vec=[[1,2,3],[4,5,6],[7,8,9]]
result=[]
for elem in vec:
    for num in elem:
        result.append(num)
print(result)
 
#######3#########
#列表推导式—元素过滤
#基本格式：[表达式 for 变量 in 列表 if 条件]
a=[-1,-4,6,7.5,-2.3,9,-11]
print([i for i in a if i>0])
##[6, 7.5, 9]
 <五>、元组(tuple)，元组一旦创建任何方法都不可以修改其元素
# 包含一个元素的元组，最后必须多写个逗号  a=(3,)
#（1）、元组的创建
#1 tuple()函数
a=tuple('abcdefg')
print(a)
##('a', 'b', 'c', 'd', 'e', 'f', 'g')
 
#2 zip()函数，zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表。
a=[1,2,3]
b=[4,5,6]
x=zip(a,b)
print(x)
##<zip object at 0x0000026AA1709400>
print(list(x)) #转换为列表
##[(1, 4), (2, 5), (3, 6)]

 

 

三、映射类型

# 字典是一种可变容器模型，且可存储任意类型对象。

# 字典每个元素的键和值用冒号分隔，元素之间用逗号分隔，所有的元素放在一对大括号“｛｝”中。

# dict = { key1 : value1，key2 : value2}

# 键可以为唯一且取任意不可修改对象，比如整数、实数、复数、字符串、元组等等。键不可重复的！

# 字典是无序可变。

 

<一>、字典dict的创建

#1、赋值，使用“=” 将一个字典赋值给一个变量

a_dict = {'server': 'db.diveintopython3.org', 'database': 'mysql'}

print(a_dict)

##{'server': 'db.diveintopython3.org', 'database': 'mysql'}

x = {} #空字典

print(x)

##{}

print(type(x))

##<class 'dict'>



#2、dict函数，使用dict利用已有数据创建字典：

keys=['a','b','c','d']

values=[1,2,3,4]

dic=dict(zip(keys,values))

print(dic)

##{'a': 1, 'b': 2, 'c': 3, 'd': 4}



#3、指定内容，使用dict根据给定的键、值创建字典

d=dict(name='Dong',age=37)

print(d)

##{'name': 'Dong', 'age': 37}



#以给定内容为键，创建值为空的字典

adict = dict.fromkeys(['name', 'age', 'sex'])

print(adict)

##{'name': None, 'age': None, 'sex': None}

 

<二>、字典的读取

# 1,字典元素的读取,以键作为下标可以读取字典元素，若键不存在则抛出异常

aDict = {'name':'Dong', 'sex':'male', 'age':37}

print(aDict['name'])

##Dong



#2，字典键或值的读取



#使用字典对象的items()方法可以返回字典的键、值对列表

print(aDict.items())

##dict_items([('name', 'Dong'), ('sex', 'male'), ('age', 37)])



#使用字典对象的keys()方法可以返回字典的键列表

print(aDict.keys())

##dict_keys(['name', 'sex', 'age'])



#使用字典对象的values()方法可以返回字典的值列表

print(aDict.values())

##dict_values(['Dong', 'male', 37])



#3,字典元素的遍历读取-items()

aDict = {'name':'Dong', 'sex':'male', 'age':37}

for item in aDict.items():

    print(item)

##('name', 'Dong')

##('sex', 'male')

##('age', 37)



for key, value in aDict.items(): #序列解包用法

    print(key,value)

# #name Dong

# #sex male

# #age 37

<三>、get()方法

#字典(Dictionary) get() 函数返回指定键的值，如果值不在字典中返回默认值。

# dict.get(key, default=None)

# ✓ key -- 字典中要查找的键。

# ✓ default -- 如果指定键的值不存在时，返回该默认值。



dict = {'Name': 'Zara', 'Age': 27}

print ("Value={}".format(dict.get('Age')))

print ("Value : %s" % dict.get('Sex', "Never"))



## Value=27

## Value : Never

<四>、修改字典

#增加新的键/值对，修改或删除已有键/值对

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

dict['Age'] = 8  # 更新 Age

print(dict)

##{'Name': 'Runoob', 'Age': 8, 'Class': 'First'}

dict['School'] = "菜鸟教程" # 添加信息

print(dict)

##{'Name': 'Runoob', 'Age': 8, 'Class': 'First', 'School': '菜鸟教程'}

<五>、删除字典元素

#能删单一的元素也能清空字典，清空只需一项操作。显示删除一个字典用del命令

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

del dict['Name'] # 删除键 'Name'

print(dict)

##{'Age': 7, 'Class': 'First'}

dict.clear() # 清空字典

print(dict)

##{}

 

 四、集合(set)类型

# 集合(set)是无序可变对象，使用一对大括号界定，元素不可重复，同一个集合中每个元素都是唯一的。

# 集合中只能包含数字、字符串、元组等不可变类型（或者说可哈希）的数据，而不能包含列表、字典、集合等可变类型的数据。

 

<一>、集合的创建

#1，，直接将集合赋值给变量

a={3,5}

#2,,使用set将其他类型数据转换为集合

b=set([0,1,2,3,5,3,4])  #自动去除重复

print(b)

##{0, 1, 2, 3, 4, 5}

 

<二>、集合元素的添加，添加一个元素

#1，add()函数

thisset = set(("Google", "Runoob", "Taobao"))

thisset.add("Facebook")

print(thisset)

##{'Google', 'Taobao', 'Runoob', 'Facebook'}



#2.update（）函数，添加多个元素

thisset = set(("Google", "Runoob", "Taobao"))

thisset.update("Facebook")

print(thisset)

##{'F', 'a', 'o', 'Google', 'k', 'b', 'Runoob', 'c', 'Taobao', 'e'}

##字母顺序随机？

<三>、集合元素的删除

#1，，remove函数:将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

thisset = set(("Google", "Runoob", "Taobao"))

thisset.remove("Taobao")

print(thisset)

##{'Runoob', 'Google'}



#2，discard函数:将元素 x 从集合 s 中移除，如果元素不存在，不会发生错误。

 

<四>、集合元素成员的判断

#基本格式：element in set_name

thisset = set(("Google", "Runoob", "Taobao"))

print("Runoob" in thisset)

##True

 

<五>、集合基本运算，，Python集合支持交集、并集、差集等运算

a_set=set([8,9,10,11,12,13])

b_set={0,1,2,3,7,8}

print(a_set|b_set)  #并集

print(a_set.union(b_set)) #并集

print(a_set&b_set)     #交集

print(a_set.intersection(b_set)) # 交集

print( a_set - b_set)  #差集

print( a_set.difference(b_set)) #差集

 

##小结：

#Python组合数据类型表示：

#切片：列表（方括号），元组（圆括号），字符串（单或者双引号）

 

#字典（成对大括号）