34. Strings 和 tuples 是不可修改的

这一点在上一点中已经提到过，但我想强调一下，因为这是非常重要的。

name = "Fatos"
print(id(name))  # 4422282544

name = "fatos"
print(id(name))  # 4422346608

my_tuple = (1, 2, 3, 4)
print(id(my_tuple))  # 4499290128

my_tuple = ('a', 'b')
print(id(my_tuple))  # 4498867584

35. Lists, sets, 和 dictionaries 是不可修改的

这意味着我们可以在不丢失绑定的情况下更改对象：

cities = ["Munich", "Zurich", "London"]
print(id(cities))  # 4482699712

cities.append("Berlin")
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")

如果你这样做，就会抛出一个错误：

AttributeError: 'frozenset' object has no attribute 'add'

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

但是，如果前面没有“if”，“elif”就不能独立存在：

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. 一行代码获取字典中所有的keys

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

keys = [i for i, _ in dictionary.items()]

print(keys)  # ['a', 'b', 'c']

41. 一行代码获取字典中所有的值

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

values = [i for _, i in dictionary.items()]

print(values)  # [1, 2, 3]

42. 交换字典中的keys和values

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. 你可以算术操作中使用布尔值

“False”是0，而“True”是1。

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

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. 把值加到列表的第一个位置

如果你使用append()，你将从右边插入新的值。

也可以使用*insert()*来指定要插入新元素的索引和元素。在我们的例子中，我们想把它插入到第一个位置，所以我们使用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方法只能在一行里

在使用lambdas方法的时候，不能超过一行。

让我们试试以下方法：

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

将抛出以下错误:

result = lambda x: if x > 3:
 ^
SyntaxError: invalid syntax

49. lambda中的条件语句应该始终包含“else”部分

我们试下下面的：

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

我们将得到以下错误:

comparison = lambda x: "x > 3" if x > 3
                                          ^
SyntaxError: invalid syntax

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() 返回一个新的对象

my_list = [1, 2, 3, 4]

squared = map(lambda x: x ** 2, my_list)

print(list(squared))   # [1, 4, 9, 16]
print(my_list)  # [1, 2, 3, 4]

52. range() 中有一个步长的参数，但是知道的并不多

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，所以你不需要将其与0进行比较:

def get_element_with_comparison(my_list):
    if len(my_list) > 0:
        return my_list[0]

def get_first_element(my_list):
    if len(my_list):
        return my_list[0]

elements = [1, 2, 3, 4]
first_result = get_element_with_comparison(elements)
second_result = get_element_with_comparison(elements)

print(first_result == second_result)  # True

55. 可以在同一范围内多次定义相同的方法

但是，只有最后一个被调用，因为它覆盖了以前的。

def get_address():
    return "First address"

def get_address():
    return "Second address"

def get_address():
    return "Third address"

print(get_address())  # Third address

56. 你可以访问私有属性

class Engineer:
    def __init__(self, name):
        self.name = name
        self.__starting_salary = 62000

dain = Engineer('Dain')
print(dain._Engineer__starting_salary)  # 62000

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('Zürich', 'Rämistrasse 101', 'ETH Zürich')
print(child.university)  # ETH Zürich

使用父类的名称调用父类:

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('Zürich', 'Rämistrasse 101', 'ETH Zürich')
print(child.university)  # ETH Zürich

注意，使用**init()和super()**调用父类初始化器只能在子类的初始化器中使用。

60. 你可以在自己的类中重新定义“+”操作符

当你在两个int数据类型之间使用**+**操作符时，你将得到它们的和。

然而，当你在两个字符串数据类型之间使用它时，你将合并它们：

print(10 + 1)  # Adding two integers using '+'
print('first' + 'second')  # Merging two strings '+'

这表示操作符重载。

你也可以在你自己的类中使用它:

class Expenses:
    def __init__(self, rent, groceries):
        self.rent = rent
        self.groceries = groceries

    def __add__(self, other):
        return Expenses(self.rent + other.rent,
                        self.groceries + other.groceries)


april_expenses = Expenses(1000, 200)
may_expenses = Expenses(1000, 300)

total_expenses = april_expenses + may_expenses
print(total_expenses.rent)  # 2000
print(total_expenses.groceries)  # 500

61. 你还可以在自己的类中重新定义“<”和“=”操作符Y

下面是另一个你可以自己定义的操作重载的例子：

class Game:
    def __init__(self, score):
        self.score = score

    def __lt__(self, other):
        return self.score < other.score


first = Game(1)
second = Game(2)

print(first < second)  # True

类似地，就像前面的两种情况，我们可以根据自己的需要重写*eq()*函数：

class Journey:
    def __init__(self, location, destination, duration):
        self.location = location
        self.destination = destination
        self.duration = duration

    def __eq__(self, other):
        return ((self.location == other.location) and
                (self.destination == other.destination) and
                (self.duration == other.duration))


first = Journey('Location A', 'Destination A', '30min')
second = Journey('Location B', 'Destination B', '30min')

print(first == second)

你也可以类似地定义:

• sub() for -
• mul() for *****
• truediv() for /
• ne() for !=
• ge() for >=
• gt() for >

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, because all characters are alphabetsname = "Secure Password "
print(name.isalnum())  # False, because it contains whitespacesname = "S3cur3P4ssw0rd"
print(name.isalnum())  # Truename = "133"
print(name.isalnum())  # True, because all characters are numbers

66. 检查字符串中的所有字符是否都是字母

string = "Name"
print(string.isalpha())  # Truestring = "Firstname Lastname"
print(string.isalpha())  # False, because it contains whitespacestring = “P4ssw0rd”
print(string.isalpha())  # False, because it contains numbers