元组&字典&函数基础

Posted fengzi759

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了元组&字典&函数基础相关的知识,希望对你有一定的参考价值。

  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

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

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

    • 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

以上是关于元组&字典&函数基础的主要内容,如果未能解决你的问题,请参考以下文章

python目录

python基础:元组字典深浅拷贝与函数

python基础-----集合与函数

Python基础语法—— 列表+元组+字典

Python基础语法

技术栈