Python数据结构

一、组合类型简介

数据结构是通过某种方式组织在一起的数据元素的集合，这些元素可以是数字或符号。
Python有可以处理一些复杂的数据类型，称为组合数据类型。
组合数据类似能够将多个基本数据类型或组合数据类型组织起来，作用是能够更清晰的反映数据之间的关系，也能更方便地管理和操作数据。
Python中组合数据类型有三类：序列类型、映射类型和集合类型

1.1 序列类型

序列类型是一个元素向量，元素之间存在先后关系，通过序号访问。
Python中的序列类型主要有字符串（str）、列表类型（list）、元组类型（tuple）

1.2 映射类型

映射类型是一种键值对，一个键只能对应一个值，但是多个键可以对应相同的值，通过键可以访问值。
字典类型（dict）是Python中唯一的映射类型。
字典中的元素没有特定的顺序，每个值都对应唯一的键。
字典类型的数据和序列类型的数据的区别在于存储和访问方式的不同。此外，序列类型只用整数作为序号，而映射类型可以用整数、字符串或者其他类型的数据作为键，而且键和键值之间有一定的关联性，键可以映射到键值。

1.3 集合类型

集合类型是一种无序不重复的元素集。
集合的元素类型只能是固定数据类型，eg：整型、字符串、元组等，而列表、字典等是可变数据类型，不能作为集合中的数据元素。
集合可以进行交、并、差、补等运算。

二、字符串的基本操作

2.1 字符串对象的特性

Python中的字符串可以看作是一串连续存储的字符的序列，它可以通过索引进行顺序访问。

2.2 字符串的格式化

字符串的格式化通常用在print()函数，用来实现输出字符的特定格式。
格式字符和普通字符构成一个格式化字符串，通过格式运算符%限定输出数据的显示样式。
<格式化字符串> %(<值1>,<值2>,……<值n>)
通过格式运算符可以实现将一个值插入到格式字符串中相应运算符%出现的位置

year=int(input())
month=int(input())
day=int(input())
print("today is' %d.%d.%d"%(year,month,day))
##结果
2020
11
23
today is' 2020.11.23

如果要在格式化字符串中包含百分号，就必须使用%%，这样Python才不会将百分号误认为是格式符。

a=('%.2f%%')          ##%%
b= 20.16
c= a%b
print(c)
##结果
20.16%
a=('%.2f%')          ##%,会报错
b= 20.16
c= a%b
print(c)
c= a%b
ValueError: incomplete format

字符串常用格式化符号

2.3 字符串的索引和切片

2.3.1 索引

字符串中的字符按位置进行了编号，称为索引，使用的时候可以使用索引来访问字符串中特定的字符。
字符串中的第一个字符的编号为，长度为L的字符串的最后一个字符编号为L-1。
正向索引，从0开始递增，逆向索引，从-1开始递减。

s= 'lhuan'
print(s[0])
print(s[-1])
##结果
l
n

2.3.2 切片

字符串的切片是指通过索引对字符串进行切片的操作。
<字符串名>[i:j:k]
切片语句中的i、j、k都可以省略，
i是起始编号，i省略的时候，表示从0或-1开始
j是结束编号，不包含j上面的字符，j省略的时候，表示到最后一个字符；
k是编号增加步长，k省略的时候，表示步长为1

str = "一如既往，万事胜意"
print(str[0:8:2])     ##将str的0、2、4、6的位置进行切片
##结果
一既，事
str = "一如既往，万事胜意"
print(str[4:6])          ##省略k
print(str[::2])          ##省略i，j
print(str[5::])          ##省略j，k
##结果
，万
一既，事意
万事胜意
##利用切片逆序输出字符串
str = "一如既往，万事胜意"
print("逆序输出：%s"%(str[-1::-1]))   ##从末尾进行切片直到完成，步长为-1
##结果
逆序输出：意胜事万，往既如一

2.4 字符串的运算符

2.4.1 + 加号

使用加号（+）运算符可以将两个字符串连接起来，成为一个新的字符串。

str1="一如既往,"
str2="万事胜意."
str3=str1+str2
print(str3)
##结果
一如既往,万事胜意.

2.4.2 * 乘号

使用乘号（*）运算符可以将一个字符串的内容复制多次，成为一个新的字符串。

str1="一如既往,"
str2=str1*6
print(str2)
##结果
一如既往,一如既往,一如既往,一如既往,一如既往,一如既往,

2.4.3 逻辑运算符

使用大于（>)、等于（==）、小于（>）逻辑运算符可以比较两个字符串的大小

str1='lhuan'
str2='12'
print(str1>str2)
print(str1<str2)
print(str1<str2)
##结果
True
False
False

2.4.4 in 和not in运算符

使用in 或 not in 运算符可以测试某个字符是否存在于字符串中

str="梨花风起正清明"
print('梨'in str)
print('lhuan'not in str)
##结果
True
True

2.5 字符串的运算方法

2.5.1 len()

返回字符串的长度

str="梨花风起正清明，\n游子寻春半出城"
print(len(str))
##结果
16

