Python 基础补充

本文将介绍 Python 基础的补充内容。

1. 函数参数详细

相对于其他编程语言，Python 中的函数参数的传递、定义具有更多方便实用的功能。

1.1 调用函数时传参

Python 中调用函数时，支持多种参数传递方式，如：

def f(a, b, c, d):
    print(a, b, c, d)

# 直接传递参数，必须按顺序
f(1, 2, 3, 4)

# 指定参数名传递参数，不必按顺序
f(c=3, b=2, a=1, d=4)

# 参数组成列表，使用 * 传递，必须按顺序
params = [1, 2, 3, 4]
f(*params)

# 参数组成字典，使用 ** 参数，不必按顺序
params = {
    'd': 4,
    'c': 3,
    'a': 1,
    'b': 2,
}
f(**params)

# 以上混用（注意顺序，位置传参在前，命名传参在后）
params_list = [2]
params_dict = { 'd': 4 }
f(1, *params_list, c=3, **params_dict)

输出：

1 2 3 4

1.2 定义函数不定参数

函数在定义时，也支持多种参数定义方式：

def f(a, b=2, *args, **kwargs):
    '''
    a 为固定参数
    b 具有默认值，可以不传递
    *args    会自动搜集多余的位置参数
    **kwargs 会自动搜集多余的命名参数
    '''
    print(a, b, args, kwargs)

f(1)
f(1, 2)
f(1, 2, 3, 4)
f(1, 2, x=7, y=8)
f(1, 2, 3, 4, x=7, y=8)

输出：

1 2 () {}
1 2 (3, 4) {}
1 2 () {'x': 7, 'y': 8}
1 2 (3, 4) {'x': 7, 'y': 8}

2. Lambda 函数

Python 中支持 Lambda 函数语法，用来方便创建简单的函数，语法结构如下：

def plus(x, y):
    return x + y

# 等价于

lambda_plus = lambda x, y: x + y

print(plus(1, 2) == lambda_plus(1, 2))

输出：

True

3. 真假值判断

在 Python 中，除了 bool 类型的 True、False，还有很多其他值可以直接在 if、while 等语句或其他用于真假值判断：

for v in [ 0, 1, 2]:
    result = bool(v)
    print(f'数字 {v} 会被判断为：{result}')

for v in [ 'false', '' ]:
    result = bool(v)
    print(f'字符串 "{v}" 会被判断为：{result}')

for v in [ [1, 2, 3], [] ]:
    result = bool(v)
    print(f'列表 {v} 会被判断为：{result}')

for v in [ (1, 2, 3), tuple() ]:
    result = bool(v)
    print(f'元组 {v} 会被判断为：{result}')

for v in [ { 'a': 1}, {} ]:
    result = bool(v)
    print(f'字典 {v} 会被判断为：{result}')

for v in [ {1, 2, 3}, set() ]:
    result = bool(v)
    print(f'集合 {v} 会被判断为：{result}')

输出：

数字 0 会被判断为：False
数字 1 会被判断为：True
数字 2 会被判断为：True
字符串 "false" 会被判断为：True
字符串 "" 会被判断为：False
列表 [1, 2, 3] 会被判断为：True
列表 [] 会被判断为：False
元组 (1, 2, 3) 会被判断为：True
元组 () 会被判断为：False
字典 {'a': 1} 会被判断为：True
字典 {} 会被判断为：False
集合 {1, 2, 3} 会被判断为：True
集合 set() 会被判断为：False

4. 内置函数

Python 中内置了很多有用的函数，通过这些函数可以快速达到想要的目的，无需编写复杂的代码。

4.1 通用类

print('生成元素为 [0, 3) 区间的列表生成器：')
for x in range(3):
    print(f'  {x}')

print('生成元素为 [3, 5) 区间的列表生成器：')
for x in range(3, 5):
    print(f'  {x}')

print('生成元素为 [3, 10) 区间的列表生成器，步进为 2：')
for x in range(3, 10, 2):
    print(f'  {x}')

value = [ 'a', 'b', 'c' ]

print('返回类型：', type(value))
print('返回属性：', dir(value))
print('返回长度：', len(value))

print('返回附带索引的序列：')
for i, x in enumerate(value):
    print(f'  value[{i}] = {x}')

value = [ 'a', 'b', 'c' ]
other = [ 'x', 'y', 'z' ]
result = list(zip(value, other))
print('返回两个列表的配对列表：', result)

l = [ 1, 2, 3, 4, 5 ]
result = list(map(lambda x: x ** 2, l))
print('返回其中元素依次被指定函数处理后的新列表：', result)
result = list(filter(lambda x: x % 2 == 0, l))
print('返回其中元素被指定函数判断为 True 的新列表：', result)

