d = {

'Alice': 45,

'Bob': 60,

'Candy': 75,

'David': 86,

'Ellena': 49,

'Gaven': 86

}

not计算的优先级是高于and和or的。

Python把0、空字符串和None看成False

字符串可以用' '或者" "括起来表示。

当字符串本身包含'时：

比如要表示字符串 I'm OK ，这时，可以用" "括起来表示：

"I'm OK"

类似的，如果字符串包含"，可以用' '括起来表示：

'Learn "Python" in imooc'

当字符串既包含'又包含"时：

需要对字符串中的某些特殊字符进行“转义”，Python字符串用\进行转义。

由于'和"会引起歧义，因此，需要在它前面插入一个\表示这是一个普通字符，不代表字符串的起始，例如要表示字符串：Bob said "I'm ok"

就可以写成‘Bob said \"I\'m ok\".'

注意：转义字符\不计入字符串的内容中。

常见的转义字符还有：

\n表示换行

\t表示一个制表符

\\表示\字符本身

1.在Python中，整数和整数，浮点数和整数之间可以直接进行许多运算

其计算格式类似于日常的计算，如：
a=10

b=2.5

c=a+b

print(c)

此时计算机输出的结果为12.5

减法、乘除法也是同样的道理

注：整数和浮点数进行计算后，结果都显示浮点数形式，这是正常的

·在不同的Python版本中，计算的结果可能会不同，建议使用最新版Python

2.Python支持取模运算（取模运算即为计算两个数相除的余数的运算），取模运算使用%号表示。

取模运算的格式与加减乘除法相同，写作a%b

如：3%2，3 /2=1......1，余数为1，因此3%2=1

3. Python中还有一种叫“地板除”的运算，即为计算两数相除，取整数部分为结果的运算，地板除的符号为//

4.若计算后只想保留小数点后几位，可以使用round()函数，round()函数包含两个语句，第一个语句是需要进行保留小数点位数操作的那个数，第二个是保留的位数。

如：

a=10/3