2.5.2 ord()

返回某个字符的ASCII码

print(ord('r'))
##结果
114

2.5.3 chr()

返回整数x对应的ASCII码

print(chr(99))
##结果
c

2.5.4 str()

将元素转换成字符串

a=99
print(type(a))
a=str(a)
print(type(a))
##结果
<class 'int'>
<class 'str'>

2.5.5 max()

返回字符串中的最大值，如果出现相同字母的大小写，则小写字母大于大写字母。

str='lhuan102456789'
print(max((str)))
##结果
u

2.5.6 min()

返回字符串中的最小值，如果出现相同字母的大小写，则大写字母小于小写字母

str='LlhHJj'
print(min((str)))
##结果
H

2.5.7 lower()

将字符串中的所有大写字符转化成小写字符。
<字符串名>.lower()

str='LlhHJj'
print(str.lower())
##结果
llhhjj

2.5.8 upper()

将字符串中的所有小写字符转化成大写字符
<字符串名>.upper()

str='LlhHJj'
print(str.upper())
###结果
LLHHJJ

2.5.9 capitalize()

将字符串的第一个字符转化成大写，其他字符转换成小写，如果字符串的首字符不是字母，那么该字符串的第一个字符不会转换成大写，而转换成小写。

str1='ooppiilhHJj'                ##首字符是字母
print(str1.capitalize())
str2='1WoppiilhHJj'               ##首字符不是字母
print(str2.capitalize())       
##结果
Ooppiilhhjj
1woppiilhhjj

2.5.10 title()

返回“标题化”的字符串，所有单词都以大写字母开始，其余字母都是小写。

str1='ooppiilhHJj'
print(str1.title())
##结果
Ooppiilhhjj

2.5.11 count()

用于统计字符串中某个字符出现的个数，可选参数在字符串搜索的开始和结束的地方。
str.count(sub,start =0,end=len(string))
sub为搜索的子字符串
start为字符串开始搜索的位置，默认为第一个字符，第一个字符的索引为0
end 为字符串中结束搜索的地方，默认为字符串的最后一个位置，不包含

str = 'lkossSpoussubkwsseradaf'
print(str.count('l'))
print(str.count('s',2,8))
##结果
1
2

2.5.12 find()

用于检测字符串中是否含有子字符串。如果包含子字符串，就返回开始的索引值，否则，就返回-1.
str.find(str,beg=0,end=len(string))
str 为指定检索的字符串
beg 开始索引，默认为0
end 结束索引，默认为字符串的长度

str="梨花风起正清明，游子寻春半出城"
str2='清明'
print(str.find(str2))      
print(str.find(str2,9,10))
##结果
5             ##返回子字符串开始的索引
-1

2.5.13 index()

检测字符串中是否包含子字符串，如果包含子字符串，就会返回开始的索引，否则，就会报一个异常
str.index(str,beg=0,end=len(string))
str 为指定检索的字符串
beg 开始索引，默认为0
end 结束索引，默认为字符串的长度

str="梨花风起正清明，游子寻春半出城"
str2='清明'
print(str.index(str2))
print(str.index(str2,9,10))  ##不存在，就会报错
##结果
5
  File "D:/pythontest/geshu.py", line 249, in <module>
    print(str.index(str2,9,10))
ValueError: substring not found

2.5.14 join()

用于将序列中的元素以指定的字符连接生成一个新的字符串。
str.join(seq)
seq 为要连接的元素序列，必须为字符串，如果是其他数据类型，运行的时候会报错

str="梨花风起正清明，游子寻春半出城"
str1='****'
print(str1.join(str))
##结果
梨****花****风****起****正****清****明****，****游****子****寻****春****半****出****城

2.5.15 replace()

用于把字符串中的旧字符串替换成新字符串
str.replace(old,nex[, max])
old为被替换的子字符串
nex为新字符串，用于替换old子字符串
max为可选参数，表示替换不超过max次，如果不指定的话，会全部替换

str="梨花风起正清明，游子寻春半出城春春春"
print(str.replace('春','夏',1))    ##最多替换一次
print(str.replace('春','夏',2))    ##最多替换两次
print(str.replace('春','夏'))      ##不指定max，全部替换
##结果
梨花风起正清明，游子寻夏半出城春春春
梨花风起正清明，游子寻夏半出城夏春春
梨花风起正清明，游子寻夏半出城夏夏夏

2.5.16 swapcase()

用于对字符串的大小写进行转换，将字符串的大写转换为小写，小写转换为大写。
str.swapcase()

str = 'lkossSpoussubkwsseradaf'
print(str.swapcase())
##结果
LKOSSsPOUSSUBKWSSERADAF

2.5.17 split()

用于分割字符串
str.split(sep[, maxsplit])
sep为分隔符，默认分隔符为空格
maxsplit为可选参数，表示拆分的次数，默认为-1，表示无限制

