零基础学Python4——python基础数据类型(列表类型，元组类型，字典类型，bytes类型，set集合类型)

一.列表类型

1.定义：列表是python中最基本也是最常用的数据结构之一。列表中的每个元素都被分配一个数字作为索引，用来表示该元素在列表内所排在的位置。第一个元素是0，第二个为1，以此类推，最后一个为-1。

列表是一个有序可重复的元素组合，可嵌套，迭代，修改，分片，追加，删除，成员判断。从数据结构上来看，python列表是一个可变长度地顺序存储结构，每一个位置存放的都是对象地指针。

2.创建方式：创建一个列表，只要把逗号分隔的不同数据项使用方括号括起来即可。或者使用内置函数list()。

3.访问元素

列表从0开始为它的每一个元素创建下标索引，直到总长度减一。要访问它的某个元素，直接以方括号加下标值的方式即可。注意要确保索引不越界，越界会直接报错。

4.修改元素：直接对元素进行重新赋值。

5.删除元素：使用del语句或者remove()，pop()方法删除指定元素。

6.列表的特殊操作

7.列表的常用函数

# 函数       作用
>>> l1 = [1, 2, 3]
>>> len(l1)   # 返回列表元素个数，也就是获取列表长度 l1.__len__()
3
>>> max(l1)   # 返回列表元素最大值  max(l1)  max(1,2,3,4)
3
>>> min(l1)   # 返回列表元素最小值
1
>>> list('hello')  # 将序列转换为列表
['h', 'e', 'l', 'l', 'o']

>>> s = list((1, "a", "b", 2))
>>> s
[1, 'a', 'b', 2]

>>> max(s)          # 不能混合不同类型进行最大最小求值
Traceback (most recent call last):
  File "<pyshell#20>", line 1, in <module>
    max(s)
TypeError: '>' not supported between instances of 'str' and 'int'

8.排序和反转

>>> li = [1,2,3,4,5,2,1,3,1]
>>> li.reverse()   # 将列表反转 修改本身 *IN PLACE*
>>> li
[1, 3, 1, 2, 5, 4, 3, 2, 1]
>>> li.sort()    # 排序，默认升序 L.sort(key=None, reverse=False)
>>> li
[1, 1, 1, 2, 2, 3, 3, 4, 5]
>>> li.sort(reverse=True) # reverse=True 降序
>>> li
[5, 4, 3, 3, 2, 2, 1, 1, 1]

