python简易笔记

类型

在python中，一切都是对象，每个对象都有一个类型。

检查对象类型的常用方式。

  1. <type> = type(<el>) 或 <el>.__class__：

这两行代码都是获取对象的类型。type(<el>)会返回<el>的类型，而<el>.__class__会返回类类型。这两种方法都可以用来确定一个对象的类型。

例如，如果我们有一个字符串"Hello, world!"，我们可以这样获取它的类型：

s = "Hello, world!"
print(type(s))  # 输出：<class 'str'>
print(s.__class__)  # 输出：<class 'str'>

这两行代码都会输出<class 'str'>，表示s是一个字符串类型。

  1. <bool> = isinstance(<el>, <type>) 或 issubclass(type(<el>), <type>)：

这两行代码都是检查一个对象是否是特定类型或其子类型的实例。isinstance(<el>, <type>)会检查<el>是否是<type>或其子类型的实例，而issubclass(type(<el>), <type>)会检查<el>的类型是否是<type>或其子类型。

例如，如果我们有一个列表[1, 2, 3, 4]，我们可以这样检查它是否是列表类型或其子类型的实例：

lst = [1, 2, 3, 4]
print(isinstance(lst, list))  # 输出：True
print(issubclass(type(lst), list))  # 输出：True

列表

列表的切片（slicing）操作：

  • from_inclusive（包含）是切片开始的索引，如果省略，默认为 0。
  • to_exclusive（不包含）是切片结束的索引，如果省略，默认为列表的长度。
  • step 是切片的步长，如果省略，默认为 1。

例子：

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 获取索引为 2 到 5（不包含）的元素
sub_list = my_list[2:5]
print(sub_list)  # 输出：[2, 3, 4]


# 获取索引为 2 到 8（不包含）的元素，步长为 2
sub_list = my_list[2:8:2]
print(sub_list)  # 输出：[2, 4, 6]

向列表添加元素

<list>.append(<el>)：这个方法将一个元素 <el> 添加到 <list> 的末尾。这个元素可以是任何类型的数据，包括另一个列表.

例子：

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  
# 输出：[1, 2, 3, 4]

<list>.extend(<collection>)：这个方法将一个集合 <collection> 中的所有元素添加到 <list> 的末尾。这个集合可以是任何可迭代的对象，例如另一个列表、一个元组、一个字典等。

例子：

my_list = [1, 2, 3]
my_list.extend([4, 5, 6])
print(my_list)  
# 输出：[1, 2, 3, 4, 5, 6]

用于排序和反转列表的4种方法

1.<list>.sort()：这个方法会对 <list> 进行升序排序。这会直接修改原始列表，而不是创建一个新的列表。例如：

my_list = [3, 1, 4, 1, 5, 9]
my_list.sort()
print(my_list)  
# 输出：[1, 1, 3, 4, 5, 9]

2.<list>.reverse()：这个方法会将 <list> 中的元素顺序反转。这会直接修改原始列表，而不是创建一个新的列表。例如：

my_list = [1, 2, 3, 4, 5]
my_list.reverse()
print(my_list)  
# 输出：[5, 4, 3, 2, 1]

3.<list> = sorted(<collection>)：sorted() 函数会返回一个新的列表，这个列表包含 <collection> 中的所有元素，并且这些元素已经按升序排序。例如：

my_list = [3, 1, 4, 1, 5, 9]
sorted_list = sorted(my_list)
print(sorted_list)  
# 输出：[1, 1, 3, 4, 5, 9]
# 例子2
# 按照经纬度对过滤后的要素进行排序
filtered_features.sort(key=lambda x: (x['geometry']['coordinates'][0][0], x['geometry']['coordinates'][0][1]))

4.<iter> = reversed(<list>)：reversed() 函数会返回一个迭代器，这个迭代器会按逆序生成 <list> 中的元素。例如：

my_list = [1, 2, 3, 4, 5]
reversed_iter = reversed(my_list)
for i in reversed_iter:
    print(i, end=' ')  
# 输出：5 4 3 2 1

一些常用的列表语法糖

“语法糖”是一个编程术语，指的是一种编程语法，它并没有增加任何新的功能，但是可以使代码更易读、更易写。这种语法提供了一种更方便、更清晰的方式来表达一种已经存在的编程结构或操作。

  1. sum_of_elements = sum(<collection>)

    这段代码将计算集合（列表、元组等）中所有元素的总和。

    例子：

    numbers = [1, 2, 3, 4, 5]
sum_of_elements = sum(numbers)
print(sum_of_elements)  
# 输出：15

  2. elementwise_sum = [sum(pair) for pair in zip(list_a, list_b)]

    这段代码将两个列表中的对应元素相加。

    例子：

    list_a = [1, 2, 3]
list_b = [4, 5, 6]
elementwise_sum = [sum(pair) for pair in zip(list_a, list_b)]
print(elementwise_sum)  
# 输出：[5, 7, 9]

  3. sorted_by_second = sorted(<collection>, key=lambda el: el[1])

    这段代码将根据集合中每个元素的第二个值进行排序。

    例子：

    pairs = [(2, 3), (1, 2), (4, 1)]
sorted_by_second = sorted(pairs, key=lambda el: el[1])
print(sorted_by_second)  
# 输出：[(4, 1), (1, 2), (2, 3)]

  4. sorted_by_both = sorted(<collection>, key=lambda el: (el[1], el[0]))

    这段代码将根据集合中每个元素的第二个值和第一个值进行排序。

    例子：

    pairs = [(2, 3), (1, 2), (4, 1), (3, 2)]
sorted_by_both = sorted(pairs, key=lambda el: (el[1], el[0]))
print(sorted_by_both)  
# 输出：[(4, 1), (1, 2), (3, 2), (2, 3)]

  5. flatter_list = list(itertools.chain.from_iterable(<list>))

    这段代码将一个嵌套的列表（列表的列表）扁平化为一个单一的列表。

    例子：

    import itertools
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flatter_list = list(itertools.chain.from_iterable(nested_list))
print(flatter_list)  
# 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9]

  6. product_of_elems = functools.reduce(lambda out, el: out * el, <collection>)

    这段代码将计算集合中所有元素的乘积。

    例子：

    import functools