str="梨 花*** 风 *起*正 清 明，游子 寻春 半出城"
print(str.split(sep='*',maxsplit=1))
###结果
['梨 花', '** 风 *起*正 清 明，游子 寻春 半出城']
str="梨 花*** 风 *起*正 清 明，游子 寻春 半出城"
print(str.split(sep='*'))
##结果
['梨 花', '', '', ' 风 ', '起', '正 清 明，游子 寻春 半出城']

2.5.18 isalnum ()

用于检测字符串是否由字母和数字组成
str.isalnum ()
如果字符串中至少有一个字符并且所有字符都是字母或数字，就返回True，否则就返回False。

str1 = 'lkossSpoussubkwsseradaf'
str2 = 'lkossSpoussu121354bkwsseradaf'
str3 = 'lkossSpoussu   12bkwsseradaf'
str4 = 'lkossSpoussubkwsseradaf,游子寻春半出城'
print(str1.isalnum())
print(str2.isalnum())
print(str3.isalnum())
print(str4.isalnum())
##结果
True
True
False
False

2.5.19 isalpha()

用于检测字符串中是否只有字母或汉字组成，如果字符串中至少有一个字符并且所有的字符都是字母或汉字，就返回True，否则，就返回False

str1 = 'lkossSpoussubkwsseradaf'
str2 = 'lkossSpoussu121354bkwsseradaf'
str3 = 'lkossSpoussu   12bkwsseradaf'
str4 = 'lkossSpoussubkwsseradaf游子寻春半出城'
str5 = 'lkossSpoussubkwsseradaf,游子寻春半出城'
print(str1.isalpha())
print(str2.isalpha())
print(str3.isalpha())
print(str4.isalpha())
print(str5.isalpha())
##结果
True
False
False
True
False

2.5.20 isdigit()

用于检测字符串是否只由数字组成。如果字符串中只包含数字，就返回True，否则就返回False。
str.isdigit()

str1 = 'lkossSpoussubkwsseradaf'
str2 = 'lkossSpoussu121354bkwsseradaf'
str3 = '123456'
str4 = '123  456'
print(str1.isdigit())
print(str2.isdigit())
print(str3.isdigit())
print(str4.isdigit())

2.5.21 isupper()

用于判断字符串中字符是否全大写字母
str.isupper()

str1='LLLHHHH'
str2='lkossSpoussubkwsseradaf'
print(str1.isupper())
print(str2.isupper())
##结果
True
False

2.5.22 islower()

用于判断字符串中字符是否全小写字母
str.islower()

str1='klooooug'
str2='lkossSpoussubkwsseradaf'
print(str1.islower())
print(str2.islower())
##结果
True
False

2.5.23 format()

用于格式化输出字符串

print('{} {} {}'.format('aaron',18,'teacher'))        ##不指定位置
print('{1} {0} {1}'.format('aaron',18,'teacher'))    ##指定位置        
print('{name} {age} {job}'.format(job='teacher',name='aaron',age=18))
##结果
aaron 18 teacher
18 aaron 18
aaron 18 teacher

数字格式化
^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制。

2.6 字符串的转义字符

Python的转义字符是由一个反斜杠（\）与一个字符组成的。

##换行符
str="梨花风起正清明，\n游子寻春半出城"
print(str)
##结果
梨花风起正清明，
游子寻春半出城
##双引号
str="你说：\"万事胜意\"。"
print(str)
##结果
你说："万事胜意"。
##各进制的ASCII码
print("\x48")
#结果
H
#加入反斜杠
print(r"\万事胜意")
print(R"\万事胜意")
##结果
\万事胜意
\万事胜意

三、列表的基本操作

列表是一种可变序列数据类型。

3.1 列表对象的特性

1.列表将数据元素放在一对方括号（[]）之间，并使用逗号作为数据元素的分割。
2.一个列表中的数据元素可以是基本数据类型，也可以是组合数据类型或自定义数据类型的数据。
3.访问列表中对象，可以使用索引，列表中的序号是从0开始的
4.列表是可以嵌套的，如果要读取列表对象中的另一个列表，可以使用另一个中括号（[]）来做索引。
5.可以用 in 来判断一个元素是否存在于列表中

b=[12,49,"lhuan"]
a = [12,"农夫山泉","lll",1.23,5+9j,b]
print(a[0])
print(a[-1])
print( 9 in  a)
print( 12 in  a)
##结果
12
[12, 49, 'lhuan']
False
True

3.2 创建列表

3.2.1 通过使用方括号（[]）

通过使用方括号（[]），并且把方括号内每一个列表元素用逗号分开进行创建。

3.2.2 使用list() 函数进行创建

3.2.3 列表推导式

[<表达式> for <变量> in <序列>]

# 方式一：（常用）
l1 = [1, 2, '太白']
# 方式二：（不常用）
l1 = list()  # 空列表
# l1 = list(iterable)  # 可迭代对象
l1 = list('123')
print(l1)  # ['1', '2', '3']
# 方式三：列表推导式
l1 = [i for i in range(1,5)]
print(l1)  # [1, 2, 3, 4]
list1=[x*x for  x in  range(1,10)]
print(list1)
[1, 4, 9, 16, 25, 36, 49, 64, 81]
list2=[i for i in range(1,10) if i%2==0]
print(list2)
[2, 4, 6, 8]

