学习笔记 on 御坂11451

Dart列表

Mon, 10 Aug 2026 04:38:02 +0800

dart列表类型- List

场景当一个变量需要多少个值存储时，可以使用列表类型list

需要一个班级学生list 支持对学生查找增加删除循环

会发 List 属性名 = [“学生1”，“学生2“]

1
2
3
4


void main(){
 List students = ["小明", "小红", "小刚"];
 print(students);
}

List常用的操作方法

在尾部添加 add（内容）
在尾部添加一个列表 addAll（列表）
删除满足内容的第一个 remove（内容） 注意只删除满足条件的第一个
删除最后有个 removeLast（）
删除引用范围内的数据 removeRange（start,end）注意开始包含结尾不包含从0开始

0,1,2,3,4

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


void main(){
 List students = ["小明", "小红", "小刚"];
 print(students);
 student.add("小芳");
 print(students);
 student.add("小芳");
 print(students);
 students.addAll("小王","小夏");
 print(students);
 students.remove("小芳");
 print(students);
 students.removeLast();
 print(students);
 students.removeRange(0,4);
 print(students);
}

1
2
3
4
5
6


[小明 小红 小刚 小芳]
[小明 小红 小刚 小芳 小芳]
[小明 小红 小刚 小芳 小芳 小王 小夏]
[小明 小红 小刚 小芳 小王 小夏]
[小明 小红 小刚 小芳 小王]
[小王]

Dart判断

Mon, 10 Aug 2026 04:18:03 +0800

dart的布尔类型 - bool

场景我们需要一个属性来表示当前状态为真（ture）或者假（false）的时候需要用上bool关键词声明

需求声明自己是否完成家庭作业

语法 bool 属性名 = ture 或者false

1
2
3
4
5
6


