python期末复习精简版

期末复习精简版

第1章

1.6 Python编程规范与代码优化建议

• 注释

以符号#开始，表示本行#之后的内容为注释。

• 缩进

  • 类定义、函数定义、选择结构、循环结构、with快，行尾的冒号表示缩进的开始。
  • Python是依靠代码块的缩进来体现代码之间的逻辑关系的，缩进结束就表示一个代码块结束了。
  • 同一个级别的代码块的缩进量必须相同。
  • 以4个空格为基本缩进单位。

• 最好在每个类、函数定义和一段完整的功能代码之后增加一个空行

• 尽量不要写过长的语句。如果语句确实太长而超过屏幕宽度，最好使用续行符\，或者使用圆括号将多行代码括起来表示是一条语句。

• 虽然Python运算符有明确的优先级，但对于复杂的表达式建议在适当的位置使用括号使得各种运算的隶属关系和顺序更加明确、清晰。

• 每个import语句只导入一个模块，最好按标准库、扩展库、自定义库的顺序依次导入。

1.7 模块 模块的导入方式

import math
import math as a
from math import* 
from math import pow,e

第2章

了解变量的命名规则

标识符命名规则：

• 标识符由**大小写字母、数字、下划线、汉字**组成
• 变量名**不能以数字**开头
• 变量名是**区分大小写**的
• 变量名不能有空格以及标点符号（括号、引号、逗号、斜线、反斜线、冒号、句号、问号等）

知道 type函数和isinstance函数功能
type函数

• 功能：type()函数查看变量类型
• 格式：type(变量)

>>> a=100
>>> type(a)
<class 'int'>

isinstance函数

• 功能：isinstance函数判断变量是否为指定的类型

• 格式：isinstance(变量,类型)

>>> a=100
>>> isinstance(a,int)
True

input()函数 、eval()函数、 print()函数

input()函数

• 功能：input()函数执行时在屏幕上显示提示字符串，用户输入完毕后，并将用户输入都以文本形式返回。

• 格式：<变量>=input(<提示性文字>)

  >>> x=input("请输入x值：")
  请输入x值：100
  >>> x
  '100'   # 字符类型
  

  input的所有值都是以文本形式表达的

eval()函数

• 功能：eval()函数用于执行一个字符串表达式，并返回表达式计算结果值

• 格式：eval(<字符串>)

>>> x =4 
>>> "3*x"
'3*x'
>>> eval('3*x')
12
>>> eval('pow(x,2)')
16
>>> eval("'3*x'")
'3*x'

print()函数

• 功能：print()函数用来输出字符信息。print()函数可以输出各种类型变量的值

• 常用格式：

  1.print(): 用于输出一个空白行

  2.print(<表达式>): 在屏幕显示表达式的值

  3.print(<表达式1>, <表达式2>, …, <表达式n>): 将各表达式的值从左到右显示在同一行

[例]

print("Hello")
print()         # 输出一个空白行
print(3+2,1+2,"hello")  
print("here")  
print(3+2,1+2,"hello",end=";")  # 用分号作为分隔符，把回车符修改掉打在同一行
print("here")

程序结果：

Hello

5 3 hello
here
5 3 hello;her

[例]

a ="有理想"
print(a,"有担当")
print()
print("有本领",end="")
print("青年一代")

运行结果：

有理想 有担当

有本领青年一代

第3章

熟悉 数据类型

3.2.1 算术运算操作符

操作符	描述
x+y	x与y之和
x-y	x与y之差
x*y	x与y之积
x/y	x与y之商
x//y	x与y之整数商，向下取整
x%y	x与y之商的余数
-x	x的负值，即：x*（-1）
+x	x本身
x**y	x的y次幂$x^y$，等价于pow(3,2)

3.2.2关系运算操作符

<(小于)、> (大于)、<= (小于等于)、 >=(大于等于)、 ==(等于)、!=(不等于)

3.2.3逻辑运算符

and（与）:两边都是真，结果为真
or（或）：只要一个为真，结果为真
not（非）：取反

map()

map()是接收一个函数f依次映射到序列或迭代对象上的每个元素，并返回一个map对象。

map(函数f,list数据)

>>> x,y=map(int,["45","56"])
>>> x,y
(45, 56)
>>> a,b=map(round,[3.4546,4.6757],(3,2))
>>> a,b
(3.455, 4.68)

3.5 字符串类型及其操作