3.2 访问列表

列表是一个有序序列，可以通过访问序号访问列表中的列表元素。
列表的序号是一个整数，可以从正向或逆向访问列表。

可以通过使用索引号访问列表中的某些列表元素 <列表名> [<索引>]

l1 = ['a', 'b', '中国', 3, 666]
print(l1[0])  # 'a'                             ##访问列表的第一个元素
print(l1[-1])  # 666                             ##访问列表的最后一个元素
print(l1[1:3])  # ['b', '中国']                  ##访问列表正向索引序列从1到3（不包括）的数据元素
print(l1[:-1])  # ['a', 'b', '中国', 3]          ##访问列表从开始到逆序所有-1的元素，也就是所有的元素 
print(l1[2:])    #['中国', 3, 666]                   ##访问列表从正向索引2到最后的元素
print(l1[::2])  # ['a', '中国', 666]             ##访问列表步长为2的元素
print(l1[::-1])  # [666, 3, '中国', 'b', 'a']    ##访问列表步长为-1的元素

如果访问的列表元素也是由列表构成的，可以构成了类似矩阵的二维结构，访问二维列表的格式
<列表名> [<索引1>][<索引2>]
索引1是二维列表的元素索引号，索引2是二维列表中索引1指向的列表元素中的元素索引号

l1 = ['a', 'b', '中国', 3, 666]
l2 = ['x', 'y', 'mac', 8, 999]
l3 = [1,2,3,4,5]
list=[l1,l2,l3]
print(list[1][3])  #8 访问list列表中索引号为1的列表元素，即列表l2，访问列表l2中索引号为3的元素
print(list[0][0])  #a 访问list列表中索引号为0的列表元素，即列表l1，访问列表l2中索引号为0的元素

遍历二维列表

l1=['1','lars','boy','21']
l2=['2','gyon','boy','21']
l3=['3','ccy','boy','21']
l4=['4','mj','boy','31']
list=[l1,l2,l3,l4]
print(list)
for i in range(len(list)):
    for j in  range(len(list[i])):
        print(list[i][j],end=" ")
##结果
[['1', 'lars', 'boy', '21'], ['2', 'gyon', 'boy', '21'], ['3', 'ccy', 'boy', '21'], ['4', 'mj', 'boy', '31']]
1 lars boy 21 2 gyon boy 21 3 ccy boy 21 4 mj boy 31

列表也可以像变量之间的赋值一个，将一个列表的值赋给另一个列表，但是和基本变量赋值不同的是，列表的赋值只是将实际数据的地址引用进行了赋值，而不是将实际数据赋值一份给新的列表。

a = 100         
b = a                 #将b赋值给a
print(id(a))
print(id(b))
a = 200               #改变a的值
print(b)
print(id(a))
print(id(b))
140715831885168
140715831885168
100
140715831888368
140715831885168
l1=['1','lars','boy','21']
l2=l1                    #将l1赋值给l2
l2[0]=9                 #改变l2的某些元素值
l1[3]=8                 #改变l1的某些元素值
print(l1)
print(l2)
print(id(l1))
print(id(l2))
[9, 'lars', 'boy', 8]
[9, 'lars', 'boy', 8]
2017456443912
2017456443912

3.3 更新列表

3.3.1 修改列表元素值

修改列表元素值可以采用赋值语句
<列表名> [<索引>] = <值>
列表名为一个已经存在的列表
索引为该列表的正向或逆向索引序号，当索引不存在的时候，会提示用户“索引超出范围”错误。
值为任意数据值

# 按照索引修改列表中的一个列表元素
l = ['中国', 'jerry', 'tom', '女神']
l[0] = '男神'
print(l) # ['男神', 'jerry', 'tom', '女神']
# 按照切片改值(迭代着增加)，修改列表中的多个元素
l = ['中国', 'jerry', 'tom', '女神']
l[1:3] = 'abcdefg'   
# 顾前不顾后
## 当Index是一个范围的时候，值也需要是一个范围
## 当列表序号范围和赋值列表长度不相等的时候，就可以增加或删除元素
print(l) # ['中国', 'a', 'b', 'c', 'd', 'e', 'f', 'g', '女神'] 
# 按照切片(步长)改值(必须一一对应)
l = ['中国', 'jerry', 'tom', '女神']
l[::2] = '对应'
print(l) # ['对', 'jerry', '应', '女神']
## 用一个列表元素替换选定的3个列表元素
l = ['中国', 'jerry', 'tom', '女神']
l[-2:]=['lhuan']
print(l)  ##['中国', 'jerry', 'lhuan']

3.3.2 添加列表元素值

可以在赋值的时候添加元素，还有专门的函数用于对列表添加元素。

## append
l = [1, 2, 'a']
l.append(666)
print(l) # [1, 2, 'a', 666]
## insert
l = [1, 2, 'a']
l.insert(1,'中国')
print(l) # [1, '中国', 2, 'a']
##  extend
l = [1, 2, 'a']
l.extend('中国a')
print(l) 
#结果
[1, 2, 'a', '中', '国', 'a']
l.extend('lhuan')
print(l)
[1, 2, 'a', 'l', 'h', 'u', 'a', 'n']

