Python入门课程[微软官方+廖雪峰]

课程：微软官方 Python 入门教程

1. 输入输出

input() 输入

字符串

print() 输出

# 输出字符串，单双引号都可用，注意统一
print("Hello World")
print('Hello World')

# 输出空行
print()

# \n 自动换行
print("Hello \nWorld")

用print()函数debug

格式化

1）占位符

'Hello, %s'% 'world'
输出：'Hello, world'
'Hi, %s, you have $%d.'% ('Michael', 1000000)
输出：'Hi, Michael, you have $1000000.'

%d：整数
%f：浮点数
%s：字符串
%x：十六进制整数

格式化整数和浮点数还可以指定是否补0和整数与小数的位数：

print('%2d-%02d' % (3, 1))
print('%.2f' % 3.1415926)
输出：
 3-01
3.14

如果不太确定应该用什么，%s永远起作用，它会把任何数据类型转换为字符串；
字符串里面的%是一个普通字符时需要转义，用%%来表示一个%。

2）format()方法

另一种格式化字符串的方法是使用字符串的format()方法，它会用传入的参数依次替换字符串内的占位符{0}、{1}……（不写0、1也可以）

'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)
输出：'Hello, 小明, 成绩提升了 17.1%'

3）f-string

最后一种格式化字符串的方法是使用以f开头的字符串，称之为f-string，它和普通字符串不同之处在于，字符串如果包含{xxx}，就会以对应的变量替换：

r = 2.5
s = 3.14* r ** 2
print(f'The area of a circle with radius {r} is {s:.2f}')
The area of a circle with radius 2.5 is 19.62

上述代码中，{r}被变量r的值替换，{s:.2f}被变量s的值替换，并且:后面的.2f指定了格式化参数（即保留两位小数），因此，{s:.2f}的替换结果是19.62。

2. 注释 comments

# 单行注释

'''
多行注释
多行注释
多行注释
'''

3. 字符串

变量命名

不用声明！！！
直接给一个变量并赋值就ok

操作

可以直接相加

first_name = 'Dabiao'
last_name = 'Meng'

print(first_name + ' ' + last_name)
print(first_name + last_name)

first_name.lower() 
print(first_name)
print(first_name.lower())  # 变小写
first_name = first_name.lower() # 改变了first_name的值
print(first_name) 

print(last_name.upper()) # 变大写

print(first_name.capitalize()) # 首字母大写

print(first_name.count('a')) # 计算字母a的个数 

# 输出结果
Dabiao Meng
DabiaoMeng
Dabiao
dabiao
dabiao
MENG
Dabiao
2

字符串格式化

first_name = 'Dabiao'
last_name = 'Meng'

output1 = 'Hello1, ' + first_name + ' ' + last_name
print(output1)


output2 = 'Hello2, {} {}'.format(first_name,last_name)
print(output2)
output3 = 'Hello3, {0} {1}'.format(first_name,last_name) # 从0开始
print(output3)
output4 = f'Hello4, {first_name} {last_name}' # python3
print(output4)

# 也可以直接输出！
print('Hello1, ' + '\n' + first_name + ' ' + last_name)
print('Hello2, \n{} {}'.format(last_name,first_name)) 
print('Hello3, \n{1} {0}'.format(first_name,last_name))
print(f'Hello4, \n{first_name} {last_name}')

数字和字符串类型转换

数字可相加，字符串可相加，但是数字和字符串不可相加
如果想输出数字（或其他数据类型）+字符串，需要将数字（或其他数据类型）转换成字符串，需要调用字符串函数str()

days_in_feb = 28
print(str(days_in_feb) + ' days in February')

注意，加了引号的是字符串，避坑！！！

first_num = input('Enter first number: ')
second_num = input('Enter second number: ')
print(first_num + second_num)

# 输出结果：
Enter first number: 1
Enter second number: 4
14

input()函数输入的为字符串格式！！！