9.切片(截取）

切片指的是对序列进行截取，选取序列中的某一段。语法为list [start : end : step] ;以冒号分割索引，start代表起点索引，默认为0。end代表结束点索引，默认为结尾。step为步长，默认为1。 且区间为左闭右开的。

如果提供的是负整数下标，则从列表的最后开始往头部查找。例如-1表示最后一个元素，-3表示倒数第三个元素。

>>> l3 = ['a','b','c','d','e','f']
>>> l3[1]       # 取'b'     注意：index默认从0开始
'b'
>>> l3[2]       # 取'c'
'c'
>>> l3[1:3]       # 取['b', 'c']   注意：左闭右开
['b', 'c']
>>> l3[:3]       # 取['a', 'b', 'c']  注意：start不写默认从头开始
['a', 'b', 'c']
>>> l3[2:]       # 取['c', 'd', 'e', 'f'] 注意：end不写默认到最后   
['c', 'd', 'e', 'f']
>>> l3[:]       # 取全部   
['a', 'b', 'c', 'd', 'e', 'f']
>>> l3[::2]       # 取['a', 'c', 'e']  注意：步长为2
['a', 'c', 'e']
>>> l3[::-1]      # 逆序  
['f', 'e', 'd', 'c', 'b', 'a']

10 多维列表（嵌套列表）

>>> a = [[1,2,3],[4,5,6],[7,8,9]]
>>> a[0][1]
2

11.列表的遍历

 

12.列表的常用内置方法

（1）append(obj) 在列表的末尾添加新的对象

（2）count(obj)   统计某个元素在列表中出现的次数

（3）entend(seq)   在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

（4）index(obj)   从列表中找出某个值第一个匹配项的索引

（5）insert(index , obj)    将对象插入列表

（6）pop(obj=list[-1])    移除列表中的一个元素，默认为最后一个，并且可以返回该元素的值

（7）remove(obj)   移除列表中的某个值匹配的第一个匹配项

（8）reverse()    反向列表中的元素

（9）sort([func])   对原列表进行排序，默认为升序

（10）copy()    复制列表

（11）clear()    清空列表，等于del lis[ : ]

>>> li = [1,2,3]
>>> li.append([3,3])
>>> li
[1, 2, 3, [3, 3]]

>>> li = [1,2,3,[3,3]]
>>> li.count(3) 
1

>>> li = [1,2,3]
>>> li.extend([4,5])   
>>> li
[1, 2, 3, 4, 5]

>>> li = [1,2,3,2,3]
>>> li.index(3) 
2

>>> li = ['happy','year']
>>> li.insert(1,'new') 
>>> li
['happy', 'new', 'year']

>>> li = [1,2,3]
>>> li.clear() 
>>> li
[]

注意：其中的类似append，insert，remove，会严格修改列表本身，并且没有返回值（严格地说返回的是None）

二.元组类型

1.定义：用圆括号括起来的就是元组。

元组也是序列结构，但是是一种不可变序列，你可以简单地理解为内容不可变的列表。除了在内部元素不可修改的区别外，元组和列表的用法差不多。

2.元组创建：

3.元组与列表相同的操作

（1）使用方括号加下表访问元素

（2）切片（形成新元组对象）

（3）tuple.count() 和 tuple.index()

列表中还有 list.reverse() 与 list.sort() ，但是元组没有，但是要实现反转与排序可以使用python的内置函数：reversed() 和 sorted() 。

>>> tu1
(1, 2, 3, 4, 5, 5, 5, 4)
>>> reversed(tu1)
<reversed object at 0x000001B9FE543C88>
>>> tuple(reversed(tu1))
(4, 5, 5, 5, 4, 3, 2, 1)

>>> tu = (1,2,3,5,4,3)
>>> sorted(tu)   # 升序
[1, 2, 3, 3, 4, 5]

4.元组中不允许的操作

（1）不允许修改，新增元素；一旦想改变该元组，就只能重新开辟一块内存，创建新的数组。

 注意：元组只保证它的一级子目录不可变，对于嵌套的元素内部，不保证不可变。

>>> tup = (1,2,3,['name',5])   # 将'name'改为4
>>> tup[3][0] = 4
>>> tup
(1, 2, 3, [4, 5])

>>> tup1 = (1,2,3,('name',5))  # 将'name'改为4
>>> tup1[3][0] = 4
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

(2)不允许删除某个元素（但可以删除整个元组）

实际上，所有会对元组内部元素发生修改动作的方法元组都没有。例如，元组没有remove，append，pop等方法。

5.列表与元组的转换

（1）元组转为列表

>>> tu = (1,2,3)
>>> list(tu)
[1, 2, 3]

 （2)列表转为元组

>>> li = [1,2,3]
>>> tuple(li)
(1, 2, 3)

三.字典类型 

1.定义：python字典数据类型，是基于hash散列算法实现的，采用键值对的形式，根据key的值计算value的地址，具有非常快的查取和插入速度。但它是无序的，包含的元素个数不限，值的类型也可以是其它任何数据类型！

字典的key必须是不可变的对象，例如整数，字符串，bytes和元组，但使用最多的还是字符串。列表，字典，集合等就不可以作为key。同时，同一个字典内key必须是唯一的，但值则不必。

简而言之，字典可精确描述为不定长，可变，无序，散列的集合类型。

字典的每个键值对用冒号（:）分割，每个对之间用逗号（,）分割，整个字典包括在花括号（{}）内。例如：

d = {key1 : value1, key2 : value2 }

2.创建字典

（1）创建空字典

 （2）创建字典的三种方式

 

3.访问字典

字典是集合类型，不是序列类型，因此没有索引下标的概念，更没有切片的说法。但是，与list类似，字典采用把相应的键放入方括号内获取对应的值的方式取值。

4.增加和修改

增加就是往字典插入新的键值对，修改就是给原有的键赋予新的值。由于一个key只能对应一个值，所以，多次对一个key赋值，后面的值会把前面的值冲掉。

5.删除字典元素，清空字典，和删除字典

使用 del 关键字删除字典元素或者字典本身，使用字典的 clear() 方法清空字典。

6.字典的常用方法

