python学习第三周（列表，元组，字典，集合）

列表

1、作用：类似于其他语言的数组。（数组：数字的组合，列表可以延伸为字母的组合，字符串的组合）
2、关键字：list
3、符号：[ ]
4、声明：lists = [‘a’,‘b’]
5、地址：空列表也会分配地址，id(lists)

列表的增删改查

一、查

1、元素的获取是使用下标（索引）。例如：lists[0]:获取列表的第一个元素。
2、获取列表的最后一个元素：lists[-1]，或 lists[len (lists) - 1].
len()不仅能获取字符串长度，还能 获取列表的长度。
3、结合循环

for i in lists:
	print(i)      # 因为列表和字符串一样都是序列，所以列表也支持遍历

4、in：运算符
列表中in的使用类似字符串中in的使用，应用在字符串判断中，返回的是布尔值。也可以用在列表中，返回的是字符串。

增加的知识点

in与 “= =”的关系：in可以做 ‘= =‘的作用，in包含’= =’，所以in具有包含和相等的作用。

if...in..:                      返回的是布尔值，判断后面的是否包含或相等前面的
for 变量 in str/list:           返回字符串，把字符串或列表进行遍历

二、改

步骤：1、找到（使用下标）。2、通过 = 赋值。3、新的值会覆盖原值。
改是在查的基础上进行的。

三、删

1、删除：del
2、用法：del list[index]删除列表相应位置的内容。
3、注意：删除之后的列表也会变短，位置索引会发生变化，所以不要边删边遍历。
使用for循环还是while循环呢？
for循环生成的序列不会发生变化，while循环生成的序列可以发生变化。所以用while循环。
4、列表函数：

1、remove(value) :删除列表中第一次的value，返回值为None，如果找不到，则抛出异常。
2、pop():弹栈，移除列表中最后一个元素，返回值是删除的那个元素。默认是删除最后一个，但可以指定index删除。
3、clear()：清空列表，返回空列表。

补充：
1、队列：先进先出FIFO
2栈：先进后出FILO

列表的切片

1、列表中可以是任何类型的值。
2、切边之后截取的结果再次保存在一个列表中。
3、步长：lists[a:b:c] a:开始的位置，b:结束的位置，c:c的符号表示方向，大小表示步长

四、增

列表函数的使用：
1、append()：末尾追加（每次加一个）
2、extend()：列表的合并（不管列表是什么类型的内容）

list1.extend(list2) extend把list2中的列表拆分，加入到list1中之后合并成一个新的列表。

3、‘+’：list1 + list2：列表的合并，和extend作用一样
4、insert ：insert（index,'str'）指定位置插入元素，之前位置的元素后移。

其他

1、字符串中可以使用的符号：

+, *, in, not in, is,not is,[]切片 

2、列表支持的符号：

+， * in, 列表内的元素为：int,str,float,列表，元组，字典，对象。

3、list()类型转换，与str(),int()作用一样，将指定内容转换为列表，可迭代的内容可以放到列表中。
什么是可迭代的：
只要可以实现for i in xxx:就是可以迭代的 有：列表，元组，字典，字符串。
4、翻转

reverse()与[:,:,-1]都是倒序取出列表中的值。但：
reverse():改变了列表位置结构。
[:,:,-1]:只是逆序拿出列表中的元素，原列表内容顺序不变。

5、排序

1、lists.sort() 默认升序，reverse=True：倒序输出
2、sorted(lists) 系统提供的排序

6、次数

lists.count()

7、枚举：

enumerate():把列表中分索引和内容打印出来，括号的元素可为：字符串，列表，元组，集合。
for index,value in enumerate(list):
		print(index,value)

元组

1、作用：类似列表（当成容器）
特点：
1、符号：（ ）
2、关键字：tuple
3、元组中的内容不可修改
注意：元组（ ），当括号内只用一个元素时，元素的类型是什么，这个元组就是什么类型，但若加一个逗号（A,）,那就是一个元组了。
4、元组不能增，删，改，但可以查。
5、查：通过下标（index）或切片[ : ]
6、tuple() 转为元组：tuple(list) :把list转为tuple
7、tuple的函数：
index():返回下标。
count():返回个数。
8、拆包

1、a,b,c = (4,7,3) 变量个数与元组个数一致。
2、变量个数与元祖个数不一致时：
  a, *b, c = (2,3,4,5,6,7)    # *b中 *号是必须的，其他可以随便写
  	print(a,b,c)  # a:2,   b:[3,4,5,6],  c:
