python review

仅限个人学习总结，不适用参考。

参考文献：
《python 从入门到实践》
《流畅的 python》

pycharm 导入自定义模块

from folder.filename import classname

string

title()
upper()
lower() rstrip() lstrip() strip()
" ' "正确使用单、双引号
str()

list 可变

list.append(elem)
list.insert(pos,elem)
复制代码

del list[pos]
val = list.pop() #删除列表尾元素
val = list.pop(pos)
复制代码

原则：删除后不用，del；删除后还用，pop

list.remove(elem) # 移除首个 elem

# 永久性,元素顺序改变
list.sort() #字母序
list.sort(reverse=True)
复制代码

# 临时性，元素顺序不变
sorted(list)
复制代码

list.reverse()
len(list)
list[-1] #最后一个元素

# 操作列表
for elem in list:
复制代码

# 生成数值列表

range(start,end) #tuple; start ~ end-1
range(start,end,step)
list(range(start,end))
复制代码

num**2 次方

min() max() sum()

列表解析 squares = [val**2 for value in range(1,5)]

# 切片

list[start:end] #start ~ end-1
list[:end]
list[start:] # list[-3:end]
list[start:end:step] #step 步长

for elem in list[:3]:

list_b = list_a[:] # 复制列表
复制代码

tuple 不可变

if

if : elif: else:

dict 键值对

dict = {} dist['a'] = b

键不可变类型：整型、浮点型、字符串、元组
值：任意类型

del list['a']

for key,value in list.items():

for key in list.keys():

for value in list.values():

for key in sorted(list.keys())
复制代码

input & while

message = input('some hint') #解读为字符串

age = input()
age = int(age)

while

for 循环是一种遍历列表的有效方式，但在 for 循环中不应修改列表，否则将导致 Python 难以 跟踪其中的元素。要在遍历列表的同时对其进行修改，可使用 while 循环。通过将 while 循环同列表和字典结合起来使用，可收集、存储并组织大量输入，供以后查看和显示。

function

传递参数

1. 位置参数 顺序不能错
2. 关键字参数 传参时关联名称和值
3. 默认值

使用默认值时，形参列表中必须先列出没有默认值的形参，正确解读。

传递列表
function(list)

禁止函数修改列表
function(list[:])

传递任意数量的实参 function(*tuple_name)
生成一个名为 tuple_name 的空元组，并将所有的值都封装到该元组中

结合使用位置实参和任意数量实参

如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最 后。Python 先匹配位置实参和关键字实参，再将余下的实参都收集到最后一个形参中。

使用任意数量的关键字实参

def build_profile(first, last, **user_info):
"""创建一个字典，其中包含我们知道的有关用户的一切"""

user_profile = build_profile('albert', 'einstein',location='princeton',field='physics')
复制代码

class

开头和末尾各有两个下划线，这是一种约定，旨在避免 Python 默认方法与普通方法发生名称冲突 如 __init()__

class Car():
    def **init**(self, make, model, year):
    """初始化描述汽车的属性"""

        self.make = make
        self.model = model
        self.year = year
        # 给属性指定默认值
        self.odometer_reading = 0

    def get_descriptive_name(self):
        """返回整洁的描述性信息"""

        long_name = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name.title()

class ElectricCar(Car):
    def __init__(self, make, model, year):
      super().__init__(make, model, year)

      # 新属性
      self.battery = Battery()
复制代码

将实例用作属性

class Battery():
    """一次模拟电动汽车电瓶的简单尝试"""

    def __init__(self, battery_size=70):
        self.battery_size = battery_size

    def describe_battery(self):
        """打印一条描述电瓶容量的消息"""

        print("This car has a " + str(self.battery_size) + "-kWh battery.")

my_tesla = ElectricCar("tesla", "model s", 2018)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
复制代码

可以以三种不同的方式修改属性的值：

• 直接通过实例进行修改；
• 通过方法进行设置；
• 通过方法进行递增（增加特定的值）

类名应采用驼峰命名法，即将类名中的每个单词的首字母都大写，而不使用下划线。实例名 和模块名都采用小写格式，并在单词之间加上下划线。

higher-order function

接受函数为参数，或者把函数作为结果返回的函数是高阶函数
函数式编程的特点之一是使用高阶函数

map()

map 函数返回一个可迭代对象，里面的元素是 把第一个参数（一个函数）应用到第二个参数（一个可迭代对象)

def factorial(n):
  return 1 if n < 2 else n \* factorial(n - 1)

print(list(map(factorial, range(11))))

sort(key=function)
sorted(key=function)
任何单参数函数都能作为 key 参数的值

fruits = ['strawberry', 'fig', 'apple', 'cherry', 'raspberry', 'banana']
print(sorted(fruits, key=len))

def reverse(word):
  return word[::-1]

# reverse 仅作为排序条件

print(sorted(fruits, key=reverse))
复制代码

最为人熟知的高阶函数有 map、filter、reduce 如果想使用不定量的参数调用函数，可以编写 fn(*args, **keywords)，不用再编写 apply(fn, args, kwargs)

map、filter 和 reduce 的现代替代品

列表推导和生成器表达式

list(map(factorial, range(6)))
print([factorial(n) for n in range(6)])

list(map(factorial, filter(lambda n: n % 2, range(6))))
print([factorial(n) for n in range(6) if n % 2])
复制代码

在 Python 3 中，map 和 filter 返回生成器（一种迭代器），因此现在 它们的直接替代品是生成器表达式（在 Python 2 中，这两个函数返回列 表，因此最接近的替代品是列表推导）

reduce(add, range(100))
print(sum(range(100)))
复制代码

lambda

# lambda 返回函数

def make_increment(n):
return lambda x: x + n

f = make_increment(42)
print(f(1))
复制代码

# lambda 作参数

pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
pairs.sort(key=lambda pair: pair[1])
print(pairs)
复制代码

在参数列表中最适合使用匿名函数
除了作为参数传给高阶函数之外，Python 很少使用匿名函数。

closure（闭包）

只有涉及嵌套函数时才有闭包问题

闭包指延伸了作用域的函数，

其中包含函数定义体中引用、但是不在定义体中定义的非全局变量。
函数是不是匿名的没有关系，关键是它能访问定义体之外定义的非全局变量。

def make_averager():
    series = []

    def averager(new_value):
        series.append(new_value)
        total = sum(series)
        return total / len(series)

    return averager
复制代码

综上，闭包是一种函数，它会保留定义函数时存在的自由变量的绑定， 这样调用函数时，虽然定义作用域不可用了，但是仍能使用那些绑定。

nonlocal

def make_averager():
    count = 0
    total = 0

    def averager(new_value):
        nonlocal count, total
        count += 1
        total += new_value
        return total / count

    return averager
复制代码