Python基础入门Week2-常用的四种数据结构

列表list

列表是由一系元素按特定顺序构成的数据序列，是可变的数据类型，可进行增、删、改、查等操作
总结：有序，可变，可进行(增、删、改、查)操作

1. 创建列表

list1 = []
list2 = list(range(1,10))
# 列表生成式
[ i for i in range(10)]

2. 增
   append() ----> 往列表末尾追加元素

list1 = [1,2,3,4,5,6]
list1.append(7)
# 结果
list1 = [1,2,3,4,5,6,7] # 向列表末尾追加元素

3. 删
   del ----> 删除指定元素
   pop() ----> 给出元素指定下标，删除指定位置元素，否则删除末尾元素；最后会返回删除的元素
   remove() ----> 删除指定元素，如果有多个相同的元素，删除第一个；如果元素不存在会报异常ValueError

list1 = [1,2,1,3,4,5,6,7]
del list1[5] # 删除下标为5的元素，删除5
list1.pop() # 删除末尾元素，删除7
list1.pop(3) # 删除下标为3的元素，删除3
list1.remove(1) # 删除1；删的第一个出现的1

4. 改

list1 = [1,2,3,4,5,6]
list1[5] = 7 # 将下标为5的元素重新赋值为7
# 结果
list1 = [1, 2, 3, 4, 5, 7]

5. 查
   index()---->查找元素在列表的下标

list1 = [1,2,3,1,4,5,6]
list1.index(1) # 查找元素为1的下标，第一次出现的位置
# 结果
0

6.排序
sort() ----> 默认从低—高；reverse=True时，从高到低。说明一点，sort()方法是在原列表上操作，原列表的顺序将被改变
reverse() ----> 反转列表

list1 = [2,5,1,3,6,4,8,5,2,4]
list1.sort() # 低-高
# 结果
[1, 2, 2, 3, 4, 4, 5, 5, 6, 8]
list1.sort(reverse = True) # 高-低
# 结果
[8, 6, 5, 5, 4, 4, 3, 2, 2, 1]
list1.reverse() # 反转
[1, 2, 2, 3, 4, 4, 5, 5, 6, 8]

7.切片
list[::step] ----> step：步长，默认为1

list1 = [1,2,3,4,5,6,7,8]
list1[:] # 复制一个一样的列表
# 结果
[1, 2, 3, 4, 5, 6, 7, 8]
list1[::-1] # 反转列表
# 结果
[8, 7, 6, 5, 4, 3, 2, 1]
list1[::2] # 两步取一个数
# 结果
[1, 3, 5, 7]

总结
Python中的列表底层是一个可以动态扩容的数组，列表元素在内存中也是连续存储的，所以可以实现随机访问（通过一个有效的索引获取到对应的元素且操作时间与列表元素个数无关）。列表是容器，可以保存各种类型的数据，可以通过索引操作列表元素

元组tuple

元组是有序、不可变的数据类型，不可进行增、删、改操作

1. 创建元组

tuple1 = (1,2,3,4)
tuple2 = (1,) # 当元组只有一个元素时，一定要在元素后面加个逗号.
tuple3 = () # 空元组

2. 交换变量
   有了星号表达式，我们就可以让一个变量接收多个值，星号表达式只能出现一次。

a,b = 1,2 # 元组操作
a,b,*c = 1,2,3,4,5,6
print(a,b,c)
#结果
1 2 [3, 4, 5, 6]

总结
列表和元组都是容器型的数据类型，即一个变量可以保存多个数据。列表是可变数据类型，元组是不可变数据类型，所以列表添加元素、删除元素、清空、排序等方法对于元组来说是不成立的。但是列表和元组都可以进行拼接、成员运算、索引和切片这些操作，就如同之前讲到的字符串类型一样，因为字符串就是字符按一定顺序构成的序列，在这一点上三者并没有什么区别。

字符串

由零个或多个字符组成的有限序列，有序，不可变的数据类型，不可进行增、删、改操作。

