1
2
3
4
5
6
7
8

attrs = [1,['piglei',100]]

user_id,(username,score) = attrs

>> user_id
1
>> username
'piglei'

1
2
3
4
5
6
7
8
9

data = ['piglei', 'apple', 'orange', 'banana', 100]
username,*fruits,score = data
>>username
'piglei'

>>fruits
['apple','orange','banana']
>>score
100

1
2
3
4
5

# 动态解包
>> username,*fruits,score = data
# 切片赋值
>> username,fruits,score = data[0],data[1:-1],data[-1]
# 两种完全等价

1
2
3
4

for username,score in [('piglei',100),('raymonmd',60)]:
    print(username)
>>glei
>>ymond

1
2
3
4
5

# 忽略展开时的第二个变量
author,_ = usernames

# 忽略第一个和最后一个变量之间的所有变量
username,*_,score = data

1
2
3
4

>>> 'foo'.upper()
'FOO'
>>> print(_)
FOO

1
2
3
4
5
6

def remove_invalid(items):
    """剔除items里面无效的元素

    :param items:待剔除对象
    :type items:包含整数的列表,[int,...]
    """

1
2
3
4

from typing import List

def remove_invalid(items:List[int]):
    """剔除items里无效的元素"""

1
2

from django.utils.translation import gettext as _
print(_('待翻译文字'))

1
2
3
4
5
6
7

class Person:
    """人

    :param name:姓名
    :param age:年龄
    :param favorite_color:最喜欢的颜色
    """

1
2
3
4
5
6
7
8
9

def resize_image(image,size):
    """将图片缩放到指定尺寸，并返回新的图片
    
    注意：当⽂件超过 5MB 时，请使⽤ resize_big_image(

    :param image:图片文件对象
    :param size:包含宽高的元组:(width,height)
    :return:新图片对象
    """

 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

def magic_bubble_sort(numbers:List[int]):
    """有魔力的冒泡排序算法，默认所有的偶数都比奇数大

    :param numbers:需要排序的列表，函数会直接修改原始列表
    """

    stop_position = len(numbers) - 1
    while stop_position > 0:
        for i in range(stop_position):
            cuurent,next_ = numbers[i],number[i+1]
            current_is_even,next_is_even = current % 2 == 0,next_ % 2 == 0
            should_swap = False
            # 交换位置的两个条件
            # - 前面是偶数，后面是奇数
            
        # - 前面和后面同为奇数或者偶数，但是前面比后面大
        if current_is_even and not next_is_even:
            should_swap = True
        elif current_is_even == next_is_even and current > next_:
            should_swap = True
        
        if should_swap:
            numbers[i],numbers[i+1] = numbers[i+1],numbers[i]
        
        stop_position -= 1

    return numbers

1
2
3
4

# 为所有性别为⼥或者级别⼤于 3 的活跃⽤⼾发放 10 000 个⾦币
if user.is_active and (user.sex == 'female' or user.level > 3):
    user.add_coins(10000)
    return

1
2
3
4
5
6

# 为所有性别为⼥或者级别⼤于 3 的活跃⽤⼾发放 10 000 个⾦币
user_is_eligible = user.is_active and (user.sex == 'female' or user.level > 3)

if user_is_eligible:
    user.add_coins(10000)
    return

 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

class ImportedSummary:
    """保存导入结果摘要的数据类"""
    
    def __init__(self):
        self.succeeded_count = 0
        self.failed_count = 0

class ImportingUserGroup:
    """用于暂存用户导入处理的数据类"""

    def __init__(self):
        self.duplicated = []
        self.banned = []
        self.normal = []

def import_users_from_file(fp):
    """尝试从文件对象读取用户，然后导入数据库

    :param fp:可读文件对象
    :return: 成功与失败的数量
    """
    importing_user_group = ImportingUserGroup()
    for line in fp:
        parsed_user = parse_user(line)
        # …… 进⾏判断处理，修改上⾯定义的 importing_user_group 变量

    summary = ImportedSummary()
    #  …… 读取 importing_user_group，写⼊数据库并修改成功与失败的数量

    return summary.succeeded_count,summary.failed_count

