Python 中的变量不需要声明。每个变量在使用前必须赋值，变量赋值以后该变量才会被创建。在 Python 中，变量本身是没有类型的，我们所说的 “类型” 是变量所指内存中的对象的类型。

Number

Python 支持三种不同的数值类型：

• 整型 (int) ： 通常被称为整型或者整数，是正数或者负数，不带小数点。在 Python3 中，整型没有大小限制，所以也可以用来表示 long 类型。

  bool 是整型的子类型。

• 浮点型 (float) ： 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示

• 复数 (complex) ： 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

整型类型转换

• int(x)： 将变量 x 转换为整型，如果转换失败将会抛出异常

  >>> a = '1'
  >>> int(a)
  >>> 1

  >>> a = 'x'
  >>> int(a)
  Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
  int(a)
  ValueError: invalid literal for int() with base 10: 'x'

• float(x)： 将变量 x 转换为浮点型，如果转换失败将会抛出异常

  >>> a = '1.2'
  >>> float(a)
  1.2

  >>> a = '1/2'
  >>> float(a)
  Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    float(a)
  ValueError: could not convert string to float: '1/2'

• complex(x)： 将x转换到一个复数，实数部分为 x，虚数部分为 0。

  >>> a = a
  >>> complex(a)
  (1.2+0j)

• complex(x, y)： 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

  >>> complex(1,1)
  (1+1j)

数字运算

和其他语言一样，通过 +、-、* 、/ 来进行四则运算。

>>> 1 + 1
2
>>> 1 - 1
0
>>> 1 * 1
1
>>> 1 / 1
1.0

注意：

1. 在不同的机器上，浮点运算的结果可能不同；
2. 在整数除法中，除法 / 总是返回浮点数，如果想得到整数的结果，可以使用 // 运算符；
3. 运算符 // 得到的并不一定是整数类型的数，它与分子和分母有关系；
4. 通过运算符 ** 可以进行幂运算；

>>> 3//2
1
>>> 3//2.0
1.0
>>> 3 ** 2
9
>>> 3 ** 3
27

String

字符串是 Python 中最常用的数据类型。我们可以使用引号( '' 或 "" )来创建字符串。

>>> a  = 'hello world'
>>> type(a)
<class 'str'>

如果需要访问字符串中的元素，可以通过 [] 来截取，语法如下：

变量[首下标:尾下表]

例如：

>>> a  = 'hello world'
>>> type(a)
<class 'str'>
>>> a[0]
'h'
>>> a[0:2]
'he'
>>> a[1:3]
'el'

Python 字符串运算符

Python 字符串格式化

常用内置函数

List

1. 序列是 Python 中最基本的数据结构。
2. 序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。
3. Python 有 6 个序列的内置类型，但最常见的是列表和元组。
4. 列表都可以进行的操作包括索引，切片，加，乘，检查成员。
5. 此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。
6. 列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。
7. 列表的数据项不需要具有相同的类型。
8. 像字符串一样，可以通过列表索引访问列表中的元素，并可通过索引进行截取、组合等操作。

访问列表中的值

>>> name = ['张三丰', '李自成', '张无忌', '陈圆圆']
>>> print(name)
['张三丰', '李自成', '张无忌', '陈圆圆']
>>> name[1]
'李自成'
>>> name[-1]
'陈圆圆'
>>> name[2:3]
['张无忌']
>>> name[1:-2]
['李自成']

列表常用方法

• len()
  返回列表元素个数。

  >>> name = ['张三丰', '张翠山', '张无忌', '陈圆圆', '赵敏', '东坡肉']
  >>> len(name)
  6

• max()
  返回列表元素的最大值。

  >>> num = [1,3,2,4,0]
  >>> max(num)
  4

• min()
  返回列表元素的最小值

  >>> num = [1,3,2,4,0]
  >>> min(num)
  0

• list()
  讲元组转换为列表。

  >>> a = (1,2,3)
  >>> list(a)
  [1, 2, 3]

• list.append(obj)
  在列表的末尾添加元素。

  >>> num = [1,3,2,4,0]
  >>> num.append(['a','c'])
  >>> num
  [1, 3, 2, 4, 0, ['a', 'c']]

• list.count(obj)
  统计某个元素在列表中出现的次数。

  [1, 3, 2, 4, 0, ['a', 'c']]
  >>> num.count(1)
  1
  >>> num.count(5)
  0

• list.extend(seq)
  在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。

  >>> num = [2,3,4]
  >>> num.extend((6,7,8))
  >>> num
  [2, 3, 4, 6, 7, 8]

• list.index(obj)
  从列表中找出某个值第一个匹配项的索引位置。

  >>> num = [2,3,4,5,2,3,5]
  >>> num.index(3)
  1

• list.insert(index, obj)
  将对象插入列表中指定位置。

  >>> num = [2,3,4,5,2,3,5]
  >>> num.insert(2, ['a','b'])
  >>> num
  [2, 3, ['a', 'b'], 4, 5, 2, 3, 5]

• list.pop(index = -1)
  移除列表中的元素，默认最后一个元素，并且返回该元素的值。

  >>> num = [1,2,3,4,5]
  >>> num.pop()
  5
  >>> num
  [1, 2, 3, 4]
  >>> num.pop(2)
  3
  >>> num
  [1, 2, 4]

