Python 语法基础

1. 数值类型

1.1 数字Numbers

Python 3支持int、float、bool、complex（复数）。在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。内置的type()函数可以用来查询变量所指的对象类型。此外还可以用 isinstance 来判断：

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))

<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

>>> a = 111
>>> isinstance(a, int)
True

可以使用del语句删除一些对象引用。如del var_a, var_b

注意：

1). Python可以同时为多个变量赋值，如a, b = 1, 2。
2). 一个变量可以通过赋值指向不同类型的对象。
3). 到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。
4). 在混合计算时，Python会把整型转换成为浮点数。
5). type()不会认为子类是一种父类类型。isinstance()会认为子类是一种父类类型。

1.1.1 整型 int

int可以存储任意大的数：

>>>  ival = 17239871
>>>  ival ** 6
26254519291092456596965462913230729701102721

1.1.2 浮点型 float

浮点数使用Python的float类型。每个数都是双精度（占8个字节，64位）的值，其中52位表示底，11位表示指数，剩下的一位表示符号。也可以用科学计数法表示：

>>>  fval = 7.243
>>>  fval2 = 6.78e-5

不能得到整数的除法会得到浮点数：

>>>  3 / 2
1.5

要获得C-风格的整除（去掉小数部分），可以使用底除运算符//：

>>>  3 // 2
1

1.1.3 复数 complex

复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。

1.1.4 布尔类型 bool

Python中的布尔值有两个，True和False（注意：首字母都是大写，与C++、JavaScript中的小写有所不同）。比较和其它条件表达式可以用True和False判断。布尔值可以与and，or和not结合使用：

总结一下为假的情况有：

• None, False
• 数值中的0, 0.0, 0j(虚数), Decimal(0), Fraction(0, 1)
• 空字符串(‘’)、空元组(())、空列表([])
• 空字典({})、空集合(set())
• 对象默认为True，除非它有bool()方法且返回False或len()方法且返回0.

>>>  True and True
True

>>>  False or True
True

下面的表列举了布尔运算的结果，优先级为升序：

运算	表达式	结果	说明
或运算	x or y	如果x为False则取决于y；如果x为True则不考虑y	（1）
与运算	x and y	如果x为False则不考虑y；如果x为True则取决于y	（2）
非运算	not x	如果x为False则为True，否则为False	（2）

说明：
（1）or 是一种“短路运算符”，只有当第一个为False时才去验证第二个。即：两个变量只要有一个为True则为True。
（2）and也是种“短路运算符”，只有当第一个为True时才去验证第二个。即：两个变量都为True时结果才为True。
（3）not的优先级比非布尔运算符底，所以not a == b解释为not (a == b)，并且a == not b是语法错误。

1.2 字符串 str

Python中的字符串用单引号 ‘ 或双引号 “ 括起来，同时使用反斜杠 \ 转义特殊字符。

a = 'one way of writing a string'
b = "another way"

对于有换行符的字符串，可以使用三引号，’’’或”””都行：

c = """
This is a longer string that
spans multiple lines
"""

字符串c实际包含四行文本，”””后面和lines后面的换行符。可以用count方法计算c中的新的行：

>>>  c.count('\n')
3

Python的字符串是不可变的，不能修改字符串：

>>>  a = 'this is a string'
>>>  a[10] = 'f'

--------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-57-5ca625d1e504> in <module>()
----> 1 a[10] = 'f'
TypeError: 'str' object does not support item assignment

>>>  b = a.replace('string', 'longer string')
>>>  b
'this is a longer string'

经过以上的操作，变量a并没有被修改：

>>>  a
'this is a string'

许多Python对象使用str函数可以被转化为字符串：

>>>  a = 5.6
>>>  s = str(a)
>>>  print(s)
5.6

字符串是一个序列的Unicode字符，因此可以像其它序列，比如列表和元组（下一章会详细介绍两者）一样处理：

>>>  s = 'python'
>>>  list(s)
['p', 'y', 't', 'h', 'o', 'n']

>>>  s[:3]
'pyt'

语法s[:3]被称作切片，适用于许多Python序列。

索引值以 0 为开始值，-1 为从末尾的开始位置。

加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，紧跟的数字为复制的次数。实例如下：

str = 'Runoob'
 
>>> print (str)          # 输出字符串
Runoob

>>> print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
Runoo

>>> print (str[0])       # 输出字符串第一个字符
R

>>> print (str[2:5])     # 输出从第三个开始到第五个的字符
noo 

>>> print (str[2:])      # 输出从第三个开始的后的所有字符
noob

>>> print (str * 2)      # 输出字符串两次
RunoobRunoob

>>> print (str + "TEST") # 连接字符串
RunoobTEST

Python 使用反斜杠()转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

>>> print('Ru\noob')
Ru
oob

>>> print(r'Ru\noob')
Ru\noob
>>> 