range(..), zip(...), map(...)，filter(...) 函数返回值为可迭代对象，可以直接用于循环，也可以使用 list(...) 转换为列表

输出：

生成元素为 [0, 3) 区间的列表生成器：
  0
  1
  2
生成元素为 [3, 5) 区间的列表生成器：
  3
  4
生成元素为 [3, 10) 区间的列表生成器，步进为 2：
  3
  5
  7
  9
返回类型： <class 'list'>
返回属性： ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
返回长度： 3
返回附带索引的序列：
  value[0] = a
  value[1] = b
  value[2] = c
返回两个列表的配对列表： [('a', 'x'), ('b', 'y'), ('c', 'z')]
返回其中元素依次被指定函数处理后的新列表： [1, 4, 9, 16, 25]
返回其中元素被指定函数判断为 True 的新列表： [2, 4]

4.2 数学类

print('返回绝对值        ：', abs(-5))
print('返回四舍五入取整  ：', round(2.6))
print('返回指数          ：', pow(2, 3))
print('返回除法的商和余数：', divmod(9, 2))
print('返回最大值        ：', max([1, 5, 2, 9]))
print('返回最小值        ：', min([9, 2, -4, 2]))
print('返回求和          ：', sum([2, -1, 9, 12]))

输出：

返回绝对值        ： 5
返回四舍五入取整  ： 3
返回指数          ： 8
返回除法的商和余数： (4, 1)
返回最大值        ： 9
返回最小值        ： -4
返回求和          ： 22

4.3 转换类

print('转换为整数               ：', int("5"))
print('转换为浮点数             ：', float(2))
print('转换为字符串             ：', str(2.3))
print('转换为布尔值             ：', bool(0))
print('转换为 2 进制            ：', bin(56))
print('转换为 8 进制数          ：', oct(56))
print('转换为 16 进制数         ：', hex(56))
print('返回字符对应的 ASCII 码值：', ord("A"))
print('返回 ASCII 码值对应的字符：', chr(65))

输出：

转换为整数               ： 5
转换为浮点数             ： 2.0
转换为字符串             ： 2.3
转换为布尔值             ： False
转换为 2 进制            ： 0b111000
转换为 8 进制数          ： 0o70
转换为 16 进制数         ： 0x38
返回字符对应的 ASCII 码值： 65
返回 ASCII 码值对应的字符： A

4.4 初始化类

print('初始化列表：', list((1, 2, 3)))
print('初始化元组：', tuple([2, 3, 4]))
print('初始化字典：', dict(a=1, b="hello", c=True))
print('初始化集合：', set([5, 6, 7]))

输出：

初始化列表： [1, 2, 3]
初始化元组： (2, 3, 4)
初始化字典： {'a': 1, 'b': 'hello', 'c': True}
初始化集合： {5, 6, 7}

4.5 类、对象操作类

print('判断对象是否为某个类    ：', isinstance(100, int))
print('判断对象是否为一组类之一：', isinstance(100, (int, float)))

class User(object):
    pass

class Student(User):
    pass

print('判断类是否为另一个类的子类：', issubclass(Student, User))

输出：

判断对象是否为某个类    ： True
判断对象是否为一组类之一： True
判断类是否为另一个类的子类： True

5. 格式化字符串

result = '你好，我是 %s，我今年 %d 岁' % ('张三', 25)
print('旧版元组方式格式化（不推荐）：', result)

result = '你好，我是 %(name)s，我今年 %(age)d 岁' % { 'name': '张三', 'age' : 25 }
print('旧版字典方式格式化（不推荐）：', result)

result = '你好，我是 {}，我今年 {} 岁'.format('张三', 25)
print('format 函数格式化，参数按照顺序排列：', result)

result = '你好，我是 {0}，我今年 {1} 岁，{1} 年前出生'.format('张三', 25)
print('format 函数格式化，参数按照索引填入：', result)

params = {
    'name': '张三',
    'age' : 25,
    'job' : '学生',
}
result = '你好，我是 {name}，我今年 {age} 岁，{age} 年前出生'.format(**params)
print('format 函数格式化，参数按照字典 Key 填入（多余参数不影响）：', result)

result = '你好，我是 {name}，我今年 {age} 岁，{age} 年前出生'.format(name='张三', age=25, job='学生')
print('format 函数格式化，参数按照 参数名=参数值 填入（多余参数不影响）：', result)

name = '张三'
age  = 25
result = f'你好，我是 "{name}"，我今年 {age} 岁，{age} 年前出生'
print('最新 f-string 方式格式化（推荐）：', result)

