杭师管科python专业课线上笔记（一）：python易错基础知识笔记（141分）

先说下成绩，在对的改错一道5分填空题的情况下141分。应该是代码题被老师挑刺挑出了4分

没有买教材，因为看过真题后发现总共快30章的书实际上只考其中6章（1-5，11），买的话有点亏，就从网上整了个电子版，如有需要的可以评论个邮箱，没必要细看，只需要过一遍就好了
注：为更好贴合教材，标题以书中为准；为更好理解，标题较原书中会有改动（书翻译得是真不咋样…

软件的话去下一个Anaconda，用里面的spyder就好了

0 2022考纲要求

1 基础知识

1.3 数和表达式

除法和整除的区别

• 除法的运算结果是浮点数（即小数）

>>> 1/2
0.5
>>> 1/1
1.0
>>> 

• 整除可以丢弃小数部分，用双斜杠 （但其实原理是得到不大于结果的最大整数）

>>> 1//2
0
>>> 1//1
1
>>> 5.0//2.4
2.0

求模运算

• “%”是求模运算，取余数

>>> 10%3
1
#10÷3=3······1

负数整除与负数求模（手算方式总结，大概率不考）

• 负数整除

>>> 10//-3
-4
>>> -10//3
-4
>>> -10//-3
3

10÷-3=-3.333 --> -4<-3.333
-10÷3=-3.333 --> -4<-3.333
-10÷-3=3.333 --> 3<3.333
原理是得到不大于结果的最大整数

• 负数求模

>>> 10%-3
-2
>>> -10%3
2
>>> -10%-3
-1

10//-3=-4 --> -4X-3=12 --> 10-12=-2
-10//3=-4 --> -4X3=-12 --> -10-(-12)=2
-10//-3=3 --> 3X-3=-9 --> -10-(-9)=-1
理解并模仿上述流程即可（实在难以拿话总结出来了…

乘方优先级比取负高

• 即-(3**2)

>>> -3**2
-9

命名规则

• python变量命名规则：只能由数字、字母、下划线组成，不能以数字带头，不能是保留字（如：def）。

1.7 常见函数

pow()

• 表示乘方

>>> pow(2,3)
8

round()

• 用于将浮点数转换为最接近的整数，注round(0.5)=0

>>> round(0.5)
0
>>> round(0.51)
1
>>> round(0.49)
0

sqrt()

• 表示平方根

>>> from math import sqrt
>>> sqrt(9)
3.0
>>> sqrt(-1)
Traceback (most recent call last):
  File "<pyshell#11>", line 1, in <module>
    sqrt(-1)
ValueError: math domain error

或import math
使用时用math.sqrt()

2 列表和元组

2.2 序列

切片及步长

• 切片指定步长可以跳过一些元素
• 注意，步长为负数时，从右向左提取元素=，因此前者下标对应的元素要在后者下标对应元素的后面

>>> list=[1,2,3,4,5,6,7,8,9,10]
>>> list[-3:-1]
[8, 9]
>>> list[0::2]
[1, 3, 5, 7, 9]
>>> list[::4]
[1, 5, 9]
>>> list[8:3:-2]
[9, 7, 5]
>>> list[9:-3:-1]
[10, 9]

序列加法

• 加法可以拼接同类型序列

>>> [1,2]+[3]
[1, 2, 3]
>>> 'he'+'llo'
'hello'
>>> [1,2]+'h'
Traceback (most recent call last):
  File "<pyshell#29>", line 1, in <module>
    [1,2]+'h'
TypeError: can only concatenate list (not "str") to list

序列乘法

• 序列与x相乘，重复x次创建新序列