另外，反斜杠()可以作为续行符，表示下一行是上一行的延续。也可以使用 “””…””” 或者 ‘’’…’’’ 跨越多行。

注意，Python 没有单独的字符类型，一个字符就是长度为1的字符串。

>>> word = 'Python'
>>> print(word[0], word[5])
P n

>>> print(word[-1], word[-6])
n P

与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = ‘m’会导致错误。

注意：

• 1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
• 2、字符串可以用+运算符连接在一起，用*运算符重复。
• 3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
• 4、Python中的字符串不能改变。

将两个字符串合并，会产生一个新的字符串：

>>>  a = 'this is the first half '
>>>  b = 'and this is the second half'
 
>>>  a + b

'this is the first half and this is the second half'

字符串的模板化或格式化，是另一个重要的主题。Python 3拓展了此类的方法，这里只介绍一些。字符串对象有format方法，可以替换格式化的参数为字符串，产生一个新的字符串：

>>>  template = '{0:.2f} {1:s} are worth US${2:d}'

在这个字符串中，

• {0:.2f}表示格式化第一个参数为带有两位小数的浮点数。
• {1:s}表示格式化第二个参数为字符串。
• {2:d}表示格式化第三个参数为一个整数。

要替换参数为这些格式化的参数，我们传递format方法一个序列：

>>>  template.format(4.5560, 'Argentine Pesos', 1)
'4.56 Argentine Pesos are worth US$1'

字符串格式化是一个很深的主题，有多种方法和大量的选项，可以控制字符串中的值是如何格式化的。推荐参阅Python官方文档。

1.2.1 类型转换

str、bool、int和float也是函数，可以用来转换类型：

>>>  s = '3.14159'
>>>  fval = float(s)
>>>  type(fval)
float

>>> int(fval)
3

>>>  bool(fval)
True

>>>  bool(0)
 False

1.3 列表 list

List（列表）是 Python 中使用最频繁的数据类型。列表是写在方括号[]之间、用逗号分隔开的元素列表。列表中元素的类型可以不相同它支持数字，字符串甚至可以包含列表（所谓嵌套）：

>>>  a = ['him', 25, 100, 'her']
>>>  print(a)
['him', 25, 100, 'her']

和字符串一样，列表同样可以被索引和切片，列表被切片后返回一个包含所需元素的新列表。

索引值以 0 为开始值，-1 为从末尾的开始位置。

列表还支持串联操作，加号 + 是列表连接运算符，星号 * 是重复操作。

>>>  a = [1, 2, 3, 4, 5]
>>>  a + [6, 7, 8]
[1, 2, 3, 4, 5, 6, 7, 8]
```
与Python字符串不一样的是，列表中的元素是可以改变的：

```python
>>>  a = [1, 2, 3, 4, 5, 6]

>>>  a[0] = 9
>>>  a[2:5] = [13, 14, 15]
>>>  a
[9, 2, 13, 14, 15, 6]

>>>  a[2:5] = []   # 删除
>>>  a
[9, 2, 6]
```
**要点：**
> 1、List写在方括号之间，元素用逗号隔开。
> 2、和字符串一样，list可以被索引和切片。
> 3、List可以使用+操作符进行拼接。
> 4、星号 * 是重复操作。
> 5、List中的元素是可以改变的。

#### 1.3.1 常用方法 
##### 1.3.1.1 更新列表 list.append(obj)
append() 方法向列表的尾部添加一个新的元素。
```python
>>> list1 = ['Google', 'Runoob', 'Taobao']
>>> list1.append('Baidu')
>>> print ("更新后的列表 : ", list1)
更新后的列表 :  ['Google', 'Runoob', 'Taobao', 'Baidu']
```
##### 1.3.1.2 list.count(obj)
count() 方法用于统计某个元素在列表中出现的次数。
```python
>>> aList = [123, 'Google', 'Runoob', 'Taobao', 123];

>>> print ("123 元素个数 : ", aList.count(123))
123 元素个数 :  2
>>> print ("Runoob 元素个数 : ", aList.count('Runoob'))
Runoob 元素个数 :  1
```
统计字符出现的个数或列表内出现的元素次数等也可以用 Counter。
一个 Counter 是一个 dict 的子类，用于计数可哈希对象。
```python
from collections import Counter

>>> c = Counter('sadasfas')
>>> print(c)
Counter({'s': 3, 'a': 3, 'd': 1, 'f': 1})
>>> a=['su','bu','sum','bu','sum','bu']
>>> c = Counter(a)
>>> print(c)
Counter({'bu': 3, 'sum': 2, 'su': 1})
>>> c.update('sadasfas') #添加
>>> print(c)
Counter({'bu': 3, 's': 3, 'a': 3, 'sum': 2, 'su': 1, 'd': 1, 'f': 1})
```
##### 1.3.1.3 list.extend(seq)
extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。
```python
# 语言列表
>>> language = ['French', 'English', 'German']
 
