四时宝库

Python 通过变量引用内存中的值，变量的值占用多少空间是由变量类型决定。声明变量不需要显示指定变量的类型，解释器会自动根据值来判断。变量的名称必须符合标识符的定义。

标识符

标识符是由字母、数字和下划线构成。

标识符不能以数字开头。

标识符是区分大小写的。

下划线开头的标识符有特殊的意义，例如 _foo 代表不能直接访问的类属性。双下划线 __foo 代表类的私有成员。双下划线开头和结尾的例如 __foo__ 代表类里的特殊方法。

标识符不能是保留字。

保留字

保留字在 Python 程序中有特殊意义。不能用于定义变量名。这些保留字是：

and,exec,not,assert,finally or,break,for,pass,class,from,print,continue,global,raise,def,if,return,del,import,try,elif,in,while,else,is,with,except,lambda,yield

变量声明

下面的例子声明了不同类型的变量，你可以任意赋值并打印他们

x = 3 # 数字类型
f = 3.1415926 # 浮点数类型 floating point number
name = 'alex' # 字符串类型 string

a = 1, 2, 3, 4, 5 # 元组
b = ['hello', 'world', '!'] # 列表
d = dict(name='alex', age=18) # 字典

Python有5个标准的数据类型。

1. 数字类型 Numbers
2. 字符串类型 String
3. 列表 Lists
4. 元组 Tuple
5. 字典 Dictionary

当你声明一个变量的时候，是不需要指定变量类型的，可以直接给变量赋与任何类型的值。

数字类型 Numbers

Python 支持很多数字类型

1. 整数 Numeric
2. 浮点数 Float
3. 复数 Complex

>>> a = 1 # 整数
>>> print(a)
1
>>> b = 3.14 # 浮点数
>>> print(b)
3.14
>>> c = 2 + 3j # 复数
>>> print(c)
(2+3j)
>>> complex(2, 3) # 复数
(2+3j)

a+bj 和 complex(a, b) 等效。

字符串

字符串类型是一个不可变的字符序列，由 str 对象表示。

字符串字面量有几种不同的定义形式

• 单引号：'foo'
• 双引号："foo"
• 三个引号： '''foo''' 或者 """foo"""

三个引号的形式可以定义多行，换行符也算字符串的字符。

>>> a = """
... aaa
... bbb
... """
>>> a
'\naaa\nbbb\n'
>>> print(a)

aaa
bbb

>>> 

字符串相当于表达式，可以使用空格连续写多个字符串，相当于定义一个。例如 ('foo ' 'bar') 相当于 'foo bar'。

如果字符串里包含双引号，单引号，需要使用 \ 转义。

>>> a = 'hello \"world\"'
>>> print(a)
hello "world"
>>> a = 'hello \'world\''
>>> print(a)
hello 'world'

可以转义单引号，双引号。以上输出并没有 \。 若你想输出 \，需要写两个连续的 \。例如：

a = '\\'
print(a) # 输出 "\"

或者加前缀 r，取消转义。

>>> a = r'hello \'world\''
>>> print(a)
hello \'world\'

字符串可以使用 + ，连接多个字符串，返回一个新的字符串。

>>> a = 'hello'
>>> b = ' world'
>>> a+b
'hello world'

列表

列表是可修改的序列类型。所以列表不可以作为字典的键。

>>> a = [1]
>>> hash(a)
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

如果调用 hash() 函数抛出异常 TypeError。

列表的操作：

• 赋值操作: s[i] = x
• 赋值操作: s[i:j] = t
• 删除操作：del s[i:j] 相当于 s[i:j] = []
• 赋值操作：s[i:j:k] = t
• 删除操作：del s[i:j:k]
• 添加元素到末尾：s.append(x)
• 删除整个列表的元素：s.clear()
• 浅复制：s.copy() 相当于 s[:]
• 扩展列表：s.extend(t) 或者 s += t
• 复制内容n次：s*= n
• 在位置i,插入元素：s.insert(i, x)
• 弹出：s.pop([i]) 弹出位置i的元素，并返回，i是可选的，默认弹出列表末尾的元素
• 删除：s.remove(x) 删除元素 x，如果没有找到元素，抛出 ValueError 异常
• 倒序：s.reverse()

举例：

>>> s
[1, 3]
>>> s.extend([4])
>>> s
[1, 3, 4]
>>> s += [6,7]
>>> s
[1, 3, 4, 6, 7]
>>> s *= 2
>>> s
[1, 3, 4, 6, 7, 1, 3, 4, 6, 7]
>>> s.insert(3, 10)
>>> s
[1, 3, 4, 10, 6, 7, 1, 3, 4, 6, 7]
>>> s.pop()
7
>>> s
[1, 3, 4, 10, 6, 7, 1, 3, 4, 6]
>>> s.pop(3)
10
>>> s
[1, 3, 4, 6, 7, 1, 3, 4, 6]
>>> s.remove(1)
>>> s
[3, 4, 6, 7, 1, 3, 4, 6]
>>> s.reverse()
>>> s
[6, 4, 3, 1, 7, 6, 4, 3]
>>> s.remove(100)
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list