使用 f-string 时，注意单双引号，具体可以参考「Python 基础 / 基本数据类型 / 字符串 str」

输出：

旧版元组方式格式化（不推荐）： 你好，我是 张三，我今年 25 岁
旧版字典方式格式化（不推荐）： 你好，我是 张三，我今年 25 岁
format 函数格式化，参数按照顺序排列： 你好，我是 张三，我今年 25 岁
format 函数格式化，参数按照索引填入： 你好，我是 张三，我今年 25 岁，25 年前出生
format 函数格式化，参数按照字典 Key 填入（多余参数不影响）： 你好，我是 张三，我今年 25 岁，25 年前出生
format 函数格式化，参数按照 参数名=参数值 填入（多余参数不影响）： 你好，我是 张三，我今年 25 岁，25 年前出生
最新 f-string 方式格式化（推荐）： 你好，我是 "张三"，我今年 25 岁，25 年前出生

6. 字符串方法

字符串在 Python 中是非常常用的对象。Python 中字符串内置了丰富的实用方法。

s = 'Hello, world! Python world!'
sub = 'world'
print('返回指定字符串出现次数                                     ：', s.count(sub))
print('返回指定字符串第一次出现的索引（找不到返回 -1）            ：', s.find(sub))
print('返回指定字符串【从右开始】第一次出现的索引（找不到返回 -1）：', s.rfind(sub))
print('返回指定字符串第一次出现的索引（找不到则报错）             ：', s.index(sub))
print('返回指定字符串【从右开始】第一次出现的索引（找不到则报错） ：', s.rindex(sub))

print('判断字符串是否只包含字母、数字  ：', 'abcd1234'.isalnum())
print('判断字符串是否只包含字母        ：', 'abcd'.isalpha())
print('判断字符串是否只包含数字        ：', '1234'.isdigit())
print('判断字符串是否每个词都以大写开头：', 'Tom Jerry'.istitle())
print('判断字符串是否为全空格          ：', '   '.isspace())
print('判断字符串是否为全小写          ：', 'TOM JERRY'.isupper())
print('判断字符串是否为全大写          ：', 'tom jerry'.islower())

s = 'apple,microsoft,ibm,intel,amd'
print('将字符串按照指定分隔符分割                               ：', s.split(','))
print('将字符串按照指定分隔符分割，切最多切分数 3 次            ：', s.split(',', 3))
print('将字符串按【从右开始】照指定分隔符分割                   ：', s.rsplit(','))
print('将字符串按【从右开始】照指定分隔符分割，切最多切分数 3 次：', s.rsplit(',', 3))

print('将列表以字符串为分隔符合并  ：', ', '.join(['Tom', 'Jerry', 'John']))
print('将列表以空字符串为分隔符合并：', ''.join(['Tom', 'Jerry', 'John']))
print(f'去除字符串前后空格          ：【{"  abc   ".strip()}】')
print(f'去除字符串前后空格          ：【{"  abc   ".rstrip()}】')
print(f'去除字符串前后空格          ：【{"  abc   ".lstrip()}】')
print(f'去除字符串前后指定内容      ：【{"xyzabc789".strip("xyz789")}】')
print(f'去除字符串前后指定内容      ：【{"xyzabc789".rstrip("xyz789")}】')
print(f'去除字符串前后指定内容      ：【{"xyzabc789".lstrip("xyz789")}】')
print('替换字符串中指定内容        ：', 'abc123abc'.replace('123', 'xyz'))
print('将字符串中第一个字母大写    ：', 'hello, world'.capitalize())
print('将字符串全部转为大写        ：', 'Hello, World'.upper())
print('将字符串全部转为小写        ：', 'Hello, World'.lower())
print('将字符串大小写互换          ：', 'Hello, World'.swapcase())
print('将字符串中每个单词首字母大写：', 'hello, world'.title())

print(f'将字符串以指定宽度居中                ：【{"abc".center(10)}】')
print(f'将字符串以指定宽度居左                ：【{"abc".ljust(10)}】')
print(f'将字符串以指定宽度居右                ：【{"abc".rjust(10)}】')
print(f'将字符串以指定宽度居左，并填充指定内容：【{"abc".ljust(10, "_")}】')
print(f'将字符串以指定宽度居中，并填充指定内容：【{"abc".center(10, "_")}】')
print(f'将字符串以指定宽度居右，并填充指定内容：【{"abc".rjust(10, "_")}】')

输出：