# 元组
>>> language_tuple = ('Spanish', 'Portuguese')
 
# 集合
>>> language_set = {'Chinese', 'Japanese'}
 
# 添加元组元素到列表末尾
>>> language.extend(language_tuple)
 
>>> print('新列表: ', language)
新列表:  ['French', 'English', 'German', 'Spanish', 'Portuguese']
# 添加集合元素到列表末尾
>>> language.extend(language_set)
 
>>> print('新列表: ', language)
新列表:  ['French', 'English', 'German', 'Spanish', 'Portuguese', 'Japanese', 'Chinese']
```

##### 1.3.1.4 list.index(obj)
index() 函数用于从列表中找出某个值第一个匹配项的索引位置。该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。
index()方法语法：
```python
>>> list.index(x[, start[, end]])
```
```python
>>> list1 = ['Google', 'Runoob', 'Taobao']
>>> print ('Runoob 索引值为', list1.index('Runoob'))
Runoob 索引值为 1
>>> print ('Taobao 索引值为', list1.index('Taobao'))
Taobao 索引值为 2
```
##### 1.3.1.5 list.insert(index, obj)
insert() 函数用于将指定对象插入列表的指定位置。该方法没有返回值，但会在列表指定位置插入对象。
```python
>>> list1 = ['Google', 'Runoob', 'Taobao']
>>> list1.insert(1, 'Baidu')
>>> print ('列表插入元素后为 : ', list1)
列表插入元素后为 :  ['Google', 'Baidu', 'Runoob', 'Taobao']
```

##### 1.3.1.6 list.pop([index=-1])
pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
```python
>>> list1 = ['Google', 'Runoob', 'Taobao']
>>> list1.pop()
>>> print ("列表现在为 : ", list1)
列表现在为 :  ['Google', 'Runoob']

>>> list1.pop(1)
>>> print ("列表现在为 : ", list1)
列表现在为 :  ['Google']
```
##### 1.3.1.7 list.remove(obj)
remove() 函数用于移除列表中某个值的第一个匹配项。该方法没有返回值但是会移除列表中的某个值的第一个匹配项。
```python
>>> list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
>>> list1.remove('Taobao')
>>> print ("列表现在为 : ", list1)
列表现在为 :  ['Google', 'Runoob', 'Baidu']
>>> list1.remove('Baidu')
>>> print ("列表现在为 : ", list1)
列表现在为 :  ['Google', 'Runoob']
```
##### 1.3.1.8 list.reverse()
reverse() 函数用于反向列表中元素。该方法没有返回值，但是会对列表的元素进行反向排序。
```python
>>> list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
>>> list1.reverse()
>>> print ("列表反转后: ", list1)
列表反转后:  ['Baidu', 'Taobao', 'Runoob', 'Google']
```
##### 1.3.1.9 list.sort(key=None, reverse=False)
sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。该方法没有返回值，但是会对列表的对象进行排序。
```python
>>> aList = ['Google', 'Runoob', 'Taobao', 'Facebook']
 
>>> aList.sort()
>>> print ( "List : ", aList)
List :  ['Facebook', 'Google', 'Runoob', 'Taobao']
```
```python
# 列表
>>> vowels = ['e', 'a', 'u', 'o', 'i']
 
# 降序
>>> vowels.sort(reverse=True)
 
# 输出结果
>>> print ( '降序输出:', vowels )
降序输出: ['u', 'o', 'i', 'e', 'a']
```
##### 1.3.1.10 	list.clear()
clear() 函数用于清空列表，类似于 del a[:]。该方法没有返回值。
```python
>>> list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
>>> list1.clear()
>>> print ("列表清空后 : ", list1)
列表清空后 :  []
```

调用 clear() 方法后，已经赋值给其它变量的列表也会被清空。
```python
>>> d = {}
>>> 
>>> d = {}
>>> s = ['一','二','三','四']
>>> d['大写数字'] = s
>>> d
{'大写数字': ['一', '二', '三', '四']}
>>> s.clear()
>>> d
{'大写数字': []}
>>> 
```
> 通过 clear() 方法，remove() 方法，pop() 方法，append() 方法等改变列表的，相应的已经赋值给其它变量的列表也会被清空。
##### 1.3.1.11 list.copy()
copy() 函数用于复制列表，类似于 a[:]。返回复制后的新列表。
```python
>>> list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
>>> list2 = list1.copy()
>>> print ("list2 列表: ", list2)

list2 列表:  ['Google', 'Runoob', 'Taobao', 'Baidu']
```
#### 1.3.2 Python列表脚本操作符

列表对 + 和  * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

如下所示：

| Python 表达式          | 结果          | 描述             |
| :--------------------: | :-----------: | :-------------: |
| len([1, 2, 3])         | 3             | 长度            |
| [1, 2, 3] + [4, 5, 6]  | [1, 2, 3, 4, 5, 6]  | 组合      |
| ['Hi!'] * 4   | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重复      |
| 3 in [1, 2, 3]   | True      | 元素是否存在于列表中 |
| for x in [1, 2, 3]: print(x, end=" ") | 1 2 3   | 迭代    |

### 1.4 元组 tuple

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。

元组中的元素类型也可以不相同：
实例

```python
>>> tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
>>> tinytuple = (123, 'runoob')
 
