Python基本数据类型

a = b = c = 1

a, b, c = 1, 2, "ZHOU"

x = 1
y = 10

z = 3 + 4j
print(type(z))  # <class 'complex'>

z = complex(3, 4)  # 等价于 3 + 4j

print(z.real)     # 3.0：实部
print(z.imag)     # 4.0：虚部
                                    # 实部与虚部都是浮点型

a = 3 + 4j
b = 1 - 2j

print(a + b)  # (4+2j)
print(a - b)  # (2+6j)
print(a * b)  # (11-2j)
print(a / b)  # (-1+2j)

print(1j ** 2)  # (-1 + 0j)，即 -1

z = 3 + 4j

print(abs(z))         # 5.0
print(z.conjugate())  # (3-4j)

import cmath        # 导入 cmath 库

a, b, c = 1, 2, 5
delta = b ** 2 - 4 * a * c

x1 = (-b + cmath.sqrt(delta)) / (2 * a)
x2 = (-b - cmath.sqrt(delta)) / (2 * a)

print(x1)  # (-1 + 2j)
print(x2)  # (-1 - 2j)

变量[头下标:尾下标]

字符串[开始位置:结束位置:步长]

s = "Python"

print(s[1:4])  # yth

字符： P  y  t  h  o  n
索引： 0  1  2  3  4  5

print(s[:3])  # Pyt，从开头截取到索引 3 之前
print(s[2:])  # thon，从索引 2 截取到末尾
print(s[:])   # Python，截取整个字符串

print(s[0:6:2])  # Pto

print(s[::2])  # Pto，每隔一个字符取一次
print(s[::3])  # Ph，取索引 0、3

s[1:4]       # 等价于 s[1:4:1]

print(s[::-1])  # nohtyP，字符串反转

print(s[4:1:-1])  # oht

s[::0]  # 报错：ValueError

s[start:stop]       # 按默认步长 1 截取
s[start:stop:step]  # 指定步长
s[::-1]             # 反转字符串

nums = [10, 20, 30, 40]

print(nums[0])   # 10
print(nums[-1])  # 40

nums[0] = 100       # 修改
nums.append(50)     # 末尾添加
del nums[1]         # 删除

data = [10, "Python", True, 3.14]

scores = [85, 92, 76, 100]

matrix = [
    [1, 2, 3],
    [4, 5, 6]
]
print(matrix[1][2])  # 6

my_tuple = ('Furthe77oad', 3.14, 1145141919810)  # 避免使用 tuple 作为变量名

a = ([10, 20], 30)

a[0] = [100, 200]  # Error

a[0].append(40)
print(a)  # ([10, 20, 40], 30)

tup_1 = ()          # 空元组
tup_2 = (1, )       # 一个元素的元组

t = (1)     # type(t) : <classType: int>

numbers = {10, 20, 30}
print(numbers)              # {10, 20, 30}
print(type(numbers))  # <class 'set'>

numbers = set([10, 20, 30])
print(numbers)  # {10, 20, 30}

a = set()  # 空集合
b = {}     # 空字典，不是集合
print(type(a))  # <class 'set'>
print(type(b))  # <class 'dict'>

numbers = {10, 20, 10, 30, 20}
print(numbers)  # {10, 20, 30}

numbers = [1, 2, 2, 3, 3, 3]

result = set(numbers) # 等价于 set([1, 2, 2, 3, 3, 3])

# 这里本质与 set([1, 2, 3], [2, 3, 3]) 有非常大的区别，后面会说到，集合中的元素必须是可哈希的(hashable)

print(result)  # {1, 2, 3}

result = list(set(numbers))     # 这里把 set 转换为 list
print(result)  # [1, 2, 3]

numbers = [3, 1, 3, 2, 1]
result = list(dict.fromkeys(numbers))
# 当然这里没有用到任何和 set 有关的东西，这里利用是“字典”的特性，后面会讲到
print(result)  # [3, 1, 2]

letters = {"a", "b", "c"}
print(letters[0])  # 报错

letters[0:2]  # 报错

letters = {"a", "b", "c"}
print(letters)  # 显示顺序不应作为程序依据

for letter in letters:
    print(letter)       # 你也不应该依赖遍历读取到的顺序

for i, number in enumerate(numbers):
    print(i, number)        # 这里的 i 只是遍历时产生的编号
# 如果期望从 1 开始遍历的话，可以 enumerate(numbers, start=1)
# 或者可以写 enumerate(numbers, 1)

numbers = {10, 20}
numbers.add(30)
print(numbers)  # {10, 20, 30}

numbers.add(20)
print(numbers)  # 仍然只有 10、20、30

numbers = {10, 20}
numbers.update([20, 30, 40])
print(numbers)  # {10, 20, 30, 40}

numbers = {10, 20, 30}
numbers.remove(20)
print(numbers)  # {10, 30}

numbers.remove(100)  # KeyError

numbers = {10, 20, 30}
numbers.discard(20)
numbers.discard(100)  # 不报错
print(numbers)  # {10, 30}

numbers = {10, 20, 30}
value = numbers.pop()
print(value)        # 这里也不确定会 pop 哪一个
print(numbers)

numbers = {10, 20, 30}
numbers.clear()
print(numbers)  # 输出 set()

numbers = {10, 20, 30}

print(20 in numbers)      # True
print(100 in numbers)     # False
print(100 not in numbers) # True

registered_names = {"alice", "bob", "tom"}
name = "bob"
if name in registered_names:
    print("用户名已存在")
else:
    print("用户名可以使用")

a = {1, 2, 3}
b = {3, 4, 5}

