1
boolVar = True
2
# 推荐: 直接使用布尔值
3
if boolVar:
4
    print("为真")
5

6
if not boolVar:
7
    print("为假")
8

9
# 也可以使用 == (更明确)
10
if boolVar == True:
11
    print("为真")
12

13
# 可以使用,但有隐患,不推荐使用,具体原因见运算符章节
14
if boolVar is True:
15
    print("为真")
16

17
# 这是个坑,bool只会判断是否为空串.虽然里面传入了False字面量,但这不是真正的False.
18
boolVar = bool("False")
19
print(boolVar)
20

21
emptyTuple = ()  # 创建空元组方式一
22
emptyTuple = tuple()    # 创建空元组方式二
23
boolVar = bool(emptyTuple)
24
print(boolVar)  # False

1
# 字符串切片(slice)
2
# [<起始下标>:<终止下标>:<步长>]   # 从起始下标开始,终于终止下标,但不包括终止下标.
3
# 另外,如果起始下标为0,或终止下标为 len(list),那么可以省略
4
str_var2 = str_var[1:2]  # 取出下标从1开始,取到2之前,不包括2,也就是只有1
5
# 实际上,字符切片完全可以套在列表上使用.
6
# 当然起始下标和终止下标也可以为负数,一般不用.
7
# 取负数时,从右边开始取,最右边元素下标为-1,第二个为-2,以此类推.
8
# 有一个反转字符串的方法较为常用,如下,记住即可. [::-1],双冒号,后跟-1.
9
str_var_reversed = str_var[::-1]
10

11
# 切片示例
12
s = "abcdefghij"
13
print(s[0:5])  # 'abcde' (索引0到4)
14
print(s[2:8:2])  # 'ceg' (从索引2开始,到7结束,步长为2)
15

16
# 省略start,默认从0开始
17
print(s[:5])  # 'abcde'
18

19
# 省略stop,默认到字符串末尾
20
print(s[5:])  # 'fghij'
21

22
# 省略step,默认步长为1
23
print(s[::])  # 完整取出
24

25
# 使用负数索引,从后往前数,很少使用
26
# 当使用负数索引时,索引下标从-1开始,表示最后一个元素.
27
print(s[-1])  # 'j' (最后一个字符)
28
print(s[-5:])  # 'fghij' (倒数5个字符)
29
print(s[::-1])  # 'jihgfedcba' (字符串反转,步长为-1),这个方法很常用

1
# 获取字符串长度,字符长度,而非字节长度.即有几个字符.
2
str_var = "Hello kulve"
3
length = len(str_var)
4
print(length)
5

6
# 注意：所有修改字符串的方法都会返回一个新的字符串,原字符串不变
7
text = "  Python is a programming language. Welcome to using Python.  "
8
print("--- 去除空白 ---")
9
print(text.strip())  # 去除两端空白
10
print(text.lstrip())  # 去除左侧空白
11
print(text.rstrip())  # 去除右侧空白
12
print(text.strip().strip("."))  # 允许给定一个字符,然后将其去掉.
13

14
text = "Python is a programming language. Welcome to using Python."
15

16
print("--- 大小写转换 ---")
17
print(text.lower())  # 转换为小写
18
print(text.upper())  # 转换为大写
19
print(text.title())  # 每个单词首字母大写
20
print(text.capitalize())  # 仅第一个字符大写
21

22
print("--- 查找 ---")
23
# find() 找到返回索引,找不到返回 -1
24
print(text.find("language"))  # language在text中的索引位置
25
print(text.find("CRAZYTHURSDAYVME50"))  # -1
26
# index(<值>) 类似find,但找不到会抛出ValueError异常
27
print(text.index("Python"))  # 0
28

29
print("--- 统计出现次数 ---")
30
# count(<值>) 统计子串出现的次数
31
print(text.count("Python"))  # 2
32

33
print("--- 替换 ---")
34
# replace(<被替换字符串>,<替换值>) 替换
35
print(text.replace("Python", "Java"))
36
# Java is a programming language. Welcome to using Java.
37

38
print("--- 分割 ---")
39
words = text.split()  # 默认按空白字符分割,返回列表
40
print(words)
41
# ['Python', 'is', 'a', 'programming', 'language.', 'Welcome', 'to', 'using', 'Python.']
42

43
csv_var = "apple,banana,cherry"
44
fruits = csv_var.split(',')  # 按指定分隔符分割
45
print(fruits)  # ['apple', 'banana', 'cherry']
46

47
print("--- 连接 ---")
48
# join() 是split的逆操作,将列表元素连接成一个字符串
49
new_text = '-'.join(words)
50
print(new_text)
51
# Python-is-a-programming-language.-Welcome-to-using-Python.
52

53
print("--- 开头和结尾匹配 ---")
54
filename = "report.pdf"
55
print(filename.startswith("report"))  # True
56
print(filename.endswith(".pdf"))  # True
57

