set集合，类型转换，列表生成式，迭代器，函数

• set集合
• 类型转换
• 列表生成式
• 迭代器
• 函数

set集合

set集合：本质也是一个无序的集合
主要功能：去重复。
vs字典：同样使用大括号{ } ，但是只存储了字典中key，没有存储字典中的value。
set集合中的元素与字典中key的元素有共同的特征：
1.set集合中元素也是唯一的
2.set集合中元素也是不可变的

1. 创建set集合：
   创建set需要一个list,或tuple，或dict作为输入，重复的元素在set中会被自动的过滤
   set1 = set() #创建空的set集合
   set2 = {1,2,3} #创建具有元素的set集合
   set3 = set([]) #创建set集合

2. 集合操作
   set1.add(ele)
   功能:向set1中添加元素，
   注意:当添加的元素与set1集合中的元素出现重复的时候，不会有任何效果，但是并不报错。
   添加的元素必须是不可变类型的，如可变类型的元素则报错。

   set1.update(序列)
   功能：将序列中的元素打碎插入到set1中
   注意：使用update函数的时候，其参数一定是序列。
   注意：不能直接插入数字！！

   s1 = set([1, 2, 3, 4, 5])
   s1.update([4,"anam","hha"])
   s1.update("hello")
   print(s1)
   #结果
   {1, 2, 3, 4, 5, 'anam', 'l', 'o', 'h', 'e', 'hha'}

   set1.remove(ele)
   功能：将指定的元素移除

3. 集合的遍历
   for x in set1:
   pass

注意：set是无序的，因此不能通过下标获取元素，可以通过这种方式，来强行添加下标

for index, data  in  enumerate(set):

1. 交集&并集
   set1 & set2 获取集合的交集 【两个集合元素重叠的部分】
   set1 | set2 获取集合的并集 【两个集合的所有元素去除重叠的部分】

类型转换

• set，tuple，list 三种类型可以直接进行相互转换。

• 将dict转为set/tuple/list，只转换了key。

• 若将set/tuple/list转为字典的时候，对set/tuple/list要求会高一些。

• set/tuple/list里面的元素必须元组（列表也行），元组中元素的个数必须是两个。

  list1 = [1,2,3,4]
  tuple1 = ("a","b","c","d")
  set1 = {"I","II","III","IV"}
  dict1 = {"1":"hello","2":"hi","3":"haha","4":"heihei"}
  
  # 将其它的数据类型转为list
  print(list(tuple1))
  print(list(set1))
  # 将字典使用list转换的时候，只转换了key没有转换value
  print(list(dict1))
  
  #将其它的数据类型转为tuple
  print(tuple(list1))
  print(tuple(set1))
  # 只转换了key
  print(tuple(dict1))
  
  # 将其它的数据类型转为set
  print(set(tuple1))
  print(set(list1))
  # 只转换了key
  print(set(dict1))
  
  # 将其它的数据类型转为字典
  #当列表为二维列表，并且二维列表的元素是成对的，也是就说二维				列表的元素只有两个的情况下，是可以进行转换的
  print(dict([(1,(1233,22)),[2,3]]))
  print(dict(((1,2),(2,3))))
  print(dict({(1,2),(3,4)}))

列表生成式

本质就是将for循环强制性写在一行，把结果写在for循环的最前面，然后使用[]括起来，得到的就是一个由结果集组成的一个列表。

使用一行代码实现 要求去除3的倍数 list4 = [1,4,16,25,…,10000]

list3 = [ x*x for x in range(1,101) if x%3]

对比常规写法：
list2 = []
for x in range(1,101):
if x%3 != 0:
list2.append(x*x)

迭代器

不但能够作用于for循环，还可以被next函数调用，不断返回下一个值，直到最后出现StopIteration错误，表示无法返回下一个值。这样的对象我们就称之为迭代器

常见的只有生成器是迭代器，其他类型的都不是。

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

isinstance(object,type)：判断某个对象是否属于某种类型

总结：迭代器与可迭代对象的关系：
迭代器一定是可迭代对象，可迭代对象不一定是迭代器。

可以使用isinstance()函数判断一个对象是否是Iterator对象

print(isinstance([],Iterator))
print(isinstance((),Iterator))
print(isinstance({},Iterator))
print(isinstance("",Iterator))
# 只有这个是迭代器
print(isinstance((x for x in range(10)),Iterator))

#结果
False
False
False
False
True

生成器:
通过列表生成式，我们可以直接创建一个列表,但是，受到内存限制，列表容量肯定是有限的,如果我们仅仅需要访问前面几个元素,如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器（Generator）

要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator
g = (x for x in range(1, 101))

Iterator转换

可以通过Iter()函数将list、tuple、dict、string转换为Iterator对象

>>> a = iter([1, 2, 3, 4, 5])
>>> print(next(a))
1

print(isinstance(iter([]), Iterator))
print(isinstance(iter(()), Iterator))
print(isinstance(iter({}), Iterator))
print(isinstance(iter(''), Iterator))
#结果
True
True
True
True

函数

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

优点：
1.提高代码的复用性，简化代码结构
2.增加代码的可维护性

函数的定义：
def 函数名(参数列表):
函数体
return 表达式

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

最简单的函数

说明：最简单的函数，无参数，无返回值的函数

#定义函数
def myPrint():
print("you are a good man")
#调用函数
myPrint()

函数的参数

参数列表：如果函数所实现的需求中涉及到未知项参与运算，就可以将未知项设置为参数。

格式：（参数1，参数2，参数3，…）

形式参数：在方法中定义的，用于接收中间参数的值

实际参数：在函数外面定义，实际参与运算的值，就是为了给形式参数赋值

#函数的定义
#name是形参
def myPrint(name):
print("%s is a good man !"%name)

#"lili" 是实参
myPrint("lili")
#结果
lili is a good man !

练习：
1.设计一个函数，函数的功能求n!
n!=1x2x3x…xn

2.设计一个函数，函数的功能求阶乘之和
sum = 1！+2！+3！+…+n！

#1
def jiecheng(n):
jie = 1
for x in range(1,n+1):
jie *= x
return jie

#2
def jiechenghe(n):
res = 0
for x in range(1,n+1):
res += jiecheng(x)
return res

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

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