zoukankan      html  css  js  c++  java
  • python 数据类型 变量 列表 元组 字典 集合

    Python中,能够直接处理的数据类型有以下几种:

    整数

    Python可以处理任意大小的整数,当然包括负整数,在程序中的表示方法和数学上的写法一模一样,例如:1100-80800,等等。

    浮点数

    浮点数也就是小数,之所以称为浮点数,是因为按照科学记数法表示时,一个浮点数的小数点位置是可变的,比如,1.23x109和12.3x108是完全相等的。浮点数可以用数学写法,如1.233.14-9.01,等等。但是对于很大或很小的浮点数,就必须用科学计数法表示,把10用e替代,1.23x109就是1.23e9,或者12.3e8,0.000012可以写成1.2e-5,等等。

    整数和浮点数在计算机内部存储的方式是不同的,整数运算永远是精确的(除法难道也是精确的?是的!),而浮点数运算则可能会有四舍五入的误差。

    字符串

    字符串是以单引号'或双引号"括起来的任意文本,比如'abc',"xyz"等等。当然单引号‘和双引号"本身也是字符,如果字符串中有单引号'或双引号"则按照如下的方法处理

    字符串的方法

    name.capitalize()  首字母大写
    name.casefold()   大写全部变小写
    name.center(50,"-")  输出 '---------------------Alex Li----------------------'
    name.count('lex') 统计 lex出现次数
    name.encode()  将字符串编码成bytes格式
    name.endswith("Li")  判断字符串是否以 Li结尾
     "Alex	Li".expandtabs(10) 输出'Alex      Li', 将	转换成多长的空格 
     name.find('A')  查找A,找到返回其索引, 找不到返回-1 
    
    format :
        >>> msg = "my name is {}, and age is {}"
        >>> msg.format("alex",22)
        'my name is alex, and age is 22'
        >>> msg = "my name is {1}, and age is {0}"
        >>> msg.format("alex",22)
        'my name is 22, and age is alex'
        >>> msg = "my name is {name}, and age is {age}"
        >>> msg.format(age=22,name="ale")
        'my name is ale, and age is 22'
    format_map
        >>> msg.format_map({'name':'alex','age':22})
        'my name is alex, and age is 22'
    
    
    msg.index('a')  返回a所在字符串的索引
    '9aA'.isalnum()   True
    
    '9'.isdigit() 是否整数
    name.isnumeric  
    name.isprintable
    name.isspace
    name.istitle
    name.isupper
     "|".join(['alex','jack','rain'])
    'alex|jack|rain'
    
    
    maketrans
        >>> intab = "aeiou"  #This is the string having actual characters. 
        >>> outtab = "12345" #This is the string having corresponding mapping character
        >>> trantab = str.maketrans(intab, outtab)
        >>> 
        >>> str = "this is string example....wow!!!"
        >>> str.translate(trantab)
        'th3s 3s str3ng 2x1mpl2....w4w!!!'
    
     msg.partition('is')   输出 ('my name ', 'is', ' {name}, and age is {age}') 
    
     >>> "alex li, chinese name is lijie".replace("li","LI",1)
         'alex LI, chinese name is lijie'
    
     msg.swapcase 大小写互换
    
    
     >>> msg.zfill(40)
    '00000my name is {name}, and age is {age}'
    
    
    
    >>> n4.ljust(40,"-")
    'Hello 2orld-----------------------------'
    >>> n4.rjust(40,"-")
    '-----------------------------Hello 2orld'
    
    
    >>> b="ddefdsdff_哈哈" 
    >>> b.isidentifier() #检测一段字符串可否被当作标志符,即是否符合变量命名规则
    True

    布尔值

    布尔值和布尔代数的表示完全一致,一个布尔值只有TrueFalse两种值,要么是True,要么是False,在Python中,可以直接用TrueFalse表示布尔值(请注意大小写),也可以通过布尔运算计算出来

    空值

    空值是Python里一个特殊的值,用None表示。None不能理解为0,因为0是有意义的,而None是一个特殊的空值。

    此外,Python还提供了列表、字典等多种数据类型,还允许创建自定义数据类型,我们后面会继续讲到。

    变量

    变量即在程序运行过程中它的值是允许改变的量

    变量的作用:代指内存里某个地址中保存的内容

    变量定义的规则:

    • 变量名只能是 字母、数字或下划线的任意组合
    • 变量名的第一个字符不能是数字
    • 以下关键字不能声明为变量名
      ['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']

    变量不仅可以是数字,还可以是任意数据类型

    变量的赋值

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    
    name = "sunny"    # name是字符串
    age=24            # age是整数

    这种变量本身类型不固定的语言称之为动态语言,与之对应的是静态语言

    常量

    所谓常量就是不能变的变量,比如常用的数学常数π就是一个常量。在Python中,通常用全部大写的变量名表示常量:

    PI = 3.14159265359

    list

    list是一种有序的集合,可以随时添加和删除其中的元素

    创建一个列表

    list1=[1, 2, 3, 4, 5 ]

    查看列表

    list1

    列表元素的个数

    len(list1)

    用索引来访问list中每一个位置的元素,记得索引是从0开始的

    >>> list1[0]
    1
    >>> list1[-1]
    5

    查找列表中值为3元素的索引

    list1.index(3)

    在列表末尾添加新的元素

    list.append(8)

    插入元素到指定位置

    list1.insert(2,'hehe')

    移除列表中的一个元素(默认最后一个元素),并且返回该元素的值

    list1.pop()
    list1.pop(2)

    删除指定元素

    list1.remove(3)

    替换元素

    list1[0]=4

    排序

    list1.sort()

    反转

    list1.reverse()

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

    list1.count('hehe')

    在列表末尾追加另一个列表

    list1.extend(list2)

    返回列表元素最大值

    max(list1)

    返回列表元素最小值

    min(list1)

    切片

    list1[0:5]

     判断某个值是否在列表中

    if 5 in list1:
        print("true")

    删除列表

    del list1
     

    tuple

    tuple和list非常类似,但是tuple一旦初始化就不能修改

    创建一个元组

    tup1 = (1, 2, 3, 4, 5 )

    只有1个元素的tuple定义时必须加一个逗号,

    tup2= (1,)

    将元组转为列表

    list2=list(tup1)

    将列表转为元组

    tup2=tuple(list2)

    删除元组

    del tup1

    dict

    使用键-值(key-value)存储,具有极快的查找速度 。dict是无序的 key是唯一的

    >>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}  #生成一个字典
    >>> d['Michael']         #通过key查询对应的值
    95
    
    >>> d['Adam'] = 67       #向字典中插入新值
    >>> d['Adam']
    67
    
    >>> d['Jack'] = 90        
    >>> d['Jack']
    90
    >>> d['Jack'] = 88       #多次对一个key放入value,后面的值会把前面的值冲掉
    >>> d['Jack']
    88
    
    >>>d['Thomas']           #key不存在,dict就会报错    
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    KeyError: 'Thomas'
    
    >>> 'Thomas' in d       #通过in判断key是否存在 
    False

    >>>d.get('Thomas')     #如果key不存在,可以返回None,并不会报错

    >>> d.pop('Bob')       #删除一个key,用pop(key)方法,对应的value也会从dict中删除
    75

    循环打印

    #方法1 这种速度快,大数据用这种
    for i in dic:
        print i,dic[i]

    #方法2      
    for k,v in dic.items():
        print k,v    

    dic.items()

    取key
    dic.keys()
    ['key2', 'key1']

    取值
    dic.values()
    ['sxl1', 'sxl']


    随机删,慎重使用
    dic.popitem()

    如果没有这个key,就设置一个默认的值
    dic.setdefault('name','sun')

    将2个字典聚合,如果有重复数据将被覆盖
    dic.update(a)

    清空字典
    dic.clear()

    删除字典
    del dic

    浅复制,将字典复制一份
    b=dic.copy()

     

    set

    set和dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key

    >>> s = set([1, 2, 3])
    >>> s
    {1, 2, 3}
    
    注意,传入的参数[1, 2, 3]是一个list,而显示的{1, 2, 3}只是告诉你这个set内部有1,2,3这3个元素,显示的顺序也不表示set是有序的。。
    
    重复元素在set中自动被过滤:
    
    >>> s = set([1, 1, 2, 2, 3, 3])
    >>> s
    {1, 2, 3}
    
    通过add(key)方法可以添加元素到set中,可以重复添加,但不会有效果:
    
    >>> s.add(4)
    >>> s
    {1, 2, 3, 4}
    >>> s.add(4)
    >>> s
    {1, 2, 3, 4}
    
    通过remove(key)方法可以删除元素:
    
    >>> s.remove(4)
    >>> s
    {1, 2, 3}
    
    set可以看成数学意义上的无序和无重复元素的集合,因此,两个set可以做数学意义上的交集、并集等操作:
    
    >>> s1 = set([1, 2, 3])
    >>> s2 = set([2, 3, 4])
    >>> s1 & s2
    {2, 3}
    >>> s1 | s2
    {1, 2, 3, 4}
    
    set和dict的唯一区别仅在于没有存储对应的value,但是,set的原理和dict一样,所以,同样不可以放入可变对象,因为无法判断两个可变对象是否相等,也就无法保证set内部“不会有重复元素”。试试把list放入set,看看是否会报错。

    difference 差异比较

    l1 = ['1','2','3','4'] l2 = ['4','5','6'] s1 = set(l1) #传入一个集合 s2 = s1.difference(*l2) print(s1) 原集合并未改变 print(s2) # 最终返回一个新的集合, # 这个属性是通过对象本身与传入的元素进行对比,只要对象本身没有与传入元素相同的元素,则返回这个元素,最终组合成新的元素集合

    difference_update 差异更新

    l1 = ['1','2','3','4','6']
    l2 = ['4','5','6']

    s1 = set(l1)
    s2 = s1.difference_update(*l2)

    print(s1)
    print(s2)

    #通过观察返回结果可知,这个方法是直接更新对象本身,就存在相同的元素剔除,并不会返回剔除元素,剔除规则,对象本身与传入元素对比,如果对象本身的元素在传入的元素里面,则删除这个元素
    #{'3', '1', '2'}  
    #None


    discard 删除一个元素
    l1 = ['1','2','3','4','6']
    l2 = ['4','5','6']

    s1 = set(l1)
    print(s1)
    s2 = s1.discard('1')
    print(s1)
    print(s2)


    #通过传入一个元素,对象本身则将这个元素删除,如果对象本身不存在这个元素则没有任何变化,也没有错误信息,该操作是直接操作对象本身,且没有返回值
    #{'3', '2', '6', '4', '1'}
    #{'3', '2', '6', '4'}
    #None


    intersection 取交集元素集合
    l1 = ['1','2','3','4','6']
    l2 = ['4','5','6']

    s1 = set(l1)
    s2 = set(l2)
    print(s1)
    s3 = s1.intersection(s2)
    print(s1)
    print(s2)
    print(s3)


    #{'1', '2', '4', '3', '6'}  第一次原始集合
    #{'1', '2', '4', '3', '6'}  集合s1和s2进行交集判断后的输出结果,并没有改变对象本身
    #{'4', '5', '6'}    s2的集合也并未发生改变
    #{'4', '6'}  通过交集比较,返回了一个新的元素集合,返回的是s1和s2共同拥有的元素集合



    intersection_update 交集更新
    l1 = ['1','2','3','4','6']
    l2 = ['4','5','6']

    s1 = set(l1)
    s2 = set(l2)
    print(s1)

    s3 = s1.intersection_update(s2)
    print(s1)
    print(s3)


    #通过输出结果可以看出,s1是直接更新了自己,把与传入的集合,与集合里面不相同的元素删除,且没有返回值
    #{'6', '3', '4', '1', '2'}
    #{'6', '4'}
    #None


    isdisjoint 判断是非没有交集

    l1 = ['1','12']
    l2 = ['4','6']

    s1 = set(l1)
    s2 = set(l2)
    print(s1)

    s3 = s1.isdisjoint(s2)
    print(s1)
    print(s3)

    #{'12', '1'}
    #{'12', '1'}
    #True

    #当两个集合之间没有任何交集时,则返回True

    issubset 是否是子集
    l1 = ['1','12','13']
    l2 = ['4','6']
    s3=set(['1','13'])

    s1 = set(l1)
    s2 = set(l2)
    print(s1)

    print(s1.issubset(s2))  #  输出为False说明s1不是s2的子集
    print(s1.issubset(s3))  #  输出false说明 s1不是 s3的子集
    print(s3.issubset(s1))  # 输出true,说明s3是s1的子集



    issuperset 是否父集

    l1 = ['1','12','13']
    l2 = ['4','6']
    s3=set(['1','13'])

    s1 = set(l1)
    s2 = set(l2)
    print(s1)

    print(s1.issuperset(s3))  #输出True,说明s1是s3的父集
    print(s3.issuperset(s1))  #输出false,说明s3不是s1的父集



    pop 随机删除元素
    l1 = ['1','12','13']
    l2 = ['4','6']
    s3=set(['1','13'])

    s1 = set(l1)
    s2 = set(l2)
    print(s1)

    s4 = s1.pop()
    print(s1)   #对象本身被随机删除一个元素
    print(s4)   #  随机删除的元素会返回被随机删除的元素


    remove 移除指定元素
    l1 = ['1','12','13']
    l2 = ['4','6']
    s3=set(['1','13'])

    s1 = set(l1)
    s2 = set(l2)
    print(s1)
    s4 = s1.remove('12')
    print(s1)  #直接移除指定元素,并更新对象本身,如果指定元素不存在,则抛出异常
    print(s4)  #  该属性没有返回值


    symmetric_difference 差集对比
    l1 = ['1','12','13']
    l2 = ['4','6','1']
    s3=set(['1','13'])

    s1 = set(l1)
    s2 = set(l2)
    print(s1)
    s4 = s1.symmetric_difference(s2)

    print(s1)  #该方法并不会更新对象本身的值
    print(s4)  #该对象返回一个新的集合,传入的元素与对象本身比较,如果传入的元素里面有的元素,而对象本身没有,则添加到对象本身的集合内,最终返回一个新的集合



    symmetric_difference_update 差集更新

    l1 = ['1','12','13']
    l2 = ['4','6','1']
    s3=set(['1','13'])

    s1 = set(l1)
    s2 = set(l2)
    print(s1)
    s4 = s1.symmetric_difference_update(s2)

    print(s1)  #直接扩展对象本身与传入集合的没有交集的元素
    print(s4)  #该方法没有返回值


    union 返回新集合
    #效果与差异更新类似,只是这个是返回一个新的集合,而差异更新是更新对象本身,不返回新集合
    l1 = ['1','12','13']
    l2 = ['4','6','1']
    s3=set(['1','13'])

    s1 = set(l1)
    s2 = set(l2)
    s4 = s1.union(s2)
    print(s1)  #对象本身没有变化
    print(s4)  #将对象本身与传入的集合元素比较,把所有的元素重现组合成一个新的集合返回

    update 更新集合
    dic1 ={'k1':'v1','k2':'v2'}
    dic2 ={'k1':'vv','k2':'v2','k3':'v3'}
    s1 = set(dic1)
    print(s1)
    s2 = s1.update(dic2)
    print(s1)  #将会对集合本身进行扩展,如果对象本身不存在这个传入的元素,则添加到对象本身的元素集合


    s = set([3,5,9,10])      #创建一个数值集合  
      
    t = set("Hello")         #创建一个唯一字符的集合  
    
    
    a = t | s          # t 和 s的并集  
      
    b = t & s          # t 和 s的交集  
      
    c = t – s          # 求差集(项在t中,但不在s中)  
      
    d = t ^ s          # 对称差集(项在t或s中,但不会同时出现在二者中)  
      
       
      
    基本操作:  
      
    t.add('x')            # 添加一项  
      
    s.update([10,37,42])  # 在s中添加多项  
      
       
      
    使用remove()可以删除一项:  
      
    t.remove('H')  
      
      
    len(s)  
    set 的长度  
      
    x in s  
    测试 x 是否是 s 的成员  
      
    x not in s  
    测试 x 是否不是 s 的成员  
      
    s.issubset(t)  
    s <= t  
    测试是否 s 中的每一个元素都在 t 中  
      
    s.issuperset(t)  
    s >= t  
    测试是否 t 中的每一个元素都在 s 中  
      
    s.union(t)  
    s | t  
    返回一个新的 set 包含 s 和 t 中的每一个元素  
      
    s.intersection(t)  
    s & t  
    返回一个新的 set 包含 s 和 t 中的公共元素  
      
    s.difference(t)  
    s - t  
    返回一个新的 set 包含 s 中有但是 t 中没有的元素  
      
    s.symmetric_difference(t)  
    s ^ t  
    返回一个新的 set 包含 s 和 t 中不重复的元素  
      
    s.copy()  
    返回 set “s”的一个浅复制

     

    有序字典(orderedDict )

    import collections
    
    
    mydic = collections.OrderedDict(name='zcy',age='25',job='IT')
    print(mydic)
    
    print(mydic.keys())
    print(mydic.values())
    mydic.update(name='hello')
    mydic.update(time='2016')
    print(mydic)
    
    #OrderedDict([('age', '25'), ('name', 'zcy'), ('job', 'IT')])
    
    #odict_keys(['age', 'name', 'job'])
    #odict_values(['25', 'zcy', 'IT'])
    #OrderedDict([('age', '25'), ('name', 'hello'), ('job', 'IT'), ('time', '2016')])
    View Code


    默认字典(defaultdict)

    import collections
    
    mydic = collections.defaultdict(list)
    print(mydic)
    
    mydic['k1']
    print(mydic)
    print(mydic.keys())
    print(mydic.values())  #默认值为一个列表类型
    
    newdic={}
    newdic.setdefault('k1',list)
    newdic['k1']
    
    print(newdic)
    print(newdic['k1'])
    print(newdic.values())
    
    
    #defaultdict(<class 'list'>, {})
    #defaultdict(<class 'list'>, {'k1': []})
    #dict_keys(['k1'])
    #dict_values([[]])
    #{'k1': <class 'list'>}
    #<class 'list'>
    #dict_values([<class 'list'>])
    View Code


    可命名元组(namedtuple)

    import collections
    
    Point = collections.namedtuple('Point',['x','y','z'])  #创建一个类,类名为Point
    
    myPoint = Point(11,22,33)
    print(myPoint)
    print(myPoint.x)  #直接通过命名元素去访问元组对应的元素,
    print(myPoint[0])  #等同于上面这种方式,但是没有上面这种方式可读性强
    print(myPoint.y)
    print(myPoint.z)
    
    
    
    #Point(x=11, y=22, z=33)
    #11
    #11
    #22
    #33
    View Code

     双向队列(deque)

    import collections
    newqueue = collections.deque(['a','b','c'])
    
    print(newqueue)
    newqueue.append(['d1','d2'])  #追加一个元素到队列
    print(newqueue)
    
    newqueue.appendleft('a1')  #追加一个元素到队列左侧
    newqueue.appendleft('a2') #追加一个元素到队列左侧
    print(newqueue)
    
    newc = newqueue.count('a')  #对队列某个元素进行计数
    print(newc)
    
    newqueue.extend(['e','f','g'])  #扩展队列元素
    print(newqueue)
    
    newqueue.extendleft(['a11','a22','a33'])  #从左侧开始扩展队列
    print(newqueue)
    
    newqueue.insert(2,'aa22')  #插入到下标2的位置
    print(newqueue)
    
    newqueue.reverse()  #顺序反转
    print(newqueue)
    
    newqueue.rotate(4)  #将队列末尾4个元素反转到队列左侧
    print(newqueue)
    
    
    
    #deque(['a', 'b', 'c'])
    #deque(['a', 'b', 'c', ['d1', 'd2']])
    #deque(['a2', 'a1', 'a', 'b', 'c', ['d1', 'd2']])
    #1
    #deque(['a2', 'a1', 'a', 'b', 'c', ['d1', 'd2'], 'e', 'f', 'g'])
    #deque(['a33', 'a22', 'a11', 'a2', 'a1', 'a', 'b', 'c', ['d1', 'd2'], 'e', 'f', 'g'])
    #deque(['a33', 'a22', 'aa22', 'a11', 'a2', 'a1', 'a', 'b', 'c', ['d1', 'd2'], 'e', 'f', 'g'])
    #deque(['g', 'f', 'e', ['d1', 'd2'], 'c', 'b', 'a', 'a1', 'a2', 'a11', 'aa22', 'a22', 'a33'])
    #deque(['a11', 'aa22', 'a22', 'a33', 'g', 'f', 'e', ['d1', 'd2'], 'c', 'b', 'a', 'a1', 'a2'])
    View Code

    单项队列

    #单向队列是FIFO工作模式
    
    
    import queue
    newqueue = queue.Queue(2)  #设置队列长度为2,也就是队列里只有两个任务
    newqueue.put(['1','2'])  # 放入一个任务
    newqueue.put(2)  # 放入第二个任务
    isempty = newqueue.empty()  #判断队列是否空
    isfull = newqueue.full()  # 判断队列是否满了
    get1 = newqueue.get()  #获取第一个任务
    get2 = newqueue.get() #获取第二个任务
    print(get1)  
    print(get2)
    isfull2 = newqueue.full()  #判断队列是否满了,因为已经把任务取出来了,所以这时队列应该是没有满
    isempty2 = newqueue.empty()  #判断队列是否为空
    print(isfull)
    print(isfull2)
    print(isempty)
    print(isempty2)
    
    
    
    #['1', '2']
    #2
    #True
    #False
    #False
    #True
    
    queue 单向队列
    View Code
  • 相关阅读:
    使用 libevent 和 libev 提高网络应用性能
    An existing connection was forcibly closed by the remote host
    各种浏览器的兼容css
    vs输出窗口,显示build的时间
    sass
    网站设置404错误页
    List of content management systems
    css footer not displaying at the bottom of the page
    强制刷新css
    sp_executesql invalid object name
  • 原文地址:https://www.cnblogs.com/sxlnnnn/p/6362595.html
Copyright © 2011-2022 走看看