58
print("--- 判断字符串内容 ---")
59
print("12345".isdigit())  # True (是否全部由数字组成)
60
print("abc123".isalpha())  # False (是否全部由字母组成)
61
print("abc123".isalnum())  # True (是否全部由字母或数字组成)
62
print("   ".isspace())  # True (是否全部由空白符组成)
63

64
# ======================
65
# 4. 类型转换 (Type Casting)
66
# ======================
67

68
# --- 字符串转其他类型 ---
69
num_str = "123"
70
float_str = "123.45"
71
bool_str = "True"
72
list_str = "[1, 2, 3]"
73

74
# 转为整数
75
num_int = int(num_str)  # 123
76

77
# 转为浮点数
78
num_float = float(float_str)  # 123.45
79

80
# 转为布尔值 (非空字符串转为True)
81
bool_val1 = bool("any non-empty string")  # True
82
bool_val2 = bool("")  # False
83
# 注意：这种方式将"True"转为True,"False"转为True,因为它们都是非空字符串。
84
# 如果想根据字符串内容转为对应的布尔值,需要特殊处理或使用ast.literal_eval
85
import ast
86

87
bool_val3 = ast.literal_eval(bool_str)  # True
88

89
# 将表示列表/字典的字符串转为对应对象 (安全方式)
90
list_obj = ast.literal_eval(list_str)  # [1, 2, 3]
91

92
# --- 其他类型转字符串 ---
93
num = 42
94
pi = 3.1415
95
is_true = True
96
my_list = [1, 2, 3]
97

98
# 使用 str() 函数
99
str_num = str(num)  # "42"
100
str_pi = str(pi)  # "3.1415"
101
str_bool = str(is_true)  # "True"
102
str_list = str(my_list)  # "[1, 2, 3]"
103

104
# 使用格式化方法 (更灵活,推荐使用f-string)
105
name = "Alice"
106
age = 30
107
greeting = f"My name is {name} and I am {age} years old."
108
print(greeting)  # My name is Alice and I am 30 years old.
109

110
# 使用 % 格式化 (较旧的方式)
111
greeting_old = "My name is %s and I am %d years old." % (name, age)
112
print(greeting_old)
113

114
# 使用 str.format() (Python 2.6+)
115
greeting_format = "My name is {} and I am {} years old.".format(name, age)
116
print(greeting_format)

1
# 列表(list)
2
# Python没有传统数组,一般使用list
3

4
arr = [1, 2, 3, 4]  # 创建一个列表
5
print(arr)  # 调用函数输出所有的字符
6

7
arr[0] = 100  # 将第一个元素设置为100
8
print(arr)
9

10
arr.append(5)  # 追加一个元素5
11
print(arr)
12

13
arrPopVar = arr.pop()  # 弹出最后一个元素.
14
print(arr)
15
print(arrPopVar)
16

17
# 解释下面这行: 这是Python中的列表推导式,用于快速创建列表
18
# 语法: [<表达式> for <变量> in <可迭代对象>]
19
# range(5): 生成0->4,差值为1的列表.
20
# x * x: 表达式,也即将0->4计算为平方.
21

22
squares = [x * x for x in range(5)]
23
print(squares)
24

25
# 等价写法
26
squares2 = []
27
for x in range(5):
28
    squares2.append(x * x)
29

30
# 与其它语言的数组的不同点
31
# 1. 一个列表中支持多种不同类型的对象.
32
# 可以理解为一个Object类型的数组,什么都能存.

1
def foreach_set(set):
2
    # 这里实际上就是在遍历列表.
3
    # for <变量> in <列表>
4
    for i in set:
5
        print(i, end="")
6
    print("")
7

8

9
# 集合(set)是去重的,无序的.
10
setVar = {1, 2, 3, 3}
11
foreach_set(setVar)  # 在这里,可以发现刚刚添加的两个3,已经被去重了.
12

13
setVar.add(4)
14
foreach_set(setVar)  # 新增元素4
15

16
setVar.remove(2)
17
foreach_set(setVar)  # 移除元素2

1
# --- 1. 创建字典的多种方式 ---
2
# 1) 使用花括号,如上面的例子.
3
dict1 = {
4
    "key1": "value1",
5
    "key2": "value2"
6
}
7

8
# 2) 使用dict()构造函数
9
dict2 = dict(
10
    name="Charlie",
11
    age=25
12
)
13
print("使用dict()创建:", dict2)
14

15
# 3) 使用dict()传入 键值对 列表
16
dict3 = dict([
17
    ("fruit", "apple"),
18
    ("color", "red")
19
])
20
print("使用列表创建:", dict3)

1
person = {
2
    "name": "Alice",
3
    "age": 20
4
}
5

6
# --- 2. 安全地访问和修改字典 ---
7