numbers = [1, 2, 3, 4, 5]
product_of_elems = functools.reduce(lambda out, el: out * el, numbers)
print(product_of_elems)  
# 输出：120

  7. list_of_chars = list(<str>)

    这段代码将一个字符串转换为一个字符列表。

    例子：

    my_string = "Hello"
list_of_chars = list(my_string)
print(list_of_chars)  
# 输出：['H', 'e', 'l', 'l', 'o']

列表的增删查改

.insert(, )

这个方法会在指定的索引位置插入元素，并将剩余的元素向右移动。

例子：

numbers = [1, 2, 3, 4, 5]
numbers.insert(2, 999)
print(numbers)  # 输出：[1, 2, 999, 3, 4, 5]

= .pop([])

这个方法会删除并返回指定索引位置的元素，如果没有指定索引，则默认删除并返回列表的最后一个元素。

例子：

numbers = [1, 2, 3, 4, 5]
last_element = numbers.pop()
print(last_element)  # 输出：5
print(numbers)  
# 输出：[1, 2, 3, 4]

= .count()

这个方法会返回指定元素在列表中的出现次数。这个方法也适用于字符串。

例子：

numbers = [1, 2, 3, 2, 2, 4, 5]
count_of_2 = numbers.count(2)
print(count_of_2)  # 输出：3

= .index()

这个方法会返回指定元素在列表中第一次出现的索引位置。如果元素不存在，则会抛出 ValueError。

例子：

numbers = [1, 2, 3, 2, 2, 4, 5]
index_of_3 = numbers.index(3)
print(index_of_3)  # 输出：2

.remove()

这个方法会删除列表中第一次出现的指定元素。如果元素不存在，则会抛出 ValueError。

例子：

numbers = [1, 2, 3, 2, 2, 4, 5]
numbers.remove(2)
print(numbers)  
# 输出：[1, 3, 2, 2, 4, 5]

.clear()

这个方法会删除列表中的所有元素。这个方法也适用于字典和集合。

例子：

numbers = [1, 2, 3, 4, 5]
numbers.clear()
print(numbers)  # 输出：[]

字典

获取字典信息的方式

  1. <view> = <dict>.keys()

    这个方法返回一个反映字典键的动态视图。如果字典改变，视图也会改变。

    例子：

    student = {'name': 'John', 'age': 15, 'grade': 'A'}
keys = student.keys()
print(keys)  
# 输出：dict_keys(['name', 'age', 'grade'])

  1. <view> = <dict>.values()

    这个方法返回一个反映字典值的动态视图。如果字典改变，视图也会改变。

    例子：

    student = {'name': 'Han Meimei', 'age': 18, 'grade': 'A'}
values = student.values()
print(values)  
# 输出：dict_values(['Han Meimei', 18, 'A'])

  1. <view> = <dict>.items()

    这个方法返回一个反映字典键值对的动态视图。每个键值对被表示为一个元组。如果字典改变，视图也会改变。

    例子：

    student = {'name': 'Li Ming', 'age': 15, 'grade': 'A'}
items = student.items()
print(items)  
# 输出：dict_items([('name', 'Li Ming'), ('age', 15), ('grade', 'A')])

获取或设置字典的值

  1. value = <dict>.get(key, default=None)

    这个方法用于获取字典中给定键的值。如果键不存在，那么返回默认值，如果没有指定默认值，则返回None。

    例子：

    student = {'name': 'John', 'age': 15}
value = student.get('grade', 'A')
print(value)  # 输出：'A'

  1. value = <dict>.setdefault(key, default=None)

    这个方法用于获取字典中给定键的值。如果键不存在，那么将默认值写入字典，并返回默认值，如果没有指定默认值，则写入并返回None。

    例子：

    student = {'name': 'John', 'age': 15}
value = student.setdefault('grade', 'A')
print(value)  # 输出：'A'
print(student)  
# 输出：{'name': 'John', 'age': 15, 'grade': 'A'}

  1. <dict> = collections.defaultdict(<type>)

    这个方法返回一个默认字典，如果请求的键不存在，那么返回给定类型的默认值。<type>应该是一个无参数的函数，用于生成默认值。

    例子：

    from collections import defaultdict
count = defaultdict(int)
for letter in 'hello':
    count[letter] += 1
print(count)  
# 输出：defaultdict(<class 'int'>, {'h': 1, 'e': 1, 'l': 2, 'o': 1})

  1. <dict> = collections.defaultdict(lambda: 1)

    这个方法也返回一个默认字典，但是这次我们使用一个lambda函数来生成默认值，这个lambda函数总是返回1。

    例子：

    from collections import defaultdict
count = defaultdict(lambda: 1)
for letter in 'hello':
    count[letter] += 1
print(count)  # 输出：defaultdict(<function <lambda> at 0x7f8c0c3d2f70>, {'h': 2, 'e': 2, 'l': 3, 'o

创建字典的方法

  1. <dict> = dict(<collection>)

    这个方法用于从键值对的集合创建一个字典。集合可以是一个列表的列表，也可以是一个元组的列表，只要每个内部列表或元组包含两个元素。

    例子：

    pairs = [('name', 'John'), ('age', 15), ('grade', 'A')]
student = dict(pairs)
print(student)  
# 输出：{'name': 'John', 'age': 15, 'grade': 'A'}

  2. <dict> = dict(zip(keys, values))

    这个方法用于从两个集合创建一个字典，一个集合作为键，另一个集合作为值。这两个集合的长度必须相等。

    例子：

    keys = ['name', 'age', 'grade']
values = ['John', 15, 'A']
student = dict(zip(keys, values))
print(student)  
# 输出：{'name': 'John', 'age': 15, 'grade': 'A'}

  3. <dict> = dict.fromkeys(keys [, value])

    这个方法用于从键的集合创建一个字典。所有的键都有相同的值，如果没有指定值，则默认为None。

    例子：

    keys = ['name', 'age', 'grade']
student = dict.fromkeys(keys, 'unknown')
print(student)  
# 输出：{'name': 'unknown', 'age': 'unknown', 'grade': 'unknown'}