1. 转义字符
   在字符串中，\n不是代表反斜杠和字符n，而是表示换行；\t也不是代表反斜杠和字符t，而是表示制表符。所以如果字符串本身又包含了'、"、\这些特殊的字符，必须要通过\进行转义处理。如果字符串前面有r表示所有转义字符失效

s = "\'hello\nwor\tld\'"
print(s)
# 结果
'hello
wor	ld'
s = r"\'hello\nwor\tld\'"
print(s)
# 结果
\'hello\nwor\tld\'

2. 字符串的运算
   1. 拼接与重复

   s1 = "hello"
   s2 = "world"
   print(s1+s2)
   # 结果
   helloworld
   print(s1*3)
   # 结果
   hellohellohello
   

   2. 字符串的方法
      1. find() / rfind() ; index(）/ rindex()
         判断一个字符串是否在另一个字符串中；rfind()从右开始变量，存在就返回下标，找不到就返回-1
         index与find相似，只是不存在 会返回异常
      2. replace(old,new)
         将old替换成new
      3. split()
         以某元素，将字符串切割成列表，默认以空格切割；返回一个列表
      4. strip() / lstrip() / rstrip()
         删除字符串两端的空格,lstrip()删除左边的空格，rstrip()删除右边的空格

集合set

集合是无序，可变的数据类型，可进行增，删的操作，集合里面的元素必须是不可变的数据类型
1. 无序性：一个集合中，每个元素的地位都是相同的，元素之间是无序的。
2. 互异性：一个集合中，任何两个元素都认为是不相同的，即每个元素只能出现一次。
3. 确定性：给定一个集合，任给一个元素，该元素或者属于或者不属于该集合，二者必居其一，不允许有模棱两可的情况出现。

1. 创建集合

set1 = set() # 创建空集合时，必须set()，不能直接{}
set2 = {1，2，3，4，5，6}
set3 = set('hello')
# 结果
set3 = {'h','o','e','l'}

2. 集合的方法
   add() ----> 随机添加到集合里面
   pop() ----> 随机取出一个值，有返回值
   discard() ----> 删除指定元素

总结
Python中的集合底层使用了哈希存储的方式，元素必须是hashable类型，与列表不同的地方在于集合中的元素没有序、不能用索引运算、不能重复。

字典dict

字典是有键-值构成的，字典有序，可变的数据类型，可进行增、删、改、查等操作

1. 创建字典

dict1 = {} # 空字典
dice2 = dict(name = 1,age = 2,address = 3)
# 结果
{'name': 1, 'age': 2, 'address': 3}
dict3 = dict(zip('abcde','12345'))
# 结果
{'a': '1', 'b': '2', 'c': '3', 'd': '4', 'e': '5'}
{i:i*i for i in range(10)} # 生成式
# 结果
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

2. 字典的方法

dict3 = dict(zip('abcde',12345))
dict3.keys() # 获得全部键
# 结果
dict_keys(['a', 'b', 'c', 'd', 'e'])
dict3.values() # 获得全部值
# 结果
dict_values(['1', '2', '3', '4', '5'])
dict3.items() # 同时获得键和值
dict_items([('a', '1'), ('b', '2'), ('c', '3'), ('d', '4'), ('e', '5')])

1. get(key)方法
   判断key是否在，存在就返回值，不存在就返回给定的值，默认为空
2. pop(key)
   dict_items([(‘a’, ‘1’), (‘b’, ‘2’), (‘c’, ‘3’), (‘d’, ‘4’), (‘e’, ‘5’)])
3. popitem()
   使用popitem方法删除字典中最后一组键值对并返回对应的二元组,如果字典中没有元素，调用该方法将引发KeyError异常
4. setdefault(key,value)
   如果key存在，就返回key对应的值，如果key不存在就向字典添加key，value
5. update（others)
   更新字典里面的值，相同的键，会覆盖原来的值，不存在的键值对将会添加

总结
Python程序中的字典跟现实生活中字典非常像，允许我们以键值对的形式保存数据，再通过键索引对应的值。这是一种非常有利于数据检索的数据类型，字典中的键必须是不可变类型，字典中的值可以是任意类型。