您的位置:新葡亰496net > 奥门新萄京娱乐场 > 新葡亰496net:文本操作,Python数据类型方法精心

新葡亰496net:文本操作,Python数据类型方法精心

发布时间:2019-10-30 00:30编辑:奥门新萄京娱乐场浏览(141)

    计算机顾名思义就是可以做数学计算的机器,因此,计算机程序理所当然地可以处理各种数值。但是,计算机能处理的远不止数值,还可以处理文本、图形、音频、视频、网页等各种各样的数据,不同的数据,需要定义不同的数据类型。在Python中,能够直接处理的数据类型有以下几种:

    Python认为一切皆为对象;比如我们初始化一个list时:

    一 Number(数字)

    li = list('abc')
    

    1.1 数字类型的创建

    1 a=10
    2 b=a
    3 b=666
    4  
    5 print(a)#10
    6 print(b)#666
    

    新葡亰496net 1 

    注意这里与C的不同:

    新葡亰496net 2新葡亰496net 3

     1 #include <stdio.h>
     2 void main(void)
     3 {
     4  
     5     int a = 1;
     6     int b = a;
     7     printf ("a:adr:%p,val:%d,b:adr:%p,val:%dn",&a,a,&b,b);
     8     a = 3;
     9     printf ("a:adr:%p,val:%d,b:adr:%p,val:%dn",&a,a,&b,b);
    10  
    11 }
    12  
    13 //打印结果:
    14 topeet@ubuntu:~$ gcc test.c
    15 topeet@ubuntu:~$ ./a.out
    16 a:adr:0x7fff343a069c,val:1
    17 b:adr:0x7fff343a0698,val:1
    18 a:adr:0x7fff343a069c,val:3
    19 b:adr:0x7fff343a0698,val:1
    

    View Code

    1.2 Number 类型转换

    1 var1=3.14
    2 var2=5
    3 var3=int(var1)
    4 var4=float(var2)
    5  
    6 print(var3,var4
    

    实际上是实例化了内置模块builtins(python2中为__builtin__模块)中的list类;

    二 字符串类型(string)

    字符串是以单引号'或双引号"括起来的任意文本,比如'abc'"123"等等。

    请注意,''""本身只是一种表示方式,不是字符串的一部分,因此,字符串'abc'只有abc这3个字符。如果'本身也是一个字符,那就可以用""括起来,比如"I'm OK"包含的字符是I'm,空格,OK这6个字符。

    2.1 创建字符串:

    1 var1 = 'Hello World!'
    2 var2 = "Python RAlvin"
    

    对应操作:

    新葡亰496net 4新葡亰496net 5

     1 # 1   * 重复输出字符串
     2 print('hello'*2)
     3  
     4 # 2 [] ,[:] 通过索引获取字符串中字符,这里和列表的切片操作是相同的,具体内容见列表
     5 print('helloworld'[2:])
     6  
     7 # 3 in  成员运算符 - 如果字符串中包含给定的字符返回 True
     8 print('el' in 'hello')
     9  
    10 # 4 %   格式字符串
    11 print('alex is a good teacher')
    12 print('%s is a good teacher'%'alex')
    13  
    14  
    15 # 5     字符串拼接
    16 a='123'
    17 b='abc'
    18 c='789'
    19 d1=a b c
    20 print(d1)
    21 #  效率低,该用join
    22 d2=''.join([a,b,c])
    23 print(d2)
    

    View Code

    python的内置方法

    新葡亰496net 6新葡亰496net 7

    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
    

    View Code

    新葡亰496net 8新葡亰496net 9

    三 字节类型(bytes)

    新葡亰496net 10新葡亰496net 11

     1 # a=bytes('hello','utf8')
     2 # a=bytes('中国','utf8')
     3  
     4  
     5 a=bytes('中国','utf8')
     6 b=bytes('hello','gbk')
     7 #
     8 print(a)        #b'xe4xb8xadxe5x9bxbd'
     9 print(ord('h')) #其十进制 unicode 值为: 104
    10 print(ord('中'))#其十进制 unicode 值为:20013
    11  
    12 #  h   e  l   l   o
    13 # 104 101 108 108 111   编码后结果:与ASCII表对应
    14  
    15  
    16 #     中                国
    17 #   xd6xd0         xb9xfa       gbk编码后的字节结果
    18 #xe4 xb8 xad   xe5 x9b xbd    utf8编码后的字节结果
    19 # 228 184 173      229 155  189        a[:]切片取
    20  
    21  
    22 c=a.decode('utf8')
    23 d=b.decode('gbk')
    24 #b=a.decode('gbk') :很明显报错
    25  
    26 print(c) #中国
    27 print(d) #hello 
    

    View Code

    注意:对于 ASCII 字符串,因为无论哪种编码对应的结果都是一样的,所以可以直接使用 b'xxxx' 赋值创建 bytes 实例,但对于非 ASCII 编码的字符则不能通过这种方式创建 bytes 实例,需要指明编码方式。

    1 b1=b'123'
    2 print(type(b1))
    3 # b2=b'中国' #报错
    4 # 所以得这样:
    5 b2=bytes('中国','utf8')
    6 print(b2)#b'xe4xb8xadxe5x9bxbd'
    
    class list(object):
    
        def __init__(self, seq=()): # known special case of list.__init__
            """
            list() -> new empty list
            list(iterable) -> new list initialized from iterable's items
            # (copied from class doc)
            """
            pass
    

    四 布尔值

    一个布尔值只有TrueFalse两种值,要么是True,要么是False,在Python中,可以直接用TrueFalse表示布尔值(请注意大小写)

    1 print(True)
    2 print(4>2)
    3 print(bool([3,4]))
    4 print(True 1)
    

    与或非操作:

    1 bool(1 and 0)
    2 bool(1 and 1)
    3 bool(1 or 0)
    4 bool(not 0)
    

    布尔值经常用在条件判断中:

    1 age=18
    2 if age>18:#bool(age>18)
    3     print('old')
    4 else:
    5     print('young')
    

    View Code

    五 List(列表)

    什么是列表:

    列表(list)是Python以及其他语言中最常用到的数据结构之一。Python使用使用中括号 [ ] 来解析列表。列表是可变的(mutable)——可以改变列表的内容。

    对应操作:

    验证:

    1 查([])

     1 names_class2=['张三','李四','王五','赵六']
     2  
     3 # print(names_class2[2])
     4 # print(names_class2[0:3])
     5 # print(names_class2[0:7])
     6 # print(names_class2[-1])
     7 # print(names_class2[2:3])
     8 # print(names_class2[0:3:1])
     9 # print(names_class2[3:0:-1])
    10 # print(names_class2[:]) 
    

    新葡亰496net 12新葡亰496net 13

    2 增(append,insert)

    insert 方法用于将对象插入到列表中,而append方法则用于在列表末尾追加新的对象。

    1 names_class2.append('alex')
    2 names_class2.insert(2,'alvin')
    3 print(names_class2)
    
    In [1]: li = list('abc')
    
    In [2]: li.__class__
    Out[2]: list
    
    In [3]: li.__class__.__name__
    Out[3]: 'list'
    

    3 改(重新赋值)

    1 names_class2=['张三','李四','王五','赵六']
    2  
    3 names_class2[3]='赵七'
    4 names_class2[0:2]=['wusir','alvin']
    5 print(names_class2)
    

    View Code

    4 删(remove,del,pop)

    1 names_class2.remove('alex')
    2 del names_class2[0]
    3 del names_class2
    4 names_class2.pop()#注意,pop是有一个返回值的 
    

    1. Python对象特性

    python使用对象模型来存储数据。构造任何类型的值都是一个对象。所有python对象都拥有三个特性:身份、类型、值:

    1)身份:每个对象都有一个唯一的身份标识自己,任何对象的身份可以使用内建函数 id() 来得到。

    2)类型:对象的类型决定了该对象可以保存什么类型的值,可以进行什么样的操作,以及遵循什么样的规则。可以使用 type() 函数查看python对象的类型。type()返回的是对象而不是简单的字符串。

    3)值:对象表示的数据。

    python不需要事先声明对象类型,当python运行时,会根据“=“右侧的数据类型来确定变量类型;

    5 其他操作

    5.1  count

           count 方法统计某个元素在列表中出现的次数:

    1 >>> ['to', 'be', 'or', 'not', 'to', 'be'].count('to') 
    2 2 
    3 >>> x = [[1,2], 1, 1, [2, 1, [1, 2]]] 
    4 >>> x.count(1) 
    5 2 
    6 >>> x.count([1,2]) 
    7 1
    

    5.2 extend

    extend 方法可以在列表的末尾一次性追加另一个序列中的多个值。

    1 >>> a = [1, 2, 3] 
    2 >>> b = [4, 5, 6] 
    3 >>> a.extend(b) 
    4 >>> a 
    5 [1, 2, 3, 4, 5, 6]
    

    extend 方法修改了被扩展的列表,而原始的连接操作( )则不然,它会返回一个全新的列表。

     1 >>> a = [1, 2, 3] 
     2 >>> b = [4, 5, 6] 
     3 >>> a.extend(b) 
     4 >>> a 
     5 [1, 2, 3, 4, 5, 6] 
     6 >>> 
     7 >>> a   b 
     8 [1, 2, 3, 4, 5, 6, 4, 5, 6] 
     9 >>> a 
    10 [1, 2, 3, 4, 5, 6] 
    

    5.3  index

           index 方法用于从列表中找出某个值第一个匹配项的索引位置:

    1 names_class2.index('李四')
    

    5.4  reverse

           reverse 方法将列表中的元素反向存放。

    1 names_class2.reverse()
    2 print(names_class2)
    

    5.5  sort

           sort 方法用于在原位置对列表进行排序。

    1 x = [4, 6, 2, 1, 7, 9]
    2 x.sort()#x.sort(reverse=True)
    

    5.6  深浅拷贝

    现在,大家先不要理会什么是深浅拷贝,听我说,对于一个列表,我想复制一份怎么办呢?

    肯定会有同学说,重新赋值呗:

    1 names_class1=['张三','李四','王五','赵六']
    2 names_class1_copy=['张三','李四','王五','赵六']
    

    这是两块独立的内存空间

    这也没问题,还是那句话,如果列表内容做够大,你真的可以要每一个元素都重新写一遍吗?当然不啦,所以列表里为我们内置了copy方法:

     1 names_class1=['张三','李四','王五','赵六',[1,2,3]]
     2 names_class1_copy=names_class1.copy()
     3 names_class1[0]='zhangsan'
     4 print(names_class1)
     5 print(names_class1_copy)
     6 ############
     7 names_class1[4][2]=5
     8 print(names_class1)
     9 print(names_class1_copy)
    10  #问题来了,为什么names_class1_copy,从这一点我们可以断定,这两个变量并不是完全独立的,那他们的关系是什么呢?为什么有的改变,有的不改变呢?
    

    这里就涉及到我们要讲的深浅拷贝了:

    新葡亰496net 14新葡亰496net 15

     1 #不可变数据类型:数字,字符串,元组         可变类型:列表,字典
     2 # l=[2,2,3]
     3 # print(id(l))
     4 # l[0]=5
     5 # print(id(l))   # 当你对可变类型进行修改时,比如这个列表对象l,它的内存地址不会变化,注意是这个列表对象l,不是它里面的元素
     6 #                # this is the most important
     7 #
     8 # s='alex'
     9 # print(id(s))   #像字符串,列表,数字这些不可变数据类型,,是不能修改的,比如我想要一个'Alex'的字符串,只能重新创建一个'Alex'的对象,然后让指针只想这个新对象
    10 #
    11 # s[0]='e'       #报错
    12 # print(id(s))
    13 #重点:浅拷贝
    14 a=[[1,2],3,4]
    15 b=a[:]#b=a.copy()
    16 print(a,b)
    17 print(id(a),id(b))
    18 print('*************')
    19 print('a[0]:',id(a[0]),'b[0]:',id(b[0]))
    20 print('a[0][0]:',id(a[0][0]),'b[0][0]:',id(b[0][0]))
    21 print('a[0][1]:',id(a[0][1]),'b[0][1]:',id(b[0][1]))
    22 print('a[1]:',id(a[1]),'b[1]:',id(b[1]))
    23 print('a[2]:',id(a[2]),'b[2]:',id(b[2]))
    24 print('___________________________________________')
    25 b[0][0]=8
    26 print(a,b)
    27 print(id(a),id(b))
    28 print('*************')
    29 print('a[0]:',id(a[0]),'b[0]:',id(b[0]))
    30 print('a[0][0]:',id(a[0][0]),'b[0][0]:',id(b[0][0]))
    31 print('a[0][1]:',id(a[0][1]),'b[0][1]:',id(b[0][1]))
    32 print('a[1]:',id(a[1]),'b[1]:',id(b[1]))
    33 print('a[2]:',id(a[2]),'b[2]:',id(b[2]))<br><br><br>#outcome
    

    View Code

     1 # [[1, 2], 3, 4] [[1, 2], 3, 4]
     2 # 4331943624 4331943752
     3 # *************
     4 # a[0]: 4331611144 b[0]: 4331611144
     5 # a[0][0]: 4297375104 b[0][0]: 4297375104
     6 # a[0][1]: 4297375136 b[0][1]: 4297375136
     7 # a[1]: 4297375168 b[1]: 4297375168
     8 # a[2]: 4297375200 b[2]: 4297375200
     9 # ___________________________________________
    10 # [[8, 2], 3, 4] [[8, 2], 3, 4]
    11 # 4331943624 4331943752
    12 # *************
    13 # a[0]: 4331611144 b[0]: 4331611144
    14 # a[0][0]: 4297375328 b[0][0]: 4297375328
    15 # a[0][1]: 4297375136 b[0][1]: 4297375136
    16 # a[1]: 4297375168 b[1]: 4297375168
    17 # a[2]: 4297375200 b[2]: 4297375200
    

    那么怎么解释这样的一个结果呢?

     新葡亰496net 16新葡亰496net 17 

    列表补充:

    b,*c=[1,2,3,4,5]
    

    2.Python对象类型

    (1)标准类型(基本数据类型)

    a) .数字(分为几个字类型,其中三个是整型)

    •   Integer  整型
    •   Boolean  布尔型
    •   Long integer  长整型
    •   Floating point real number  浮点型
    •   Complex number 复数型

    b) String 字符串

    c) List 列表

    d) Tuple 元祖

    e) Dictionary 字典

    (2)其他内建类型

    类型、Null对象(None)、文件、集合/固定集合、函数/方法、模块、类

    六 tuple(元组)

    元组被称为只读列表,即数据可以被查询,但不能被修改,所以,列表的切片操作同样适用于元组。

    元组写在小括号(())里,元素之间用逗号隔开。

    虽然tuple的元素不可改变,但它可以包含可变的对象,比如list列表。

    构造包含 0 个或 1 个元素的元组比较特殊,所以有一些额外的语法规则:

    tup1 = ()    # 空元组
    tup2 = (20,) # 一个元素,需要在元素后添加逗号
    
    作用:
    

    1 对于一些数据我们不想被修改,可以使用元组;

    2 另外,元组的意义还在于,元组可以在映射(和集合的成员)中当作键使用——而列表则不行;元组作为很多内建函数和方法的返回值存在。 

    字典

    新葡亰496net 18新葡亰496net 19

     1 # product_list=[
     2 #     ('book',100),
     3 #     ('Mac Pro',9000),
     4 #     ('watch',500),
     5 #     ('coffee',30),
     6 #     ('Python',106),]
     7 # 
     8 # saving=input('input your saving:')
     9 # shopping_car=[]
    10 # 
    11 # if saving.isdigit():
    12 #     saving=int(saving)
    13 #     while True:
    14 #         for i,v in enumerate(product_list):
    15 #             print(i,v)
    16 #         user_choice=input('选择购买商品编号[退出:q]:')
    17 # 
    18 #         if user_choice.isdigit():
    19 #             user_choice=int(user_choice)
    20 #             if user_choice<len(product_list) and user_choice>=0:
    21 #                 product_item=product_list[user_choice]
    22 #                 if product_item[1]<saving:
    23 #                     saving-=product_item[1]
    24 #                     shopping_car.append(product_item)
    25 #                     print('您当前的余额为%s'%saving)
    26 #             else:
    27 #                 print('编号错误')
    28 #         elif user_choice=='q':
    29 #             print('---------您已经购买如下商品-----------')
    30 #             for i in shopping_car:
    31 #                 print(i)
    32 #             print('您的余额为%s'%saving)
    33 #             break
    34 # 
    35 #         else:
    36 #             print('invalid choice')
    

    View Code

    3. 基本对象类型分类

    有3种不同的模型可以帮助我们对基本类型进行分类

    1)存储类型

    新葡亰496net 20

    一个能保存单个字面对象的类型,称为原子或标量存储;可以容纳多个对象的类型,称为容器存储;并且所有的python容器对象都可以容纳不同类型的对象;

    注意,python没有字符类型,所以虽然字符串你看上去像容器类型,实际是原子类型

    2)更新模型(是否可变)

    新葡亰496net 21

    这里所说的是否可变,可更新是针对的对象的值而言的;是在对象身份不变的情况下(id不变),值是否可更新;

    新葡亰496net 22新葡亰496net 23

    s = 'abc'
    print('id of s: ', id(s))
    s = 'xyz'
    print('id of s: ', id(s))
    

    View Code

    结果:

    id of s:  41643960
    id of s:  46319184
    

    上例中,很多人会说s是字符串,也可变啊,但是注意,这里s指向的对象发生了变化(id值发生了变化),所以这不是我们所说的可更新;让我们看一下list

    新葡亰496net 24新葡亰496net 25

    li = ['a', 'b']
    print('li before update', li)
    print('id of li: ', id(li))
    li[0] = 'x'
    print('li after update', li)
    print('id of li: ', id(li))
    

    View Code

    结果:

    li before update ['a', 'b']
    id of li:  48447304
    li after update ['x', 'b']
    id of li:  48447304
    

    li的值发生了变化,但是li还是原来的对象(id值不变)

    另外,对于元祖,元祖本身不可变,但是当元祖存在可变元素时,元祖的元素可变,比如

    新葡亰496net 26新葡亰496net 27

    t = (1, ['a','b'])
    print('t before update', t)
    print('id of t: ', id(t))
    t[1][0] = 'x'
    print('t after update', t)
    print('id of t: ', id(t))
    

    View Code

    结果:

    t before update (1, ['a', 'b'])
    id of t:  48328968
    t after update (1, ['x', 'b'])
    id of t:  48328968
    

    注意:在使用for循环来遍历一个可更新对象过程中,增加删除可更新对象容器的大小会得到意想不到的结果(不期望的结果)甚至出现异常,其中对于字典,直接报错;

    直接遍历列表:

    新葡亰496net 28新葡亰496net 29

    1 lst = [1, 1, 0, 2, 0, 0, 8, 3, 0, 2, 5, 0, 2, 6]
    2 
    3 for item in lst:
    4     if item == 0:
    5         lst.remove(item)
    6 print(lst)    #结果为 [1, 1, 2, 8, 3, 2, 5, 0, 2, 6]
    

    View Code

    遍历索引:

    新葡亰496net 30新葡亰496net 31

    1 lst = [1, 1, 0, 2, 0, 0, 8, 3, 0, 2, 5, 0, 2, 6]
    2 
    3 for item in range(len(lst)):
    4     if lst[item] == 0:
    5         del lst[item]
    6 print(lst)    #结果为IndexError: list index out of range
    

    View Code

    字典:

    新葡亰496net 32新葡亰496net 33

    1 dct = {'name':'winter'}
    2 for key in dct:
    3     if key == 'name':
    4         di['gender'] = 'male'
    5 print(dct)        #结果报错RuntimeError: dictionary changed size during iteration
    

    View Code

    for循环来遍历可变对象时,遍历顺序在最初就确定了,而在遍历中如果增加删除了元素,更新会立即反映到迭代的条目上,会导致当前索引的变化,这样一是会导致漏删或多增加元素,二是会导致遍历超过链表的长度。那么有解决方案吗?

    a) 通过创建一个新的可变对象实现,比如:

    b) 通过while循环

    新葡亰496net 34新葡亰496net 35

    1 #通过创建新的copy
    2 for item in lst[:]:
    3     if item == 0:
    4         lst.remove(item)
    5 print (lst)
    6 #通过while循环
    7 while 0 in lst:
    8     lst.remove(0)
    9 print (lst)
    

    View Code

    更多的内容,看我关于“迭代器”的博客

    3)访问模型

    新葡亰496net 36

    序列是指容器内的元素按从0开始的索引顺序访问;

    字典的元素是一个一个的键值对,类似于哈希表;通过获取键,对键执行一个哈希操作,根据计算的结果,选择在数据结构的某个地址中存储你的值。任何一个值的存储地址取决于它的键;所以字典是无序的,键必须是不可变类型(对于元祖,只能是元素不可变的元祖)

    总结:

    新葡亰496net 37

     新葡亰496net 38

     既然字符串,列表,元祖,字典都是对象,那么任何一种实例化的对象都会有相同的方法,下面让我们来依次来认识这些常见的数据类型:

    七 Dictionary(字典)

    字典是python中唯一的映射类型,采用键值对(key-value)的形式存储数据。python对key进行哈希函数运算,根据计算的结果决定value的存储地址,所以字典是无序存储的,且key必须是可哈希的。可哈希表示key必须是不可变类型,如:数字、字符串、元组。

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

    创建字典:     

    dic1={'name':'alex','age':36,'sex':'male'}
    dic2=dict((('name','alex'),))
    print(dic1)
    print(dic2)
    

    对应操作:

    4. 字符串

    1)创建字符串

    两种方式:

    #直接创建字符串引用
    s = 'winter'
    #通过使用str()函数创建
    s = str(123)
    

    2)字符串方法

    作为内建对象,字符串类的定义在内建模块builtins中,通过源码可以查看到所有字符串方法;如果你在用pycharm,那么更加方便,选中str类以后,点击按钮"Scroll from Source";就可以看到所有方法的列表;

    新葡亰496net 39

    针对每一种方法都有详细的方法文档;在这里吐血一一罗列出,有的注释部分很重要:

    新葡亰496net 40新葡亰496net 41

      1 '''字符串方法'''
      2 
      3 #index,字符串查找,返回第一个匹配到的索引值,没有就报错,可以提供开始,结束位置
      4 s = 'xyzabc'
      5 ret = s.index('za') #结果为2
      6 ret = s.index('z',2)    #结果为2
      7 #rindex,反向查找,结果和index方法得到的结果一样
      8 #find,也是字符串查找,与index不同的是找不到时,不会报错,而是返回-1,注意bool(-1)为True
      9 
     10 
     11 #split,字符串分隔,如果不指定分割符,则默认采用任意形式的空白字符:空格,tab(t),换行(n),回车(r)以及formfeed
     12 res = 'a b    c   dne'.split()       #结果res为['a', 'b', 'c', 'd', 'e']
     13 res = 'a:b:c:d'.split(':')          #结果为['a', 'b', 'c', 'd']
     14 #rsplit,从字符串尾部开始分割,没有设置maxsplit参数时和split的结果一样
     15 #splitlines用于将多行字符串,列表的每个元素为一行字符串,默认不带换行符
     16 
     17 
     18 #partition,类似于s.split(sep, 1),只是输出是一个包括了sep的元祖,且没有默认分隔符sep
     19 res = 'a:b:c:d'.partition(':')  #结果为('a', ':', 'b:c:d')
     20 #rpartition,从字符串末尾开始执行partition方法
     21 res = 'a:b:c:d'.rpartition(':') #结果为('a:b:c', ':', 'd')
     22 
     23 
     24 #strip,去掉字符串两端的字符,如果没指定字符,则默认去掉任意形式的空白字符:空格,tab(t),换行(n),回车(r)以及formfeed
     25 res = 'abcd'.strip('a')     #结果res为'bcd'
     26 res = ' abcd   n'.strip()  #结果res为'abcd',可以通过len(res)验证
     27 #rstrip,去掉右端的字符
     28 #lstrip,去掉左端的字符
     29 
     30 
     31 #join,字符串拼接
     32 #format,字符串格式化
     33 #解决万恶的‘ ’号,每次' '操作都会创建一个新的对象,就需要在内存空间开辟一块新的区域来存储;所以大量使用' '会浪费内存空间
     34 #解决方法1,使用join
     35 #join,字符串拼接
     36 li = ['a', 'b']
     37 res = ':'.join(li)      #使用字符串来拼接一个可迭代对象的所有元素,结果res为'a:b'
     38 #解决方法2,使用format,有两种方式:
     39 #方式1:
     40 res = 'my name is {0}, my age is {1}'.format('winter',30)   #{0},{1}为实参的索引
     41 #方式2:
     42 res = 'my name is {name}, my age is {age}'.format(name='winter', age=30)
     43 #或者直接下面这样
     44 userInfo = {'name':'winter','age':30}
     45 res = 'my name is {name}, my age is {age}'.format(**userInfo)
     46 #或者用format_map(python3.x新增)
     47 userInfo = {'name':'winter','age':30}
     48 res = 'my name is {name}, my age is {age}'.format_map(userInfo)
     49 #解决方法3,除了format以外,还可以使用占位符%,看上去没那么高级,同样有两种方式
     50 #方式1
     51 res = 'my name is %s, my age is %s'%('winter',30)
     52 #方式2
     53 userInfo = {'name':'winter','age':30}
     54 res = 'my name is %(name)s, my age is %(age)s'%userInfo
     55 #结果为'my name is winter, my age is 30'
     56 
     57 #replace,字符串替换,因为字符串为不可变数据类型,所以原字符串不会改变,改变的字符串以返回值形式返回
     58 s = '123xyz'
     59 ret = s.replace('1','a')    #结果s不变,ret为'a23xyz'
     60 ret = s.replace('12', 'ab') #结果为'ab3xyz'
     61 
     62 
     63 #maketrans和translate,一对好基友;用于字符串替换和删除,很好用,python2.x与python3.x语法不同
     64 #maketrans用于创建翻译表,translate用于翻译表
     65 s = 'abccba'
     66 trans_table = str.maketrans('ab','12','c')
     67 res = s.translate(trans_table)  #结果为'1221',注意与replace的区别
     68 
     69 
     70 s.count(strings)   #count,统计字符串中字符的数目
     71 
     72 
     73 s.encode()      #以某种编码格式编码,比如utf-8
     74 
     75 
     76 #大小写切换类方法
     77 s = 'aBcD'
     78 res = s.capitalize()    #首字母大写,结果res为'Abc'
     79 res = s.lower()         #所有字母小写,结果res为'abcd',注意仅对ASCII编码的字母有效
     80 res = s.casefold()      #所有字母小写,结果res为'abcd',注意对unicode编码的字母有效
     81 res = s.upper()         #所有字母大写,结果res为'ABCD'
     82 res = s.swapcase()      #字符串中大小写互换,结果res为'AbCd'
     83 s = 'aB cD,ef'
     84 res = s.title()         #每个单词首字母大写,结果res为'Ab Cd,Ef',其判断“单词”的依据则是基于空格和标点
     85 
     86 
     87 #字符串判断类方法,以下方法除了isspace()以外,对于空字符串都返回False
     88 s.isalpha()      #判断字符串是否全为字母,等价于^[a-zA-Z] $
     89 s.islower()      #判断字符串中字母部分是否全为小写字母,可以有其他字符,但是至少要有一个小写字母,等价于[a-z] 
     90 s.isupper()      #判断字符串中字母部分是否全为小写字母,可以有其他字符,但是至少要有一个小写字母,等价于[A-Z] 
     91 s.istitle()      #判断字符串首字母是否全为大写,可以有其他字符
     92 s.isnumeric()    #判断字符串是否全为数字(包括unicode数字,罗马数字,汉字数字)
     93 s.isdigit()       #也是判断字符串是否全为数字(包括unicode数字,罗马数字)
     94 s.isdecimal()    #判断字符串是否全为十进制数字(包括unicode数字)
     95 s.isalnum()      #判断字符串是否为数字与字母的组合,等价于^[0-9a-zA-Z] $
     96 s.isidentifier()    #判断标识符是否合法
     97 s.isspace()     #判断是否为任意形式的空白字符:空格,tab(t),换行(n),回车(r)以及formfeed
     98 s.isprintable() #判断字符串是否可打印
     99 s.startswith(strings)  #判断字符串是否以某个字符串开头
    100 s.endswith(stings)  #判断字符串是否以某个字符串结尾
    101 
    102 
    103 #center,ljust,rjust,zfill字符串排版,填充
    104 s = '123'
    105 res = s.center(50,'-')  #center是字符串居中,结果为-----------------------123------------------------
    106 #ljust为居左,rjust为居右,zfill使用0来左填充
    107 
    108 
    109 s.expandtabs()  #expandtables,用于将字符串中的tab字符转换为空格,如果没有指定tabsize,默认为8个
    

    View Code

    1 增

     1 dic3={}
     2  
     3 dic3['name']='alex'
     4 dic3['age']=18
     5 print(dic3)#{'name': 'alex', 'age': 18}
     6  
     7 a=dic3.setdefault('name','yuan')
     8 b=dic3.setdefault('ages',22)
     9 print(a,b)
    10 print(dic3)
    

    2 查

     1 dic3={'name': 'alex', 'age': 18}
     2  
     3 # print(dic3['name'])
     4 # print(dic3['names'])
     5 #
     6 # print(dic3.get('age',False))
     7 # print(dic3.get('ages',False))
     8  
     9 print(dic3.items())
    10 print(dic3.keys())
    11 print(dic3.values())
    12  
    13 print('name' in dic3)# py2:  dic3.has_key('name')
    14 print(list(dic3.values()))
    

     5. 列表

    1)创建列表

    三种方式:

    a = ['a','b','c']   #直接创建
    b = list('abc')     #通过创建list实例创建,结果为['a','b','c']
    c = [x for x in range(4)]  #列表推导式,结果为[1,2,3,4]
    

    注意,第二种方法,我们来看一下它的构造函数:

    新葡亰496net 42新葡亰496net 43

        def __init__(self, seq=()): # known special case of list.__init__
            """
            list() -> new empty list
            list(iterable) -> new list initialized from iterable's items
            # (copied from class doc)
            """
            pass
    

    View Code

    接收的参数是一个可迭代对象,即拥有__iter__方法的对象,元祖,集合和字典的构造函数的参数都是可迭代对象;

    第三种方法称为列表推导式,语法为

    [expr for iter_var in iterable]     #迭代iterable里所有内容,每一次迭代,都把iterable里相应内容放到iter_var中,再在表达式中应用该iter_var的内容,最后用表达式的计算值生成一个列表。
    

    扩展形式

    [expr for iter_var in iterable if cond_expr]    #加入了判断语句
    

    2)列表方法

    与查看字符串方法类似,可以通过源码查看,这里也一一罗列出:

    新葡亰496net 44新葡亰496net 45

     1 #增,append,insert,extend
     2 #追加append
     3 li = ['a','b','c']
     4 li.append('d')  #结果li = ['a','b','c','d'],list是可变类型,所以li元素的增加删除会影响源列表
     5 #插入insert
     6 li = ['a','b','c']
     7 li.insert(1,'d')    #结果li = ['a','d','b','c']
     8 #extend,将一个可迭代对象增加追加到列表里
     9 li = ['a','b','c']
    10 li.extend(['x','y'])    #结果li = ['a','b','c','x','y']
    11 li.extend(('m','n'))    #结果li = ['a', 'b', 'c', 'x', 'y', 'm', 'n']
    12 
    13 
    14 #删,remove,pop,clear
    15 #remove,删除第一个与参数值相等的元素,删除不存在的元素报ValueError
    16 li = ['a','b','c','a']
    17 li.remove('a')  #结果li =  ['b', 'c', 'a']
    18 #pop,参数为索引值,弹出对应索引值的元素,返回值为弹出的元素,默认为弹出最后一个元素,索引不存在报IndexError
    19 li = ['a','b','c','a']
    20 res = li.pop(1)   #结果res = ‘b',li = ['a', 'c', 'a']
    21 #clear,清空列表,但是列表对象依然存在,没有被回收
    22 li = ['a','b','c','a']
    23 li.clear()  #结果li = []
    24 
    25 
    26 #查,count,index
    27 #count,统计列表内元素个数
    28 li = ['a','b','c','a']
    29 res = li.count('a') #结果res = 2
    30 #index,查找元素对应的索引值,不存在报ValueError
    31 li = ['a', 'b', 'c', 'a']
    32 res = li.index('a')   #结果res = 0
    33 
    34 
    35 #reverse,反转
    36 li = ['a','b','c']
    37 li.reverse()    #结果li = ['c','b','a']
    38 
    39 
    40 #sort,根据key排序,默认从小到大,同样可以实现反转
    41 li = ['c','b','a']
    42 li.reverse()    #结果li = ['a', 'b', 'c']
    43 li = [[4,5,6], [7,2,5], [6,1,8]]
    44 li.sort(key=lambda x:x[1])  #结果li =  [[6, 1, 8], [7, 2, 5], [4, 5, 6]],根据li元素的第二个值进行排序
    45 
    46 
    47 #copy,浅复制,注意与赋值和深复制的区别
    48 li = [[1,2,3], 'a']
    49 li_new = li.copy()
    50 li_new[0][0] = 4    #li_new = [[4, 2, 3], 'a'],但是li也发生了变化li = [[4, 2, 3], 'a']
    51 li_new[1] = 'b'     #li_new =  [[1, 2, 3], 'b'],但是li不变,[[1, 2, 3], 'a']
    

    View Code

    3 改

    1 dic3={'name': 'alex', 'age': 18}
    2  
    3 dic3['name']='alvin'
    4 dic4={'sex':'male','hobby':'girl','age':36}
    5 dic3.update(dic4)
    6 print(dic3)
    

    6. 元祖

    1)创建元祖

    两种方式:

    t = (1,2,3)     #直接创建
    t = tuple([1,2,3])  #通过tuple函数创建,参数为可迭代对象,结果为(1,2,3)
    

    2)元祖方法

    和字符串,一样,通过源码查看,这里一一列出:

    新葡亰496net 46新葡亰496net 47

    #count,统计元祖内元素个数
    t = (1,2,3,1)
    res = t.count(1)      #结果res = 2
    
    
    #index,查找元素对应的索引值,不存在报ValueError
    t = (1,2,3,1)
    res = t.index(1)      #结果res = 0
    

    View Code

    元祖的方法很少,而且元祖对象是不可变的,元组不可变的好处。保证数据的安全,比如我们传数据到一个不熟悉的方法或者数据接口, 确保方法或者接口不会改变我们的数据从而导致程序问题。

    注意,因为()处理用于定义元祖,还可以作为分组操作符,比如if ( a> b) and (a < c)中的(),且python遇到()包裹的单一元素,首先会认为()是分组操作符,而不是元组的分界符,所以一般我们对于元组,会在)之前再加入一个,

    a = (1,2,3,)
    

    3) 列表vs元组

    使用不可变类型变量的情况:如果你在维护一些敏感数据,并且需要把这些数据传递给一个不了解的函数(或一个根本不是你写的API),作为一个只负责一个软件某一部分的工程师,如果你希望你的数据不要被调用的函数篡改,考虑使用不可变类型的变量;

    需要可变类型参数的情况:管理动态数据集合时,你需要先创建,然后渐渐地不定期地添加,或者有时需要移除一些单个的元素,这时必须使用可变类型对象;将可变类型变量作为参数传入函数,在函数内可以对参数进行修改,可变类型变量也会相应修改;

    4 删

     1 dic4={'name': 'alex', 'age': 18,'class':1}
     2 
     3 # dic4.clear()
     4 # print(dic4)
     5 del dic4['name']
     6 print(dic4)
     7 a=dic4.popitem()
     8 print(a,dic4)
     9 # print(dic4.pop('age'))
    10 # print(dic4)
    11 # del dic4
    12 # print(dic4)
    

    7. 序列共有特性

    字符串,列表,元祖统称序列,是可以顺序访问的;他们的关系和共有特性如下:

    1)相互转换

    新葡亰496net 48

    2)序列操作符

    新葡亰496net 49

    a)根据索引取值,可以正向索引,也可以反向索引

    新葡亰496net 50

    新葡亰496net 51新葡亰496net 52

    li = [1,2,3,4]
    res = li[0]   #结果为1
    res = li[-1]    #结果为4
    li[1] = ['a']    #结果li = [1,'a',3,4]
    

    View Code

    b)切片

    seq[ind1:ind2:step],原则是顾头不顾尾

    新葡亰496net 53新葡亰496net 54

    li = [1,2,3,4]
    res = li[:]     #结果为[1, 2, 3, 4]
    res = li[1:]    #结果为[2,3,4]
    res = li[:-2]   #结果为[1,2]
    res = li[1:3]   #结果为[2,3]
    res = li[::2]   #取索引值为偶数的元素[1,3],对应的li[1::2]为取索引值为基数的元素
    res = li[::-1]  #步进为-1,结果为[4, 3, 2, 1]
    res = li[-1:-3:-1]  #结果为[4,3]
    res = li[3:1:-1]    #结果为[4,3]
    res = li[1:1]       #结果为[]
    li[1:2] = ['a','b'] #结果li = [1, 'a', 'b', 3, 4]
    li[1:1] = [9]   #结果li = [1, 9, 'a', 'b', 3, 4],相当于插入
    

    View Code

    注意序列不能读写不存在的索引值,但是切片可以

    新葡亰496net 55新葡亰496net 56

    li = [1,2,3]
    li[9]    #报IndexError
    li[1:9]    #结果为[2,3]
    li[8:9] = [9]    #结果为[1,2,3,9]
    

    View Code

     c)重复操作符*

    新葡亰496net 57新葡亰496net 58

    [1]*3    #结果为[1,1,1]
    [1,2,3]*3    #结果为[1, 2, 3, 1, 2, 3, 1, 2, 3]
    

    View Code

    d)连接操作符

    新葡亰496net 59新葡亰496net 60

     [1,2,3] [4,5,6]    结果为 [1, 2, 3, 4, 5, 6]
    

    View Code

    e)成员关系操作符in, no in

    新葡亰496net 61新葡亰496net 62

    li = [1,2,3]
    1 in li     #结果为True
    4 not in li #结果为True
    

    View Code

    f)删除序列对象,元素关键字del

    新葡亰496net 63新葡亰496net 64

     l = [1,2,3]
    del l[0]    #结果l为[2,3]
    del l    #结果访问l后,报NameError
    

    View Code

    3)可操作内建函数

    新葡亰496net 65

    新葡亰496net 66新葡亰496net 67

     1 #enumerate,枚举
     2 li = ['a','b','c']
     3 for item in enumerate(li):
     4     print(item)
     5 '''
     6 结果为:
     7 (0, 'a')
     8 (1, 'b')
     9 (2, 'c')
    10 '''
    11 for item in enumerate(li,5):
    12     print(item)
    13 '''
    14 结果为:
    15 (5, 'a')
    16 (6, 'b')
    17 (7, 'c')
    18 '''
    19 
    20 
    21 #len
    22 len([1,2,3])    #结果为3
    23 len([[1,2],[3,4]])  #结果为2
    24 
    25 
    26 #max, min
    27 max([1,2,3])    #结果为3
    28 min([1,2,3])    #结果为1
    29 
    30 
    31 #sorted,注意与list.sort()方法的区别
    32 li = [[1,4],[2,3],[3,2]]
    33 res = sorted(li, key=lambda x:x[1])     #结果res为[[3, 2], [2, 3], [1, 4]]
    34 
    35 
    36 #zip,和倒置有点像
    37 l1 = [1,2,3]
    38 l2 = [1,2,3]
    39 for item in zip(l1,l2):
    40     print(item)
    41 '''
    42 结果为:
    43 (1, 1)
    44 (2, 2)
    45 (3, 3)
    46 '''
    47 l1 = [1,2,3]
    48 l2 = [1,2]
    49 for item in zip(l1,l2):
    50     print(item)
    51 '''
    52 结果为:
    53 (1, 1)
    54 (2, 2)
    55 '''
    

    View Code

    5 其他操作以及涉及到的方法

    5.1 dict.fromkeys

     1 d1=dict.fromkeys(['host1','host2','host3'],'Mac')
     2 print(d1)
     3  
     4 d1['host1']='xiaomi'
     5 print(d1)
     6 #######
     7 d2=dict.fromkeys(['host1','host2','host3'],['Mac','huawei'])
     8 print(d2)
     9 d2['host1'][0]='xiaomi'
    10 print(d2)
    

    5.2  d.copy() 对字典 d 进行浅复制,返回一个和d有相同键值对的新字典

    5.3  字典的嵌套

    新葡亰496net 68新葡亰496net 69

     1 av_catalog = {
     2     "欧美":{
     3         "www.youporn.com": ["很多免费的,世界最大的","质量一般"],
     4         "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
     5         "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
     6         "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]
     7     },
     8     "日韩":{
     9         "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
    10     },
    11     "大陆":{
    12         "1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]
    13     }
    14 }
    15 
    16 av_catalog["大陆"]["1024"][1]  = ",可以用爬虫爬下来"
    17 print(av_catalog["大陆"]["1024"])
    18 #ouput 
    19 ['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']
    

    View Code

    dic={5:'555',2:'222',4:'444'}
    print(sorted(dic)) 
    

    5.4 sorted(dict) : 返回一个有序的包含字典所有key的列表

    5.5 字典的遍历

    1 dic5={'name': 'alex', 'age': 18}
    2  
    3 for i in dic5:
    4     print(i,dic5[i])
    5  
    6 for items in dic5.items():
    7     print(items)
    8 for keys,values in dic5.items():
    9     print(keys,values)
    

     还用我们上面的例子,存取这个班学生的信息,我们如果通过字典来完成,那:

    1 dic={'zhangsan':{'age':23,'sex':'male'},
    2      '李四':{'age':33,'sex':'male'},
    3      'wangwu':{'age':27,'sex':'women'}  
    4      }
    

    8. 字典

    字典是Python语言中唯一的映射类型。映射对象类型里哈希值(键,key)和指向的对象(值,value)是一对多的关系;

    特性:

    a)字典是无序的可变的容器类型

    b)字典的键是唯一的,且必须是不可变类型,如果是元组,要求元组的元素也不可变(因为值的内存地址与键的哈希值有关)

    1)创建字典

    新葡亰496net 70新葡亰496net 71

     1 #直接创建
     2 d = {
     3     'name':'winter',
     4     'age':18,
     5     'hobbies':['basketball','football']
     6 }
     7 
     8 #通过dict函数创建,参数为可迭代对象,字典或列表组成的任意形式;[(),()]或((),())或([],[])或[[],[]]或使用dict(zip())
     9 d = dict([('name', 'winter'),
    10           ('age',18),
    11           ('hobbies',['basketball','football'])]) #结果为{'age': 18, 'hobbies': ['basketball', 'football'], 'name': 'winter'}
    12 
    13 #通过字典推导式
    14 d = {x:y for x, y in zip(['name','age','hobbies'],['winter',18,['basketball','football']])} #结果为{'age': 18, 'hobbies': ['basketball', 'football'], 'name': 'winter'}
    15 d = {x:y for x, y in zip(['name','age','hobbies'],['winter',18,['basketball','football']]) if x=='name'}#结果为{'name': 'winter'}
    16 
    17 #通过字典方法fromkeys()创建一个含有默认值的字典,fromkeys方法是dict类的静态方法
    18 d = dict.fromkeys(['name','gender'], 'unknown') #结果{'gender': 'unknown', 'name': 'unknown'}
    

    View Code

    2)字典方法

    新葡亰496net 72新葡亰496net 73

     1 #增
     2 d = {
     3     'name':'winter',
     4     'age':18,
     5     'hobbies':['basketball','football']
     6 }
     7 #update,类似于list.extend(),将键值对参数加到字典中,对于已存在的更新
     8 d.update({'gender':'male'}) #结果为:{'age': 18, 'gender': 'male', 'hobbies': ['basketball', 'football'], 'name': 'winter'}
     9 
    10 
    11 #删
    12 d = {
    13     'name':'winter',
    14     'age':18,
    15     'hobbies':['basketball','football']
    16 }
    17 #popitem,随机删除一组键值对,并返回该组键值对
    18 res = d.popitem()   #结果为res = ('hobbies', ['basketball', 'football']), d为{'age': 18, 'name': 'winter'}
    19 #pop,删除指定键的键值对,返回对应的值
    20 res = d.pop('name') #结果为res = 'winter', d为{'age': 18}
    21 #clear,清空字典,字典对象还在,没有被回收
    22 d.clear()   #结果d为{}
    23 #del关键字,可以用于删除字典对象和元素
    24 d = {
    25     'name':'winter',
    26     'age':18,
    27     'hobbies':['basketball','football']
    28 }
    29 del d['hobbies']   #结果为 {'age': 18, 'name': 'winter'}
    30 del d   #结果访问d,报NameError
    31 
    32 
    33 #查
    34 d = {
    35     'name':'winter',
    36     'age':18,
    37     'hobbies':['basketball','football']
    38 }
    39 #get,根据键取对应的值,没有对应的键,就返回第二个参数,默认为None
    40 res = d.get('name', 'not found')   #res = ’winter'
    41 res = d.get('gender', 'not found')    #res = 'not found'
    42 #setdefault,根据键取对应的值,如果不存在对应的键,就增加键,值为第二个参数,默认为None
    43 res = d.setdefault('name','winter')   #res = ’winter'
    44 res = d.setdefault('gender','male')   #res = 'male',d变为{'age': 18, 'gender': 'male', 'hobbies': ['basketball', 'football'], 'name': 'winter'}
    45 #keys,获得所有的键
    46 res = d.keys()    #res = dict_keys(['name', 'age', 'hobbies', 'gender'])
    47 #values,获得所有的值
    48 res = d.values()    #res = dict_values(['winter', 18, ['basketball', 'football'], 'male'])
    49 #items,获得所有的键值对
    50 res = d.items()     #res = dict_items([('name', 'winter'), ('age', 18), ('hobbies', ['basketball', 'football']), ('gender', 'male')])
    51 
    52 
    53 #copy方法, 和list.copy一样,是浅复制
    

    View Code

    3)字典元素的访问

    新葡亰496net 74新葡亰496net 75

     1 dic = {'name':'winter', 'age':18}
     2 '''
     3 下面3中方式的结果都为
     4 name winter
     5 age 18
     6 '''
     7 #方式1
     8 for item in dic:
     9     print(item, dic[item])
    10 #方式2
    11 for item in dic.keys():
    12     print(item, dic[item])
    13 #方式3
    14 for k,v in dic.items():
    15     print(k, v)
    

    View Code

    推荐方式1),采用了迭代器来访问;

    4)字典vs列表

    a) 字典:

    •       查找和插入的速度极快,不会随着key的数目的增加而增加(直接查找hash后得到的内存地址);
    •       需要占用大量的内存,内存浪费多(大量的hash值,占用内存你空间)
    •       key不可变
    •       默认无序

    b) 列表:

    •       查找和插入的时间随着元素的增加而增加
    •       占用空间小,浪费内存很少
    •       通过下标查询
    •       有序

    八 集合(set)

    集合是一个无序的,不重复的数据组合,它的主要作用如下:

    • 去重,把一个列表变成集合,就自动去重了
    • 关系测试,测试两组数据之前的交集、差集、并集等关系

    集合(set):把不同的元素组成一起形成集合,是python基本的数据类型。

    集合元素(set elements):组成集合的成员(不可重复)

    1 li=[1,2,'a','b']
    2 s =set(li)
    3 print(s)    # {1, 2, 'a', 'b'}
    4  
    5 li2=[1,2,1,'a','a']
    6 s=set(li2)
    7 print(s)  #{1, 2, 'a'}
    

    集合对象是一组无序排列的可哈希的值:集合成员可以做字典的键

    1 li=[[1,2],'a','b']
    2 s =set(li) #TypeError: unhashable type: 'list'
    3 print(s)
    

    集合分类:可变集合、不可变集合

    可变集合(set):可添加和删除元素,非可哈希的,不能用作字典的键,也不能做其他集合的元素

    不可变集合(frozenset):与上面恰恰相反

    1 li=[1,'a','b']
    2 s =set(li)
    3 dic={s:'123'} #TypeError: unhashable type: 'set'
    

    集合的相关操作  

    9. 集合

    这是高一数学的内容了

    集合对象是一组无序排列的值,分为可变集合(set)和不可变集合(frozenset);可变集合不可hash;不可变集合可以hash,即可以作为字典的键;

    特性:

    a) 无序性,无法通过索引访问

    b) 互异性,元素不可重复,即有去重的功能

    1)  创建集合

    新葡亰496net 76新葡亰496net 77

    1 #直接创建可变集合
    2 s1 = {1,2,3,3}      #结果,python3.x为{1,2,3},python2.x为set([1, 2, 3]),因为集合不允许有重复元素,所以只有一个3元素
    3 #通过函数创建
    4 s2 = set([1,2,3,4]) #创建可变集合{1, 2, 3, 4}
    5 s3 = frozenset([1,2,3,3]) #创建不可变集合,结果为frozenset({1, 2, 3})
    

    View Code

    2) 集合方法和操作符

    这里直接用一张表:

    新葡亰496net 78

    这里只列出可变集合的方法示例,因为不可变集合的方法可变集合都有

    a) 单个集合的操作

    新葡亰496net 79新葡亰496net 80

     1 #集合
     2 
     3 #直接创建可变集合
     4 s1 = {1,2,3,3}      #结果,python3.x为{1,2,3},python2.x为set([1, 2, 3]),因为集合不允许有重复元素,所以只有一个3元素
     5 #通过函数创建
     6 s2 = set([1,2,3,4]) #创建可变集合{1, 2, 3, 4}
     7 s3 = frozenset([1,2,3,3]) #创建不可变集合,结果为frozenset({1, 2, 3})
     8 
     9 
    10 s1 = {1,2,3}
    11 
    12 #增
    13 s1.add('456')   #结果s1 = {1, 2, 3, '456'}
    14 s1.update('789')    #结果s1 = {1, 2, 3, '7', '8', '9', '456'}
    15 
    16 #删
    17 res = s1.pop()      #结果res = 1,s1 = {2, 3, '7', '8', '9', '456'}
    18 s1.remove(3)    #结果s1 =  {2, '7', '8', '9', '456'}
    19 s1.discard(4)   #结果s1 =  {2, '7', '8', '9', '456'},同时不报Error
    20 s1.clear()      #结果s1 = set()
    21 
    22 #浅复制
    23 s1 = {1,2,3}
    24 s2 = s1.copy()  #结果s2 = {1,2,3}
    

    View Code

    b) 集合之间的操作,集合的主要功能

    新葡亰496net 81新葡亰496net 82

     1 s0 = {1,2}
     2 s1 = {1,2,3,4}
     3 s2 = {3,4,5,6}
     4 
     5 #子集,超级判断
     6 res = s0.issubset(s1)   #结果res = True
     7 res = s1.issubset(s2)   #结果res = False
     8 res = s1.issuperset(s0) #结果res = True
     9 res = s0 <= s1      #结果res = True
    10 
    11 #并集
    12 res = s1.union(s2)  #结果res = {1, 2, 3, 4, 5, 6}
    13 res = s1 | s2   #结果res = {1, 2, 3, 4, 5, 6}
    14 
    15 #交集
    16 res = s1.intersection(s2)   #结果为{3, 4}
    17 res = s1 & s2   #结果为{3, 4}
    18 
    19 #差集
    20 res = s2.difference(s1) #结果res = {5, 6}
    21 res = s2 - s1 #结果res = {5, 6}
    22 res = s1.difference(s2) #结果res = {1, 2}
    23 
    24 #对称差集
    25 res = s2.symmetric_difference(s1)   #结果为{1, 2, 5, 6}
    26 res = s2 ^ s1   #结果为{1, 2, 5, 6}
    27 
    28 #在原集合基础上修改原集合
    29 s1.intersection_update(s2)
    30 s1.difference_update(s2)
    31 s1.symmetric_difference_update(s2)
    

    View Code

     用一张图来解释一下:

    新葡亰496net 83

     


    2017年9月20日更新

    1. 推导式

    有列表推导式,字典推导式,集合推导式

    1)列表推导式

    新葡亰496net 84新葡亰496net 85

     1 li_1 = [item for item in range(5)]  #结果li_1 = [0, 1, 2, 3, 4]
     2 
     3 li_2 = [item for item in range(5) if item > 2]  #结果li_2 = [3, 4]
     4 
     5 li_3 = [item if item>2 else 0 for item in range(5)] #结果li_3 = [0, 0, 0, 3, 4]
     6 
     7 li_4 = [(x,y) for x in range(3) for y in range(3,6)]    #结果li_4 = [(0, 3), (0, 4), (0, 5), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5)]
     8 
     9 li_raw = [['winter', 'tom', 'lily'], ['winter']]
    10 li_5 = [item for li in li_raw for item in li if item.count('l') > 1]    #结果li_5 = ['lily']
    

    View Code

    2)集合推导式

    和列表推导式一样,只要把[]换成{}即可

    3)字典推导式

    和列表推导式一样,只是没有if...else...形式

    4)有元祖推导式吗?

    (x for x in range(5))就是元祖推导式呢?

    答案是:不是的

    (x for x in range(5)得到的是一个生成器

    >>>a = (x for x in range(10))
    >>>a
    >>><generator object <genexpr> at 0x0000000004B09F68>
    >>>a.__next__()
    >>>0
    >>>a.__next__()
    >>>1
    

     

    1、创建集合

         由于集合没有自己的语法格式,只能通过集合的工厂方法set()和frozenset()创建

    1 s1 = set('alvin')
    2 s2= frozenset('yuan')
    3  
    4 print(s1,type(s1))  #{'l', 'v', 'i', 'a', 'n'} <class 'set'>
    5 print(s2,type(s2))  #frozenset({'n', 'y', 'a', 'u'}) <class 'frozenset'>
    

    2、访问集合

    由于集合本身是无序的,所以不能为集合创建索引或切片操作,只能循环遍历或使用in、not in来访问或判断集合元素。

     1 s1 = set('alvin')
     2 print('a' in s1)
     3 print('b' in s1)
     4 #s1[1]  #TypeError: 'set' object does not support indexing
     5  
     6 for i in s1:
     7     print(i)
     8     
     9 # True
    10 # False
    11 # v
    12 # n
    13 # l
    14 # i
    15 # a
    

    3、更新集合

    可使用以下内建方法来更新:

    s.add()
    s.update()
    s.remove()

    注意只有可变集合才能更新:

     1 # s1 = frozenset('alvin')
     2 # s1.add(0)  #AttributeError: 'frozenset' object has no attribute 'add'
     3  
     4 s2=set('alvin')
     5 s2.add('mm')
     6 print(s2)  #{'mm', 'l', 'n', 'a', 'i', 'v'}
     7  
     8 s2.update('HO')#添加多个元素
     9 print(s2)  #{'mm', 'l', 'n', 'a', 'i', 'H', 'O', 'v'}
    10  
    11 s2.remove('l')
    12 print(s2)  #{'mm', 'n', 'a', 'i', 'H', 'O', 'v'}
    

    del:删除集合本身 

    四、集合类型操作符 

    1   in ,not in
    2   集合等价与不等价(==, !=)
    3   子集、超集

    1 s=set('alvinyuan')
    2 s1=set('alvin')
    3 print('v' in s)
    4 print(s1<s)
    

          4   联合(|)

    新葡亰496net:文本操作,Python数据类型方法精心收拾。      联合(union)操作与集合的or操作其实等价的,联合符号有个等价的方法,union()。

    1 s1=set('alvin')
    2 s2=set('yuan')
    3 s3=s1|s2
    4 print(s3)  #{'a', 'l', 'i', 'n', 'y', 'v', 'u'}
    5 print(s1.union(s2)) #{'a', 'l', 'i', 'n', 'y', 'v', 'u'} 
    

    5、交集(&)

    与集合and等价,交集符号的等价方法是intersection()

    1 s1=set('alvin')
    2 s2=set('yuan')
    3 s3=s1&s2
    4 print(s3)  #{'n', 'a'}
    5  
    6 print(s1.intersection(s2)) #{'n', 'a'}
    

      6、查集(-)
          等价方法是difference()

    1 s1=set('alvin')
    2 s2=set('yuan')
    3 s3=s1-s2
    4 print(s3)  #{'v', 'i', 'l'}
    5  
    6 print(s1.difference(s2)) #{'v', 'i', 'l'} 
    

    7、对称差集(^)

    对称差分是集合的XOR(‘异或’),取得的元素属于s1,s2但不同时属于s1和s2.其等价方法symmetric_difference()

    1 s1=set('alvin')
    2 s2=set('yuan')
    3 s3=s1^s2
    4 print(s3)  #{'l', 'v', 'y', 'u', 'i'}
    5  
    6 print(s1.symmetric_difference(s2)) #{'l', 'v', 'y', 'u', 'i'}
    

    应用

    1 '''最简单的去重方式'''
    2 lis = [1,2,3,4,1,2,3,4]
    3 print list(set(lis))    #[1, 2, 3, 4]
    

    九 文件操作

    9.1 对文件操作流程

    1. 新葡亰496net:文本操作,Python数据类型方法精心收拾。打开文件,得到文件句柄并赋值给一个变量
    2. 通过句柄对文件进行操作
    3. 关闭文件

         现有文件如下:     

    1 昨夜寒蛩不住鸣。
    2 惊回千里梦,已三更。
    3 起来独自绕阶行。
    4 人悄悄,帘外月胧明。
    5 白首为功名,旧山松竹老,阻归程。
    6 欲将心事付瑶琴。
    7 知音少,弦断有谁听。
    
    1 f = open('小重山') #打开文件
    2 data=f.read()#获取文件内容
    3 f.close() #关闭文件
    

    注意 if in the win,hello文件是utf8保存的,打开文件时open函数是通过操作系统打开的文件,而win操作系统

    默认的是gbk编码,所以直接打开会乱码,需要f=open('hello',encoding='utf8'),hello文件如果是gbk保存的,则直接打开即可。

    9.2 文件打开模式

     1 Character Meaning
     2 --------- ---------------------------------------------------------------
     3 'r'       open for reading (default)
     4 'w'       open for writing, truncating the file first
     5 'x'       create a new file and open it for writing
     6 'a'       open for writing, appending to the end of the file if it exists
     7 'b'       binary mode
     8 't'       text mode (default)
     9 ' '       open a disk file for updating (reading and writing)
    10 'U'       universal newline mode (deprecated)
    

    先介绍三种最基本的模式:

    1 # f = open('小重山2','w') #打开文件
    2 # f = open('小重山2','a') #打开文件
    3 # f.write('莫等闲1n')
    4 # f.write('白了少年头2n')
    5 # f.write('空悲切!3')
    

    9.3 文件具体操作

    新葡亰496net 86新葡亰496net 87

      1 def read(self, size=-1): # known case of _io.FileIO.read
      2         """
      3         注意,不一定能全读回来
      4         Read at most size bytes, returned as bytes.
      5 
      6         Only makes one system call, so less data may be returned than requested.
      7         In non-blocking mode, returns None if no data is available.
      8         Return an empty bytes object at EOF.
      9         """
     10         return ""
     11 
     12 def readline(self, *args, **kwargs):
     13         pass
     14 
     15 def readlines(self, *args, **kwargs):
     16         pass
     17 
     18 
     19 def tell(self, *args, **kwargs): # real signature unknown
     20         """
     21         Current file position.
     22 
     23         Can raise OSError for non seekable files.
     24         """
     25         pass
     26 
     27 def seek(self, *args, **kwargs): # real signature unknown
     28         """
     29         Move to new file position and return the file position.
     30 
     31         Argument offset is a byte count.  Optional argument whence defaults to
     32         SEEK_SET or 0 (offset from start of file, offset should be >= 0); other values
     33         are SEEK_CUR or 1 (move relative to current position, positive or negative),
     34         and SEEK_END or 2 (move relative to end of file, usually negative, although
     35         many platforms allow seeking beyond the end of a file).
     36 
     37         Note that not all file objects are seekable.
     38         """
     39         pass
     40 
     41 def write(self, *args, **kwargs): # real signature unknown
     42         """
     43         Write bytes b to file, return number written.
     44 
     45         Only makes one system call, so not all of the data may be written.
     46         The number of bytes actually written is returned.  In non-blocking mode,
     47         returns None if the write would block.
     48         """
     49         pass
     50 
     51 def flush(self, *args, **kwargs):
     52         pass
     53 
     54 
     55 def truncate(self, *args, **kwargs): # real signature unknown
     56         """
     57         Truncate the file to at most size bytes and return the truncated size.
     58 
     59         Size defaults to the current file position, as returned by tell().
     60         The current file position is changed to the value of size.
     61         """
     62         pass
     63 
     64 
     65 def close(self): # real signature unknown; restored from __doc__
     66             """
     67             Close the file.
     68 
     69             A closed file cannot be used for further I/O operations.  close() may be
     70             called more than once without error.
     71             """
     72             pass
     73 ##############################################################less usefull
     74     def fileno(self, *args, **kwargs): # real signature unknown
     75             """ Return the underlying file descriptor (an integer). """
     76             pass
     77 
     78     def isatty(self, *args, **kwargs): # real signature unknown
     79         """ True if the file is connected to a TTY device. """
     80         pass
     81 
     82     def readable(self, *args, **kwargs): # real signature unknown
     83         """ True if file was opened in a read mode. """
     84         pass
     85 
     86     def readall(self, *args, **kwargs): # real signature unknown
     87         """
     88         Read all data from the file, returned as bytes.
     89 
     90         In non-blocking mode, returns as much as is immediately available,
     91         or None if no data is available.  Return an empty bytes object at EOF.
     92         """
     93         pass
     94 
     95     def seekable(self, *args, **kwargs): # real signature unknown
     96         """ True if file supports random-access. """
     97         pass
     98 
     99 
    100     def writable(self, *args, **kwargs): # real signature unknown
    101         """ True if file was opened in a write mode. """
    102         pass
    

    View Code

    新葡亰496net 88新葡亰496net 89

     1 f = open('小重山') #打开文件
     2 # data1=f.read()#获取文件内容
     3 # data2=f.read()#获取文件内容
     4 #
     5 # print(data1)
     6 # print('...',data2)
     7 # data=f.read(5)#获取文件内容
     8  
     9 # data=f.readline()
    10 # data=f.readline()
    11 # print(f.__iter__().__next__())
    12 # for i in range(5):
    13 #     print(f.readline())
    14  
    15 # data=f.readlines()
    16  
    17 # for line in f.readlines():
    18 #     print(line)
    19  
    20  
    21 # 问题来了:打印所有行,另外第3行后面加上:'end 3'
    22 # for index,line in enumerate(f.readlines()):
    23 #     if index==2:
    24 #         line=''.join([line.strip(),'end 3'])
    25 #     print(line.strip())
    26  
    27 #切记:以后我们一定都用下面这种
    28 # count=0
    29 # for line in f:
    30 #     if count==3:
    31 #         line=''.join([line.strip(),'end 3'])
    32 #     print(line.strip())
    33 #     count =1
    34  
    35 # print(f.tell())
    36 # print(f.readline())
    37 # print(f.tell())#tell对于英文字符就是占一个,中文字符占三个,区分与read()的不同.
    38 # print(f.read(5))#一个中文占三个字符
    39 # print(f.tell())
    40 # f.seek(0)
    41 # print(f.read(6))#read后不管是中文字符还是英文字符,都统一算一个单位,read(6),此刻就读了6个中文字符
    42  
    43 #terminal上操作:
    44 f = open('小重山2','w')
    45 # f.write('hello n')
    46 # f.flush()
    47 # f.write('world')
    48  
    49 # 应用:进度条
    50 # import time,sys
    51 # for i in range(30):
    52 #     sys.stdout.write("*")
    53 #     # sys.stdout.flush()
    54 #     time.sleep(0.1)
    55  
    56  
    57 # f = open('小重山2','w')
    58 # f.truncate()#全部截断
    59 # f.truncate(5)#全部截断
    60  
    61  
    62 # print(f.isatty())
    63 # print(f.seekable())
    64 # print(f.readable())
    65  
    66 f.close() #关闭文件
    

    View Code

    接下来我们继续扩展文件模式:

    新葡亰496net 90新葡亰496net 91

     1 # f = open('小重山2','w') #打开文件
     2 # f = open('小重山2','a') #打开文件
     3 # f.write('莫等闲1n')
     4 # f.write('白了少年头2n')
     5 # f.write('空悲切!3')
     6  
     7  
     8 # f.close()
     9  
    10 #r ,w 模式
    11 # f = open('小重山2','r ') #以读写模式打开文件
    12 # print(f.read(5))#可读
    13 # f.write('hello')
    14 # print('------')
    15 # print(f.read())
    16  
    17  
    18 # f = open('小重山2','w ') #以写读模式打开文件
    19 # print(f.read(5))#什么都没有,因为先格式化了文本
    20 # f.write('hello alex')
    21 # print(f.read())#还是read不到
    22 # f.seek(0)
    23 # print(f.read())
    24  
    25 #w 与a 的区别在于是否在开始覆盖整个文件
    26  
    27  
    28 # ok,重点来了,我要给文本第三行后面加一行内容:'hello 岳飞!'
    29 # 有同学说,前面不是做过修改了吗? 大哥,刚才是修改内容后print,现在是对文件进行修改!!!
    30 # f = open('小重山2','r ') #以写读模式打开文件
    31 # f.readline()
    32 # f.readline()
    33 # f.readline()
    34 # print(f.tell())
    35 # f.write('hello 岳飞')
    36 # f.close()
    37 # 和想的不一样,不管事!那涉及到文件修改怎么办呢?
    38  
    39 # f_read = open('小重山','r') #以写读模式打开文件
    40 # f_write = open('小重山_back','w') #以写读模式打开文件
    41  
    42 # count=0
    43 # for line in f_read:
    44     # if count==3:
    45     #     f_write.write('hello,岳飞n')
    46     #
    47     # else:
    48     #     f_write.write(line)
    49  
    50  
    51     # another way:
    52     # if count==3:
    53     #
    54     #     line='hello,岳飞2n'
    55     # f_write.write(line)
    56     # count =1
    57  
    58  
    59 # #二进制模式
    60 # f = open('小重山2','wb') #以二进制的形式读文件
    61 # # f = open('小重山2','wb') #以二进制的形式写文件
    62 # f.write('hello alvin!'.encode())#b'hello alvin!'就是一个二进制格式的数据,只是为了观看,没有显示成010101的形式
    

    View Code

    注意1:  无论是py2还是py3,在r 模式下都可以等量字节替换,但没有任何意义的! 

    注意2:有同学在这里会用readlines得到内容列表,再通过索引对相应内容进行修改,最后将列表重新写会该文件。

               这种思路有一个很大的问题,数据若很大,你的内存会受不了的,而我们的方式则可以通过迭代器来优化这个过程。 

    补充:rb模式以及seek

    在py2中:

    1 #昨夜寒蛩不住鸣.
    2 f = open('test','r',) #以写读模式打开文件
    3 f.read(3)
    4 # f.seek(3)
    5 # print f.read(3) # 夜
    6 # f.seek(3,1)
    7 # print f.read(3) # 寒
    8 # f.seek(-4,2)
    9 # print f.read(3) # 鸣
    

    在py3中:

    新葡亰496net 92新葡亰496net 93

     1 # test: 
     2 昨夜寒蛩不住鸣.
     3 
     4 f = open('test','rb',) #以写读模式打开文件
     5 
     6 f.read(3)
     7 
     8 # f.seek(3)
     9 # print(f.read(3)) # b'xe5xa4x9c'
    10 
    11 # f.seek(3,1)
    12 # print(f.read(3)) # b'xe5xafx92'
    13 
    14 # f.seek(-4,2)
    15 # print(f.read(3))   # b'xe9xb8xa3'
    16 
    17 #总结: 在py3中,如果你想要字符数据,即用于观看的,则用r模式,这样我f.read到的数据是一个经过decode的
    18 #     unicode数据; 但是如果这个数据我并不需要看,而只是用于传输,比如文件上传,那么我并不需要decode
    19 #     直接传送bytes就好了,所以这个时候用rb模式.
    20 
    21 #     在py3中,有一条严格的线区分着bytes和unicode,比如seek的用法,在py2和py3里都是一个个字节的seek,
    22 #     但在py3里你就必须声明好了f的类型是rb,不允许再模糊.
    23 
    24 #建议: 以后再读写文件的时候直接用rb模式,需要decode的时候仔显示地去解码.
    

    View Code

    9.4 with语句

    为了避免打开文件后忘记关闭,可以通过管理上下文,即:

    with open('log','r') as f:
            pass
    

    如此方式,当with代码块执行完毕时,内部会自动关闭并释放文件资源。

    在Python 2.7 后,with又支持同时对多个文件的上下文进行管理,即:

    with open('log1') as obj1, open('log2') as obj2:
        pass
    

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:新葡亰496net:文本操作,Python数据类型方法精心

    关键词: