20个学习python的要点，你都知道几个？

---

Python

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

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

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

• 这两行代码都是获取对象的类型。"type()“会返回”“的类型，而”.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(, )“会检查”“是否是”"或其子类型的实例，而"issubclass(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\]

---

一些常用的列表语法糖

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

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)  \# 输出：\[\]

---

3 字典

获取字典信息的方式

1. <view> = <dict>.keys()：这个方法返回一个反映字典键的动态视图。如果字典改变，视图也会改变。

• 例子：

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

2. <view> = <dict>.values()：这个方法返回一个反映字典值的动态视图。如果字典改变，视图也会改变。

• 例子：

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

3. <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')\])

---

---

集合

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

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(<coll.>)或 - `：这两种操作都是用来获取两个集合的差集。差集意味着获取在第一个集合中出现，但不在第二个集合中出现的元素。

• 例如：

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)

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

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

---

字符串

字符串方法和操作符

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

---

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)时，生成器都会返回序列中的下一个值，并更新内部的状态，以便下次调用时能返回正确的值。

---

11 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'\]    
    
\# 如果要保留分隔符，则需要后处理或使用其他方法

---

12 格式问题

字符串格式化方法

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

---

math模块

在科学计算领域，会用到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 中的任意一个

---

内置函数

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))  

---

导入语句

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。

---

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))  

---

👉《Python兼职资源&全套学习资料》免费分享！放心点击！！！