• 字符串是用双引号“”或者单引号''括起来的一个或多个字符
• 字符串对象是不可变的。字符串对象提供的涉及到字符串”修改“的方法都是返回修改后的新字符串，并不对原始字符串做任何修改。

3.5.1字符串类型

字符串是一个字符序列：字符串最左端位置标记为0，依次增加。字符串中的编号叫做”索引“。

国	无	德	不	兴		人	无	德	不	立
0	1	2	3	4	5	6	7	8	9	10

• 单个索引辅助访问字符串中的特定位置

格式为：<string>[<索引>]

• 切片，通过两个索引值返回一个子串

格式为：<string>[<start>:<end>:step]

• 这个子序列从索引start开始直到索引end结束，但不包括end位置。step代表步长

>>> a='国无德不兴 人无德不立'
>>> a[2]
'德'
>>> x=8
>>> a[x-2]
'人'
>>> a[-7]
'兴'
>>> a[-11:-7]        
'国无德不'
>>> a[1:-1]
'无德不兴 人无德不'
>>> a[2:-2:2]
'德兴人德'

反斜杠字符(\)是一个特殊字符，在字符串中表示转义，即该字符与后面相邻的一个字符共同组成了新的含义。

\n:表示换行

\t:表示制表符（Tab）

>>> print("Python\n语言\t程序\t设计")
Python
语言	程序	设计
>>> print("c:\\now")
c:\now
>>> a= 'Let\'s go'
>>> print(a)
Let's go

3.5.2 基本的字符串操作符 + * in not in

字符串之间可以通过+或*进行连接

• 加法操作(+)将两个字符串连接成为一个新的字符串

• 乘法操作(*)生成一个由其本身字符串重复连接而成的字符串

  >>> "pine"+"apple"
  'pineapple'
  >>> 3*'pine'
  'pinepinepine'
  

操作符	描述
x in s	如果x是s的元素，返回True，否则返回False
x not in s	如果x不是s的元素，返回True，否则返回False

>>> c='cat,dog'
>>> "d" in c
True
>>> "z" in c
False
>>> "z" not in c
True

操作	含义
len(x)	返回字符串x的长度，也可返回其他组合数据类型元素个数
str(x)	返回任意类型x所对应的字符串形式
chr(x)	Unicode码对应的单个字符
ord(x)	返回单字符表示的Unicode编码

操作	含义
str.replace(old,new[,count])	返回字符串str的副本，所有old子串被替换为new，如果count给出，则前count次old出现被替换。查找字符串所有匹配项并替换，返回字符串。
str.split()	返回一个列表，由str根据sub子串出现的次数。用来将字符串分隔成序列。如果不指定分隔符，则空格、换行符、制表符等都将被认为是分隔符，把连续多个空白字符看作一个分隔符。
str.join()	用来连接元组、列表等中的元素，注意其元素一定要是字符串。返回一个新字符串，由组合数据类型iterable变量的每个元素组成，元素间用str分隔。
str.count()	统计子字符串出现的次数
str.find()	可以在一个较长的字符串中查找子串，并返回子串所在位置的左端索引位置，如果没有找到则返回-1
str.strip()	去掉字符串两侧的空格，并返回字符串。返回字符串str的副本，在其左侧和右侧去掉chars中列出的字符。=
str.upper()	字符串中字母大写
str.lower()	字符串中字母小写
str.islower()	判断字符串是否都是小写，是时，返回True，否则False
str.isupper	判断字符串是否都是大写，是时，返回True，否则False

>>> a='Python'
>>> a.lower()
'python'
>>> a.upper()
'PYTHON'
>>> string = 'Python is a programming language.'
>>> string.replace('a','A')
'Python is A progrAmming lAnguAge.'
>>> string.split()
['Python', 'is', 'a', 'programming', 'language.']
>>> s="2017-10-31"
>>> s.split("-")
['2017', '10', '31']
>>> a=["1","2"]
>>> "t".join(a)   # "t"为连接符
'1t2'
>>> b=s.split("-")
>>> '/'.join(b)
'2017/10/31'

>>> s="apple,peach,banana,peach,pear"
>>> s.find("peach")
6
>>> s.find("peach",7)  #从7位置字符开始往后找
19

>>> string = '   Python is a programming languages'
>>> string.strip()
'Python is a programming languages'

第四章

4.1程序的基本结构 不要看

