精华内容
下载资源
问答
  • 一.字典 1.1使用 字典可存储的信息量几乎受限制 字典是一系列键-值对,可以使用键来访问与之...当需要编写自动生成大量键-值对的代码时,可以先定义一个空字典。 1.4修改字典中的值 1.5删除键-值对 使用del语句 ...

    一.字典
    1.1使用
    字典可存储的信息量几乎不受限制
    字典是一系列键-值对,可以使用键来访问与之相关联的值,值也可以是数字、字符串、列表或字典
    使用{},键与值之间冒号分隔,键-值对之间逗号分隔。
    1.2访问字典中的值
    1.3添加键-值对
    键-值对的排列顺序与添加顺序不同。
    当需要编写能自动生成大量键-值对的代码时,可以先定义一个空字典。
    1.4修改字典中的值
    1.5删除键-值对
    使用del语句
    2.遍历字典
    2.1遍历所有键-值对
    使用for循环,要声明两个变量,用于存储键-值对中的键和值,对于这两个变量,可用任何名称。
    键-值对的返回循序也和存储顺序不同。
    2.2遍历字典中的所有键
    使用方法keys()
    遍历字典时,会默认遍历所有的键。
    2.3按顺序遍历字典中所有键
    在for循环中对返回的键进行排序,使用函数sorted()
    2.4遍历字典中所有值
    3.嵌套
    3.1在列表中存储字典
    3.2在字典中存储列表
    当需要在字典中将一个键关联到多个值时,可以在字典中嵌套一个列表。在遍历字典的for循环中,我们需要再使用一个for循环来遍历与被调查者相关联的语言列表。
    3.3在字典中存储字典
    二.集合
    集合类似于列表,但每个元素必须是独一无二的
    可食用集合来剔除列表中的重复项,对包含重复元素的列表调用set(),可让Python找出列表中独一无二的元素,并使用这些元素来创建一个集合。

    展开全文
  • 在写程序时不能用到的python关键字 dict,list,file,bool,str,input,len 字典可以和所有标准类型...dict()工厂函数,如果不提供参数生成空字典 当容器类型对象做为一个参数传 递给方法 dict() 时很有意思。如果参

    在写程序时不能用到的python关键字

    dict,list,file,bool,str,input,len

    字典可以和所有标准类型的操作符一起工作,但不支持拼接和重复操作,

    cmp() 内建函数的:首先比较字典大小,然后是键,然后是值  ,一般不是很有用


    dict()工厂函数,如果不提供参数生成空字典

    当容器类型对象做为一个参数传
    递给方法 dict() 时很有意思。如果参数是可以迭代的,即,一个序列,或是一个迭代器,或是一个
    支持迭代的对象,那每个可迭代的元素必须成对出现。在每个值对中,第一个元素是字典的键、第
    二个元素是字典中的值

    如果输入参数是(另)一个映射对象,比如,一个字典对象,对其调用 dict()会从存在的字典里
    复制内容来生成新的字典。新生成的字典是原来字典对象的浅复制版本, 它与用字典的内建方法
    copy() 生成的字典对象是一样的。但是从已存在的字典生成新的字典速度比用 copy()方法慢,我们
    推荐使用 copy()。
    dict([['x', 1], ['y', 2]])
    dict(x=1, y=2)


    copy()函数

    dict1 = {'name':'zhangsan','age':21}

    dict2 = dict1.copy()

    print dict1,dict2

    dict2['name'] = 'tiantian'

    print dict1,dict2


    len()函数

    len(dict1)   #返回所有元素(键-值对)的数目

    字典中的元素是没有顺序的。从上面的例子中可以看到,dict2 的元素显示的顺序
    和输入时的顺序正相反。


    hash(obj) 返回 obj 的哈希值


    keys()方法,返回一个列表,包含字典中所有的键,

    values()方法,返回一个列表,包含字典中所有的值,

    items(), 返回一个包含所有(键, 值)元


    方法名字  操作
    dict.clear() 删除字典中所有元素
    dict.copy()  返回字典(浅复制)的一个副本 

    dict.fromkeys(seq, val=None)   创建并返回一个新字典,以 seq 中的元素做该字典的键,val 做该字典中所有键对应的初始值(如果不提供此值,则默认为 None) 


    dict.get(key, default=None)      对字典 dict 中的键 key,返回它对应的值 value,如果字典中不存在此键,则返回 default 的值(注意,参数 default 的默认值为 None) 


    dict.has_key(key)  如果键(key)在字典中存在,返回 True,否则返回 False. 在 Python2.2版本引入 in 和 not in 后,此方法几乎已废弃不用了,但仍提供一个可工作的接口。

    dict.items()  返回一个包含字典中(键, 值)对元组的列表 


    dict.keys()  返回一个包含字典中键的列表 


    dict.iter()方法 iteritems(), iterkeys(), itervalues()与它们对应的非迭代方法一样,不同的是它们返回一个迭代子,而不是一个列表。 


    dict.pop(key [, default])和方法 get()相似,如果字典中 key 键存在,删除并返回 dict[key],如果 key 键不存在,且没有给出 default 的值,引发 KeyError 异常。


    dict.setdefault(key, default=None)和方法 set()相似,如果字典中不存在 key 键,由 dict[key]=default 为它赋值。 


    dict.update(dict2)将字典 dict2 的键-值对添加到字典 dict 


    dict.values() 返回一个包含字典中所有值的列表

    在 Python 2.4 版本以前,你只能调用字典的 keys()方法获得键的列表,然后调用列表的 sort()
    方法得到一个有序可遍历的列表。现在特别为迭代子设计了一个名为 sorted()的内建函数,它返回
    一个有序的迭代子:
    >>> for eachKey in sorted(dict2):
    ... print 'dict2 key', eachKey, 'has value',
    dict2[eachKey]
    ...
    dict2 key name has value earth
    dict2 key port has value 80


    展开全文
  • python的集合

    2020-12-15 21:20:43
    空集合:set{}(注意:这里不能直接使用{},{}表示的是空字典python由两个表示集合的类型:set 和 frozenset(冻结集合)。两者的不同之处在于set是可变类型,而frozenset是不变类型。 要生成frozenset的对象,...

    集合(set)
    (1)集合的元素
    (2)集合的构造
    (3)集合的操作**
    写在前面:

    集合的概念来源于数学,因此,python的集合同样支持元素的判断,也支持各种重要的集合操作,并集、交集、差集等。
    表达式:{元素,…}
    空集合:set{}(注意:这里不能直接使用{},{}表示的是空字典)
    python由两个表示集合的类型:set 和 frozenset(冻结集合)。两者的不同之处在于set是可变类型,而frozenset是不变类型。
    要生成frozenset的对象,只能用frozenset(…)的形式。
    接下来主要介绍set,与元素变动无关的均适用于frozenset。

    集合的元素
    集合的元素只能是不变对象,而且必须能做相等比较(用 == 运算符)。内置的数值类型、字符串、bool对象,及他们的元组等都满足这些要求。
    元素对象具有唯一性,不会出现重复元素,元素之间也没有顺序关系。
    e.g.

    {6,6,2,2,7,7,4,4,5,5}
    {2,4,5,6,7}
    1
    2
    集合的构造
    直接描述
    e.g.

    {‘math’, ‘Math’, ‘MATH’, ‘phys’, ‘Phys’}
    {‘phys’, ‘MATH’, ‘math’, ‘Phys’, ‘Math’}

    注意:元素的排列是不能控制的

    set(…)转换
    从任意的序列或可迭代对象生成相应的集合
    e.g.

    set([3,7,5,4,9])
    {3, 4, 5, 7, 9}

    用描述式生成集合
    {生成器表达式}
    e.g.

    s = {x for x in range(5)}
    {0, 1, 2, 3, 4}

    类型转换
    tuple
    如果一个tuple的元素总能用 == 比较,就可以从它转换得到一个set对象,但顺序丢失,重复元素消去。另一方面,一个set对象总能转换得到一个tuple对象。
    list
    如果一个list里的元素都满足set对元素的要求,就可以从这个list转换得到一个set对象,但表对象的顺序丢失,消除了重复元素。另一方面,一个set对象,总能转换得到一个表对象。
    字符串
    任何字符串可以转换得到一个集合,其中的元素就是原字符串中单个字符的串,消去重复字符,顺序内定。从集合转换得到字符串得到集合的字符串表示,意思完全不同。

    特殊状况

    set() is set()
    False #两次生成的空集合(set)不是同一个对象

    frozenset() is frozenset()
    True #不会创建两个不同的不变空集

    {1, 1.0} #python认为数值1与1.0等值
    {1.0}

    {1.0, 1}
    {1}

    {1, True} #python认为True和1等值,False和0等值
    {True}

    {False, 0}
    {0}
    1
    集合的操作
    标准操作

    序列 表达式 意义
    1 len(s) 求集合长度,即集合内元素个数
    2 x in s ; x not in s 判断x是否在集合s内,是返回True,否则返回False;not in 反之
    3 for x in s: …x… 集合可作为可迭代对象使用,取得元素顺序由集合内部实现确定
    4 sorted(s) 得到集合元素排序的表
    简单实例

    #len(s)

    s = {1,2,3,4,5,6,7,8,9}
    len(s)
    9

    #x in s ; x not in s

    s = {1,2,3,4,5}
    3 in s
    True

    9 in s
    False

    #for x in s: …x…

    s = {2,7,1,‘a’,‘s’,‘d’}
    for x in s:
    print(x)

    #sorted(s)

    s = {1,5,7,2,4,5}
    sorted(s)
    [1, 2, 4, 5, 7]

    s = {‘a’,‘d’,‘z’,‘y’,‘m’}
    sorted(s)
    [‘a’, ‘d’, ‘m’, ‘y’, ‘z’]

    #调用sorted(s)时,s里不能同时用str和int,否则会报错

    s = {1,3,‘a’,‘d’}
    sorted(s)
    Traceback (most recent call last):
    File “<pyshell#28>”, line 1, in
    sorted(s)
    TypeError: ‘<’ not supported between instances of ‘int’ and ‘str’

    集合的比较

    序列 表达式 意义
    1 s1 <= s2 ; s1.issubset(s2) 当且仅当s1为s2子集时返回True
    2 s1 < s2 当且仅当s1为s2的真子集时得到True;真子集说明s2至少包含一个不属于s1的元素
    3 s1 > = s2 ; s1.issuperset(s2) 判断s1是否为s2的超集
    4 s1 > s2 判断s1是否为s2的真超集
    5 s1.isdisjoint(s2) 判断两个集合是否不想交,即有没有公共元素
    简单实例

    s1 = {1,2,3,4,5,6,7,8,9,10}
    s2 = {2,4,6,8,10}

    s1 <= s2
    False

    s1 < s2
    False

    s1 >= s2
    True

    s1 > s2
    True

    s1.isdisjoint(s2)
    False

    集合运算

    序列 表达式 意义
    1 s1.union(s2, …) ; s1/ s2(直线) 并集,生成新集合
    2 s1.intersection(s2, …) ; s1 & s2 & … 交集,生成新集合
    3 s1.difference(s2, …) ; s1 -s2 - … 生成第一个集合减去后面集合的差集
    4 s1.symmetric_difference(s2) 生成s1和s2的对称差集,包含属于s1但不属于s2,属于s2但不属于s1(即并集与交集的差集)
    5 s1.copy() 生成s1的拷贝
    简单实例

    s1 = {1,2,3,4,5,6,7,8,9,10}
    s2 = {2,4,6,8,10,12,14,16}

    s1 | s2 #表格里因无法输入 | 显示的是 \ ,正确使用时应用 |
    {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16}

    s1 & s2
    {2, 4, 6, 8, 10}

    s1 - s2
    {1, 3, 5, 7, 9}

    s1.symmetric_difference(s2)
    {1, 3, 5, 7, 9, 12, 14, 16}

    s1.copy()
    {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

    tip: 对于非运算符形式的集合运算,比如s.union(…),其实参可以是任意可迭代对象。采用运算符的形式时参数必须是集合。

    修改集合

    序列 表达式 意义
    1 s.add(x) 将元素x加入集合s
    2 s.remove(x) 从s里删除元素x,若s里无x报错
    3 s.discard(x) 如果s里有x,抛弃,若无则什么都不做
    4 s.pop() 从s里删除某个(任意的)元素并返回它,具体元素由集合内部确定。若s空,将报错
    5 s.clear() 清除s里的所有元素
    简单实例

    s = {1,7,9,‘c’,‘e’,5,‘s’}
    #s随操作不断更新

    s.add(2)
    s
    {1, 2, ‘s’, 5, ‘e’, 7, 9, ‘c’}

    s.remove(‘c’)
    s
    {1, 2, ‘s’, 5, ‘e’, 7, 9}

    s.discard(1)
    s
    {2, ‘s’, 5, ‘e’, 7, 9}

    s.pop()
    2

    s
    {‘s’, 5, ‘e’, 7, 9}

    s.clear()
    s
    set()

    集合更新操作

    序列 表达式 意义
    1 s1.update(s2, …) ; s1 /=s2 /…(直线) 修改s1,使之包含属于其他集合的元素
    2 s1.intersection_update(s2, …) ; s1 &= s2 & … 修改s1,使之只包含同属所有集合的公共元素
    3 s1.differnence_update(s2, …) ; s1 -=s2 / … 修改s1,从中去除属于其他集合的元素
    4 s1.symmetric_difference_update(s2) 修改s1,使之只包含仅属于s1或s2之一但不同时属于两者的元素
    简单实例

    s1 = {1,2,3,4,5,6,7,8,9,10}
    s2 = {2,4,6,8,10,12,14,16}

    s1 |= s2
    s1
    {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16}

    s1 &= s2
    s1
    {2, 4, 6, 8, 10, 12, 14, 16}

    s1 -= s2
    s1
    set()

    s1.symmetric_difference_update(s2)
    {2, 4, 6, 8, 10, 12, 14, 16}

    展开全文
  • Python_基本概念_列表

    2019-09-16 12:14:16
    Python_元组 Python_集合 可迭代对象、迭代器、生成器 字符串 ...在选择和循环结构中,条件表达式的值只要不是False、0(或0.0、0j等)、空值None、空列表、空元组、空集合、空字典、空字符串、空ra...

     

    Python中不需要先声明变量名及其类型,直接赋值即可

    字符串前面加字母r或R表示原始字符串,其中的特殊字符不进行转义,但字符串的最后一个字符不能是\符号

    在选择和循环结构中,条件表达式的值只要不是False0(或0.00j等)、空值None、空列表、空元组、空集合、空字典、空字符串、空range对象或其他空迭代对象,Python解释器均认为与True等价。

    变量类型:

    数字:int,flat,complex

    字符串:str  字符串支持使用+运算符进行合并以生成新的字符串

    列表:list

    字典:dict

    元组:tuple

    集合:set

    布尔型:bool

    空类型:None

    x=3
    print(type(x)) #int
    x=3.5
    print(type(x)) #float
    x=3+5j
    print(type(x)) #complex
    x='hello world'
    print(type(x)) #str
    x=[1,2,3]
    print(type(x)) #list
    x=True
    print(type(x)) #bool
    x=(2,5,6)
    print(type(x)) #tuple
    x=None
    print(type(x)) #NoneType

    条件表达式

    算术运算符:+、-、*、/、//、%、**

    关系运算符:>、<、==、<=、>=、!=,可以连续使用

    测试运算符:in、not in、is、is not

    逻辑运算符:and、or、not,注意短路求值

    位运算符:~&|^<<>>

    矩阵乘法运算符:@

    短路求值:当进行与运算时(a&&b),当a的值为False时,则直接跳过b值的判断

                      当进行或运算时(a||b),当a的值为True时,则直接跳过b值的判断 

    x=3
    y=4
    z=x+y  #7
    z=x-y    #-1
    z=x*y    #12
    z=x/y    #0.75
    z=x//y #整除运算 0
    z=x%y    #3
    z=x**y #平方运算 81
    
    z=x and y #4
    z=x or y    #3
    z=not y    #False
    

    单分支结构 

    if x :
        print("OK")

    双分支结构

    if x :
        print("Ok")
    else :
        print("No")
    # value1 if condition else value2
    print("True") if x else print("False")

    多分支结构

    #多分支
    if x==1:
        print("1")
    elif x==2 :
        print("2")
    else :
        print("3")

    Python中缩进代表代码块,取消括号

    循环结构

    #while
    while x:
        break
    #for
    list=(1,2,3)
    for x in list:
        print(x)
    else:        #如果没有break则执行else语句
        print("ok")
        #局部变量访问比全局变量快

     例题

    #编写一个程序,完成以下功能。假设由变量a,判断变量a是否为偶数,若为偶数,则输出a为偶数。无论变量a是否为偶数,都把其值输出出来。编写函数:函数功能是将学生成绩从百分制变换到等级制:
    def prin():
            if (a % 2 == 0):
                print(a)
                print("a为偶数")
            else:
                print(a)
    
    #90分及以上 A
    #80分-90分之间 B
    #70分-80分之间 C
    #60分-70分之间 D
    #60分以下 E
    def score(grade):
        if (grade >= 90):
            return "A"
        elif (grade >= 80 and a < 90):
            return "B"
        elif (grade >= 70 and a < 80):
            return "C"
        elif (grade >= 60 and a < 70):
            return "D"
        else:
            return "E"
    
    #修改猜一猜小游戏:( 使用random.randint(0, 10) )要求:可以不停猜,并提示猜大了还是猜小了,直到猜中为止。
    def game():
        ans = random.randint(0, 10)
        while True:
            num = input()
            num = int(num)
            if (num > ans):
                print("big")
            elif (num < ans):
                print("small")
            else:
                print("bingo")
                break
    #主函数调用
    if __name__=="__main__": #相当于C的main函数接口
        a = input()
        a=int(a)
        prin()
        grade=input()
        grade=int(grade)
        print(score(grade))
        game()

    Python序列:列表、元组、字典、字符串、集合等

    列表是Python中内置有序、可变序列,列表的所有元素放在一对中括号“[]”中,并使用逗号分隔开

    在Python中,一个列表中的数据类型可以各不相同,可以同时分别为整数、实数、字符串等基本类型,甚至是列表、元组、字典、集合以及其他自定义类型的对象

    [10, 20, 30, 40]
    ['crunchy frog', 'ram bladder', 'lark vomit']
    ['spam', 2.0, 5, [10, 20]]
    [['file1', 200,7], ['file2', 260,9]]
    

    列表创建

    使用=”直接将一个列表赋值给变量即可创建列表对象

    a_list = ['a', 'b', 'mpilgrim', 'z', 'example']
    a_list = []               //空列表             

    也可以使用list()函数将元组、range对象、字符串或其他类型的可迭代对象类型的数据转换为列表

    a_list = list((3,5,7,9,11))
    a_list
    //[3, 5, 7, 9, 11]
    list(range(1,10,2))
    //[1, 3, 5, 7, 9]
    list('hello world')
    //['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
    x = list()          //创建空列表                  

    列表访问

    索引访问方式:下标从0开始(可以逆向访问,从尾开始为-1)

    切片访问:[起始位置,最终位置,步长]

    list_a = list[1:4:2] #起始位置为1,终止位置为4,步长为2

    列表运算符

    列表之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制,运算后会生成一个新的列表

    表达式

    结果

    描述

    [1, 2, 3] + [4, 5, 6]

    [1, 2, 3, 4, 5, 6]

    连接

    ['Hi!’] * 4

    ['Hi!', 'Hi!', 'Hi!', 'Hi!’]

    重复

    3 in [1, 2, 3]

    True

    元素是否存在

    for x in [1, 2, 3]: print x

    1 2 3

    遍历

    列表常用方法

    方法

    说明

    lst.append(obj)

    在列表尾部添加新的元素

    lst.extend(L)

    将列表L中所有元素添加至列表lst尾部

    lst.insert(index, obj)

    在列表lst指定位置index处添加元素

    lst.remove(x)

    在列表lst中删除首次出现的指定元素

    lst.pop([index])

    删除并返回列表lst中下标为index(默认为-1)的元素

    lst.clear()

    清空列表,但保留对象

    lst.index(obj)

    从列表中找出某个值第一个匹配项的索引位置

    lst.count(obj)

    统计某元素在列表的出现次数

    lst.reverse()

    对列表lst所有元素进行逆序

    lst.sort(key=None, reverse=False)

    对列表lst中的元素进行排序,key用来指定排序依据,reverse决定升序(False)还是降序(True

    lst.copy()

    复制列表

    列表元素增加

    1)“+”运算符

    aList = [3,4,5]
    aList = aList + [7]
    #[3, 4, 5, 7]
    

    严格意义上来讲,这并不是真的为列表添加元素,而是创建了一个新列表,并将原列表中的元素和新元素依次复制到新列表的内存空间。操作速度较慢,在涉及大量元素添加时不建议使用该方法。

    2append()方法

    aList.append(9)
    aList
    #[3, 4, 5, 7, 9]
    

    在当前列表尾部追加元素,原地修改列表,是真正意义上的在列表尾部添加元素,速度较快

    所谓原地,是指不改变列表在内存中的首地址

    id(aList)前后地址是不变的。

    3extend()方法

    a = [1,2,3]
    id(a)
    #25289752
    a.extend([7,8,9])
    a
    #[1, 2, 3, 7, 8, 9]
    >>> id(a)
    #25289752
    a.extend((15,17))
    a
    [1, 2, 3, 7, 8, 9, 15, 17]
    

        可以将另一个迭代对象的所有元素添加至该列表对象尾部。通过extend()方法来增加列表元素也不改变其内存首地址,属于原地操作

    4insert()方法

    aList=[3, 4, 5, 7, 9, 11, 13, 15, 17]
    aList.insert(3, 6)                #在下标为3的位置插入元素6
    aList
    #[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
    

    将元素添加至列表的指定位置

    注意: 会引发数据的移动!

    列表元素的删除

    1del命令

    删除列表中的指定位置上的元素

    a_list = [3,5,7,9,11]
    del a_list[1]
    a_list
    #[3, 7, 9, 11]
    

    2pop()方法

    a_list = list((3,5,7,9,11))
    a_list.pop()
    #11
    a_list
    #[3, 5, 7, 9]
    a_list.pop(1)
    #5
    a_list
    #[3, 7, 9]
    

    删除并返回指定位置(默认为最后一个)上的元素,如果给定的索引超出了列表的范围则抛出异常

    (3remove()方法

    a_list = [3,5,7,9,7,11]
    a_list.remove(7)
    a_list
    #[3, 5, 9, 7, 11]
    

        删除首次出现的指定元素,如果列表中不存在要删除的元素,则抛出异常

    4clear()方法

    a_list = [3,5,7,9,7,11]
    a_list.clear()
    

      清空列表里所有元素

    列表计数

    aList
    #[3, 4, 5, 5.5, 7, 9, 11, 13, 15, 17]
    aList.count(7)
    #1
    aList.count(0)
    #0
    aList.count(8)
    #0
    

    使用列表对象的count()方法统计指定元素在列表对象中出现的次数。

    列表内置函数

    函数

    说明

    len(list)

    列表长度,即元素个数

    max(list)

    返回列表元素最大值

    min(list)

    返回列表元素最小值

    list(seq)

    将元组转成列表

    #请用索引取出下面list的指定元素
    #L = [['Apple','Google','Microsoft'],['Java','Python','Ruby','PHP'],['Adam','Bart','Lisa']]
    if __name__=="__main__":
    L = [['Apple','Google','Microsoft'],['Java','Python','Ruby','PHP'],['Adam','Bart','Lisa']]
        for index in range(len(L)):
            print(L[index])
    
    #遍历下面的列表
    #lst=['Apple','Google','Microsoft','Java','Python','Ruby','PHP']
    LST = ['Apple','Google','Microsoft','Java','Python','Ruby','PHP']
        for index in range(len(LST)):
            print(LST[index])
    x = [1,2,1,2,1,1,1]
    for i in range(len(x)-1,-1,-1):  # range(起始位置,终止位置,每次操作)
            if x[i]==1:
            del x[i]
    
    
    x = [1,2,1,2,1,1,1]
    for i in x[::]:               #x[::] : 拷贝副本          #切片
         if i == 1:
    	     x.remove(i)
    

    列表排序

    使用列表对象的sort()方法进行原地排序,支持多种不同的排序方法。

    list.sort(key=None, reverse=False) 
    >>> aList = [3, 4, 15, 11, 9, 17, 13, 6, 7, 5]
    >>> aList.sort()                          #默认升序排序
    >>> aList.sort(reverse = True)            #降序排序
    >>> aList
    [17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
    

    关键字问题

    list.sort(key=None, reverse=False)

    key=函数名,该函数的返回值作为元素的权值大小

    reverse -- 排序规则,reverse = True 降序, reverse = False 升序

    #按转换成字符串的长度排序
    >>> aList.sort(key = lambda x:len(str(x)))   #lambda : 匿名函数 返回值为表达式
    >>> aList
    [9, 7, 6, 5, 4, 3, 17, 15, 13, 11]
    

    列表排序

    使用内置函数sorted()对列表进行排序并返回新列表

    >>> aList
    [9, 7, 6, 5, 4, 3, 17, 15, 13, 11]
    >>> sorted(aList)                            #升序排序
    [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
    >>> sorted(aList,reverse = True)             #降序排序
    [17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
    

    列表逆序

    使用列表对象的reverse()方法将元素原地逆序

    >>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
    >>> aList.reverse()
    >>> aList
    [17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
    
    

    序列操作的常用内置函数1

    len(列表)返回列表中的元素个数,同样适用于元组、字典、集合、字符串等

    max(列表)min(列表)返回列表中的最大或最小元素,同样适用于元组、字典、集合、range对象等

    sum(列表)对列表的元素进行求和运算,对非数值型列表运算需要指定start参数,同样适用于元组、range

    >>> sum(range(1, 11))      #sum()函数的start参数默认为0
    55
    >>> sum(range(1, 11), 5)   #指定start参数为5,等价于5+sum(range(1,11))
    60
    >>> sum([[1, 2], [3], [4]], [])    #这个操作占用空间较大,慎用
    [1, 2, 3, 4]

    序列操作常用内置函数2zip()

    zip()函数返回可迭代的zip对象

    >>> aList = [1, 2, 3]
    >>> bList = [4, 5, 6]
    >>> cList = zip(aList, bList)                 #返回zip对象
    >>> cList
    #<zip object at 0x0000000003728908>
    >>> list(cList)                       #把zip对象转换成列表
    #[(1, 4), (2, 5), (3, 6)]

    序列操作常用内置函数3: enumerate()

    enumerate()函数用来枚举可迭代对象中的元素,返回可迭代的enumerate枚举对象,其中每个元素为包含下标和值的元组。该函数对元组、字符串同样有效

    >>> for item in enumerate('abcdef'):
        print(item)
    '''
    (0, 'a')
    (1, 'b')
    (2, 'c')
    (3, 'd')
    (4, 'e')
    (5, 'f')
    '''

    列表推导式

    列表推导式使用非常简洁的方式来快速生成满足特定需求的列表,代码具有非常强的可读性

    列表推导式语法形式为

    [expression for expr1 in sequence1 if condition1
                for expr2 in sequence2 if condition2
                for expr3 in sequence3 if condition3
                ...
                for exprN in sequenceN if conditionN]
    

    列表推导式在内部实际上是一个循环结构,只是形式更加简洁,例如:

    >>> aList = [x*x for x in range(10)]
    
    #等价于
    
    >>> aList = []
    
    >>> for x in range(10):
    
          aList.append(x*x)

    使用列表推导式实现嵌套列表的平铺

    >>> vec = [[1,2,3], [4,5,6], [7,8,9]]
    >>> [num for elem in vec for num in elem]
    [1, 2, 3, 4, 5, 6, 7, 8, 9]
    #等价于
    >>> vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    >>> result = []
    >>> for elem in vec:
        for num in elem:
      result.append(num)
    >>> result
    [1, 2, 3, 4, 5, 6, 7, 8, 9]

    例题 

    #使用random模块,随机生成一个每个数据元素都小于100且列表长度为20的列表。并调整列表元素顺序,把所有奇数都放到前面,偶数都放到后面。(注意:布尔类型可以比较大小)
    
    >>>result = [random.randint(0,100) for i in range(20)]
    >>>result.sort(key=lambda x:x%2==0,reverse = False)
    >>>    print(result)
    
    
    
    
    
    
    #aList = [-1,-4,6,7.5,-2.3,9,-11],采用列表推导式过滤掉负数并且将正数的值求平方组成一个列表。
    
    
    >>>alist = [-1,-4,6,7.5,-2.3,9,-11]
    >>>l=[i**2 for i in alist if i > 0]
    >>>  print(l)

     

    展开全文
  • 集合是没有value的字典(只有key),所以集合容许重复,集合是无序的。 集合创建方式: (1)花括号; (2)使用内置函数set()。 s1 = {1,2,3,4,5} s1 = set(range(6)) s1 = set({1,2,3,4,5}) s1 = set([1,2,2,4,...
  • Python内置函数5

    2019-09-28 00:25:57
    2.frozenset([iterable]) iterable -- 可迭代的对象,比如列表、字典、元组等等返回一个冻结的集合,冻结后集合不能再添加或删除任何元素返回新的 frozenset 对象,如果不提供任何参数,默认会生成空集合 ...
  • 集合内的数据对象都是唯一的(不能重复多次) 集合是无序的存储结构,集合中的数据没有先后关系 集合是相当于只有键,没有值的字典,则键是集合的数据、 集合内的元素必须是不可变对象 集合是可迭代的(可以用...
  • python编码的转换

    2020-04-10 23:55:20
    练习题:一个列表,排重,不能用set,也不能字典。 算法: 1、 生成一个列表result,存储排重后的元素 2、 遍历列表的每一个元素,判断是否在result列表 3、 如果在,则不做任何动作 4、 最后打印result列表 l=...
  • 本文的文字及图片来源于网络,仅供学习、交流使用,不具有任何商业...set集合由{}(花括号,大括号)包裹,注意生成空的集合不能用空的{},空的{}生成的是个空字典,列表和元组可以用这种方式生成空列表或元组。 不同的
  • python:数据类型

    2019-12-09 16:24:07
    元组不能修改,但是可以拼接生成新的元组 a = (1, 2) a = (1, 2, 3) b = (a, b ,c) c = a + b print c (1, 2, 3, a, b, c) 2.列表 列表有序的可重复的, 可修改 a = [] or a = list() 3.字典 字典是键值对, 键(ke....
  • python组合数据类型

    2021-01-24 16:38:21
    集合,里面的元素是无重复,无序的,并且其中的元素是不能被修改的,使用{}或者set()来生成一个集合(集合必须用set()来生成,{}用来生成字典) mySet = set("helloWorld") print(b) #输出为:{'W', 'd', 'l', 'o'...
  • frozenset() 返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。 语法 frozenset() 函数语法: class frozenset([iterable]) 参数 iterable – 可迭代的对象,比如列表、字典、元组等等。 返回值 ...
  • python-组合数据

    2020-06-08 10:12:35
    元组是一种序列类型,一旦创建就不能被修改 使用()和tuple()创建,元素间使用,逗号分割 可以使用,或者不使用小括号 其中creature[::-1]不改变原有元组的值,是生成了一个新的和原始元组反序的元组。 列表 列表...
  • python笔记(八)

    2018-11-22 23:36:58
    1.字典 键和值,字典是集合不是序列,里面的元素是无序的 2.字典是可变数据类型 3.由于元素是无序的,不能通过下标来访问,字典是通过键来访问的。...10.用set()函数可以创建集合,注意但不能用{}创建集合,...
  • python类型之frozenset

    千次阅读 2018-06-08 03:25:22
    描述frozenset() 返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。语法frozenset() 函数语法:1class frozenset([iterable])参数iterable -- 可迭代的对象,比如列表、字典、元组等等。返回值返回新的 ...
  • Python frozenset() 函数

    2017-10-16 18:27:00
    frozenset()返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。 语法 frozenset() 函数语法: class frozenset([iterable]) 参数 iterable -- 可迭代的对象,比如列表、字典、元组等等。 ...
  • 元组&字典&集合

    2020-08-20 14:50:28
    1. for循环和range函数 for: 语法 for i in x: … i 为一个变量,x为一个...Python的元组与列表类似,不同之处在于元组的元素不能修改。 参考资料 https://www.runoob.com/python/python-tuples.html 3 . 字典 字典
  • Python 内置函数41-50

    2020-05-25 11:42:24
    frozenset() 返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。 class frozenset([iterable]) iterable -- 可迭代的对象,比如列表、字典、元组等等。 返回新的 frozenset 对象,如果不提供任何参数,默认...
  • 描述frozenset() 返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。语法frozenset() 函数语法:class frozenset([iterable])参数iterable -- 可迭代的对象,比如列表、字典、元组等等。返回值返回新的 ...
  • set集合由{}(花括号,大括号)包裹,注意生成空的集合不能用空的{},空的{}生成的是个空字典,列表和元组可以用这种方式生成空列表或元组。 不同的元素组成(没有重复的元素) 无序 集合中的元素必须是不...
  • frozenset() 返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。 语法 frozenset() 函数语法: class frozenset([iterable]) 参数 iterable – 可迭代的对象,比如列表、字典、元组等等。 返回值 返回新...
  •  {'1', '3', 'p', 'y', '2'} 集合不能用{}生成,留个字典了, 用set()  关系操作  交 & 并 | 差 - 补^ 支持(&=, |=, -=, ^=)  关系操作符 <,<=,>,>= 判断子集关系或包含关系 >>...
  • 全模式,把句子中所有的可以成词的词语都扫描出来, 速度非常快,但是不能解决歧义; 搜索引擎模式,在精确模式的基础上,对长词再次切分,提高召回率,适合用于搜索引擎分词。 paddle模式,利用PaddlePaddle深度学习...
  • 布尔数,__nonzero__()

    2013-05-11 23:12:00
    布尔型是整型的子类,但是不能再被继承而生成它的子类 没有 __nonzero__() 方法的读写的默认值是 True 对于值为零的任何数字或空集(空列表,空元组和空字典等)在 Python 中布尔值都是 False 在数学运算中,...

空空如也

空空如也

1 2
收藏数 37
精华内容 14
关键字:

python不能生成空字典

python 订阅