写文章 点击打开何可ke的主页 Python 必知必会知识点

1：列表、数组、字典、集合、元组的区别

• 可变性

列表，字典，集合创建之后可以对其进行增删改查（集合无法直接修改元素，但可以先删后增）；

利用 numpy 或者 array 定义的数组都可以进行改查，但无法进行增删，即使增删时不报错也是新建了一个数组，原始数组并未改变，即不可变；

元组一旦创建就不可以进行增删改查！

# 列表增加元素语法
my_list = [1, 2, 3]

# 1、利用 append 函数在末尾添加元素 4
my_list.append(4)  

# 2、在索引 1 的位置插入元素 5
my_list.insert(1, 5)  

# 列表删除元素语法
my_list = [1, 2, 3, 4, 5]

# 1、删除元素 3
my_list.remove(3) 

# 2、删除索引为 1 的元素
del my_list[1]  

# 3、删除索引为 0 的元素
my_list.pop(0)

# 字典增加元素语法
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 直接增加元素：元素存在则修改对应键的值、不存在则新增
my_dict['d'] = 4
my_dict.update({'e': 6, 'f': 7})

# 字典删除元素语法
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 删除元素
del my_dict['b']
my_dict.pop('a')

# 集合增加元素的方法
my_set = {1, 2, 3}
my_set.add(4)
my_set.update([5, 6])

# 删除元素
my_set.remove(3)
my_set.discard(2)
my_set.pop()

• 数据存储形式

列表，元组中保存的是数据的地址，数组，集合，字典中保存的是数据的真实值；

字典中数据以键值对形式存在，键无序不可重复，值可重复且数据类型可不同；集合内数据无序不可重复，可以是不同数据类型；

列表、元组和数组内的数据无序且可重复，但数组的数据类型必须一致；

• 运算形式

列表，元组和数组可以进行算术运算，对元组和列表执行加减等操作会添加或删除列表元素，对数组执行算术运算会转换为线性关系运算；集合和字典无法进行算术运算但可以进行集合运算；

• 查找效率

字典和集合查找效率相较于元组，数组和列表更高，元组相较于数组和列表效率更高（列表和数据长度可变，因此需要动态分配内存，会影响元素查找耗时）

2：如何进行字符串插值

字符串插值是通过常量，变量和字面量（字母和数字等构成的字符串或数字，只能作为右值出现）等来构建新的字符串；

• %（Python 3.6 及之前的版本）

print("%s %d" % ('name', 1))
print("%(a)s %(b)d" % {'a': name, 'b':1})

'''
%d：整数
%f：浮点数
%e：科学计数法
%s：字符串
%x：十六进制整数
%o：八进制整数
%c：ASCII 码
%%：输出为 %
'''

• format（Python 3.6 版本以上支持）

res = "my name is {name}, im {age} years old".format(name = 'yaozhizhan', age = 26)
res = "my name is {}, im {} years old".format('yaozhizhan', 26)
# {} 表示占位符

• f-string（Python 3.6 版本以上支持）

name = yaozizhan
age = 25
print(f"my name is {name}, im {age}  years old")

3：is 和 == 有什么区别

is 用于判断二者是否属于同一个 id（标识：Python 中可以通过 id(xxx) 查看某个对象的 id）

== 用于判断二者内容是否相同；

a = [1, 2, 3]
b = a
c = [1, 2, 3]
print(a is b)  
# 结果是 true

print(a == b)  
# 结果是 true

print(a is c)  
# 结果是 false

print(a == c)  
# 结果是 true

4：什么是装饰器

装饰器作用是接受一个函数 / 类作为参数，在不改变原始函数 / 类的情况下，增强或修改函数 / 类的功能，返回一个新的函数**（函数装饰器必须返回新函数，类装饰器不必须返回新函数）**装饰器具体原理如下：

• 定义一个函数装饰器

def myDecorator(func):
  def wrapper():
    print("Before the function is called.")
    func()
    print("After the function is called.")
 
  return wrapper
 
# 前缀符：叫语法糖
@myDecorator
def addNumbers():
  num1 = int(input("Enter first number: "))
  num2 = int(input("Enter second number: "))
  result = num1 + num2
  print("The sum of", num1, "and", num2, "is": , result)
 
