Notes
Python

Python 基本语法

变量

变量赋值

name = "Alice"

变量类型

print(type(name))   # <class 'str'>

变量命名

变量名只能包含字母、数字和下划线，且不能以数字开头。

变量作用域

在函数内部定义的变量，只能在函数内部使用。

变量类型转换

print(int("1"))     # 1
print(float("1"))   # 1.0
print(str(1))       # "1"

输入

使用 input 处理输入：

name = input("What's your name? ")
print("Hello, " + name + "!")

使用 split() 可以将输入的字符串分割成一个列表：

numbers = input("Enter two numbers, separated by a space: ")
numbers_list = numbers.split()
print(numbers_list)

输出

使用 print 处理输出：

print("Hello, world!")

不想换行输出，可以使用 end 参数：

print("Hello, world!", end="")
print("Hello, world!")

使用 f 进行格式化输出：

name = "Alice"
print(f"Hello, {name}!")

也可以指定小数点后的位数：

pi = 3.1415926
print(f"Pi is {pi:.2f}")

算数运算

加法

print(1 + 1)

减法

print(2 - 1)

乘法

print(2 * 3)

除法

print(4 / 2)

整除

print(4 // 2)

取余

print(5 % 2)

指数

print(2 ** 3)   # 2 的 3 次方

逻辑运算

与

print(True and False)   # False

或

print(True or False)    # True

非

print(not True)         # False

比较运算

等于

print(1 == 1)           # True

不等于

print(1 != 1)           # False

大于

print(2 > 1)            # True

小于

print(1 < 2)            # True

大于等于

print(2 >= 1)           # True

小于等于

print(1 <= 2)           # True

成员运算

in

print("a" in "abc")     # True

not in

print("d" not in "abc") # True

身份运算

用于标识两个对象是否是同一个对象：

is

print(1 is 1)           # True

is not

print(1 is not 1)       # False

条件语句

if

if 1 == 1:
    print("1 == 1")

if-else

if 1 == 1:
    print("1 == 1")
else:
    print("1 != 1")

if-elif-else

if 1 == 1:
    print("1 == 1")
elif 1 == 2:
    print("1 == 2")
else:
    print("1 != 1 and 1 != 2")

case

case = {
    1: "1",
    2: "2",
    3: "3"
}
 
print(case.get(1, "default"))   # 1
print(case.get(4, "default"))   # default

循环语句

while

i = 0
while i < 5:
    print(i)
    i += 1

使用 break 可以跳出循环：

i = 0
while i < 5:
    print(i)
    if i == 3:
        break
    i += 1
# 0, 1, 2, 3

使用 continue 可以跳过本次循环：

i = 0
while i < 5:
    i += 1
    if i == 3:
        continue
    print(i)
# 1, 2, 4, 5

for-range

for i in range(5):
    print(i)

注意 range 左闭右开：

for i in range(1, 5):
    print(i)   # 1, 2, 3, 4

range 的使用非常灵活，可以指定步长：

for i in range(1, 5, 2):    # 表示从 1 开始，到 5 结束，步长为 2
    print(i)   # 1, 3

只填写一个参数时，表示从 0 开始：

for i in range(5):
    print(i)   # 0, 1, 2, 3, 4

for-in

for i in [1, 2, 3, 4, 5]:
    print(i)

for-enumerate

for i, v in enumerate([1, 2, 3, 4, 5]):
    print(i, v)

列表

创建列表

numbers = [1, 2, 3, 4, 5]
print(numbers)

同时，有很多特殊的列表初始化方法：

# 创建一个长度为 5 的列表，每个元素都是 0
print([0] * 5)   # [0, 0, 0, 0, 0]
 
# 创建一个长度为 5 的列表，每个元素都是 1
print([1] * 5)   # [1, 1, 1, 1, 1]
 
# 创建一个从 0 到 4 的列表
items = [i for i in range(5)]
print(items)     # [0, 1, 2, 3, 4]

访问列表

numbers = [1, 2, 3, 4, 5]
print(numbers[0])   # 1
print(numbers[1])   # 2
 
# 访问最后一个元素
print(numbers[-1])  # 5
print(numbers[-2])  # 4

切片

对列表进行切片操作，得到一个子列表，区间为 [start, end)：

numbers = [1, 2, 3, 4, 5]
print(numbers[1:3])   # [2, 3]
print(numbers[:3])    # [1, 2, 3]
print(numbers[1:])    # [2, 3, 4, 5]
print(numbers[:])     # [1, 2, 3, 4, 5]

注意，切片操作不会改变原列表。

当然，也可以指定步长：

numbers = [1, 2, 3, 4, 5]
print(numbers[1:4:2])   # [2, 4]

修改列表

numbers = [1, 2, 3, 4, 5]
numbers[0] = 0
print(numbers)   # [0, 2, 3, 4, 5]

删除列表元素

numbers = [1, 2, 3, 4, 5]
numbers.pop(0)
print(numbers)   # [2, 3, 4, 5]
numbers.pop()
print(numbers)   # [2, 3, 4]
numbers.remove(2)
print(numbers)   # [3, 4]

追加元素

numbers = [1, 2, 3, 4, 5]
numbers.append(6)
print(numbers)   # [1, 2, 3, 4, 5, 6]

插入元素

numbers = [1, 2, 3, 4, 5]
numbers.insert(0, 0)
print(numbers)   # [0, 1, 2, 3, 4, 5]

合并列表

numbers = [1, 2, 3, 4, 5]
numbers += [6, 7, 8]
print(numbers)   # [1, 2, 3, 4, 5, 6, 7, 8]

列表长度

numbers = [1, 2, 3, 4, 5]
print(len(numbers))   # 5

遍历列表

numbers = [1, 2, 3, 4, 5]
for number in numbers:
    print(number)

列表排序

numbers = [5, 4, 3, 2, 1]
numbers.sort()
print(numbers)   # [1, 2, 3, 4, 5]

字符串也可以用来排序：

vegetables = ["tomato", "potato", "carrot", "cabbage"]
vegetables.sort()
print(vegetables)   # ['cabbage', 'carrot', 'potato', 'tomato']

主要是按照字母顺序排序的，如果想要按照长度排序，可以使用 key 参数：

vegetables = ["tomato", "potato", "carrot", "cabbage"]
vegetables.sort(key=len)
print(vegetables)   # ['cabbage', 'carrot', 'tomato', 'potato']

列表反转

numbers = [1, 2, 3, 4, 5]
numbers.reverse()
print(numbers)   # [5, 4, 3, 2, 1]

列表拷贝

numbers = [1, 2, 3, 4, 5]
numbers_copy = numbers.copy()
print(numbers_copy)   # [1, 2, 3, 4, 5]

index

numbers = [1, 2, 3, 4, 5]
print(numbers.index(1))   # 0

min 和 max

numbers = [1, 2, 3, 4, 5]
print(min(numbers))   # 1
print(max(numbers))   # 5

字符串

创建字符串

string = "Hello, world!"
print(string)

访问字符串

string = "Hello, world!"
print(string[0])   # H
print(string[1])   # e

字符串切片

string = "Hello, world!"
print(string[1:3])   # el
print(string[:3])    # Hel
print(string[1:])    # ello, world!
print(string[:])     # Hello, world!

字符串拼接

string = "Hello, " + "world!"
print(string)   # Hello, world!

字符串长度

string = "Hello, world!"
print(len(string))   # 13

字符串转列表

string = "Hello, world!"
print(list(string))   # ['H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!']

多行字符串

string = """
Hello,
world!
"""
print(string)

ord ☆

作用是将字符转换为 ASCII 码：

print(ord("a"))   # 97

chr ☆

作用是将 ASCII 码转换为字符：

print(chr(97))   # a

max & min

string = "Hello, world!"
print(min(string))   # !
print(max(string))   # w

作用是返回字符串中的最小字符和最大字符。

count ☆

string = "Hello, world!"
print(string.count("l"))   # 3

作用是返回字符串中指定字符的个数。

find

string = "Hello, world!"
print(string.find("l"))   # 2

作用是返回字符串中指定字符的索引，如果不存在，则返回 -1。

index ☆

string = "Hello, world!"
print(string.index("l"))   # 2

join

print("".join(["a", "b", "c"]))   # abc

作用是将列表中的字符串拼接起来。

split

print("a b c".split())   # ['a', 'b', 'c']

作用是将字符串按照空格分割成一个列表。

replace

print("a b c".replace(" ", ","))   # a,b,c

作用是将字符串中的指定字符替换成另一个字符。

lower

print("Hello, world!".lower())   # hello, world!

upper

print("Hello, world!".upper())   # HELLO, WORLD!

strip

print("  Hello, world!  ".strip())   # Hello, world!

作用是去除字符串两端的空格。

字典

创建字典

person = {
    "name": "Alice",
    "age": 18
}
 
print(person)   # {'name': 'Alice', 'age': 18}

访问字典

person = {
    "name": "Alice",
    "age": 18
}
 
print(person["name"])   # Alice
print(person["age"])    # 18

修改字典

person = {
    "name": "Alice",
    "age": 18
}
 
person["name"] = "Bob"
print(person)   # {'name': 'Bob', 'age': 18}

栈

用列表实现栈：

stack = []
stack.append(1)
stack.append(2)
stack.append(3)
print(stack)   # [1, 2, 3]
print(stack.pop())   # 3
print(stack.pop())   # 2
print(stack.pop())   # 1

队列

用列表实现队列：

queue = []
queue.append(1)
queue.append(2)
queue.append(3)
print(queue)   # [1, 2, 3]
print(queue.pop(0))   # 1
print(queue.pop(0))   # 2
print(queue.pop(0))   # 3

哈希表

创建哈希表

hash_table = {}

添加元素

hash_table = {}
 
hash_table["name"] = "Alice"
hash_table["age"] = 18
 
print(hash_table)   # {'name': 'Alice', 'age': 18}

集合

创建集合

numbers = {1, 2, 3, 4, 5}
 
print(numbers)   # {1, 2, 3, 4, 5}

添加元素

numbers = {1, 2, 3, 4, 5}
 
numbers.add(6)
print(numbers)   # {1, 2, 3, 4, 5, 6}

删除元素

numbers = {1, 2, 3, 4, 5}
 
numbers.remove(1)
print(numbers)   # {2, 3, 4, 5}

集合运算

a = {1, 2, 3, 4, 5}
b = {4, 5, 6, 7, 8}
 
print(a | b)   # {1, 2, 3, 4, 5, 6, 7, 8}
print(a & b)   # {4, 5}
print(a - b)   # {1, 2, 3}
print(a ^ b)   # {1, 2, 3, 6, 7, 8}
TypeScript 高级特性IDEA