对字典进行修改、查询和过滤

  1. <dict>.update(<dict>)

    这个方法用于添加新的键值对到字典中。如果新的字典中的键在原字典中已经存在，那么它会替换原字典中的键值对。

    例子：

    student = {'name': 'John', 'age': 15}
student.update({'grade': 'A', 'age': 16})
print(student)  # 输出：{'name': 'John', 'age': 16, 'grade': 'A'}

  1. value = <dict>.pop(key)

    这个方法用于移除字典中的一个键值对，并返回该键对应的值。如果键不存在，那么会抛出KeyError。

    例子：

    student = {'name': 'John', 'age': 15, 'grade': 'A'}
age = student.pop('age')
print(age)  # 输出：15
print(student)  # 输出：{'name': 'John', 'grade': 'A'}

  1. {k for k, v in <dict>.items() if v == value}

    这是一个字典推导式，用于获取所有值等于给定值的键。结果是一个集合。

    例子：

    student = {'name': 'John', 'age': 15, 'grade': 'A', 'level': 'A'}
keys = {k for k, v in student.items() if v == 'A'}
print(keys)  # 输出：{'grade', 'level'}

  1. {k: v for k, v in <dict>.items() if k in keys}

    这也是一个字典推导式，用于根据给定的键集合过滤字典。结果是一个新的字典。

    例子：

    student = {'name': 'John', 'age': 15, 'grade': 'A', 'level': 'A'}
keys = ['name', 'grade']
filtered_student = {k: v for k, v in student.items() if k in keys}
print(filtered_student)  # 输出：{'name': 'John', 'grade': 'A'}

集合

集合是一个无序的元素集，每个元素唯一，不可重复。

s = set()  # 创建一个空集合
print(s)  # 输出：set()

这里需要注意的是，尽管在Python中 {} 用于创建空字典，但如果在 {} 中放入一些用逗号分隔的值，Python会创建一个集合，而不是字典。例如：

s = {1, 2, 3}  # 创建一个包含三个元素的集合
print(s)  # 输出：{1, 2, 3}

但如果想创建一个空集合，那必须使用 set()，而不能使用 {}，因为 {} 在Python中表示一个空的字典：

d = {}  # 创建一个空字典，而不是集合
print(d)  # 输出：{}

1.<set> = <set>.union(<coll.>) 或 <set> | <set>：这两种操作都是用来获取两个集合的并集。并集意味着获取所有在两个集合中出现的元素，重复的元素只会出现一次。

例如：

set1 = {1, 2, 3}
set2 = {3, 4, 5}
set3 = set1.union(set2)
# 或者
set3 = set1 | set2
print(set3)  # 输出：{1, 2, 3, 4, 5}

2.<set> = <set>.intersection(<coll.>) 或 <set> & <set>：这两种操作都是用来获取两个集合的交集。交集意味着获取在两个集合中都出现的元素。

例如：

set1 = {1, 2, 3}
set2 = {3, 4, 5}
set3 = set1.intersection(set2)
# 或者
set3 = set1 & set2
print(set3)  # 输出：{3}