addNumbers() 
# 装饰器必须返回新函数的原因

• 定义一个类装饰器

class myDecorator: 
  def __init__(self, func): 
    self.func = func
 
# 该函数可以被类外实例直接执行，这也是类装饰器不一定需要返回函数的原因
  def __call__(self): 
    print('this is new content')
    self.func()
 
@myDecorator
def addNum(): 
  print("original content")
 
addNum() 

5：实例方法、静态方法和类方法有什么区别

• 定义方式

实例方法是一个普通的函数，而类方法和静态方法定义则是分别通过 @classmethod 以及 @staticmethod 装饰器实现的；

• 参数传递

创建类的实例方法需要传入 self 参数，self 代表类的实例对象本身，也就是实例对象的内存地址，传入 self 参数可以避免多线程情况下对类的实例方法调用的逻辑混乱；类方法需要传入 cls 参数，cls 代表类本身，也就是类对象的内存地址；静态方法无需传入 self 或 cls；

• 调用方式

实例方法只能被实例对象调用，类方法和静态方法既可以被类的实例对象调用，也可以被类本身调用；

6：Python 命名规范

• Python 中所有对象的命名都应该以字母或下划线开始且不能与 Python 的关键字冲突
• 变量名、模块名、包名、文件名应该使用小写字母，如果有多个单词，则用下划线分隔，如 variable_name
• 类名应该采用驼峰式命名，并且首字母需要大写，如 ClassName
• 函数名应该采用驼峰式命名，并且首字母需要小写，如 funName
• 常量（不变的值）通常使用全大写字母表示，有多个单词时，需要用下划线进行分隔，如 CONSTANT_NAME
• 私有变量或方法在名称前加上一个下划线，如 private_var
• 特殊方法或属性，应该以双下划线开始和结束，如_init__()

7：迭代器和生成器的区别

• 迭代器

首先理解一个概念，凡是可以通过循环逐个访问内部元素的对象都叫做可迭代对象；

迭代器是一种支持 next 方法的对象，每次执行 next 方法都会从迭代器中返回一个元素，并且会记住程序当前运行状况，当迭代器中的元素全部返回后，会产生 StopIteration 异常；如果迭代器内元素没有遍历完，那么下次遍历会从上一次遍历的最后一个元素的下一个元素开始，想要从头开始遍历需要重新建立一个迭代器对象。

用 iter 方法创建的迭代器和其他可迭代对象相同，也需要一次性请求内存空间，但不可以利用 len 返回获取迭代器大小！

# 构造方法如下代码所示：
lista = [1, 2, 3, 4]
itera = iter(lista)
while True: 
  try: 
    print(next(itera))
  except StopIteration: 
    sys.exit

• 生成器

生成器是一种特殊的迭代器，可以利用 yield 函数产生；应用场景，比如当我们需要打印一个 1000000 个元素的有规律的列表，如果直接初始化列表再打印会消耗很多内存空间，生成器可以做到按需打印，节省内存空间；

有两种方法利用生成器制造迭代器，如下代码所示：

# 使用函数定义生成器
def my_generator():
    for i in range(10):
        yield i

# 使用生成器表达式
my_generator_expr = (i for i in range(10))

• 区别：生成器用来生成元素，迭代器用来访问可迭代对象元素；迭代器生成生成器的内容；

8：按引用调用和按值调用的区别

按引用 / 值调用都是函数调用参数过程中的参数传递方式，按引用调用指函数直接对原始参数进行隐式调用，而不是调用副本，这意味着当如果调用者对实参进行修改时，原始参数也会改变；按值调用是指函数的实参只是原始参数的一个副本，函数内部的改动不会影响原始参数的值；

Python 中的函数调用过程是按对象调用，比较灵活，对于可变对象（列表、字典、集合）是按引用调用！对于不可变对象（字符串、数值、元组）是按值调用；

9：深拷贝和浅拷贝区别

假设 list01 = [1, 2, [3, 4]]，对比三种情况说明！

• 直接引用

list02 = list01

直接引用情况下 list02 变化会影响到 list01

• 浅拷贝

list02 = copy.copy(list01)