# 进行格式串转换：
first_num = input('Enter first number: ')
second_num = input('Enter second number: ')
print(int(first_num) + int(second_num)) # 整型
print(float(first_num) + float(second_num)) # 浮点型
print(int(first_num) ** int(second_num)) # 乘方

# 输出结果：
Enter first number: 2
Enter second number: 3
5
5.0
8
# 如果输入的是小数，则无法进行整型间的运算

4. 日期

需要调用datetime库

子类关系：
object

• timedelta 时间间隔
• tzinfo
  • timezone
• time
• date 日期
  • datetime

输出当前日期时间

from datetime import datetime

current_date = datetime.now() # 当前日期和时间
print('Now is: ' + str(current_date))
print('Day: ' + str(current_date.day))
print('Month: ' + str(current_date.month))
print('Year: ' + str(current_date.year))

# 输出结果：
Now is: 2021-08-10 15:13:24.018980
Day: 10
Month: 8
Year: 2021

日期和字符串的相互转换

str转换成datetime

from datetime import datetime
cday = datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S')
print(cday)

# 输出结果：
2015-06-01 18:19:59
# 无时区信息

字符串'%Y-%m-%d %H:%M:%S'规定了日期和时间部分的格式。

注意strptime()和strftime()

datetime转换成str

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M'))

# 输出结果：
Tue, Aug 10 15:47

datetime加减–timedelta

from datetime import date,timedelta

today = date.today() # 当前日期
one_day = timedelta(days=1) # 定义一个时间差
yesterday = today - one_day
print('Yesterday was: ' + str(yesterday))

# 输出结果：
Yesterday was: 2021-08-09

class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)

所有参数都是可选的并且默认为 0。 这些参数可以是整数或者浮点数，也可以是正数或者负数。

参考

5. 异常处理

注意error handling和debugging的区别
error handling：不可控因素
debugging：已知程序存在问题

Error types：
Syntax errors
Runtime errors
Logic errors

try/except/finally

x = 24
y = 0

try:
	print(x/y)
except ZeroDivisionError as e:
	print("Not allowed to divide by zero")
else:
	print("Something else went wrong")
finally:
	print("This is our cleanup code")

6. 运算符

python运算符：
算术运算符
比较（关系）运算符
赋值运算符
逻辑运算符
位运算符
成员运算符
身份运算符

7. 条件语句

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

字符串比较，对大小写敏感
如果需要进行字符串的比较’==‘，可以把输入字符串通过全部大写或小写的形式用于比较

country = input("Enter your country: ")
city = input("Enter your city: ")
if country.lower() == 'china':
	if city.lower() == 'beijing' or city.lower() == 'shanghai':
	#if city.lower() in ('beijing','shanghai'):
		print(f'{city} is a big city')
	else:
		print(f'{city} is not a big city')
else:
	print("You are a foreigner")

8. 布尔标记

如果用了过多的if语句，可以使用布尔类型变量简化代码

gpa = 0.9
lowest_grade = 79
if gpa >= .85 and lowest_grade >= 70.0:
	honor_roll = True # 注意没有引号！！！
else:
	honor_roll = False
if honor_roll:
	print("well done! ")

9. 数据类型

Python3 中有六个标准的数据类型：
Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）

Python3 的六个标准数据类型中：
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

使用内建的isinstance函数可以判断一个变量的类型：

isinstance(object, type)

>>> x = 'abc'
>>> y = 123
>>> isinstance(x, str)
True
>>> isinstance(y, int)
True

也可以用于判断其他类型

列表

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
元素也可以为列表。列表可以存储各种数据类型，包括字典。

可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

数据读取

列表截取的语法格式如下：变量[头下标:尾下标]

注意：不包括尾下标所在位置！！！相当于左闭右开区间

索引值以 0 为开始值，-1 为从末尾的开始位置。
Python 列表截取可以接收第三个参数，参数作用是截取的步长，如果第三个参数为负数表示逆向读取。

