【375】COMP 9021 相关笔记

1. Python 中的逻辑否定用 not

2. 对于下面的代码直邮输入整数才能运行，无论字符串或者浮点型都会报错

int(input('How many games should I simulate? '))

　　可以通过 try 来修改，同时注意 raise 的使用

while True:
    try:
        nb_of_games = int(input('How many games should I simulate? '))
        if nb_of_games <= 0:
            raise ValueError
        print('Ok, will do!')
        break
    except ValueError:
        print('Your input is incorrect, try again.')

3. set 与 dict 都是大括号

# Checking for membership in a list
'y' in ['yes', 'y', 'no', 'n']
'Y' in ['yes', 'y', 'no', 'n']
# Checking for membership in a set
'y' in {'yes', 'y', 'no', 'n'}
'Y' in {'yes', 'y', 'no', 'n'}

'''
Curly braces are used for both literal dictionaries and literal sets. 
There is no potential conflict, except for empty set versus empty dictionary; 
{} denotes an empty dictionary, not an empty set:
'''

# Singleton dictionary and set, respectively
type({'one': 1})
type({'one'})
# Empty dictionary and set, respectively
type({})
type(set())

4. random.choice() 可以随机选择列表里面的元素

　　random.randrange()，在 0 与 n 之间随机产生一个数

from random import choice
doors = ['A', 'B', 'C']
for i in range(12):
    choice(doors)

5. list.pop() 默认删除最后一个，否则按照索引删除

6. format

　　To output information about the game as it is being played, it is convenient to use formatted strings; they are preceded with f and can contain pairs of curly braces that surround expressions meant to be replaced with their values. Also, though strings can be explicitly concatenated with the + operator, they can also be implicitly concatenated when they are separated with nothing but space characters, including possibly new lines:

x = 10
u = 4.5
v = 10
print(f'x is equal to {x}.'
      ' That is not all: '
      f'{u} divided by {v} equals {u / v}.'
     )

x = 123 / 321
f'{x}'
f'{x:.0f}'
f'{x:.1f}'
f'{x:.2f}'
f'{x:.3f}'
f'{x:.4f}'
f'{x:.30f}'

7. 神奇的 * 号，乘号，可以扩展字符串，可以扩展列表

[1, 2, 3]*3
"abc"*3

8. 输出格式，0补全

# A field width of 3 at least, padding with spaces if needed
f'{90:3}', f'{90:3b}', f'{90:3o}', f'{90:3x}', f'{90:3X}'
# A field width of 3 at least, padding with 0's if needed
f'{90:03}', f'{90:03b}', f'{90:03o}', f'{90:03x}', f'{90:03X}'
# A field width of 8 at least, padding with spaces if needed
f'{90:8}', f'{90:8b}', f'{90:8o}', f'{90:8x}', f'{90:8X}'
# A field width of 8 at least, padding with 0's if needed
f'{90:08}', f'{90:08b}', f'{90:08o}', f'{90:08x}', f'{90:08X}'

(' 90', '1011010', '132', ' 5a', ' 5A')

('090', '1011010', '132', '05a', '05A')

('      90', ' 1011010', '     132', '      5a', '      5A')

('00000090', '01011010', '00000132', '0000005a', '0000005A')

sorted

Let us still not "hardcode" the sequence of bits as (s[7], s[3], s[5], s[1], s[6], s[2], s[4], s[0]), but generate it. Let us first examine the sorted() function. By default, sorted() returns the list of members of its arguments in their default order:

sorted([2, -2, 1, -1, 0])
# Lexicographic/lexical/dictionary/alphabetic order
sorted({'a', 'b', 'ab', 'bb', 'abc', 'C'})
sorted(((2, 1, 0), (0, 1, 2), (1, 2, 0), (1, 0, 2)))

[-2, -1, 0, 1, 2]

['C', 'a', 'ab', 'abc', 'b', 'bb']

[(0, 1, 2), (1, 0, 2), (1, 2, 0), (2, 1, 0)]

sorted() accepts the reverse keyword argument:

sorted([2, -2, 1, -1, 0], reverse = True)
sorted({'a', 'b', 'ab', 'bb', 'abc', 'C'}, reverse = True)
sorted(((2, 1, 0), (0, 1, 2), (1, 2, 0), (1, 0, 2)), reverse = True)

[2, 1, 0, -1, -2]

['bb', 'b', 'abc', 'ab', 'a', 'C']

[(2, 1, 0), (1, 2, 0), (1, 0, 2), (0, 1, 2)]

sorted() also accepts the key argument, which should evaluate to a callable, e.g., a function. The function is called on all elements of the sequence to sort, and elements are sorted in the natural order of the values returned by the function:

sorted([2, -2, 1, -1, 0], key = abs)
sorted({'a', 'b', 'ab', 'bb', 'abc', 'C'}, key = str.lower)
sorted({'a', 'b', 'ab', 'bb', 'abc', 'C'}, key = len)

[0, 1, -1, 2, -2]

['a', 'ab', 'abc', 'b', 'bb', 'C']

['C', 'b', 'a', 'ab', 'bb', 'abc']

We can also set key to an own defined function: 按照自定义的顺序进行排序

def _2_0_1(s):
    return s[2], s[0], s[1]

def _2_1_0(s):
    return s[2], s[1], s[0]

sorted(((2, 1, 0), (0, 1, 2), (1, 2, 0), (1, 0, 2)), key = _2_0_1)
sorted(((2, 1, 0), (0, 1, 2), (1, 2, 0), (1, 0, 2)), key = _2_1_0)

[(1, 2, 0), (2, 1, 0), (0, 1, 2), (1, 0, 2)]

[(2, 1, 0), (1, 2, 0), (1, 0, 2), (0, 1, 2)]

So we could generate the sequence (0, 4, 2, 6, 1, 5, 3, 7) as follows:

def three_two_one(p):
    return p % 2, p // 2 % 2, p % 4

for p in sorted(range(8), key = three_two_one):
    p, f'{p:03b}'

(0, '000')

(4, '100')

(2, '010')

(6, '110')

(1, '001')

(5, '101')

(3, '011')

(7, '111')

lambda 表达式

There is a better way, using a lambda expression. Lambda expressions offer a concise way to define functions, that do not need to be named:

# Functions taking no argument, so returning a constant
f = lambda: 3; f()
(lambda: (1, 2, 3))()

3

(1, 2, 3)

# Functions taking one argument, the first of which is identity
f = lambda x: x; f(3)
(lambda x: 2 * x + 1)(3)

3

7

# Functions taking two arguments
f = lambda x, y: 2 * (x + y); f(3, 7)
(lambda x, y: x + y)([1, 2, 3], [4, 5, 6])

20

[1, 2, 3, 4, 5, 6]