注意到 list01 内部有一个可变子对象 [3, 4]，浅拷贝只会拷贝对象顶层结构（对象自身及其直接子对象）但不拷贝子对象内部内容，仍旧保留直接引用（即新旧列表共享子对象）；所以当 list02 对 [3, 4] 进行修改后，list01 中对应的子列表也会更新；列表的切片操作和 python 的 copy 模块可以实现浅拷贝；

• 深拷贝

list02 = copy.deepcopy(list01)

深拷贝将完全递归的复制一份 list01 的内存空间，之后无论如何修改 list02 都不会影响 list01；深拷贝可能会遇到两个问题：一是拷贝复杂的数据结构，例如循环链表时，会导致无休止的递归拷贝造成栈溢出现象；二是深拷贝可能对原本设计为多个对象共享的数据也进行拷贝，导致共享变量不再共享；

深拷贝本质上是一次序列化和反序列化过程 my_deep_copy = lambda obj: pickle.loads(pickle.dumps(obj))

注：对于不可变对象，深拷贝和浅拷贝没有本质区别！！

import copy

a = [1, 2, 3, 4, ['a', 'b']]
b = a 
c = copy.copy(a) 
d = copy.deepcopy(a) 
 
a.append(5) 
a[4].append('c') 
 
print 'a= ', a
print 'b= ', b
print 'c= ', c
print 'd= ', d

''' 
输出结果：
a = [1, 2, 3, 4, ['a', 'b', 'c'], 5] 
b = [1, 2, 3, 4, ['a', 'b', 'c'], 5]
c = [1, 2, 3, 4, ['a', 'b', 'c']] 
d = [1, 2, 3, 4, ['a', 'b']] 
'''

10：pickle 模块作用

pickle 模块允许将 Python 中的对象转换为二进制字节流进行存储或者网络传输，当需要的时候再将其转换为Python 对象，即能够持久化各种数据，整个过程实际上就涉及到数据的序列化（pickling）和反序列化（unpickling）pickling 和 unpickling 主要通过 pickle.dump 和 pickle.load 函数实现；这样即使 Python 对象的生命周期结束了，保存在文件中的数据也不会丢失，步骤如下：

import pickle

obj = [{'id':1, 'na':'Stu'}, {'id': 2, 'na': 'Flu'}]
with open('file.p', 'wb') as f:
  pickle.dump(obj, f) 
  # 将对象序列化
  # 注意和 pickle.dumps 区分：pickle.dumps 只有一个对象参数，且其返回的内容就是 pickle.dump(obj, f) 写入到文件中的二进制字节流的实际形式

with open('file.p', 'rb') as f: 
  newObj = pickle.load(f) 
  # 将对象反序列化

print(newObj)
# 结果为 [{'id': 1, 'na': 'Stu'}, {'id': 2, 'na': 'Flu'}]

11：字典和 JSON 的区别

• 定义

字典是一种数据结构，可直接在 Python 中调用；而 JSON 是一种独立于编程语言之外的数据交换格式**（纯文本文件）**需要通过序列化和反序列化实现在不同平台的使用；实际应用中若需要跨语言或者更广泛的数据交互，应选择 JSON；如果仅在 Python 环境中需要处理复杂数据类型，pickle 更适合；

• 数据类型

字典的键可以是任意可哈希类型**（不可变类型）而 JSON 的键只能是字符串类型**

• 使用方法

import requests, json
payload = {"Overall": "良好", "Progress": "30%", "Problems": [{"No": 1}, {"No": 2}]}
r = requests.post(url, data = json.dumps(payload))
# 字典中的非字符串类型的键会被转换为字符串类型，元组会被转换为数组

json.loads(file.read())
# 导入 JSON 格式文件

12：SQLalchemy 模型

13：如何将 if else 改写成三目运算符形式

'YES' if 1 == 0 else 'NO'

14：Python 如何处理异常

try:
  # 可能引发异常的代码
  raise Exception
  # 手动抛出异常让程序跳转执行

  except ExceptionType1:
  # 处理 ExceptionType1 类型的异常

  except ExceptionType2:
  # 处理 ExceptionType2 类型的异常

  except …… :
  else:
    # 如果没有异常被引发时执行的代码（可选）

  finally:
    # 无论是否引发异常都会执行的代码（可选）

15：Python 有哪些异常

