变量

变量命名规则

1. 只能包含数字、字母、下划线
2. 不能以数字开头
3. 不能使用python关键字或保留字(如print)
4. 应具有一定描述性含义
5. 谨慎使用小写l和大写O, 容易与数字1和0混淆
6. 可使用驼峰命名法StudentName, 或下划线

基本数据类型

字符串

1. 用法：

• 单引号或双引号连接

2. 字符串常用方法

• a.title()
• a.upper()
• a.lower()
• a.strip() a.lstrip() a.strip()

3. 字符串拼接

• 字符串a + 字符串b

4. 常用转义字符

• /n : 换行符
• /t : 制表符

数字

1. 整数int

• 计算
  • 加
  • 减
  • 乘
  • 除
  • 幂运算：2**3
  • 整除：10//3
  • 取余数：10%3

2. 浮点数float

列表

1. 列表的定义：

​ 列表由一系列按特定排列的元组成。用方括号[]标示列表。

1

bicycles = ['trek', 'cannondale', 'redline', 'specialized']

2. 列表的增删改查

• 查

  • 通过索引访问

    1 2	bicycles[0] #访问列表第一个元素 bicycles[-1] # 访问列表最后一个元素

• 改

  • 通过索引覆盖修改

    1 2 3 4

    motorcycles = ['honda', 'yamaha', 'suzuki'] print(motorcycles) motorcycles[0] = 'ducati' print(motorcycles)

• 增

  • 列表末尾追加元素

    • a.append(object)

    1 2 3 4 5 6 7 8 9 10 11 12

    # 已有列表末尾增加元素 motorcycles = ['honda', 'yamaha', 'suzuki'] print(motorcycles) motorcycles.append('ducati') print(motorcycles) # 可用于动态创建列表 motorcycles = [] motorcycles.append('honda') motorcycles.append('yamaha') motorcycles.append('suzuki') print(motorcycles)

  • 列表中插入元素

    • a.insert(index, object)

    1 2 3 4 5

    # 根据索引向列表中插入元素 motorcycles = ['honda', 'yamaha', 'suzuki'] print(motorcycles) motorcycles.insert(0, 'ducati') print(motorcycles)

• 删

  • 根据索引删除元素

    • del a[index]

  • 返回值为删除的元素。 默认删除最后一个。

    • a.pop(index)

    1 2 3 4 5 6

    # 删除列表末尾元素，返回值为删除的元素 motorcycles = ['honda', 'yamaha', 'suzuki'] print(motorcycles) popped_motorcycle = motorcycles.pop() print(motorcycles) print(popped_motorcycle)

  • 根据值删除元素

    • a.remove(object) 只删除第一个指定的值，如果有多个相同值在列表中需要循环删除

数据类型转换

字符串-数字转换：

python2与python3区别

1. print函数用法不同

• python2: print “hello world”
• python3: print(“hello world”)

2. 整数相除计算结果不同

• python2: 3/2 result: 1
• python3: 3/2 result: 1.5

3.

注释

• 编写目的：阐述代码要实现的功能以及如何实现。
• 注释原则：清晰，简洁。
• 注释用#号标识

python之禅

The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one– and preferably only one –obvious way to do it.
Although that way may not be obvious at first unless you’re Dutch.
Now is better than never.
Although never is often better than right now.
If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea – let’s do more of those!

写下标题的时候，下意识的打成了“2018”。就好像2019已经过去4个月，可自己好像还没有意识过来一样。

这个五一过的挺没意思的，由于老婆3号一大早公司出游，硬生生吧五一假分成了2个2天。前两天陪着她准备，收拾家里；后两天一个人在家也无所事事，重温了一遍红警，开启了权游刷剧（从第一季开始），唯一算的上对自己有提高的就是昨天早上健身了。

仔细想来，觉得自己现阶段性格里最大的问题就是执行力差。每次预想的计划，总是因为各种借口最终未能完成，所以造成了一次又一次的挫败感。还是得加强这方面的锻炼。

python学习已经断断续续一年了，加上前面的零散上edx课学习，也算是入门了。最近想暂停看视频教程，多看看书，想学着类似培训课程中的手法，做思维导图、写博客，把已经学到的基础知识总结下来，温故而知新。之后的阶段就开始实际练习了。

自己的公司任务的话，首先保质保量完成，希望五月加班工作少一点，一些进阶学习考虑在公司完成。

另外一个新想法：想做一个app，暂定名字叫做three,大概就是定三件事，每天类似github一样打卡记录，每天都有三个格子，根据完成的自我评价选择百分比，未完成就没有颜色，完成度越高颜色越深。这样便于自我鼓励。

1. 主要内容

- 迭代器

- 生成器

2. 迭代器

- 可迭代协议：

• 只要含有双下划线iter方法的都是可迭代的
• 可以被for循环的都是可迭代的，for循环其实就是在使用迭代器