>>> print (tuple)             # 输出完整元组
('abcd', 786, 2.23, 'runoob', 70.2)

>>> print (tuple[0])          # 输出元组的第一个元素
abcd

>>> print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
(786, 2.23)

>>> print (tuple[2:])         # 输出从第三个元素开始的所有元素
(2.23, 'runoob', 70.2)

>>> print (tinytuple * 2)     # 输出两次元组
123, 'runoob', 123, 'runoob')

>>> print (tuple + tinytuple) # 连接元组
('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')
```
元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取（）。其实，可以把字符串看作一种特殊的元组。 

```python
>>> tup = (1, 2, 3, 4, 5, 6) 
>>> print(tup[0])
1 

>>> print(tup[1:5])
(2, 3, 4, 5) 

>>> tup1 = (12, 34.56)
>>> tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
>>> # 创建一个新的元组
>>> tup3 = tup1 + tup2
>>> print (tup3)
(12, 34.56, 'abc', 'xyz')
```
虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

```python
>>> tup1 = ()    # 空元组
>>> tup2 = (20,) # 一个元素，需要在元素后添加逗号
```

string、list 和 tuple 都属于 sequence（序列）。

**注意：**

- 1、与字符串一样，元组的元素不能修改。
- 2、元组也可以被索引和切片，方法一样。
- 3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
- 4、元组也可以使用+操作符进行拼接。

#### 1.4.1 元组内置函数

Python元组包含了以下内置函数

| 序号 | 方法及描述    | 实例                        |
| :----: | :-------------: | :-----------------------: |
| 1    | len(tuple) 计算元组元素个数。     | `>>> tuple1 = ('Google', 'Runoob', 'Taobao') >>> len(tuple1) 3 >>> ` |
| 2    | max(tuple) 返回元组中元素最大值。 | `>>> tuple2 = ('5', '4', '8') >>> max(tuple2) '8' >>> `      |
| 3    | min(tuple) 返回元组中元素最小值。 | `>>> tuple2 = ('5', '4', '8') >>> min(tuple2) '4' >>> `      |
| 4    | tuple(seq) 将列表转换为元组。     | `>>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu'] >>> tuple1=tuple(list1) >>> tuple1 ('Google', 'Taobao', 'Runoob', 'Baidu')` |





### 1.5 字典 dict
字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值(key=>value)对用冒号(**:**)分割，每个对之间用逗号(**,**)分割，整个字典包括在花括号(**{})**中 ,格式如下所示：

```python
d = {key1 : value1, key2 : value2 }
```
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
一个简单的字典实例：
```python
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
```
也可如此创建字典：

```python
>>> dict1 = { 'abc': 456 }
>>> dict2 = { 'abc': 123, 98.6: 37 }
```
#### 1.5.1 访问字典里的值

把相应的键放入到方括号中，如下实例:
```python
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}  
>>> print ("dict['Name']: ", dict['Name']) 
dict['Name']:  Runoob

>>> print ("dict['Age']: ", dict['Age'])
dict['Age']:  7
```
如果用字典里没有的键访问数据，会输出错误如下：
```python
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}  

>>> print ("dict['Alice']: ", dict['Alice'])

Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print ("dict['Alice']: ", dict['Alice'])
KeyError: 'Alice'
```

#### 1.5.2 修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:

```python
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}  
>>> dict['Age'] = 8               # 更新 Age 
>>> dict['School'] = "菜鸟教程"  # 添加信息   
>>> print ("dict['Age']: ", dict['Age']) 
dict['Age']:  8

>>> print ("dict['School']: ", dict['School'])
dict['School']:  菜鸟教程
```
#### 1.5.3 删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。

显示删除一个字典用del命令，如下实例：
```python
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} 

>>> del dict['Name'] # 删除键 'Name' 
>>> dict.clear()     # 清空字典 
>>> del dict         # 删除字典  

>>> print ("dict['Age']: ", dict['Age']) 
>>> print ("dict['School']: ", dict['School'])

```
但这会引发一个异常，因为用执行 del 操作后字典不再存在：

```
Traceback (most recent call last):
  File "test.py", line 9, in <module>
    print ("dict['Age']: ", dict['Age'])
TypeError: 'type' object is not subscriptable
```
#### 1.5.3 字典键的特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。

两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
```python
>>> dict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'} 
>>> print ("dict['Name']: ", dict['Name'])

dict['Name']:  小菜鸟
```
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：
```python
>>> dict = {['Name']: 'Runoob', 'Age': 7}  
>>> print ("dict['Name']: ", dict['Name'])

Traceback (most recent call last):
  File "test.py", line 3, in <module>
    dict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'
```
#### 1.5.4 内置函数：