返回指定字符串出现次数                                     ： 2
返回指定字符串第一次出现的索引（找不到返回 -1）            ： 7
返回指定字符串【从右开始】第一次出现的索引（找不到返回 -1）： 21
返回指定字符串第一次出现的索引（找不到则报错）             ： 7
返回指定字符串【从右开始】第一次出现的索引（找不到则报错） ： 21
判断字符串是否只包含字母、数字  ： True
判断字符串是否只包含字母        ： True
判断字符串是否只包含数字        ： True
判断字符串是否每个词都以大写开头： True
判断字符串是否为全空格          ： True
判断字符串是否为全小写          ： True
判断字符串是否为全大写          ： True
将字符串按照指定分隔符分割                               ： ['apple', 'microsoft', 'ibm', 'intel', 'amd']
将字符串按照指定分隔符分割，切最多切分数 3 次            ： ['apple', 'microsoft', 'ibm', 'intel,amd']
将字符串按【从右开始】照指定分隔符分割                   ： ['apple', 'microsoft', 'ibm', 'intel', 'amd']
将字符串按【从右开始】照指定分隔符分割，切最多切分数 3 次： ['apple,microsoft', 'ibm', 'intel', 'amd']
将列表以字符串为分隔符合并  ： Tom, Jerry, John
将列表以空字符串为分隔符合并： TomJerryJohn
去除字符串前后空格          ：【abc】
去除字符串前后空格          ：【  abc】
去除字符串前后空格          ：【abc   】
去除字符串前后指定内容      ：【abc】
去除字符串前后指定内容      ：【xyzabc】
去除字符串前后指定内容      ：【abc789】
替换字符串中指定内容        ： abcxyzabc
将字符串中第一个字母大写    ： Hello, world
将字符串全部转为大写        ： HELLO, WORLD
将字符串全部转为小写        ： hello, world
将字符串大小写互换          ： hELLO, wORLD
将字符串中每个单词首字母大写： Hello, World
将字符串以指定宽度居中                ：【   abc    】
将字符串以指定宽度居左                ：【abc       】
将字符串以指定宽度居右                ：【       abc】
将字符串以指定宽度居左，并填充指定内容：【abc_______】
将字符串以指定宽度居中，并填充指定内容：【___abc____】
将字符串以指定宽度居右，并填充指定内容：【_______abc】

7. 列表方法

列表在 Python 中是非常常用的对象。Python 中列表内置了丰富的实用方法。

元组由于和列表类似，一些不改变对象本身的方法同样也适用于元组

l = [True, 1, "hello!", False]

print('判断列表中元素个数        ：', len(l))
print('判断列表中元素是否都为真  ：', all(l))
print('判断列表中元素是否有一为真：', any(l))

l = [3, 2, 1]
print('返回列表中的最小值：', min(l))
print('返回列表中的最大值：', max(l))
print('返回列表中的元素合：', sum(l))
print('返回排序后的新列表：', sorted(l))
print('返回倒序后的新列表：', list(reversed(l)))

l = [3, 3, 2, 1]
print('返回列表中指定元素个数            ：', l.count(3))
print('返回列表中指定元素第一次出现的索引：', l.index(2))

l.sort()
print('将本列表排序：', l)

l.reverse()
print('将本列表倒序：', l)

l.extend([7, 8, 9])
print('向本列表拼接另一个列表：', l)

l.append(10)
print('向本列表追加元素：', l)

x = l.pop()
print('从本列表弹出元素：', l, x)

del l[0]
print('从本列表删除指定索引的元素：', l)

输出：

判断列表中元素个数        ： 4
判断列表中元素是否都为真  ： False
判断列表中元素是否有一为真： True
返回列表中的最小值： 1
返回列表中的最大值： 3
返回列表中的元素合： 6
返回排序后的新列表： [1, 2, 3]
返回倒序后的新列表： [1, 2, 3]
返回列表中指定元素个数            ： 2
返回列表中指定元素第一次出现的索引： 2
将本列表排序： [1, 2, 3, 3]
将本列表倒序： [3, 3, 2, 1]
向本列表拼接另一个列表： [3, 3, 2, 1, 7, 8, 9]
向本列表追加元素： [3, 3, 2, 1, 7, 8, 9, 10]
从本列表弹出元素： [3, 3, 2, 1, 7, 8, 9] 10
从本列表删除指定索引的元素： [3, 2, 1, 7, 8, 9]

sorted(...) 和 reversed(...) 函数返回新列表，并不改变原来的列表。但 list.sort() 和 list.reverse() 则是在原来的列表上排序，不产生新列表

reversed(...) 和 range(...) 等函数一样，实际返回的是一个生成器。如确实需要列表，可以使用 list(...) 函数转换为实际的列表