3. = .difference()或 - `：这两种操作都是用来获取两个集合的差集。差集意味着获取在第一个集合中出现，但不在第二个集合中出现的元素。

例如：

set1 = {1, 2, 3}
set2 = {3, 4, 5}
set3 = set1.difference(set2)
# 或者
set3 = set1 - set2
print(set3)  # 输出：{1, 2}

4.<set> = <set>.symmetric_difference(<coll.>) 或 <set> ^ <set>：这两种操作都是用来获取两个集合的对称差集。对称差集意味着获取只在一个集合中出现的元素。

例如：

set1 = {1, 2, 3}
set2 = {3, 4, 5}
set3 = set1.symmetric_difference(set2)
# 或者
set3 = set1 ^ set2
print(set3)  # 输出：{1, 2, 4, 5}

5.<bool> = <set>.issubset(<coll.>) 或 <set> <= <set>：这两种操作都是用来检查一个集合是否是另一个集合的子集。子集意味着第一个集合中的所有元素都出现在第二个集合中。

例如：

set1 = {1, 2}
set2 = {1, 2, 3, 4, 5}
is_subset = set1.issubset(set2)
# 或者
is_subset = set1 <= set2
print(is_subset)  # 输出：True

6.<bool> = <set>.issuperset(<coll.>) 或 <set> >= <set>：这两种操作都是用来检查一个集合是否是另一个集合的超集。超集意味着第二个集合中的所有元素都出现在第一个集合中。

例如：

set1 = {1, 2, 3, 4, 5}
set2 = {1, 2}
is_superset = set1.issuperset(set2)
# 或者
is_superset = set1 >= set2
print(is_superset)  # 输出：True

元组

元组是一个不可变的列表。

如何定义一个元组

  1. 定义一个空的元组：

    empty_tuple = ()

    这将创建一个没有元素的元组。

  2. 定义一个只有一个元素的元组：

    single_element_tuple = (1,)

    注意，如果你省略了末尾的逗号，Python会将其解释为一个数值，而不是一个元组。例如，(1)在Python中表示的是数值1，而不是一个包含1的元组。

  3. 定义一个有多个元素的元组：

    multi_element_tuple = (1, 2, 3)

    这将创建一个包含三个元素的元组。你可以添加任意数量的元素到元组中，只要它们被逗号分隔开。

注意，元组是不可变的，这意味着一旦你创建了一个元组，就不能修改它的内容。这包括添加新的元素，删除已有的元素，或者改变元素的顺序。

字符串

不可变的字符序列。

移除字符串两端的字符

strip()是Python中的一个字符串方法，用于移除字符串两端的字符。

1.<str> = <str>.strip()：这个方法会移除字符串两端的所有空白字符（包括空格、换行\n、制表符\t等）。

例如：

s = "   Hello, LiMing!   "
s = s.strip()
print(s)  # 输出："Hello, LiMing!"

2.<str> = <str>.strip('<chars>')：这个方法会移除字符串两端的指定字符。如果你传入一个字符串参数，它会移除所有在这个字符串中出现的字符。此外，还有lstrip()和rstrip()方法，分别用于移除字符串左端（前端）和右端（后端）的字符。

例如：

s = "www.remotesensing.com"
s = s.strip("w.com")
print(s)  # 输出："remotesensing"

字符串的分割和连接

1.<list> = <str>.split()：这个方法会根据一个或多个空白字符（包括空格、换行\n、制表符\t等）来分割字符串，并返回一个包含分割后的子字符串的列表。

例如：

s = "Hello, world! How are you?"
lst = s.split()
print(lst)  # 输出：['Hello,', 'world!', 'How', 'are', 'you?']

2.<list> = <str>.split(sep=None, maxsplit=-1)：这个方法会根据sep参数指定的字符来分割字符串。maxsplit参数指定了分割的最大次数。如果sep为None，则默认根据空白字符分割；如果maxsplit为-1，则表示没有分割次数的限制。

例如：

s = "apple,banana,cherry,dates"
lst = s.split(sep=",", maxsplit=2)
print(lst)  # 输出：['apple', 'banana', 'cherry,dates']

3.<list> = <str>.splitlines(keepends=False)：这个方法会根据换行符来分割字符串，并返回一个包含分割后的子字符串的列表。keepends参数指定是否保留换行符。

例如：

s = "Hello\nworld!\nHow\nare\nyou?"
lst = s.splitlines()
print(lst)  # 输出：['Hello', 'world!', 'How', 'are', 'you?']

4.<str> = <str>.join(<coll_of_strings>)：这个方法会使用指定的字符串作为分隔符，将一个字符串的集合（如列表或元组）连接成一个新的字符串。

例如：

lst = ['Hello', 'world!', 'How', 'are', 'you?']
s = " ".join(lst)
print(s)  # 输出："Hello world! How are you?"

字符串方法和操作符

1.<bool> = <sub_str> in <str>：这个操作会检查字符串是否包含子字符串，如果包含则返回True，否则返回False。

例如：

s = "Hello, world!"
print("world" in s)  # 输出：True
print("goodbye" in s)  # 输出：False

2.<bool> = <str>.startswith(<sub_str>)：这个方法会检查字符串是否以子字符串开头，如果是则返回True，否则返回False。你还可以传入一个字符串的元组，来检查字符串是否以元组中的任何一个字符串开头。

例如：

s = "Hello, world!"
print(s.startswith("Hello"))  # 输出：True
print(s.startswith(("world", "goodbye")))  # 输出：False

3.<int> = <str>.find(<sub_str>)：这个方法会返回子字符串首次出现的位置的索引，如果字符串中不包含子字符串，则返回-1。

例如：

s = "Hello, world!"
print(s.find("world"))  # 输出：7
print(s.find("goodbye"))  # 输出：-1

4.<int> = <str>.index(<sub_str>)：这个方法和find()方法类似，都是返回子字符串首次出现的位置的索引，但是如果字符串中不包含子字符串，index()方法会抛出一个ValueError异常。

例如：

s = "Hello, world!"
print(s.index("world"))  # 输出：7
# print(s.index("goodbye"))  # 这行代码会抛出 ValueError: substring not found

修改字符串的大小写

<str> = <str>.lower()：这个方法会将字符串中的所有大写字符转换为小写，并返回新的字符串。

类似的方法还有upper()（将所有字符转换为大写）、capitalize()（将第一个字符转换为大写，其余字符转换为小写）和title()（将每个单词的第一个字符转换为大写，其余字符转换为小写）。

例如：

s = "Hello, WORLD!"
print(s.lower())  # 输出："hello, world!"
print(s.upper())  # 输出："HELLO, WORLD!"
print(s.capitalize())  # 输出："Hello, world!"
print(s.title())  # 输出："Hello, World!"

替换字符串中的子字符串

<str> = <str>.replace(old, new [, count])：这个方法会将字符串中的old子字符串替换为new子字符串，并返回新的字符串。count参数指定了替换的最大次数，如果省略count参数，或者count为负数，则替换所有的old子字符串。

例如：

s = "Hello, world! world!"
print(s.replace("world", "everyone"))  # 输出："Hello, everyone! everyone!"
print(s.replace("world", "everyone", 1))  # 输出："Hello, everyone! world!"

转换Unicode字符和对应的整数编码

1.<str> = chr(<int>)：这个函数会返回对应整数编码的Unicode字符。

例如：

print(chr(65))  # 输出："A"
print(chr(20013))  # 输出："中"

2.<int> = ord(<str>)：这个函数会返回对应Unicode字符的整数编码。注意，这个函数只接受单个字符作为参数。

例如：

print(ord("A"))  # 输出：65
print(ord("中"))  # 输出：20013

字符串属性方法

1.<bool> = <str>.isdecimal()：这个方法检查字符串是否只包含十进制数字。这包括从0到9的所有数字，以及其他语言中的数字，例如印地语的[०-९]和阿拉伯语的[٠-٩]。如果字符串为空或包含非十进制数字的字符，该方法返回False。

例如：

print("12345".isdecimal())  # 输出：True
print("12345.67".isdecimal())  # 输出：False
print("१२३४५".isdecimal())  # 输出：True

2.<bool> = <str>.isdigit()：这个方法检查字符串是否只包含数字字符。这包括十进制数字、上标和下标数字（例如²和³）、以及其他语言中的数字。如果字符串为空或包含非数字的字符，该方法返回False。

例如：

print("12345".isdigit())  # 输出：True
print("12345.67".isdigit())  # 输出：False
print("²³".isdigit())  # 输出：True

3.<bool> = <str>.isnumeric()：这个方法检查字符串是否只包含数字字符。这包括十进制数字、上标和下标数字、分数（例如¼、½和¾）以及其他语言中的数字，例如中文数字（零、一、二等）。如果字符串为空或包含非数字的字符，该方法返回False。

例如：

print("12345".isnumeric())  # 输出：True
print("12345.67".isnumeric())  # 输出：False
print("½".isnumeric())  # 输出：True
print("一二三".isnumeric())  # 输出：True

4. = .isalnum()`：这个方法检查字符串是否只包含字母和数字。这包括拉丁字母（A-Z和a-z）、数字以及其他语言中的字母和数字。如果字符串为空或包含非字母或非数字的字符，该方法返回False。

例如：

print("abc123".isalnum())  # 输出：True
print("abc 123".isalnum())  # 输出：False

