1.set集合

本质：是一个无序的集合，只存储字典的key，没有存储字典的value。

set集合中的元素与字典中key的元素有共同特征：

1.set集合中的元素也是唯一的

2.set集合中的元素也是不可变的

set集合的创建
set1 = set()     #创建空的set集合
set2 = {1,2,3}   #创建具有元素的set集合
set3 = set([])    #创建set集合
print(set1)         #返回set()
print(type(set1))    #返回<class 'set'>
print(set2)          #返回{1, 2, 3}
print(type(set2))    #返回<class 'set'>
print(set3)          #返回set()
print(type(set3))    #返回<class 'set'>
set添加元素

set.add(ele)添加

功能：向set中添加元素。

注意:当添加的元素与set集合中的元素出现重复的时候，不会有任何效果，但是并不报错。
添加的元素必须是不可变类型的，若添加可变类型的元素则会报错。

set1 = {1,2,3}
print(set1)  #输出{1, 2, 3}
set1.add(4)
print(set1)   #输出{1, 2, 3, 4}

set.update(序列)

功能：将序列中的元素打碎插入到set中。

注意：使用update函数的时候，其参数一定是序列。

set1 = {1,2,3}
set2 = {4,5,6}
list1 = [5,8,"hello"]
str1 = "hollo"
set1.update(list1)
set2.update(str1)
print(set1)          #输出{1, 2, 3, 5, 8, 'hello'}
print(set2)          #输出{4, 5, 6, 'l', 'o', 'h'}
set移除元素

set.remove(ele)

将指定的元素移除

set1 = {1,2,3}
set1.remove(1)
print(set1)   #输出{2, 3}
set集合的交/并集

交集

set1&set2获取集合的交集

set1 = {1,2,3,4}
set2 = {4,5,6,7}
print(set1 & set2)   #输出 {4}

并集

set1&set2获取集合的并集

set1 = {1,2,3,4}
set2 = {4,5,6,7}
print(set1 | set2)   #输出 {1, 2, 3, 4, 5, 6, 7}
set集合的遍历
set1 = {1,2,3}
for i in set1:
    print(i,end="\t")   #输出1	2	3

2.list、tuple、set、dict的转换

(1)tuple、set、dict转为list

tuple转化为list
tuple1 = (1,2,3)
list1 = list(tuple1)
print(list1)    #输出[1, 2, 3]
dict转化为list

字典使用list转换的时候，只转换了key没有转换value

dict1 = {"张三":1,"李四":2,"郭五":3}
list1 = list(dict1)
print(list1)   #输出 ['张三', '李四', '郭五']
set转化为list
set1 = {1,2,3}
list1 = list(set1)
print(list1)    #输出[1, 2, 3]

(2)list、set、dict转为tuple

list转化为tuple
list1 = [1,2,3]
tuple1 = tuple(list1)
print(tuple1)   #输出(1, 2, 3)
dict转化为tuple

字典使用tuple转换的时候，只转换了key没有转换value

dict1 = {"张三":1,"李四":2,"郭五":3}
tuple1 = tuple(dict1)
print(tuple1)   #输出 ['张三', '李四', '郭五']
set转化为tuple
set1 = {1,2,3}
tuple1 = tuple(set1)
print(tuple1)   #输出(1, 2, 3)

(3)list、tuple、dict转为set

list转化为set
list1 = [1,2,3]
set1 = set(list1)
print(set1) #输出{1, 2, 3}
tuple转化为set
tuple1 = (1,2,3)
set1 = set(tuple1)
print(set1) #输出{1, 2, 3}
dict转化为set

字典使用tuple转换的时候，只转换了key没有转换value

dict1 = {"张三":1,"李四":2,"郭五":3}
set1 = set(dict1)
print(set1)   #输出 ['张三', '李四', '郭五']

(4)list、tuple、set转为字典

当列表为二维列表，并且二维列表的元素是成对的，也是就说二维列表的元素只有两个的情况下，才是可以进行转换

