精华内容
下载资源
问答
  • 集合与函数

    2019-10-17 19:43:27
    集合与函数 集合(set) 集合也是python中的一种数据结构,但是一般不常用,表现形式是set,与列表基本一致,但在以下方面又与列表不同: 1.集合只能存储不可变对象(int,str,bool,tuple); 2.集合存储的对象是...

    集合与函数

    集合(set)

    集合也是python中的一种数据结构,但是一般不常用,表现形式是set,与列表基本一致,但在以下方面又与列表不同:
    1.集合只能存储不可变对象(int,str,bool,tuple);
    2.集合存储的对象是无序的(意味着通过index取集合中的值无法实现);
    3.集合中没有重复的元素(选用set的实际情形之一)

    创建集合

    使用{}来进行创建或者通过set()函数来进行创建。如

    在这里插入图片描述
    注意:set()函数可以将列表以及字典转化成set,转化字典时,set内只有key值,没有value值!
    在这里插入图片描述

    集合的使用

    检查某个值是否在/不在set中(in / not in)

    会得到一个bool类型的返回值。

    集合的方法

    1.len()获取集合元素的个数;
    2.add()可以向集合中添加元素;如s.add(6),将6添加进s集合中去
    3.update()将一个集合中的元素添加到集合中去;如s.update(s1),将是s1添加进s集合中去
    4.pop()随机删除集合中的一个元素,返回被删除的元素值;如:
    在这里插入图片描述
    5.remove()删除set中指定的元素;如s.remove(1),将集合s中的1删除掉。
    6.clear()清空集合;如s.clear(),将集合s中所有的元素都清空,那么此时set是一个none类型。

    集合的运算

    几个概念

    1.并集 s1 & s 2 得到一个包括是s1 s2所有元素的集合;
    2.交集 s1 | s2 得到一个即属于s1又属于s2元素的集合;
    3.差集 s1 - s2 得到一个s1中剔除掉交集元素的集合
    4.亦或集 s1 ^ s2 得到一个并集并剔除掉交集元素的集合

    函数(function)

    函数的简介

    函数是可以实现一些特定功能的小方法或是小程序,也是一个对象,对象是内存中专门用来存储数据的一块区域。函数可以用来保存一些可执行的代码,用以在需要的时候进行多次调用。

    函数的创建

    语法:
    def 函数名([形参1,形参2,形参3…])
    代码块

    在这里插入图片描述
    注意:函数名info是对象,它存储的内存地址见上图,而info()则是调用函数。

    函数的参数

    在定义函数的时候,可以在函数名后面的括号里面定义数量不等的形参,多个形参我们用,号隔开,形参(形式参数)定义形参就是相当于在函数内部定义了变量,但是并没有赋值;实参(实际参数)函数定义时指定了形参,那么调用函数的时候也必须传递实参,实参将会赋值给对应的形参,有几个形参就传几个实参。

    函数的参数传递方式

    1.默认值参数,在定义形参时,我们可以指定默认值参数,比如c=10,当我们在给调用函数时给c传参,那么c的值会变成我们传的值,如果不给c传参,那么c的值为默认值,注意默认值参数必须放在形参的后面;
    在这里插入图片描述
    2.位置传参
    位置传参就是将对应位置的实参传递给对应位置的形参。

    3.关键字传参
    关键字传参可以不按照形参定义的顺序去传参,而根据参数名来传递参数。
    在这里插入图片描述
    注意:位置传参可以和关键字传参混合使用,但是关键字传参必须放到位置传参之后,否则会报错。如:
    在这里插入图片描述

    实参的类型

    函数在调用的时候,解释权不会检查实参的类型, 实参的类型可以是任意的对象

    实参的类型

    1.在函数中对形参进行重新赋值是不会改变实参,比如形参a的id与实参c的id就不是同一地址。
    在这里插入图片描述
    2.如果形参在执行的时候,当我们通过形参去修改对象时,会影响到指向该对象的变量。
    在这里插入图片描述

    不定长参数

    1.在定义函数的时候,可以在形参的前面加上一个*,这样这个形参将会获取到所有的形参,它会将所有的实参保存到一个元祖中。如:
    在这里插入图片描述
    在调用函数时,a就是元组tuple(1,2,5,7,9,11)。
    2.可变长参数不是必须要写到最后的,但是注意 带的参数后面的参数,必须以关键字的形式传参。若果在形参的开头直接写一个,则要求我们但是所有的参数要以关键字的形式来传递
    在这里插入图片描述
    3. (**形参可以接收其他的关键字参数,它会将这些参数统一保存到一个字典当中,字典当中的key是参数的名字,字典当中的value是参数的值,**形参只能有一个,并且必须写在最后面)

    在这里插入图片描述

    参数解包

    要求序列中的元素的个数必须和形参的个数一致
    在这里插入图片描述

    展开全文
  • Python 集合与函数简介

    2020-04-24 17:01:46
    Python 集合与函数1. Python 集合1.2 集合的使用1.3 集合的运算1. 函数简介2. 函数的参数2.1 形参和实参2.2 函数的传递方式3. 不定长参数4. 参数的解包 1. Python 集合 集合的简介 集合只能存储不可变对象,即字符...

    1. Python 集合

    • 集合的简介
      集合只能存储不可变对象,即字符串,元组,数字,布尔值。字典、列表、集合不能作为集合存储的对象。
      集合中的元素是无序的。
      集合中不能出现重复的元素。
    s = {25,4,6,13,1,1,1,2,2,2,2} # {4,6,25,13,2,1}
    s = {[1,2,3],[4,5,6]} # TypeError: unhashable type: 'list'
    s = {} # 空字典
    
    • set()函数
      可以作为数据类型的转换,如把列表、元组、字符串等转换成集合,转换字典,只能返回字典的keys。不能转换布尔值。数据类型转换,同样不能把字典、列表、集合作为新集合的元素。
    #set()函数可以创建集合,可以通过set()函数将序列转换为集合
    s = set([1,2,3,4,2,2,3,1]) # {1, 2, 3, 4}
    s = set('python') # {'t', 'y', 'o', 'n', 'p', 'h'} <class 'set'>
    s = set({'a':1,'b':2}) # {'a', 'b'} <class 'set'> 使用set()函数将字典转换为集合时,只包含字典的keys(键)
    s = {'a','b',1,2,3}
    print(s[0]) # TypeError: 'set' object does not support indexing,集合不支持索引。
    # print(list(s)[0])
    

    1.2 集合的使用

    in 和 not in来检查集合中的元素
    len() 获取集合的长度或者元素的数量
    add() 向集合中添加元素
    update() 将一个集合中的元素添加到当前的集合中
    pop() 随机删除集合中的一个元素 返回值(删除的元素)
    remove() 删除集合中指定的元素
    clear() 清空集合

    s = {'a','b',1,2,3}
    print(len(s)) # 5
    s.add(40)
    print(s) # {1, 2, 3, 'a', 40, 'b'}
    s1 = set('python')
    s.update(s1)
    print(s) # {1, 2, 3, 'y', 'p', 'h', 'a', 40, 'n', 'b', 't', 'o'}
    result = s.pop()
    print(result) # 1
    s.remove(40)
    print(s) # {2, 3, 'h', 'y', 'a', 't', 'p', 'b', 'o', 'n'}
    s.clear()
    print(s) # set()
    

    1.3 集合的运算

    交集运算 &
    并集运算 |
    差集运算 -
    亦或集 ^ 不相交的部分
    <= 检查一个集合是否是另一个集合的子集
    < 检查一个集合是否是另一个集合的真子集
    >= 检查一个集合是否是另一个集合的超集
    > 检查一个集合是否是另一个集合的超超集
    如果超集b中包含子集a中所有的元素,并且b中还有a集合中没有的元素,b是a的真超级 a

    1. 函数简介

    • 函数也是一个对象
    • 函数用来保存一些可执行的代码,并且可以在需要时,对这些语句进行多次调用
    语法
    def 函数名([形参1,形参2,形参3…]):
    代码块
    注意:
    函数名必须符合标识符的规范(可以包含字母、数字、下划线但是不能以数字开头)
    print是函数对象 print()是调用函数

    2. 函数的参数

    2.1 形参和实参

    • 形参(形式参数) 定义形参就相当于在函数内部声明了变量,但是并不是赋值
    • 实参(实际参数)指定了形参,那么在调用函数时必须传递实参,实参将会赋值给对应的形参,简单来说有几个形参就要有几个实参

    2.2 函数的传递方式

    • 在定义函数的时候,可以在函数后面的()中定义数量不等的形参。多个形参之间使用,隔开
    def s(a,b):

    定义形参时,可以为形参指定默认值。指定了默认值以后,如果用户传递了参数则默认值不会生效。如果用户没有传递,则默认值就会生效

    def fn(a = 5,b =10,c=20):
        print('a =',a)
        print('b =',b)
        print('c =',c)
    fn(1,2,3) # a=1,b=2,c=3
    fn(1,2)   # a=1,b=2,c=20
    

    • 位置参数:位置参数就是将对应位置的实参赋值给对应位置的形参
    • 关键字参数 : 关键字参数可以不按照形参定义的顺序去传递,而根据参数名进行传递
    • 混合使用位置参数和关键字参数的时候必须将位置参数写到关键字参数前面去。如 fn(1,2,c=3)

    def fn(a):
        a = 20 # 在函数中对形参进行赋值,不会影响其他的变量. 
        print('a =',a)
    c = 10
    fn(c)
    print('c =',c) 
    # a = 20
    # c = 10
    def fn4(a):
        a[0] = 20
        print('a =',a)
         # 但当a是一个列表会修改列表中的元素。
    c = [1,2,3]
    fn(c)
    print('c =',c) 
    # a = [20,2,3]
    # c = [20,2,3]
    

    3. 不定长参数

    • 定义函数时,可以在形参前面加一个*,这样这个形参可以获取到所有的实参,它会将所有的实参保存到一个元组中
    • 带*号的形参只能有一个,可以和其他参数配合使用
    • *形参只能接受位置参数,不能接受关键字参数
    • **形参可以接收其他的关键字参数,它会将这些参数统一保存到字典当中。字典的key就是参数的名字,字典的value就是参数的值
    • **形参只有一个,并且必须写在所有参数的后面

    def fn( a,*c ):
      print("输出: ")
      print(a)
      for i in c:
         print(i)
      return
    fn(1,2,3)
    # 结果
    输出: 
    1
    2
    3
    
    # 不定长参数不一定都要写在后面,但是注意 带*的参数后面的所有参数,必须以关键字形式来传递
    
    
    def fn1(a,*b,c):
         print('a =', a)
         print('b =', b)
         print('c =', c)
    fn1(1,2,3,4,c=5)
    # 结果
    a = 1
    b = (2, 3, 4)
    c = 5
    def fn2(*a,b,c):
         print('a =', a)
         print('b =', b)
         print('c =', c)
    fn2(1,2,3,b=4,c=5)
    # 结果 
    a = (1, 2, 3)
    b = 4
    c = 5
    
    # **的形参可以接收其他的关键字参数 它会将这些参数统一保存到字典当中
    # 字典的key就是参数的名字,字典的value就是参数的在值
    # **形参只能有一个,并且必须写在所有参数后面
    # *a 处理的是位置参数 **a 是处理的是关键字参数
    def fn3(**a):
        print('a =', a)
    
    fn3(b=4,d=5,c=6)
    # 结果 
    a = {'b':2,'d':1,'c':3}
    
    
    

    4. 参数的解包

    • 传递实参时,也可以在序列类型的参数前添加星号,这样它会自动的将序列中元素依次作为参数传递
    • 要求序列中的元素的个数必须和形参的个数一致

    def fn(a,b,c):
    
        print('a =', a)
        print('b =', b)
        print('c =', c)
    
    # 创建一个元组
    t = (20,30,40)
    fn(*t)
    # 结果
    a = 20
    b = 30
    c = 40
    # 传递实参时候,也可以在序列类型的参数前面添加*号,这样它会自动的将序列三种的元素依次作为参数传递
    
    # 可以通过**来对字典进行解包
    d = {'a':2,'b':3,'c':4}
    fn(**d)
    # 结果
    a = 2
    b = 3
    c = 4
    
    展开全文
  • 05 集合与函数

    2019-02-15 20:59:00
    05 集合与函数 数字 字符串 元组集合的定义: 1.不同元素组成 2.无序 3.集合中元素必须是不可变类型 不可变:数字 字符串 元组可变:列表 字典 访问顺序:直接访问:数字 顺序访问:字符串 列表 ...

    数字 字符串 元组
    集合的定义: 1.不同元素组成 2.无序 3.集合中元素必须是不可变类型

    不可变:数字 字符串 元组
    可变:列表 字典

    访问顺序:
    直接访问:数字 顺序访问:字符串 列表 元组 映射:字典

    存放元素个数:
    容器类型:俩表 元组 字典
    原子类型:数字 字符串

    集合创建方式:

    s = {1,2,3,4}
    set_test=set('hello')
    {'h','e','l','o'}

     




    内置方法:

    s.add('s')    #添加元素
    s.clear()    #清空元素
    sl = s.copy()    #拷贝
    s.pop()    #随意删除一个元素
    s.remove('x')    #删除指定元素x    如不存在 报错
    s.dicard('x')    #删除指定 如不存在 不报错
    
    p_s l_s    #两个集合
    print (p_s & l_s)    #求出交集
    print (p_s.intersection l_s)
    print (p_s | l_s)    #求并集
    print (p_s.union l_s)
    print (p_s-l_s)    #求差集
    print (p_s .difference l_s)
    print (p_s ^ l_s)    #交叉补集 两者合并出去交集
    print (p_s .symetric_difference l_s)
    print (p_s .isdisjoint l_s)    #二者交集为空 返回TRUE
    print (p_s .issubset(l_s))    #前者是后者的子集 返回TRUE
    print (p_s .issupset(l_s))    #前者是后者的父集 返回TRUE
    #以s1 s2代指
    s1.add(s2)    #更新多个值 也可以插入元组
    
    s = frozenset('hello')    #大部分集合是可变类型,这种是不可变集合

     


    百分号字符串连接

    msg = 'i am %s my hobby is %s' %('lhf','alex') 
    #%s 可以接受一切    %d 仅仅数字
    #%f    默认保留六位    %.2f    保留二位    浮点数
    mas = " i am %(name)s age"    %{'name':'alex'}    #name取K值的value
    
    print ('a','x','v','n',sep=':')    

     


    常用格式化

    mas="i am {} age {} {} ".farmat("alex",12,"hello")
    mas="i am {2} age {1} {0} ".farmat("alex",12,"hello")
    #按照索引取值
    mas="i am {name} age {age} {name} ".farmat(name= “seven”,age=18)
    #字典形式取值,如果后面写标准字典形式,前加**
    mas="i am {:s} age {:d} {:f} ".farmat("alex",12,13.12)

     


    函数
    定义方法:
    def test(x) #test函数名 x形参
    "the function definitions" #文字描述 非必要 但最好有
    x+=1 #泛指程序处理逻辑
    return x #定义返回值

    使用函数的好处:1.代码重用
    2.保持一致性 易维护
    3.可扩展性
    过程: 没有返回值的函数
    返回多个值 打印一个元组
    若果无返回值 返回None

    函数参数:形参和实参 未知参数 默认参数 参数组
    1: 只有在调用时才分配内存 调用结束 释放所分配内存
    2: 可以是常量 表达式 变量 函数等
    3. 位置参数 必须一一对应 缺一不可

    test(1,2,3,y=4) #位置参数必须在关键字参数左边

     


    5.

    def test (x,*args)    #*列表 **字典
      print(x)
      print(args)
    test (1,2,3,5,6,8) 
    
    def test(x,*args,**kwargs):
      print(x)
      print(args,args[-1])
      print(kwargs,kwargs.get('y'))
    test(1,*[1,2,3],**{"y":1})

     














    posted on 2019-02-15 20:59 TTNTONZES 阅读(...) 评论(...) 编辑 收藏

    转载于:https://www.cnblogs.com/louzhiyuan/p/10385890.html

    展开全文
  • Python遍历字典、集合与函数 一、遍历字典 代码块 意义 keys() 该⽅法返回字典所有的key values() 该⽅法返回⼀个序列,序列中保存有字典的值 items() 该⽅法会返回字典中所有的项,它返回⼀个序列,...

    Python遍历字典、集合与函数

    一、遍历字典

    代码块 意义
    keys() 该⽅法返回字典所有的key
    values() 该⽅法返回⼀个序列,序列中保存有字典的值
    items() 该⽅法会返回字典中所有的项,它返回⼀个序列,序列中包含有双值⼦序列。双值分别是:字典中的key和value
    • keys()
      在这里插入图片描述
    • values()
      在这里插入图片描述
    • items()
      在这里插入图片描述

    二、集合

    2.1集合

    • 集合表现形式set 集合和列表⾮常相似。
    • 不同点
    • 集合只能存储不可变对象。
    • 集合中存储的对象是⽆序的。
    • 集合不能出现重复元素。
    • 使⽤{}来创建集合
    • 可以通过set()来将序列和字典转换成集合,set()为空集
      在这里插入图片描述

    2.2集合使用方法

    代码 意义
    len() 使⽤len()来获取集合中元素的数量
    add() 像集合中添加元素
    update() 将⼀个集合中的元素添加到另⼀个集合当中
    pop() 随机删除集合中的⼀个元素⼀般是删除最后⼀个元素
    remove() 删除集合中指定的元素
    clear() 清空集合

    在这里插入图片描述

    2.3 集合的运算

    符号 意义
    & 交集运算
    l 并集运算
    - 差集运算
    ^ 亦或集
    <= 检查⼀个集合是否是另⼀个集合的⼦集
    < 检查⼀个集合是否是另⼀个集合的真⼦集
    >= 检查⼀个集合是否是另⼀个集合的超集
    > 检查⼀个集合是否是另⼀个集合的真超集

    三、函数

    3.1 函数的介绍

    • 函数也是⼀个对象

    • 函数⽤来保存⼀些可执⾏的代码,并且可以在需要时,对这些语句进⾏多次调⽤。

    • 语法:

    def  函数名(【形参123...):
    	代码块
    

    注意:
    函数名必须符合标识符的规范(可以包含字⺟、数字、下划线但是不能以数字开头)
    例:print是函数对象 print()是调⽤函数
    在这里插入图片描述

    3.2函数的参数

    3.2.1形参和实参

    • 在定义函数时,可以再函数后面的括号中定义数量不等的形参,多个形参之间要用“,”隔开。(有几个形参–>几个实参)
    • 形参(形式参数) 定义形参就相当于在函数内部声明了变量,但是并不是赋值
    • 实参(实际参数)指定了形参,那么在调⽤函数时必须传递实参,实参将会赋值给对应的形参。
      在这里插入图片描述

    3.2.2函数的传递方式

    • 定义形参时,可以为形参指定默认值。指定了默认值以后,如果⽤户传递了参数则默认值不会⽣效。如果⽤户没有传递,则默认值就会⽣效。
    • 位置参数:位置参数就是将对应位置的实参赋值给对应位置的形参。
    • 关键字参数 : 关键字参数可以不按照形参定义的顺序去传递,⽽根据参数名进⾏传递。
    • 混合使⽤位置参数和关键字参数的时候必须将位置参数写到关键字参数前⾯去。
      在这里插入图片描述

    3.2.3实参的类型

    可以为任意类型的实参,在函数中对形参重新赋值,不会影响其他的变量。

    3.3可变对象

    对象在内存中保存了三种数据:

    1. id(标识)
    2. type(类型)
    3. value(值)
      在这里插入图片描述
      注意:

    1.值的变化是在原有对象的基础上进行更新的,变量引用的地址没有变化。
    2.对于一个变量的两次赋值操作,值相同,但是引用的地址是不同的,也就是同样值的对象,在内存中是保存了多份的,地址是不同的。

    展开全文
  • Python集合与函数

    2020-04-24 19:52:52
    集合&函数初识1.集合1.1 集合简介1.2 集合的使用1.3 集合的运算2. 函数简介3. 函数的参数3.1 形参和实参3.2 函数的传递方式4. 不定长参数5. 参数的解包 1.集合 1.1 集合简介 集合表现形式set 集合和列表非常...
  • 高数—集合与函数

    2020-09-26 15:28:00
    包含于 ⊂:集合与集合的关系 属于 ∈: 集合和元素的关系 空集φ: 是一个集合 空集包含于任何一个集合 运算 A ⋃ B 两个集合全部元素的集合 A ⋂ B 两个集合的交集 A — B 减去在A中B的部分、 ​ Ω 全集 ​ A‾\...
  • 集合与函数入门

    2020-11-13 13:28:15
    集合与函数集合集合的简介集合的使用集合的运算函数函数简介与快速入门函数的参数字典的补充 集合 集合的简介 集合的表现形式为set 集合和列表非常相似 不同点 集合只能存储不可变对象 集合中存储的对象是无序的 ...
  • 语法 def 函数名([形参1,形参2,形参3....]): 代码块
  • Day08 集合与函数

    2021-02-01 23:39:19
    因此列表等有序数据会冲突 例如: a = [1,2,3] #列表是可变的 b = set(a) #集合是不可变的 print(b) 结果: 报错 集合中储存的对象是无序的 例如: a = {6,8} b = set(a) 结果: {8,6} 集合中不能出现重复...
  • 集合表现形式set集合与列表非常相似 集合与列表的异同 集合只能存储不可变对象 集合中存储的对象是无序的 集合不能出现相同的元素 使用{}来创建集合 len() 显示集合中的元素 add() 向集合添加元素 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,354
精华内容 5,341
关键字:

集合与函数