加号 + 是列表连接运算符，星号 * 是重复操作。

names = ['Amy','Bob','Mei']
print(len(names)) # 获取变量的个数
names.insert(0,'Candy') # 在0前插入Candy
print(names)
names.insert(2,'Nancy')
print(names)
names.sort() # 按照首字母顺序排序
print(names)
presenters = names[0:2] # 左闭右开
print(presenters)

# 输出结果：
3
['Candy', 'Amy', 'Bob', 'Mei']
['Candy', 'Amy', 'Nancy', 'Bob', 'Mei']
['Amy', 'Bob', 'Candy', 'Mei', 'Nancy']
['Amy', 'Bob']

增加数据

数据追加

names.append('Dave')
输出：['Amy', 'Bob', 'Mei', 'Dave']

数据插入到指定位置

names.insert(2,'Candy')  # 在索引号为2的位置插入Candy
输出：['Amy', 'Bob', 'Candy', 'Mei', 'Dave']

删除数据

删除结尾数据

names.pop()  # 在索引号为2的位置插入Candy
输出：['Amy', 'Bob', 'Candy', 'Mei']

删除指定位置的数据

names.pop(2)  # 删除索引号为2的位置的数据
输出：['Amy', 'Bob', 'Mei']

数组中的值必须是相同的数据类型，列表可以是任意类型

输出列表中出现次数最多的元素

a = [1,1,2,3]
print(max(a,key=a.count))
输出：1

列表生成式

列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式。

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['x=A', 'y=B', 'z=C']

>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']

元组

有序列表，tuple一旦初始化就不能修改【代码会更安全】
（指向的元素/位置不变，但内容可变）

t=() # 空的tuple
t=(1,2) # 两个元素
t=(1,)  # 一个元素

注意：在定义只有一个元素的tuple时元素后必须加一个逗号，用以与小括号区分

t = ('a', 'b', ['A', 'B'])
t[2][0] = 'X'
t[2][1] = 'Y'
输出t：('a', 'b', ['X', 'Y'])   # list中的可变

字典

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。

键(key)必须使用不可变类型。dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key。

在同一个字典中，键(key)必须是唯一的。一个key只能对应一个value。

person1 = {}
person1['first'] = 'Tom'
person1['last'] = 'Andy'

person2 = {'first':'Susan','last':'Anna'}

print(person1)
print(person2)

people = [person1,person2]
print(people)
people.append({'first':'Bill','last':'Gates'}) # 增加信息
print(people)

presenters = people[0:2]
print(presenters)
print(len(presenters))

# 输出结果：
{'first': 'Tom', 'last': 'Andy'}
{'first': 'Susan', 'last': 'Anna'}
[{'first': 'Tom', 'last': 'Andy'}, {'first': 'Susan', 'last': 'Anna'}]
[{'first': 'Tom', 'last': 'Andy'}, {'first': 'Susan', 'last': 'Anna'}, {'first': 'Bill', 'last': 'Gates'}]
[{'first': 'Tom', 'last': 'Andy'}, {'first': 'Susan', 'last': 'Anna'}]
2

列表可以存储各种数据类型，包括字典。

使用key取值时，如果key不存在，就会报错。1）可以用in判断key是否存在，2）也可以使用get()方法，如果不存在可以返回None（交互环境不显示结果。）或自己指定的value。

person1 = {}
person1['first'] = 'Tom'
person1['last'] = 'Andy'
person1.get('Teddy',-1)
输出：-1

peron1.pop('first')   # 删除key，对应的value也会被删除

和list比较，dict：查找和插入的速度极快，不会随着key的增加而变慢；需要占用大量的内存，内存浪费多。
而list相反：查找和插入的时间随着元素的增加而增加；占用空间小，浪费内存很少。
【dict：用空间换取时间】

集合

set() 无序，不重复