• list.remove(obj)
  移除列表中某个值的第一个匹配项

  >>> num = [1,2,1,2,3,4,5]
  >>> num.remove(1)
  >>> num
  [2, 1, 2, 3, 4, 5]
  >>> num.remove(4)
  >>> num
  [2, 1, 2, 3, 5]

• list.reverse()
  反向列表中的元素。

  >>> num = [1,2,3,4,5]
  >>> num.reverse()
  >>> num
  [5, 4, 3, 2, 1]

• list.sort(key=None, reverse=False)
  对原列表进行排序。key 主要是用来进行比较的元素，reverse 排序规则，reverse = True 降序， reverse = False 升序（默认）。

  >>> a = [1,4,2,10,3,5]
  >>> a.sort()
  >>> a
  [1, 2, 3, 4, 5, 10]

• list.clear()
  清空列表。

  >>> num = [1,2,3,4,5]
  >>> num.clear()
  >>> num
  []

• list.copy()
  复制列表。类似于 a[:]

  >>> num = [1,2,3,4,5]
  >>> a = num.copy()
  >>> a
  [1, 2, 3, 4, 5]

Tuple

元组与列表类似，用 () 表示，与列表不同的是：元组的元素不能被修改。

1. 元组只包含一个元素时，需要在元素后面追加逗号，否则 () 会被当做运算符使用；
2. 元素与字符串类似，下表索引从 0 开始，可以进行截取、组合等；
3. 元组中的元素值是不能被修改的，但我们可以对元组进行链接组合；
4. 元组中的元素不允许删除，但可以通过 del 删除整个元组；
5. 元组可以通过 + 和 * 进行组合和复制运算；运算后会生成一个新元组；
6. 元组是不可变的，也就是元组指向的内存中的内容不可变。

内置函数

Dictionary

字典是 Python 中另一种可变容器模型，可以存储任意类型对象。字典的每个键值对用 : 分割，每个对之间用 , 隔开，整个字典则包含在 {} 中，如：{ d = key1 : value1, key2 : value2, key3 : value3 }。

字典中的键必须是唯一的(如果同一个键出现多次，则只会保留最后一个键值对)，且类型不可变(可以是字符串、数字或元组类型)，但值则可以重复，也可以是任意类型。

访问字典中的值

可通过把键放入到 [] 中，获取指定键的值，如果键不存在，则会抛出异常：

>>> dic = {'name':'张三', 'age':10, 'sex':'男'}
>>> dic['name']
'张三'
>>> dic['s']
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    dic['s']
KeyError: 's'

修改字典

• 向字典中添加元素

>>> dic = {'name':'张三', 'age':10, 'sex':'男'}
>>> dic['class'] = '三年级'
>>> dic
{'name': '张三', 'age': 10, 'sex': '男', 'class': '三年级'}

• 修改字典中的元素

>>> dic = {'name':'张三', 'age':10, 'sex':'男'}
>>> dic['class'] = '三年级'
>>> dic
{'name': '张三', 'age': 10, 'sex': '男', 'class': '三年级'}
>>> dic['class'] = '二年级'
>>> dic
{'name': '张三', 'age': 10, 'sex': '男', 'class': '二年级'}

• 删除字典中的元素

可以通过 del 来进行删除操作。语法为 del set[key]，如果删除一个不存在的 key，则会抛出异常。

>>> dic  = {'name':'张三', 'age':3, 'sex':'男'}
>>> del dic['sex']
>>> dic
{'name': '张三', 'age': 3}
>>> del dic['age']
>>> dic
{'name': '张三'}
>>> del dic['age']
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    del dic['age']
KeyError: 'age'
>>> del dic['name']
>>> dic
{}

字典常用操作方法及函数

Set

集合是一个无序的不重复元素序列。可以使用 {} 或者 set() 函数创建一个集合。但创建一个空集合需要使用 set() 函数而不是 {}，因为 {} 用来创建的是空字典。

集合的基本操作

• 添加元素

语法格式为 s.add(x)。将元素 x添加至集合，如果元素存在，则不进行任何操作。另一种方式为 s.update(x)，x 可以是列表、元组、字典等，且可以一次添加多个，多个用 , 隔开。

>>> s = {'张三丰', '张无忌','张翠山'}
>>> s.add('赵敏')
>>> s
{'赵敏', '张无忌', '张三丰', '张翠山'}
>>> s.add('张三丰')
>>> s
{'赵敏', '张无忌', '张三丰', '张翠山'}
>>> a = ('金毛', '哈士奇', '拉布拉多')
>>> s.update(a)
>>> s
{'哈士奇', '赵敏', '金毛', '张无忌', '张三丰', '张翠山', '拉布拉多'}

• 移除元素

s.remove(x)：将元素 x 从集合中移除，如果元素不存在，则抛出异常。
s.discard(x)：将元素 x 从集合中移除，如果元素不存在，不会发生错。
s.pop()：随机移除集合中的元素，并返回该元素。

>>> s = {'哈士奇', '赵敏', '金毛', '张无忌', '张三丰', '张翠山', '拉布拉多'}
>>> s.remove('x')
Traceback (most recent call last):
  File "<pyshell#8>", line 1, in <module>
    s.remove('x')
KeyError: 'x'
>>> s.discard('x')
>>> s
{'哈士奇', '赵敏', '金毛', '张无忌', '张三丰', '张翠山', '拉布拉多'}
>>> a = s.pop()
>>> a
'哈士奇'

集合常用方法