s.remove(e) 只会删除一个元素。

元组

元组是不可变的序列类型。由于它的不可变，可作为字典的键。

>>> t = 1,
>>> hash(t)
3430019387558

列表调用 hash() 函数会抛出 TypeError 异常，元组没有问题，返回的是一个整数。

元组的构造方式

• 使用一对小括号生成一个空的元组 ()
• 逗号加在一个字符末尾，声明一个元素的元组 2, 或者 (2,)
• 逗号分隔的元素 1,2,3 或者 (1,2,3)
• 利用 tuple() 函数，tuple() 或者 tuple(iterable)

>>> t = tuple()
>>> print(t)
()
>>> t = 1,
>>> print(t)
(1,)
>>> t[0]
1
>>> t[1]
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
IndexError: tuple index out of range
>>> t2 = (1,2,3)
>>> print(t2)
(1, 2, 3)
>>> t3 = tuple([1,2,3,4])
>>> print(t3)
(1, 2, 3, 4)
>>> t4 = tuple(range(10))
>>> print(t4)
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> print(t4[3])
3
>>> print(t4[3:8])
(3, 4, 5, 6, 7)

列表和元组访问如果下标越界，会抛出 IndexError 异常，例如元组越界会抛出 IndexError: tuple index out of range。

字典

Python中的字典是一个可映射的对象，映射是指一个可哈希化（hashable）的键值对应一个对象。字典是一个可变对象。

例如 {'name': 'alex', 'age': 18} ，声明了一个字典，对应两个映射对象，键姓名 name 对应一个字符串值alex，键年龄 age 对应一个整数 18。键 name 和 age 都是字符串，由于字符串是不可变的，可以哈希化，所以能够作为键值。字典的值不必是哈希化的，所以列表可以作为值。

字典的声明方式：

• {'one': 1}
• dict(**kwarg)
• dict(mapping, **kwarg)
• dict(iterable, **kwarg)

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> a
{'one': 1, 'two': 2, 'three': 3}
>>> b
{'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1,2,3]))
>>> c
{'one': 1, 'two': 2, 'three': 3}
>>> d = dict([('one', 1), ('two', 2), ('three', 3)])
>>> d
{'one': 1, 'two': 2, 'three': 3}

字典的操作：

• 返回字典长度 len(d)
• 返回键值 d[key]，如果键不存在，抛出 KeyError
• 设置或更新键值 d[key] = value
• 从字典中删除键 del d[key]，如果键不存在，抛出 KeyError
• key in d 判断一个键是否存在
• iter(d) 返回一个包含字典中所有键的迭代器
• d.clear() 清空字典
• classmethod fromkeys(seq, [value]) 从一个序列seq生成一个字典，value值是可选的，不传默认是 None，这是一个类方法。
• d.get(key[, default]) 获取键key的值。key不存在，则返回第二个参数default的值，如果第二个参数没有传，返回 None 类型。
• d.items() 返回键值对的一个视图对象，可以用for遍历，键值对是元组形式。
• d.keys() 返回键的一个视图对象，可以用for遍历
• d.pop(key[, default]) 弹出键key的值，没有则返回default值
• d.popitem() 弹出一个键值元组
• d.setdefault(key[, default]) 如果键key存在，返回值，不存在则设置字典key=default，返回default
• d.update(other) 从other更新字典，如果other中的键已经存在了，则覆盖原来的值。
• d.values() 返回所有值的视图对象，可以用for遍历

>>> d = {}
>>> d['one'] = 1
>>> d['two'] = 2
>>> d
{'one': 1, 'two': 2}
>>> del d['not_exists']
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
KeyError: 'not_exists'
>>> del d['one']
>>> d
{'two': 2}
>>> d.clear()
>>> d
{}
>>> len(d)
0
>>> d = dict.fromkeys('abc', 2)
>>> d
{'a': 2, 'c': 2, 'b': 2}
>>> d.get('a', 100)
2
>>> d.get('f', 100)
100
>>> d
{'a': 2, 'c': 2, 'b': 2}
>>> for i in d.items(): print(i)
... 
('a', 2)
('c', 2)
('b', 2)
>>> for i in d.keys(): print(i)
... 
a
c
b
>>> d['c'] = 5
>>> for i in d.values(): print(i)
... 
2
5
2
>>> d.pop('f')
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
KeyError: 'f'
>>> d.pop('f', 99)
99
>>> d
{'a': 2, 'c': 5, 'b': 2}
>>> d.popitem()
('a', 2)
>>> d
{'c': 5, 'b': 2}
>>> d.setdefault('c', 99)
5
>>> d
{'c': 5, 'b': 2}
>>> d.setdefault('e', 99)
99
>>> d
{'e': 99, 'c': 5, 'b': 2}
>>> d.update({'d': 8})
>>> d
{'e': 99, 'c': 5, 'b': 2, 'd': 8}