python100个小技巧

1、for循环中的else条件
这是一个for-else方法，循环遍历列表时使用else语句。下面举个例子，比如我们想检查一个列表中是否包含奇数。那么可以通过for循环，遍历查找。

如果找到了奇数，就会打印该数值，并且执行break语句，跳过else语句。没有的话，就不会执行break语句，而是执行else语句。

2、从列表中获取元素，定义多个变量

3、使用heapq模块，获取列表中n个最大或最小的元素

4、将列表中的所有元素作为参数传递给函数
我们可以使用 * 号，提取列表中所有的元素

如此便可以将列表中的所有元素，作为参数传递给函数

5、获取列表的所有中间元素

6、使用一行代码赋值多个变量

one, two, three, four = 1, 2, 3, 4

7、列表推导式

只用一行代码，便可完成对数组的迭代以及运算。比如，将列表中的每个数字提高一倍。

numbers = [1,2，3，4，5]
squared numbers = [num * num for num in numbers]
print(squared_numbers) # [1，4，9，16，25]

推导式不仅列表能用，字典、集合、生成器也能使用。下面看一下，使用字典推导式，将字典的值提高一倍。

dictionary = {'a': 4,'b': 51
squared dictionary = {key: num * num for (key, num) in dictionary.iterprint}
print(squared dictionary) #  a': 16，"b": 251

8、通过Enum枚举同一标签或一系列常量的集合

from enum import Enum
class Status(Enum):
NO STATUS = -1
NOT STARTED = 0IN PROGRESS = 1
COMPLETED = 2
print(status.IN PROGRESS.name# IN PROGRESSprint(status.COMPLETED.value)#2

9、重复字符串

name = "Banana"
print(name * 4)  # BananaBananaBananaBanana

10、比较3个数字的大小

如果想比较一个值和其他两个值的大小情况，你可以使用简单的数学表达式

1<x<1日

这个是最简单的代数表达式，在Python中也是可以使用的

X=3
print(1 < x < 10) # True
print(1 < x and x < 10) # True

11、使用1行代码合并字典

first_dictionary = {'name': 'Fan', 'location': 'Guangzhou'}
second_dictionary = {'name': 'Fan', 'surname': 'Xiao', 'location': 'Guangdong, Guangzhou'}

result = first_dictionary | second_dictionary

print(result)
# {'name': 'Fan', 'location': 'Guangdong, Guangzhou', 'surname': 'Xiao'}

12、查找元组中元素的索引

books = ('Atomic habits', 'Ego is the enemy', 'Outliers', 'Mastery')
print(books.index('Mastery'))   # 3

13、将字符串转换为字符串列表

假设你在函数中获得输出，原本应该是一个列表，但实际上却是一个字符串。

input = "[1,2,3]

你可能第一时间会想到使用索引或者正则表达式。实际上，使用ast模块的literal eval方法就能搞定

import ast
def string to list(string):
return ast.literal eval(string)
string = "[1，2，3]"
my list = string to list(string)
print(my list) # [1，2，3]string = "[[1，2，3],[4，5，6]]"my_list = string to list(string)0print(my_list) # [[1，2,3]，[4，5，6]]

14、计算两数差值

计算出2个数字之间的差值

def subtract(a, b):
return a - b
print((subtract(1，3)))# -2
print((subtract(3，1))) # 2

上面的这个方法，需要考虑数值的先后顺序。

def subtract(a, b):
return a - b
print((subtract(a=1， b=3)))# -2print((subtract(b=3，a=1))) # -2

使用命名参数，安排顺序，这样就不会出错了

15、用一个print()语句打印多个元素

print(1, 2, 3, "a", "z", "this is here", "here is something else")

16、在同一行打印多个元素

print("Hello", end="")
print("World")  # HelloWorld
print("Hello", end=" ")
print("World")  # Hello World
print('words',   'with', 'commas', 'in', 'between', sep=', ')
# words, with, commas, in, between

17、打印多个值，在每个值之间使用自定义分隔符

print("29", "01", "2022", sep="/")  # 29/01/2022

print("name", "domain.com", sep="@")  # name@domain.com

18、不能在变量名的开头使用数字

four_letters = "abcd" # this works
4_letters = "abcd" # this doesn’t work

这是Python的变量命名规则

19、不能在变量名的开头使用运算符

+variable = "abcd"  # this doesn’t work

20、数字的第一位不能是0

number = 0110 # this doesn't work

这个确实挺神奇的

21、在变量名的任何地方使用下划线

a____b="abcd"     # this works
_a_b_c_d ="abcd"    # this also works

这并不意味着，，你可以无限使用，为了代码的易读性，还是需要合理使用

22、使用下划线分割数值较大的数字

print(1 @09 @na @aa)#1889999899
print(1 234 567) # 1234567

如此，看到一大堆数字时，也能轻松阅读

23、反转列表

my_list = ['a', 'b', 'c', 'd']
my_list.reverse()
print(my_list)  # ['d', 'c', 'b', 'a']

24、使用步进函数对字符串切片

my_string = "This is just a sentence"
print(my_string[0:5])  # This
# Take three steps forward
print(my_string[0:10:3])  # Tsse

25、反向切片

my_string = "This is just a sentence"
print(my_string[10:0:-1])  # suj si sih

# Take two steps forward
print(my_string[10:0:-2])  # sjs i

26、使用开始或结束索引进行切片

my_string = "This is just a sentence"
print(my_string[4:])  # is just a sentence

print(my_string[:3])  # Thi

27、/和//的区别

print(3/2)  # 1.5
print(3//2)  # 1

28、==和is的区别

is = 检查两个变量是否指向同一对象内存中,==: 比较两个对象的值

first list = [1，2,3]
second list = [1, 2，3]
# 比筱两个值
print(first list == second list)# True
# 是否指向同一内存
print(first list is second list)# False
third list = first list
print(third list is first list)
# True

29、合并字典

dictionary_one = {"a": 1, "b": 2}
dictionary_two = {"c": 3, "d": 4}

merged = {**dictionary_one, **dictionary_two}

print(merged)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}

30、检查字符串是否大于另一字符串

first = "abc"
second = "def"

print(first < second)  # True

second = "ab"
print(first < second)  # False

31、检查字符串是否以特定字符开头(不使用索引)

my_string = "abcdef"
print(my_string.startswith("b"))  # False

32、使用id()查找变量的唯一id

print(id(1))  # 4325776624
print(id(2))  # 4325776656
print(id("string"))  # 4327978288

33、整数、浮点数、字符串、布尔值和元组都是不可变的

当变量被赋值为整数、浮点数、字符串、布尔值、元组这些不可变类型后，该变量就会指向一个内存对象。如果重新给变量再赋值，它的内存对象就会发生改变。

number = 1
print(id(number)) # 4325215472
print(id(1)) # 4325215472
number = 3
print(id(number)) # 4325215536
print(id(1)) # 4325215472

34、字符串和元组也是不可变的

此处再说明一次

name = "Fatos'
print(id(name))# 4422282544
name = "fatos
print(id(name))# 4422346608

35、列表、集合和字典都是可变的

这意味着发生更改时，不会改变其内存对象

cities = ["Beijing","chengdu""Guangzhou"print(id(cities))# 4482699712
cities .append("Beijing")
print(id(cities)) # 4482699712

下面是字典

my_set = (1 2,3,4]
print(id(my_set)) # 4352726176
my_set.add(5)
print(id(my_set)) # 4352726176

36、把一个列表变成不可变的列表

my_set = frozenset(['a', 'b', 'c', 'd'])

my_set.add("a")

使用frozenset()后，你就无法更改了。

37、if-elif块可以在没有else块的情况下存在

但是elif不能在没有if语句之前独立存在。

def check number(number) :
if number > 0:
return "Positive
elif number == 0:
return "Zero'
return "Negative'
print(check number(1)) # Positive

38、使用sorted()检查2个字符串是否为相同

def check_if_anagram(first_word, second_word):
    first_word = first_word.lower()
    second_word = second_word.lower()
    return sorted(first_word) == sorted(second_word)

print(check_if_anagram("testinG", "Testing"))  # True
print(check_if_anagram("Here", "Rehe"))  # True
print(check_if_anagram("Know", "Now"))  # False

39、获取字符的Unicode值

print(ord("A"))  # 65
print(ord("B"))  # 66
print(ord("C"))  # 66
print(ord("a"))  # 97

40、获取字典的键

dictionary = {"a": 1, "b": 2, "c": 3}

keys = dictionary.keys()
print(list(keys))  # ['a', 'b', 'c']

41、获取字典的值

dictionary = {"a": 1, "b": 2, "c": 3}

values = dictionary.values()
print(list(values))  # [1, 2, 3]

42、交换字典的键、值位置

dictionary = {"a": 1, "b": 2, "c": 3}

reversed_dictionary = {j: i for i, j in dictionary.items()}
print(reversed)  # {1: 'a', 2: 'b', 3: 'c'}

43、将布尔值转换为数字


print(int(False))  # 0
print(float(True))  # 1.0

44、在算术运算中使用布尔值

x = 10
y = 12
result = (x - False)/(y * True)
print(result)  # 0.833333333333333

45、将任何数据类型转换为布尔值

print(bool(.0))  # False
print(bool(3))  # True
print(bool("-"))  # True
print(bool("string"))  # True
print(bool(" "))  # True

46、将值转换为复数

print(complex(10, 2))  # (10+2j)
也可以将数字转换为十六进制数。

print(hex(11))  # 0xb

47、在列表的第一个位置添加一个值

如果使用append0，将从列表的最后一个位置插入新值。可以通过使用in来指定插入新元素的索引和数值。那么列表的第一个位置为0，即下sert() ,标为0。

my_list = [3,4，5]
my list.append(6)
my_list.insert(0，2)
print(my_list) # [2,3，4，5，6]

48、Lambda函数只能在一行代码中

无法通过多行代码，来使用lambda函数。

comparison = lambda x: if x > 3:
print("x > 3")
else:
print("x is not greater than 3")

报错

49、Lambda中的条件语句应始终包含else语句

comparison = lambda x:"X > 3” if X > 3

运行上面的代码，报错

这是由于条件表达式的特性，而不是lambda的导致的

50、使用filter()，获得一个新对象


my_list = [1, 2, 3, 4]

odd = filter(lambda x: x % 2 == 1, my_list)

print(list(odd))   # [1, 3]
print(my_list)  # [1, 2, 3, 4]

51、map()返回一个新对象

52、range()的step参数

for number in range(1, 10, 3):
    print(number, end=" ")
# 1 4 7

53、range()默认从0开始

def range_with_zero(number):
    for i in range(0, number):
        print(i, end=' ')

def range_with_no_zero(number):
    for i in range(number):
        print(i, end=' ')

range_with_zero(3)  # 0 1 2
range_with_no_zero(3)  # 0 1 2

54、不需要和0比较长度

如果长度大于0，则默认为True。

detget element with_comparison(my list):if len(my list) > :
return my_list[e]
get first element(my list):def
if len(my_list):
return my list[o]
elements = [1,2，3，4]
17first result = get element with comparison(elements)second result = get element with comparison(elements
print(first result == second result) # True

55、可以在同一个作用域内多次定义一个方法

但是，只有最后一个会被调用，覆盖以前。

defget address():
return "First address
get address():def
"Second addressreturn
defget address():
return "Third address'
print(get address()) # Third address

56、在外部直接访问私有属性

57、检查对象的内存使用情况

import sys
print(sys.getsizeof("bitcoin"))  # 56

58、定义一个方法，可以调用任意个参数

def get_sum(*arguments):
    result = 0
    for i in arguments:
        result += i
    return result

print(get_sum(1, 2, 3))  # 6
print(get_sum(1, 2, 3, 4, 5))  # 15
print(get_sum(1, 2, 3, 4, 5, 6, 7))  # 28

59、使用super()或父类的名称调用父类的初始化

使用super函数调用父类的初始化方法。

Class Parent:
def __init_(self, city, address):
self.city = city
self.address = address
class Child(Parent):
def_init__(self, city, address, university):super()._ init__(city, address)self.university = university
child = Child('Peking University','Fudan University','Tsinghua Univtprint(child.university) # Tsinghua University

使用父类的名称调用父类

Class Parent:
    def _init__(self, city, address):
        self.city = city
        self.address = address
class Child(Parent):
    def __init__(self, city, address, university):
        Parent._ init__(self, city, address)
        self.university = university
child = Child('Peking University','Fudan University 'Tsinghua Unive4)
              print(child.university) # Tsinghua University

60、在类中使用 + 操作符

61、在类中使用 < 和 == 操作符

62、为类的对象定义自定义的可打印版本

class Rectangle:
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def __repr__(self):
        return repr('Rectangle with area=' + str(self.a * self.b))


print(Rectangle(3, 4))  # 'Rectangle with area=12'

63、交换字符串中字符的大小写

string = "This is just a sentence."
result = string.swapcase()
print(result)  # tHIS IS JUST A SENTENCE.

64、检查字符串是否都是空格

string = "  "
result = string.isspace()
print(result)  # True

65、检查字符串是否都是字母或数字

name = "Password"
print(name.isalnum())  # True
name = "Secure Password "
print(name.isalnum())  # False
name = "S3cur3P4ssw0rd"
print(name.isalnum())  # True
name = "133"
print(name.isalnum())  # True

66、检查字符串是否都是字母

string = "Name"
print(string.isalpha())  # True

string = "Firstname Lastname"
print(string.isalpha())  # False

string = "P4ssw0rd"
print(string.isalpha())  # False

67、根据参数删除字符

68、检查字符串是否为数字

string = "seven"
print(string.isdigit())  # False

string = "1337"
print(string.isdigit())  # True

string = "5a"
print(string.isdigit())  # False

string = "2**5"
print(string.isdigit())  # False

69、检查字符串是否为中文数字


# 42673
string = "四二六七三"

print(string.isdigit())  # False
print(string.isnumeric())  # True

70、检查字符串是否所有单词都是大写开头

string = "This is a sentence"print(string.istitle())  # False
string = "10 Python Tips"print(string.istitle())  # True
string = "How to Print A String in Python"# Falseprint(string.istitle())
string = "PYTHON"print(string.istitle())  # False

71、在元组中使用负索引


numbers = (1, 2, 3, 4)

print(numbers[-1])  # 4
print(numbers[-4])  # 1

72、在元组中嵌套列表和元组

mixed_tuple = (("a"*10, 3, 4), ['first', 'second', 'third'])

print(mixed_tuple[1])  # ['first', 'second', 'third']
print(mixed_tuple[0])  # ('aaaaaaaaaa', 3, 4)

73、快速统计元素在列表中出现的次数

names = ["Besim", "Albert", "Besim", "Fisnik", "Meriton"]

print(names.count("Besim"))  # 2

74、使用slice()获取元素

75、计算元素在元组中出现的次数

my_tuple = ('a', 1, 'f', 'a', 5, 'a')

print(my_tuple.count('a'))  # 3

76、获取元组中元素的索引

my_tuple = ('a', 1, 'f', 'a', 5, 'a')

print(my_tuple.index('f'))  #  2

77、步进获得元组

my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

print(my_tuple[::3])  # (1, 4, 7, 10)

78、通过索引获取子元组

my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

print(my_tuple[3:])  # (4, 5, 6, 7, 8, 9, 10)

79、将列表、集合、字典中所有元素删除

my_list = [1, 2, 3, 4]
my_list.clear()
print(my_list)  # []

my_set = {1, 2, 3}
my_set.clear()
print(my_set)  # set()

my_dict = {"a": 1, "b": 2}
my_dict.clear()
print(my_dict)  # {}

80、合并集合