5.<bool> = <str>.isprintable()：这个方法检查字符串是否只包含可打印的字符。这包括字母、数字、标点符号、空格以及其他可打印的字符。如果字符串包含控制字符或其他非打印字符，该方法返回False。

例如：

print("Hello, world!".isprintable())  # 输出：True
print("Hello,\nworld!".isprintable())  # 输出：False

6.<bool> = <str>.isspace()：这个方法检查字符串是否只包含空白字符。这包括空格、制表符、换行符、回车符、换页符以及其他空白字符。如果字符串为空或包含非空白字符，该方法返回False。

例如：

print(" \t\n".isspace())  # 输出：True
print(" \t\na".isspace())  # 输出：False

range函数

range()函数在Python中用于生成一个不可变的整数序列。这是一个内置函数，可以接受一到三个参数。以下是具体的用法：

  1. range(stop): 创建一个从0开始，到stop（不包括）结束的整数序列。例如：

    for i in range(5):
    print(i)

    输出将是：

    0
1
2
3
4

  2. range(start, stop): 创建一个从start（包括）开始，到stop（不包括）结束的整数序列。例如：

    for i in range(2, 5):
    print(i)

    输出将是：

    2
3
4

  3. range(start, stop, step): 创建一个从start（包括）开始，到stop（不包括）结束，步长为step的整数序列。例如：

    for i in range(2, 10, 2):
    print(i)

    输出将是：

    2
4
6
8

Enumerate 枚举

enumerate()函数是Python的内置函数，用于在遍历一个集合（例如列表、元组或字符串）时获取元素以及其索引。它返回一个枚举对象，其中包含索引和值的元组。这个函数非常有用，因为它允许你在遍历一个集合时同时获取索引和值，而不需要手动处理索引。

enumerate()函数可以接受两个参数：

  1. <collection>：需要遍历的集合。
  2. i_start（可选）：索引的起始值，默认为0。

以下是一个简单的例子：

English = ['LiMing', 'HanMeimei', 'ZhangSan']

for i, name in enumerate(English):
    print(f"Index: {i}, English: {name}")

输出将是：

Index: 0, English: LiMing
Index: 1, English: HanMeimei
Index: 2, English: ZhangSan

Iterator 迭代器

iter()和next()是Python中的内置函数，用于创建和操作迭代器。迭代器是一个可以记住遍历的位置的对象，它从集合的第一个元素开始访问，直到所有元素被访问完结束。

  1. iter(collection): 这个函数返回一个迭代器对象，可以遍历collection中的所有元素。如果collection已经是一个迭代器，那么iter()会返回未修改的迭代器。

    例如：

    my_list = [1, 2, 3, 4]
my_iter = iter(my_list)

print(next(my_iter))  # 输出：1
print(next(my_iter))  # 输出：2

  2. iter(function, to_exclusive): 这个函数返回一个迭代器，该迭代器会连续调用function，直到返回值等于to_exclusive为止。

    例如：

    import random
my_iter = iter(lambda: random.randint(0, 5), 2)

for num in my_iter:
    print(num)

    这个例子会打印出一系列随机数，直到2被打印出来为止。

  3. next(iter, default): 这个函数返回迭代器iter的下一个元素。如果迭代器已经耗尽（即没有更多的元素可以返回），那么它会引发StopIteration异常。如果提供了default参数，那么在迭代器耗尽时会返回default，而不是引发异常。

    例如：

    my_list = [1, 2, 3, 4]
my_iter = iter(my_list)

print(next(my_iter, 'No more elements'))  # 输出：1
print(next(my_iter, 'No more elements'))  # 输出：2
print(next(my_iter, 'No more elements'))  # 输出：3
print(next(my_iter, 'No more elements'))  # 输出：4
print(next(my_iter, 'No more elements'))  # 输出：No more elements

  4. list(iter): 这个函数返回一个列表，其中包含迭代器iter的所有元素。

    例如：

    my_iter = iter([1, 2, 3, 4])
my_list = list(my_iter)

print(my_list)  # 输出：[1, 2, 3, 4]

generator生成器

使用yield语句来生成值，每次调用next()时都会返回下一个值。

以下是如何使用这个生成器的例子：

def count(start, step):
    while True:
        yield start
        start += step

counter = count(10, 2)
print(next(counter))  # 输出：10
print(next(counter))  # 输出：12
print(next(counter))  # 输出：14

每次调用next(counter)时，生成器都会返回序列中的下一个值，并更新内部的状态，以便下次调用时能返回正确的值。

Regex 正则表达式

1.re.sub(pattern, repl, string, count=0, flags=0)

在字符串中查找与正则表达式模式匹配的所有子串，并用新的字符串替换它们。

示例：

import re  
  
text = "apple apple apple orange"  
new_text = re.sub(r'apple', 'banana', text)  
print(new_text)  # 输出: banana banana banana orange

2.re.findall(pattern, string, flags=0)

在字符串中查找所有与正则表达式模式匹配的子串，并返回一个列表。

示例：

import re  
  
text = "apple apple apple orange"  
matches = re.findall(r'apple', text)  
print(matches)  # 输出: ['apple', 'apple', 'apple']

3.re.split(pattern, string, maxsplit=0, flags=0)

通过正则表达式模式指定的分隔符来分割字符串。返回分割后的子串列表。

示例：

import re  
  
text = "apple,banana,orange"  
split_text = re.split(r',', text)  
print(split_text)  # 输出: ['apple', 'banana', 'orange']  
  
# 如果要保留分隔符，则需要后处理或使用其他方法

4.re.search(pattern, string, flags=0)

在字符串中查找与正则表达式模式匹配的第一个位置，并返回一个相应的匹配对象。如果没有找到匹配项，则返回None。

示例：

import re  
  
text = "apple apple apple orange"  
match = re.search(r'orange', text)  
if match:  
    print(match.group())  
    # 输出: orange

5.re.match(pattern, string, flags=0)

从字符串的开头开始匹配正则表达式模式。如果模式在字符串的起始位置匹配，则返回一个相应的匹配对象。否则，返回None。

示例：

import re  
  
text = "apple apple apple orange"  
match = re.match(r'apple', text)  
if match:  
    print(match.group())  # 输出: apple  
  