>>> [1,2]*8
[1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
>>> 'haha'*4
'hahahahahahahaha'

判断成员资格

• ‘in’、‘not in’运算符判断成员资格

>>> 'w'in'w1'
True
>>> 'w'in'q1'
False
>>> '1'in[1,2,3]
False
>>> 1 in [1,2,3]
True
>>> 1 not in [1,2,3]
False

2.3 列表

2.3.1 list和str相互转换

>>> list('hello')
['h', 'e', 'l', 'l', 'o']
>>> ''.join(['w','o','r','l','d'])
'world'

2.3.2 基本列表操作

索引赋值

• 索引可以给列表直接赋值，从而更改列表某一元素

>>> list=[1,1,1]
>>> list[2]=3
>>> list
[1, 1, 3]

切片赋值

-可以用切片进行多个元素的赋值，且可以替换成长度不同的序列

>>> name=list('Perl')
>>> name
['P', 'e', 'r', 'l']
>>> name[2:]=list('ar')
>>> name
['P', 'e', 'a', 'r']
>>> name[1:]=list('ython')
>>> name
['P', 'y', 't', 'h', 'o', 'n']
>>> name[2:]=[]
>>> name
['P', 'y']

2.3.3 列表方法

len()

• len()用于列表长度计算

>>> list=[1,2]
>>> a=len(list)
>>> a
2

append()与extend()的区别

• append()用于将对象作为单个元素加到列表末尾

>>> list=[1,2]
>>> list.append(3)
>>> list
[1, 2, 3]
>>> list.append([4,5])
>>> list
[1, 2, 3, [4, 5]]

• extend()用于将一个列表的多个值加到列表末尾
• extend()效果与列表加法一样

>>> list=[1,2,3]
>>> list.extend([4,5])
>>> list
[1, 2, 3, 4, 5]

clear()

• 清空列表内容，返回空列表。

常规复制与copy()复制的区别

• 不使用copy()，常规复制只是将名称进行关联，list和list1指向同一个列表。

>>> list=[1,2,3]
>>> list1=list
>>> list[1]=4
>>> list1
[1, 4, 3]

• copy()
  copy()用于创建副本，list1与list的副本关联

>>> list=[1,2,3]
>>> list1=list.copy()
>>> list1[1]=4
>>> list1
[1, 4, 3]
>>> list
[1, 2, 3]

count()

• 计算指定元素在列表中出现了多少次

>>> [1,2,3,4,'1',1].count(1)
2

index()

• 查找指定值第一次所出现的索引

>>> [1,2,5,7,5,1].index(5)
2

insert()

• 将一个元素插入列表中，让该元素成为前面指定的下标

>>> list=[1,2,3,4,5]
>>> list.insert(3,'a')
>>> list
[1, 2, 3, 'a', 4, 5]

pop()

• 从列表删除一个元素，未指定则删除末尾最后的元素。并返回这一元素。
  pop是唯一既修改列表又返回一个非None值的列表方法

>>> list=[1,2,3]
>>> list.pop()
3
>>> x=list.pop(0)
>>> list
[2]
>>> x
1

remove()

• 删除第一个指定的元素，不是传入索引

>>> list=[9,8,7,6,5,4,3,2,1]
>>> list.remove(1)
>>> list
[9, 8, 7, 6, 5, 4, 3, 2]
>>> list.remove(9)
>>> list
[8, 7, 6, 5, 4, 3, 2]

reverse()

• 不进行排序，反向排列列表元素。

>>> list=[1,2,3]
>>> list.reverse()
>>> list
[3, 2, 1]

sort()

• 对列表进行排序，默认升序。设置reverse=True变成降序。

>>> list=[4,6,2,1,7,9]
>>> list.sort()
>>> list
[1, 2, 4, 6, 7, 9]
>>> list=[4,6,2,1,7,9]
>>> list.sort(reverse=True)
>>> list
[9, 7, 6, 4, 2, 1]

set()

• 去掉列表中重复的元素，可以通过list(set())将其转化为列表形式

>>> l1=[2,1,4,4,3,2]
>>> set(l1)
{1, 2, 3, 4}
>>> list(set(l1))
[1, 2, 3, 4]

enumerate()

• 主要用于需要同时取出下标和值的列表

>>> l1=[2,1,4,4,3,2]
>>> for index,value in enumerate(l1):
	print(f'下标为{index},值为{value}')

	
下标为0,值为2
下标为1,值为1
下标为2,值为4
下标为3,值为4
下标为4,值为3
下标为5,值为2

2.4 元祖（基本不考）

创建元组

>>> 1,2,3
(1, 2, 3)
>>> ()
()
>>> 42,
(42,)
>>> 3*(40+2,)
(42, 42, 42)

tuple()

• 可以将一个序列转换为元祖

>>> tuple([1,2,3])
(1, 2, 3)
>>> tuple('abc')
('a', 'b', 'c')

访问元素

• 索引和切片同样可以应用在元组。

>>> x=1,2,3
>>> x[1]
2
>>> x[0:]
(1, 2, 3)

3 字符串

3.2 字符串格式

format()

-用于将括号内的值替换成花括号的值

>>> "{},{} and {}".format('one','two','three')
'one,two and three'
>>> "{2},{1} and {0}".format('one','two','three')
'three,two and one'

3.3 字符串格式（完整版）

字段名替换

>>> "{a} is {b:.2f}".format(a='pi',b=3.141415926)
'pi is 3.14'
>>> '{foo}{1}{bar}{0}'.format(1,2,bar=4,foo=3)
'3241'

宽度和精度
{x:m.nf}，表示对浮点数x保留n位小数，m宽度

>>> "{pi:10.2f}".format(pi=3.1415926)
'      3.14'

3.4 字符串方法

center()

• 用于在两边填充字符（默认空格），让字符串居中

>>> 'Middle'.center(12,'#')
'###Middle###'

find()

• 查找子串，返回子串的第一个字符的索引，没有查到则返回-1

>>> '123456789'.find('678')
5
>>> '123456789'.find('679')
-1

join()

• 用于合并序列中的元素，str.join(list),

>>> seq=['1','2','3']
>>> seq.join('+')
Traceback (most recent call last):
  File "<pyshell#62>", line 1, in <module>
    seq.join('+')
AttributeError: 'list' object has no attribute 'join'
>>> '+'.join(seq)
'1+2+3'

>>> a='usr','bin','env'
>>> a
('usr', 'bin', 'env')
>>> '/'.join(a)
'usr/bin/env'

lower()

• 返回字符串的小写版本

upper()

• 返回字符串的大写版本

title()

• 文章的所有单词首字母都大写

replace()

• 将子串替换为另一个字符串

>>> 'heda heheda'.replace('hehe','haha')
'heda hahada'

split()

• 拆分，与join()相反，没有指定分隔符时默认空格，注意拆分出来的是列表形式

>>> '1+2+3+4'.split('+')
['1', '2', '3', '4']
>>> '1 2 45'.split()
['1', '2', '45']

strip()

• 删除字符串开头和结尾的空白或指定字符

>>> '   23 32 '.strip()
'23 32'
>>> '##!23#33##'.strip('#')
'!23#33'

isalnum()

• 判断是否为全是字母或数字

isalpha()

• 判断是否为全是字母

isdight()

• 判断是否为全是数字

islower()

• 判断是否都是小写字母

isspace()

• 判断是否都是空白字符

4 字典

4.2创建和使用字典

4.2.1 dict()函数创建

元组列表创建

• 通过若干个元组组成的列表进行创建，通过对于key的索引进行访问

>>> list=[('nname','john'),('age',18)]
>>> d=dict(list)
>>> d
{'nname': 'john', 'age': 18}
>>> d['age']
18`

关键字实参创建

>>> d=dict(name='john',age=22)
>>> d
{'name': 'john', 'age': 22}

4.2.2 基本字典操作

len()

• 用于返回键值对的数量

dict[k]

• 返回键k对应的值

dict[k]=v

• 将值v关联到键k

del dict[k]

• 删除键k的键值对

k in dict

• 检查dict中是否包含键为k的项

直接创建键值对

>>> dict={}
>>> dict['age']=18
>>> dict
{'age': 18}

4.2.4 字典方法

clear()

• 删除所有的字典项

copy()

• copy()修改一方的值，另一方不会变化，相互独立

>>> dict={'name': 'john', 'age': 22}
>>> dict1=dict.copy()
>>> dict['age']=1
>>> dict1
{'name': 'john', 'age': 22}
>>> dict1['age']=2
>>> dict
{'name': 'john', 'age': 1}

fromkeys()

• 创建新字典，包含指定键，如不传入统一值则为None

>>> dict={}
>>> dict.fromkeys(['name','age'])
{'name': None, 'age': None}
>>> dict.fromkeys(['name','age'],'unknow')
{'name': 'unknow', 'age': 'unknow'}
>>> dict.fromkeys(['name','age'],('john',22))
{'name': ('john', 22), 'age': ('john', 22)}

get()

• 访问字典项，传入键得到值，如访问不到则返回None

>>> dict={}
>>> print(dict.get('job'))
None
>>> dict['age']=2
>>> dict
{'age': 2}
>>> dict.get('age')
2

items()、keys()、values()

• 返回包含所有字典项的列表，每个元素（key,value）形式
• keys()返回所有键，values()返回所有值

>>> dict.items()
dict_items([('name', 'unknow'), ('age', 'unknow')])
>>> dict.keys()
dict_keys(['name', 'age'])
>>> dict.values()
dict_values(['unknow', 'unknow'])

• 可以用list()转换为列表进行列表操作

>>> list(dict.values())
['unknow', 'unknow']
>>> list(dict.keys())
['name', 'age']
>>> list(dict.items())
[('name', 'unknow'), ('age', 'unknow')]

pop()

• 获取指定键的值，并将该键值对删除

>>> dict={'name': 'john', 'age': 18}
>>> x=dict.pop('age')
>>> dict
{'name': 'john'}
>>> x
18

update()

• 使用一个字典的项更新另一个字典

>>> dict={'name': 'john', 'age': 18}
>>> x={'age':28}
>>> dict.update(x)
>>> dict
{'name': 'john', 'age': 28}

5 条件、循环及其他语句

5.1 print()

通过sep设置字符的间隔

>>> x='1'
>>> y='2'
>>> z='3'
>>> print(x,y,z)
1 2 3
>>> print(x,y,z,sep='')
123
>>> print(x,y,z,sep='+')
1+2+3

通过end对末尾进行设置，默认换行

print('hello',end='') 

5.2 赋值方式

同时赋值

>>> x,y,z=1,2,3
>>> print(x,y,z)
1 2 3

交换变量值

>>> x,y=1,2
>>> x,y=y,x
>>> print(x,y)
2 1

增强赋值

>>> x=2
>>> x+=1
>>> x
3
>>> x*=4
>>> x
12

5.4 条件语句

记得条件语句的最后要加冒号“:”
用and和or表示且和或， 不要用C语言的&和||
用elif，不要用C语言的else if

5.5 循环语句

5.5.1 while循环

注意，while循环的最终退出结果不符合while的条件

>>> while a<10:
	a+=3
>>> print(a)
12

5.5.2 for循环

range相关

• range(x)表示区间[0,x)，左闭右开
• range(x,y)表示区间[x,y)，左闭右开
• range(x,y,z)表示步长为z，不管z的正负，仍是左闭右开，

5.5.3 字典遍历

>>> dict={'x':1,'y':2,'z':3}
>>> for key in dict:
	print(key,dict[key])
x 1
y 2
z 3
>>> for key,value in dict.items():
	print(key,value)
x 1
y 2
z 3

5.5.4 迭代工具

zip()序列缝合

• 用于将多个序列缝合起来

>>> name=['x','y','z']
>>> age=[1,2,3]
>>> for i,j in zip(name,age):
        print('name:',i,',','age:',j,'.')
name: x , age: 1 .
name: y , age: 2 .
name: z , age: 3 .

enumerate()获取索引

>>> string='abcdefg'
>>> for index,char in enumerate(string):
	print('index:',index,',','char:',char,'.')
index: 0 , char: a .
index: 1 , char: b .
index: 2 , char: c .
index: 3 , char: d .
index: 4 , char: e .
index: 5 , char: f .
index: 6 , char: g .

reversed()反向迭代

>>> ''.join(reversed('hello,world'))
'dlrow,olleh'

5.5.5 跳出循环

break跳出整个循环；continue跳出本次循环，进行下一次，不结束循环

5.5.6 for-else循环

用于判断循环是break提前结束还是循环完正常结束

输出结果为Didn’t find it!

5.5.5 列表推导式

用于快速创建列表

>>> [x*x for x in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> [x*x for x in range(10) if x % 3==0]
[0, 9, 36, 81]
>>> [(x,y) for x,y in enumerate('abcdefg')]
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd'), (4, 'e'), (5, 'f'), (6, 'g')]

11 基于python的txt文件操作(教材11章，P213)

11.1 打开文件模式

• ‘r’、‘rt’：读取模式（默认值）
• ‘w’：写入模式，文件不存在会直接创建，删除原有内容
• ‘a’：附加模式，不删除原有内容，在其后继续写入
• ‘+’：和其他模式结合使用，读取+写入
  ‘r+’：读取+写入，不删除原有内容，‘w+’：读取+写入，删除原有内容
• ‘t’：和其他模式结合使用，Unicode文本，UTF-8模式（默认）
• ‘b’：和其他模式结合使用，二进制模式

11.2 文件的基本方法

• open()
  打开文件，传入文件模式，默认‘rt’
• write()
  将提供的字符串写入既有文件的后面。
  注：不要与’w’模式搞混
• read()
  read()将文本全部输出，若内有数字，则输出前X个字符，\n也算。多多次重复read()，则已读取的字符不算在内

f=open('something.txt','w') #创建something.txt文件，写入模式
f.write('Hello,') #写入Hello,
f.write('world!') #在末尾写入world！
结果：
同目录下产生something.txt文件，内容为：Hello，world！
-------------------------------------------------------------
f=open('something.txt','r') #读模式打开
print(f.read(5)) #读取前5个字符
print(f.read()) #读取余下的字符
结果：
Hello
,world!
-------------------------------------------------------------
f=open('something.txt','w') #写入模式打开something.txt文件，删除原有内容
f.write('123') # 写入123
f.close()
结果：
原内容消失，文件内容为：123

---

• with open(filepath) as f:语句
  打开文件，赋给f变量
• readline() 读取一行，readlines()将各行以列表形式读取

（文本内容）
Welcome to this file
There is nothing here except
This stupid haiku

with open('something.txt') as f:
    for i in range(3):
        print(str(i)+':'+f.readline(),end='')#文件内自带了换行，所以此处不换行，否则会空出一个空白行
结果：
0:Welcome to this file
1:There is nothing here except
2:This stupid haiku

with open('something.txt') as f:
    print(f.readlines()) #将文本各行以列表形式读取
结果：
['Welcome to this file\n', 'There is nothing here except\n', 'This stupid haiku']

---

• writelines(list)
  传入字符串元素的列表，依次写入文件

（文本内容）
Welcome to this file
There is nothing here except
This stupid haiku

with open('something.txt') as f:
    lines=f.readlines()#将文本各行以列表形式读取
    lines[0]='hello\n'
    lines[1]='world\n'

with open('something.txt','w') as f:
    f.writelines(lines)
结果：
hello
world
This stupid haiku

11.3 迭代文件内容

（本节文本内容）
hello
world

11.3.1 每次一个字符

with open('something.txt') as f:
    while True:
        char=f.read(1)
        if not char : break
        print('Processing:', char)
结果：
Processing: h
Processing: e
Processing: l
Processing: l
Processing: o
Processing: 

Processing: w
Processing: o
Processing: r
Processing: l
Processing: d
Processing: 

11.3.2 每次一行

with open('something.txt') as f:
    while True:
        line=f.readline()#读取一行
        if not line : break
        print('Processing:', line,,end='')#文件内自带了换行，所以此处不换行，否则会空出一个空白行
结果：
Processing: hello
Processing: world

11.3.3 读取所有内容

使用read()以字符串形式读取
readlines()以列表形式读取