Python学习记录

1.题型说明

一、单选题（301分=30分）
二、多选题（52分=10分）
三、填空题（101分=10分）
四、简答题（35分=15分）
五、上机编程题（共3道，第一小题8分，第二小题10分，第三小题17分，共计35分）

2.课程重点知识说明:

元组和列表区别，优势

元组和列表对比：
1、元组中的数据一旦定义就不允许更改。
2、元组没有append()、extend()和insert()等方法，无法向元组中添加元素；
3、元组没有remove()或pop()方法，也无法对元组元素进行del操作，不能从元组中删除元素。
4、内建的tuple( )函数接受一个列表参数，并返回一个包含同样元素的元组，而list( )函数接受一个元组参数并返回一个列表。从效果上看，tuple( )冻结列表，而list( )融化元组。

#元组和列表的转换
tuple()
list()

4.元组的优势
（1）元组的速度比列表更快。如果定义了一系列常量值，而所需做的仅是对它进行遍历，那么一般使用元组而不用列表。
（2）元组对不需要改变的数据进行“写保护”将使得代码更加安全。
（3）一些元组可用作字典键（特别是包含字符串、数值和其它元组这样的不可变数据的元组）。列表永远不能当做字典键使用，因为列表不是不可变的。

5.元组运算
特别说明：与列表一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

len((1,2,3))	#3	计算元素个数
(1,2,3) + (4,5,6)	#(1, 2, 3, 4, 5, 6)	连接
('Hi!',)*4	#('Hi!', 'Hi!', 'Hi!', 'Hi!')	复制
3 in (1,2,3)	#True 	元素是否存在
for x in (1,2,3): print x,	#1 2 3	迭代

序列切片操作

 切片指从现有列表中，获取一个子列表
 创建一个列表，一般创建列表时，变量的名字会使用复数
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精']

 列表的索引可以是负数
 如果索引是负数，则从后向前获取元素，-1表示倒数第一个，-2表示倒数第二个 以此类推
print(stus[-2])

 通过切片来获取指定的元素
 语法：列表[起始:结束] 
   通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素
   做切片操作时，总会返回一个新的列表，不会影响原来的列表
   起始和结束位置的索引都可以省略不写
   如果省略结束位置，则会一直截取到最后
   如果省略起始位置，则会从第一个元素开始截取
   如果起始位置和结束位置全部省略，则相当于创建了一个列表的副本
 print(stus[1:])
 print(stus[:3])
 print(stus[:])
 print(stus)

 语法：列表[起始:结束:步长] 
 步长表示，每次获取元素的间隔，默认值是1
 print(stus[0:5:3])
 步长不能是0，但是可以是负数
 print(stus[::0]) ValueError: slice step cannot be zero
 如果是负数，则会从列表的后部向前边取元素
print(stus[::-1])

常见通用函数

 创建一个列表
stus = ['孙悟空','猪八戒','沙和尚','唐僧','蜘蛛精','白骨精','沙和尚','沙和尚']

 in 和 not in
 in用来检查指定元素是否存在于列表中
   如果存在，返回True，否则返回False
 not in用来检查指定元素是否不在列表中
   如果不在，返回True，否则返回False
 print('牛魔王' not in stus) #True
 print('牛魔王' in stus)

 len()获取列表中的元素的个数

 min() 获取列表中的最小值
 max() 获取列表中的最大值
arr = [10,1,2,5,100,77]
 print(min(arr) , max(arr))


 s.index() 获取指定元素在列表中的第一次出现时索引
 print(stus.index('沙和尚'))
 index()的第二个参数，表示查找的起始位置 ， 第三个参数，表示查找的结束位置
 print(stus.index('沙和尚',3,7))
 如果要获取列表中没有的元素，会抛出异常
 print(stus.index('牛魔王')) ValueError: '牛魔王' is not in list
 s.count() 统计指定元素在列表中出现的次数
 print(stus.count('牛魔王'))

Isinstance的用法是用来判断一个量是否是相应的类型，接受的参数一个是对象加一种类型
isinstance(str1,str)
type(str1)


>>> isinstance(str1,str)
True
>>> isinstance(str1,float)
False
>>>

eval()函数
eval(<字符串>)函数是Python语言中一个十分重要的函数，它能够以Python表达式的方式解析并执行字符串，并将放回结果输出。
eval（）官方文档里面给出来的功能解释是：将字符串string对象转化为有效的表达式参与求值运算,返回计算结果

