本文为Python学习笔记系列第一篇，仅列出我在Python基础知识学习过程中，遇到的以往学习语言不同之处或其它值得注意的地方。如有缺漏还请原谅。文中标记⭐的内容是我认为比较重要或需要多加理解的地方。

算术运算符

整除（//）在Python中，可以用//符号进行整除（向上取整）：

print(5/2)  # 输出2.5
print(5//2)  # 输出2

逻辑语句

判断语句

if……elif……else

a = 5
if a > 0:
    print('+')
elif a < 0:
    print('-')
else:
    print('0')

循环语句

for...in

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

💕tip: Python中若无特殊说明，范围一般都是左闭右开的

while

continue 提前结束本次循环，直接开始下一次循环

break 退出循环（break仅可退出本层循环）

# 打印10以内的奇数
n = 0
while n < 10:
    n += 1
    if n % 2 == 0:
        continue
    print(n)

💕tip: Python中没有switch语句

数据类型

Python中的数据类型分为两大类：数字类型和序列类型。

数字类型

数字类型的值可以用于数学运算，包括整数类型（int）、浮点型（float）和布尔类型（bool），没太多可说的。

不过有一点和其他语言差异较大的是，Python中的数字是无限长的，至于它的实现原理，参考这个：

是因为 Python 使用了可变长度的二进制补码来存储整数和浮点数，并且在执行运算时可以自动扩展存储空间。这与其他语言（如 C/C++）不同，在这些语言中整数和浮点数的存储长度是固定的，如果数值超出了存储长度的限制，就会产生溢出或舍入误差。需要注意的是,在 python 中,小数的精度是有限的。这是因为python中的浮点数都是用二进制表示的,而二进制有时无法精确的表示十进制的小数,所以可能会出现精度丢失的问题。
——chatGPT

序列类型

重点来说序列类型。Python中的序列类型包括字符串（str）、列表（list）、元组（tuple），下面来分别说说它们各自的特点，注意本部分的最后一小节，序列类型的共同特点。

字符串（str）

字符串的格式化

在Python中有好几种字符串格式化方法，常用的如下：

# 1.%格式化字符串
print("hello,%s" % name)
# 2.使用{}和format()函数
print("hello,{}".format(name))
# 3.f-strings，格式化字符串文字，是Python3.6及其以上版本提供的新语法
print(f"hello, {name}")

💕tip: Python中的单双引号含义是相同的

字符串常用内容

支持多种变量与字符串拼接

a = "hello"
print("Python {} World".format(a))
print("Python" + a + "World")

取消转义(r"...")

print(r"D:\test.txt")

常用方法

a = "Hello world"
print(a.split())  # 将字符串拆分为列表，输出["Hello", "world"]
print(a.split("l"))  # 将字符串按"l"拆分为列表，输出["He", "", "o", "wor", "d"]
print("-".join(a))  # 将字符串 "-" 作为分隔符，将 a 中的字符连接起来，输出 H-e-l-l-o- -w-o-r-l-d

# 查找字符串，find(str, 开始位置, 结束位置)
print(a.find("lo"))  # 输出3
print(a.find("l", 1, 5))  # 输出2

# 字符是否均为数字
print("123".isdigit())
# 字符是否均为字母
print("abc".isalpha())

# 大小写验证/转换
print("abc".islower())
print("abc".upper)

# 替换字符串，第三个参数代表替换前n个
print(a.replace("1", "n", 1))

列表（list）

列表和其他语言有相似之处（但不多）。用方括号括起来：

[1, 2, 3, 4, 5]
[1， True, "hello", ['w', 3]] # 列表中支持多种类型

💕tip: 列表的索引可以为负数，-1代表最后一位，索引的范围为-n ~ n-1.例如list1[-1]

添加、插入、删除

list1 = [1, 5, 8, 7]
list1.append(4)  # 末尾添加4
list1.insert(2, 'a')  # 在索引为2处添加'a'
list1.pop() # 删除末尾，加索引则删除索引处

遍历列表

list1 =[1, 2, 9, 6]
for item in list1:
    print(item)

# 循环时获取下标
for i, item in enumerate(list1):
    print(i, item)

排序、逆序、反向

list1 =[1, 2, 9, 6]
list1.sort() # 正序
list1.sort(reverse=True) # 逆序
list1.reverse() # 反向

⭐列表复制（涉及深浅拷贝问题）

list1 = [1, 3, 6, 8, 5, [2, 3]]
# 直接赋值：对象引用
list2 = list1
print(list2)
list1[1] = 0
print(list2)

# 浅拷贝：拷贝对象，不拷贝对象内部的子对象
list2 = list1.copy()
print(list2)
list1[1] = 0
print(list2)    # list2的输出不随list1改变
list1[5][0] = 0
print(list2)    # list2的输出改变：子对象不会被拷贝

# 深拷贝：完全拷贝对象及其子对象
list3 = copy.deepcopy(list1)
print(list3)
list1[5][0] = 10
print(list1)
print(list3) # list3的输出不随list1改变

元组（tuple）

元组和列表比较相似，但是元组一旦创建就不可再更改其中的元素。用括号括起来：

(1, 2, 3, 4, 5)

那么问题来了，下面这个例子会输出些什么呢？（本例为元组的元素值替换问题）

# 1
tuple1 =(1, 5)
tuple[0] = 0
print(tuple1)
# 2
tuple2 = (1, 5, [2, 4])
tuple2[2][0] = 1
print(tuple2)
tuple2[2] = [6, 8]
print(tuple2)

答案如下

# 1
(1, 5)
# 2
(1, 5, [1, 4]) # 可以修改元组包含的子对象
(1, 5, [1, 4]) # 而不能修改选组的元素

💕tip: 对于元组包含的子对象如列表，字典等可以进行修改, 而不能修改元组的元素

⭐共同特性及函数

共同特点

可以通过索引访问元素：可以使用索引下标访问序列中的元素。
可以切片：可以使用切片语法获取序列的一段元素。
支持连接和重复：可以使用加号（+）连接两个序列，使用乘号（*）重复一个序列。
元素类型可以不同：序列中的元素类型可以不同。
不可修改：字符串和字节串是不可变的，列表和元组是可变的。

序列函数

len() 长度

'c' in str 判断元素'c'是否在str序列中

max() min()最大值最小值

count() 元素出现次数

index(x,i,j) 查找指定元素的索引（第一个），i和j分别代表查找的索引范围

字典和集合

字典（dict）

映射类型：{key:value}

dict1 = {
    "name":"Li",
    "age":"20",
    "family_info":{
        "address":"beijing"
    },
    "list1":[1, 2],
    (1, 2):"turple"  # key是不可变类型
}

获取字典中的元素

通过key

print(dict1["name"], dict1["age"])
dict1["age"] = 18

通过get()方法

　　如果没有对应值，会输出None，不会报错，可在后附加默认值

print(dict1.get("name"))
print(dict1.get("name", "jack"))

遍历字典

for k in dict2:
    print(k)
    
for k, v in dict2.items():
    print(k, ":", v)
    
print(dict1.keys())
print(dict1.values())

赋值、添加、删除、更新

print(dict1["name"], dict1["age"])
dict1["age"] = 18 #赋值
dict1["weight"] = 120 #添加
dict1.pop("weight") #删除
del dict1["weight"] #删除
dict1.update({"age":20, "weight":120}) #更新

字典和JSON

二者均由键值对构成，格式上略有差别，掌握二者的转换对实际应用有很大帮助：

import json

# 将字典转换为JSON
person = {
    "name": "John Doe",
    "age": 30,
    "city": "New York"
}

person_json = json.dumps(person)
print(person_json)

# 将JSON转换为字典
person = json.loads(person_json)
print(person)

💕tip: JSON（JavaScript Object Notation）是一种轻量级的数据交换格式。它的语法基于JavaScript对象的语法，但是它被许多语言支持，包括Python。

集合（set）

　　一组key的集合，但集合中的元素都是唯一的，互不相同。

set1 = {"name", "height", "height"}
print(set1)  #将输出{"name", "height"}

⭐推导式

推导式（comprehension）在内存中的工作是通过对一个已知序列的元素进行简单的操作（例如过滤，转换），创建一个新的序列。
推导式的优点在于代码简洁，并且有效地利用了内存，因为它不需要在内存中创建一个临时的列表或元组，而是在每一步生成新的元素。
在运行时，推导式会通过迭代对序列中的每个元素进行简单的操作，并在每一步生成新的元素。当推导式结束后，它返回产生的新的序列，并将它保存在内存中。
总而言之，推导式是一种高效的方法，可以用于从已知序列中生成新的序列，并在内存上利用了更少的空间。
——chatGPT

列表推导式

[expression for item in iterable if condition]

在一个列表的基础上用一个简单的语句创建一个新的列表：

numbers = [1, 2, 3, 4, 5]
squared_numbers = [n**2 for n in numbers]
print(squared_numbers)
# 输出：[1, 4, 9, 16, 25]

# list2 里的每个元素是list1中每奇数个元素的2倍
list1 = [1, 5, 8, 7]
list2 = [item * 2 if item % 2 == 1 else item // 2 for item in list1]

字典推导式

# 字典推导式
name_age = {'Alice': 23, 'Bob': 25, 'Charlie': 27}
age_name = {age: name for name, age in name_age.items()}
print(age_name)
# 输出：{23: 'Alice', 25: 'Bob', 27: 'Charlie'}

元组推导式

如果利用列表推导式生成的列表中元素很多，而只是用前面几个元素会浪费大量的内存控件。

生成器可以边循环边生成元素，生成器表达式的优势在于它仅在需要时生成元素。

tuple1 = [1, 5, 8, 7]

tuple2 = (item * 2 for item in tuple1)
print(next(tuple2))
print(next(tuple2))
print(next(tuple2))
print(next(tuple2))
print(next(tuple2))
# next 到没有元素会报错，可用for循环
for item in tuple2:
    print(item)