|  序号  |     函数及描述      |           实例               |
| :----: | :----------------: | :--------------------------: |
| 1    | len(dict) 计算字典元素个数，即键的总数。     | `>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> len(dict) 3` |
| 2    | str(dict) 输出字典，以可打印的字符串表示。 | `>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> str(dict) "{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"` |
| 3    | type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。 | `>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> type(dict) ` |

#### 1.5.5 内置方法：
##### 1.5.5.1 dict.clear()
Python 字典 clear() 函数用于删除字典内所有元素。该函数没有任何返回值。
```python
>>> dict = {'Name': 'Zara', 'Age': 7}
>>> print ("字典长度 : %d" %  len(dict))
字典长度 : 2

>>> dict.clear()
>>> print ("字典删除后长度 : %d" %  len(dict))
字典删除后长度 : 0
```
##### 1.5.5.2 dict.copy()
Python 字典 copy() 函数返回一个字典的浅复制。返回一个字典的浅复制。
```python
>>> dict1 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> dict2 = dict1.copy()
>>> print ("新复制的字典为 : ",dict2)
新复制的字典为 :  {'Age': 7, 'Name': 'Runoob', 'Class': 'First'}
```


##### 1.5.5.3 dict.fromkeys()
Python 字典 fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。该方法返回一个新字典。
```python
>>> seq = ('name', 'age', 'sex')
>>> dict = dict.fromkeys(seq)
>>> print ("新的字典为 : %s" %  str(dict))
新的字典为 : {'age': None, 'name': None, 'sex': None}

>>> dict = dict.fromkeys(seq, 10)
>>> print ("新的字典为 : %s" %  str(dict))
新的字典为 : {'age': 10, 'name': 10, 'sex': 10}
```
##### 1.5.5.4 dict.get(key, default=None)
Python 字典 get() 函数返回指定键的值，如果值不在字典中返回默认值。返回指定键的值，如果值不在字典中返回默认值 None。
```python
>>> dict = {'Name': 'Runoob', 'Age': 27}
>>> print ("Age 值为 : %s" %  dict.get('Age'))
Age 值为 : 27

>>> print ("Sex 值为 : %s" %  dict.get('Sex', "NA"))
Sex 值为 : NA
```
##### 1.5.5.5 key in dict
Python 字典 in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回 true，否则返回 false。

而 not in 操作符刚好相反，如果键在字典 dict 里返回 false，否则返回 true。

##### 1.5.5.6 dict.items()
Python 字典 items() 方法以列表返回可遍历的(键, 值) 元组数组。返回可遍历的(键, 值) 元组数组。
```python
>>> dict = {'Name': 'Runoob', 'Age': 7}
>>> print ("Value : %s" %  dict.items())
Value : dict_items([('Age', 7), ('Name', 'Runoob')])
```
遍历例子：
```python
>>> dict = {'Name': 'Runoob', 'Age': 7}
>>> for i,j in dict.items():
>>>     print(i, ":\t", j)
#输出：
Name :   Runoob
Age :    7
```
##### 1.5.5.7 dict.keys()
Python3 字典 keys() 方法返回一个可迭代对象，可以使用 list() 来转换为列表。**注意**：Python2.x 是直接返回列表
```python
>>> dict = {'Name': 'Runoob', 'Age': 7}
>>> dict.keys()
dict_keys(['Name', 'Age'])

>>> list(dict.keys())             # 转换为列表
['Name', 'Age']
字典所有的键为 : dict_keys(['Age', 'Name'])
```

##### 1.5.5.8 dict.setdefault(key, default=None)
Python 字典 setdefault() 方法和 get()方法 类似, 如果键不已经存在于字典中，将会添加键并将值设为默认值。
如果 key 在 字典中，返回对应的值。如果不在字典中，则插入 key 及设置的默认值 default，并返回 default ，default 默认值为 None。 
```python
>>> dict = {'Name': 'Runoob', 'Age': 7}
>>> print ("Age 键的值为 : %s" %  dict.setdefault('Age', None))
Age 键的值为 : 7

>>> print ("Sex 键的值为 : %s" %  dict.setdefault('Sex', None))
Sex 键的值为 : None

>>> print ("新字典为：", dict)
新字典为： {'Age': 7, 'Name': 'Runoob', 'Sex': None}
```


##### 1.5.5.9 dict.update(dict2)
Python 字典 update() 函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。该方法没有任何返回值。
```python
>>> dict = {'Name': 'Runoob', 'Age': 7}
>>> dict2 = {'Sex': 'female' }
 
>>> dict.update(dict2)
>>> print ("更新字典 dict : ", dict)
更新字典 dict :  {'Name': 'Runoob', 'Age': 7, 'Sex': 'female'}
```
##### 1.5.5.10 dict.values()
Python 字典 values() 方法返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值。
```python
>>> dict = {'Sex': 'female', 'Age': 7, 'Name': 'Zara'}
>>> print ("字典所有值为 : ",  list(dict.values()))
字典所有值为 :  ['female', 7, 'Zara']
```

