一、序列：列表，元组，字符串，字节序列
# 列表：用于存储其值可变的表
# 元组：用于存储值固定不变的表
# 字符串：包含若干字符的序列数据，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组合数据类型表示：
#切片：列表（方括号），元组（圆括号），字符串（单或者双引号）
#字典（成对大括号）
5719
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