底层实现：
	1、把外套去掉：2,3，4,5，6,7（拆包）
	2、赋值：a = 2, b = [3,4,5,6](底层有*号：把内容方在一个列表内)， c = 7
3、print（*b）= print（*[3,4,5,6]）# 返回 3,4,5,6。（在列表前面加*：系统认为把一个列表拆了）

9、元组支持的符号：

+， *， is not, in not, in

10、元组系统函数：

max(), min(), len(), 
sorted(),但返回的是列表类型。
tuple():强制类型转换为元组。

字典

1、应用：保留信息
2、符号：{ }
3、关键字：dict
4、保存的元素的形式：{key:value，}成对出现
5、定义;
空字典：

dict1 = { }
dict2 = dict()

正常形式：

1、dict3 = {key:value,key1:value1...}
2、dict4 = dict( [ (key,value) , (0,1) ] )
底层：{key:value,0:1}

6、列表可以转换为字典，但前提是列表中的元素都要成对出现。

dict( [ (a,b) , (c,d) ] ) 返回：a:b,c:d

字典的增删改查

一、增

dict1 = { }
1、格式：dict1[key] = value
若出现同名的key,不同的value，则会发生覆盖原来的value ，这就是改。
若没有同名的key，则实现添加功能。
2、特点
key是唯一的，value不是唯一的。

二、查

1、通过key查找value

dict1[key] --> value
若key不存在，则报出keyError

2、遍历
单独遍历字典的结果是：字典的key。
in :在字典操作，用于判断元素有没有在字典的key中出现。
3、字典的函数：

1、items() ：将字典的键对值转为列表保存 ---》[(key,value),(key1,value1)]
for key,value in dict1.items():
	print(key,value)
2、values()：取出字典中所有的值，保存到列表中，不用使用遍历，把value值全部取出
dict1.values()
3、keys()：取出字典中所有的key值，保存到列表中。

4、字典的内置函数：

get()
1、dict1.get(key):返回value，若找不到，则会报错，返回None。
2、dict1.get(key,default) 返回value,如果能取到值则返回字典中的值，如果取不到则返回default的值。

删

del dict1[key]

字典的内置函数：pop()

1、pop(key[,default]) 根据key删除字典中的键对值，返回值是键值对的value。
default是在删除时没找到对应的key，则返回default。
2、popitem():随即删除字典中键值对（一般是从末尾删除）
3、clear()：清空字典
4、updata()：合并字典，但相同的key值会被更新。
5、fromkeys(seq[, value]):将seq转为字典，如果没有指定value，用none代替value。

集合

1、作用：利用不重复的特点
2、关键字：set
3、特点：无序的不重复的元素。
4、作用：利用不重复的特点。
5、声明：
空集合：

1、s1= set()：创建空集合只能用这个。
2、s2 = { }与字典的区别：字典是{key:value},集合是：{元素1，元素2，元素3，...}

应用：s3 = set(list1):去除重复项，且排序。

集合的增删改查

增

s1 = set( )
s1.add( )：添加一个元素
s1.update( )：添加多个元素（可以是列表，元组）

删

s1.remove( 元素)：若元素存在，则删除，不存在则报错keyError。
s1.pop( )：随即删除（但一般删除第一个元素）
s1.clear( )：清空集合
s1.dicard( )：类似remove( )，但在移除不存在元素时，不会报错。

其他符号操作

1、in
2、not in
3、== ：比较判断两个集合中的内容是否相等
4、+ ， * 集合不支持
5、-：差集 = difference()

s1-s2 = : s1 = difference(s2) 去除s1中和s2相同的内容

6、&：交集 = intersection( )

s1&s2 = s1.intersection(s2) s1与s2的相同的部分

7、| ：并集 = union()

s1|s2 = s1.union(s2) 

8、^：对称交集

s1^s2   异或  两个集合中不一样的元素  （除去交集的部分）

可变和不可变

1、不可变：对象所指向的内存中的值是不可变的
不可变的类型：int, str, float, tuple。
2、可变：对象所指向的内存中的值是可变的
可变的类型：dict, list, set
3、frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
5、类型转换：

str()   <---> int(), list(), set(), tuple(), float()
list()  <---> tuple(), set(), dict()(直降key)保存在list中