python

学习python的知识
写这种读书笔记从来都是写的一塌糊涂（因为我懒

1.数据类型和变量

1.1 数据类型

  1. 整数（普通整数：-2 147 483 648 ～ 2 147 483 647 长整数和普通整数可以混用）
  2. 浮点数
  3. 字符串：在最新的 Python 3 版本中，字符串是以 Unicode 编码的，不可变对象
  4. 布尔值
  5. 空值：空值是 Python 里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None 是一个特殊的空值。

  • 列表：list 是一种有序的集合，可以随时添加和删除其中的元素，元素的数据类型也可以不同，也可以是另一个 list。

    1
    classmates = ['Michael', 'Bob', 'Tracy']

直接获取最后一个元素：

1
classmates[-1]

追加元素到末尾：

1
classmates.append('Adam')

把元素插入到指定的位置:

1
classmates.insert(1, 'Jack')

删除 list 末尾的元素，用pop()方法：

1
classmates.pop()

要删除指定位置的元素，用pop(i)方法，其中i是索引位置：

1
classmates.pop(1)
  • tuple：元祖

  • 字典:
    dict 全称 dictionary，在其他语言中也称为 map，使用键 - 值（key-value）存储，具有极快的查找速度。

    1
    2
    3
    >>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
    >>> d['Michael']
    95

由于一个 key 只能对应一个 value，所以，多次对一个 key 放入 value，后面的值会把前面的值冲掉。

要避免 key 不存在的错误，有两种办法，一是通过in判断 key 是否存在：

1
'Thomas' in d

二是通过 dict 提供的 get 方法，如果 key 不存在，可以返回 None，或者自己指定的 value：

1
2
3
d.get('Thomas')
d.get('Thomas', -1)
-1

要删除一个 key，用pop(key)方法，对应的 value 也会从 dict 中删除

dict 可以用在需要高速查找的很多地方，在 Python 代码中几乎无处不在，正确使用 dict 非常重要，需要牢记的第一条就是 dict 的 key 必须是不可变对象。

  • set

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

    通过add(key)方法可以添加元素到 set 中，可以重复添加，但不会有效果

    通过remove(key)方法可以删除元素

    set 可以看成数学意义上的无序和无重复元素的集合，因此，两个 set 可以做数学意义上的交集、并集等操作：

1
2
3
4
5
6
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}
  • 自定义数据类型

1.2 变量

没什么可说的

1.3 常量

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

1
PI = 3.14159265359

你要是非得变，谁也没办法

2. 运算

2.1 除法

在Python中，有两种除法，一种除法是/：

1
2
3
4
5
6
7
8
9
10
>>> 10 / 3
3.3333333333333335
/除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：
>>> 9 / 3
3.0
还有一种除法是//，称为地板除，两个整数的除法仍然是整数：
>>> 10 // 3
3

你没有看错，整数的地板除//永远是整数，即使除不尽。要做精确的除法，使用/就可以。

因为//除法只取结果的整数部分，所以Python还提供一个余数运算，可以得到两个整数相除的余数：

1
2
>>> 10 % 3
1

无论整数做//除法还是取余数，结果永远是整数，所以，整数运算结果永远是精确的。

在python 3.0 中，x/y 将只执行 true 除法，而与操作数无关；x//y 则执行 floor 除法

2.2 幂运算

1
2
(-3) ** 2 = 9
-3 ** 2 = -9

幂运算符比取反的优先级要高

3. 列表和元组

Python最基本的数据结构是序列（sequence）,六种内建序列

  1. 列表
  2. 元组
  3. 字符串
  4. Unicode字符串
  5. buffer 对象
  6. xrange对象

所有序列都可以索引／分片／加／乘／检查成员资格／计算长度／最大／最小

3.1 分片操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>>numbers = [1,2,3,4,5,6,7,8,9,10]
>>>numbers[3:6]
[4,5,6]
>>>numbers[0:1]
[1]
#只要左面的索引比右面的晚出现在序列中结果就是个空序列
>>>numbers[-3:0]
[]
>>>numbers[-3:-1]
[8,9]
>>>numbers[-3:]
[8,9,10]
>>>numbers[:3]
[1,2,3]

步长

