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}'
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)))
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)
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)
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)
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}'
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))()
# Functions taking one argument, the first of which is identity
f = lambda x: x; f(3)
(lambda x: 2 * x + 1)(3)
# 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])