- Python中的省略号
Python省略号是三点序列，通常在自然语言中使用。但是您可能不知道的是，这也是Python中的有效对象：
1. >>> ...
2. Ellipsis
它主要用于NumPy中的矩阵切片操作。但是，您可以在尚未实现的函数中使用它代替占位符，而不必使用通常的方法：
1. def my_awesome_func():
2. ...
这就是有效的Python代码
2.数据类别
从3.7版开始，Python附带了数据类。与常规类或其他替代方法相比，它们具有一些优点：
- 返回多个值或字典;
- 数据类需要最少的代码量；
- 比较数据类别的能力；
- 使用__repr__打印数据类以进行调试的能力；
- 减少由于类型提示数据类的要求而导致的错误机会。
运行中的示例数据类：
1. from dataclasses import dataclass
3. @dataclass
4. class Card:
5. rank: str
6. suit: str
8. card = Card("Q", "hearts")
10. print(card == card)
11. # True
13. print(card.rank)
14. # 'Q'
15. print(card)
16. Card(rank='Q', suit='hearts')
- Python之禅
最早的Python pep之一是PEP-20。这是19个Python编程论文的清单，称为“ The Zen of Python”。这些规则可以追溯到2004年，并以PEP-8为基础。
这个复活节彩蛋在Python中已经存在很长时间了，并列出了一组规则：
因此，只要您拥有Python REPL，就可以在屏幕上查看这些规则。
4.匿名功能
有时，函数的命名不值得特别注意。例如，如果您确定只使用一次。对于这种情况，Python建议使用匿名函数，也称为lambda函数。
可以将lambda函数分配给变量，从而创建一种定义函数的简洁方法：
1. >>> add_one = lambda x: x + 1
2. >>> add_one(3)
3. 4
当您需要使用函数作为参数时，它会变得更加有趣。在这种情况下，通常只使用一次。如您所知，map将函数应用于可迭代对象的所有元素。我们可以在调用map时使用lambda：
1. >>> numbers = [1, 2, 3, 4]
2. >>> times_two = map(lambda x: x * 2, numbers)
3. >>> list(times_two)
4. [2, 4, 6, 8]
5. >>>
这段代码很普通。例如，当您要将操作应用于迭代对象的每个元素时。在这种情况下，将map（）与lambda函数结合使用既简洁又有效。
5.清单理解
整体理解可以替代用于填充列表的非审美循环。语法如下：
[ expression for item in list if conditional ]用数字序列填充列表的最简单示例：
2. mylist = [i for i in range(10)]
3. print(mylist)
4. # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]由于您可以在此处使用表达式，因此可以使用数学：
1. squares = [x**2 for x in range(10)]
2. print(squares)
3. # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
外部函数调用：
1. def some_function(a):
2. return (a + 5) / 2
4. my_formula = [some_function(i) for i in range(10)]
5. print(my_formula)
6. # [2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0]
最后，您可以使用“ if”来过滤列表。在这种情况下，将仅保存那些可被2整除的值：
1. filtered = [i for i in range(20) if i%2==0]
2. print(filtered)
3. # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
**很多人学习python，不知道从何学起。
很多人学习python，掌握了基本语法过后，不知道在哪里寻找案例上手。
很多已经做案例的人，却不知道如何去学习更加高深的知识。
那么针对这三类人，我给大家提供一个好的学习平台，免费领取视频教程，电子书籍，以及课程的源代码！
QQ群：721195303**
6.替换变量
这个巧妙的技巧将为您节省几行代码：
1. a = 1
2. b = 2
3. a, b = b, a
4. print (a)
5. # 2
6. print (b)
7. # 1
7.格式化命名字符串
这并不经常使用，但是如果数据已经在字典中，则以下技巧对于格式化命名字符串很有用：
您甚至可以使用locals（）函数，但是在Python的最新版本中，您将必须像下面这样访问f字符串：
8.嵌套列表推导
还记得列表推导的基本语法吗？
[ expression for item in list if conditional ]如果expression可以是任何有效的Python表达式，那么它也可以是另一个列表推导。当您需要创建矩阵时，这很有用：
1. >>> [[j for j in range(3)] for i in range(4)]
2. [[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]
或者，如果您要“展平”以前的矩阵：
1. >>> [value
2. for sublist in m
3. for value in sublist]
4. [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]
循环的第一部分穿过矩阵m，第二部分穿过每个向量的元素。
9.必填参数
要强制使用参数，请在其前面放置一个星号，强制所有参数变为关键字：
1. >>> def f(*, a, b):
2. ... print(a, b)
3. ...
4. >>> f(1, 2)
5. Traceback (most recent call last):
6. File "<stdin>", line 1, in <module>
7. TypeError: f() takes 0 positional
8. arguments but 2 were given
9. >>> f(a=1, b=2)
10. 1 2
11. >>>
10.在REPL中使用下划线
您可以使用下划线运算符在Python REPL中获得最后一个表达式的结果，例如，在Python REPL中，它看起来像这样：
1. >>> 3 * 3
2. 9
3. >>> _ + 3
4. 12
该技巧也可以在IPython Shell中使用。
11.检查所需的Python版本
为了防止用户以不兼容的版本运行脚本，值得在代码中检查Python的当前版本。做一个简单的测试：
1. if not sys.version_info > (2, 7):
2. # berate your user for running a 10 year
3. # python version
4. elif not sys.version_info >= (3, 5):
5. # Kindly tell your user (s)he needs to upgrade
6. # because you're using 3.5 features
12.装饰功能
装饰器是对函数的包装，该函数以某种方式更改其行为。装饰器有一些用例，在使用Flask之类的框架时，您可能已经使用过它们。
让我们创建自己的装饰器：
1. def print_argument(func):
2. def wrapper(the_number):
3. print("Argument for",
4. func.__name__,
5. "is", the_number)
6. return func(the_number)
7. return wrapper
8. @print_argument
9. def add_one(x):
10. return x + 1
11. print(add_one(1))
在print_argument内部，我们定义了包装函数。它打印出被调用函数的参数和名称，执行实际函数，并返回其结果，就好像该函数被“正常”调用一样。
通过@print_argument，我们将装饰器应用于函数。装饰器也可以重新用于其他功能。
让我们创建自己的装饰器：
1. Argument for add_one is 1
2. 2
13.返回多个值
Python中的函数可以不使用字典，列表或类而返回多个变量。它是这样的：
1. def get_user(id):
2. # fetch user from database
3. # ....
4. return name, birthdate
6. name, birthdate = get_user(4)
这是返回元组的地方。您可能已经写出了具有相同效果的申报表（姓名，生日）。
对于有限数量的返回值，这很好。但是任何超过3个值的东西都必须放在（data）类中。
14.合并字典
从Python 3.5开始，合并字典变得更加容易。
1. dict1 = { 'a': 1, 'b': 2 }
2. dict2 = { 'b': 3, 'c': 4 }
3. merged = { **dict1, **dict2 }
5. print (merged)
6. # {'a': 1, 'b': 3, 'c': 4}
8. # Python >= 3.9 only
9. merged = dict1 | dict2
11. print (merged)
12. # {'a': 1, 'b': 3, 'c': 4}
如果有重复的键，则它们将在第一个词典中被覆盖。
15.切片列表
切片语法如下：
2. `a[start:stop:step]`开始， 停止和步进是可选的。它们具有默认值，如果您不填写参数将被激活：
- 0开始;
- 停止清单的末端;
- 1为步骤。
这里有些例子：
1. # We can easily create a new list from
2. # the first two elements of a list:
3. first_two = [1, 2, 3, 4, 5][0:2]
4. print(first_two)
5. # [1, 2]
7. # And if we use a step value of 2,
8. # we can skip over every second number
9. # like this:
10. steps = [1, 2, 3, 4, 5][0:5:2]
11. print(steps)
12. # [1, 3, 5]
14. # This works on strings too. In Python,
15. # you can treat a string like a list of
16. # letters:
17. mystring = "abcdefdn nimt"[::2]
18. print(mystring)
19. # 'aced it'
16.内存使用
使用sys.getsizeof（），您可以检查对象的内存使用情况：
1. import sys
3. mylist = range(0, 10000)
4. print(sys.getsizeof(mylist))
5. # 48
庞大的列表只有48个字节，因为range函数返回的行为类似于列表。就内存而言，范围比使用实际数字列表更有效。
1. import sys
3. myreallist = [x for x in range(0, 10000)]
4. print(sys.getsizeof(myreallist))
5. # 87632
17，使用和*解压功能参数
某些函数需要一长串参数。应该避免这种情况（例如，使用数据类），尽管它并不总是由您决定。另一种选择是使用命名参数创建字典并将其传递给函数。这将使您的代码更具可读性。
您可以使用**前缀解压缩字典：
1. >>> def f(a, b):
2. ... print(a, b)
3. ...
4. >>> args = { "a": 1, "b": 2 }
5. >>> f(**args)
6. 1 2
同样，您可以使用*解压缩数组并将其内容作为参数传递给函数：
1. >>> def f(a, b, c):
2. ... print(a, b, c)
3. ...
4. >>> l = [1, 2, 3]
5. >>> f(*l)
6. 1 2 3
18.行-标题
如果您想快速获得一个不错的标题，请执行以下操作：
1. mystring = "10 awesome python tricks"
2. print(mystring.title())
3. '10 Awesome Python Tricks'
19.将字符串拆分为列表
您可以将字符串拆分为字符串列表。在这种情况下，分割发生在空格字符处：
1. mystring = "The quick brown fox"
2. mylist = mystring.split(' ')
3. print(mylist)
4. # ['The', 'quick', 'brown', 'fox']
您不需要传递 任何参数来分割以空格分割—使用mystring.split（）。
Split还具有第二个参数maxsplit，它确定最大拆分数。默认情况下，它是-1（无限制）。这是一个示例，将拆分限制为1：
1. >>> mystring.split(' ', 1)
2. ['The', 'quick brown fox']
20.从字符串列表中创建一个字符串
从列表创建字符串并在每个单词之间设置空格：
1. mylist = ['The', 'quick', 'brown', 'fox']
2. mystring = " ".join(mylist)
3. print(mystring)
4. # 'The quick brown fox'
归结为这样一个事实，即String.join（）函数不仅可以联接列表，而且可以联接任何可迭代对象。将其放在字符串中会阻止在多个位置实现相同功能。
21.查询JSON
JMESpath是一种JSON查询语言，可让您从JSON文档或字典中检索所需的数据。该库可用于Python和其他语言，从而扩展了其功能。
以下是一些一般介绍的代码示例：
1. >>> import jmespath
2. >>> persons = {
3. ... "persons": [
4. ... { "name": "erik", "age": 38 },
5. ... { "name": "john", "age": 45 },
6. ... { "name": "rob", "age": 14 }
7. ... ]
8. ... }
9. >>> jmespath.search('persons[*].age', persons)
10. [38, 45, 14]
22.反向字符串和列表
您可以使用切片符号来反转字符串或列表。如果步长值为负，则交换元素：
1. revstring = "abcdefg"[::-1]
2. print(revstring)
3. # 'gfedcba'
5. revarray = [1, 2, 3, 4, 5][::-1]
6. print(revarray)
7. # [5, 4, 3, 2, 1]
23.从列表或字符串中获取唯一项
通过使用set（）函数创建一个集合，可以从列表或对象中获得所有唯一元素：
1. mylist = [1, 1, 2, 3, 4, 5, 5, 5, 6, 6]
2. print (set(mylist))
3. # {1, 2, 3, 4, 5, 6}
5. # And since a string can be treated like a
6. # list of letters, you can also get the
7. # unique letters from a string this way:
8. print (set("aaabbbcccdddeeefff"))
9. # {'a', 'b', 'c', 'd', 'e', 'f'}
24.有效的字典值
您可以在字典中放入任何内容-不限于数字或字符串。您可以将列表放入字典中并访问嵌套值：
1. >>> a = { 'sub_dict': { 'b': True }, 'mylist': [100, 200, 300] }
2. >>> a['sub_dict']['b']
3. True
4. >>> a['mylist'][0]
5. 100
25.三元条件赋值运算符
这是使代码更简洁并保持可读性的另一种方法：
[on_true] if [expression] else [on_false]这是一个例子：
x = "Success!" if (y == 2) else "Failed!"26.计算列表中的条目
使用集合库中的Counter可以获得列表中所有唯一项的字典：
1. from collections import Counter
3. mylist = [1, 1, 2, 3, 4, 5, 5, 5, 6, 6]
4. c = Counter(mylist)
5. print(c)
6. # Counter({1: 2, 2: 1, 3: 1, 4: 1, 5: 3, 6: 2})
8. # And it works on strings too:
9. print(Counter("aaaaabbbbbccccc"))
10. # Counter({'a': 5, 'b': 5, 'c': 5})
27.比较运算符链
使您的代码更具可读性和整洁性：
1. x = 10
3. # Instead of:
4. if x > 5 and x < 15:
5. print("Yes")
6. # yes
8. # You can also write:
9. if 5 < x < 15:
10. print("Yes")
11. # Yes
28.处理日期
该Python-dateutil模块提供标准的DATETIME一个强大的扩展。它的安装如下：
2. `pip3 install python-dateutil`这是从日志中解析日期的示例：
1. from dateutil.parser import parse
3. logline = 'INFO 2020-01-01T00:00:01 Happy new year, human.'
4. timestamp = parse(logline, fuzzy=True)
5. print(timestamp)
6. # 2020-01-01 00:00:01
29.使用地图（）
这是此内置函数的语法：
2. `map(function, something_iterable)`以下是使用列表的示例：
1. def upper(s):
2. return s.upper()
4. mylist = list(map(upper, ['sentence', 'fragment']))
5. print(mylist)
6. # ['SENTENCE', 'FRAGMENT']
8. # Convert a string representation of
9. # a number into a list of ints.
10. list_of_ints = list(map(int, "1234567"))
11. print(list_of_ints)
12. # [1, 2, 3, 4, 5, 6, 7]
30.词汇和定格理解
字典需要一个键和一个值：
1. >>> {x: x**2 for x in (2, 4, 6)}
2. {2: 4, 4: 16, 6: 36}
我们在表达式中定义键和值。
集合理解语法与列表理解没有太大区别。我们只使用花括号而不是方括号：
{ <expression> for item in list if <conditional> }例子：
1. >>> {s for s in range(1,5) if s % 2}
2. {1, 3}
在这里还是要推荐下我自己建的Python学习群:721195303，群里都是学Python的，如果你想学或者正在学习Python ，欢迎你加入，大家都是软件开发党，不定期分享干货（只有Python软件开发相关的），包括我自己整理的一份2021最新的Python进阶资料和零基础教学，欢迎进阶中和对Python感兴趣的小伙伴加入！