3.3.3 删除列表元素值

# pop  通过索引删除列表中对应的元素，该方法有返回值，返回值为删除的元素
l = ['中国', 'jerry', 'tom', '女神']
ret = l.pop(1)
print(ret,l) # jerry ['中国', 'tom', '女神']
# remove  通过元素删除列表中该元素
l = ['中国', 'jerry', 'tom', '女神']
l.remove('jerry')
print(l) # ['中国', 'tom', '女神']
# clear 清空列表
l = ['中国', 'jerry', 'tom', '女神']
l.clear()
print(l)# []  
# del
#按照索引删除该元素
l = ['中国', 'jerry', 'tom', '女神']
del l[2]
print(l) # ['中国', 'jerry', '女神']
# 切片删除该元素
l = ['中国', 'jerry', 'tom', '女神']
del l[1:]    # 删除索引为1和后面的元素
print(l)  # ['中国']  
# 切片(步长)删除该元素
l = ['中国', 'jerry', 'tom', '女神']
del l[::2]
print(l) # ['jerry', '女神']

3.4 其他操作

3.4.1 index()

将列表对象中元素值为value的索引值返回,返回的是匹配到的第一个元素的索引值。
<列表名>index(<值>)

a = ["q", "w", "q", "r", "t", "y",5]
print(a.index('q'))

3.4.2 count()

统计某个元素在列表中出现的次数
<列表名>.count(<值>)

 a = ["q","w","q","r","t","y"]    
 print(a.count("q"))    ##计算q在列表a中出现的次数
##结果 2

3.4.3 sort() sorted()

将列表中的元素依照大小顺序排列，顺序，由小到大
<列表名>.sort()
sorted(<列表名>)

b = [1,3,5,89,99,56,45]
ret =b.sort() 
print(b.sort())       None 没有返回值，所以只能打印a  从小到大
print(b)
b = [1,3,5,89,99,56,45]
print(sorted(b))
##结果都是
[1, 3, 5, 45, 56, 89, 99]

3.4.4 reserve() reserved()

将列表对象中的元素颠倒顺序
<列表名>.reserve()
reserved(<列表名>)

b = [1,3,5,89,99,56,45]
ret = b.reverse()  
print(b)
print(b.reverse())       None 没有返回值，只能打印b 
##结果
[45, 56, 99, 89, 5, 3, 1]

3.4.5 len()

返回列表的长度
len(<列表名>)

a = ["q", "w", "q", "r", "t", "y"]
print(len(a))      ##计算列表a的长度
#结果为6

3.4.6 mx()

返回列表中元素的最大值，要求列表中的元素类型相同，否则会出错
max(<列表名>)

a = ["q", "w", "q", "r", "t", "y"]
print(max(a))            ##获取列表a中的最大值
b = [1,3,5,89,99,56,45]
print(max(b))            ##获取列表b中的最大值
#结果
y
99
a = ["q", "w", "q", "r", "t", "y",5]         ##列表中的元素类型不同，求最大值，报错
print(min(a))
Traceback (most recent call last):
  File "D:/pythontest/geshu.py", line 99, in <module>
    print(min(a))
TypeError: '<' not supported between instances of 'int' and 'str'

3.4.7 min()

返回列表中元素的最小值，要求列表中的元素类型相同
min(<列表名>)

a = ["q", "w", "q", "r", "t", "y"]
print(min(a))                 ##获取列表a中的最小值
b = [1,3,5,89,99,56,45]
print(min(b))                 ##获取列表b中的最小值
##结果
q
1

3.4.8 dir()

显示内置的方法列表
dir([])

print(dir([]))
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

3.4.9 copy()

用于复制列表

a = ["q", "w", "q", "r", "t", "y",5]
b = a.copy()
print(b)             
print(b==a)
#结果
['q', 'w', 'q', 'r', 't', 'y', 5]
True

3.4.10 sum()

如果列表中所有的元素都是数字，返回列表元素之和

b = [1,3,5,89,99,56,45]
print(sum(b))
##结果
298

3.4.11 cmp()

cmp(<列表名1>,<列表名2>)
比较两个列表中的元素，如果列表1中的元素比列表2中对应的元素大，则函数返回1；如果小，则函数返回-1；如果列表1和列表2中所有元素相等，则返回0

3.4.12 列表的操作符 +

+号用于组合列表

a = [4,6,33,78,88,56,45]
b = [1,3,5,89,99,56,45]
c = a +b
print(c)
[4, 6, 33, 78, 88, 56, 45, 1, 3, 5, 89, 99, 56, 45]

3.4.13 列表的操作符 *

号用于重复列表
n<列表名> 或 <列表名>*n

a = ["**"]
b = a*10
print(b)
##结果
['**', '**', '**', '**', '**', '**', '**', '**', '**', '**']

四、元组的基本操作

元素是不可变序列。

4.1 元组对象的特性