void main(){
 bool finish = false;
 print("我目前的作业状态$finish);
 finish = ture;
 print("我目前的作业状态$finish);
}

Dart和字符串

Sat, 08 Aug 2026 08:22:32 +0800

dart string

场景当我们需要一个变量描述一段文本，就可以使用string来声明

关键词 string

语法 string 属性名 = = ‘文本内容’

特点引号支持双引号或者单引号，支持拼接及模版字符串

1
2
3
4


void main(){
 String text = "明天";
 print(text);
}

dart -string -模板字符串

场景当String 类型的变量当前时间来显示，可以使用模板字符串或者拼接实现

需求打印出我要在具体时吃饭

语法 String 属性名 = ‘文本内容$变量名’。或者String 变量名 = ‘文本内容${变量名}’

1
2
3
4


void main(){
 String text = "小米";
 print("我的名字叫$text");
}

1
2
3
4


void main(){
 text = "我今天要在${DateTimes.now()}睡觉"；
 print（text）;
}

Dart数字类型

Thu, 06 Aug 2026 19:06:35 +0800

dart数字类型 - int/num/double

场景当我们需要一个数字类型的时候，需要使用int/num/double

区别 int-整数数字 num-可整可小数 double-小数

1
2
3
4
5
6
7
8


void main() {
 int friendCount = 5; // 整数
 print("我有 $friendCount 个朋友");
 num rest = 1.5; // 可整数可小数
 print("我有 $rest 月的假期");
 double appleCount = 1.5; // 小数
 print("我买了 $appleCount 个苹果");
}

double 不能直接给int赋值（把需赋值处理放最后面）

1
2
3


friendCount // int
appleCount // double
friendCount = appleCount.toInt(); // double 转换为 int 进行赋值

num 不能直接给double赋值

1
2
3


appleCount // double
rest // num
appleCount = rest.toDouble(); // num 转换为 double 进行赋值

double 可直接能给num赋值

1
2
3


appleCount // double
rest // num
rest = appleCount; // double 可以直接给 num 赋值

Dart

Fri, 31 Jul 2026 20:35:35 +0800

dart变量与常量

dart变量（可被修改）

dart变量声明 - var

关键词 var

语法 var 变量名 = 值/表达式；

void main(){

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


 void main(){
 var age = 20; //第一次被赋值之后 类型被确定 后面不许被更改其他类型

 print(age);

 var age = 21;

 print(age);

 var age1 = 20 + 21;

 print(age1);
}

20

21

41

2 . 注意

；结尾

第一次被赋值之后类型被确定后面不许改为其他类型

dart常量（不可修改）

const声明

关键词:const

const 属性名 = 值/表达式；

const 不允许表达式中有变量存在，必须为常量或者固定值

1
2
3
4
5
6


 void main(){
 const num1 = 3.1415926;

 const num = num1;

 const length = 2 *num* 10; //圆的周长

1
2
3
4
5
6
7
8


 void main(){
 const num = 3.1415926;

 num = 3.14; //修改常量

 const length = 2 *num* 10;

}

final 声明（获取时间）

关键词 final

final 属性词 = 表达式/值

3.find运行时被初始化其值设置后不可以被修改

1
2
3
4
5


void main(){
 final time = DateTime.now()；//获取用户电脑时间 运行时为常量
 print（time）

}

调用函数

Mon, 29 Jun 2026 20:08:17 +0800

函数

直接从Python的官方网站查看文档，也可以在交互式命令行通过help(abs)查看abs函数的帮助信息

函数名	功能说明	备注
`abs()`	求绝对值	接收 1 个参数；参数数量或类型错误会报 `TypeError`。
`max()`	返回最大值	可以接收任意多个参数。
`int()`	转换为整数	将其他数据类型（如字符串或浮点数）转换为整数。
`float()`	转换为浮点数	将其他数据类型转换为小数形式。*
`str()`	转换为字符串	将其他数据类型转换为文本字符串形式。*
`bool()`	转换为布尔值	将其他数据类型转换为 `True` 或 `False`。*
`hex()`	转换为十六进制	将一个整数转换成十六进制表示的字符串。
`help()`	查看帮助信息	在交互式命令行中使用，例如 `help(abs)`。

说明：

带有 * 标记的函数（float, str, bool）虽然在当前的文本片段中未详细展开，但它们与 int() 共同构成了 Python 的基本类型转换工具箱，符合来源中提到的“数据类型转换函数”这一分类。
函数名作为引用：请记住，表格中的这些名称（如 abs、int）本质上都是指向函数对象的引用，你可以像执行 f = abs 一样为它们起别名。

调用 abs 函数(绝对值)

1
2
3
4
5
6
7
8
9


a = abs(100)
print(a)
100
a = abs(-20)
print(a)
20
a = abs(12.34)
print(a)
12.34

调用函数的时候，如果传入的参数数量不对，会报TypeError的错误，并且Python会明确地告诉你：abs()有且仅有1个参数，但给出了两个：

1
2
3
4


abs(1, 2)
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
TypeError: abs() takes exactly one argument (2 given)

如果传入的参数数量是对的，但参数类型不能被函数所接受，也会报TypeError的错误，并且给出错误信息：str是错误的参数类型：

1
2
3
4


abs('a')
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
TypeError: bad operand type for abs(): 'str'

2.int()整数

1
2
3
4
5
6


a = int('123')
print(a)
123
a = int(12.34)
print(a)
12

3.max函数选取最大值

1
2
3
4
5
6


a = max(1,2)
print(a)
2
a = (2,3,4,5,6,-1,-2)
print(a)
6

float 浮点数

1
2
3


a = float(12.34)
print(a)
12.34

str 数字转换为文本

1
2
3
4
5
6


a = str(1.23)
print(a)
'12.34'
a = str(100)
print(a)
'100'

bool() 布尔值

1
2
3
4


bool(1)
ture
bool('')
false

7.hex()整数转换为十六进制表示的字符串

1
2
3
4
5
6


n1 = hex(255)
print(n1)
0xe1
n2 = hex(1000)
print(n2)
0x3e8

在 Python 中，函数被视为一种对象。函数名（比如 abs）并不是函数本身，而是一个变量，它存储了指向该函数对象的内存地址，也就是所谓的“引用”。

可以把它想象成一个标签：

把函数名赋给变量

既然函数名只是一个变量（标签），那么你当然可以把这个变量的值赋给另一个变量。

执行 a = abs 时，你并不是在运行函数，而是把 abs 指向的那个“机器地址”也告诉了变量 a。现在，标签 abs 和标签 a 都贴在了同一个“绝对值计算”机器上。

1
2
3


>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
1

Dict和set

Sun, 28 Jun 2026 23:30:05 +0800

dict

Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。

1
2
3


d = {'Michael:95,'BOb':75,'Tracy':85}
d['Michael']
95

为什么dict查找速度这么快？因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字，我们要查某一个字，一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。

第二种方法是先在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字。无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢。

dict就是第二种实现方式，给定一个名字，比如'Michael'，dict在内部就可以直接计算出Michael对应的存放成绩的“页码”，也就是95这个数字存放的内存地址，直接取出来，所以速度非常快。

把数据放入dict的方法，除了初始化时指定外，还可以通过key放入:

1
2
3


d['Adam'] = 67
print(d['Adma'])
67

由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉：

1
2


d = ['jack'] = 90
print(d['jack'])

通过in判断key是否存在

1
2


'Thomas' in d
false

二是通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value:

1
2
3


d.get('Thomas')
d.get('Thomas',-1)
-1

要删除一个key，用pop(key)方法，对应的value也会从dict中删除：

1
2
3
4


d.pop('BOb')
75
print(d)
{'Michael': 95, 'Tracy': 85}

dict内部存放的顺序和key放入的顺序是没有关系的。

和list比较，dict有以下几个特点：

查找和插入的速度极快，不会随着key的增加而变慢；
需要占用大量的内存，内存浪费多。

而list相反：

查找和插入的时间随着元素的增加而增加；
占用空间小，浪费内存很少。

dict是用空间来换取时间的一种方法

第一条就是dict的key必须是不可变对象

set

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key

1
2
3


s = {1,2,3}
print(s)
{1,2,3}

通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果

1
2
3
4
5
6


s.add(4)
print(S)
{1,2,3,4}
s.add(4)
print(s)
{1,2,3,4}

通过remove(key)方法可以删除元素

注：无法使用s.pop

1
2
3


s.remove(4)
s
{1,2,3}

set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：

1
2
3
4
5
6


s1 = {1,2,3}
s2 = {2,3,4}
s1 & s2
{2,3}
s1|s2
{1,2,3,4}

set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等

为了保证 dict 和 set 能快速、准确地找到数据，它们要求钥匙（key）必须是绝对不可变**的。

整理了关于 dict 和 set 的详细对比及操作表格：

1. dict 与 set 的核心概念对比

这两者在 Python 中都是非常高效的数据结构，但用途有所不同：

特性	dict (字典)	set (集合)
定义	使用键-值 (key-value) 存储，具有极快的查找速度 [1]。	一组 key 的集合，但不存储 value [2]。
重复性	一个 key 只能对应一个 value，多次赋值会覆盖旧值 [3]。	key 不能重复，重复元素会自动被过滤 [2, 4]。
有序性	内部存放顺序和 key 放入的顺序无关 [2]。	无序，显示的顺序不代表内部实际顺序 [4]。
对 Key 的要求	必须是不可变对象（如字符串、整数）[2]。	同样必须是不可变对象，不能放入 list 等 [4]。
主要用途	快速根据 key 查找对应的 value [1]。	数学意义上的去重、交集、并集运算 [4]。

2. dict 与 set 的常用操作方法

下表列出了文中提到的主要操作方式：

操作类型	dict (字典)	set (集合)
初始化/创建	`d = {'Michael': 95, 'Bob': 75}` [1]	`s = {1, 2, 3}` 或 `set([5-7])` [2, 4]
添加/修改	`d['Adam'] = 67` [3]	`s.add(4)` [4]
查找/判断是否存在	`key in d` 或 `d.get(key)` [3]	`key in s` (原理同 dict)
删除元素	`d.pop(key)` [3]	`s.remove(key)` [4]
特殊运算	——	交集 `s1 & s2`，并集 `s1

3. dict 与 list 的性能对比（空间换时间）

源码中明确对比了 dict（哈希表原理）和 list（顺序查找）的差异 [2]：

特性	dict	list
查找和插入速度	极快，不会随 key 增加而变慢 [2]。	随着元素增加，耗时越来越长 [2]。
内存占用	较大，需要占用大量内存，浪费多 [2]。	占用空间小，浪费内存很少 [2]。
结论	用空间换取时间的方法 [2]。	适合数据量小、对内存敏感的场景。

💡 重要提醒：关于“不可变对象”

无论是 dict 的 key 还是 set 的元素，都必须使用 不可变对象 [2, 4]。

可以放入： 字符串 (str)、整数 (int)、全由不可变对象组成的元组 (tuple) [2, 8]。
不可以放入： 列表 (list)，因为它是可变的，无法计算固定的哈希值，会导致报错 [2, 4]。

在 Python 中，花括号 `{}` 和圆括号 `()` 分别代表了不同的数据结构，其核心区别在于功能用途和可变性：

1. 花括号 `{}`：用于 dict 和 set

在源码中，花括号主要有两种用途：

dict（字典）： 采用 “键-值对”（key-value） 的形式存储数据 [1]。
- 写法： d = {'Michael': 95, 'Bob': 75} [1, 2]。
- 特点： 查找速度极快，不会随元素增加而变慢，但占用内存较多 [1, 3]。
set（集合）： 是一组 key 的集合，但不存储 value [3]。
- 写法： s = {1, 2, 3} [3]。
- 特点： 元素不重复（自动过滤重复项），且内部元素是无序的 [4]。

2. 圆括号 `()`：用于 tuple

圆括号在源码中被用来表示 tuple（元组）。

tuple（元组）： 一种不可变的有序列表 [5]。
- 写法： t = (1, 2, 3) [5]。
- 特点： 一旦初始化就不能修改。因为它是不可变的，所以安全性更高 [5]。

3. 核心区别汇总

特性	花括号 `{}` (dict/set)	圆括号 `()` (tuple)
数据类型	dict 或 set [1, 3]	tuple [5]
存储内容	dict 存键值对，set 只存键 [1, 3]	存储有序的元素序列 [5]
重复性	key 不允许重复（set 会去重）[3, 4]	允许元素重复
有序性	无序（存放顺序与放入顺序无关）[3, 4]	有序 [5]
可变性	dict 和 set 本身是可变的（可添加删除）[2, 4]	tuple 是不可变对象 [5]

循环

Sat, 27 Jun 2026 01:20:39 +0800

循环

为了让计算机能计算成千上万次的重复运算，我们就需要循环语句

1
2
3
4
5
6
7


names = ['Michael,'Bob','tracy']
for name in name
 print(name)

Michael
Bob
Tracy

其中 for name in 中表示 ‘ name ‘元素中每一个元素

计算1-10的整数之和 sum变量做累加

1
2
3
4


sum = 0
for x in [1,2,3,4,5,6,7,8,9,10]:
 sum = sum + x
print(sum)

range()函数，可以生成一个整数序列，再通过list()函数可以转换为list。比如range(5)生成的序列是从0开始小于5的整数

1
2


list(range(5))
[0,1,2,3,4]

while循环

while循环，只要条件满足，就不断循环，条件不满足时退出循环。比如我们要计算100以内所有奇数之和，可以用while循环实现

1
2
3
4
5
6
7


sum = 0
n = 99
while n > 0:
 sum = sum + n
 n = n - 2
print(sum)

循环依次对list中的每个名字打印出Hello, xxx!

1
2
3


L = ['Bart', 'Lisa', 'Adam']
for L in name
print(f'hello,{name}!)

关于f

(f 是 format（格式化） 的缩写。

f'Hello, {name}!' 是 Python 3.6 版本引入的一种语法，正式名称叫 f-string（格式化字符串字面量）。

它的核心作用是：在字符串中直接嵌入变量或表达式，而不需要像之前那样用加号（+）拼接。

1. 具体含义拆解

f：告诉 Python 解释器，这是一个“格式化字符串”。
'...'：字符串内容。
{name}：花括号 {} 里面的内容会被当作普通的 Python 代码执行，并将计算结果替换到字符串中。

2. 对比老方法（为什么用 f）

写法	代码	特点
拼接法	`'Hello, ' + name + '!'`	加号多，容易漏掉空格，较繁琐。
传统格式化	`'Hello, %s!' % name`	需要记占位符（`%s`），变量多时容易对错位置。
f-string（你问的）	`f'Hello, {name}!'`	最直观，变量写在哪就显示在哪，一目了然。

3. 进阶用法（花括号里不仅能放变量）

因为 {} 内会执行 Python 代码，所以你可以直接写运算或调用方法：

1
2
3
4
5
6
7
8
9


# 直接做运算
print(f'明年我就 {18 + 1} 岁了') # 输出：明年我就 19 岁了

# 调用字符串方法
name = 'adam'
print(f'首字母大写：{name.capitalize()}') # 输出：首字母大写：Adam

# 调用函数
print(f'列表长度是 {len([1,2,3])}') # 输出：列表长度是 3

⚠️ 注意事项

f 必须紧贴在引号前面，中间不能有空格（f 'Hello' 会报错）。
如果字符串内部需要显示花括号本身（比如字典），需要写双花括号 {{ 和 }}：
1

print(f'字典显示：{{"key": 1}}') # 输出：字典显示：{"key": 1}

这种写法是现在 Python 最推荐、最主流的字符串格式化方式，既清晰又高效（执行速度比拼接和 % 格式化都快）。)

1
2
3


L = ['Bart', 'Lisa', 'Adam']
for L in name
print('Hello,' + name + '!')

continue

continue语句跳过某些循环

1
2
3
4
5
6


n = 0
while n < 10:
 n = n + 1
 if n % 2 == 0:# 如果n是偶数，执行continue语句
 continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行
 print(n)

break

1
2
3
4
5
6
7


n = 1
while n <= 100 # 只要 n ≤ 100 就一直循环
 if n > 10 :# 当n = 11时，条件满足，执行break语句
 break # 立刻跳出整个 while 循环（不再执行后续代码）
 print(n) # 打印当前的 n
 n = n + 1 # n 增加 1
print('end') # 循环结束后打印 END

逐轮执行流程（盯着 `print` 看）

第1轮循环：执行到 print(n) → 此时 n=1，屏幕显示 1 → 接着执行 n=n+1，n 变成 2（但屏幕没反应）。
第2轮循环：再次执行到 print(n) → 此时 n 已经是 2，屏幕显示 2 → 接着执行 n=n+1，n 变成 3。
第3轮循环：再次执行到 print(n) → 此时 n 已经是 3，屏幕显示 3 ..

数据类型

Fri, 19 Jun 2026 23:34:17 +0800

数据类型与变量

变量名第一个数不能为数学

12356…

解决特殊符号

1
2
3
4
5
6
7
8
9


s2 = 'hello,\'adam\''
print(s2)
hello,'adam'


或者这样解决:
a = "'hello world'"
print(a)
> 'hello world'

布尔法则

1
2
3
4
5


a = Ture
b = False
print(a and b) #False（又一个假取假）
print(a or b) #Ture（一个为真为真）
print（not a） #False（取反）

变相指向

1
2
3
4
5
6


a = 'ABC'
b = a
a = 'XYZ'
print(b)

> abc

a = ‘abc’

b = a

a = XYZ

b = ABC

 # 数据算数

/ = ➗

10/3
3.3333333333333335

// = 除法保留整数

% = 除法保留余数

1
2


>>> 10 % 3
1

模式匹配

Thu, 18 Jun 2026 19:41:02 +0800

针对若干个变量匹配

可以使用 mate 语句

1
2
3
4
5
6
7
8
9


socer = 'b'
if socer = 'a'
 print('socer is b')
elif socer = 'b'
 print('socer is b')
elif socer = 'c'
 print('socer is c')
else:
 print('linalid socer.')

如果使用match语法代码更易读

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


socer = 'a'
 match socer:
 case 'a'
 print('score is a')
 case 'b'
 print('score is b')
 case 'c'
 print('score is c')
 case_: 表示匹配条件
 print('socer is ???')

针对若干复杂条件:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


age = 15

match age:
 case x if x < 10:
 print(f'< 10 years old: {x}') #范围比较
 case 10:
 print('10 years old.') #匹配
 case 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18:
 print('11~18 years old.')
 case 19:
 print('19 years old.')
 case _:
 print('not sure.')

match语句还可以匹配列表是输出，功能非常强大

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


args = ['gcc', 'hello.c', 'world.c']
# args = ['clean']
# args = ['gcc']

match args:
 # 如果仅出现gcc，报错:
 case ['gcc']:
 print('gcc: missing source file(s).')
 # 出现gcc，且至少指定了一个文件:
 case ['gcc', file1, *files]:
 print('gcc compile: ' + file1 + ', ' + ', '.join(files))
 # 仅出现clean:
 case ['clean']:
 print('clean')
 case _:
 print('invalid command.')

易错项

case [‘gcc’, file1, *files]

*[gcc 第一个文件 剩余文件 ]
如果任何一个case没有匹配成功程序会跳过这个match
- case [‘clean’]: 这种写法是精确匹配，要求列表里有且仅有一个元素且内容为 ‘clean’。
- case [‘clean’, *files]: 这种写法表示第一个是 ‘clean’，后面可以带零个或多个其他内容。
- 如果数据是 [‘clean’]，最精准的匹配方式是不带星号的 case [‘clean’]

If

Tue, 16 Jun 2026 17:45:57 +0800

条件判断

1.判断

注意添加 ：

1
2
3


age = 20
if age >= 18:
 prnit('adult')

1
2
3
4
5


age = 3
if age >= 18:
 print('adult')
else:
 print('teenager')

2. 多次判断

 age >= 3
if age >= 18:
print('adult')
elif age >= 6:
print('teenager')
else:
print('kid')

其中elif是else if的缩写

1
2
3
4
5
6
7
8
9


if <条件判断1>:
 <执行1>
elif <条件判断2>:
 <执行2>
elif <条件判断3>:
 <执行3>
else:
 <执行4>

“先到先得”原则：在 if…elif…else 结构中，程序非常“懒”，只要碰到第一个符合条件的选项，它做完就收工了，后面的哪怕也符合条件，它也不会再看

else 是最后的港湾：当所有条件都不成立时，程序才会去找 else。

3.str 与 int

1
2
3
4
5


birth = input('birth: ')
if birth < 2000:
 print('00前')
else:
 print('00后')

报错

Traceback (most recent call last): File “”, line 1, in TypeError: unorderable types: str() > int()

因为input 返回数值为str str不能与整数比较需要转换为int

1
2
3
4
5
6


s = input('birth: ')
birth = int(s)
if birth < 2000:
 print('00前')
else:
 print('00后')

类型转换的风险：用 int() 转换 input() 的内容时，一定要确保用户输入的是数字，否则程序会“罢工”报错。

List

Sun, 14 Jun 2026 14:53:09 +0800

list

1.列表有序集合可随时添加和删除其中元素

1
2
3


>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates
>>> ['Michael', 'Bob', 'Tracy']

len() 获取list元素个数

1
2


>>>len(classamtes)
>>3

**索引元素 **

0开始

1
2
3
4
5
6


classmates[0]
'Michael'
classmates[1]
'Bob'
classmate[2]
'Tracy'

1
2
3
4


classmates[-2]
'Bob'
classmates[-3]
'Michael'

超出范围

1
2
3


Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
IndexError: list index out of range

list 添加

添加后缀元素

1
2
3


classmates.append('Adma')
classmates
['Michael','Bob','Tracy','Adam']

元素插定指定位置选择位置原元素位置推后一位

1
2
3


classamtes.insert(1,'Jack')
classmates
['Michael','Jack','Bob','Tracy','Adam']

删除元素 pop（）

单独删除后缀 pop（）

1
2
3
4


classmates.pop()
Adam
classmates
['Michael','Jack','Bob','Tracy']

指定位置 pop （i）

1
2
3
4


classmates.pop(1)
'Jack'
classmates
['Micheal','Bob','Tracy']

替换元素

1
2
3


classmates[1] = 'Sarah'
classmates
['Michael','Sarah',Tracy']

元素可以不同

1

L= ['apple',123,ture]

list 也可以套入list

 s = ['python',['asp','php'],'scheme']

list 里面无元素

 L = []
len(L)
0
# tuple

tupe 与 list 非常相似 tupe 无法修改（更加安全）

t = (1,2)
t
(1,2)

1
2
3


t = ()
t
()

1
2
3


t = (1)
t
1

加上括号避免误认为数学括号

t = (1,)
(1,)

t =('a','b',['A','B'])
t[2][0] = 'x'
t[2][1] = 'y'
('a','b',['x','y'])