• **TypeError：**操作应用于不适当的数据类型时触发 例如 int(‘abc’ + 1) 或 ‘abc’ + 1
• **IndexError：**当试图访问超出序列范围的索引时触发
• **ValueError：**传递的参数不符合预期就会返回该类异常，例如 [1, 2, 3].remove(4) 或 int(‘abc’)
• **KeyError：**当试图访问字典中不存在的键时触发
• **ZeroDivisionError：**当试图将数字除以零时触发
• **AttributeError：**当尝试访问不存在的属性或方法时触发
• **ImportError：**当无法导入模块时触发
• **FileNotFoundError：**当试图打开不存在的文件时触发
• **StopIterationError：**迭代器元素迭代完后继续用 next 方法时触发

16：面向对象设计细节

17：Python 赋值方式

• **直接赋值：**x = 1
• **链式赋值：**x = y = 1
• **拆包赋值：**x, y = 1, 1

18：垃圾回收机制

19：什么是匿名函数

匿名函数是指利用 lambda 关键字定义的函数，通常具有代码简短，一次性的优势；匿名函数一定能转为常规函数，但是常规函数不一定能转为匿名函数：

lambda arguments: function(arguments)
# 匿名函数语法

num.sorted(key = lambda x: x[1])
# 实例：sorted 中的 key 通常接受一个函数作为排序键，它会将数组中的每个元素应用到 lambda 构建的匿名函数（排序键）上后进行排序

20：随机数相关用法

import random
# 导入随机数包

my_list = [1, 2, 3, 4, 5, 6]
random.randint(1, 100)
# 生成一个 1 到 100 之间的随机整数

random.uniform(0.0, 1.0) 
# 生成一个 0 到 1 之间的随机浮点数

random.choice(my_list) 
# 从列表中随机选择一个元素

random.shuffle(my_list) 
# 随机打乱列表中元素的顺序

random.random()
# 随机生成 0-1 之间的浮点数

random.randrange(1, 10, 2)
# random.randrange(start, stop, step)
# 按照步长随机生成一系列整数，比如有时候只想在某个范围内随机取奇数或者偶数，就可以将步长设置为 2

21：什么是工厂函数

比如我想定义一个具备加减乘除功能的计算器，传统做法如下面代码所示：

# 定义基础功能函数
def add(a, b): 
  return a + b

def sub(a, b): 
  return a – b

def multiply(a, b): 
  return a * b

def divide(a, b):
  return a / b

# 定义计算器
def call(a, b, operate):
  if operate == 1:
    return plus(a, b)
  elif operate == 2:
    return sub(a, b)
  elif operate == 3:
    return multiply(a, b)
  elif operate == 4:
    return divide(a, b)
  else:
    return None

这种做法直接且逻辑清晰，但过于冗余，便可以考虑使用工厂函数解决，如下代码所示：

# 定义一个字典，封装操作符和对应函数名
funcmap = {1: plus, 2: substact, 3: multiply, 4: divide}

# 函数工厂是对函数进行动态分配
def cal(a, b, how):
  if how in funcmap.keys():
    return funcmap[how](a, b)
  else:
    return None

22：正则表达式模块用法

import re
# 正则表达式模块：regular expression

re1 = re.compile('blue|white|red')
# re1是一个正则表达式对象，优化了编译过程，并且匹配语法也和正则表达式不同

re2, re3 = r"The", r"flag"
# re2 和 re3 是正则表达式

print(re1.pattern)
# 正则表达式对象不是字符串，无法打印

text = "The flag can be blue, white, or red."
partRes1 = re1.search(text)
# 部分搜索：只匹配第一个匹配到的字符串

partRes1all = re.findall(re1, text)
# 全局搜索：返回结果是一个列表

partRes2 = re.match(re2, text)
# 只在字符串首部进行匹配

partRes3 = re.sub(re2, 'haha', text)
# 查找对应的正则表达式并替换字符串，返回结果是替换后的字符串

partRes4 = re.subn(re2, 'ha', text)
# 查找对应的正则表达式，返回结果是替换后的字符串和替换次数构成的元组

partRes5 = re.split(re3, text)
# 按照正则表达式的值将字符串进行切割，返回结果是一个列表

print(partRes1all) 
# 结果：['blue', 'white', 'red']