元组和列表相似，但是元组的元素的不可变的，元组一旦创建，不可以修改其元素，也不能添加或删除元素。
使用一对小括号() 创建元组，在小括号内用逗号分割元素。
一个元组中的数据元素可以是基本数据类型，也可以是组合数据类型或自定义类型的数据。

4.2 创建元组

1.通过小括号()，并且把小括号内每一个元组元素用逗号分开进行创建
2.使用tuple() 函数进行创建
3.生成器推导式
(<表达式> for <变量> in <序列>])
这种推导式的结果是一个生成器对象，不是元组。
生成器对象可以使用next()函数依次访问其中的元素，也可以使用list()函数或者tuple()函数转化成列表或者元组后使用。

##通过小括号创建
tup1=(1,5,6,'lhuan','MJ')
print(tup1)
print(type(tup1))        ##查看tup1的数据类型
(1, 5, 6, 'lhuan', 'MJ')
<class 'tuple'>
##使用tuple()函数创建
tup1 =tuple()             ##产生一个空元组，等价于tup1=()
print(tup1)
##结果
()
tup1 =tuple(range(1,45,5))   ##从1到45，步长为5创建一个元组
print(tup1)
(1, 6, 11, 16, 21, 26, 31, 36, 41)
##使用生成器推导式
g = (x ** 2 for x in range(1,10))         #使用推导式产生生成器g
print(g)                                  #输出g
print(next(g))                            #使用next函数访问生成器中的第一个元素
print(next(g))                            #使用next函数访问生成器中的下一个元素
###结果
<generator object <genexpr> at 0x0000025BD0CE87C8>
1
4
##将生成器对象转换成元组对象
g = (x ** 2 for x in range(1,10))
tuple1=tuple(g)
print(tuple1)
print(type(tuple1))
###结果
(1, 4, 9, 16, 25, 36, 49, 64, 81)
<class 'tuple'>

4.3 访问元组

使用索引的方式

tup1=(1,5,6,'lhuan','MJ') 
print(tup1[1])                 ##访问索引值为1的元素
print(tup1[-1])                ##访问元组中逆向索引为-1的元素
print(tup1[2:4])               ##访问元组中正向索引从2到4（不包括4)的元素
##结果
5
MJ
(6, 'lhuan')

如果一个元组中的元素是也是由列表和元组等构成的，也可以构成二维结构。
采用和访问二维列表类似的方式访问二维元组。
如果元组元素是列表等可变序列，那么这个列表内的元素的可变的。

tup1=(1,5,6,'lhuan','MJ')
list1=[1,5,9,0,2]
list2=[3,56,78,90]
d=(tup1,list1,list2) 
print(d)
print(d[1][1])                
d[1][2]=99                  ##修改列表中元素的值
print(d[1])
##结果
((1, 5, 6, 'lhuan', 'MJ'), [1, 5, 9, 0, 2], [3, 56, 78, 90])
5
[1, 5, 99, 0, 2]

4.4 删除整个元组

使用del语句可以删除整个元组

tup1=(1,5,6,'lhuan','MJ')
del tup1
print(tup1)
##结果报错
    print(tup1)
NameError: name 'tup1' is not defined

4.5 其他操作

4.5.1 元组的操作符 +

用于组合元组

tup1=(1,5,6,'lhuan','MJ')
tup2=(55,'lk','pp','ii')
c = tup1+ tup2
print(c)
##结果
(1, 5, 6, 'lhuan', 'MJ', 55, 'lk', 'pp', 'ii')

4.5.2 元组的操作符 *

用于重复元组

tup1=(1,5,6,'lhuan','MJ')
c = tup1*2
print(c)
##结果
(1, 5, 6, 'lhuan', 'MJ', 1, 5, 6, 'lhuan', 'MJ')

4.5.3 len()

返回元组的长度

tup1=(1,5,6,'lhuan','MJ')
print(len(tup1))
##结果
5

4.5.4 max()

返回元组中元素的最大值，元素需要是同一种数据类型

tup3=(1,55,66,56,25,88)
print(max(tup3))
##结果
88
#如果不是同一种数据类型，会报下面的错
tup1=(1,5,6,'lhuan','MJ')
print(max(tup1))
##结果
    print(max(tup1))
TypeError: '>' not supported between instances of 'str' and 'int'

4.5.5 min()

返回元组中元素的最小值，元素需要是同一种数据类型

tup3=(1,55,66,56,25,88)
print(min(tup3))
##结果
1

4.5.6 sum()

如果元组中所有的元素都是数字，返回元组元素之和

tup3=(1,55,66,56,25,88)
print(sum(tup3))
##结果
291

五、字典的基本操作

字典是一种映射型的组合数据结构，由键值对组成。

5.1 字典对象的特性