1
2
3
4
5
6
7
8
>>>numbers[0:10:1]
[1,2,3,4,5,6,7,8,9,10]
>>>numbers[3:6:3]
[4]
#步长可以为负数
>>>numbers[10:0:-2]
[10,8,6,4,2]

3.2 加

相同类型序列可以相加

1
2
>>>[1,2,3] + [4,5,6]
[1,2,3,4,5,6]

3.3 乘

1
2
3
4
>>>[42] * 3
[42，42，42]
>>>‘python’ * 3
‘pythonpythonpython’

3.4 索引／检查成员资格／计算长度／最大／最小

  • 成员资格 in：检查一个值是否在序列（或其他容器）中，对字符串是特例，可以查找子字符串。
  • 计算长度 len()
  • 最大 max()
  • 最小 min(）

什么是数据结构，什么是数据类型

int char float double 这些是 数据类型 ，类比作原子，他们间的不同就是元素种类的不同，只涉及自身的不同，比如两种原子内的质子中子数不同，是一种内在属性。

链表 队列 堆栈 树 这些是数据结构，类比作分子，他们间描述的是数据间的关系，就如同分子描述了原子的组合方式

3.5 列表

列表是可变的

3.5.1 list函数

因为字符串不能像列表一样被修改，所以有时根据字符串创建列表会很有用。list函数适用于所有类型的序列，不只是字符串。

1
2
>>>list('Hello')
['H','e','l','l','o']

可以用下面的表达式将一个由字符（如前）组成的列表转换为字符串：

1
''.join(somelist)

在这里，somelist是需要转换的列表。

3.5.2 列表操作

1
names = ['alice','beth','ceil','earl']
  1. 删除 del names[2]

  2. 分片赋值

    1
    2
    3
    4
    5
    6
    >>>name = list('Perl')
    >>>name
    ['P','e','r','l']
    >>>name[1:] = list('ython')
    >>>name
    ['P','y','t','h','o','n']

    分片赋值插入(删除)新元素（敲黑板，划重点）

    1
    2
    3
    4
    >>>numbers = [1,5]
    >>>numbers[1:1] = [2,3,4]
    >>>numbers
    [1,2,3,4,5]

3.5.3 列表方法

  • append() 在末尾追加
  • count() 统计某个元素在列表中出现的次数

  • extend() 在末尾追加另一个序列中的多个值

    1
    2
    3
    4
    5
    >>>a = [1,2,3]
    >>>b = [4,5,6]
    >>>a.extend(b)
    >>>a
    [1,2,3,4,5,6]
    1
    2
    3
    4
    5
    6
    >>>a = [1,2,3]
    >>>b = [4,5,6]
    >>>a + b
    [1,2,3,4,5,6]
    >>>a
    [1,2,3]
  • index()
  • insert(位置，插入内容)

  • pop() 移除列表中的最后一个元素并返回该元素的值

    pop方法是唯一一个既能修改列表又返回元素值(除了None)的列表方法
    入栈，使用append
    出栈，使用pop

  • remove() 移除列表中某个值的第一个匹配项，修改了列表但没有返回值

  • reverse() 反向，改变了列表但不返回值
  • sort() 排序[高级排序]

3. 字符串

字符串方法

  • find() 查找子串，返回子串所在位置的最左端索引
  • join()
  • lower()
  • replace()
  • split()
  • translate

杂七杂八

多态

对不同类的对象使用相同的操作，让用户对于不知道什么类（对象类型）的对象进行方法调用。

+

封装

封装是可以不用关心对象是如何构建的而直接进行使用，对外部世界隐藏工作细节

继承

以通用的类为基础建立专门的类对象

一个有趣的 python 排序模块：bisect

先看看模块的结构：

先说明的是，使用这个模块的函数前先确保操作的列表是已排序的。

先看看 insort 函数

其插入的结果是不会影响原有的排序。

再看看 bisect 函数：

其目的在于查找该数值将会插入的位置并返回，而不会插入。

接着看 bisect_left 和 bisect_right 函数，该函数用入处理将会插入重复数值的情况，返回将会插入的位置：

其对应的插入函数是 insort_left 和 insort_right ：

reference

  1. 廖雪峰的官方网站
  2. 知乎——数据结构与数据类型
  3. python基础教程第二版
python
python