##### 1.5.5.11 pop(key[,default])
Python 字典 pop() 方法删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
```python
>>> site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}
>>> pop_obj=site.pop('name')
>>> print(pop_obj)
菜鸟教程
```
##### 1.5.5.12 popitem()
Python 字典 popitem() 方法随机返回并删除字典中的最后一对键和值。返回一个键值对(key,value)形式，按照 LIFO（Last In First Out 后进先出法） 顺序规则，即最末尾的键值对。
如果字典已经为空，却调用了此方法，就报出KeyError异常。
```python
>>> site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}
>>> pop_obj=site.popitem()
>>> print(pop_obj)  
('url', 'www.runoob.com')

>>> print(site)
{'name': '菜鸟教程', 'alexa': 10000}
```

注意：

    1、字典是一种映射类型，它的元素是键值对。
    2、字典的关键字必须为不可变类型，且不能重复。
    3、创建空字典使用 { }。

### 1.6 集合
集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：
```python
parame = {value01,value02,...}
或者
set(value)
```
```python
>>> student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}  
>>> print(student)   # 输出集合，重复的元素被自动去掉  
{'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}

# 成员测试 
>>> if 'Rose' in student :
>>> 	print('Rose 在集合中') 
>>> else :
>>> 	print('Rose 不在集合中')   
Rose 在集合中

# set可以进行集合运算 
>>> a = set('abracadabra') 
>>> b = set('alacazam')  
>>> print(a) 
{'b', 'a', 'c', 'r', 'd'}

>>> print(a - b)     # a 和 b 的差集  
{'b', 'd', 'r'}

>>> print(a | b)     # a 和 b 的并集  
{'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}

>>> print(a & b)     # a 和 b 的交集  
{'a', 'c'}

>>> print(a ^ b)     # a 和 b 中不同时存在的元素
{'l', 'r', 'z', 'm', 'b', 'd'}
```

### 1.7 空None

None是Python的空值类型。如果一个函数没有明确的返回值，就会默认返回None：

```python
>>>  a = None
>>>  a is None
True

>>>  b = 5
>>>  b is not None
True
```

None也常常作为函数的默认参数：

```python
def add_and_maybe_multiply(a, b, c=None):
    result = a + b

    if c is not None:
        result = result * c

    return result
```

另外，None不仅是一个保留字，还是唯一的NoneType的实例：

```python
>>>  type(None)
NoneType
```


### 1.8 字节和Unicode
在Python 3及以上版本中，Unicode是一级的字符串类型，这样可以更一致的处理ASCII和Non-ASCII文本。在老的Python版本中，字符串都是字节，不使用Unicode编码。假如知道字符编码，可以将其转化为Unicode。看一个例子：

```python
>>>  val = "español"

>>>  val
'español'
```

可以用`encode`将这个Unicode字符串编码为UTF-8：

```python
>>> val_utf8 = val.encode('utf-8')

>>> val_utf8
b'espa\xc3\xb1ol'

>>>  type(val_utf8)
bytes
```

如果你知道一个字节对象的Unicode编码，用`decode`方法可以解码：

```python
>>>  val_utf8.decode('utf-8')
'español'
```

虽然UTF-8编码已经变成主流，但因为历史的原因，你仍然可能碰到其它编码的数据：

```python
>>> val.encode('latin1')
b'espa\xf1ol'

>>> val.encode('utf-16')
b'\xff\xfee\x00s\x00p\x00a\x00\xf1\x00o\x00l\x00'

>>> val.encode('utf-16le')
b'e\x00s\x00p\x00a\x00\xf1\x00o\x00l\x00'
```

工作中碰到的文件很多都是字节对象，盲目地将所有数据编码为Unicode是不可取的。

虽然用的不多，你可以在字节文本的前面加上一个b：

```python
>>>  bytes_val = b'this is bytes'

>>>  bytes_val
b'this is bytes'

>>>  decoded = bytes_val.decode('utf8')
>>>  decoded  # this is str (Unicode) now
'this is bytes'
```
### 1.9 Python数据类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