- 迭代器协议：

• 内部含有__iter__和__next__方法的就是迭代器
• 只要是迭代器，就一定可以迭代
• 可迭代的.__iter__()方法就可以得到一个迭代器
• 迭代器中的.__next__()方法可以一个一个的获取值
• 惰性运算

- 迭代器的好处

• 从容器类型中一个一个的获取值
• 节省内存空间（需要时才会执行，每次__next__()生成一个值）

- 判断可迭代和迭代器的一种方法

1
2
3
4
5
6
7
8
9
10
11
12

from collections import Iterable
from collections import Iterator
# print(isinstance([],Iterator))
# print(isinstance([],Iterable))

# class A:
#     # def __iter__(self):pass
#     def __next__(self):pass
#
# a = A()
# print(isinstance(a,Iterator))
# print(isinstance(a,Iterable))

3. 生成器

- 生成器的本质：迭代器

- 生成器的表现形式：

• 生成器函数
• 生成器表达式

- 生成器函数：

• 只要含有yield关键字的函数都是生成器函数
• yield不能和return共用，且需要写在函数内部
• 调用生成器函数会得到一个生成器

- 生成器运行方式：

• 通过__next__执行
• 通过for循环执行
• 数据类型强制转换
• 通过send执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

def generator():
    print(1)
    yield 'a'
    print(2)
    yield 'b'
# 生成器函数：执行之后会得到一个生成器作为返回值
g = generator()

# __next__方法运行生成器
ret = g.__next__()
print(ret)
ret = g.__next__()
print(ret)
# for 循环方法运行生成器
g = generator()
for i in g:
	print(i)
# 数据类型强行转换
g = generator()
print(list(g))

- send的使用方法：

• 利用send执行的过程中，可以给上一个yield的地方传值
• 第一次使用生成器的时候，利用next获取下一个值
• 最后一个yield不能接收外部的值

1
2
3
4
5
6
7
8
9
10
11
12

def generator():
    print(123)
    content = yield 1
    print('======', content)
    print(456)
    yield 2

g = generator()  #得到生成器
ret = g.__next__()  # 执行到第一个yield，打印123，返回1
print('****', ret)  # 打印**** 1
ret = g.send('hello')  # 传值给content, 执行到第二个yield,打印456， 返回2
print('****',ret)  # 打印**** 2

- 生成器表达式：

• 列表推导式—返回列表

  1 2 3 4 5 6 7 8 9 10

  egg_list = ['egg%s' % (i*i) for i in range(10)] print(egg_list) ret = [i*i for i in range(30) if i%3 == 0] print(ret) #根据条件筛选查找嵌套列表并返回 names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'], ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']] ret = [j for i in names for j in i if j.count('e') == 2] print(ret)

• 字典推导式

  1 2 3 4 5 6 7 8

  #字典key,value对调 mcase = {'a': 10, 'b': 34} ret = {mcase[i]:i for i in mcase.keys()} print(ret) # 例二：合并大小写对应的value值，将k统一成小写 mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3} ret = {k.lower():(mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0))for k in mcase.keys()} print(ret)

• 集合推导式

  1 2 3

  # 计算列表中每个值的平方，自带去重功能 squared = {x**2 for x in [1, -1, 2]} print(squared)

• 生成器表达式—返回生成器

  1 2 3

  g = ('egg%s' % (i*i) for i in range(10)) for i in g: print(i)

4. 例题

- 利用生成器监听文件输入

利用生成器的yield特性，不需要一次返回所有的值，只是将功能提供给用户，用户需要时进行循环输出或选择性输出。

1
2
3
4
5
6
7
8
9
10
11

def tail(filename):
    f = open(filename,encoding='utf-8')
    while True:
        line = f.readline()
        if line.strip():
            yield line.strip()

g = tail('file')
for i in g:
    if 'python' in i:
        print('***',i)

- 获取移动平均值

• 利用yield和send配合
• 第一步的生成器__next__初始化通过装饰器来预激活

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

def init(func):
    def inner(*args, **kwargs):
        g = func(*args, **kwargs)
        g.__next__()
        return g
    return inner

@init
def average():
    sum = 0
    count = 0
    avg = 0
    while True:
        num = yield avg
        sum += num
        count += 1
        avg = sum/count


avg_g = average()
avg1 = avg_g.send(10)
print(avg1)

4. 练习题

1
2
3
4
5
6
7
8
9
10
11

# 练习题：
lst = ['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe']
# 例1:  过滤掉长度小于3的字符串列表，并将剩下的转换成大写字母
new_lst = [i.upper() for i in lst if len(i)>=3]
print(new_lst)
# 例2:  求(x,y)其中x是0-5之间的偶数，y是0-5之间的奇数组成的元祖列表
lst = [(i, j) for i in range(0,5,2) for j in range(1,6,2)]
print(lst)
# 例3:  求M中3,6,9组成的列表M = [[1,2,3],[4,5,6],[7,8,9]]
M = [[1,2,3],[4,5,6],[7,8,9]]
print([row[2] for row in M])