eval（）函数的常见作用：

计算字符串中有效的表达式，并返回结果

>>>eval("1+2")
3

>>>eval(" '1+2' ")
'1+2'
#去掉外部一对双引号后，剩下的‘1+2’被解释为字符串

>>>eval(' "1+2" ')
"1+2"

>>> a = '[1,2,3]'
>>> type(a)
<class 'str'>
>>> type(eval(a)) #将字符串转换为列表
<class 'list'>
>>> b = '1000'
>>> type(b)
<class 'str'>
>>> type(eval(b)) #将字符串转换为整形
<class 'int'>
>>> c = "{1: 'a', 2: 'b'}"
>>> type(c)
<class 'str'>
>>> type(eval(c)) #将字符串转换为字典
<class 'dict'>

如果直接输入eval（“Hello world”）因为eval()函数去掉外部的双引号后，成为变量Hello world，而之前没有定义过该变量，所以会报错。

>>>list.extend() 把一个序列seq的内容添加到列表中
>>>list.append() 向列表中添加一个对象

>>>lia = ['aa', 1, 'bb', None]
>>>lib = ['cc', 2, {
   'dd': 3}]

>>>list.extend()

>>>lia.extend(lib)      #不能用变量接收

>>>['aa', 1, 'bb', None, 'cc', 2, {
   'dd': 3}]

>>>list.append()

>>>lia.append(lib)
>>>['aa', 1, 'bb', None, ['cc', 2, {
   'dd': 3}]]


>>>list.extend()

>>>lia = ['aa', 1, 'bb', None]
>>>lib = {
   'dd': 3, 'ee': 44} # 若为字典

>>>lia.extend(lib)
>>>['aa', 1, 'bb', None, 'dd', 'ee']


extend若为列表将列表元素，在尾部逐一加入，
若为字典是将字典key值，在尾部逐一加入
append是将整个对象在末尾加入

id()
返回对象在内存中的地址

输入输出函数input、print函数的使用

基本输入输出

1、输入格式：
    input([提示信息])
	X= input([提示信息])
	当前接收：键盘任意输入
	返回值：字符串类型
	**注意：Python所有的输入都是以字符串形式接收，再转化成数字或其他数据**

#输入多个数字
#用int()函数可以把字符串转化成数字，比如int(name)。然后name就变成了数字
a=input().split(' ') #默认空格，可改为其他
n=int(a[0])
m=int(a[1])

2、输出格式：
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
	*objects：表示可以一次输出多个对象，输出的多个对象，通过“，”分隔开
	sep： 用来间隔多个对象，默认空格
	end：设置以什么结尾，默认换行\n
	file： 要写入的文件对象
	flush：输出是否被缓存，默认为False，取决于file。

>>> a=”aa”
>>> b=”bb”
>>> print(a)
>>> print(b)
>>> print(a,b)
>>> print(a,b,sep=”=”)
>>> print(a,end=” ”)
>>> fp = open(r'D:\mytest.txt', 'a+')
>>> print('Hello,world!', file = fp)
>>> fp.close()

特殊说明：
	a. open() :创建文件对象
	b. a+文件权限，表示对文件有读写权限，且文件打开时是追加模式。

全局变量和局部变量对比

变量作用域

变量作用域：变量起作用的范围称为变量的作用域
局部变量：在函数内定义的变量只在该函数内起作用，称为局部变量。函数结束时，其局部变量被自动删除。
全局变量：能够同时作用于函数内外，称为全局变量。

total=0  #全局变量

def sum(arg1,arg2):
    global total
    global a
    a=1 #a 局部变量
    total=arg1+arg2; #total 局部变量
    print("局部变量：",total)
    print("局部变量：",a)
    return total

sum(1,2)

print(total)
print(a)

模块的引入与使用

1. 定义
2. 内置模块或者第三方模块（例如，安装Numpy）

在一个模块中引入外部模块
 ① import 模块名 （模块名，就是python文件的名字，注意不要py）
 ② import 模块名 as 模块别名
	 import test_module as test
   - 可以引入同一个模块多次，但是模块的实例只会创建一个
   - import可以在程序的任意位置调用，但是一般情况下，import语句都会统一写在程序的开头
   - 在每一个模块内部都有一个__name__属性，通过这个属性可以获取到模块的名字
   - __name__属性值为 __main__的模块是主模块，一个程序中只会有一个主模块
       主模块就是我们直接通过 python 执行的模块

