元组&字典&函数基础

1. set: 类似dict, 是一组key的集合，不存储value

   • 本质：无序和无重复元素的集合

   • 创建：

     • 创建set需要一个list或者tuple或者dict作为输入集合

     • 重复元素在set中会自动被过滤

     • s1 = set([1,2,3,4,5,3,4,5,6]) 值为 {1,2,3,4,5,6}

     • s2 = set((1,2,3,4,5,1,2,3)) 值为 {1,2,3,4,5}

   • 添加

     • s4 = set([1,2,3,4,5])

     • s4.add(6)

     • s4.add(4) 可以添加重复的 但是没有效果

     • s4.add((7,8,9)) set的元素不能是列表和字典，因为列表和字典是可变的

     • 插入元组 是将元组当成一个元素来看的

   • 插入整个list、tuple、字符串,打碎插入

     • s5 = set([1,2,3,4,5])

     • s5.update([6,7,8]) 值为{1，2，3，4，5，6，7，8}

     • 这个插入元素，不会将元组当成一个元素来看

   • 删除

     • s6 = set([1,2,3,4,5])

     • s6.remove(3)

   • 遍历

     • s7 = set([1,2,3,4,5])

     • for i in s7

     • print(i)

     • set没有索引的

   • 交集

     • s8 = set([1,2,3])

     • s9 = set([2,3,4])

     • a1 = s8 & s9

   • 并集

     • a2 = s8 | s9

2. 类型转换

   • list -> set

     • L1 = [1,2,3,4,5,3,4,5]

     • s1 = set(L1)

   • tuple ->set

     • t2 = (1,2,3,4,3,2)

     • s2 = set(t2)

   • set - >list

     • s3 = {1,2,3,4}

     • l3 = list(s3)

   • set->tuple

     • s4 = {2,3,4,5}

     • t4 = tuple(s4)

3. 迭代器

   • 可迭代对象

     • 导入 from collections import Iteralbe

     • 可以直接作用于for循环的对象统称为可迭代对象(Iteralbe)

     • 可以用isinstance()去判断一个对象是否是可迭代对象

     • 可以直接作用于for的数据类型一般分两种

       • 集合数据类型，如list、tuple、dict、set、string

       • 是generator，包括生成器和带yield的generator function

     • print(isinstance([],Iterable)) 返回True

   • 迭代器

     • 导入 from collections import Iterator

     • 不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后会抛出一个StopIteration错误表示无法继续返回下一个值

     • 可以被next()函数调用并不断返回下一个值的对象称为迭代器(Iterator)

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

     • l = (x for x in range(5))

     • print(next(1)) 0

     • print(next(1)) 1

     • print(next(1)) 2

     • print(next(1)) 3

     • print(next(1)) 4

     • .

     • .

     • 转成Iterator对象

     • a = iter([1,2,3,4,5])

     • print(next(a)) 1

     • print(next(a)) 2

   • iter(object,sentinel)

     • object必须是集合对象，且支持迭代协议

     • sentinel

       • 如果传递了第二个参数，则object必须是一个可调用的对象（如，函数）。此时，iter创建了一个迭代器对象，每次调用这个迭代器对象的next()方法时，都会调用object。

       • 如果next的返回值等于sentinel，则抛出StopIteration异常，否则返回下一个值。