s = set([1,1,2,3,4])
输出s：{1,2,3,4}
s.add(5)  # 添加元素
输出s：{1,2,3,4,5}
s.remove(4)
输出s：{1,2,3,5}

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

a = [0,1,2,3,4]
b = [0,2,6]
list(set(a) & set(b))   # 使用  "&"  运算求a与b的交集，输出：[0, 2]
list(set(a) | set(b))   # 使用  "|"  运算求a与b的并集，输出：[0, 1, 2, 3, 4, 6]
list(set(b) - set(a))   # 使用  "-"  运算求a与b的差(补)集： 求b中有而a中没有的元素，输出：[6]
list(set(a) - set(b))   # 使用  "-"  运算求a与b的差(补)集： 求a中有而b中没有的元素，输出：[1, 3, 4]
list(set(a) ^ set(b))   # 使用  "^"  运算求a与b的对称差集，输出：[1, 3, 4, 6]

a = [0,1,2,3,4]
b = [0,2,6]
list(set(a).intersection(set(b)))  # 使用 intersection 求a与b的交集，输出：[0, 2]
list(set(a).union(b))              # 使用 union 求a与b的并集，输出：[0, 1, 2, 3, 4, 6]
list(set(b).difference(set(a)))    # 使用 difference 求a与b的差(补)集：求b中有而a中没有的元素，输出： [6]
list(set(a).difference(set(b)))    # 使用 difference 求a与b的差(补)集：求a中有而b中没有的元素，输出：[1, 3, 4]
list(set(a).symmetric_difference(b))   # 使用 symmetric_difference 求a与b的对称差集，输出：[1, 3, 4, 6]

10. 循环

for循环

names = ['Amy','Bob']
for name in names:
	print(name)

while循环

names = ['Amy','Bob']
idx = 0
while idx < len(names):
	print(names[idx])
	idx = idx + 1

for name in ['Amy','Bob']:
	print(name)

for index in range(0,3):
	print(index)

names = ['Amy','Bob']
idx = 0
while idx < len(names):
	print(names[idx])
	idx = idx + 1

# 输出结果：
Amy
Bob
0
1
2
Amy
Bob

break和continue

break：满足条件时结束当前循环
continue：跳过本次循环，开始下一循环

n = 1
while n <= 100:
    if n > 10: # 当n = 11时，条件满足，执行break语句
        break # break语句会结束当前循环
    print(n)
    n = n + 1
print('END')

输出：
1
2
3
4
5
6
7
8
9
10
END

n = 0
while n < 10:
    n = n + 1
    if n % 2 == 0: # 如果n是偶数，执行continue语句
        continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行
    print(n)

输出：
1
3
5
7
9

这两个语句通常都必须配合if语句使用。

要特别注意，不要滥用break和continue语句。break和continue会造成代码执行逻辑分叉过多，容易出错。大多数循环并不需要用到break和continue语句，上面的两个例子，都可以通过改写循环条件或者修改循环逻辑，去掉break和continue语句。

11. 函数

函数可以同时返回多个值，但其实就是一个tuple。

# 获取姓名首字母
def get_initial(name):
	initial = name[0:1]
	return initial

first_name = input('Enter your first name: ')
last_name = input('Enter your last name: ')

print("Your initials are: " + get_initial(first_name) + get_initial(last_name))

函数参数

如果函数的参数过多，建议使用命名表示法，而不是位置表示法，使得代码更易读。

参考

默认参数

使用默认参数能降低调用函数的难度。，但是设置默认参数时，要注意
一是必选参数在前，默认参数在后；
二是如何设置默认参数，当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面，变化小的参数就可以作为默认参数。
但默认参数必须指向不变对象！

可变参数

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum
    
nums = [1, 2, 3]
calc(*nums)

calc(1, 3, 5, 7)

*nums表示把nums这个list的所有元素作为可变参数传进去。

定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数。

