一.字典:

定义字典:
d = {}
d = dict()
d = {\”a\”:1, \”b\”:2}

1.获取元素:

d[\'a\']
d.get(\'a\')
>这两个的区别,用get在key不存在的时候不会抛出Error;

d.get(\'a\', \'information\')   //设置当key不存在的时候返回的内容;

2.增加和修改元素:

d[\'a\'] = 3   //修改和增加元素的方法都是这个

3.删除元素:

d.pop(\'c\')  //删除的同时返回删除的内容
>如果删除不存在的key会报KeyError,这个时候就需要给定返回值

d.pop(\'c\', \'information\')
help(d.pop)

>这样返回的就是information,不会报KeyError错误;

d.popitem()    //从字典中随机删除一个;

利用关键字del 删除,del 可以删除一个变量 同时也可以用来删除字典:
del d[\'a\']

4.遍历:

>[生成一个生成器,可以进行迭代操作][字典是无序的,所以返回的迭代对象也是无序的]

d.items()  生成器中是一个元组的列表
d.values()  
d.keys()    
    for i in d.keys()

    d = {}
    d[\'root\'] = \'root\'
    d[\'root\'][\'left\'] = \'left\'
    d[\'root\'][\'right\'] = \'right\'
    d  //生成一个二叉树

二.列表解析:

• 列表解析是Python重要的语法糖

• 列表解析的速度比for in 迭代 快

基本语法:

    ret = [expression for item in iterator]
    ret = [expression for item in iterator if iterator >=1 and iterator != 7 ] 
    ret = [expression for x in X for y in Y]   //返回的是一个笛卡尔积,相当于两个嵌套的for循环

    等价于
    ret = []
    for item in iterator:
        ret.append(expression)

例子1:
    lst = list(range(10))
    [x + 1 for x in lst]

    import timeit
    def fn1():

    timeit.timeit(fn1())   //查看函数执行需要的时间

例子2:
    带条件的列表解析:
    lst = list(range(10))
    [x + 1 for x in lst if x % 2 == 0]   //输出奇数

    [x + 1 for x in lst if x % 2 == 0 and x > 2 ]   //两个条件

例子3:
    l1 = [1, 3, 5, 7, 9]
    l2 = [0, 2, 4, 6, 8]
    [(x,y) for x in l1 for y in l2]
    [(1, 0-8)        //每个l1的值 x 都会循环一遍l2
      (3,0-8 )
     (5, 0-8)
    ] 
    
    

三.集合解析:

**集合解析中得到的元素只能有一个**
ret = {expression for item in iterator}

例子1:
     s = [1, 3, 5, 5] 
    {x + 1 for x in s}
    {2, 4, 6}

四.字典解析:

ret = {exprK:exprV for item in iterator}

例子1:
    d = {\'a\':1, \'b\':2}
    {k, v for k, v in d.items()}

例子2:
    {k:v for k, v in [(\'a\',1), (\'b\', 2)]}
    {\'a\':1, \'b\':2}

五.字符串与文本操作:

python2 和python3最大的差别就是在于字符串
python2中字符串是byte的有序序列
python3中字符串是unicode的有序序列
字符串是不可变的
字符串支持下标和切片

1.字符串的切片操作:

t = \'asdfzxv\'     //前面是闭区间,从0开始,后面是开区间
t[1]
t[-1]
t[0:]
t[:]
t[1:-1]

2.字符串格式化:

1.使用 % 来格式化

\'i love %s\' % (\'python\',)
\'i love %(name)s\' % {\'name\':\'python\'}
\'i love %(name)s %(name)s\' % {\'name\':\'python\'}   //当有多个重复使用的值,可以使用字典的方式
\'i love %s ,%s\' % (\'python\', \'python\')  //进行多个不同数值的格式化

FLAG
flag |说明 |实例                                        输出:
n    n表示一个数字       \'%3s\' % (\'a\', )                     \'  a\'    //在a前面会有两个空格
0    使用0填充,仅适用与数字  \'%03d\' % (1, )          \'001\'
.     是有那个空格填充,默认行为  \'%.3d\' % (1, )      \'  1\'  //在1前面以空格填充

• 右边使用空格填充 \’%-3d\’ % (1, ) \’1 \’ //在1后面以两个空格填充

• 填充之前加\’+\’ 仅对于正数 \’%+03d\’ % (1, ) \’+01\’ //在1前面填充0,增加正数标记符

  CONVERSION
  符号 说明

1. 整数

2. 整数

3. 八进制整数

4. 小写十六进制整数
   X 大写十六进制整数

5. 浮点数
   F 浮点数

6. 小写科学计数法
   E 大写科学计数法

7. 整数, 已废弃

8. 同f,如果指数小于-4,同e
   G 同f,如果指数小于-4,同E

9. 字符,接收unicode编码或单字符字符串

10. 字符串,使用ascii函数转换

11. 字符串,使用repr函数转换

12. 字符串,使用str函数转换

    
    例子1:
    \'%d\' % 3.4
    > 3

2.使用format方法格式化:

https://docs.python.org/3.4/library/stdtypes.html?highlight=format#str.format
template format(args, *kwargs) (1) (2) (3) (4)

1.template 使用 {} 标示变量
2.{}或{\\d+} 使用 *args 按顺序填充
3.{key} 使用 **kwargs 按 key 填充
4.Format String Syntax

例子1:
\'{0}, {name}\'.format(\'hello\',name=\'world\')

3.字符串常用操作 [重点] :

字符串连接join
字符串分割split, rsplit, splitlines, partition, rpartition
字符串修改-大小写 capitalize, title, lower, upper, swapcase
字符串修改-填充清除 center, ljust, rjust, zfill, strip, rstrip,lstrip
字符串判断 startswith, endswith,is*
字符串查找替换 count, find, rfind, index, rindex, replace

1.join[字符串连接]:

    lst = [\'i\', \'like\', \'python\']
    \' \'.join(lst)
    \'_\'.join(lst)
    ret = \'\'
    for i in lst:
          ret += i
          ret += \' \'
    ret

2.split – rsplit – splitlines[分割]:

    内置函数split是不支持正则表达式的,需要先import re模块;
    help(str.split)
    S.split(sep=None, maxsplit=-1) 
    
    例子1:
    s＝\'i like python\'
    s.split()
    [\'i\', \'like\', \'python\']

    例子2:
    s.split(\'o\')      //指定的分割符不会被保留;
    >[\'i like pyth\', \'n\'] 
    
    例子3:
    s.split(\' \', 1)  //后面的数表示分割几次,默认是最大分割, -1表示从后开始分割
    ssplit(\' \', -1)
    这里可以使用UNPACKING:
    s = \'root:x:0:0:root:/root:/bin/bash\'
    username,_ = s.plit(\':\', 1)
    username
    > \'root\'

    例子4:
    s = \'root\\n:x:0\\n:0\\n:root:/root:/bin/bash\'   //按照换行符分割
    s = \'\'\'                  //像这样需要多行的且需要按行分割的就需要用到splitlines
    11111111          //这里总共是4行,按照换行符算,第一行也有换行符
    22222222
    33333333
    \'\'\'
    s.splitlines()
    > [\'root\', \':x:0\', \':0\', \':root:/root:/bin/bash\']
    s.splitlines(True)   //填写True将会保留换行符,默认False

3.partition – rpartition[分割]:

    s = \'root\\n:x:0\\n:0\\n:root:/root:/bin/bash\'
    s.partition(\':\')         //partition会按照顺序 将分隔符单独分割成一个元素,
    >(\'root\', \':\', \'x:0:0:root:/root:/bin/bash\')

4.capitalize – title – lower – upper – swapcase[修改 大小写]:

capilize :   第一个字母变大写,其他字母变小写
       title:   每个单词的首字母大写,其他字母变小写
    lower:   将所有字母变小写
    upper:   将所有字母变大写

swapcase: 将大小写对换;

5.center – ljust – rjust – zfill – strip – rstrip – lstrip [修改 字母]:

center: 前后填充

            s.center(20)   //默认用空格进行前后填充,填充满20个字符
            s.center(20,\'#\') //以\'#\'进行前后填充.

 ljust:     填充向左边
            s.ljust(20,\'#\')  #号将会填充在原来字符串的右边,因为是向左填充

 rjust:     填充向右边
            与ljust方向相反;

   zfill:    zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0
            str.zfill(width)

 strip:    删除头尾匹配符,默认删除换行符和空格,tab键
rstrip:    删除结尾匹配符
lstrip:    删除开头匹配符

            f = open(\'/etc/passwd\', \'r\')
            f.readline()   //返回的一行带有换行符
            f.readline().strip()  //这样将不会带上换行符

6.startswith – endswith – is *[判断]:

            for line in f.readlines():
                    line = line.strip()
                    if line.startwith(\'root:\'):
                        _, shell = line.rsplit(\":\",1)
                        print(shell)

7.count, find, rfind, index, rindex, replace[查找 和 替换]:

        f = \'sdfsdfsdfsadfsdf\'
        f.count(\'r\')  //统计有多少个r,如果是多个字符就是多个字符进行匹配统计
        
        f.find(\'fs\')      //从左开始查找第一次匹配到的位置; 找不到会返回 -1
        f.find(\'fs\', 2, 4)  //设置 [开始] [结束] 位置
        f.index(\'fs\')     //从左开始查找第一次匹配到的位置;找不到会返回ValueError

        f.replace(\'fs\',\'pp\')     //替换   将fs替换成pp
        f.replace(\'fs\',\'pp\', 2)  //从左向右进行替换,替换两个;

六.STR与BYTES的区别:

Python3中严格区分了文本和二进制数据
Python2并没有严格区分
文本数据使用str类型,底层实现是unicode
二进制数据使用bytes类型,底层是byte
str使用encode方法转化为bytes
bytes方法使用decode方法转化成str
由于清晰的区分文本和二进制,Python3解决了大多数python2的编码问题

python3 中json的应用:

   import json
   json.loads(\'{\"name\":\"comyn\"}\')

socket中的发送信息;需要将str转换成bytes才能发送;
s.send(\'{\"name\":\"comyn\"}\'.encode())