分享20个python学习要点

1 类型

在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

2 类型

列表的切片(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)  \# 输出:\[\]

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')\])
    
获取或设置字典的值
  1. value = <dict>.get(key, default=None)

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

    例子:

    student \= {'name': 'John', 'age': 15}  
    value \= student.get('grade', 'A')  
    print(value)  \# 输出:'A'
    
  2. 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'}
    
  3. <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})
    
  4. <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'}
    
  2. 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'}
    
  3. {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'}
    
  4. {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'}
    

4 集合

对于一些代码中的循环部分,集合特别好用,值得学习。

================================

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

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

5 元组

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

如何定义一个元组
  1. 定义一个空的元组:

    empty\_tuple \= ()
    

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

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

    single\_element\_tuple \= (1,)
    

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

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

    multi\_element\_tuple \= (1, 2, 3)
    

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

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

6 字符串

字符串

不可变的字符序列。

移除字符串两端的字符

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参数指定了分割的最大次数。如果sepNone,则默认根据空白字符分割;如果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

7 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
    

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

9 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\]
    

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

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]

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()% 运算符。

13 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>)<number> \** <number>

    这两个表达式都是用于计算幂的。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
    

14 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的对数

15 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,则使用它作为种子;否则,使用系统时间。设置种子可以确保随机数生成器的输出是可重复的。

16 内置函数

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  

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

17 导入语句

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 \*

18 类

我不知道你有没有对象,但我知道python肯定是有对象的

===================================

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

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

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

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__),接受两个参数:namestaff_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

19 open函数

数据写入到文本中

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

模式mode

  • 'r' - 读取(默认)。

  • 'w' - 写入(截断)。

  • 'x' - 如果文件已经存在,则写入或失败。

  • 'a' - 附加。

  • 'w+'- 读取和写入(截断)。

  • 'r+'- 从头开始阅读和写作。

  • 'a+'- 从末尾开始读、写。

  • 'b' - 二进制模式

20 命令行参数

**经常用于交互获取用户输入的参数
**

方法一:内置函数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总结已打包在文件夹,领取方式在文中。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/372008.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

如何将资源前端通过 Docker 部署到远程服务器

作为一个程序员&#xff0c;在开发过程中&#xff0c;经常会遇到项目部署的问题&#xff0c;在现在本就不稳定的大环境下&#xff0c;前端开发也需要掌握部署技能&#xff0c;来提高自己的生存力&#xff0c;今天就详细说一下如何把一个前端资源放到远程服务器上面通过docker部…

C++入门(C语言过渡)

文章目录 前言一、C关键字二、命名空间三、C输入&输出四、缺省参数五、函数重载六、引用七、inline八、nullptr总结 前言 C是一种通用的、高级的、静态类型的编程语言&#xff0c;它在20世纪80年代由丹尼斯里奇创建的C语言基础上发展而来。以下是C发展的一些重要里程碑。 1…

kafka 生产者

生产者 生产者负责创建消息&#xff0c;然后将其投递到Kafka中。 负载均衡 轮询策略。随机策略。按照 key 进行hash。 Kafka 的默认分区策略&#xff1a;如果指定了 key&#xff0c;key 相同的消息会发送到同一个分区&#xff08;分区有序&#xff09;&#xff1b;如果没有…

const 修饰不同内容区分

1.修饰局部变量 const int a 1;int const a 1; 这两种是一样的 注意&#xff1a; const int b; 该情况下编译器会报错&#xff1a;常量变量"b”需要初始值设定项 将一个变量没有赋初始值直接const修饰后&#xff0c;在以后时无法更改内容的。 2.修饰常量字符串 a.…

【密码学基础】基于LWE(Learning with Errors)的全同态加密方案

学习资源&#xff1a; 全同态加密I&#xff1a;理论与基础&#xff08;上海交通大学 郁昱老师&#xff09; 全同态加密II&#xff1a;全同态加密的理论与构造&#xff08;Xiang Xie老师&#xff09; 现在第二代&#xff08;如BGV和BFV&#xff09;和第三代全同态加密方案都是基…

第10章:网络与信息安全

目录 第10章&#xff1a;网络与信息安全 网络概述 计算机网络概念 计算机网络的分类 网络的拓扑结构 ISO/OSI网络体系结构 网络互联硬件 物理层互联设备 数据链路层互联设备 网络层互联设备 应用层互联设备 网络的协议与标准 网络标准 TCP/IP协议族 网络接口层协…

浅谈反射机制

1. 何为反射&#xff1f; 反射&#xff08;Reflection&#xff09;机制指的是程序在运行的时候能够获取自身的信息。具体来说&#xff0c;反射允许程序在运行时获取关于自己代码的各种信息。如果知道一个类的名称或者它的一个实例对象&#xff0c; 就能把这个类的所有方法和变…

PyQt5显示QImage并将QImage转换为PIL图像保存到缓存

