Python学习笔记—— Soft shelled turtle

LESSON 4

Python3一行可以写多个语句，用分号隔开。

print('dui'); print('cuo')

一个语句也可以分成多行书写。行末加‘\’或者用括号括起来这个语句

3 > 4 and \
1 < 2

(3 > 4 and
1 < 2)

短路逻辑

参考文章：link
计算：not 1 or 0 and 1 or 3 and 4 or 5 and 6 or 7 and 8 and 9
涉及知识点：

1. 优先级：not > and > or
2. and：x and y and z and w 返回的结果为第一个为0的值，若全部非0，则返回最后一个值，（这和与的逻辑是一样的，找到假一定假(0)，找不到就返回最后一个值）例如：
   3 and 4 and 5 返回值为5
   3 and 4 and 0 and 5 返回值是0
3. or：x or y or z or w 返回第一个为非0的值（这和或的逻辑也一样，找到真就真(非0)，找不到就返回0）
   0 or 0 or 1 返回值为1

所以本题为 (not 1) or (0 and 1) or (3 and 4) or (5 and 6) or (7 and 8 and 9) ---->0 or 0 or 4 or 6 or 9 ---->4

LESSON 6 算术操作符

1. +、-、*、/ 都和数学运算一样
2. // 计算后的结果向下（floor）取整，但类型和更高级别的一样
   比如：10.0//8 结果为1.0
3. ** 次幂运算，前一个数为底，后一个数为次幂
   例如：8 ** 2 =64
   优先级问题：-3 ** 2=-9 但3 ** -2 = 3^-2

LESSON 7&8&9 分支和循环

else:
   if 条件 :
等价于
elif 条件 :

三元操作符

x, y = 4, 5
if x < y:
	small = x
else:
	small = y

改为三元操作符：

small = x if x < y else y

进一步

small = x if (x < y and x < z) else (y if y < z else z)

断言 (assert)

assert后面语句为真，程序正常工作
assert后面语句为假，程序自动崩溃并抛出AssertionError

for循环

for 目标 in 表达式：
   循环体

例子：