在一个字典结构中，一个键只能对应一个值，但是多个键可以对应相同的值
字典类型和序列类型的区别在于存储和访问方式的不同。
序列类型通常通过索引序号访问，而且只采用整数作为索引序号
字典可以用任意不可变类型（eg：数字、字符串、元组等）作为值的索引序号，也就是键。
字典将键值对放在一对大括号（{}）之间，并用逗号作为分割，每个键值对内部使用冒号（:）分割
Key: 不可变（可哈希）的数据类型.并且键是唯一的，不重复的。
Value:任意数据(int，str，bool，tuple，list，dict，set)，包括后面要学的实例对象等。
字典也有缺点：他的缺点就是内存消耗巨大。
简言之字典是用空间换时间，查找速度不会因为key的增加而变慢

在Python3.5版本（包括此版本）之前，字典是无序的。
在Python3.6版本之后，字典会按照初建字典时的顺序排列(即第一次插入数据的顺序排序)。

5.2 创建字典

5.2.1 通过赋值语句创建字典

dic ={}                                 ##创建空列表
dic1 = {'one': 1, 'two': 2, 'three': 3} ##通过赋值语句创建列表
print(dic)
print(dic1)
##结果
{}
{'one': 1, 'two': 2, 'three': 3}

5.2.2 通过dict() 函数创建字典

使用dict()函数将键值对形式的列表创建为字典

dic1 = dict([['one',1], ['two',2] ,['three', 3]])
print(dic1)
##结果
{'one': 1, 'two': 2, 'three': 3}

使用dict()函数将键值对形式的元组创建为字典

dic1 = dict((('one',1), ('two',2) ,('three', 3)))
print(dic1)
##结果
{'one': 1, 'two': 2, 'three': 3}

在dict()函数中调用zip函数，可以将多个序列作为参数，返回由元组构成的列表。

dict=dict(zip(['one','two','three','four'],[1,2,3,4]))
print(dict)
##结果
{'one': 1, 'two': 2, 'three': 3, 'four': 4}

5.2.3 通过fromkeys()函数创建字典

调用fromkeys()函数可以创建值都相同的字典，可以将一个序列作为键，然后指定一个统一的值。
嗲用fromkeys()函数也可以不指定值，创建的字典默认为None空值。

dict={}.fromkeys(['lars','gyon','MJ','CCY'],'BB')   ##创建值相同的字典
print(dict)
##结果
{'lars': 'BB', 'gyon': 'BB', 'MJ': 'BB', 'CCY': 'BB'}
dict={}.fromkeys(['lars','gyon','MJ','CCY'])         ##创建的字典默认都为None空值
print(dict)
##结果
{'lars': None, 'gyon': None, 'MJ': None, 'CCY': None}

5.2.4 通过推导式创建字典

{<键>:<值> for <变量> in <序列>}

dict = {n:n**2 for n in range(0,4)}
print(dict)
##结果
{0: 0, 1: 1, 2: 4, 3: 9}

5.3 访问字典

5.3.1 通过键访问值

字典的键值对是一种映射关系，根据键可以访问到值，访问字典中键值对的值可以通过方括号并指定键的方式进行访问。如果键不存在，就会报错。

dict = {0: 0, 1: 1, 2: 4, 3: 9}
print(dict[0])
##结果
0
dict = {0: 0, 1: 1, 2: 4, 3: 9}
print(dict[5])
##结果
   print(dict[5])
KeyError: 5

字典也可以使用get() 方法通过键访问对应的值，当键存在的时候，返回该键对应的值，而键不存在的时候也不会报错，而是返回指定值。
get(k[,d])
k是字典的索引值，d是索引值的默认值。如果k存在，就返回其的值，如果k不存在，就返回d。

dict = {0: 0, 1: 1, 2: 4, 3: 9}
print(dict.get(2))
print(dict.get(5))
##结果
4
None
dict1={'lhuan':100,'lj':99,'mj':88,'ccy':100}
print(dict1.get('lj','lll'))
#结果
99
dict1={'lhuan':100,'lj':99,'mj':88,'ccy':100}
print(dict1.get('mmm','lll'))
#结果
lll

5.3.2 访问字典中的所有键值对、所有键、所有值

通过调用items() 方法可以返回所有的键值对
通过调用keys() 方法可以返回所有的键
通过调用value() 方法可以返回所有的值

dict = {0: 0, 1: 1, 2: 4, 3: 9}
print(dict.items())             ##获取所有的键值对
print(dict.keys())              ##获取所有的键
print(dict.values())            ##获取所有的值
##结果
dict_items([(0, 0), (1, 1), (2, 4), (3, 9)])
dict_keys([0, 1, 2, 3])
dict_values([0, 1, 4, 9])

5.3.3 遍历字典

一般通过for语句循环可以遍历字典的元素

dic = {"age":18, "name":"aaron", 'sex':'male'}
for i in dic.items():
    # 将键和值作为元祖列出
    print(i)
 ##结果
('age', 18)
('name', 'aaron')
('sex', 'male')
for key,value in dic.items():
    print(key,value)
 ##结果
age 18
name aaron
sex male
for i in dic:
    # 只是迭代键
    print(i)
 ##结果
age
name
sex
for i in  dic.values():   ##指定迭代字典的值
    print(i)    
##结果
18
aaron
male

5.4 更新字典

5.4.1 添加元素

通过赋值语句可以向字典添加键值对元素