PyQt5显示QImage并将QImage转换为PIL图像保存到缓存 1、效果图 2、流程 1、获取摄像头资源,打开摄像头 2、截取图像 3、opencv读的通道是BGR,要转成RGB 4、往显示视频的Label里显示QImage 5、将QImage转换为PIL图像,并保存到缓存 6、获取图像中人脸信息3、代码 # -*- codin…

python-22-零基础自学python-数据分析基础 打开文件 读取文件信息

学习内容&#xff1a;《python编程&#xff1a;从入门到实践》第二版 知识点&#xff1a; 读取文件 、逐行读取文件信息等 练习内容&#xff1a; 练习10-1:Python学习笔记 在文本编辑器中新建一个文件&#xff0c;写几句话来总结一下你至此学到的Python知识&#xff0c;其中…

Docker-11☆ Docker Compose部署RuoYi-Cloud

一、环境准备 1.安装Docker 附:Docker-02-01☆ Docker在线下载安装与配置(linux) 2.安装Docker Compose 附:Docker-10☆ Docker Compose 二、源码下载 若依官网:RuoYi 若依官方网站 鼠标放到"源码地址"上,点击"RuoYi-Cloud 微服务版"。 跳转至G…

vue对axios进行请求响应封装

一、原因 像是在一些业务逻辑上&#xff0c;比如需要在请求之前展示loading效果&#xff0c;或者在登录的时候判断身份信息&#xff08;token&#xff09;等信息有没有过期&#xff0c;再者根据服务器响应回来的code码进行相应的提示信息。等等在请求之前&#xff0c;之后做的一…

创建react的脚手架

Create React App 中文文档 (bootcss.com) 网址&#xff1a;creat-react-app.bootcss.com 主流的脚手架&#xff1a;creat-react-app 创建脚手架的方法&#xff1a; 方法一&#xff08;JS默认&#xff09;&#xff1a; 1. npx create-react-app my-app 2. cd my-app 3. …

【深度学习练习】心脏病预测

&#x1f368; 本文为&#x1f517;365天深度学习训练营 中的学习记录博客&#x1f356; 原作者&#xff1a;K同学啊 一、什么是RNN RNN与传统神经网络最大的区别在于&#xff0c;每次都会将前一次的输出结果&#xff0c;带到下一隐藏层中一起训练。如下图所示&#xff1a; …

comsol随机材料参数赋值

comsol随机材料参数赋值 在comsol中定义外部matlab函数 在comsol中定义外部matlab函数 首选项&#xff0c;安全性&#xff0c;允许 材料中&#xff0c;将杨氏模量更改为变量函数 计算 应力有波动&#xff0c;可见赋值成功 也可以看到赋值的材料参数&#xff1a;

CnosDB:深入理解时序数据修复函数

CnosDB是一个专注于时序数据处理的数据库。CnosDB针对时序数据的特点设计并实现了三个强大的数据修复函数&#xff1a; timestamp_repair – 对时间戳列进行有效修复&#xff0c;支持插入、删除、不变等操作。value_repair – 对值列进行智能修复&#xff0c;根据时间戳间隔和…

Unity | Shader基础知识(第十七集:学习Stencil并做出透视效果)

目录 一、前言 二、了解unity预制的材质 三、什么是Stencil 四、UGUI如何使用Stencil&#xff08;无代码&#xff09; 1.Canvas中Image使用Stencil制作透视效果 2.学习Stencil 3.分析透视效果的需求 五、模型如何使用Stencil 1.shader准备 2.渲染顺序 3.Stencil代码语…

CFS三层内网渗透——外网打点(一)

目录 外网打点 先爆破一下看看有没有啥可进攻路径 尝试那个可疑的路径发现是thinkphp这个框架&#xff0c;同时也知道了版本&#xff0c;那就nday打吧 写入php ​编辑写入php成功&#xff0c;简简单单nday拿下​编辑 蚁剑rce尝试链接 打点成功 外网打点 先爆破一下看看有…

前端使用Threejs加载机械臂并控制机械臂跳舞

1. 前言 在我的第一篇博客中,大致讲解了如何使用threejs导入机械臂模型,以及如何让机械臂模型动起来的案例,可以看一下之前的博客前端使用Threejs控制机械臂模型运动 本篇博客主要讲解的是在原来的基础上添加GSAP动画库的应用,可以通过动画,来让机械臂进行指定轨迹位姿的运动…

【鸿蒙学习笔记】页面布局

官方文档&#xff1a;布局概述 常见页面结构图 布局元素的组成 线性布局&#xff08;Row、Column&#xff09; 了解思路即可&#xff0c;更多样例去看官方文档 Entry Component struct PracExample {build() {Column() {Column({ space: 20 }) {Text(space: 20).fontSize(15)…

vue3实现echarts——小demo

版本&#xff1a; 效果&#xff1a; 代码&#xff1a; <template><div class"middle-box"><div class"box-title">检验排名TOP10</div><div class"box-echart" id"chart1" :loading"loading1"&…