favorite = 'convention'
for i in favorite:
	print(i, end(' ')

结果：c o n v e n t i o n

member = ['征途','黑夜','宵禁','迷途知返','convention']
for i in member:
	print(i, len(i))

结果：
征途 2
黑夜 2
宵禁 2
迷途知返 4
convention 10

range

语法：range(start,stop,step)
从start开始直到stop-1，步进为step

for i in range(1,9,2)
	print(i)

结果为：1 3 5 7

break&continue

break退出当前循环体
continue后面的循环体不再执行，跳到下一次循环

LESSON 10&11 数组基本操作

列表
列表比数组更强大，可以容纳不同“类型”的数据
如：member = [1,‘整’，2.67，[1,2,3]]

向列表添加元素
 append(一次只能添加一个元素)
  member.append(‘inhibit’)
  此时member = [1,‘整’，2.67，[1,2,3],‘inhibit’]
 extend(添加另一个列表里的元素)
  member.extend([‘prohibit’,‘embassy’,‘sporadically’])
  此时member =[1,‘整’，2.67,[1,2,3],‘inhibit’,‘prohibit’,‘embassy’,‘sporadically’]
 insert(指定位置，元素）——指定位置添加元素
  member.insert(0,‘stir’）
  此时member = [‘stir’,1,‘整’，2.67,[1,2,3],‘inhibit’,‘prohibit’,‘embassy’,‘sporadically’]

从列表删除元素
 remove(删除某个元素)
  member.remove(‘整’)
  此时member = [‘stir’,1,2.67,[1,2,3],‘inhibit’,‘prohibit’,‘embassy’,‘sporadically’]
 del(删除某一个元素)
  del member[1]
  此时member = [‘stir’,2.67,[1,2,3],‘inhibit’,‘prohibit’,‘embassy’,‘sporadically’]
  del member是删掉整个列表里面的元素
 pop(删除某个元素，缺省时删除最后一个)
  member.pop(1)
  此时member = [‘stir’,[1,2,3],‘inhibit’,‘prohibit’,‘embassy’,‘sporadically’]
  另外这时候可以把member.pop(1)赋值给别的变量

列表分片
  member[1:5]
  此时得到一个新的列表从member[1]到member[4] 不包括member[5]

LESSON 12 数组操作符

1. ‘>’ 比较第一个元素的大小
2. ‘+’ 列表1+列表2 得到两个列表的拼接
3. '’ 列表3得到这个列表复制三次

元素 in 列表
‘embassy’ in member
返回bool类型的值：True
‘embassy’ not in member
返回bool类型的值：False
但是in不能判断列表里面的列表的元素
1 in member
返回bool类型的值：False
对于嵌套列表寻找元素：可以写member[1][2],此时找到3

count
member.count(元素）
功能：计算这个元素出现的次数，不算嵌套

index
member.index(元素，start，stop）
功能：找到从start到stop-1范围里这个元素第一次出现的位置

reverse
member.reverse()
功能：原地翻转

sort
member.sort()
功能：从小到大排序
member.sort(reverse)
功能：从大到小排序

注意
list2 = list1[:] 和 list3 = list1
同样是复制一份列表，但前者赋值后对list1的操作不改变list2，后者改变list1时list3也会变，解释如下：

LESSON 13 元组—戴枷锁的列表

戴枷锁即元组的元素是无法被修改的
创建一个元组：
tuple1 = (1, 2, 3, 4, 5, 6, 7)
确保创建的变量类型为元组关键在逗号
temp1 = (1) 它是一个整形
temp2 = (1, ) 它是一个元组
temp3 = ( ) 它是一个空元组

LESSON 14 字符串内建函数

函数	功能
capitalize()	将字符串的第一个字符转换为大写
center(width, fillchar)	返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格
count(str, beg= 0,end=len(string))	返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
bytes.decode(encoding=“utf-8”, errors=“strict”)	Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回
encode(encoding=‘UTF-8’,errors=‘strict’)	以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’
endswith(suffix, beg=0, end=len(string))	检查字符串是否以suffix代表的字符串结束，如果beg 或者 end 指定则检查指定的范围内是否以suffix代表的字符串结束，如果是，返回 True,否则返回 False.
expandtabs(tabsize=8)	把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8
find(str, beg=0, end=len(string))	检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
index(str, beg=0, end=len(string))	跟find()方法一样，只不过如果str不在字符串中会报一个异常
isalnum()	如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
isalpha()	如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
isdigit()	如果字符串只包含数字则返回 True 否则返回 False
islower()	如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
isnumeric()	如果字符串中只包含数字字符，则返回 True，否则返回 False
isspace()	如果字符串中只包含空白，则返回 True，否则返回 False
title()	返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
istitle()	如果字符串是标题化的(见 title())则返回 True，否则返回 False
isupper()	如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
join(seq)	以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
len(string)	返回字符串长度
ljust(width[, fillchar])	返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格
rjust(width,[, fillchar])	返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
lower()	转换字符串中所有大写字符为小写
lstrip()	截掉字符串左边的空格或指定字符
replace(old, new [, max])	把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次
rfind(str, beg=0,end=len(string))	类似于 find()函数，不过是从右边开始查找
rindex( str, beg=0, end=len(string))	类似于 index()，不过是从右边开始
rstrip()	删除字符串字符串末尾的空格
startswith(substr, beg=0,end=len(string))	检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查
strip([chars])	在字符串上执行 lstrip()和 rstrip()
swapcase()	将字符串中大写转换为小写，小写转换为大写
translate(table, deletechars="")	根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
upper()	转换字符串中的小写字母为大写
zfill (width)	返回长度为 width 的字符串，原字符串右对齐，前面填充0
isdecimal()	检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false

具体用法见：link

LESSON 15 格式化

format方法

它接受位置参数和关键字参数
例：

"{0} Love {1}".format("I", "Python")

得到： I Love Python

"{a} Love {b}".format(a="I", b="Python")

得到：I Love Python

位置参数和关键字参数混用时位置参数要放在前面

"{0} Love {a}".format("I", a="Python")

得到：I Love Python

注意

"{{0}}".format("不打印"）

运行结果：’{0}’
**原因：**类似于print(’\\’)结果为’\’，{0}不是位置参数，因此没有地方输出"不打印"

"{0:.1f}{1}".format(27.658, 'GB')

运行结果：27.7GB
解释：依然是0和1两个位置参数，但是.1f规定了{0}这个位置是定点数且保留1位小数

字符串格式化符号

以下实例怎么理解：如"%c %c %c" % (97,98,99)"，就是97，98，99被翻译（%）利用规则（%c %c %c）翻译成了’a b c’

符号	描述	实例	结果
%c	格式化字符及其ASCII码	"%c" % 97	‘a’
		"%c %c %c" % (97,98,99)"	‘a b c’
%s	格式化字符串	"%s" % 'I love Python'	‘I love Python’
%d	格式化整数	"%d + %d = %d" % (4,5,4+5)	‘4 + 5 = 9’
%o	格式化无符号八进制数	"%o" % 8	‘10’
%x	格式化无符号十六进制数	"%x" % 160	‘a0’
%X	格式化无符号十六进制数(大写)	"%X" % 160	‘A0’
%f	格式化浮点数字，可指定小数点后的精度	"%.2f" % 27.658	‘27.66’
%e	用科学计数法格式化浮点数	"%e" % 27.658	‘2.765800e+01’(默认6位小数)
%E	用科学计数法格式化浮点数	"%e" % 27.658	‘2.765800E+01’(默认6位小数)
%g	根据值的大小选用%f或%e
%G	根据值的大小选用%f或%E

更多用法见：link

格式化操作符辅助指令

符号	功能	实例	结果
m.n	m是显示的最小总宽度,n是小数点后的位数	"%7.1f" % 27.658	’  27.7’
-	用做左对齐	"%-9d" % 5	'5    ’
+	在正数前面显示加号( + )	"%+8d" % 5	'+5   ’
#	在八进制数前面显示零(‘0o’)，在十六进制前面显示’0x’或’0X’	"%#o" % 8	‘0o10’
		"%#x" % 108	‘0x6c’
		"%#X" % 108	‘0X6C’
0	显示的数字前面填充’0’而不是默认的空格	"%9d" % 5	‘000000005’

更多用法见：link

LESSON 16 序列内建函数

序列：列表、元组、字符串

list

将一个可迭代对象转换成列表

a = (1, 1, 2, 3, 'I love Python')
print(list(a))

输出：[1, 1, 2, 3, ‘I love Python’]

tuple

将一个可迭代对象转化成元组

a = [1, 1, 2, 3, 'I love Python']
print(tuple(a))

输出： (1, 1, 2, 3, ‘I love Python’)

str

将obj对象转换为字符串

更多内建函数

函数	功能
len	返回对象长度
max	返回序列或参数中最大值或ASCII码最大值
min	返回序列或参数中最小值或ASCII码最小值
sum	返回序列的参数总和
sorted	序列中的参数从小到大排
reversed	将序列原地翻转构成列表
enumerate	生成由每个元素的index值和item值组成的元组所构成的列表，下行举例
list(enumerate([1, 2, 'a', 'Python']))	结果：[(0, 1), (1, 2), (2, ‘a’), (3, ‘Python’)]
zip	看下面的例子
list(zip([1,2,3,4],['a','Python','d']))	结果：[(1, ‘a’), (2, ‘Python’), (3, ‘d’)] 多余的被丢弃

LESSON 17&18 函数

函数文档

解释函数功能

参数

形参和实参

形参：函数定义过程中的参数
实参：函数发生作用时传递进来的参数

关键字参数

当参数过多时，直接写某个parameter=…，若省略‘parameter=’直接让程序自己索引参数，可能会出现顺序紊乱。

def Saysomething(name, words)
	print(name + '->' + words)

Saysomething(words='没问题', name='我')

输出：我->没问题
若没加name=和words=，则
输出：没问题->我

默认参数

定义了默认值的参数，于是调用时若不给其赋值，程序也不会报错。

收集参数

因为有时候搞不清楚到底需要几个参数，就诞生了这种参数

def test(*params, exp):
	print('参数的长度是：', len(params), 'exp =', exp)
	print('第二个参数是：', params[1])

test(1, 'Python', 89, -6, 3.14, 'excess')

结果：
参数的长度是：5 exp = excess
第二个参数是：Python

LESSON 19 函数与过程

局部变量和全局变量

def discounts(price,rate):
	final_price = price * rate
	old_price = 50
	print('修改后的old_price的值1：'，old_price)
	return final_price
old_price = float(input('请输入原价：'))
rate = float(input('请输入折扣率：'))
new_price = discounts(old_price, rate)
print('修改后old_price的值2：', old_price)
print('打折后的价格是：', new_price)
print('这里试图打印局部变量final_price的值：', final_price)

程序运行过程为（假设原价100，打八折）：

请输入原价：100
请输入折扣率：0.8
修改后的old_price的值1：50
修改后old_price的值2：100
打折后的价格是：80
报错

解释

1. discounts函数里面的old_price和函数外的old_price只是名称一样的变量，前者为局部变量，后者为全局变量，它们互不影响。因此可以到看修改后old_price的值1和值2是不一样的。
2. 最后报错是因为final_price作为局部变量，它只是暂时存储在栈里，当函数内的计算完成之后，栈里面保存的变量名和值就会被清空，因此在函数外无法打印final_price的值，于是最后报错。

Global关键字

若想要在函数里面改变全局变量，用global关键字

count = 5
def Myfun():
	global count
	count = 10

print('count=', count)

此时程序运行完后输出：count=10

LESSON 20 内嵌函数和闭包

内嵌函数

def fun1():
	print('函数fun1()正在被调用...')
	def fun2():
		print('函数fun2()正在被调用...')
	fun2()

运行结果

• 函数fun1()正在被调用…
• 函数fun2()正在被调用…

执行下列语句：

fun2()

执行完该语句会报错，因为执行过程中看不到内嵌的函数，会显示fun2()并未被定义。

访问内层函数

def funOut():
    def funIn():
        print('宾果，你成功访问到我啦！')
    return funIn

funOut()()

def funOut():
    def funIn():
        print('宾果，你成功访问到我啦！')
    return funIn()

funOut()

二者执行结果均为:

宾果，你成功访问到我啦！

区别：
return时一个funIn带括号，而另一个不带括号。

• 不带括号时，调用的是这个函数本身，是整个函数体，不须等函数执行完成。
• 带括号时，调用的是函数执行的结果，须等函数执行完成的结果。、

可以理解成没有括号只是调用了函数名字，而加了括号才会执行函数。

因此对于第一种代码，可以用如下方法调用：

go = funOut()
go()

闭包

内部函数调用了外部函数的参数（存疑）

def FunX(x):
	def FunY(Y)
		return x * y
	return FunY

执行下列语句：

i = Funx(8)

相当于此时给x赋值为8，而 i 的类型为一个函数

i(5)

返回结果：40

上述两个语句相当于：

Funx(8)(5)

这个语句相当于给x赋值8，给y赋值5，因此输出为40

nonloca

内部函数不能够修改外部函数的参数值

def Fun1():
	x = 5
	def Fun2():
		x *= 5
		return x
	return Fun2()

执行后报错并提示
UnboundLocalError： local variable ‘x’ referenced before assignment

解释：函数Fun1的参数x相对于Fun2来说是“全局变量”，因此它是无法直接进行修改的（可以直接调用），当它试图修改时，Python就会使用屏蔽(shadowing) 具体做法就是新建一个用栈存储的和“全局变量x”名字相同的变量，而当我们试图修改这个变量时，因为我们之前没有对其进行赋值，于是报错提醒我们referenced before assignment.

解决方法：nonlocal

def Fun1():
	x = 5
	def Fun2():
		nonlocal x
		x *= 5
		return x
	return Fun2()

执行语句：

• Fun1()

此时执行结果：25

LESSON 21 lambda表达式

使用lambda关键字来创建匿名函数

def add(x, y):
	return x + y

add(3, 4)

效果和下列的lambda语句一样

g = lambda x, y : x + y
g(3, 4)

lambda表达式的作用

• Python写一些执行脚本时，使用lambda就可以省下定
  义函数过程，比如说我们只是需要写个简单的脚本来管
  理服务器时间，我们就不需要专门定义一个函数然后再
  写调用，使用lambda就可以使得代码更加精简。
• 对于一些比较抽象并且整个程序执行下来只需要调用一
  两次的函数，有时候给函数起个名字也是比较头疼的问
  题，使用lambda就不需要考虑命名的问题了。
• 简化代码的可读性，由于普通的函数阅读经常要跳
  到开头def定义部分，使用lambda函数可以省去这样的
  步骤。

两个BIF（内建函数）

filter

• 将一个可迭代的序列作为函数的参数计算后，取出其中计算结果为true的对象
• 如果函数是none，则直接取出值=true的对象。

def odd(x):
	return x %2 
temp = range(10)  #返回0~9
show = filter(odd, temp)
list(show)

运行结果：

• [1, 3, 5 ,7 ,9]

解释：将temp里面的值作为odd函数的参数计算时，1.3.5.7.9返回值为1，即为true，它们筛选后返回给show

使用lambda表达式精简代码

list(filter(lambda x: x % 2, range(10)))

从上面两个代码片中可以看出：lambda x: x % 2和定义的odd函数效果等价

map

用作映射（跟数学中的函数映射的解释差不多）
例如实现y=2x这个函数（x=0,1,2,3,…,9）

list(map(lambda x : x * 2, range(10)))

执行结果为：
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

LESSON 22&23&24 递归

特征

• 调用函数自身
• 设置了正确的返回值

例如写一个计算阶乘的函数

def factorial(n):
	if n == 1:
		return 1
	else:
		return n * factorial(n-1)

number = int(input('请输入一个正整数：'))
result = factorial(number)
print('%d 的阶乘是： %d ' % (number, result))

执行结果为（假设输入5）：

请输入一个正整数：5
5 的阶乘是: 120

计算过程，主要红色箭头，是递归中 归 的过程

汉诺塔

def hanoi(n, x, y, z):
	if n == 1:
		print(x, ' --> ', z)
	else:
		hanoi(n-1, x, z, y) # 将x上前n-1个借助z移动到y上
		print(x, ' --> ', z) # 将x上最底下的移动到z
		hanoi(n-1, y, x, z) # 将y上n-1个借助x移动到z

n = int(input('请输入汉诺塔层数：'))
hanoi(n, 'X', 'Y', 'Z')

递归思路：

LESSON 25&26 字典

字典是python中唯一的映射类型

• 字典是键(key)值(value)组合而成，每个键值组合之间用逗号隔开
• 标志性符号为{}
• 索引时，索引值不像序列一样用0开始的整数索引，而是用键来索引，键可以是整形，字符串，字符等等类型。

dict1 = { '李宁':'一切皆有可能', "耐克":'Just do it', '阿迪达斯':'Nothing is impossible", "鱼c工作室':'让编程改变世界'}
print('鱼c工作室的口号是:', dict1['鱼c工作室'])

结果：

鱼c工作室的口号是：让编程改变世界

dict2 = {1:'one', 2：'two', 3:'three'}
print(dict[2])

结果：

‘two’

借助dict函数创建字典

dict3 = dict((('F',70), ( 'i',105), ( 's',115), ('h',104), ('C',67)))

括号的解释：
这种用法为dict(mapping)，它应该只有一个参数，因此各个键值组合要用一个括号括起来，然后dict本身一层括号，所以总共两层括号：
(((‘F’,70), ( ‘i’,105), ( ‘s’,115), (‘h’,104), (‘C’,67)))

用关键字形式创建字典

给字典的键赋值时

• 若键原先存在，则改变键对应的值
• 若键原先不存在，则添加新的键值组合

dict4 = dict(小甲鱼='让编程改变世界', 李宁='一切皆有可能')
dict4['小甲鱼'] = 'I love Fishc.com'
dict4['耐克'] = 'Just do it'
print(dict4)

结果：

{‘小甲鱼’: ‘I love Fishc.com’, ‘李宁’: ‘一切皆有可能’, ‘耐克’: ‘Just do it’}

字典的内建方法

formkeys

dict.fromkeys(s[,v])
s为键名，v为键值（只能有一个参数）赋给所有的键名

dict1 = {}
dict1 = dict1.fromkeys((1, 2, 3), ('one', 'two', 'three' ))
print(dict1)

结果：

{1:( ‘one’, ‘two’, ‘three’), 2: ( ‘one’, ‘two’, ‘three’), 3: (‘one’, ‘two’, ‘three’)}

说明对于所有的键名都只能赋同样的值

基于上一行代码若再执行下面的代码：

dict1 = dict1.fromkeys((1, 3),'Number')
print(dict1)

结果：

{1: ‘Number’, 3: ‘Number’}

说明不能对其进行批量修改，只会新建一个字典

keys()、values()、items()

• dict1.keys()返回字典dict1里的键名
• dict1.values()返回字典dict1里的键值
• dict1.items()返回字典dict1里的每一项键值组合

dict1 = {}  #声明dict1是字典
dict1 = dict1.fromkeys(range(5),'赞')
print(dict1, end='\n')
for eachKey in dict1.keys():
	print(eachKey, end=',')
print()
for eachValue in dict1.values():
	print(eachValue, end=',')
print()
for eachItem in dict1.items():
	print(eachItem, end=',')

结果：

{0: ‘赞’, 1: ‘赞’, 2: ‘赞’, 3: ‘赞’, 4: ‘赞’}
0,1,2,3,4,
赞,赞,赞,赞,赞,
(0, ‘赞’),(1, ‘赞’),(2, ‘赞’),(3, ‘赞’),(4, ‘赞’),

get()

利用get()进行索引可以规避键名不存在带来的报错，例如对于上面的dict1

print(dict1.get(5))
print(dict1.get(4))

结果：

None
赞

并且进一步的可以规定索引的键名不存在时的返回值,并且不会影响既定的键名对应的键值

print(dict1.get(5, '无！'))
print(dict1.get(4, '无！'))

结果：

无！
赞

成员操作符在字典里的应用

成员操作符：in、not in

序列和字典使用成员操作符的区别：

• 序列查找的是元素的值
• 字典里面查找的键名

4 in dict1
5 in dict1

结果：

True
False

清空字典clear()

dict1.clear()
建议使用clear清空字典，这样子若之前有一步操作是dict2 = dict1，dict2里存放的信息也会清空掉
使用上面的dict1：

• 情形一

dict2 = dict1
dict1 = {}
print(dict1)
print(dict2)

结果：

{}
{0: ‘赞’, 1: ‘赞’, 2: ‘赞’, 3: ‘赞’, 4: ‘赞’}

• 情形二

dict2 = dict1
dict1.clear()
print(dict1)
print(dict2)

结果：

{}
{}

copy()

dict2 = dict1
dict3 = dict1.copy()
dict1[5] = '赞'
print(dict1)
print(dict2)
print(dict3)

结果：

{0: ‘赞’, 1: ‘赞’, 2: ‘赞’, 3: ‘赞’, 4: ‘赞’, 5: ‘赞’}
{0: ‘赞’, 1: ‘赞’, 2: ‘赞’, 3: ‘赞’, 4: ‘赞’, 5: ‘赞’}
{0: ‘赞’, 1: ‘赞’, 2: ‘赞’, 3: ‘赞’, 4: ‘赞’}

和赋值不同，copy是把数据拷贝一份，而存放的地址不同，因此对dict1的变化不影响dict3

LESSON 27 集合

特征

• 用花括号括起来一堆数据
• 但是没有体现映射关系（有映射关系的是字典）

特点：

• 无序性，因此没办法通过index索引
• 唯一性，相同的元素只保留一个

创建集合

• 方法一：直接把一堆元素用花括号括起来，逗号隔开
• 方法二：使用set()工厂函数，括号里面是序列

不可变集合 frozenset()

该集合不可被改变

内置方法

link
link

LESSON 28 文件

将一个文件对象(f)的数据存放进列表中：
list(f)操作即可

打开文件 open()

语法：

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

常用形式是接收两个参数：

open(file, mode='r')

mode参数控制文件打开的模式：link

file对象常用函数

file.close()

关闭文件。虽然python有垃圾回收机制——当文件对象的引用计数降为0时自动关闭文件，不会导致内存泄漏，但是若你对文件完成写入后没有及时关闭，此时遇到突发的断电会导致文件丢失。因此用完文件要及时关闭。

file.seek(offset[, whence])

• offset: 开始的偏移量，也就是代表需要移动偏移的字节数，如果是负数表示从倒数第几位开始。
• whence: 可选，默认值为 0。给 offset 定义一个参数，表示要从哪个位置开始偏移；0 代表从文件开头开始算起，1 代表从当前位置开始算起，2 代表从文件末尾算起。

file.tell()

返回当前文件指针的位置

file.read([size])

从文件当前指针位置（注意不是从文件头）读取size个字节，如果size未给定或为负则读取所有。

更多内置方法：link