1
2
3
4
5

def get_best_trip_by_user_id(user_id):
    return {
        'user': get_user(user_id),
        'trip': get_best_trip(user_id)
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

def render_trip_page(request,user_id,trip_id):
    """渲染旅程页面"""
    user = User.objects.get(id=user_id)
    trip = get_object_or_404(Trip,pk=trip_id)
    is_suggested = check_if_suggested(user,trip)
    return render(request,'trip.html',{
        'user':user,
        'trip':trip,
        'is_suggested':is_suggested
    })

1
2
3
4

def render_trip_page(request,user_id)
    # 利⽤ locals() 把当前所有变量作为模板渲染参数返回
    # 节约了三⾏代码，我简直是个天才！
    return render(request,'trip.html',locals())

1
2
3
4

from decimal import Decimal
# 这里的'0.1'和'0.2'必须是字符串
Decimal('0.1') + Decimal('0.2')
Decimal('0.3')

1
2

Decimal(0.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

int(True),int(False)
(1,0)
>> True + 1
2

# 把False当除数的效果和0一样
1/False

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

1
2
3
4
5
6

numbers = [1, 2, 4, 5, 7]
count = 0
for i in numbers:
    if i % 2 == 0:
        count += 1
print(count)

1

count = sum(i % 2 == 0 for i in numbers)

1
2
3
4
5
6

# 将 username 靠右对⻬，左侧补空格到⼀共 20 个字符
# 以下两种⽅式将输出同样的内容
print('{:>20}'.format(username))
print(f'{username:>20}')
# 输出：
#               piglei

1
2
3

print('{0}:name={0} score={1}'.format(username,score))
# 输出：
piglei: name=piglei score=100

1
2
3
4
5
6
7
8
9

words = ['Number(1-10):']
for i in range(10):
    words.append(f'Value:{i+1}')

print('\n'.join(words))
Number(1-10):
Value:1
...
Value:10

1
2
3
4
5
6
7

def extract_value(s):
    items = s.split(':')
    # 因为s不一定会包含':',所以需要对结果长度进行判断
    if len(items) == 2:
        return items[1]
    else:
        return ''

1
2
3
4

def extract_value_v2(s):
    # 当s包含分隔符 ： 时，元组最后一个成员刚好是value
    # 若是没有分隔符，最后一共成员默认时空字符串''
    return s.partition(':')[-1]

1
2
3
4
5

s = '明明是中文，却使用了英文标点.'

# 创建替换规则表：',' -> '，','.'->'。'
table = s.maketrans(',.','，。')
s.translate(table)

1
2
3
4
5
6
7

>>> 'Hello'.split('e')
['H', 'llo']
# str 不能使⽤ bytes 来调⽤任何内置⽅法，反之亦然
>>> 'Hello'.split(b'e')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: must be str or None, not bytes

1
2
3
4

# ⽤⼾每⽇奖励积分数量
DAILY_POINTS_REWARDS = 100
# VIP ⽤⼾每⽇额外奖励积分数量
VIP_EXTRA_POINTS = 20

1
2
3
4
5
6
7
8
9

from enum import Enum

# 在定义枚举类型时，如果同时继承⼀些基础类型，⽐如 int、str，
# 枚举类型就能同时充当该基础类型使⽤。⽐如在这⾥，UserType 就可以当作int 使⽤
class UserType(int,Enum):
    # VIP用户
    VIP = 3
    # 小黑屋用户
    BANNED = 13

1
2
3
4
5
6
7
8
9

def add_daily_points(user):
    """用户每天完成第一次登录后，为其增加积分"""
    if user.type == UserType.BANNED:
        return
    if user.type == UserType.VIP:
        user.points += DAILY_POINTS_REWARDS + VIP_EXTRA_POINTS
        return
    user.points += DAILY_POINTS_REWARDS
    return

 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

def fetch_users(
    conn,
    min_level=None,
    gender=None,
    has_membership=False,
    sort_field="created",
 ):
    """获取⽤⼾列表
    :param min_level: 要求的最低⽤⼾级别，默认为所有级别
    :type min_level: int, optional
    :param gender: 筛选⽤⼾性别，默认为所有性别
    :type gender: int, optional
    :param has_membership: 筛选会员或⾮会员⽤⼾，默认为 False，代表⾮会员
    :type has_membership: bool, optional
    :param sort_field: 排序字段，默认为 "created"，代表按⽤⼾创建⽇期排序
    :type sort_field: str, optional
    :return: ⼀个包含⽤⼾信息的列表：[(User ID, User Name), ...]
    """
    # ⼀种古⽼的 SQL 拼接技巧，使⽤“WHERE 1=1”来简化字符串拼接操作
    statement = "SELECT id, name FROM users WHERE 1=1"
    params = []
    if min_level is not None:
        statement += " AND level >= ?"
        params.append(min_level)
    if gender is not None:
        statement += " AND gender >= ?"
        params.append(gender)
    if has_membership:
        statement += " AND has_membership = true"
    else:
        statement += " AND has_membership = false"
    statement += " ORDER BY ?"
    params.append(sort_field)
    # 将查询参数 params 作为位置参数传递，避免 SQL 注⼊问题
    return list(conn.execute(statement, params))

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

def fetch_users_v2(
    conn,
    min_level=None,
    gender=None,
    has_membership=False,
    sort_field="created",
):
    """获取用户列表"""
    query = select([users.c.id,users.c.name])
    if mini_level != None:
        query = query.where(users.c.level >= min_level)
    if gender != None:
        query = query.where(users.c.gender == gender)
    query = query.where(users.c.has_membership == has_membership).order_by(
        users.c[sort_field]
    )
    return list(conn.execute(query))

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

def render_movies(username,movies):
    """
    以文本方式展开电源列表信息
    """
    welcome_test = 'Welcome,{}.\n'.format(username)
    text_parts = [welcome_text]
    for name,rating in movies:
        # 没有提供评分的电影，以[NOT RATED]代替
        rating_text = rating if rating else '[NOT RATED]'
        movie_item = '* {},Rating:{}'.format(name,rating_text)
        text_parts.append(movie_item)
    return '\n'.join(text_parts)

movies = [
    ('The Shawshank Redemption', '9.3'),
    ('The Prestige', '8.5'),
    ('Mulan', None),
]

print(render_movies('piglei',movies))

1
2
3
4
5
6
7

from jinja2 import Template

_MOVIES_TMPL = '''\
Welcome,{{ username }}.
{%for name,rating in movies %}
* {{ name }}, Rating: {{ rating|default("[NOT RATED]",True)}}
{%- endfor %}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

def add(x,y):
    return x+y

# 导⼊ dis 模块，使⽤它打印 add() 函数的字节码，也就是解释器如何理解 add() 函数
import dis
dis.dis(add)
2           0 LOAD_FAST                     0 (x)
            2 LOAD_FAST                     1 (y)
            4 BINARY_ADD
            6 RETURN_VALUE

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

def sort_users_inf(users):

    def key_func(username):
        age = users[username]
        # 当年龄为空时,返回正无穷大作为key，因此就会被排到最后
        return age if age is not None else float('inf')
    
    return sorted(users.keys(),key=key_func)

users = {"tom": 19, "jenny": 13, "jack": None, "andrew": 43}
print(sort_users_inf(users))
# 输出
['jenny', 'tom', 'andrew', 'jack']

1
2
3
4
5
6
7
8
9

from textwrap import dedent

def main():
    if user.is_active:
        message = dedent("""\
            Welcome,today's move list:
            - Jaw (1975)
            - The Shining (1980)
            - Saw (2004)""")

1
2
3
4
5

l = log_line.split()

# 因为UserqAgent里面有空格,所以切完后得把它们再连接起来
>>> " ".join(l[:-1]),l[-1]
('"AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.77 Safari/537.36"', '47632')

1
2
3

# 从右往左切割，None 表⽰以所有的空⽩字符串切割
>>> log_line.rsplit(None,maxsplit=1)
['"AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.77 Safari/537.36"', '47632']

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

# 定义⼀个⻓度为 100 的词汇列表
WORDS = ['Hello', 'string', 'performance', 'test'] * 25

def str_cat():
    """使用字符串拼接"""
    s = ''
    for word in WORDS:
        s += word
    return s

def str_join():
    """使用列表配合join产生字符串"""
    l = []
    for word in WORDS:
        l.append(word)
    return ''.join(l)

1
2
3
4
5
6
7
8

import timeit

# 默认执行100万次
cat_spent = timeit.timeit(setup='from __main__ import str_cat',stmt='str_cat()')
pirnt("cat_spent:",cat_spent)

join_spent = timeit.timeit(setup='from __main__ import str_join',stmt='str_join()')
print("join_spent",join_spent)

1
2
3
4
5
6
7
8
9

def get_rectangle():
    """返回长方形的宽和高"""
    width = 100
    height = 20
    return width,height

# 获取函数的多个返回值
result = get_rectangle()
print(result,type(result))

1
2
3

results = (n*100 for n in range(10) if n%2 == 0)
results
>>>  <generator object <genexpr> at 0x10e94e2e0>

1
2
3

result = tuple((n*100 for n in range(10) if n%2==0))
results
(0,200,400,600,800)

1
2
3

from collections import namedtuple

Rectangle = namedtuple('Rectangle','width,height')

1
2
3
4
5
6
7
8
9

>>> rect = Rectangle(100, 20) 
>>> rect = Rectangle(width=100, height=20)
>>> print(rect[0]) 
100
>>> print(rect.width) 
100
>>> rect.width += 1 
...
AttributeError: can't set attribute

1
2
3
4
5

class Rectangle(NamedTuple):
    width:int
    height:int

rect = Rectangle(100,20)

1
2

# 提供错误的类型来初始化
rect_wrong_type = Rectangle('string', 'not_a_number')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 第一种写法
if 'rating' in movie:
    rating = movie['rating']
else:
    rating = 0

# 第二种写法
try:
    rating = movie['rating']
except KeyError:
    rating = 0

1

movie.get('rating',0)

1
2
3
4
5
6
7

d = {'title':'foobar'}
d.setdefault('items',[]).append('foo')
d
{'title': 'foobar', 'items': ['foo']}
d.setdefault('items',[]).append('bar')
d
{'title': 'foobar', 'items': ['foo', 'bar']}

1
2
3

d1 = {'foo':3,'bar':4}
{key:value * 10 for key,value in d1.items() if key == 'foo'}
>>>{'foo',30}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from collections import OrderedDict
d = OrderedDict()
d['FIRST_KEY'] = 1
D['SECOND_KEY'] = 2

for key in d:
    print(key)

FIRST_KEY
SECOND_KEY

1
2
3

nums = [1,2,2,4,1]
{n for n in nums if n<3}
{1,2}

1
2

hash((1,2,3,['foo','bar']))
TypeError: unhashable type: 'list'

1
2
3
4
5
6

class Foo:
    pass

foo = Foo()
has(foo)
>>>  273594269

1
2
3
4
5
6
7

import copy
nums_copy = copy.copy(nums)
nums[2] = 30

# 修改不再相互影响
>>> nums, nums_copy
([1, 2, 30, 4], [1, 2, 3, 4])

1
2
3
4
5

d = {'foo':1}
d2 = {key:value for key,value in d.items()}
d['foo'] = 2
d,d2
({'foo': 2}, {'foo': 1})

1
2

d2 = dict(d.items())
nums_copy = list(nums)

1
2

#  nums_copy 会变成 nums 的浅拷⻉
nums_copy = nums[:]

1
2
3
4
5
6
7
8
9

# 列表有copy方法
num = [1,2,3,4]
nums.copy()
[1,2,3,4]

# 字典也有copy方法
d = {'foo':'bar'}
d.copy()
{'foo':'bar'}

1
2
3
4
5
6
7
8

>>> import copy
>>> items_copy = copy.copy(items)
>>> items[0] = 100 ❶
>>> items[1].append('xxx') ❷
>>> items
[100, ['foo', 'bar', 'xxx'], 2, 3]
>>> items_copy ❸
[1, ['foo', 'bar', 'xxx'], 2, 3]

 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
37
38
39
40
41
42
43
44
45
46
47

from enum import Enum

class PagePerfLevel(str,Enum):
    LT_100 = 'Less than 100ms'
    LT_300 = 'Between 100 and 300 ms'
    LT_1000 = 'Between 300 ms and 1s'
    GT_1000 = 'Greater than 1s'

def analyze_v1()
    path_groups = {}
    with open("logs.txt","r") as fp:
        for line in fp:
            path,time_costs_str = line.strip().split()
        
        # 根据页面耗时计算性能等级
        time_cost = int(time_cost_str)
        if time_cost < 100:
            level = PagePerfLevel.LT_100
        elif time_cost < 300:
            level = PagePerfLevel.LT_300
        elif time_cost < 1000:
            level = PagePerfLevel.LT_1000
        else:
            level = PagePerfLevel.GT_1000

        # 如果路径第一次出现，存入初始值
        if path not in path_groups:
            path_groups[path] = {}
        
        # 如果性能level第一次出现，存入初始值1
        try:
            path_groups[path][level] += 1
        except KeyError:
            path_groups[path][level] = 1

    for path,result in path_groups.iems():
        print(f'== Path:{path}')
        total = sum(result.values())
        print(f'    Total requests:{total}')
        print(f'    Performance')

        # 在输出结果前，按照“性能等级”在 PagePerfLevel ⾥⾯的顺序排列，⼩于 100 毫秒的在最前⾯
        sorted_items = sorted(
            result.items(),key=lambda pair:list(PagePerfLevel).index(pair[0])
        )
        for level_name,count in sorted_items:
            print(f'    - {level_name}:{count}')

 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
37
38
39
40
41

from collections.abc import MutableMapping

class PerfLevelDict(MutableMapping):
    """⽤于存储响应时间的⾃定义字典"""

    def __init__(self):
        self.data = defaultdict(int)

    def __getitem__(self,key):
        """当某个级别不存在时，默认返回0"""
        return self.data[self.compute_level(key)]

    def __setitem__(self,key,value):
        """将key转换为对应的性能等级，然后设置值"""
        self.data[self.compute_level(key)] = value

    def __delitem__(self,key):
        del self.data[key]

    def __iter__(self):
        return iter(self.data)

    def __len__(self):
        return len(self.data)
    
    @staticmethod
    def compute_level(timg_cost_str):
        """根据响应时间计算性能等级"""
        #  假如已经时性能等级，不做转换直接返回
        if time_cost_str in list(PagePerfLevel):
            return time_cost_str

        time_cost = int(time_cost_str):
        if time_cost < 100:
            return PagePerfLevel.LT_100
        elif time_cost < 300:
            return  PagePerfLevel.LT_300
        elif time_cost < 1000:
            return PagePerfLevel.LT_1000

        return PagePerfLevel.GT_1000

 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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

from enum import Enum
from collections import defaultdict
from collections.abc import MutableMapping

class PagePerfLevel(str,Enum):
    LT_100 = 'Less than 100 ms'
    LT_300 = 'Between 100 and 300 ms'
    LT_1000 = 'Between 300 ms and 1 s'
    GT_1000 = 'Greater than 1 s'

class PerfLevelDict(MutableMapping):
    """存储响应时间性能等级的字典"""
    def __init__(self):
        self.data = defaultdict(int)

    def __getitem__(self,key):
        """当某个性能等级不存在时，默认返回 0"""
        return self.data[self.compute_level(key)]

    def __delitem__(self,key):
        del self.data[key]

    def __iter__(self):
        return iter(self.data)

    def __len__(self):
        return len(self.data)

    def items(self):
        """按照顺序返回性能等级数据"""
        return sorted(
            self.data.items(),
            key = lambda pair:list(PagePerfLevel).index(pair[0]),
        )

    def total_request(self):
        """返回总请求数"""
        return sum(self.values())

    @staticmethod
    def compute_level(time_cost_str):
        """根据响应时间计算性能等级"""
        if time_cost_str in list(PagePerfLevel):
            return time_cost_str

        time_cost = int(time_cost_str)
        if time_cost < 100:
            return PagePerfLevel.LT_100
        elif time_cost < 300:
            return PagePerfLevel.LT_300
        elif time_cost < 1000:
            return PagePerfLevel.LT_1000
        return PagePerfLevel.GT_1000

def analyze_v2():
    path_groups = defaultdict(PerfLevelDict)
    with open("log.txt","r") as fp:
        for line in fp:
            path,time_cost = line.strip().split()
            path_groups[path][time_cost] += 1

    for path,result in path_groups.items():
        print(f'== Path: {path}')
        print(f'   Total requests: {result.total_requests()}')
        print(f'   Performance:')
        for level_name,count in result.items():
            print(f'    - {level_name}:{count}')

1
2
3
4
5
6
7
8

def generate_even(max_number):
    """一个简单生成器，返回 0 到 max_number 之间的所有偶数"""
    for i in range(0,max_number):
        if i % 2 == 0:
            yield i 
    
for i in generate_even(10):
    print(i)

1
2
3
4
5

i = generate_even(10)
next(i)
>> 0 
next(i)
>> 2

1
2

list(generate_even(10))
[0,2,4,6,8]

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

def batch_process(items):
    """
    批量处理多个items对象
    """
    # 初始化空结果列表
    results = []
    for item in items:
        # 处理 item，可能需要耗费⼤量时间……
        # processed_item = ...
        results.append(processed_item)
    # 将拼装后的结果列表返回
    return results

1
2
3
4

for processed_item in batch_process(items):
    # 如果某个已处理对象过期了，就中断当前的所有处理
    if processed_item.has_expired():
        break

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

from collections import deque

def deque_append(): 
    """不断往尾部追加"""
    l = deque()
    for i in range(5000):
        l.append(i)
    
def deque_appendleft():
    """不断往头部插入"""
    l = deque()
    for i in range(5000):
        l.appendleft(i)

1
2
3

from collections import OrderedDict
list(OrderedDict.fromkeys(nums).keys())
>>> [10,2,3,21]

1
2
3
4
5
6
7

def remove_even(numbers):
    """去掉列表里所有的偶数"""
    for number in numbers:
        if number %  2 == 0:
            numbers.remove(number)

>>> [1,7,8,11]

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

from typing import NamedTuple

class Address(NamedTuple):
    """地址信息结果"""
    country:str
    province:str
    city:str

def latlon_to_address(lat,lon):
    return Address(
        country=country,
        province=province,
        city=city,
    )

addr = latlon_to_address(lat,lon)
# 通过属性名来使用addr
addr.counrty/addr.province/addr.city

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

class UserCollection:
    """用于保存多个用户的集合工具类"""

    def __init__(self,users):
        self.items = users

    def __len__(self):
        return len(self.items)

users = UserCollection(['piglei','raymond'])

# 不再需要手动判断对象内部items的长度
if users:
    print("There's some users in collection!")

1
2
3
4
5
6
7
8

class ScoreJudger:
    """仅当分数大于60时为真"""

    def __init__(self,score):
        self.score = score

    def __bool__(self):
        return self.score >= 60

1
2
3
4
5
6
7

class EqualWithAnything:
    """与任何对象相等"""
    
    def __eq__(self,other):
        # ⽅法⾥的 other ⽅法代表 == 操作时右边的对象，⽐如
        # x == y 会调⽤ x 的 __eq__ ⽅法，other 的参数为 y
        return True

 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

class Movie:
    """电源对象数据类"""

    def __init__(slef,name,year,rating):
        self.name = name
        self.year = year
        self.rating = rating

    @property
    def rank(self):
        """按照评分对电影分级

        - S: 8.5 分及以上
        - A：8 ~ 8.5 分
        - B：7 ~ 8 分
        - C：6 ~ 7 分
        - D：6 分以下
        """
        rating_num = floay(self.rating)
        if rating_num >= 8.5:
            return 'S'
        elif rating_num >= 8:
            return 'A'
        elif rating_num >= 7:
            return 'B'
        elif rating_num >= 6:
            return 'C'
        else:
            return 'D'

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

def get_sorted_movies(movies,sorting_type):
    """对电影列表进行排序并返回

    :param movies:Movie 对象列表
    :param sorting_type:排序选项，可选值
        name（名称）、rating（评分）、year（年份）、random（随机乱序）
    """
    if sorting_type == 'name':
        sorted_movies = sorted(movies,key=lambda movie:movie.name.lower())
    elif sorting_type == 'rating':
        sorted_movies = sorted(movies,key=lambda movie:float(movie.rating),reverse=True)
    elif sorting_type == 'year':
        sorted_movies = sorted(
            movies,key=lambda movie:movie.year,reverse=True
        )
    elif sorting_type == 'random':
        sorted_movies = sorted(movies,key=lambda movie:random.random())
    else:
        raise RuntimeError(f'Unkown sorting type:{sorting_type}')
    return sorted_movies

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

def main():
    # 接收用户输入的排序选项
    sorting_type = input('Please input sorting type')
    if sorting_type not in all_sorting_types:
        print(
            'Sorry, "{}" is not a valid sorting type, please choose from '
            '"{}", exit now'.format(
                sorting_type,
                '/'.join(all_sorting_types),
            )          
        )
        return 

    # 初始化电影数据对象
    movie_items = []
    for movie_json in movies:
        movie = Movie(**movie_json)
        movie_items.append(movie)

    # 排序并输出电影列表
    sorted_movies = get_sorted_movies(movie_items,sorting_type)
    for movie in sorted_movies:
        print(f'- [{movie,rank}] {movie.name} ({movie.year}) | rating: {movie.rating}')

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

@property
def rank(self):
    rating_num = float(self.rating)
    if rating_num >= 8.5:
        return 'S'
    elif rating_num >= 8:
        return 'A'
    elif rating_num >= 7:
        return 'B'
    elif rating_num >= 6:
        return 'C'
    else:
        return 'D'

1
2

# 已经排好序的评级分界点
breakpoints = (6,7,8,8.5)

1
2
3
4
5
6
7

import bisect
# 注意：用来做二分查找的容器必须事已经排好序的
breakpoints = [10,20,30]

# bisect函数会返回值在列表中的位置，0代表相应的值位于第一个元素10之前
bisect.bisect(breakpoints,1)
0

1
2
3
4
5
6
7
8
9

@property
def rank(self):
    # 已经排序号的评级分界点
    breakpoints = (6,7,8,8.5)
    # 各评分区间级别名
    grades = ('D','C','B','A','S')

    index = bisect.bisect(breakpoints,float(slef.rating))
    return grades[index]

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

def get_sorted_movies(movies,sorting_type):
    if sorting_type == 'name':
        sorted_movies = sorted(movies,key=lambda movie:movie.name.lower())
    elif sorting_type == 'rating':
        sorted_movies = sorted(movies,key=lambda movie:float(movie.rating),reverse=True)
    elif sorting_type == 'year':
        sorted_movies = sorted(movies,key=lambda movie:movie.year,reserve=True)
    elif sorting_type == 'random':
        sorted_type = sorted(movies,key=lambda movie:random.random())
    else:
        raise RuntimeError(f'Unknown sorting type:{sorting_type}')
    return sorted_movies

1
2
3
4
5
6
7

sorting_algos = {
    # sorting_type:(key_func,reverse)
    'name':(lambda movie:movie.name.lower(),False)
    'rating':(lambda movie:float(movie.rating),True)
    'year':(lambda movie:movie.year,True)
    'random':(lambda movie:random.random(),False)
}

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

def get_sorted_movies(movies,sorting_type):
    """对电影列表进行排序并返回
    :param movie:Movie 对象列表
    :param sorting_type 排序选项，可选值
        name(名称),rating(评分)、year（年份）、random（随机乱序）
    """
    sorting_algos = {
        # sorting_type:(key_func,reverse)
        'name':(lambda movie:movie.name.lower(),False),
        'rating':(lambda movie:float(movie.rating),True),
        'year':(lambda movie:movie_year,True),
        'random':(lambda movie:random.random(),False)
    }

    try:
        key_func,reverse = sorting_algos[sorting_type]
    except KeyError:
        raise RuntimeError(f'Unknown sorting type: {sorting_type}')

    sorted_movies = sorted(movies,key=key_func,reverse=reverse)
    
    return sorted_movie