python3“组”的概念与定义（4）

组的概念：在python中表示组的方式有很多种，并不是只有一种

4.1 列表的定义
列表用[]定义的，元素间用“，”隔开
如用列表表示1、2、3、4、5、6
[1,2,3,4,5,6]

>>> type([1,2,3,4,5,6])
<class 'list'>

列表的特性
1.列表内部元素的类型不是固定的

>>> type(['hello',1,2,3,True,False])
<class 'list'>                       //列表中可以有不同的数据类型

2.列表内部可以嵌套列表

>>> type([[1,2],[3,4],[True,False])
<class 'list'>                     //列表中嵌套列表， 其他语言中叫二维数组，python中叫做嵌套列表    

4.2 列表的基本操作
1.访问列表中的某个元素：

用单一数字索引访问列表得到的是一个字符串

>>> ["1","2",3,4][0]
'1'                //得到的是列表中的一个元素

用：方式得到的是一个列表，哪怕列表只有一个元素

>>> ["1","2",3,4][0:2]
['1', '2']
>>> ["1","2",3,4][-1:]
[4]                  //得到的是一个新的列表

2.更改列表中某个元素的值

列表的相加：

>>> [1,2,3,4] + [5,6,7,8]
[1, 2, 3, 4, 5, 6, 7, 8]

列表的相乘（支持列表数字，不支持列表列表）：

>>> [1,2,3,4] * 3
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]

3.列表不支持减法

4.3 元组
元组是不可变的
元组是用()定义的，元素间用，隔开

>>> (1,-1,True)
(1, -1, True)
>>> type((1,2,3))
<class 'tuple'>
>>> type((1))
<class 'int'>

1.元组特性
1）元组内部元素的类型不是固定的

>>> (1,'1',True)
(1, '1', True)

2）元组内部元素的访问（同列表、字符串）

>>> (1,2,3,4)[0]
1
>>> (1,2,3,4)[0:2]
    (1, 2)

2.元组的拼接
1）相加

>>> (1,2,3)+(4,5,6)
(1, 2, 3, 4, 5, 6)

2）相乘

>>> (1,2,3)*3
(1, 2, 3, 1, 2, 3, 1, 2, 3)

小知识点补充：
1.python规定，若元组中只有一个元素，就默认为其类型是括号内元素的类型，而非元组

>>> type((2))
<class 'int'>
>>> type(('hello'))
<class 'str'>

2.那如何定义只有一个元素的元组？
答：在元素后加一个"，"假装后面还有其他元素

>>> (1,)
(1,)
>>> type((1,))
<class 'tuple'>

3.如果元组换成列表，元素也只有一个，那么类型是list

>>> type([1])
<class 'list'>

其访问等行为与列表保持一致
4. 元组和列表的区别：列表可变，元组不可变

4.4 序列
因为每个元素都有顺序和序号，所以叫序列
int、float、bool、str、list、tuple
str、list、tuple都可以看作序列，序列共有的特性：每个元素都将被分配序号，且都可以切片

>>> type([1])
<class 'list'>
>>> type((1))
<class 'int'>       //小括号既能表示元组也能表示运算优先级的括号，有歧义
>>> type((1,))
<class 'tuple'>    //去除歧义
>>> type(())
<class 'tuple'>    //空元组

1.通过[序号]获取某个元素

>>> 'hello world'[2]
'l'
>>> [1,2,3][2]
3

2.相加&相乘

>>> [1,2,3]+[4,5,6]
[1, 2, 3, 4, 5, 6]
>>> [1,2,3]*3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

3.判断一个序列中是否包含某个元素：in

>>> 3 in [1,2,3,4,5]
True
>>> 10 in [1,2,3]
False

4.判断一个序列中是否不包含某个元素

>>> 3 not in [1,2,3,4,5]
False                  //判断不在序列中用 not in

5.查看列表长度用len()

>>> len([1,2,3,4,5])
5

6.求最大元素用max(),最小值为min()

>>> max([1,2,3,4])
4
>>>  min([1,2,3,4])
1

>>> min('hello world')
' '                    //输出空格
>>> max('hello wordl')
'w'                   //字母取ASCII码大小

补充
1.字母转编码（ascll码）用ord

>>> ord('w')
119         //转换ASCII码
>>> ord(' ')
32

2.切片

>>> [1,2,3,4,5][0:3]
[1, 2, 3]
>>> [1,2,3,4,5][-1:]
[5]

切片目前只用到了两个数字，后续还有三个数字的用法

>>> ['hello wordl'][0:8:2]
[hlow]

4.5 set集合
集合是无序的，序列是有序的
不支持下标索引，不支持切片
集合是用{}定义的，元素间用，隔开

>>> type({1,2,3,4,5,6})
<class 'set'>

1.集合是不重复的

>>> {1,1,2,2,3,3,4,4}
{1, 2, 3, 4}

2.支持长度判断len()

>>> len({1,2,3})
3

3.支持in/not in

>>> 1 in {1,2,3}
True
>>> 1 not in {1,2,3}
False

4.支持求差集、交集、并集的操作

>>> {1,2,3,4,5,6} - {3,4}
{1, 2, 5, 6}                 //差集“-”
>>> {1,2,3,4,5,6} & {3,4}
{3, 4}                       //交集“&”
>>> {1,2,3,4,5,6} | {3,4,7}
    {1, 2, 3, 4, 5, 6, 7}    //并集“|”

5.定义空集set()

>>> type({})
<class 'dict'>    //不是set类型，是空的字典类型
>>> type(set())
<class 'set'>    //是空集

6.校验set()是空集合：

>>> len(set())
0

4.6 dict字典
字典的定义方式：{key1:value1,key2:value2,…}

>>> type({1:1,2:2,3:3})
<class 'dict'>

key-value，最多的操作是通过key找到value
一个字典可以由很多key/value构成，是无序的，和集合set行为很像
字典和Set 的对比：
相同：用{}把元素包裹起来，不同的元素之间用，分隔
不同：每个元素的定义方式不同，set只有一个value值，
字典有value值和key，key和value之间用：隔开

>>> type({'q':'技能一','w':'技能二','e':'技能三','r':'大招'})
<class 'dict'>                            //一个有意义的字典

字典的访问方式：通过Key来访问/得到 value

>>> {'q':'技能一','w':'技能二','e':'技能三','r':'大招'}['q']
'技能一'
dict的特点：字典中不允许存在相同的Key
>>> {'q':'技能一','q':'技能二','e':'技能三','r':'大招'}['q']
'技能二'                      //相同的key会将前面的key取消，所以一个字典内不能有相同的key
>>> {'q':'技能一','q':'技能二','e':'技能三','r':'大招'}
{'q': '技能二', 'e': '技能三', 'r': '大招'}    //若字典中有相同的key，会自动取消前面的key

字典key可以是字符串和数字，且数字1和字符串’1’是两个不同的key

>>> {1:'技能一','1':'技能二','e':'技能三','r':'大招'}
{1: '技能一', '1': '技能二', 'e': '技能三', 'r': '大招'}

value可以取任意数据类型(甚至还能是一个字典)
key必须是不可变的类型 如 int ‘str’
value：可以是任意的数据类型，包括但不限于 str int float list set dict
dict中的value本身还可以是dict字典
用{}定义空字典

>>> type({})
<class 'dict'>

4.7 总结