精华内容
下载资源
问答
  • 原博文2018-09-18 16:01 −python 列表元组字典字典的区别 一、列表 1.任意对象的有序集合 列表是一组任意类型的值,按照一定顺序组合而成的 2.通过偏移读取 组成列表的值叫做元素(Elements)。每一个元素被...

    原博文

    2018-09-18 16:01 −

    python 列表、元组、字典、字典的区别<摘录> 一、列表 1.任意对象的有序集合 列表是一组任意类型的值,按照一定顺序组合而成的 2.通过偏移读取 组成列表的值叫做元素(Elements)。每一个元素被标识一个索引,第一个索引是0,序列的功能都能实现&...

    comment.png

    0

    attention.png

    15173

    相关推荐

    2019-12-19 10:17 −

    一、python基本数据类型:python3有6个标准的数据类型(区别于数字类型):  1、Number(数字): a、当你指定一个值的时候,Number对象就会被创建,如var1 = 1。另外,一个变量可以通过赋值指向不同类型的对象。 b、内置的type()可以用来查询变量所指的对象类型。 ...

    2019-12-07 20:55 −

    一、深入python的set和dict

    1.1、dict的abc继承关系

    from collections.abc import Mapping,MutableMapping

    #dict属于mapping类型

    a = {} #字典a不是继承MutableMapping,而是实现了MutableMa...

    2019-12-25 11:52 −

    在程序中,被运算的可分为常量(Literals)和变量(Variables)

    1x = 10*2-5

    2y = x+1

    以上的变量都属于Python数据类型中的一部分。

    在以上代码中,10、2、5都是常量;x、y都是变量,表示值是可变的。第一行的 * - 属于操作符,= 属于赋值符号

    ...

    2019-12-13 21:30 −

    ### 一、字典的初识 + **为什么要有字典** 字典与列表同属容器型数据类型,同样可以存储大量的数据,但是,列表的数据关联性不强,并且查询速度比较慢,只能按照顺序存储。 + **什么是字典** + 先说一下什么叫可变与不可变的数据类型分类 + 不可变(可哈希)数据类型:int, s...

    2019-12-23 21:01 −

    在python变量中除了以前文章所提到的整形int / 浮点数float / 布尔值bool / 列表list / 字典dict 之外,还有一个类型我们还没有做详细介绍,这个变量类型就是集合s...

    2019-12-20 11:56 −

    ### 变量

    定义: 变量来源于数学,是计算机语言中能储存计算结果或能表示值抽象概念。(百度百科) 变量命名规则:

    - 开头以字母或者下划线_,剩下的字符数字字母或者下划线

    - Python遵循小驼峰命名法

    - 不能使用Python中的关键字进行命名 #### 声明变量

    Python不需要申明变量,变...

    2019-12-20 17:45 −

    一、

    Python 是一种解释型语言

    Python 是交互式语言

    Python 是面向对象语言

    二、

    Python 通常是一行写完一条语句,但如果语句很长,我们可以使用反斜杠(\)来实现多行语句,在 [], {}, 或 () 中的多行语句,不需要使用反斜杠(\)。

    三、

    python中数字有四种类型:...

    2019-12-18 17:59 −

    八种数据类型分别是:

    number(数字)、string(字符串)、Boolean(布尔值)、None(空值)

    list(列表)、tuple(元组)、dict(字典)、set(集合)

    1.number(数字类型)

    数字类型转换: int(x)&nbs...

    comment.png

    0

    attention.png

    483

    2019-12-22 16:29 −

    python的各种推导式(列表推导式、字典推导式、集合推导式)

    推导式comprehensions(又称解析式),是Python的一种独有特性。推导式是可以从一个数据序列构建另一个新的数据序列的结构体。 共有三种推导,在Python2和3中都有支持:

    列表(list)推导式

    字典(dict)推导...

    2019-09-27 14:25 −

    9-2 python之迭代dict的value 我们已经了解了dict对象本身就是可迭代对象,用 for 循环直接迭代 dict,可以每次拿到dict的一个key。 如果我们希望迭代 dict 对象的value,应该怎么做? dict 对象有一个 values() 方法,这个方法把dict转...

    展开全文
  • ----列表集合字典排序sorted ----字符串、列表集合元组字典比较集合求差集、交集、并集并集交集差集数据转换:字典格式的字符串/ json对象转为字典两个列表/元组/集合 转为字典字典转为列表/元组/集合嵌套...

    符串、列表、元组、集合、字典对比

    字符串str列表list元组tuple集合set字典dict
    索引、切片、相加和相乘索引、切片、相加和相乘索引、切片、相加和相乘--
    不可变可变不可变可变可变
    有序有序有序无序无序
    -值可重复值可重复值不可重复key不可重复
    bool(’’) is Falsebool([]) is Falsebool(()) is Falsebool(set()) is Falsebool({}) is False
    排序值同类型可排序值同类型可排序值同类型可排序key值同类型可排序
    -元素可以是任意类型元素可以是任意类型元素必须是不可变的:字符串、数字、元组key值必须是不可变的:字符串、数字、元组,value任意类型

    说明
    有序/无序:是否可通过下标访问
    可变/不可变:指存储位置不变、type也不变的情况下,值是否可变,可使用id(变量名)来查看存储位置

    数据操作

    索引----字符串、列表、元组

    n个元素索引下标从0依次递增到n-1,或者负数索引从-n到-1
    eg:

    print("abcd"[1])   #输出结果b
    print([1,2,3][0])   #输出结果1
    print((1,2,3)[1])#输出结果2
    

    切片----字符串、列表、元组

    语法:seqname[start : end : step] ,输出子序列
    start :默认0,取值包含此位置
    end:默认序列长度,取值不包含此位置
    step: 间隔几个存储位置取一次元素,默认1,可不写
    eg:

    print("abcd"[:3:2])  #输出结果“ac”
    print([1,2,3][:3:2])  #输出结果[1, 3]
    print((1,2,3)[:3:2])  #输出结果(1, 3)
    

    相加/相乘----字符串、列表、元组

    相加

    print("ab"+"cd")   #输出结果“abcd”
    print([1,2,3]+[1])   #输出结果[1, 2, 3, 1]
    print((1, 2, 3) + (2,))   #输出结果(1, 2, 3, 2)
    
    

    相乘

    print("ab"*2)  #输出结果"abab"
    print([1,2,3]*2)    #输出结果[1, 2, 3, 1, 2, 3]
    print((1, 2, 3) * 2)   #输出结果(1, 2, 3, 1, 2, 3)
    
    

    增加值----列表、字典、集合

    l=[1,2]
    l.append("a")
    l.append([1.2,3])
    print(l)      #输出结果[1, 2, 'a', [1.2, 3]]
    d={"a":1,3:2}
    d['bb']=1
    print(d)        #输出结果{'a': 1, 3: 2, 'bb': 1}
    se={1,2}
    se.add("a")
    se.add((1,2))
    se.update([1,2,4,5])
    print(se)   #输出结果{(1, 2), 1, 2, 4, 5, 'a'}
    

    修改元素----字符串、列表、字典

    s='abc'
    s=s.replace("a","AA")
    print(s)   #输出结果AAbc
    l=[1,2,3]
    l[0]=101
    print(l)    #输出结果[101, 2, 3]
    d={"a":1,3:2}
    d["a"]=101
    print(d)    #输出结果{'a': 101, 3: 2}
    

    删除元素 ----列表、集合、字典

    l=[1,5,2]
    se={1,7,2}
    d={"d":2,"b":1,"a":1}
    del l[0]   #或者l.remove(1) ,或者l.pop(0)
    print(l)  #输出结果[5, 2]
    del d["a"]
    print(d) #输出结果{'d': 2, 'b': 1}
    se.remove(1)
    print(se) #输出结果{2, 7}
    

    排序sorted ----字符串、列表、集合、元组、字典

    说明:列表、集合、元组、字典只有元素的类型一致才能排序

    s="1ab2"
    l=[1,5,2]
    t=("c","a","b")
    se={1,7,2}
    d={"d":2,"b":1,"a":1
    }print(sorted(s))    #输出结果['1', '2', 'a', 'b']
    print(sorted(l))   #输出结果[1, 2, 5]
    print(sorted(t))    #输出结果['a', 'b', 'c']
    print(sorted(se))   #输出结果[1, 2, 7]
    print(sorted(d))    #输出结果['a', 'b', 'd']
    
    

    比较

    说明 :需要对于有序的序列,若顺序不一样比较的结果是false
    直接使用 > == < !=符号进行比较

    print([1,2,3]==[1,3,2])   #输出结果False
    print((1,2)<(2,3))   #输出结果True
    

    集合求差集、交集、并集

    并集

    {1,7,2}.union({1,3,5,2})  或者{1,7,2}|{1,3,5,2}       #结果{1, 2, 3, 5, 7}
    

    交集

    {1,7,2}.intersection({1,3,5,2})或者  {1,7,2}&{1,3,5,2}  # 结果{1,2}}
    

    差集

    {1,7,2}.difference({1,3,5,2})  或者{1,7,2}-{1,3,5,2}  #结果{7}
    

    数据转换:

    原数据类型字符串str列表list元组tuple集合set字典dict
    字符串-list(str)tuple(str)set(str)-
    列表list中数据类型是字符串:’’.join(list) list中数据类型不是字符串:’’.join(str(i) for i in list) 或者’’.join(map(str,list))-tuple(list)set(list)-
    元组同上list(tuple)-(tuple)
    集合同上list(set)tuple(set)-
    字典json.dumps(dict)----

    字典格式的字符串/ json对象转为字典

    s='{"a":1,"b":2,"c":4}'
    d=json.loads(s)   #输出结果 {'a': 1, 'b': 2, 'c': 4}
    
    

    两个列表/元组/集合 转为字典

    list1=['a',"b"]
    list2=[1,2]
    print(dict(zip(list1,list2)))   #输出结果 {'a': 1, 'b': 2}
    
    

    字典转为列表/元组/集合

    d={"a":1,"b":8,"c":4}
    print(list(d.keys()))   #输出结果 ['a','b','c']
    print(list(d.values()))  #输出结果 [1,2,3]
    

    嵌套的列表/元组/集合转为字典

    说明:嵌套的元素的元素个数必须是两个

    list3=[['a',1],['b',2],['d',2]]
    print(dict(list3))  #输出结果 {'a': 1, 'b': 2,'d':2}
    
    
    展开全文
  • 目录1、字符串2、布尔类型3、整数4、浮点数5、数字6、列表7、元组8、字典9、日期1、字符串1.1、如何在Python中使用字符串a、使用单引号(')用单引号括起来表示字符串,例如:str='this is string';print str;b、使用...

    目录

    1、字符串

    2、布尔类型

    3、整数

    4、浮点数

    5、数字

    6、列表

    7、元组

    8、字典

    9、日期

    1、字符串

    1.1、如何在Python中使用字符串

    a、使用单引号(')

    用单引号括起来表示字符串,例如:

    str='this is string';

    print str;

    b、使用双引号(")

    双引号中的字符串与单引号中的字符串用法完全相同,例如:

    str="this is string";

    print str;

    c、使用三引号(''')

    利用三引号,表示多行的字符串,可以在三引号中自由的使用单引号和双引号,例如:

    str='''this is string

    this is pythod string

    this is string'''

    print str;

    2、布尔类型

    bool=False;

    print bool;

    bool=True;

    print bool;

    3、整数

    int=20;

    print int;

    4、浮点数

    float=2.3;

    print float;

    5、数字

    包括整数、浮点数。

    5.1、删除数字对象引用,例如:

    a=1;

    b=2;

    c=3;

    del a;

    del b, c;

    #print a; #删除a变量后,再调用a变量会报错

    5.2、数字类型转换

    int(x [,base]) 将x转换为一个整数

    float(x ) 将x转换到一个浮点数

    complex(real [,imag]) 创建一个复数

    str(x) 将对象x转换为字符串

    repr(x) 将对象x转换为表达式字符串

    eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象

    tuple(s) 将序列s转换为一个元组

    list(s) 将序列s转换为一个列表

    chr(x) 将一个整数转换为一个字符

    unichr(x) 将一个整数转换为Unicode字符

    ord(x) 将一个字符转换为它的整数值

    hex(x) 将一个整数转换为一个十六进制字符串

    oct(x) 将一个整数转换为一个八进制字符串

    5.3、数学函数

    abs(x) 返回数字的绝对值,如abs(-10) 返回 10

    ceil(x) 返回数字的上入整数,如math.ceil(4.1) 返回 5

    cmp(x, y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1

    exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045

    fabs(x) 返回数字的绝对值,如math.fabs(-10) 返回10.0

    floor(x) 返回数字的下舍整数,如math.floor(4.9)返回 4

    log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0

    log10(x) 返回以10为基数的x的对数,如math.log10(100)返回 2.0

    max(x1, x2,...) 返回给定参数的最大值,参数可以为序列。

    min(x1, x2,...) 返回给定参数的最小值,参数可以为序列。

    modf(x) 返回x的整数部分与小数部分,两部分的数值符号与x相同,整数部分以浮点型表示。

    pow(x, y) x**y 运算后的值。

    round(x [,n]) 返回浮点数x的四舍五入值,如给出n值,则代表舍入到小数点后的位数。

    sqrt(x) 返回数字x的平方根,数字可以为负数,返回类型为实数,如math.sqrt(4)返回 2+0j

    6、列表

    6.1、初始化列表,例如:

    list=['physics', 'chemistry', 1997, 2000];

    nums=[1, 3, 5, 7, 8, 13, 20];

    6.2、访问列表中的值,例如:

    '''nums[0]: 1'''

    print "nums[0]:", nums[0]'''nums[2:5]: [5, 7, 8] 从下标为2的元素切割到下标为5的元素,但不包含下标为5的元素'''

    print "nums[2:5]:", nums[2:5]'''nums[1:]: [3, 5, 7, 8, 13, 20] 从下标为1切割到最后一个元素'''

    print "nums[1:]:", nums[1:]'''nums[:-3]: [1, 3, 5, 7] 从最开始的元素一直切割到倒数第3个元素,但不包含倒数第三个元素'''

    print "nums[:-3]:", nums[:-3]'''nums[:]: [1, 3, 5, 7, 8, 13, 20] 返回所有元素'''

    print "nums[:]:", nums[:]

    6.3、更新列表,例如:

    nums[0]="ljq";

    print nums[0];

    6.4、删除列表元素

    del nums[0];

    '''nums[:]: [3, 5, 7, 8, 13, 20]'''

    print "nums[:]:", nums[:];

    6.5、列表脚本操作符

    列表对+和*的操作符与字符串相似。+号用于组合列表,*号用于重复列表,例如:

    print len([1, 2, 3]); #3

    print [1, 2, 3] + [4, 5, 6]; #[1, 2, 3, 4, 5, 6]

    print ['Hi!'] * 4; #['Hi!', 'Hi!', 'Hi!', 'Hi!']

    print 3 in [1, 2, 3] #True

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

    6.6、列表截取

    L=['spam', 'Spam', 'SPAM!'];

    print L[2]; #'SPAM!'

    print L[-2]; #'Spam'

    print L[1:]; #['Spam', 'SPAM!']

    6.7、列表函数&方法

    list.append(obj) 在列表末尾添加新的对象

    list.count(obj) 统计某个元素在列表中出现的次数

    list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)

    list.index(obj) 从列表中找出某个值第一个匹配项的索引位置,索引从0开始

    list.insert(index, obj) 将对象插入列表

    list.pop(obj=list[-1]) 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值

    list.remove(obj) 移除列表中某个值的第一个匹配项

    list.reverse() 反向列表中元素,倒转

    list.sort([func]) 对原列表进行排序

    7、元组(tuple)

    Python的元组与列表类似,不同之处在于元组的元素不能修改;元组使用小括号(),列表使用方括号[];元组创建很简单,只需要在括号中添加元素,并使用逗号(,)隔开即可,例如:

    tup1 = ('physics', 'chemistry', 1997, 2000);

    tup2 = (1, 2, 3, 4, 5 );

    tup3 = "a", "b", "c", "d";

    创建空元组,例如:tup = ();

    元组中只有一个元素时,需要在元素后面添加逗号,例如:tup1 = (50,);

    元组与字符串类似,下标索引从0开始,可以进行截取,组合等。

    7.1、访问元组

    tup1 = ('physics', 'chemistry', 1997, 2000);

    #tup1[0]: physics

    print "tup1[0]: ", tup1[0]

    #tup1[1:5]: ('chemistry', 1997)

    print "tup1[1:5]: ", tup1[1:3]

    7.2、修改元组

    元组中的元素值是不允许修改的,但我们可以对元组进行连接组合,例如:

    tup1 = (12, 34.56);

    tup2 = ('abc', 'xyz');

    # 以下修改元组元素操作是非法的。

    # tup1[0] = 100;

    # 创建一个新的元组

    tup3 = tup1 + tup2;

    print tup3; #(12, 34.56, 'abc', 'xyz')

    7.3、删除元组

    元组中的元素值是不允许删除的,可以使用del语句来删除整个元组,例如:

    tup = ('physics', 'chemistry', 1997, 2000);

    print tup;

    del tup;

    7.4、元组运算符

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

    191506177878024.png

    7.5、元组索引&截取

    L = ('spam', 'Spam', 'SPAM!');

    print L[2]; #'SPAM!'

    print L[-2]; #'Spam'

    print L[1:]; #['Spam', 'SPAM!']

    7.6、元组内置函数

    cmp(tuple1, tuple2) 比较两个元组元素。

    len(tuple) 计算元组元素个数。

    max(tuple) 返回元组中元素最大值。

    min(tuple) 返回元组中元素最小值。

    tuple(seq) 将列表转换为元组。

    8、字典

    8.1、字典简介

    字典(dictionary)是除列表之外python中最灵活的内置数据结构类型。列表是有序的对象结合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。

    字典由键和对应的值组成。字典也被称作关联数组或哈希表。基本语法如下:

    dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'};

    也可如此创建字典:

    dict1 = { 'abc': 456 };

    dict2 = { 'abc': 123, 98.6: 37 };

    每个键与值必须用冒号隔开(:),每对用逗号分割,整体放在花括号中({})。键必须独一无二,但值则不必;值可以取任何数据类型,但必须是不可变的,如字符串,数或元组。

    8.2、访问字典里的值

    #!/usr/bin/python

    dict = {'name': 'Zara', 'age': 7, 'class': 'First'};

    print "dict['name']: ", dict['name'];

    print "dict['age']: ", dict['age'];

    8.3、修改字典

    向字典添加新内容的方法是增加新的键/值对,修改或删除已有键/值对如下实例:

    #!/usr/bin/python

    dict = {'name': 'Zara', 'age': 7, 'class': 'First'};

    dict["age"]=27; #修改已有键的值

    dict["school"]="wutong"; #增加新的键/值对

    print "dict['age']: ", dict['age'];

    print "dict['school']: ", dict['school'];

    8.4、删除字典

    del dict['name']; # 删除键是'name'的条目

    dict.clear(); # 清空词典所有条目

    del dict ; # 删除词典

    例如:

    #!/usr/bin/python

    dict = {'name': 'Zara', 'age': 7, 'class': 'First'};

    del dict['name'];

    #dict {'age': 7, 'class': 'First'}

    print "dict", dict;

    注意:字典不存在,del会引发一个异常

    8.5、字典内置函数&方法

    cmp(dict1, dict2) 比较两个字典元素。

    len(dict) 计算字典元素个数,即键的总数。

    str(dict) 输出字典可打印的字符串表示。

    type(variable) 返回输入的变量类型,如果变量是字典就返回字典类型。

    radiansdict.clear() 删除字典内所有元素

    radiansdict.copy() 返回一个字典的浅复制

    radiansdict.fromkeys() 创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值

    radiansdict.get(key, default=None) 返回指定键的值,如果值不在字典中返回default值

    radiansdict.has_key(key) 如果键在字典dict里返回true,否则返回false

    radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组

    radiansdict.keys() 以列表返回一个字典所有的键

    radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不已经存在于字典中,将会添加键并将值设为default

    radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里

    radiansdict.values() 以列表返回字典中的所有值

    9、日期和时间

    9.1、获取当前时间,例如:

    import time, datetime;

    localtime = time.localtime(time.time())

    #Local current time : time.struct_time(tm_year=2014, tm_mon=3, tm_mday=21, tm_hour=15, tm_min=13, tm_sec=56, tm_wday=4, tm_yday=80, tm_isdst=0)

    print "Local current time :", localtime

    说明:time.struct_time(tm_year=2014, tm_mon=3, tm_mday=21, tm_hour=15, tm_min=13, tm_sec=56, tm_wday=4, tm_yday=80, tm_isdst=0)属于struct_time元组,struct_time元组具有如下属性:

    211622336621063.png

    9.2、获取格式化的时间

    可以根据需求选取各种格式,但是最简单的获取可读的时间模式的函数是asctime():

    2.1、日期转换为字符串

    首选:print time.strftime('%Y-%m-%d %H:%M:%S');

    其次:print datetime.datetime.strftime(datetime.datetime.now(), '%Y-%m-%d %H:%M:%S')

    最后:print str(datetime.datetime.now())[:19]

    2.2、字符串转换为日期

    expire_time = "2013-05-21 09:50:35"

    d = datetime.datetime.strptime(expire_time,"%Y-%m-%d %H:%M:%S")

    print d;

    9.3、获取日期差

    oneday = datetime.timedelta(days=1)

    #今天,2014-03-21

    today = datetime.date.today()

    #昨天,2014-03-20

    yesterday = datetime.date.today() - oneday

    #明天,2014-03-22

    tomorrow = datetime.date.today() + oneday

    #获取今天零点的时间,2014-03-21 00:00:00

    today_zero_time = datetime.datetime.strftime(today, '%Y-%m-%d %H:%M:%S')

    #0:00:00.001000

    print datetime.timedelta(milliseconds=1), #1毫秒

    #0:00:01

    print datetime.timedelta(seconds=1), #1秒

    #0:01:00

    print datetime.timedelta(minutes=1), #1分钟

    #1:00:00

    print datetime.timedelta(hours=1), #1小时

    #1 day, 0:00:00

    print datetime.timedelta(days=1), #1天

    #7 days, 0:00:00

    print datetime.timedelta(weeks=1)

    9.4、获取时间差

    #1 day, 0:00:00

    oneday = datetime.timedelta(days=1)

    #今天,2014-03-21 16:07:23.943000

    today_time = datetime.datetime.now()

    #昨天,2014-03-20 16:07:23.943000

    yesterday_time = datetime.datetime.now() - oneday

    #明天,2014-03-22 16:07:23.943000

    tomorrow_time = datetime.datetime.now() + oneday

    注意时间是浮点数,带毫秒。

    那么要获取当前时间,需要格式化一下:

    print datetime.datetime.strftime(today_time, '%Y-%m-%d %H:%M:%S')

    print datetime.datetime.strftime(yesterday_time, '%Y-%m-%d %H:%M:%S')

    print datetime.datetime.strftime(tomorrow_time, '%Y-%m-%d %H:%M:%S')

    9.5、获取上个月最后一天

    last_month_last_day = datetime.date(datetime.date.today().year,datetime.date.today().month,1)-datetime.timedelta(1)

    9.6、字符串日期格式化为秒数,返回浮点类型:

    expire_time = "2013-05-21 09:50:35"

    d = datetime.datetime.strptime(expire_time,"%Y-%m-%d %H:%M:%S")

    time_sec_float = time.mktime(d.timetuple())

    print time_sec_float

    9.7、日期格式化为秒数,返回浮点类型:

    d = datetime.date.today()

    time_sec_float = time.mktime(d.timetuple())

    print time_sec_float

    9.8、秒数转字符串

    time_sec = time.time()

    print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time_sec))

    展开全文
  • 列表 元组 字典 集合的区别是python面试中最常见的一个问题。这个问题虽然很基础,但确实能反映出面试者的基础水平。  (1)列表  什么是列表呢?我觉得列表就是我们日常生活中经常见到的清单。比如,统计过去一...

    列表 元组 字典 集合的区别是python面试中最常见的一个问题。这个问题虽然很基础,但确实能反映出面试者的基础水平。

        (1)列表

         什么是列表呢?我觉得列表就是我们日常生活中经常见到的清单。比如,统计过去一周我们买过的东西,把这些东西列出来,就是清单。由于我们买一种东西可能不止一次,所以清单中是允许有重复项的。如果我们扩大清单的范围,统计我们过去一周所有的花费情况,那么这也是一个清单,但这个清单里会有类别不同的项,比如我们买东西是一种花费,交水电费也是一种花费,这些项的类型是可以使不同的。python的列表个跟清单的道理是一样的,特点就是:可重复,类型可不同。类型不同也是跟数组最本质的区别了。python里的列表用“[]”表示:  

      lst = ['arwen',123]
      print lst[0] 
      print lst[1]

      lst[0] = 'weiwen'

      向list中添加项有两种方法:append和extend。append是向

      如:

      (2)元组

      元组和列表在结构上没有什么区别,唯一的差异在于元组是只读的,不能修改。元组用“()”表示,如:

      tup = ('arwen',123)
      print tup[0]
      print tup[1]

      (3)集合就是我们数学学的集合,没有什么特殊的定义。集合最好的应用是去重。集合没有特殊的表示方法,而是通过一个set函数转换成集合,如:

      lst = [ 1, 1, 0]

      lst_set = set( lst )  #lst_set 为1 , 0

      tup = (2, 2, 1)

      tup_set = set( tup) # tup_set为2 , 1

      for item in lst_set:

        print item

      (4)最后一个是字典。字典存储键值对数据,如:

      1:a,2:b,3:c

      字典最外面用大括号,每一组用冒号连起来,然后各组用逗号隔开。

      字典最大的价值是查询,通过键,查找值。

     numpy中封装的array有很强大的功能,里面存放的都是相同的数据类型

    Numpy matrices必须是2维的,但是 numpy arrays (ndarrays) 可以是多维的(1D,2D,3D····ND). Matrix是Array的一个小的分支,包含于Array。所以matrix 拥有array的所有特性。

    在numpy中matrix的主要优势是:相对简单的乘法运算符号。例如,a和b是两个matrices,那么a*b,就是矩阵积。

    import numpy as np
    
    a=np.mat('4 3; 2 1')
    b=np.mat('1 2; 3 4')
    print(a)
    # [[4 3]
    #  [2 1]]
    print(b)
    # [[1 2]
    #  [3 4]]
    print(a*b)
    # [[13 20]
    #  [ 5  8]]

     matrix 和 array 都可以通过objects后面加.T 得到其转置。但是 matrix objects 还可以在后面加 .H f得到共轭矩阵, 加 .I 得到逆矩阵。

    相反的是在numpy里面arrays遵从逐个元素的运算,所以array:c 和d的c*d运算相当于matlab里面的c.*d运算。

    c=np.array([[4, 3], [2, 1]])
    d=np.array([[1, 2], [3, 4]])
    print(c*d)
    # [[4 6]
    #  [6 4]]

    而矩阵相乘,则需要numpy里面的dot命令 :

    print(np.dot(c,d))
    # [[13 20]
    #  [ 5  8]]

     ** 运算符的作用也不一样 :

    print(a**2)
    # [[22 15]
    #  [10  7]]
    print(c**2)
    # [[16  9]
    #  [ 4  1]]

    因为a是个matrix,所以a**2返回的是a*a,相当于矩阵相乘。而c是array,c**2相当于,c中的元素逐个求平方。

    问题就出来了,如果一个程序里面既有matrix 又有array,会让人脑袋大。但是如果只用array,你不仅可以实现matrix所有的功能,还减少了编程和阅读的麻烦。

    当然你可以通过下面的两条命令轻松的实现两者之间的转换:np.asmatrixnp.asarray

    对我来说,numpy 中的array与numpy中的matrix,matlab中的matrix的最大的不同是,在做归约运算时,array的维数会发生变化,但matrix总是保持为2维。例如下面求平均值的运算

    >>> m = np.mat([[1,2],[2,3]])
    >>> m
    matrix([[1, 2],
            [2, 3]])
    >>> mm = m.mean(1)
    >>> mm
    matrix([[ 1.5],
            [ 2.5]])
    >>> mm.shape
    (2, 1)
    >>> m - mm
    matrix([[-0.5,  0.5],
            [-0.5,  0.5]])

    对array 来说

    >>> a = np.array([[1,2],[2,3]])
    >>> a
    array([[1, 2],
           [2, 3]])
    >>> am = a.mean(1)
    >>> am.shape
    (2,)
    >>> am
    array([ 1.5,  2.5])
    >>> a - am #wrong
    array([[-0.5, -0.5],
           [ 0.5,  0.5]])
    >>> a - am[:, np.newaxis]  #right
    array([[-0.5,  0.5],
           [-0.5,  0.5]])

    展开全文
  • Python有6个序列的内置类型,但最常见的是列表元组。序列都可以进行的操作包括索引,切片,加,乘,检查成员。此外,Python已经内置确定序列的长度以及确定最大和最小的元素的方法。列表是最常用的Python数据类型...
  • 目录 3.1 Python 列表 3.2 Python 元组 3.3 Python 字典 3.4 Python 集合3.1 Python列表3.1.1 Python列表的概述列表的定义:列表是一个有序的,可修改的,元素以逗号分割,以中括号包围的序列。3.1.2 Python列表的...
  • 列表list 定义符号:[] 创建:[]直接创建 , list() 可变性:可变 是否有序:有序 元素是否重复:可以重复 切片:支持切片 索引:支持索引 访问:索引访问 删除: del() list.remove(value) list.pop() 修改插入...
  • 如果使用一对引号来定义字符串,当出现符号冲突时可以使用转移字符 在字符串前添加r可以表达字符串的原生内容 使用三个单引号、双引号定义的字符串可以包裹任意文本 5.1.1 字符串的输入输出 input获取的数据,都以...
  • 列表元组字典集合的区别 数据结构 是否可变 是否重复 是否有序 定义符号 列表(list) 可变 可重复 有序 [ ] 元组(tuple) 不可变 可重复 有序 ( ) 字典...
  • 列表元组字典

    2020-12-12 13:42:23
    列表元组字典 1. 通用序列操作 Pyhton中有六种内置序列:列表元组、字符串、Unicode字符串、buffer对象和xrange对象,其中列表元组和字符串这三种序列是最常见的。 Python中的大部分序列都可以进行通用操作...
  • """ set---->增加元素: add(), update() ...符号操作: - : 差集 相当于difference() & : 交集 相当于intersection() | : 并集 相当于union() ^ : 对称差集 """
  • Python列表元组集合字典的操作及列表字典时间复杂度的比较 列表 元组 字典 集合 是否可变 可变 不可变 可变 可变 是否有序 有序 有序 可变 可变 元素是否重复 可重复 可重复 键不可重复 不可...
  • 一、列表元组字典以及集合的对比图表 列表元组字典以及集合的对比图表 列表 list 元组 tuple 字典 dict 集合 set 可否修改 可变 不可变 可变 可变 可否重复 可以 ...
  • 本文是元组 字典集合的学习笔记!
  • unicode() chr() ord() 大小写转化:lower() upper() swapcase() title() capitalize() 字符串不变性 去空格和特殊符号:strip() strip(str1) lstrip() rstrip() 字符串对齐,填充:ljust(width) rjust(width) ...
  • 1,列表元组字典集合 1.1,概念 列表(list):是长度可变有序的数据存储器,可通过下标索引取到相应的数据。 元组(tuple):固定长度不可变的顺序容器,访问效率高,适合存储一些长常量数据,可以作为...
  • 本篇文章介绍Python的列表元组字典集合。快来跟我一起学习吧!         列表元组字典集合都是Python内置的数据类型。 一、列表List 1.定义列表 1.格式.
  • 转载自:http://hi.baidu.com/yangdaming1983/item/fa9f8fc24c7cdb55ad00ef96python中,有3种内建的数据结构:列表元组字典。1.列表list是处理一组有序项目的数据结构,即你可以在一个列表中存储一个序列的项目。...
  • 列表元组字典集合都是Python中的数据类型,用于存放数据,他们区别总结如下: 列表list 元组tuple 字典dictionary 集合set 是否可变 可变 不可变 可变 可变 是否有序 有序 ...
  • 列表中的数据类型可以包含多种,包含数字、字符串、字典、布尔型等,并且列表中还可以嵌套列表 print(type([1, 2, 3, 4, 5, 6])) print(type(['Hello', 'World', 1, 6])) print(type(['Hello', 1, 2, True, 'a'])) ...
  • 数组,列表元组集合字典 数组:存储同一种数据类型的数据结构[1,2,3,4] 列表:可以存储不同数据类型的数据结构[1,2,3,3.4,”hello”] 元组:可以存储不同数据类型的数据,不可添加和删除元素(“name1”,...
  • 文章目录总结:字符串、列表元组字典集合1.字符串2.列表3.元组4.字典5.集合 可能有些地方不太清楚,随时修改 总结:字符串、列表元组字典集合 字符串 列表 元组 字典 集合 ...
  • 列表元组字典集合,都用于存放数据,它们区别总结如下: 列表 元组 字典 集合 关键字 list tuple dict set 是否可变 可变 不可变 可变 可变 是否有序 有序 有序 无序 无序 元素是否重复 可重复...
  • 列表元组字典集合属于python里四种数据存储容器,四种容器各有各的特点,我们在这四种容器中无非就是 增删改查 ,下面我们分别来看一下。 一、列表 1.列表的创建 (1)list1=[1,'李四','19.9',{key:value},...
  • 列表 元组 字典 集合 是否可变 可变 不可变 可变 可变 是否有序 有序 有序 ...
  • 列表: 是一种可以存储多个值得数据容器 内容是有序的 可以存储任何数据类型 可以存储重复的元素 是可变类型(当内容发生变化时id不变) 元组: 也是一种可以存储多个值得数据容器 元组中的元素不可以被修改 ...
  • 列表list 元组tuple 字典dictionary 集合set 是否可变 可变 不可变 可变 可变 是否有序 有序 有序 无序 无序 ...
  • python序列sequence3.1 序列详解3.1.1 基本概念3.1.2 序列基本操作3.1.3 序列操作内置函数3.2 列表 list3.3 元组 tuple3.4 字典 dict3.5 集合 set 3. python序列sequence 3.1 序列详解 3.1.1 基本概念 序列:一块...
  • python中常用容器数据类型主要有列表元组字典集合,本章将深入浅出的对每个类型进行详细说明。 列表 Python序列类似于其他语言中的数组,但功能要强大很多。Python中常用的序列结构有列表元组、字符串...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,730
精华内容 6,292
关键字:

列表集合元组字典符号