print(a | b)    # {1, 2, 3, 4, 5}

print(a.union(b))

print(a & b)    # {3}

print(a.intersection(b))

print(a - b)    # {1, 2}
print(b - a)    # {4, 5}

print(a ^ b)    # {1, 2, 4, 5}

a = {1, 2}
b = {1, 2, 3}

print(a <= b)  # True
print(a.issubset(b))  # True

print(b >= a)  # True
print(b.issuperset(a))  # True

a = {1, 2}
b = {3, 4}
print(a.isdisjoint(b))  # True

values = {
    10,          # 整数
    3.14,        # 浮点数
    "Python",    # 字符串
    (1, 2)       # 元组
}

values = {[1, 2], [3, 4]}  # 报错：列表不可哈希

a = {1, 2}
a.add(3)
a.remove(1)
print(a)  # {2, 3}

a = frozenset({1, 2, 3})
a.add(4)  # 报错

groups = {
    frozenset({1, 2}),
    frozenset({3, 4})
}

squares = {x ** 2 for x in range(1, 6)}
print(squares)
# 包含 1、4、9、16、25

even_squares = {x ** 2 for x in range(1, 10) if x % 2 == 0}
print(even_squares)
# 包含 4、16、36、64

姓名 → 电话号码

phone_book = {
    "小明": "13800000001",
    "小红": "13800000002"
}

student = {
    "name": "小明",
    "age": 18,
    "score": 95
}

student = dict(name = "小明", age = 18, score = 95)

student = {}
print(type(student))  # <class 'dict'>

{}     # 空字典
set()  # 空集合

student = {
    "name": "小明",
    "age": 18,
    "score": 95
}

print(student["name"])   # 小明
print(student["age"])    # 18
print(student["score"])  # 95

print(student["gender"])  # KeyError

print(student.get("gender"))  # 在为指定时默认返回 None

print(student.get("gender", "未知"))  # 指定默认值后，返回指定的默认值

student["gender"]          # 键不存在时产生 KeyError
student.get("gender")      # 键不存在时返回 None
student.get("gender", "")  # 键不存在时返回指定默认值

student = {
    "name": "小明",
    "age": 18
}
student["score"] = 95
print(student)
# {'name': '小明', 'age': 18, 'score': 95}

student["age"] = 19
print(student)
# {'name': '小明', 'age': 19, 'score': 95}

dictionary[key] = value

student = {
    "name": "小明",
    "name": "小红"
}
print(student)
# {'name': '小红'}

numbers = [3, 1, 3, 2, 1]
d = dict.fromkeys(numbers)
print(d)
# {3: None, 1: None, 2: None}

student = {
    "name": "小明",
    "age": 18,
    "score": 95
}
del student["score"]
print(student)
# {'name': '小明', 'age': 18}

student = {
    "name": "小明",
    "age": 18
}
age = student.pop("age")
print(age)      # 18
print(student)  # {'name': '小明'}

gender = student.pop("gender", "未知")
print(gender)  # 未知

student.clear()
print(student)  # {}

student = {
    "name": "小明",
    "age": 18
}
print("name" in student)       # True
print("score" in student)      # False
print("score" not in student)  # True

print("小明" in student.values())  # True

student = {
    "name": "小明",
    "age": 18,
    "score": 95
}

for key in student:
    print(key)

for key in student.keys():
    print(key)

for value in student.values():
    print(value)

for key, value in student.items():
    print(key, value)

student = {
    "name": "小明",
    "age": 18
}

student.update({
    "age": 19,
    "score": 95
})
print(student)
# {'name': '小明', 'age': 19, 'score': 95}

student = {
    "name": "小明",
    "age": 18,
    "passed": True,
    "scores": [90, 95, 88]
}

print(student["scores"])     # [90, 95, 88]
print(student["scores"][0])  # 90

student = {
    "name": "小明",
    "contact": {
        "phone": "13800000001",
        "city": "上海"
    }
}

print(student["contact"]["city"])  # 上海

student
   ↓ 读取 "contact"
内部字典
   ↓ 读取 "city"
"上海"

d = {
    "name": "小明",  # 字符串作为键
    1: "第一项",      # 整数作为键
    (10, 20): "坐标"  # 元组作为键
}

d = {
    [1, 2]: "内容"
}

d = {
    "numbers": [1, 2, 3],
    "settings": {"color": "blue"}
}

student = {"name": "小明"}

student["age"] = 18       # 增加
student["name"] = "小红"  # 修改
del student["age"]        # 删除

{x: x**2 for x in (2, 4, 6)}

with open("photo.png", "rb") as file:
    data = file.read()

print(type(data))  # <class 'bytes'>

x = b"hello"           # 使用 b 前缀创建 bytes 对象
print(x)               # b'hello'
print(type(x))         # <class 'bytes'>
print(x[0])            # 104（'h' 的 ASCII 值，bytes 元素是整数）

x = bytes("hello", encoding="utf-8")

x = b"hello"
y = x[1:3]          # 切片操作，得到 b'el'
z = x + b"world"    # 拼接操作，得到 b'helloworld'
print(y)            # b'el'
print(z)            # b'helloworld'

x = b"hello"
if x[0] == ord("h"):    # ord("h") 返回 104
    print("第一个元素是 'h'")

print(chr(104)) # h

data = bytearray(b"ABC")
data[0] = 90
print(data)         # bytearray(b'ZBC')
print(bytes(data))  # b'ZBC'

data = bytes([65, 66, 255])
print(data)       # b'AB\xff'
print(data.hex()) # 4142ff

data = bytes.fromhex("41 42 43")
print(data)  # b'ABC'