match = re.match(r'orange', text)  
if not match:  
    print("No match at the beginning.")  
    # 输出: No match at the beginning.

6.re.finditer(pattern, string, flags=0)

在字符串中查找所有与正则表达式模式匹配的子串，并返回一个迭代器，产生匹配对象。

示例：

import re  
  
text = "apple apple apple orange"  
matches = re.finditer(r'apple', text)  
for match in matches:  
    print(match.group())  
    # 输出: apple 三次

Match

关于re模块中Match对象的一些常见方法和它们的使用示例。这些方法和属性用于获取匹配的信息，比如整个匹配的内容、分组内容、匹配的开始和结束索引等。

1.Match.group()

返回整个匹配的子串。group(0)也返回同样的结果，因为0是默认的组号。

示例：

import re  
  
match = re.search(r'(\d+)-(\d+)', 'abc123-456def')  
if match:  
    print(match.group())       
    # 输出: '123-456'  
    
    print(match.group(0))      
    # 输出: '123-456' (与group()相同)

2.Match.group(n)

返回第n个括号中匹配到的内容。如果正则表达式中没有定义任何括号，则group(1)会引发IndexError。

示例：

import re  
  
match = re.search(r'(\d+)-(\d+)', 'abc123-456def')  
if match:  
    print(match.group(1))      
    # 输出: '123'  
    
    print(match.group(2))      
    # 输出: '456'

3.Match.groups()

返回一个包含所有括号中匹配到的内容的元组。如果没有括号，则返回一个空元组。

示例：

import re  
  
match = re.search(r'(\d+)-(\d+)', 'abc123-456def')  
if match:  
    print(match.groups())     
    # 输出: ('123', '456')

4.Match.start()

返回匹配子串在原始字符串中的起始索引。

示例：

import re  
  
match = re.search(r'\d+', 'abc123def')  
if match:  
    print(match.start())      
    # 输出: 3，因为'123'是从索引3开始的

5.Match.end()

返回匹配子串在原始字符串中的结束索引（不包括该索引处的字符）。

示例：

import re  
  
match = re.search(r'\d+', 'abc123def')  
if match:  
    print(match.end())        
    # 输出: 6，因为'123'在索引6处结束
    # 但索引6处的字符'd'不是匹配的一部分

特殊字符类的等价表示

  • \d 等同于 [0-9]，它匹配任何单个数字字符。
  • \w 等同于 [a-zA-Z0-9_]，它匹配任何单个字母数字字符（无论是大写还是小写）或下划线。
  • \s 匹配任何空白字符，包括空格、制表符、换行符、回车符、换页符和垂直制表符。它等同于字符类 [ \t\n\r\f\v]。

格式

字符串格式化方法

1.f-string（格式化字符串字面值）

从Python 3.6开始，可以使用f-string来格式化字符串。这种方法的优点是它简洁易读，并且支持在字符串内部直接执行表达式。

el_1 = 'hello'  
el_2 = 'world'  
str_value = f'{el_1}, {el_2}'  # 结果是 'hello, world'

2.str.format() 方法:

str.format() 方法允许您使用花括号 {} 作为占位符，并通过位置参数或关键字参数来填充这些占位符。

使用位置参数：

el_1 = 'hello'  
el_2 = 'world'  
str_value = '{}, {}'.format(el_1, el_2)  # 结果是 'hello, world'

使用关键字参数（命名参数）:

el_1 = 'hello'  
el_2 = 'world'  
str_value = '{0}, {a}'.format(el_1, a=el_2)  # 结果是 'hello, world'

这里，{0} 表示第一个位置参数，而 {a} 表示名为 a 的关键字参数。

3.% 运算符:

% 运算符是Python中较老的字符串格式化方法，现在通常被认为是不如 str.format() 或 f-string 的方法。但是，在某些情况下，特别是当与旧代码兼容时，它仍然很有用。

el_1 = 'hello'  
el_2 = 'world'  
str_value = '%s, %s' % (el_1, el_2)  # 结果是 'hello, world'

在选择使用哪种方法时，通常推荐使用 f-string，因为它简洁、易读，并且功能强大。然而，在需要向后兼容旧代码或特定库/框架的情况下，可能需要使用 str.format() 或 % 运算符。

Numbers 数字

数字类型

  1. 整数（<int>）:
    整数可以从浮点数、字符串或布尔值转换得到。

    int_from_float = int(3.14)      # 结果是 3  
int_from_str = int('123')       # 结果是 123  
int_from_bool = int(True)       # 结果是 1，因为True等价于1，False等价于0  
int_from_floor = math.floor(3.14)  # 结果是 3，使用math模块的floor函数

  2. 浮点数（<float>）:
    浮点数可以从整数、字符串或布尔值转换得到。另外，浮点数也可以由整数和指数（e±）表示。

    float_from_int = float(123)       # 结果是 123.0  
float_from_str = float('3.14')    # 结果是 3.14  
float_from_bool = float(False)    # 结果是 0.0  
float_from_exp = 1.23e4           # 结果是 12300.0

  3. 复数（<complex>）:
    复数可以由实部和虚部（imag）组成，也可以由整数或浮点数与j（虚数单位）结合表示。

    complex_from_zero = complex(0, 0)        # 结果是 0j  
complex_from_ints = complex(3, 4)        # 结果是 (3+4j)  
complex_from_floats = complex(3.0, 4.0)  # 结果是 (3+4j)  
complex_from_str = complex('3+4j')        # 结果是 (3+4j)

  4. 分数（<Fraction>）:
    分数来自fractions模块，可以由分子和分母组成。

    from fractions import Fraction  
fraction_from_zero = Fraction(0, 1)         # 结果是 0  
fraction_from_nums = Fraction(3, 4)         # 结果是 3/4  
# 也可以使用Fraction的命名参数  
fraction_from_kwargs = Fraction(numerator=3, denominator=4)  # 结果是 3/4

  5. 十进制数（<Decimal>）:
    十进制数来自decimal模块，常用于需要精确控制浮点数运算的场合。可以从字符串或整数转换。

    from decimal import Decimal  