|                          函数                           |                     描述                     |
| :-----------------------------------------: | :------------------------------------: |
| [int(x [,base\])](https://www.runoob.com/python3/python-func-int.html) | 将x转换为一个整数              |
| [float(x)](https://www.runoob.com/python3/python-func-float.html) | 将x转换到一个浮点数                 |
| [complex(real [,imag\])](https://www.runoob.com/python3/python-func-complex.html) | 创建一个复数        |
| [str(x)](https://www.runoob.com/python3/python-func-str.html) | 将对象 x 转换为字符串                    |
| [repr(x)](https://www.runoob.com/python3/python-func-repr.html) | 将对象 x 转换为表达式字符串            |
| [eval(str)](https://www.runoob.com/python3/python-func-eval.html) |计算字符串中的有效表达式,返回一个对象  |
| [tuple(s)](https://www.runoob.com/python3/python3-func-tuple.html) | 将序列 s 转换为一个元组             |
| [list(s)](https://www.runoob.com/python3/python3-att-list-list.html) | 将序列 s 转换为一个列表           |
| [set(s)](https://www.runoob.com/python3/python-func-set.html) | 转换为可变集合                           |
| [dict(d)](https://www.runoob.com/python3/python-func-dict.html) | 创建字典。d 必须是 (key, value)元组序列|
| [frozenset(s)](https://www.runoob.com/python3/python-func-frozenset.html) | 转换为不可变集合            |
| [chr(x)](https://www.runoob.com/python3/python-func-chr.html) | 将一个整数转换为一个字符                |
| [ord(x)](https://www.runoob.com/python3/python-func-ord.html) | 将一个字符转换为它的整数值              |
| [hex(x)](https://www.runoob.com/python3/python-func-hex.html) | 将一个整数转换为一个十六进制字符串      |
| [oct(x)](https://www.runoob.com/python3/python-func-oct.html) | 将一个整数转换为一个八进制字符串        |

## 2. 变量与运算符

### 2.1  变量命名规则

### 2.2 变量赋值

### 2.3 运算符

大多数二元数学运算和比较都不难想到：

```python
In [32]: 5 - 7
Out[32]: -2

In [33]: 12 + 21.5
Out[33]: 33.5

In [34]: 5 <= 2
Out[34]: False
```

下表列出了所有的二元运算符。

要判断两个引用是否指向同一个对象，可以使用`is`方法。`is not`可以判断两个对象是不同的：

```python
In [35]: a = [1, 2, 3]

In [36]: b = a

In [37]: c = list(a)

In [38]: a is b
Out[38]: True

In [39]: a is not c
Out[39]: True
```

因为`list`总是创建一个新的Python列表（即复制），我们可以断定c是不同于a的。使用`is`比较与`==`运算符不同，如下：

```python
In [40]: a == c
Out[40]: True
```

`is`和`is not`常用来判断一个变量是否为`None`，因为只有一个`None`的实例：

```python
In [41]: a = None

In [42]: a is None
Out[42]: True
```

![&#x8868;2-3 &#x4E8C;&#x5143;&#x8FD0;&#x7B97;&#x7B26;](/home/jwang/opt/workspace/github/myblog/source/_posts/20200103-python-basis.assets/7178691-9fb5f25b33166acf.png)



## 3. Python流程控制

Python有若干内建的关键字进行条件逻辑、循环和其它控制流操作

### 3.1 if语句

if是最广为人知的控制流语句。它检查一个条件，如果为True，就执行后面的语句：

```python
if x < 0:
    print('It's negative')
```

`if`后面可以跟一个或多个`elif`，所有条件都是False时，还可以添加一个`else`：

```python
if x < 0:
    print('It is negative')
elif x == 0:
    print('Equal to zero')
elif 0 < x < 5:
    print('Positive but smaller than 5')
else:
    print('Positive and larger than or equal to 5')
```

如果某个条件为True，后面的`elif`就不会被执行。当使用and和or时，复合条件语句是从左到右执行：

```python
In [117]: a = 5; b = 7

In [118]: c = 8; d = 4

In [119]: if a < b or c > d:
   .....:     print('Made it')
Made it
```

在这个例子中，`c > d`不会被执行，因为第一个比较是True：

也可以把比较式串在一起：

```python
In [120]: 4 > 3 > 2 > 1
Out[120]: True
```

### 3.2 for语句
for循环是在一个集合（列表或元组）中进行迭代，或者就是一个迭代器。for循环的标准语法是：

```python
for value in collection:
    # do something with value
```

你可以用continue使for循环提前，跳过剩下的部分。看下面这个例子，将一个列表中的整数相加，跳过None：

```python
sequence = [1, 2, None, 4, None, 5]
total = 0
for value in sequence:
    if value is None:
        continue
    total += value
```

可以用`break`跳出for循环。下面的代码将各元素相加，直到遇到5：

```python
sequence = [1, 2, 0, 4, 6, 5, 2, 1]
total_until_5 = 0
for value in sequence:
    if value == 5:
        break
    total_until_5 += value
```

break只中断for循环的最内层，其余的for循环仍会运行：

```python
In [121]: for i in range(4):
   .....:     for j in range(4):
   .....:         if j > i:
   .....:             break
   .....:         print((i, j))
   .....:
(0, 0)
(1, 0)
(1, 1)
(2, 0)
(2, 1)
(2, 2)
(3, 0)
(3, 1)
(3, 2)
(3, 3)
```

如果集合或迭代器中的元素序列（元组或列表），可以用for循环将其方便地拆分成变量：

```python
for a, b, c in iterator:
    # do something
```

### 3.3 break 跳出循环

### 3.4 continue跳出本次循环

### 3.5 pass 什么都不做


### 3.6 while
while循环指定了条件和代码，当条件为False或用break退出循环，代码才会退出：

```python
x = 256
total = 0
while x > 0:
    if total > 500:
        break
    total += x
    x = x // 2
```


## 4. Python文件处理

### 4.1 常用函数

#### 4.1.1 open()

#### 4.1.2 read()

#### 4.13 .readline()

#### 4.1.4 readlines()

#### 4.1.5 write()

#### 4.1.6 close()


### 4.2 上下文管理器

#### with open (afile) as:



## 5. Python 输入输出
### 5.1 输出 print
### 5.2 输入 input


## 6. Python 异常

### 6.1 错误和异常

### 6.2 异常类型

### 6.3 异常捕获

### 6.4 上下文管理

### 6.5 特殊处理



## 7. Python 函数和模块
### 7.1 函数定义

### 7.2 函数调用

### 7.3 函数返回

### 7.4 函数参数


### 7.5 迭代器


### 7.6 生成器

### 7.7 匿名函数

### 7.8 函数式编程

### 7.9 闭包

### 7.10 模块的导入



## 8. Python 面相对象

### 8.1 类的定义


### 8.2 类对象

### 8.3 继承

### 8.4 操作



## 9. Python 多线程

### 9.1 多线程可以让程序并行执行

### 9.2 常用库

### 9.3 常用方法



## 10.Python 标准库

### 10.1 运行服务的\_\_main\_\_

### 10.2 文字处理的re

### 10.3 日期类型的time, datetime

Python内建的`datetime`模块提供了`datetime`、`date`和`time`类型。`datetime`类型结合了`date`和`time`，是最常使用的：

```python
In [102]: from datetime import datetime, date, time

In [103]: dt = datetime(2011, 10, 29, 20, 30, 21)

In [104]: dt.day
Out[104]: 29

In [105]: dt.minute
Out[105]: 30
```

根据`datetime`实例，你可以用`date`和`time`提取出各自的对象：

```python
In [106]: dt.date()
Out[106]: datetime.date(2011, 10, 29)

In [107]: dt.time()
Out[107]: datetime.time(20, 30, 21)
```

`strftime`方法可以将datetime格式化为字符串：

```python
In [108]: dt.strftime('%m/%d/%Y %H:%M')
Out[108]: '10/29/2011 20:30'
```

`strptime`可以将字符串转换成`datetime`对象：

```python
In [109]: datetime.strptime('20091031', '%Y%m%d')
Out[109]: datetime.datetime(2009, 10, 31, 0, 0)
```

表2-5列出了所有的格式化命令。

![&#x8868;2-5 Datetime&#x683C;&#x5F0F;&#x5316;&#x6307;&#x4EE4;&#xFF08;&#x4E0E;ISO C89&#x517C;&#x5BB9;&#xFF09;](/home/jwang/opt/workspace/github/myblog/source/_posts/20200103-python-basis.assets/7178691-100f9a20c1536553.png)

当你聚类或对时间序列进行分组，替换datetimes的time字段有时会很有用。例如，用0替换分和秒：

```python
In [110]: dt.replace(minute=0, second=0)
Out[110]: datetime.datetime(2011, 10, 29, 20, 0)
```

因为`datetime.datetime`是不可变类型，上面的方法会产生新的对象。

两个datetime对象的差会产生一个`datetime.timedelta`类型：

```python
In [111]: dt2 = datetime(2011, 11, 15, 22, 30)

In [112]: delta = dt2 - dt

In [113]: delta
Out[113]: datetime.timedelta(17, 7179)

In [114]: type(delta)
Out[114]: datetime.timedelta
```

结果`timedelta(17, 7179)`指明了`timedelta`将17天、7179秒的编码方式。

将`timedelta`添加到`datetime`，会产生一个新的偏移`datetime`：

```python
In [115]: dt
Out[115]: datetime.datetime(2011, 10, 29, 20, 30, 21)

In [116]: dt + delta
Out[116]: datetime.datetime(2011, 11, 15, 22, 30)
```

###

### 10.4 数字和数学类型的math, random

### 10.5 文件和目录访问pathlib, os.lib

### 10.6 数据压缩和归档tarfile

### 10.7 通用操作系统os, argparse, logging, subprocess

### 10.8 多线程threading, queue

### 10.9 Internet数据处理的base64, json, urllib

### 10.10 结构化标记处理工具html, xml

### 10.11 开发工具的unitest

### 10.12 调试工具的timeit

### 10.13 软件包发布的venv

## 11. Python 第三方库

### 11.1 numpy

### 11.2 scipy

### 11.3 matplotlib

### 11.4 pandas

### 11.5 sklearn

### 11.6 psrchive

### 11.7 astropy