8
# 1. get(<键>[, <默认值>]):
9
# 安全获取值，如果键不存在，返回默认值，而不是抛出KeyError.
10
# 若未在get方法中给定默认值,则返回None
11
print("获取'age'的值:", person.get("age"))  # 20
12
print("获取不存在的键的值:",
13
      person.get("notExistsKey", "Not Specified")
14
      )  # Not Specified 未指定
15

16
# 2. setdefault(key[, default]): 如果键存在，返回其值；如果不存在，插入该键并设置为默认值，然后返回默认值
17
person.setdefault("email", "default@example.com")
18
print("使用setdefault添加默认值后:")
19
print(person)

1
person = {
2
    "name": "Alice",
3
    "age": 20
4
}
5
# --- 3. 字典合并 ---
6
# 1. 使用 update() 方法,会修改原字典.(Python3.5引入)
7
person.update({
8
    "age": 21,
9
    "job": "Engineer"
10
})
11
print(f"使用update()方法合并后: {person}")
12

13

14
# 2. 使用 | 运算符不修改原字典，返回新字典)(Python3.9引入)
15
new_info = {
16
    "country": "USA",
17
    "job": "Developer"
18
}
19
merged_dict = person | new_info
20
print(f"使用 | 运算符合并后 (新字典): {merged_dict}")
21
print(f"原字典person保持不变: {person}")

1
person = {
2
    "name": "Alice",
3
    "age": 20
4
}
5
# --- 5. 字典的视图 (Views) ---
6
# keys(), values(), items() 返回的是视图对象，它们是动态的，会反映字典的最新状态
7
keys_view = person.keys()
8
print("字典的键视图:", keys_view)
9
values_view = person.values()
10
print("字典的值视图:", values_view)
11
items_view = person.items()
12
print("字典的键值对视图:", items_view)
13

14
# 尝试修改字典，视图会随之更新
15
person["new_key"] = "new_value"
16
print("修改字典后，键视图自动更新:", keys_view)

1
# enum
2
# enum是需要导入包的,导入包的方法为
3
# from <包名> import <方法名>
4
from enum import Enum
5

6

7
# enum适用于如状态,类型,选项等,而不使用魔法数字.
8
# 声明枚举类型
9
class Color(Enum):
10
    RED = 1
11
    GREEN = 2
12
    BLUE = 3
13

14
    def a(self):
15
        print("asdf")
16
        return "asdf的返回值"
17

18

19
colorVar = Color.RED
20

21
print(colorVar)  # Color.RED
22
print(colorVar.value)  # 1
23
print(colorVar.name)  # RED
24
print(colorVar.a())  # RED
25

26
if colorVar == Color.RED:
27
    print("红色的")

1
movie = "叶问"
2
number = [1, 2]
3

4
# 常用强制类型转换的通用语法
5
# <类型>(<值>)
6
print(movie + str(number))
7

8
# --- 字符串转其他类型 ---
9
num_str = "123"
10
float_str = "123.45"
11
bool_str = "True"
12
list_str = "[1, 2, 3]"
13

14
# 转为整数
15
num_int = int(num_str)  # 123
16

17
# 转为浮点数
18
num_float = float(float_str)  # 123.45
19

20
# 转为布尔值 (非空字符串转为True)
21
bool_val1 = bool("False")  # True
22
bool_val2 = bool("")  # False
23
# 注意这里有个坑,这种方式将"True"转为True,"False"转为True,因为它们都是非空字符串。
24
# 如果想根据字符串内容转为对应的布尔值,需要特殊处理或使用ast.literal_eval
25

26
# --- 高级用法: 使用其它库转换字面量为相应对象 ---
27
# 这个库,允许字面量结构的字符串,转换为python中的对象,同时只允许解析字面量表达式,不会执行代码,更安全.
28
import ast
29
# 用法: ast.literal_eval(<字面量>)
30
# 返回值为相应的对象
31
bool_val3 = ast.literal_eval(bool_str)  # True
32

33
# 将表示列表/字典的字符串转为对应对象 (安全方式)
34
list_obj = ast.literal_eval(list_str)  # [1, 2, 3]
35

36
# --- 其他类型转字符串 ---
37
num = 42
38
pi = 3.1415
39
is_true = True
40
my_list = [1, 2, 3]
41

42
# 使用 str() 函数
43
str_num = str(num)  # "42"
44
str_pi = str(pi)  # "3.1415"
45
str_bool = str(is_true)  # "True"
46
str_list = str(my_list)  # "[1, 2, 3]"
47

48
# eval是一个非常不安全的方法,他允许通过字符串向程序中注释代码片段,并执行它,有严重的安全漏洞,推荐直接移除该库.
49
exp = "print([i for i in range(100)])"
50
# eval支持将一个字符串当成程序来执行.
51
print(eval(exp))