print(partRes1.group()) 
# 结果：blue

print(partRes2.group()) 
# 结果：the

print(partRes3) 
# 结果：haha flag can be blue, white, or red.

print(partRes4) 
# 结果为 ('ha flag can be blue, white, or red.', 1)

print(partRes5)  
# 结果为 ['The ', ' can be blue, white, or red.']

23：如何构造正则表达式

24：贪婪模式和非贪婪模式的区别

Python 中的量词 {m,n}、{m,}、{m}、?、* 和 + 都属于贪婪模式的量词，在其后加上 ？后就可以变为非贪婪模式的量词；贪婪模式下在匹配到满足条件的字符串后还会继续向右匹配，以找到更多字符串，而非贪婪模式下找到一个就停止继续匹配；

25：三引号的作用

• 定义多行字符串文本
• 多行注释

26：*args 和 **kwargs

• *args

接受任意数量的非关键字参数（位置参数：根据定义过程中的顺序识别）函数内部 *args 被表示为一个元组，可以让函数调用者传递任意数量的位置参数给函数；

• **kwargs

表示接受任意数量的关键字参数（根据定义过程的名称识别）函数内部 **kwargs 被表示为一个字典，允许函数调用者传递任意数量的关键字参数给函数；

def greet(name, *args, **kwargs): 
  print(f"Hello, {name}!") 
  print("Extra args:", args) 
  print("Keyword args:", kwargs)

greet("Alice", 1, 2, 3, key1 = "val1", key2 = "val2") 
  
'''
输出如下：
Hello, Alice! 
Extra args: (1, 2, 3) 
Keyword args: {'key1': 'val1', 'key2': 'val2'} 
'''

27：f.open() 和 with 的区别

f.open() 需要手动关闭文件，否则可能会导致文件关闭失败引起资源泄露；而 with open 在执行结束后会自动关闭文件，更加安全规范；发生异常时 open 需要手动处理，而 with open 会自动关闭文件再拋出异常，二者语法如下；

• open

file = open(path, 'r', encoding = 'UTF-8')
try: 
  file.read()
  # 读取的是文件流对象，非文件本身
except: 
  # 异常类型有文件不存在，权限不足等
finally: 
  file.close()

• with open

with open(‘file.txt’, ‘r’) as f:
  f.read()
  # 如果发生异常则自动关闭文件拋出异常

常见文件操作符：

• **r：**只能读取文件内容，文件不存在则报错
• **w：**只能将内容写入文件，如果文件存在，则会删除文件内容；反之则新建一个文件
• **a：**如果文件存在，则将内容添加到文件末尾，不会截断文件；反之则新建一个文件
• **b：**分为 rb 和 wb，表示以二进制模式读写文本
• **t：**文本模式：分为 rt和 wt，表示以二进制模式读写文本
• **关于 t 和 b 的选择：**如果需要处理的是文本文件，建议使用文本模式，可以自动处理换行符；如果是二进制数据（例如图像、音频和视频等）建议使用二进制模式，以字节读取文件，无法处理换行符

28：Cpython 的 GIL

29：__init__ 和 __new__ 的区别

# 定义并初始化一个类的完整流程
class human: 
  # 这一步默认自动定义（内部打印语句除外）
  def __new__(cls, name):
    print('this __new__')
    return super().__new__(cls)
    # 必须返回实例对象，否则类定义失败
  
  '''
  单例模式：  def __new__(cls, name):    print('this __new__')    if not hasattr(cls, '_ins'):        cls._ins = super().__new__(cls)    
    return cls._ins  '''

# 初始化函数需要手动定义
def __init__(self, name): 
  print('this __init__')
  self.name = name

yje = human(yaojianen)
hmy = human(yaojianen)
print(id(yje))
print(id(hmy))
print(yje.name)
print(hmy.name)

'''
非单例模式执行结果：
this __new__ # 一旦生成实例就执行
this __init__ # 一旦生成实例就执行
this __new__
this __init__
123456
123458
yaojianen
yaojianen
'''

'''
单例模式执行结果：
this __new__ 
this __init__ 
this __new__ 
this __init__ 
123456
123456
yaojianen
yaojianen
'''