4. 函数

   • 函数概述

     • 认识函数：在一个完整的项目中，某些功能会反复的使用。那么 会将功能封装成函数，当我们要使用功能时候，直接调用函数即可

   • 本质：函数就是对功能的封装

   • 优点：

     • 简化代码结构，增加了代码的复用度(重复使用的程度)

     • 如果想修改某些功能或者调式某个BUG，只需要修改对应的函数即可

   • 定义函数：

     • 格式:

       • def 函数名(参数列表):

       • 语句

       • return 表达式

     • def:函数代码块以def关键字开始

     • 函数名:遵循标识符规则

     • ():是参数列表的开始和结束

     • 参数列表(参数1,参数2，.......参数n)：

       • 任何传入函数的参数和变量必须放在圆括号之间，用逗号分隔。函数从函数的调用者那里获取的信息

     • 冒号: 函数内容(封装的功能)以冒号开始，并且缩进

     • 语句: 函数封装的功能

     • return: 一般用于结束函数的，并返回信息给函数的调用者

     • 表达式: 即为要返回给函数的调用者的信息

     • 注意：最后的return 表达式，可以不写，相当于return None

   • 函数的调用

     • 格式： 函数名(参数列表)

     • 函数名: 是要使用的功能的函数名字

     • 参数列表: 函数的调用者给函数传递的信息,如果没有参数，小括号也不能省略

     • 函数调用的本质: 实参给形参赋值的过程

   • 函数的参数

     • 实参(实际参数): 调用函数时给函数传递的数据，本质是值

     • 形参(形式参数): 定义函数时小括号中的变量，本质是变量

     • 参数必须按顺序传递，个数目前要对应

   • 函数的返回值

     • 通过return 返回值给调用者

   • 传递参数

     • 值传递

       • 传递的不可变类型

         • string、tuple、number是不可变的

     • 引用传递

       • 传递的可变类型

         • list、dict、set是可变的

   • 关键字参数

     • 概念：允许函数调用时参数的顺序与定义时不一致

     • def myprint(str,age)

     • print(str,age)

     • 使用关键字参数 myprint(age= 18,str = "xiaoxin")

   • 默认参数

     • 概念：调用函数时，如果没有传递参数，则使用默认参数

     • def myprint(str=“xiaoxin”,age=18)

     • print(str ,age) #值为 xiaoxin 18

     • myprint()

     • 以后要用默认参数，最好将默认参数放到最后

   • 不定长参数

     • 概念：能处理比定义时更多的参数

     • 加了星号(*)的变量存放所有未命名的变量参数，如果在函数调用时没有指定参数，它就是一个空元组

     • def func(name,*arr)

     • print(name)

     • for x in arr:

     • print(x)

     • func("good","nice","happy","handsome")

     • .

     • **代表键-值对参数字典，和 *所代表的意义类似

     • def func2(**kwargs)

     • print(kwargs)

     • func2(x = 1,y =2,z=3) 实参必须为关键字参数

   • 匿名函数

     • 概念：不使用def这样的语句定义函数，使用lambda来创建匿名函数

     • 特定：

       • lambda：只是一个表达式。函数体比def简单

       • lambda的主体是一个表达式，而不是代码块，仅仅只能在lambda表达式中封装简单的逻辑

       • lambda函数有自己的命名空间，且不能访问自由参数列表之外的或全局命名空间的参数

       • 虽然lambda是一个表达式且看起来只能写一行，与C和C++内联函数不同

     • 格式 :

       • lambda 参数1, 参数2, .......，参数n: expression

       • sum = lambda num1,num2: num1+num2

       • print(sum(1,2)) 结果为3

5. 元组

   • tuple

     • 本质：是一种有序集合

     • 特定：

       • 与列表非常相似

       • 一旦初始化就不能修改

       • 使用小括号

     • 创建tuple

       • 格式： 元组名 = （元组元素1，元组元素2，.......,元组元素n）

   • 创建空的元组

     • tuplel = ()

     • print(tuplel)

   • 创建带有元素的元组

     • tuple2 = (1,2,3,"good",True)

     • print(tuple2)

   • 定义只有一个元素的元组

     • tuple3 = (1,)

     • print(tuple3)

   • 元组元素的访问

     • 格式： 元组名[下标] 下标从0开始

     • tuple4 = (1,2,3,4,5)

     • tuple4[0]

     • tuple4[-1] 获取最后一个元素

   • 修改元组

     • tuple5 = (1,2,3,4,[5,6,7])

     • tuple5[0] =100 #会报错， 元组不能变

     • tuple5[-1] [0] = 500 #不会报错 5变成了500

     • 元组不能变，说的是元组里面的元素不能变，但是元组里面存列表等，列表里面的元素是可以改变的

   • 删除元组

     • tuple6 =(1,2,3)

     • del tuple6

   • 元组的操作

     • t7 = (1,2,3)

     • t8 = (4,5,6)

     • t9 = t7+t8 生成一个新的元组给t9 ，但t7和t8本身不改变

   • 元组重复

     • t10 = (1,2,3)

     • print(t10*3)

   • 判断元素是否在元组中

     • t11 = (1,2,3)

     • print(1 in t11)

   • 元组的截取

     • 格式：

       • 元组名[开始下标:结束下标]

       • 从开始下标开始截取，截取到结束下标之前

       • t12 = （1,2,3,4,5,6,7,8,9）

       • t12[3:7]

   • 二维元组：元素为一维元组的元组

     • t13 = ((1,2,3),(4,5,6),(7,8,9))

     • t13[1] [1] 值为5

   • 元组的方法

     • len(t13) 返回元组中元素的个数

     • max(t13) 返回元组中的最大值

     • min(t13) 返回元组中的最小值

     • 将列表转成元组

       • list = [1,2,3]

       • t15 = tuple(list)

   • 元组的遍历

     • for i in (1,2,3,4,5):