decimal_from_str = Decimal('3.14')     # 结果是 Decimal('3.14')  
decimal_from_int = Decimal(123)        # 结果是 Decimal('123')  
# 使用tuple表示的方法较少见，通常不这么用  
# decimal_from_tuple = Decimal((1, (1, 2, 3), -2))  # 这表示 1.123

数学计算的几个内置函数

  1. pow(<num>, <num>) 或 ` \ `**

    这两个表达式都是用于计算幂的。pow 是一个函数，接受两个参数（基数和指数），并返回基数的指数次幂。<number> ** <number> 是幂运算符的语法。

    示例：

    result = pow(2, 3)  # 相当于 2 ** 3  
print(result)      # 输出 8

  2. abs(<num>)

    abs 函数用于计算一个数的绝对值。它接受一个数字（整数或浮点数）作为参数，并返回其绝对值。对于复数，abs 返回的是复数的模（magnitude）。

    示例：

    result = abs(-5)   # 绝对值  
print(result)     # 输出 5  
 
result_complex = abs(3+4j)  # 复数的模  
print(result_complex)      # 输出 5.0

  3. round(<num> [, ±ndigits])

    round 函数用于四舍五入浮点数。它接受两个参数：要四舍五入的数字和一个可选的位数参数。如果提供了位数参数，它会将数字四舍五入到指定的小数位数。如果位数参数是负数，则会将数字四舍五入到指定的十的整数幂的倍数。

    示例：

    result = round(3.14159, 2)  # 保留两位小数  
print(result)               # 输出 3.14  
 
result_negative_digits = round(126, -1)  # 四舍五入到最近的十的倍数  
print(result_negative_digits)            # 输出 130

math模块

常量

  • e: 自然对数的底数（约等于2.71828）。
  • pi: 圆周率（约等于3.14159）。
  • inf: 表示正无穷大的浮点数。
  • nan: 表示“不是一个数字”（Not a Number）的特殊浮点数值。

函数

  • isinf(x): 检查x是否为正无穷大或负无穷大。
  • isnan(x): 检查x是否为“不是一个数字”（NaN）。

注意：<el> == nan 总是返回False，因为NaN是一个特殊的值，与任何其他值（包括它自身）都不相等。为了检查一个数是否是NaN，应该使用isnan(x)函数。

  • sin(x), cos(x), tan(x): 分别计算正弦、余弦和正切值。这些函数默认接受弧度作为输入。
  • asin(x), acos(x), atan(x): 分别是sin, cos, tan的反函数，也称为反正弦、反余弦和反正切。这些函数返回弧度值。

另外：math模块还提供了degrees(x)和radians(x)函数，用于在度数和弧度之间进行转换。

  • log(x[, base]): 计算x的自然对数（以e为底），如果提供了base参数，则计算以base为底的对数。
  • log10(x): 计算x的以10为底的对数。
  • log2(x): 计算x的以2为底的对数。

示例

from math import e, pi, inf, nan, isinf, isnan, sin, cos, tan, asin, acos, atan, log, log10, log2  
  
# 常量示例  
print(e)           # 输出自然对数的底数  
print(pi)          # 输出圆周率  
  
# 函数示例  
print(isinf(inf))  # 输出True，因为inf是正无穷大  
print(isnan(nan))  # 输出True，因为nan是“不是一个数字”的特殊值  
  
# 三角函数示例  
print(sin(pi / 2))  # 输出1.0，因为sin(90度)等于1（转换为弧度后）  
print(cos(0))       # 输出1.0，因为cos(0度)等于1  
print(tan(pi / 4))  # 输出1.0，因为tan(45度)等于1（转换为弧度后）  
  
# 反三角函数示例  
print(asin(1))     # 输出1.5707963267948966（弧度），相当于90度  
print(acos(0))     # 输出1.5707963267948966（弧度），相当于90度  
print(atan(1))     # 输出0.7853981633974483（弧度），相当于45度  
  
# 对数函数示例  
print(log(e))       # 输出1.0，因为ln(e)等于1  
print(log10(100))   # 输出2.0，因为log10(100)等于2  
print(log2(8))      # 输出3.0，因为log2(8)等于3  
print(log(100, 10)) # 输出2.0，计算以10为底100的对数

random模块

random()

random()函数返回一个在[0.0, 1.0)范围内的随机浮点数。也就是说，它包括0.0但不包括1.0。

示例：

from random import random  
  
random_float = random()  
print(random_float)  # 输出类似 0.3456789

randint(a, b)

randint(a, b)函数返回一个在[a, b]范围内的随机整数，包括a和b。

示例：

from random import randint  
  
random_int = randint(1, 10)  # 生成1到10之间的随机整数  
print(random_int)  # 输出可能是 1, 2, ..., 10 中的任意一个

choice(seq)

choice(seq)函数从非空序列（例如列表、元组或字符串）中随机选择一个元素并返回。

示例：

from random import choice  
  
sequence = [1, 2, 3, 4, 5]  
random_element = choice(sequence)  
print(random_element)  # 输出可能是 1, 2, 3, 4, 5 中的任意一个

其他提到的函数

  • shuffle(list)：将列表的元素随机打乱。
  • gauss(mu, sigma)：返回一个具有指定平均值（mu）和标准差（sigma）的正态分布随机数。
  • triangular(low, high, mode)：返回一个在[low, high]范围内的随机浮点数，其分布是三角形分布，其中mode是众数（即最常见的值）。
  • seed(a=None, version=2)：为随机数生成器设置种子。如果提供了a，则使用它作为种子；否则，使用系统时间。设置种子可以确保随机数生成器的输出是可重复的。

内置函数

Lambda

没有参数的lambda函数

square_of_five = lambda: 5 ** 2  # 返回一个固定值 25  
print(square_of_five())  # 输出: 25

带有参数的lambda函数

add_two_numbers = lambda x, y: x + y  # 接收两个参数并返回它们的和  
print(add_two_numbers(3, 4))  # 输出: 7

推导式

# 列表推导：创建一个包含1到10的列表  
list_comp = [i+1 for i in range(10)]                   # 结果: [1, 2, ..., 10]  
  
# 生成器表达式：创建一个生成器，它生成6到9的数字  
gen_expr = (i for i in range(10) if i > 5)            # 结果: 类似iter([6, 7, 8, 9])，但它是生成器  
  