print(test.__name__)
print(__name__)

__name__属性
每个Python脚本在运行时都有一个“__name__”属性。如果脚本作为模块被导入，
则其“__name__”属性的值被自动设置为模块名；如果脚本独立运行，则其“__name__”属性值被自动设置为“__main__”

test1.py
a=100
print("这是test模块")
print(a)
print(__name__)

def fun():
    print("验证__name__")

test2.py
import test1
b=200
print("这是test2模块")
print(b)
print(__name__)
if __name__=="__main__":
    test1.fun()

引入模块

（1） import 模块名称1
import m

访问模块中的变量：模块名.变量名
print(m.a , m.b)

def test2():
    print('这是主模块中的test2')
m.test2()



import math
import random
print(math.sin(0.5))
x=random.random()
y=random.random()
z=random.randint(1,100)
print(x,y,z)

import math, random 不推荐，每个import只导入一个模块

（2）也可以只引入模块中的部分内容
语法 from 模块名 import 变量,变量....
from m import Person,test
from m import * # 引入到模块中所有内容，一般不会使用
from 模块名 import 对象名[ as 别名]   可以减查询次数，提高执行速度
 

from math import sin as s
from random import random,randint
print(s(0.5))
x=random()
y=random()
z=randint(1,100)
print(x,y,z)

from matplotlib.pyplot import plot

3. 自定义模块

 import pack1.test1 as patest1
 patest1.test1()


from pack1.test3 import test2
test2()

列表、元组、字典、集合等序列各自特点和创建、使用

一、 序列

1. 定义：
   序列是程序设计中经常用到的数据存储方式，序列是一系列连续值，它们通常是相关的，并且按一定顺序排列。
   Python中常用的序列结构有列表、元组、字典、字符串、集合以及range等等。
   除字典和集合之外，列表、元组、字符串等序列均支持双向索引，第一个元素下标为0，第二个元素下标为1，以此类推；最后一个元素下标为-1，倒数第二个元素下标为-2，以此类推。

2. 分类：
   其中，Python基本内置数据类型：
   不可变序列（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
   可变序列（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

   有序序列：列表、元组、字符串
   无序序列：字典、集合

二、列表

 1. 基本定义

	比较项	列表
	类型名称	list
	定界符	方括号[]
	是否可变	是
	是否有序	是
	是否支持下标	是（使用序号作为下标）
	元素分隔符	逗号
	对元素值的要求	无   [‘a’,1,1.0,[1,2,3],’a’]
	元素是否可重复	是

 2.列表创建与删除

（1）列表创建：
	1>使用“=”直接将一个列表赋值给变量即可创建列表对象
		aList=[] #创建空列表
	2>使用list()函数将元组、range对象、字符串或其他类型的可迭代对象类型的数据转换为列表
		aList=list()#创建空列表
	3>列表推导式
	Python3.x
		range([start],stop,[step])  
		list(range([start],stop,[step]))
	Python2.x——了解
		xrange([start],stop,[step])  
		list(xrange([start],stop,[step]))

		range([start],stop,[step])  ——返回list列表

案例代码：

>>> range(10)
range(0, 10)
>>> for i in range(10):
	print(i)	
0
1
2
3
4
5
6
7
8
9
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(2,10))
[2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(2,10,2))
[2, 4, 6, 8]
>>> list(range(-4,4))
[-4, -3, -2, -1, 0, 1, 2, 3]
>>> list(range(4,-4,-1))
[4, 3, 2, 1, 0, -1, -2, -3]

（2）列表删除
	del  列表名称

3.	列表元素的增加

（1）“+”运算符来实现将元素添加到列表中的功能。
用法简单，但速度慢，效率低
是重新开辟一块内存空间，创建新列表
>>> aList=[3,4,5]
>>> id(aList)
2434696708040
>>> bList=aList
>>> id(bList)
2434696708040
>>> cList=aList+[7]
>>> cList
[3, 4, 5, 7]
>>> id(cList)
2434697024904
>>> id(aList)
2434696708040