6. 字典

   • 概述:

     • 使用键-值(key-value) 存储，具有极快的查找速度

     • 注意： 字典是无序的

     • key的特性

       • 字典中的key必须唯一

       • key必须是不可变的对象

       • 字符串、整数等都是不可变的，可以作为key

       • list是可变的，不能作为key

   • 字典的创建

     • dict1 = {"tom":60,"lilei":70}

   • 元素的访问

     • 获取: 字典名[key]

     • print(dict1["lilei"]) 值为70

     • print(dict1.get("sunck")) 没有找到 返回None

   • 元素的添加

     • dict1["hanmeimei"] = 99

     • dict1["lilei"] = 80

       • 因为一个key对应一个value，所以，多次对一个key的value赋值，其实就是修改值

   • 元素的删除

     • dict1.pop("tom") tom就被删除了

   • 遍历

     • for key in dict1:

       • print(key, dict1[key])

     • for value in dict1.values(): [60,80,90] 将字典的值取出来

       • print(value)

     • for k,v in dict1.items():

       • print(k,v) 能把字典的元素全部打出来 key和value

   • 和list比较

     • 查找和插入的速度极快，不会随着key-value的增加而变慢

     • 需要占用大量的内存，内存浪费多

   • list

   • 查找和插入的速度随着数据量的增多而减慢

   • 占用空间小，内存浪费少