# 集合推导：创建一个包含5到14的集合（注意集合中元素唯一）  
set_comp = {i+5 for i in range(10)}                   # 结果: {5, 6, ..., 14}，但重复的元素只会出现一次  
  
# 字典推导：创建一个字典，其中键是0到9，值是键的两倍  
dict_comp = {i: i*2 for i in range(10)}

Map, Filter, Reduce

from functools import reduce  
  
# 使用map函数将range(10)中的每个元素加1  
# 结果类似于 iter([1, 2, ..., 10])  
mapped_iter = map(lambda x: x + 1, range(10))  


  
# 使用filter函数过滤出range(10)中大于5的元素  
# 结果类似于 iter([6, 7, 8, 9])  
filtered_iter = filter(lambda x: x > 5, range(10))  

  
# 使用reduce函数将range(10)中的元素累加  
# 结果是 45
reduced_obj = reduce(lambda out, x: out + x, range(10))

Any, All


collection = [0, 1, False, True, '', 'hello']  
  
# 使用any()函数检查集合中是否有任何元素为True（在布尔上下文中）  
is_any_true = any(collection)  # 相当于检查是否有任何元素的bool值为True  
print(is_any_true)  # 输出: True，因为集合中包含True和非空字符串'hello'  
  
# 使用all()函数检查集合中的所有元素是否都为True（在布尔上下文中）  
are_all_true = all(collection)  # 相当于检查所有元素的bool值是否都为True  
print(are_all_true)  # 输出: False，因为集合中包含0、False和空字符串''，它们的bool值都是False

三元操作符（条件操作符）

简单的例子

x = 10  
y = 20  
max_value = x if x > y else y  
print(max_value)  
# 输出会是 20，因为 x 不大于 y

用传统的 if-else 语句，这段代码会是这样的：

x = 10  
y = 20  
if x > y:  
    max_value = x  
else:  
    max_value = y  
print(max_value)  # 输出会是 20

条件表达式提供了一种更简洁、更紧凑的方式来执行这种简单的条件判断和赋值。

导入语句

1.导入一个模块：

如果你有一个名为 my_function.py 的文件，并且它包含了一些数学函数，你可以这样导入它：

import my_function

但是，如果模块名称与内置模块相同，应该重命名该模块或避免使用相同的名称。

2.导入一个包：

一个包是一个包含多个模块的目录，并且该目录有一个名为 __init__.py 的特殊文件（该文件可以为空）。例如，假设有一个名为 my_package 的包，并且它有一个 __init__.py 文件和一个名为 utils.py 的模块。要导入整个包（但通常我们不会这样做，除非包中有一些在 __init__.py 中定义的函数或变量），可以这样做：

import my_package

但更常见的是，从包中导入特定的模块或函数/变量。

3.从包中导入一个模块：

假设你想从 my_package 包中导入 utils.py 模块，可以这样做：

from my_package import utils

之后，可以使用 utils 模块中的函数或变量，但需要使用 utils. 前缀。

4.从包中的模块导入特定的函数或变量：

可以直接从模块中导入特定的函数或变量，而不是整个模块。例如，如果 utils.py 中有一个名为 my_function 的函数，可以这样导入它：

from my_package.utils import my_function

之后，可以直接使用 my_function() 而无需任何前缀。

另外，如果想从模块中导入所有的内容（这通常不是一个好的做法，因为它可能导致命名空间污染），可以使用 * 符号：

from my_package.utils import *

类

面向对象语言的核心：类。

类具有可继承的特性，也是这样的特性解决了第二次软件危机。

面向对象的方法将代码组织成模块化的类和对象，使得代码更加清晰、易于维护和扩展。

class Person:
    def __init__(self, name):
        self.name = name

class Employee(Person):
    def __init__(self, name, staff_num):
        super().__init__(name)
        self.staff_num = staff_num

Person类：

  • 这是一个基本类，表示一个人。
  • 它有一个构造方法（__init__），接受一个参数name，并将其赋值给实例属性self.name。

Employee类：

  • 这是一个继承自Person类的子类，表示一个雇员。
  • 它有自己的构造方法（__init__），接受两个参数：name和staff_num。
  • 使用super()函数调用父类Person的构造方法，并将name传递给父类的构造方法，以初始化从父类继承的属性self.name。
  • 另外，它还初始化了自己的实例属性self.staff_num。

举例说明

python复制代码p = Person("Alice")
print(p.name)  # 输出: Alice

e = Employee("Bob", "E123")
print(e.name)      # 输出: Bob
print(e.staff_num) # 输出: E123

需要在实际中去使用才能深刻理解什么是类，什么是面向对象。

多重继承：

类还可以多重继承，模板如下：

class A: pass
class B: pass
class C(A, B): pass

异常

try:
	<代码块>
except Exception as e:
    print(e)

open

数据写入到文本中

with open(filename, mode='w', encoding='utf-8') as file:
        file.write(text)

模式mode

  • 'r' - 读取（默认）。
  • 'w' - 写入（截断）。
  • 'x' - 如果文件已经存在，则写入或失败。
  • 'a' - 附加。
  • 'w+'- 读取和写入（截断）。
  • 'r+'- 从头开始阅读和写作。
  • 'a+'- 从末尾开始读、写。
  • 'b' - 二进制模式

命令行参数

方法一：内置函数input

xx = input(prompt=None)

从命令行获取输入的字符串。

在与用户交互时使用。

方法二：官方标准库sys

import sys
scripts_path = sys.argv[0]
arguments    = sys.argv[1:]

方法三：官方标准库argparse

import argparse  # 1、导入argpase包


def parse_args():
	# 2、创建参数对象
    parse = argparse.ArgumentParser(description='xxx')  	  
    # 3、往参数对象添加参数
    parse.add_argument('radius', type=int, help='Radius')  
    # 4、解析参数对象获得解析对象
    parse.add_argument('height', type=int, help='height')
    args = parse.parse_args()  
    return args
if __name__ == '__main__':
    args = parse_args()
    # 5、使用解析对象.参数获取使用命令行参数
    print(cal_vol(args.radius, args.height))

没有涉及鸭子类型的内容