（2）列表.append(X)
速度快，效率高
在原来内存空间下，拓展空间，原地修改列表
>>> cList.append(9)
>>> cList
[3, 4, 5, 7, 9]
>>> id(cList)
2434697024904

案例：对比append() 和 +

拓展：列表内存管理
列表中包含的是元素值的引用，而不是直接包含元素值。如果是直接修改序列变量的值，则与Python普通变量的情况是一样的，而如果是通过下标来修改序列中元素的值或通过可变序列对象自身提供的方法来增加和删除元素时，序列对象在内存中的起始地址是不变的，仅仅是被改变值的元素地址发生变化。
>>>aList=[1,2,3,2.0]
>>>aList[2]=2  通过下标给列表元素赋值
>>>aList[2] is aList[1] 比较id
True
>>>aList=[1,2,3,2.0]
>>>aList[2]=2.0  通过下标给列表元素赋值
>>>aList[2] is aList[3] 比较id
False

（3）列表.extend(可迭代对象)
使用列表对象的extend()方法可以将另一个迭代对象的所有元素添加至该列表对象尾部。通过extend()方法来增加列表元素也不改变其内存首地址，属于原地操作
 
>>> a=[1,2,3]
>>> a.extend([4,5,6])
>>> a
[1, 2, 3, 4, 5, 6]
>>> a.extend([7,8,9])
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> id(a)
2098734883720
>>> a.extend(10)
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    a.extend(10)
TypeError: 'int' object is not iterable
>>> a.extend([10])
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> id(a)
2098734883720

（4）列表.insert()
使用列表对象的insert()方法将元素添加至列表的指定位置。
[3, 4, 5, 7, 9, 11, 13, 15, 17]
>>> aList.insert(3,6)
>>> aList
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

append()/extend()/insert()方法对比：
相同点：列表元素增加、不改变首地址，属于原地操作
不同点：
append()：向列表尾部追加一个元素
extend()：将另一个列表中的所有元素追加至当前列表尾部，使用列表对象的extend()方法可以将另一个迭代对象的所有元素添加至该列表对象尾部。通过extend()方法来增加	列表元素也不改变其内存首地址，属于原地操作。
insert()：用于向列表任意指定位置插入元素

案例：对比append() 和 insert()

（5）列表*整数=新列表（不是在原始地址操作）
x = [[None] * 2] * 3
print(x) #[[None, None], [None, None], [None, None]]
x[0][0] = 5
print(x) #[[5, None], [5, None], [5, None]]

x = [[1,2,3]]*3
print(x) #[[1, 2, 3], [1, 2, 3], [1, 2, 3]]
x[0][0] = 10
print(x) #[[10, 2, 3], [10, 2, 3], [10, 2, 3]]

4.	列表元素的删除

（1）del list[index]  
>>> alist=list((1,2,3,4,5,6,7))
>>> alist
[1, 2, 3, 4, 5, 6, 7]
>>> del alist[1]
>>> alist
[1, 3, 4, 5, 6, 7]
>>> x=alist.pop()
>>> x
7
>>> alist
[1, 3, 4, 5, 6]

（2）pop() 删除指定位置元素，有返回值，返回值是当前要删除的元素，默认删除最后一项元素。
>>> alist.pop(3)
5
>>> alist
[1, 3, 4, 6]
>>> alist.pop(4)
Traceback (most recent call last):
  File "<pyshell#25>", line 1, in <module>
    alist.pop(4)
IndexError: pop index out of range

（3）remove()：删除首次出现的元素
>>> x = [1,2,1,2,1,1,1]
>>> for i in x:
	print("x=",x)
	if i == 1:
		print(i)
		x.remove(i)
		print(x)

		
x= [1, 2, 1, 2, 1, 1, 1]
1
[2, 1, 2, 1, 1, 1]
x= [2, 1, 2, 1, 1, 1]
1
[2, 2, 1, 1, 1]
x= [2, 2, 1, 1, 1]
1
[2, 2, 1, 1]
x= [2, 2, 1, 1]
1
[2, 2, 1]


for循环实际是循环的列表下标（索引），同时由于列表的可变性，每一次删除一个元素，列表的长度就会发生变化，元素的索引也会发生变化。

remove是对值进行操作的
分析：
　　第一次循环，循环索引为0，此时索引为0的元素是1，满足条件，因此x中的第一个1被删除，此时变为[2, 1,