可以看出两个对象实际上调用了一个类并实现了同样的实例，但二者的内存地址却不相同，这无疑会导致内存的浪费，解决办法就是修改 __new__ 方法实现单例模式设计，单例模式执行结果如注释所示；但单例模式由于共享同一块内存区域，可能会导致类似于直接引用可变对象存在的缺陷！！

30：什么是猴子补丁

猴子补丁可以在不修改源代码的情况下扩展或修复现有的库或框架，如下代码所示：

# 导入目标模块或类
import math

# 定义新函数，扩展 math 模块中的 sqrt 函数
def sqrtWithLogging(x):
  result = math.sqrt(x)
  print(f"The square root of {x} is {result}")
  return result

math.sqrt = sqrtWithLogging
# 用猴子补丁将新函数分配给 math.sqrt 方法

31：CPython 解释器语句优化

CPython 解释器出于性能优化的考虑，把频繁使用的整数对象用一个叫 small_ints 的对象池缓存起来造成的；small_ints 缓存的整数值被设定为 [-5, 256]，也就是说在任何引用这些整数的地方，都不需要重新创建 int 对象，而是直接引用缓存池中的对象。如果整数不在该范围内，那么即便两个整数的值相同，它们也是不同的对象；对于字符型变量而言，如果 a 和 b 内容相同且长度小于 20，那么 CPython 会默认共享二者内存，长度大于 20 有可能不会共享内存，但对于字符型变量我们可以手动驻留，例如 a = sys.intern(‘yzzyzzyzzyzzyzzyzzyzz’)

32：如何不利用中间变量交换两个整数值

• 方法一：a, b = b, a

只适用于 Python，该语法并不是元组解包！！！是利用 ROT_TWO 字节码指令支持的，类似的还有ROT_THREE，可以利用 dis.dis 反汇编 Python 源代码；只有用到三个以上变量的时候才是元组解包思想；

• 方法二：适合所有编程语言

# 异或：相同为 False，反之为 True
a = a ^ b
b = a ^ b
a = a ^ b

33：什么是链式调用

链式调用也叫作方法链，实现方式是在类中每个方法都执行一次 return self

class Chain(object):
  def __init__(self, name):
    self.name = name
  
  def get_name(self):
    print("my name is %s" % self.name)
    return self

  def talk(self):
    print("We can make friends!")
    return self

if __name__ == '__main__':
  chain = Chain(name = "张三")
  chain.get_name()
  print("-" * 20)
  chain.get_name().talk()

34：什么是函数重载

函数重载是指在同一个类中定义多个具有相同名称但不同参数列表的函数；函数重载的目的是允许同一个类中的不同函数根据传入的参数来执行不同的逻辑，提供了多态的特性；在一些编程语言如 C++、Java 中，函数重载是通过参数类型和数量的不同来实现的；但 Python 中由于函数名称唯一，不支持直接函数重载；不过可以使用默认参数、可变参数等方式来实现类似的行为；

• 使用默认参数实现函数重载

def add(a, b = 0, c = 0):
  return a + b + c

# 调用方式 1：只传入一个参数
result1 = add(5)
print(result1) 

# 调用方式 2：传入两个参数
result2 = add(5, 3)
print(result2) 

# 调用方式 3：传入三个参数
result3 = add(5, 3, 2)
print(result3) 

• 使用可变参数实现函数重载

def add(*args):
  result = 0
  for arg in args:
    result += arg

  return result

result1 = add(5)
result2 = add(5, 3)
result3 = add(5, 3, 2)
print(result1) 
# 输出 5

print(result2) 
# 输出 8

print(result3) 
# 输出 10

35：Python 中的静态代码如何分析

了解一个概念，Python3.5 版本之前的 Python 代码与 CPP 和 Java 不同，所有变量的类型都是解释器或编译器在运行代码的过程中确定的，3.5 版本及之后 Python 才引入了类型提示（一种静态类型检查方式）静态检查代码中变量类型是否正确，改进代码质量；Python 中的一些模块，例如 mypy 提供了静态类型提示，pylint 提供了代码查错和改进建议，flake8 提供了 pyflake 用于代码查错和 pycodestyle 用于检查代码风格；

36：if __name__ == ‘_main__’ 作用

该语句用来当文件当作脚本运行时候就执行内部代码；当文件作为模块被导入时就不执行内部代码