round(a, 2）=3.33

Python中定义一个变量的约束：（关键点）

1.变量名由大小写英文字母、数字和下划线_组成

2.变量不能用数字开头

3.变量尽量不要和Python关键字重合（比如前面学习过的：and、or、not，否则可能导致Python原有关键字发挥不出作用）

4.要定义一个变量，只需要以：

变量名=数据

这种格式写一句语句，如：
a=2

此时a的值就为2

a的值也可以是字符等，如：
b='laosha'

此时b的值就为字符串'laosha'

注意：若要定义的变量的值是字符或字符串，则在需使用单引号括起这个字符串，否则将无法识别。

5.在Python里面，一个变量可以先后存储多种不同类型的数据。

当使用print语句输出文本时，注意在需要输出的文本前后都有单引号'

print和>>>不可以有空格

注意(、)、'、'）均为英文字符

注意：使用python的print语句输出文本时，除非使用# coding=utf-8等

语句告诉计算机，不然所要输出的文本中不能存在中文字符，否则电脑将无法识别

如：

print('你好')

单独执行这条语句，电脑将显示错误

但是当在前面加上提示语句告诉电脑时：
如：
# coding=utf-8

print('你好')

执行这段代码，电脑将输出"你好

要定义只有一个元素的tuple，需要在元素后面添加一个逗号,

在dict中，使用keys()方法，可以返回dict的所有key，在删除某个元素时，可以通过这个方法先判断某个元素是否存在，请改造前面的程序，使得即使key不存在时，删除也不会抛异常。

count()方法用来统计tuple中某个元素出现的次数。

index()方法可以返回指定元素的下标，当一个元素多次重复出现时，则返回第一次出现的下标位置。

由于tuple一旦定义之后便不可修改，所以在实际编程中，tuple经常用于存放固定不变的数据。

name=['Alice', 'Bob', 'Candy', 'David', 'Ellena']

name.append('Gen')

name.insert(6,'Phoebe')

name.insert(7,'Zero')

print(name)

L = [95.5, 85, 59, 66, 72]

L.sort(reverse=True)

print(L[-3:])

输出了倒数第三名

奇数的，把num改为1即可

num = 1

L = ['Alice', 66, 'Bob', True, 'False', 100]

for item in L:

    num = num + 1

    if num % 2 != 0:

        continue

    print(item)

python 中 T = (1, 'CH', [3, 4]) L = T[2] print(L) # ==> [3, 4] # 尝试替换L中的元素 L[1] = 40 print(L) # ==> [3, 40] print(T) # ==> (1, 'CH', [3, 40]) 比如这个，讲义里的代码，L=T[2],我感觉是一个赋值语句啊，相当于把T[2]给了L，那L和T的本身应该没关系吧，为什么变L会影响T呢。

这个问题确实涉及到Python中一些基础但重要的概念，特别是关于赋值语句、可变类型与不可变类型，以及对象引用的理解。下面我将详细解释为什么修改列表L的内容会影响元组T。

1. 赋值语句的工作原理

在Python中，赋值语句L = T[2]并不是在内存中创建T[2]的一个新副本赋给L，而是让L和T[2]都指向同一个对象。这里的关键是理解“引用”的概念。在Python中，变量实际上是对内存中对象的引用。当你执行赋值操作时，你只是在创建一个新的引用，而不是复制对象本身。

2. 可变类型与不可变类型

‌不可变类型‌：像整数、浮点数、字符串和元组等，一旦创建，其内容就不能改变。如果尝试修改这些类型的对象，Python会创建一个新的对象。

‌可变类型‌：列表、字典和集合等是可以修改的。当你修改这些类型的对象时，实际上是在原地修改对象的内容，而不会创建新的对象。

在你的例子中，T是一个元组，它是不可变的。但是，T中的第三个元素是一个列表，它是可变的。当你执行L = T[2]时，L和T[2]都指向同一个列表对象。因此，当你通过L修改这个列表时，实际上是在原地修改这个对象，而T[2]作为同一个对象的引用，自然会反映出这些修改。

True,第一个字母是要大写

变量初始化：

names 列表存储了人名。

scores 列表存储了对应的分数。

index 初始化为 0，用于表示当前要访问的 scores 列表元素的索引。

for 循环：

for name in names: 会遍历 names 列表中的每个元素，每次循环将当前元素赋值给 name。

访问 scores 列表：

score = scores[index] 这行代码通过 index 变量访问 scores 列表中的元素，将其赋值给 score。在第一次循环时，index 为 0，所以 scores[index] 就是 scores[0]，即 45，这是 Alice 对应的分数。

更新索引：

index = index + 1 会将 index 的值加 1，这样在下一次循环时，就可以访问 scores 列表的下一个元素。

赋值语句其实有两个功能：

1.当key不存在时，往dict中添加对应的key: value元素。

2.当key存在时，会更新dict，用新的value替换原来的value。

需要先判断key是否存在，然后再做更新。

dict提供通过key找到对应value的功能，通过d[key]的形式，就可以得到对应的value。

print(d['Bob']) # ==> 60

在dict中，当对应的key不存在时，也会引发错误。

dict本身提供get方法，把key当作参数传递给get方法，就可以获取对应的value，当key不存在时，也不会报错，而是返回None。

print(d.get('Alice')) # ==> 45
print(d.get('Dodo')) # ==> None

通过get方法在代码实现上更加简单，且不会引起错误，因此更加推荐使用get方法来获取dict的元素。

python的dict就是专门保存这种映射的，使用dict可以方便的保存“名字”->“成绩”的映射。
在dict中，每一项包含一个key和一个value，key和value是一一对应的，在解决上面的问题中，我们可以使用名字作为key，成绩作为value，那么dict的定义如下：

d = {
   'Alice': 45,
   'Bob': 60,
   'Candy': 75,
   'David': 86,
   'Ellena': 49
}

使用花括号{}表示这是一个dict

key和value之间使用冒号:分割，并且每一组key:value的最后，以逗号,表示这一组的结束。

tuple是不可变的，tuple里面的元素，也是不可替换的。但是这针对的是仅包含基础数据类型（数字类型、布尔类型、字符串类型）的数据，对于组合数据类型，则不受这个约束。

T = (1, 'CH', [3, 4])
L = T[2]
print(L) # ==> [3, 4]
# 尝试替换L中的元素
L[1] = 40
print(L) # ==> [3, 40]
print(T) # ==> (1, 'CH', [3, 40])

因为虽然tuple中的list元素改变了，但是tuple本身指向的list仍然是同一个list，list本身并没有改变，改变的只是list里面的一个元素，这是tuple所约束不到的范围。

如果我们直接替换list，这也是不行的。

T = (1, 'CH', [3, 4])
L2 = [3, 40]
# 尝试替换tuple中的list
T[2] = L2
# 报错

包含 0 个元素的 tuple，也就是空tuple，直接用()表示T=()

因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果(1)被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。

T = (1)
print(T) # ==> 1
因此，要定义只有一个元素的tuple，需要在元素后面添加一个逗号,。

T = (1, )
print(T) # ==> (1, )

而对于多个元素的tuple，则加和不加这个逗号，效果是一样的。

在使用上，tuple提供了便捷的方法可以访问tuple中的数据。

count()方法用来统计tuple中某个元素出现的次数。

index()方法可以返回指定元素的下标，当一个元素多次重复出现时，则返回第一次出现的下标位置。

注意，index()方法和count()方法不一样，当指定的元素不存在时，使用index()方法Python会报错。

替换元素L[2]='*****'/L[-3]='*****'

pop()方法默认删除列表的最后一个元素

pop()还可以接收一个参数，指定需要删除的元素的位置。

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
name = L.pop()
print(name) # ==> Ellena
print(L) # ==> L = ['Alice', 'Bob', 'Candy', 'David']

name = L.pop(2)
print(name) # ==> Candy

pop(2)☞删除第2个位置后面的第三个位置

注意，append()方法总是将元素添加到list的尾部。

insert()方法需要两个参数，分别是需要插入的位置，以及需要插入的元素。

例:names = ['Alice', 'Bob', 'David', 'Ellena']
names.insert(2, 'Candy')
print(names) # ==> ['Alice', 'Bob', 'Candy', 'David', 'Ellena']

第一个位置用0 names.insert(0,'Candy')

-1来表示最后一个元素。

0表示第一个元素。