Python入门学习容易忽略的知识

Python入门学习容易忽略的知识

一、数字

• // 整除 ，不四舍五入 如17//3 为$5$
• ** 乘方

二、字符串

• 如果你不希望前置了 \ 的字符转义成特殊字符，可以使用 原始字符串方式，在引号前添加 r 即可:

  print(r'C:\some\name') 
  

• 相邻的两个或多个字符串将会自动连接到一起.

  'Py' 'thon'
  

  输出：python

三、列表

• 列表也可以用 + 拼接在一起

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

  输出：
  [1,2,3,4,5]
• append() 追加新元素
• 改变列表大小，或者把列表整个清空:

  letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
  letters[2:5] = []
  

  输出：['a', 'b', 'f', 'g']

  letters[:] = []
  

  输出： []
• 关键字参数 end 可以用来取消输出后面的换行, 或使用另外一个字符串来结尾:

  for a in range(3):
  	print(a, end=',')
  

  输出： 0,1,2

四、循环

如果在循环内需要修改序列中的值（比如重复某些选中的元素），推荐你先拷贝一份副本。对序列进行循环不代表制作了一个副本进行操作。切片操作使这件事非常简单：

words = ['cat', 'window', 'defenestrate']
for w in words[:]: 
  if len(w) > 6:
  	words.insert(0, w)

输出：
['defenestrate', 'cat', 'window', 'defenestrate']

注意：如果写成 for w in words:，这个示例就会创建无限长的列表，一次又一次重复地插入 defenestrate。

五、函数

函数中所有的变量赋值都将存储在局部符号表中；而变量引用会首先在局部符号表中查找，然后是外层函数的局部符号表，再然后是全局符号表，最后是内置名称的符号表。
因此，全局变量和外层函数的变量不能在函数内部直接赋值（除非是在global语句中定义的全局变量，或者是在 nonlocal 语句中定义的外层函数的变量），尽管它们可以被引用。

5.1 参数默认值

默认值是在 定义过程 中在函数定义处计算的，所以

i = 5
def f(arg=i):
    print(arg)
i = 6
f()

输出：5

重要警告： 默认值只会执行一次。当默认值为可变对象（列表、字典以及大多数类实例）时很重要。

比如，下面的函数会存储在后续调用中传递给它的参数:`

def f(a, L=[]):
    L.append(a)
    return L
print(f(1))
print(f(2))

输出：
[1]
[1, 2]

如果不想在后续调用之间共享默认值，你可以这样写这个函数:

def f(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L

5.2 形参

当存在一个形式为 **name 的最后一个形参时，它会接收一个字典 ，其中包含除了与已有形参相对应的关键字参数以外的所有关键字参数。 这可以与一个形式为 *name，接收一个包含除了已有形参列表以外的位置参数的 元组 的形参 组合使用 (*name 必须出现在 **name 之前。)

def cheeseshop(kind, *arguments, **keywords):
    print("-- Do you have any", kind, "?")
    print("-- I'm sorry, we're all out of", kind)
    for arg in arguments:
        print(arg)
    print("-" * 40)
    for kw in keywords:
        print(kw, ":", keywords[kw])
cheeseshop("Limburger", "It's very runny, sir.",
           "It's really very, VERY runny, sir.",
           shopkeeper="Michael Palin",
           client="John Cleese",
           sketch="Cheese Shop Sketch")

输出：
Do you have any Limburger ?
I'm sorry, we're all out of Limburger
It's very runny, sir.
It's really very, VERY runny, sir.
-------------------------------------------
shopkeeper : Michael Palin
client : John Cleese
sketch : Cheese Shop Sketch

5.3 解包参数列表

例如，内置的 range() 函数需要单独的 start 和 stop 参数。如果它们不能单独使用，要使用 * 运算符编写函数调用以从列表或元组中解包参数:

args = [3, 6]
list(range(*args)) 

输出： [3, 4, 5]

以同样的方式，字典可以使用 ** 运算符解包，提供关键字参数:

 def parrot(voltage, state='a stiff', action='voom'):
	print("-- This parrot wouldn't", action, end=' ')
	print("if you put", voltage, "volts through it.", end=' ')
	print("E's", state, "!")
d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
parrot(**d)

输出：
This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

Lambda 表达式

由于lambda语法是固定的，其本质上只有一种用法，那就是定义一个lambda函数。
在实际中，根据这个lambda函数应用场景的不同，可以将lambda函数的用法扩展为以下几种：

• 将lambda函数赋值给一个变量，通过这个变量间接调用该lambda函数。

  add = lambda x, y: x+y
  add(1, 2)
  

  输出：3

• 将lambda函数赋值给其他函数，从而将其他函数用该lambda函数替换。
  为了把标准库time中的函数sleep的功能屏蔽，我们可以在程序初始化时调用：

  time.sleep=lambda x: None
  

  这样，在后续代码中调用time库的sleep函数将不会执行原有的功能。

  time.sleep(3)
  

  程序不会休眠 3 秒钟，而是因为lambda输出为None，所以这里结果是什么都不做

• lambda 用法之高阶函数

map() 函数：
map() 会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
语法：
map(function, iterable, …)
参数：
function ----> 函数
iterable ----> 一个或多个序列

# 1、计算平方数
def square(x):
	return x ** 2

map(square, [1,2,3,4,5])	# 计算列表各个元素的平方
# 结果：
[1, 4, 9, 16, 25]

# ===========匿名函数写法：============
# 2、计算平方数，lambda 写法
map(lambda x: x ** 2, [1, 2, 3, 4, 5])
# 结果：
[1, 4, 9, 16, 25]	 

# 3、提供两个列表，将其相同索引位置的列表元素进行相加
map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
# 结果：
[3, 7, 11, 15, 19]