关键字参数

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

>>> person('Michael', 30)
name: Michael age: 30 other: {}
>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

关键字参数有什么用？它可以扩展函数的功能。比如，在person函数里，我们保证能接收到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数。至于到底传入了哪些，就需要在函数内部通过kw检查：

# 检查是否有city和job参数
def person(name, age, **kw):
    if 'city' in kw:
        # 有city参数
        pass
    if 'job' in kw:
        # 有job参数
        pass
    print('name:', name, 'age:', age, 'other:', kw)

命名关键字参数

如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：

def person(name, age, *, city, job):
    print(name, age, city, job)

和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错。

命名关键字参数可以有缺省值，从而简化调用：

def person(name, age, *, city='Beijing', job):
    print(name, age, city, job)

>>> person('Jack', 24, job='Engineer')
Jack 24 Beijing Engineer
# 由于命名关键字参数city具有默认值，调用时，可不传入city参数

参数组合

在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这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)

>>> f1(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> f1(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> f1(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> f1(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
>>> f2(1, 2, d=99, ext=None)
a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}

虽然可以组合多达5种参数，但不要同时使用太多的组合，否则函数接口的可理解性很差。

总结

Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。

默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！

要注意定义可变参数和关键字参数的语法：
*args是可变参数，args接收的是一个tuple；
**kw是关键字参数，kw接收的是一个dict。
以及调用函数时如何传入可变参数和关键字参数的语法：
可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过*args传入：func(*(1, 2, 3))；
关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过**kw传入：func(**{'a': 1, 'b': 2})。

使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。

命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。

定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数。

12. 模块和包

Module：有很多函数、类、组建的python文件
packages：已发布的模块集合
完整包序列：python packages index

引入模块

# 使用 import 语句来引入模块
import module1[, module2[,... moduleN]]

# 使用 from 语句可以从模块中导入一个指定的部分到当前命名空间中
from modname import name1[, name2[, ... nameN]]

# 把一个模块的所有内容全都导入到当前的命名空间
from modname import *

dir() 函数一个排好序的字符串列表，内容是一个模块里定义过的名字。

返回的列表容纳了在一个模块里定义的所有模块，变量和函数。

举个例子：

# helpers.py
def display(message,is_warning = False):
	if is_warning:
		print("This is a warning")
	print(message)

# 引用1
import helpers
helpers.display('Sample message',True)

# 输出结果：
This is a warning
Sample message


# 引用2
from helpers import display
display('Sample message')

# 输出结果：
Sample message

安装包

pip install package_name

13. 虚拟环境

# 创建虚拟环境

# Install virtual environment
pip install virtualenv

# Windows system
python -m venv <folder_name> # -m 表示选取特定的模块

# OSX/Linux (bash)
virtualenv <folder_name>
# or
python3 -m venv # 不用安装virtualenv

因为anaconda配好环境了~ 具体内容就省略了kk

14. 调用API

将自己编写的函数放到Web Service上，别人可以 通过地址访问应用。

get 查询字符串，长地址，特殊字符需要转义，数据受限
post 可以在查询字符串中传入值，也可以传输消息主体包括特殊字符、文件等。

要好好看API说明哦

# This code will show you how to call the Computer Vision API from Python
# You can find documentation on the Computer Vision Analyze Image method here
# https://westus.dev.cognitive.microsoft.com/docs/services/5adf991815e1060e6355ad44/operations/56f91f2e778daf14a499e1fa

# Use the requests library to simplify making a REST API call from Python 
import requests

# We will need the json library to read the data passed back by the web service
import json

# You need to update the SUBSCRIPTION_KEY to they key for your Computer Vision Service
SUBSCRIPTION_KEY = "xxxxxxxxxxxxxxxxxxxxxxxxxxx"

# You need to update the vision_service_address to the address of your Computer Vision Service
vision_service_address = "https://canadacentral.api.cognitive.microsoft.com/vision/v2.0/"

# Add the name of the function you want to call to the address
address = vision_service_address + "analyze"

# According to the documentation for the analyze image function 
# There are three optional parameters: language, details & visualFeatures
parameters  = {'visualFeatures':'Description,Color',
               'language':'en'}

# Open the image file to get a file object containing the image to analyze
image_path = "./TestImages/PolarBear.jpg"
image_data = open(image_path, "rb").read()

# According to the documentation for the analyze image function
# we need to specify the subscription key and the content type in the HTTP header. 
# Content-Type is application/octet-stream when you pass in a image directly
headers    = {'Content-Type': 'application/octet-stream',
              'Ocp-Apim-Subscription-Key': SUBSCRIPTION_KEY}

# According to the documentation for the analyze image function
# we use HTTP POST to call this function
response = requests.post(address, headers=headers, params=parameters, data=image_data)

# Raise an exception if the call returns an error code
response.raise_for_status()

# Display the JSON results returned
results = response.json()
print(json.dumps(results))

15. JSON

很多API返回的是JSON数据

JSON的三种结构

键值对
键与子键
键与列表

读取JSON

创建JSON

# 引入json
import json

# 1. 键值对
# 创建字典
person_dict = {'first':'Meng','last':'Yuan'}
# 增加一个键值对
person_dict['city'] = 'Jinan'
# 将字典转换成JSON
person_dict = json.dumps(person_dict)

print(person_dict)

# 输出结果：
{"first": "Meng", "last": "Yuan", "city": "Jinan"}

# 引入json
import json

# 2. 键和子键
# 创建一个字典
person_dict = {'first':'Meng','last':'Yuan'}
# 增加一个键值对
person_dict['city'] = 'Jinan'

# 创建一个新的字典
student_dict = {}
student_dict['student'] = person_dict
# 将字典转换成JSON
student_dict = json.dumps(student_dict)

print(student_dict)

# 输出结果：
{"student": {"first": "Meng", "last": "Yuan", "city": "Jinan"}}

# 引入json
import json

# 3. 键和列表
# 创建一个字典
person_dict = {'first':'Meng','last':'Yuan'}
# 增加一个键值对
person_dict['city'] = 'Jinan'

# 创建一个列表
languages_list = ['C','Python','Html']

# 将列表作为一个键添加到字典中
person_dict['languages_list'] = languages_list

# 将字典转换成JSON
person_dict = json.dumps(person_dict)

print(person_dict)

# 输出结果：
{"first": "Meng", "last": "Yuan", "city": "Jinan", "languages_list": ["C", "Python", "Html"]}

要点

1. 多用print语句debug
2. 用JSON Linter美化json语句使其易读
3. 粘贴JSON输出理清其结构

16. 环境变量

用dotenv管理环境变量

17. 装饰器

def  logger(func):
	def wrapper():
		print("Logging execution")
		func()
		print("Done logging")
	return wrapper

@logger
def sample():
	print("--Inside sample function")

sample()

# 输出结果：
Logging execution
--Inside sample function
Done logging

通常在框架中使用装饰器

18. 生成器

在Python中，这种一边循环一边计算的机制，称为生成器：generator。

要创建一个generator，有很多种方法。
第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值。generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。当然，上面这种不断调用next(g)实在是太变态了，正确的方法是使用for循环，因为generator也是可迭代对象：

>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)
... 
0
1
4
9
16
25
36
49
64
81

著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：
1, 1, 2, 3, 5, 8, 13, 21, 34, …
斐波拉契数列用列表生成式写不出来，但是，用函数把它打印出来却很容易：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

要把fib函数变成generator函数，只需要把print(b)改为yield b就可以了：

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关键字，那么这个函数就不再是一个普通函数，而是一个generator函数，调用一个generator函数将返回一个generator。

generator函数和普通函数的执行流程不一样。普通函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

19. 迭代器