1. • set: 类似dict, 是一组key的集合，不存储value

     • 本质：无序和无重复元素的集合

     • 创建：

       • 创建set需要一个list或者tuple或者dict作为输入集合

       • 重复元素在set中会自动被过滤

       • s1 = set([1,2,3,4,5,3,4,5,6]) 值为 {1,2,3,4,5,6}

       • s2 = set((1,2,3,4,5,1,2,3)) 值为 {1,2,3,4,5}

     • 添加

       • s4 = set([1,2,3,4,5])

       • s4.add(6)

       • s4.add(4) 可以添加重复的 但是没有效果

       • s4.add((7,8,9)) set的元素不能是列表和字典，因为列表和字典是可变的

       • 插入元组 是将元组当成一个元素来看的

     • 插入整个list、tuple、字符串,打碎插入

       • s5 = set([1,2,3,4,5])

       • s5.update([6,7,8]) 值为{1，2，3，4，5，6，7，8}

       • 这个插入元素，不会将元组当成一个元素来看

     • 删除

       • s6 = set([1,2,3,4,5])

       • s6.remove(3)

     • 遍历

       • s7 = set([1,2,3,4,5])

       • for i in s7

       • print(i)

       • set没有索引的

     • 交集

       • s8 = set([1,2,3])

       • s9 = set([2,3,4])

       • a1 = s8 & s9

     • 并集

       • a2 = s8 | s9

   • 类型转换

     • list -> set

       • L1 = [1,2,3,4,5,3,4,5]

       • s1 = set(L1)

     • tuple ->set

       • t2 = (1,2,3,4,3,2)

       • s2 = set(t2)

     • set - >list

       • s3 = {1,2,3,4}

       • l3 = list(s3)

     • set->tuple

       • s4 = {2,3,4,5}

       • t4 = tuple(s4)

   • 迭代器

     • 可迭代对象

       • 导入 from collections import Iteralbe

       • 可以直接作用于for循环的对象统称为可迭代对象(Iteralbe)

       • 可以用isinstance()去判断一个对象是否是可迭代对象

       • 可以直接作用于for的数据类型一般分两种

         • 集合数据类型，如list、tuple、dict、set、string

         • 是generator，包括生成器和带yield的generator function

       • print(isinstance([],Iterable)) 返回True

     • 迭代器

       • 导入 from collections import Iterator

       • 不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后会抛出一个StopIteration错误表示无法继续返回下一个值

       • 可以被next()函数调用并不断返回下一个值的对象称为迭代器(Iterator)

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

       • l = (x for x in range(5))

       • print(next(1)) 0

       • print(next(1)) 1

       • print(next(1)) 2

       • print(next(1)) 3

       • print(next(1)) 4

       • .

       • .

       • 转成Iterator对象

       • a = iter([1,2,3,4,5])

       • print(next(a)) 1

       • print(next(a)) 2

     • iter(object,sentinel)

       • object必须是集合对象，且支持迭代协议

       • sentinel

         • 如果传递了第二个参数，则object必须是一个可调用的对象（如，函数）。此时，iter创建了一个迭代器对象，每次调用这个迭代器对象的next()方法时，都会调用object。

         • 如果next的返回值等于sentinel，则抛出StopIteration异常，否则返回下一个值。

   • 函数

     • 函数概述

       • 认识函数：在一个完整的项目中，某些功能会反复的使用。那么 会将功能封装成函数，当我们要使用功能时候，直接调用函数即可

     • 本质：函数就是对功能的封装

     • 优点：

       • 简化代码结构，增加了代码的复用度(重复使用的程度)

       • 如果想修改某些功能或者调式某个BUG，只需要修改对应的函数即可

     • 定义函数：

       • 格式:

         • def 函数名(参数列表):

         • 语句

         • return 表达式

       • def:函数代码块以def关键字开始

       • 函数名:遵循标识符规则

       • ():是参数列表的开始和结束

       • 参数列表(参数1,参数2，.......参数n)：

         • 任何传入函数的参数和变量必须放在圆括号之间，用逗号分隔。函数从函数的调用者那里获取的信息

       • 冒号: 函数内容(封装的功能)以冒号开始，并且缩进

       • 语句: 函数封装的功能

       • return: 一般用于结束函数的，并返回信息给函数的调用者

       • 表达式: 即为要返回给函数的调用者的信息

       • 注意：最后的return 表达式，可以不写，相当于return None

     • 函数的调用

       • 格式： 函数名(参数列表)

       • 函数名: 是要使用的功能的函数名字

       • 参数列表: 函数的调用者给函数传递的信息,如果没有参数，小括号也不能省略

       • 函数调用的本质: 实参给形参赋值的过程

     • 函数的参数

       • 实参(实际参数): 调用函数时给函数传递的数据，本质是值

       • 形参(形式参数): 定义函数时小括号中的变量，本质是变量

       • 参数必须按顺序传递，个数目前要对应

     • 函数的返回值

       • 通过return 返回值给调用者

     • 传递参数

       • 值传递

         • 传递的不可变类型

           • string、tuple、number是不可变的

       • 引用传递

         • 传递的可变类型

           • list、dict、set是可变的

     • 关键字参数

       • 概念：允许函数调用时参数的顺序与定义时不一致

       • def myprint(str,age)

       • print(str,age)

       • 使用关键字参数 myprint(age= 18,str = "xiaoxin")

     • 默认参数

       • 概念：调用函数时，如果没有传递参数，则使用默认参数

       • def myprint(str=“xiaoxin”,age=18)

       • print(str ,age) #值为 xiaoxin 18

       • myprint()

       • 以后要用默认参数，最好将默认参数放到最后

     • 不定长参数

       • 概念：能处理比定义时更多的参数

       • 加了星号(*)的变量存放所有未命名的变量参数，如果在函数调用时没有指定参数，它就是一个空元组

       • def func(name,*arr)

       • print(name)

       • for x in arr:

       • print(x)

       • func("good","nice","happy","handsome")

       • .

       • **代表键-值对参数字典，和 *所代表的意义类似

       • def func2(**kwargs)

       • print(kwargs)

       • func2(x = 1,y =2,z=3) 实参必须为关键字参数

     • 匿名函数

       • 概念：不使用def这样的语句定义函数，使用lambda来创建匿名函数

       • 特定：

         • lambda：只是一个表达式。函数体比def简单

         • lambda的主体是一个表达式，而不是代码块，仅仅只能在lambda表达式中封装简单的逻辑

         • lambda函数有自己的命名空间，且不能访问自由参数列表之外的或全局命名空间的参数

         • 虽然lambda是一个表达式且看起来只能写一行，与C和C++内联函数不同

       • 格式 :

         • lambda 参数1, 参数2, .......，参数n: expression

         • sum = lambda num1,num2: num1+num2

         • print(sum(1,2)) 结果为3