函数	描述
seed(a=None)	初始化随机数种子，默认值为当前系统时间
random()	生成一个[0.0,1.0)之间的随机小数
randint(a,b)	生成一个[a,b]之间的整数
getrandbits(k)	生成一个k比特长度的随机整数
randrange(start,stop[,step])	生成一个[start,stop]之间以step为步数的随机整数
uniform(a,b)	生成一个[a,b]之间的随机小数
choice(seq)	从序列类型，例如列表中随机返回一个元素
shuffle(seq)	将序列类型中的元素随机排列，返回打乱后的序列
sample(pop,k)	从pop类型中随机选取k个元素，以列表类型返回

>>> import random       
>>> random.random()     # 调用系统时间这个种子 每次都会不一样
0.5018134450345285      
>>> random.random()
0.032973558931030156
>>> random.random()
0.6449492388301401

>>> random.seed(2)      # 调用这个种子 可以使产生的随机数一样 即种子一样
>>> random.random()     
0.9560342718892494      
>>> random.seed(2)
>>> random.random()
0.9560342718892494

>>> random.uniform(2,5)   
3.8885526850015695
>>> random.random()*3+2   # (0,1) 上下两者区别是5是否能取到

>>> random.randint(1,5)
5
>>> random.randint(1,5)
2

>>> random.getrandbits(3)   # 随机整数占k比特，即 000-111之间二进制 1-7
7
>>> random.getrandbits(2)   # 00-11  1-3
1

>>> random.randrange(0,100,4)  # 产生一个[0,100)间能被4整除的随机整数
76
>>> random.randrange(0,100,4)
40

>>> random.choice([1,3,6,7,8])
1
>>> random.choice(range(1,50))
8

>>> random.sample([1,3,6,7,8],2)
[7, 8]

>>> a=list(range(1,10))
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> random.shuffle(a)
>>> a
[8, 3, 9, 7, 6, 4, 5, 1, 2]

第5章

5.1.1函数的定义

定义：函数是一段具有特定功能的、可重用的语句组，用函数名来表示并通过函数名进行功能调用。

5.1.2函数调用的过程

程序调用一个函数需要执行以下4个步骤。

（1）调用程序在调用处暂停执行。

（2）在调用时将实参复制给函数的形参。

（3）执行函数体语句。

（4）函数调用结束给出返回值，程序回到调用前的暂停处继续执行。

5.1.3函数返回值

函数返回值：

• 函数不一定要有return语句
• 即使函数无返回值，依旧可以获得返回值None
• return不带任何参数时，也返回None
• 如果函数有返回值，使用return来返回值
• 执行return语句意味着函数的终止
• Python的return语句可以返回多个值

#eg5_2sum.py
def sum(number1,number2):
  total=number1+number2

print(sum(1,2))

运行结果：None

5.2.1默认值参数和可变数量参数 一个*

设置默认参数值的格式如下：

def 函数名(...,形参名=默认值)

例如：

def dup(str, times=2):
	print(str*times)

dup("knock~")
dup("knock~",4)

程序输出结果：

knock~knock~
knock~knock~knock~knock~

只有在形参表末尾的参数可以有默认参数值，不能先声明有默认值的形参而后声明没有默认值的形参

如：

def func(a,b=5)是有效的
def func(a=5,b)是无效的

可变数量参数：在python中，若形参可以接收不定个数的参数，该形参称为可变数数量参数。

def all_1(*args):
	print('有',len(args),'个参数',':',args)  

all_1("团结合作","携手应对")
all_1("团结合作","携手应对",'守望相助')

形参args此时为一个元组，结果：

有 2 个参数 : ('团结合作', '携手应对')
有 3 个参数 : ('团结合作', '携手应对', '守望相助')

5.2.2位置参数和关键参数

def SayHello(s,n):
  for i in range(1,n+1):
    print(s)

SayHello("Hello!",3)      #位置参数
SayHello(3,"Hello!")      #error
SayHello(n=3,s="Hello!")  #关键参数

变量作用域 global

全局变量：在函数之外定义的变量，一般没有缩进，在程序执行全过程有效。

局部变量：在函数内部使用的变量，仅在函数内部有效，当函数退出时变量将不存在。

实参：

1.位置参数

2.关键参数

3.实参为序列、字典，传递参数时解包

形参：

默认参数def函数名(形参=值)

可变参数def函数名(*形参)

引用字典def函数名(**形参)

全局变量：global

第6章 组合数据类型

列表的操作