37：Python 常用函数

# range：可以接受 1-3 个参数然后生成一个整数列表，通常搭配 for 循环使用
range(9)
# 生成 0 到 9之间的整数

range(2, 9)
# 生成 2到 9间的整数

range(1, 10, 2)
# 以 2为间隔生成 1 到 10 之间的整数

# reduce：传入的第一个参数是一个函数 A，第二个是一个可迭代对象 B；使用 A 对 B 进行迭代，将 A 当前需要用到的元素进行计算，然后保留计算结果，循环该步骤直到 B 遍历完成，具体细节如下所示：
from functools import reduce
A = [1, 2, 3, 4, 5]
def add(x, y): 
  return x + y
  print(reduce(add, a)) 
  # 结果返回15

# filter：第一个参数是一个函数 A，第二个是一个可迭代对象 B，使用 A 对 B 进行迭代，只有当 B 中的元素代入 A 中结果为 true 才能在返回的迭代器中包含该元素
res = filter(x + 2, [1, 2, -3])

# map：第一个参数是一个函数 A（或 int 等）其余形参可以一个或多个是列表，元组，字典（如果是字典通常来说是将键代入函数，然后新的结果作为值）类型的变量
# map 首先对所有可迭代对象的第一个元素应用函数，然后对所有可迭代对象的第二个元素应用函数，依次类推，最终 Python 3 中返回的是迭代器，Python 2 中返回的是列表

# reverse：用法为 XXX.reverse()，reverse 函数无返回值，直接修改原始对象（列表，元组和字符串等）如果想要获得返回值可以对原始对象切片

# extend：作用是连接两个列表，例：list01.extend(list02)；与 list01 + list02 执行后返回结果相同
# 扩展：连接两个数组可以使用 np.contatenate((list01, list02)) 或者 np.stack((list01, list02))

# round
num1, num2 = 123.45, 123.41
print(round(num1, 1) + round(num2, 1)) 
# 结果为123.5 + 123.4

print(round(num1) + round(num2)) 
# 结果为123 + 123

print(round(num1, -1) + round(num1, -2)) 
# 结果为120 + 100

# any 和 all：二者都接受一个序列对象，前者只要序列对象中有一个及以上元素为 true 则返回 true；后者必须所有元素为 true 才能返回 true（除了0、空、None、False 外都算 True）但注意空元组、空列表返回值为 True
# bin： 返回十进制对应二进制数
# oct：返回十进制对应八进制数
# hex：返回十进制对应十六进制数
# ord：获取字符 ASCII 码
# isnumeric：字符串是否仅有数字
# isalpha：字符串是否仅有字母
# isalnum：字符串是否仅有数字和字母
# find：查找字符串子串、未找到返回 -1
# upper 和 lower 函数：将字符串转换为大 / 小写

# zip：可以接收两个或更多个可迭代对象（列表、元组、字符串等）并将这些可迭代对象中相同位置的元素逐个打包成一个元组，最后组成一个新的可迭代对象
# enumerate：将可迭代对象组合成索引序列，简化需要输出列表元素及索引场景下的遍历操作
citys = ["jinan", "qingdao", "yantai"]
enumeratedCitys = enumerate(citys)
print(list(enumeratedCitys))
# 输出 [(0, 'jinan'), (1, 'qingdao'), (2, 'yantai')]

# remove, pop, del
num = [1, 2, 3, 4]
num.remove(2)
# 根据值删除第一个匹配的内容，无返回值

del num[1]
# 删除任意给定内容，无返回值

num.pop()
# 按索引值删除并返回删除的内容，若未传递索引参数则默认删除最后一个元素

以上就是“写文章
点击打开何可ke的主页
Python 必知必会知识点”的全部内容，希望对你有所帮助。
​
​关于Python技术储备

学好 Python 不论是就业还是做副业赚钱都不错，但要学会 Python 还是要有一个学习规划。最后大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！

一、Python所有方向的学习路线

Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

二、Python必备开发工具

三、Python视频合集

观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

四、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

五、Python练习题

检查学习结果。

六、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

最后祝大家天天进步！！

上面这份完整版的Python全套学习资料已经上传至CSDN官方，朋友如果需要可以直接微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】。