1. 主要内容

- args和*args的区别

- 装饰器进阶

• functools wraps
• 带参数的装饰器
• 多个装饰器装饰同一个参数

2. args和*args的区别

1
2
3
4
5
6
7
8
9

def outer(*args):
    print(args)   # (1, 2, 3, 4)元组形式
    print(*args)   # 打散 1, 2, 3, 4

    def inner(*args):
        print('inner: ', args)    # inner:  (1, 2, 3, 4)
    inner(*args)        # inner(1,2,3,4)
 
outer(1, 2, 3, 4)

3. functools wraps

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

from functools import wraps


def wrapper(func):
    @wraps(func)   # warps 带参数的装饰器，
    def inner(*args, **kwargs):
        print('在被装饰的函数执行之前做的事')
        ret = func(*args, **kwargs)
        print('在被装饰的函数执行之后做的事')
        return ret
    return inner

@wrapper   # holiday = wrapper(holiday)
def holiday(day):
    '''这是一个放假通知'''
    print('全体放假%s天' % day)
    return '好开心'

print(holiday.__name__)
print(holiday.__doc__)   #打印函数注释文档，如果没有wraps,打印的是wrapper的注释，因此会返回None
ret = holiday(3)
print(ret)

4. 带参数的装饰器

如果有很多函数都装载了装饰器，想要取消需要一个一个的停掉，这样很麻烦。因此可以用带参数的装饰器，设置flag来解决

无参数的装饰器：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

import time


def timmer(func):
    def inner(*args, **kwargs):
        start = time.time()
        ret = func(*args, **kwargs)
        end = time.time()
        print(end - start)
        return ret
    return inner


@timmer
def wahaha():
    time.sleep(0.1)
    print('wahhhh')

@timmer
def erguotou():
    time.sleep(0.1)
    print('erguotou')

带参数的装饰器
（在装饰器函数外面又套了一个函数，利用闭包原理用外层函数向内部传递参数）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

import time

flag = False


def timmer_out(flag):

    def timmer(func):

        def inner(*args, **kwargs):
            if flag:
                start = time.time()
                ret = func(*args, **kwargs)
                end = time.time()
                print(end - start)
                return ret
            else:
                ret = func(*args, **kwargs)
                return ret
        return inner
    return timmer

# timmer = timmer_out(flag)
# @timmer
@timmer_out(flag)
def wahaha():
    time.sleep(0.1)
    print('wahhhh')

@timmer_out(flag)
def erguotou():
    time.sleep(0.1)
    print('erguotou')

wahaha()
erguotou()

5. 多个装饰器装饰同一个函数

由于装饰器会寻找最接近的函数，因此出现“外侧套内侧的现象”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

# 多个装饰器装饰一个函数
def wrapper1(func):
    def inner1():
        print('wrapper1, before func')
        func()
        print('wrapper1, after func')
    return inner1


def wrapper2(func):
    def inner2():
        print('wrapper2, before func')
        func()
        print('wrapper2, after func')
    return inner2


@wrapper2    # f = wrapper2(f)--------->wrapper2(inner1)-----> inner2
@wrapper1    # f = wrapper1(f)  === inner1
def f():
    print('in f')


f()     # inner2()


'''
wrapper2, before func
wrapper1, before func
in f
wrapper1, after func
wrapper2, after func
'''

命令执行顺序如下：

写在前面：
这篇日记记录一下我们泰国之行难忘的agoda酒店“不可取消”订单风波。
从错误下单支付，到不停地去沟通联系，到绝望，又到希望。。。
感觉这也是我们蜜月之行的一段惊险有趣的记忆。同时也希望有一天能够帮到有类似情况的人。

下周要跟老婆去泰国玩，在agoda上预定了丽贝岛的mountain resort酒店，酒店订单是“不可取消”的。预定的时候俩人没仔细看日期，错误的选择了下个月的相同日期，而且下订单的时候我也光顾着聊天没有仔细检查。结果提交都付费了才发现了问题。

1. 当天采取的办法：

发现自己每次遇到问题，第一反应就是慌+烦躁，这点真的要慢慢改掉。
冷静下来之后，我们当天晚上采取了如下办法：

• 1.立即与agoda电话客服沟通（10min内），告知订单预定填写有误，希望能够修改时间。

  结果：agoda当时电话联系酒店，由于时间太晚未接通（半夜22:00多），说第二天有结果再通知我。