dict1={'lhuan':100,'lj':99,'mj':88,'ccy':100}
dict1['daidai']=60     ##如果键不是字典的原有键，就会添加一个新的键值对
dict1['lhuan']=23      ##如果键是字典的原有键，则更新该键的值，而不添加新的元素
print(dict1)
##结果
{'lhuan': 100, 'lj': 99, 'mj': 88, 'ccy': 100, 'daidai': 60}
{'lhuan': 23, 'lj': 99, 'mj': 88, 'ccy': 100, 'daidai': 60}

使用setdefault()函数向字典添加元素
<字典名>.setdefaut(<键>,<值>)
如果第一个参数不是字典的原有键，则把第二个参数作为该键的值构成一个新的键值对添加到字典中，并返回函数结果就是该键值对的值
如果第一个参数是字典的原有键，则返回改键的值。原来的字典保持不变
如果第一个参数不是字典的原有键，又省略了第二个参数，则向字典中添加 “该键:None”元素

1.
dict1={'lhuan':100,'lj':99,'mj':88,'ccy':100}
dict1.setdefault('daiai',60)   
print(dict1)
##结果
{'lhuan': 100, 'lj': 99, 'mj': 88, 'ccy': 100, 'daiai': 60}
2.
dict1={'lhuan':100,'lj':99,'mj':88,'ccy':100}
dict1.setdefault('lj',60)
print(dict1)
##结果
{'lhuan': 100, 'lj': 99, 'mj': 88, 'ccy': 100}
3.
dict1={'lhuan':100,'lj':99,'mj':88,'ccy':100}
dict1.setdefault('lm')
print(dict1)
##结果
{'lhuan': 100, 'lj': 99, 'mj': 88, 'ccy': 100, 'lm': None}

5.4.2 合并字典

使用update() 函数可以将一个字典中的元素添加到当前字典中，如果两个字典的键由重名，就会用另一个字典中的值对当前字典进行更新。

dict1={'lhuan':100,'lj':99,'mj':88,'ccy':100}
dict2={'bcw':100,'xxx':00,'lars':55,'gyon':95}
dict1.update(dict2)
print(dict1)
##结果
{'lhuan': 100, 'lj': 99, 'mj': 88, 'ccy': 100, 'bcw': 100, 'xxx': 0, 'lars': 55, 'gyon': 95}
dict1={'lhuan':100,'lj':99,'mj':88,'ccy':100}
dict3={'lhuan':55}
dict1.update(dict3)             ##会更新dict1
print(dict1)
##结果
{'lhuan': 55, 'lj': 99, 'mj': 88, 'ccy': 100}

5.4.3 修改元素的值

修改字典中的元素的值可以用赋值语句实现

dict1={'lhuan':100,'lj':99,'mj':88,'ccy':100}
dict1['lj']=85
print(dict1)
##结果
{'lhuan': 100, 'lj': 85, 'mj': 88, 'ccy': 100}

5.4.4 删除元素

删除字典中的元素可以用del() 函数、del语句、pop()函数、popitem() 函数或者clear()函数实现。
使用del函数删除指定键的字典元素

dict1={'lhuan':100,'lj':99,'mj':88,'ccy':100}
del(dict1['lhuan'])
print(dict1)
#结果
{'lj': 99, 'mj': 88, 'ccy': 100}

使用del语句可以删除指定键的字典元素，也可以删除整个字典

dict1={'lhuan':100,'lj':99,'mj':88,'ccy':100}
del dict1['lhuan']       ##删除指定键的字典元素
print(dict1)
##结果
{'lj': 99, 'mj': 88, 'ccy': 100}
dict1={'lhuan':100,'lj':99,'mj':88,'ccy':100}
del dict1                ##删除整个字典
print(dict1)
##结果
    print(dict1)
NameError: name 'dict1' is not defined
    由于字典被删除，会报错

使用pop函数删除指定键的字典元素，如果该键不存在就返回第二个参数的值，如果键存在，就返回该键值，同时删除

dict1={'lhuan':100,'lj':99,'mj':88,'ccy':100}
dict1.pop('lj','66')
print(dict1)
##结果
{'lhuan': 100, 'mj': 88, 'ccy': 100}
dict1={'lhuan':100,'lj':99,'mj':88,'ccy':100}
dict1.pop('56','66')
print(dict1)
##结果
{'lhuan': 100, 'lj': 99, 'mj': 88, 'ccy': 100}

使用poptiem函数可以随机删除字典中的一个元素，并返回该元素的值。当字典为空的时候，使用popitem函数的时候会返回错误。

dict1={'lhuan':100,'lj':99,'mj':88,'ccy':100}
dict1.popitem()
print(dict1)
##结果
{'lhuan': 100, 'lj': 99, 'mj': 88}
dict3={}
dict3.popitem()
print(dict3)
##结果
    dict3.popitem()
KeyError: 'popitem(): dictionary is empty'

使用clear() 函数，清除字典中的所有元素

dict1={'lhuan':100,'lj':99,'mj':88,'ccy':100}
dict1.clear()
print(dict1)
##结果
{}