（1）get(key) 返回指定键的值，如果值不在字典中，则返回default，None值。

（2）items() 以列表返回可遍历的（键，值）元组对。

（3）keys() 以列表返回字典的所有的键。

（4）values() 以列表返回字典的所有的值。

>>> dic1 = {'name':'qianan','age':18}
>>> dic1.get('name')  
'qianan'
>>> dic1.get('gender') # 当key:value不存在时,返回None

>>> dic1.items()
dict_items([('name', 'qianan'), ('age', 18)])
>>> for k,v in dic1.items():
...     print(k,v)
...
name qianan
age 18

>>> dic1.keys()
dict_keys(['name', 'age'])
>>> dic1.values()
dict_values(['qianan', 18])

四.Bytes字节类型

1.定义：在python3之后，字符串和bytes类型彻底分开了。字符串是以字符为单位进行处理的，bytes类型是以字节为单位处理的。

bytes数据类型在所有的操作和使用甚至内置方法上和字符串数据类型基本一样，也是不可变的序列对象。

python3中，bytes通常用于网络数据传输，二进制图片和文件的保存等等。

2.bytes创建

可以通过调用 bytes() 生成bytes实例，其值形式为 b‘xxxxx’ ，对于同一个字符串如果采用不同的编码方式生成bytes对象，就会形成不同的值。

3.bytes类型常用转换

（1）字节转为字符串使用 decode() 方法

（2）字符串转为字节使用 encode() 方法 

五.Set集合类型

1.定义：set集合是一个无序不重复元素的集合，基本功能包括关系测试和消除重复的元素。

集合类型的核心在于自动去重。

2.创建集合

集合使用大括号（{}）框定元素，并以逗号进行分割。但是注意：如果要创建一个空集合，必须使用 set() 而不是 {} ，因为后者创建的是一个空字典。

 

 

3.集合添加元素

通过 add(key) 方法可以添加元素到set中，可以重复添加，但不会有效果：

>>> s = set([1,2,3,1,2,3,4])
>>> s
{1, 2, 3, 4}
>>> s.add(3)   # 重复添加,自动去重
>>> s
{1, 2, 3, 4}
>>> s.add(6)   # 添加成功
>>> s
{1, 2, 3, 4, 6}
>>> s.add("qianan")  # 添加成功
>>> s
{1, 2, 3, 4, 6, 'qianan'}
>>> s.add([1,2,3])  # 报错,同字典一样 不能添加可变对象
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

4.集合更新

可以通过update() 方法，将另一个对象更新到已有的集合中，这一过程同样会进行去重。

>>> s = set([1,2,3,4,5])
>>> s.update("hello")     # 将hello拆开放入集合
>>> s
{1, 2, 3, 4, 5, 'h', 'o', 'e', 'l'}
>>> s.update("hello")     # 仍然去重
>>> s
{1, 2, 3, 4, 5, 'h', 'o', 'e', 'l'}

 

5.删除元素

通过remove(key) 方法删除指定元素，或者使用pop()方法。 注意，集合的 pop方法无法设置参数，删除指定的元素：

（1）set.remove()

>>> s = {1, 2, 3, 4, 5, 'h', 'o', 'e', 'l'}
>>> s.remove(1)       # 删除该元素
>>> s
{2, 3, 4, 5, 'h', 'o', 'e', 'l'}
>>> s.remove('h')      # 删除该元素
>>> s
{2, 3, 4, 5, 'o', 'e', 'l'}
>>> s.remove('www')      # 删除不存在的元素则报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'www'

（2）set.pop()

>>> s1 = set("hello world")
>>> s1.pop()
'h'
>>> s1.pop()
'd'
>>> s1.pop()   # 注意是随机删除
'o'
>>> s1.pop(1)   # 不能通过索引删除,因为本身无序
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: pop() takes no arguments (1 given)

需要注意的是，集合不能取出某个元素，因为集合不支持下标索引也不支持字典那样都的通过键值对获取。

>>> s1
{' ', 'e', 'l', 'r', 'w'}
>>> s1[1]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support indexing

 集合数据类型属于python内置的数据类型，但不被重视，在很多书籍中甚至看不到一点介绍。其实，集合是一种非常有用的数据结构，它的去重和集合运算是其它内置类型都不具备的功能，在很多场合有着非常重要的作用，比如网络爬虫。