想写个爬虫,开始看看python。安装、数据类型、集合数组、判断和循环、函数以及一些高级方法

安装

  1. mac系统下如果安装homebrew只需要brew install python3,这里直接安装的是python3。
  2. 也可以直接在官网下载安装。
  3. 解释器

    python运行需要解释器,类似java的编译器,python有各类支持的解释器。

    • CPython:由C语言开发的解释器,安装python3时也已直接获得,是使用最广泛的解释器。
    • IPython:比CPython多了一些交互。
    • PyPy:运用了JIT,能够动态编译,且运行结果与CPython可能有所不同。
    • Jython:使用java语言开发的解释器,能够将其编译成java字节码执行。
    • 。。。
    • 还是用CPython吧

数据类型

  1. 整数,浮点数,字符串,布尔值,空值,变量,常量。
  2. 空值表示方式为None。
  3. str使用unicode每个字符占用多个字节,当在网络传输时需要转为bytes型的字符串,以b'字符串'这样形式存在即为bytes类型。
  4. 相关方法:
    • ord('A'):此段输出结果为A的ascll码即65.
    • chr('65'):输出结果为A
    • 'ABC'.encode('ascii'):输出结果为b’ABC’
    • b'ABC'.decode('ascii'):输出结果为’ABC’
    • len('中文'.encode('utf-8')) 对等于 len(b'\xe4\xb8\xad\xe6\x96\x87')
  5. 格式化
    • 输出与c语言类似,整数%d,浮点数%f,字符串s%,十六进制数为%x,通常可以直接使用s%都能够将数值转为字符串。

集合数组

  1. list: classmates = ['Michael', 'Bob', 'Tracy']
    • len(classmates):用于获取list长度
    • classmates[0]:根据索引直接访问元素
    • classmates[-1]:索引添加负号即从尾部开始进行索引。索引-1即为最后一个元素。
    • classmates.append('Adam'):添加元素
    • classmates.insert(1,'Jack'):插入元素
    • classmates.pop():弹出最后一个元素
    • classmates.pop(1):弹出指定索引元素
  2. tuple:classmates = ('Michael', 'Bob', 'Tracy'): tuple类似数组,无法被修改,list类似集合。不能使用append,pop等方法。
  3. dict:d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
    • 'Thomas' in d:判断是否在字典中,输出结果为false
    • d.get('Thomas', -1):获取key值
    • d.pop('Bob'):弹出指定key
    • 相较于list,dict查找速度快,但内存占用大
  4. set:s = set([1, 1, 2, 2, 3, 3])
    • set的value值不可见,是key不可重复的dict,

判断与循环

  1. if语句:

    1
    2
    3
    4
    5
    6
    7
    8
    if <条件判断1>:
    <执行1>
    elif <条件判断2>:
    <执行2>
    elif <条件判断3>:
    <执行3>
    else:
    <执行4>
  2. for循环:

    1
    2
    3
    names = ['Michael', 'Bob', 'Tracy']
    for name in names:
    print(name)
    1
    2
    3
    4
    sum = 0
    for x in range(101):
    sum = sum + x
    print(sum)
  3. while循环:

    1
    2
    3
    4
    5
    6
    sum = 0
    n = 99
    while n > 0:
    sum = sum + n
    n = n - 2
    print(sum)