函数或方法	描述
ls[i]=x	替换列表ls第i数据项为x
ls[i:j]=lt	用列表lt替换列表ls中第i到第j项数据**（不含第j项，下同）**
ls[i:j:k]=lt	用列表lt替换列表ls中第i到第j项以k为步数的数据
del ls[i:j]	删除列表ls第i到第j项数据，等价于ls[i:j]=[]
del ls[i:j:k]	删除列表ls第i到第j项以k为步数的数据
ls+=lt 或 ls.extend(lt)	将列表lt元素增加到列表ls中
ls * = n	更新列表ls，其元素重复n次
ls.append(x)	在列表ls最后增加一个元素x
ls.clear()	删除ls中的所有元素
ls.copy()	生成一个新列表，复制ls中的所有元素
ls.insert(i.x)	在列表ls的第i位置增加元素x
ls.pop(i)	将列表ls中的第i项元素取出并删除该元素
ls.remove(x)	将列表中出现的第一个元素x删除
ls.reverse()	列表ls中的元素反转

>>> vlist = list(range(5))
>>> vlist
[0, 1, 2, 3, 4]
>>> len(vlist[2:])       # 计算从第3个位置开始到结尾的子串长度
3
>>> 2 in vlist           # 判断2是否在列表vlist中 
True
>>> vlist[3]="PYTHON"    # 修改序号3的元素值和类型
>>> vlist
[0, 1, 2, 'PYTHON', 4]
>>> vlist[1:3]=["bit","computer"]    
>>> vlist
[0, 'bit', 'computer', 'PYTHON', 4]

# 当使用一个列表改变另一个列表值时，python不要求两个列表长度一样，但遵循”多增少减“的原则
>>> vlist[1:3]=["new_bit","new_computer",123]
>>> vlist
[0, 'new_bit', 'new_computer', 123, 'PYTHON', 4]
>>> vlist[1:3]=["fewer"]
>>> vlist
[0, 'fewer', 123, 'PYTHON', 4]

字典的操作

函数和方法	描述
<d>.keys()	返回所有的键信息
<d>.values()	返回所有的值信息
<d>.items()	返回所有键值对
<d>.get(<key>,<default>)	键存在则返回相应值，否则返回默认值
<d>.setdefault(<key>,<value>)	键存在返回相应值，否则添加元素
<d>.pop(<key>,<default>)	键存在则返回相应值，同时删除键值对，否则返回默认值
<d>.popitem()	随机从字典中取出一个键值对，以元组（key，value）形式返回
<d>.clear()	删除所有的键值对
del <d>[<key>]	删除字典中某个键值对
<key> in <d>	如果键在字典中则返回True，否则返回False

如果希望keys()、values()、items()方法返回列表类型，可以采用list()函数将返回值转换成列表：

>>>Dcountry={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
>>>Dcountry.keys()
dict_keys(['中国', '美国', '法国'])
>>> list(Dcountry.values())
['北京', '华盛顿', '巴黎']
>>> Dcountry.items()
dict_items([('中国', '北京'), ('美国', '华盛顿'), ('法国', '巴黎')])
>>> '中国' in Dcountry #只对键进行判断
True
>>> Dcountry.get('美国','悉尼')  #'美国'在字典中存在
'华盛顿'
>>> Dcountry.get('澳大利亚','悉尼')  # '澳大利亚'在字典中不存在则返回后面那个
'悉尼'
>>> Dcountry.setdefault('英国','伦敦')  # 键存在返回相应值，否则添加元素
'伦敦'
>>> Dcountry
{'中国': '北京', '美国': '华盛顿', '法国': '巴黎', '英国': '伦敦'}
>>> Dcountry.pop('英国')
'伦敦'
>>> Dcountry.popitem()
('法国', '巴黎')
>>> Dcountry
{'中国': '北京', '美国': '华盛顿'}
>>> del Dcountry['美国']
>>> Dcountry
{'中国': '北京'}
>>> Dcountry.clear()
>>> Dcountry
{}
>>> del Dcountry

于其他组合数类型一样，字典可以通过for...in语句对其元素进行遍历，基本语法结构如下：

for <变量名> in <字典名>:
  语句块
  

例如：

a={"中国":"北京","美国":"华盛顿","法国":"巴黎"}
for i in a:
  print(i)
###运行结果:
中国
美国
法国

第7章

​ open() 打开模式

​ f.close()

​ read()

​ readline()

​ readlines()

​ write()

​ writelines()

​ seek()

第8章

8.1 类的定义与使用

8.2 构造函数

8.3 类的属性

8.4 类的方法：公有方法、私有方法

8.7 继承

8.9 运算符的重载

raise抛出自己异常