print(dict([(1,2),(3,4)]))   #输出{1: 2, 3: 4}
print(dict([(1,(2,5)),(3,4)]))  #输出{1: (2, 5), 3: 4}

3.可迭代对象

定义：能直接作用于for循环的对象我们统称为可迭代对象。

常见的可迭代对象：
1.list、set，dict，tuple，str，range

2.生成器

生成器

定义：一边循环一边计算的这种机制我们称之为生成器[可以不断推算出下一个元素]

注意：生成器只能迭代一遍

创建生成器

g = (result for x in range(m,n))

例如：

g1 = (x for x in range(10))
for x in g1:
    print(x,end="\t")  #输出0	1	2	3	4	5	6	7	8	9
print()
迭代器

不但能够作用于for循环，还可以被next函数调用，不断返回下一个值，这样的对象我们就称之为迭代器
常见的只有生成器是迭代器，其他类型的都不是。

可以通过iter()函数将可迭代对象转为迭代器。

例如：

iter1 = iter([1,2,3])
print(iter1)      #返回<list_iterator object at 0x00000000021AA278>
print(type(iter1))  #返回<class 'list_iterator'>
print(next(iter1))   #输出1

迭代器与可迭代对象的关系：

迭代器一定是可迭代对象，可迭代对象不一定是迭代器。

例如使用isinstance(object,type)来判断某个对象是否属于某种类型

from collections import Iterable
from collections import Iterator

g = (x for x in range(10))
print(isinstance([],Iterable))     #返回True
print(isinstance("",Iterable))     #返回True
print(isinstance({},Iterable))     #返回True
print(isinstance((),Iterable))     #返回True
print(isinstance(range(10),Iterable))   #返回True
print(isinstance(g,Iterable))      #返回True

print(isinstance([],Iterator))   #返回False
print(isinstance("",Iterator))     #返回False
print(isinstance({},Iterator))      #返回False
print(isinstance((),Iterator))     #返回False
print(isinstance(range(10),Iterator))     #返回False
print(isinstance(g,Iterator))      #返回True

4.函数

在项目开发的过程中，有些功能代码我们可能会经常使用，我们可以将这些代码按照它的功能封装成函数，在需要的时候调用即可。

优点：

1.通关代码的复用性，简化代码结构

2.增加代码的可维护性

函数的定义

def 函数名(参数列表):
函数体
return 表达式

def 关键字标识定义函数的开始
函数名 遵循标识符的命名规则
() 列表参数的开始以及结束，无论是否存在参数，小括号都不能省略
参数列表 参数与参数之间使用逗号隔开，若不存在参数可不写
: 函数的功能以冒号开始，并且需要缩进
函数体：封装的函数的功能
return 函数结束之后的返回值，若没有返回值return可以不写，不写的时候默认return None

例如：

def myinput():
    for x in range(3):
        print("你好啊")
函数的调用

函数名(参数列表)
参数列表：若此函数需要参数，则我们需要将参数传递进去，若此函数不需要参数，则我们无需传递参数

def myprint(n):
    for x in range(n):
        print("你好啊") 
        
myprint(3)    #打印3次 "你好啊"
参数的传递

形参：形式参数
定义在函数的参数列表中的参数，我们称之为形参。
作用：用来接收函数的调用者传递过来值。
实参：实际参数
函数调用的过程中传递的参数
作用：给形参赋值
参数传递的本质：实参给形参赋值的过程。

def myprint(n):     #n为形参
    for x in range(n):
        print("你好啊")     
myprint(3)    #3为实参

对于不可变类型的传递是值传递
对于可变类型的传递是地址传递【引用传递】
若传递进去的对象是不可变类型，当在函数体内对象发生改变的时候，不会改变被传递的变量
若传递进去的变量是可变类型，当在函数内对该变量进行更改的时候，会影响到被传递的变量

例如

def func(x):
    print(id(x))  #返回4366944
    print(x)      #输出hello
    x = "你好"
    print(x)      #输出你好
    print(id(x))   #返回167226952

str1 = "hello"
func(str1)
print(str1)        #输出hello
print(id(str1))     #返回4366944