函数

  1. 数据类型转换

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    >>> int('123')
    123
    >>> int(12.34)
    12
    >>> float('12.34')
    12.34
    >>> str(1.23)
    '1.23'
    >>> str(100)
    '100'
    >>> bool(1)
    True
    >>> bool('')
    False
  2. 定义函数

    1
    2
    3
    4
    5
    def my_abs(x):
    if x >= 0:
    return x
    else:
    return -x
  3. 空函数:占位符pass

    1
    2
    def nop():
    pass
  4. 数据类型以及异常

    1
    2
    3
    4
    5
    6
    7
    def my_abs(x):
    if not isinstance(x, (int, float)):
    raise TypeError('bad operand type')
    if x >= 0:
    return x
    else:
    return -x
  5. 返回多个值:其实际返回了一个tuple

    1
    2
    3
    4
    5
    6
    import math

    def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny
  6. 默认参数:调用时power(5),与power(5,2)结果相同

    1
    2
    3
    4
    5
    6
    def power(x, n=2):
    s = 1
    while n > 0:
    n = n - 1
    s = s * x
    return s
  7. 可变参数:传入个数随意

    1
    2
    3
    4
    5
    def calc(*numbers):
    sum = 0
    for n in numbers:
    sum = sum + n * n
    return sum
  8. 关键字参数:额外的参数传入

    1
    2
    3
    >>> extra = {'city': 'Beijing', 'job': 'Engineer'}
    >>> person('Jack', 24, city=extra['city'], job=extra['job'])
    name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
  9. 命名关键字:只会接受 之后的参数,而可变参数后跟随的参数不需要添加

    1
    2
    3
    4
    5
    def person(name, age, *, city, job):
    print(name, age, city, job)

    def person(name, age, *args, city, job):
    print(name, age, args, city, job)
  10. 参数组合

    1
    2
    3
    4
    5
    def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

    def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
  11. 递归

    1
    2
    3
    4
    def fact(n):
    if n==1:
    return 1
    return n * fact(n - 1)

高级特性

  1. 切片:截取list,包左不包右,左为0时可以省略,也可以使用-索引从后至前进行索引截取

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    >>> L[0:3]
    ['Michael', 'Sarah', 'Tracy']
    >>> L[-2:]
    ['Bob', 'Jack']
    >>> L[-2:-1]
    ['Bob']
    >>> L[:10:2]
    [0, 2, 4, 6, 8]
    //从第一位开始,共10位,间隔为2
    >>> L[::5]
    [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]
    0开始到最后,间隔为5
  2. 迭代

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    >>> d = {'a': 1, 'b': 2, 'c': 3}
    //查看key
    >>> for key in d:
    //查看value
    >>> for value in d.values()
    //查看item
    >>> for k, v in d.items()
    //判断对象是否是可迭代对象
    >>> from collections import Iterable
    >>> isinstance('abc', Iterable) # str是否可迭代
    True
    >>> isinstance([1,2,3], Iterable) # list是否可迭代
    True
    >>> isinstance(123, Iterable) # 整数是否可迭代
    False
    //使用emulate函数将list变为索引-元素对
    >>> for i, value in enumerate(['A', 'B', 'C']):
    ... print(i, value)
  3. 列表生成式

    1
    2
    3
    4
    5
    6
    //x*x为元素式,for循环生成参数,
    >>> [x * x for x in range(1, 11) if x % 2 == 0]
    [4, 16, 36, 64, 100]
    //for循环嵌套
    >>> [m + n for m in 'ABC' for n in 'XYZ']
    ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
  4. 生成器generator

    • 斐波那契数列:

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      def fib(max):
      n, a, b = 0, 0, 1
      while n < max:
      print(b)
      a, b = b, a + b
      n = n + 1
      return 'done'


      def fib(max):
      n, a, b = 0, 0, 1
      while n < max:
      yield b
      a, b = b, a + b
      n = n + 1
      return 'done'
    • yield函数

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      def odd():
      print('step 1')
      yield 1
      print('step 2')
      yield(3)
      print('step 3')
      yield(5)

      >>> o = odd()
      >>> next(o)
      step 1
      1
      >>> next(o)
      step 2
      3
      >>> next(o)
      step 3
      5
      >>> next(o)
      Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      StopIteration
    • 使用for循环遍历第二个fib函数时,在运行至yield b时即中断,运行至for循环下一次,这样得不到fib函数的返回值。而使用next函数时遇yield即终止,并记录,下一次再使用next时才能得下一个结果。

  5. 迭代器

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    >>> from collections import Iterable
    >>> isinstance([], Iterable)
    True

    >>> from collections import Iterator
    >>> isinstance((x for x in range(10)), Iterator)
    True
    >>> isinstance([], Iterator)
    False
    >>> isinstance(iter([]), Iterator)
    True

    判断前者是否为可迭代的。list,tuple,dict,set,str,for循环,以及generator和yield搭配的function成为可迭代的。
    生成器都是Iterator对象,但list、dict、str虽然是Iterable,却不是Iterator。Iterator能够存储一个无限大的数据流,有自身固定长度的数据流无法作为迭代器。
    把list、dict、str等Iterable变成Iterator可以使用iter()函数。


待续。。。