• 2.老婆写英文邮件给酒店，直接联系酒店，告诉日期填错，恳求可以帮忙修改日期。

  结果：发过去后，酒店一直未回复。（感觉东南亚的普通酒店邮件联系好像很难得到回复。）

• 3.查询网上类似情况，都说要多和agoda以及酒店沟通，之前还有一个沟通模板，核心思想就是说agoda的一些政策不合理，以此来说明这个订单不合规定。但是好像网站的内容已经有些变化，模板不再适用。

第一天的感觉就是慌+无穷的后悔+难过，关键时刻不操心真的是后悔莫及。当时觉得最坏的打算就是酒店的钱打水漂了。

2. D2-D4进展缓慢

• 之后的2天，每天上午下午各一通电话，询问agoda客服的进展情况。

  结果：agoda客服每次打电话时都会再次联系酒店，酒店一直推脱说经理不在，让第二天再打，最后第四天后面直接说经理辞职了，没人能做决定，明显是一副推脱的态度。

3. D5情况波折：

• 第5天早上再次催agoda联系酒店，这次接电话的是一个台湾腔小妹，她首先直接电话过去，然后告诉我依然是说经理不在。但客服说帮忙联系在泰国的同事用泰语和酒店沟通，这样方便一些。

  结果：20分钟后agoda客服回复，用泰语沟通，酒店不同意更改日期。这也就算了，这个客服一副无所谓的样子，说我可以把行程改到下个月再过去，或者转给朋友亲戚，让他们下个月再去一趟。。。WTF。。。真的很想投诉这个客服的态度

• 忍着气求客服再让泰国同事跟酒店沟通一次，说我这边可以接受调整房型，或者额外补偿一定的费用（贵一点总比浪费好啊）。

  结果：客服电话没联系上我，邮件回复说酒店不同意更改。。。当时觉得没戏了。

失望之后决定做最后的挣扎：

• 想办法找懂泰语的帮忙沟通：
  • 淘宝上找泰语向导、泰语服务等关键词，联系旅行社、个人等；
  • 跟预定丽贝岛车船联运的卖家联系，希望能够帮忙解决。

    结果：淘宝上泰语向导都还挺贵，而且都是不管联系成功与否都要收相同费用；跟打交道的卖家联系，卖家也不是很情愿，毕竟酒店不是在人家那边定的。这个方法破灭。

• 再次通过agoda网站内的“联系酒店”功能，发了一封英文邮件给酒店，恳请体谅帮忙更改：

  结果：直到问题解决依然没有收到这封邮件的回复，这封邮件到底起没起作用我也不得而知。

• 在无法解决的情况下尽量止损：
  • 1.利用agoda的“最优惠价格保证(BRG)”功能，发现错误预定的那个时间段内，携程的酒店定价要便宜200多。。。本着尽量止损的原则，联系agoda，按要求提交价格保证申请表格，这样最起码能退回200多。
  • 2.agoda客服的话让我灵机一动，发现穷游网等网站上有转让模块，于是发布酒店转让（写的5折转让，但当时如果有人联系我砍价我肯定也会同意。。。），希望有人联系我。
  • 3.因为两人的预算确实没多少，还有一个止损策略就是后面预订更便宜的酒店，就当花了大钱住了更差的地方。当天看了大约3家接近青年旅社层次的酒店，默默的收藏了，准备第二天实在不行就预订，心理其实对老婆很愧疚。

    结果：第1个价格保护应该是没问题能返还的，但是后面agoda也没提这个问题。第2个酒店转让可能是因为去的地方太冷门了，一时半会没人联系我。

3. D6凌晨——大结局：

就在希望渺茫，已经计划怎样止损的时候，半夜突然收到agoda的邮件，说酒店回复他们同意更改日期！而且不做价格调整直接原价更改！让我尽快联系agoda确认半夜我直接从床上跳了起来。。。打电话给agoda客服，说确认更改。

大约10min后，刷新订单页面，日期已经改回正确的日子了！

4. 小结

这场agoda酒店“不可取消”订单风波最终还是以喜剧收尾。反思这次事件，有以下几点收获：

- 1.越是关键时刻，越要小心重复确认。。。特别是和钱有关的时候=。=
- 2.这次毫无疑问，归根到底是我们自己的问题。agoda客服帮了很多忙，但毕竟不是自己的事情，客服也不会特别主动地帮你。这时候还是得多积极主动地去跟客服联系，适当的催促他们。
- 3.遇到问题，悲伤、生气、烦躁不能解决任何问题，一定要尽快冷静。
- 4.不要轻易放弃，要想尽各种办法去争取。 直到最后我们也不知道到底为什么酒店的态度180度大转弯。也许是agoda一次又一次的电话，也许是我们“声泪俱下”的两封邮件，也许是酒店经理突然又回来了。。不管怎么样，这次真的是学到不能轻易放弃，多去想办法，也许歪打正着了也不一定呢。