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)
模块的引入与使用
- 定义
- 内置模块或者第三方模块（例如，安装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
- 自定义模块
import pack1.test1 as patest1
patest1.test1()
from pack1.test3 import test2
test2()
列表、元组、字典、集合等序列各自特点和创建、使用
一、 序列
-
定义：
序列是程序设计中经常用到的数据存储方式，序列是一系列连续值，它们通常是相关的，并且按一定顺序排列。
Python中常用的序列结构有列表、元组、字典、字符串、集合以及range等等。
除字典和集合之外，列表、元组、字符串等序列均支持双向索引，第一个元素下标为0，第二个元素下标为1，以此类推；最后一个元素下标为-1，倒数第二个元素下标为-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, 2, 1, 1, 1]；
第二次循环，循环索引为1，此时新列表中，索引为1的元素是1，满足条件，因此，remove方法会再次删除一个1，但是remove会删除第一次出现的1， 列表为[2, 2, 1, 1, 1];
第三次循环，循环索引为2，此时列表中，索引为2的元素是1，满足条件，remove方法会再次删除一个1，因此列表变为[2,2,1,1];
第四次循环，循环索引为3，新列表中，索引为3的元素是1，满足条件，但是remove会删除第一次出现的1（即删除索引为2的那个1），mylist为[2,2,1];
第五次循环，循环索引为4，此时由于新列表长度为3，于是循环结束。
解决方案：
>>> x = [1,2,1,2,1,1,1]
>>> for i in x[::]:
if i == 1:
x.remove(i)
或者：
>>> x = [1,2,1,2,1,1,1]
[6,5,4,3,2,1,0]
>>> for i in range(len(x)-1,-1,-1):
if x[i]==1:
del x[i]
分析：
第一次循环，循环索引为0，此时索引为x[6]的元素是1，满足条件，此时变为[1,2,1,2,1,1]；
第二次循环，循环索引为1，此时新列表中，索引为x[5]的元素是1，满足条件，因此，列表为[1,2,1,2,1];
第三次循环，循环索引为2，此时列表中，索引为x[4]的元素是1，满足条件，因此列表变为[1,2,1,2];
第四次循环，循环索引为3，新列表中，索引为x[3]的元素是2，不满足条件，列表依然是为[1,2,1,2];
第五次循环，循环索引为4，新列表中，索引为x[2]的元素是1，满足条件，列表元素为[1,2,2];
第六次循环，循环索引为5，新列表中，索引为x[1]的元素是2，不满足条件，列表依然是为[1,2,2];
第七次循环，循环索引为6，新列表中，索引为x[1]的元素是1，满足条件，列表为[2,2];
5. 列表元素访问与计数
（1） 使用下标直接访问列表元素
（2） index()/count()
6. 成员资格判断
in 运算符
zip()函数说明
7. 切片***
1> 概念：切片是Python序列的重要操作之一，适用于列表、元组、字符串、range对象等类型。
2>语法：切片使用2个冒号分隔的3个数字来完成，第一个数字表示切片开始位置（默认为0），
第二个数字表示切片截止（但不包含）位置（默认为列表长度），第三个数字表示切片的步长（默认为1），
当步长省略时可以顺便省略最后一个冒号。可以使用切片来截取列表中的任何部分，得到一个新列表，
也可以通过切片来修改和删除列表中部分元素，甚至可以通过切片操作为列表对象增加元素。
3>对比下标访问：与使用下标访问列表元素的方法不同，切片操作不会因为下标越界而抛出异常，
而是简单地在列表尾部截断或者返回一个空列表，代码具有更强的健壮性。
4>双向索引:
列表演示切片操作
（1）使用切片截取列表
（2）可以使用切片来原地修改列表内容
>>> aList = [3, 5, 7]
>>> aList[len(aList):]
[]
>>> aList[len(aList):] = [9]
>>> aList
[3, 5, 7, 9]
>>> aList[:3] = [1, 2, 3]
>>> aList
[1, 2, 3, 9]
>>> aList[:3] = []
>>> aList
[9]
>>> aList = list(range(10))
>>> aList
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> aList[::2] = [0]*(len(aList)//2)
>>> aList
[0, 1, 0, 3, 0, 5, 0, 7, 0, 9]
（3）切片返回的是列表元素的浅拷贝（浅复制），即生成了一个新列表。
aList = [3, 5, 7]
>>> bList = aList[::] #浅复制
>>> aList == bList
True
>>> aList is bList
False
对比：
>>> str="abcde"
>>> str[-1]
'e'
>>> str[4]
'e'
>>> str[0:3]
'abc'
>>> str[-5:-1:2]
'ac'
>>> str[0:2]="ac"
Traceback (most recent call last):
File "<pyshell#29>", line 1, in <module>
str[0:2]="ac"
TypeError: 'str' object does not support item assignment
>>>
8. 排序
(1)使用列表对象的sort方法进行原地排序
(2)使用内置函数sorted对列表进行排序并返回新列表
(3)使用列表对象的reverse方法将元素原地逆序
(4)使用内置函数reversed方法对列表元素进行逆序排列并返回迭代对象
举例：list.sort()
>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> import random
>>> random.shuffle(aList)
>>> aList
[7, 6, 4, 3, 5, 15, 13, 17, 11, 9]
>>> aList.sort(key = lambda x:len(str(x)))
>>> aList
[7, 6, 4, 3, 5, 9, 15, 13, 17, 11]
>>> aList.sort(key = lambda x:len(str(x)),reverse=True)
>>> aList
[15, 13, 17, 11, 7, 6, 4, 3, 5, 9]
>>> a=100001
>>> s=str(a)
>>> s
'100001'
>>> len(s)
6
>>>
9. 用于序列操作的常用内置函数
cmp()：比较2个列表的大写——python2.x方法，python3.x不支持
替换方法
（1）通过比较运算符进行比较
(a>b)-(a<b) 可代替cmp()
a>b 表达式结果为1
a<b 表达式结果为-1
a=b 表达式结果为0
（2）对象的“__le__()”及其相关方法
sum():数值型列表
len()
max()
min()
平均：sum()/len()
zip()
enumerate(列表)
10. 列表推导式
1> 概念：列表推导式使用非常简洁的方式来快速生成满足特定需求的列表，一种简要的方法创建列表。
2> 语法：[表达式 for循环语句 0个或者多个for或者if语句]
表达式任意，可以在生成的新列表中存入任意类型的对象
3> 执行顺序：
各个语句之间是嵌套关系，从左边第二条语句（最外层）开始执行，依次向右边递进一层，最后执行左边第一条语句（最后一层）
>>> blist=[]
>>> for x in range(1,5):
if x>2:
for y in range(1,4):
if y<3:
blist.append(x*y)
>>> blist
[3, 6, 4, 8]
>>> aList=[x*y for x in range(1,5) if x>2 for y in range(1,4) if y<3 ]
>>> aList
[3, 6, 4, 8]
三、元组
1. 基本定义
比较项 元组
类型名称 tuple
定界符 圆括号()
是否可变 否
是否有序 是
是否支持下标 是（使用序号作为下标）
元素分隔符 逗号
对元素值的要求 无 ( ‘a’,1,1.0,[1,2,3],’a’)
元素是否可重复 是
2.元组创建与删除
元组的创建
（1）通过“=”将元组赋值给变量
元组中只包含一个元素时，需要在元素后，添加“，”
>>> a=3
>>> a
3
>>> type(a)
<class 'int'>
>>> a=(3)
>>> a
3
>>> type(a)
<class 'int'>
>>> a=(3,)
>>> a
(3,)
>>> type(a)
<class 'tuple'>
>>> a=3,
>>> a
(3,)
>>> type(a)
<class 'tuple'>
>>>
创建空元祖 x=()
（2）tuple()：将其他的序列（字符串、列表等）转化成元组
创建空元祖 x=tuple()
元组的删除
del 元组对象 使用del删除元组对象，不能删除元组元素
3.元组和列表对比：
（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 迭代
6.序列解包和序列封包
• 把多个值赋给一个变量时，Python会自动的把多个值封装成元组，称为序列封包。
• 把一个序列（列表、元组、字符串等）直接赋给多个变量，此时会把序列中的各个元素依次赋值给每个变量，但是元素的个数需要和变量个数相同，这称为序列解包。
Type "copyright", "credits" or "license()" for more information.
>>> a=1,2,3,4,5
>>> a
(1, 2, 3, 4, 5)
>>> type(a)
<class 'tuple'>
>>> a
(1, 2, 3, 4, 5)
>>> b,c,d,e,f="a","b","v",'d","x"
SyntaxError: EOL while scanning string literal
>>> b,c,d,e,f="a","b","v","d","x"
>>> b
'a'
>>> c
'b'
>>> b,c,d,e,f=a
>>> b
1
>>> c
2
>>> d
3
>>> e
4
>>> f
5
>>> a
(1, 2, 3, 4, 5)
>>> b,c,d=a
Traceback (most recent call last):
File "<pyshell#15>", line 1, in <module>
b,c,d=a
ValueError: too many values to unpack (expected 3)
>>> a1,a2,a3,*a4=a
>>> a1
0
>>> a2
1
>>> a3
2
>>> a4
[3, 4, 5, 6, 7, 8, 9]
>>> a
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> *a1,a2,a3=a
>>> a1
[0, 1, 2, 3, 4, 5, 6, 7]
>>> a2
8
>>> a3
9
>>> a
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> a1,*a2,a3=a
>>> a1
0
>>> a2
[1, 2, 3, 4, 5, 6, 7, 8]
>>> a3
9
7.生成器推导式：
定界符：（）
返回值：生成器推导式的结果是一个生成器对象，而不是列表，也不是元组
（1）将生成器对象可以转换成列表或元组。
>>> g=[(i+2)**2 for i in range(10)]
>>> g
[4, 9, 16, 25, 36, 49, 64, 81, 100, 121]
>>> g=((i+2)**2 for i in range(10))
>>> g
<generator object <genexpr> at 0x000002247CD33CF0>
>>> tuple(g)
(4, 9, 16, 25, 36, 49, 64, 81, 100, 121)
>>> list(g)
[]
>>> g=((i+2)**2 for i in range(10))
>>> list(g)
[4, 9, 16, 25, 36, 49, 64, 81, 100, 121]
（2）生成器对象的__next__()方法（Python 3.x）进行遍历
>>> g.__next__()
Traceback (most recent call last):
File "<pyshell#42>", line 1, in <module>
g.__next__()
StopIteration
>>> g=((i+2)**2 for i in range(10))
>>> g.__next__()
4
>>> g.__next__()
9
>>> g.__next__()
16
>>> g.__next__()
25
>>> g.__next__()
36
>>> g.__next__()
49
>>> g.__next__()
64
>>> g.__next__()
81
>>> g.__next__()
100
>>> g.__next__()
121
>>> g.__next__()
Traceback (most recent call last):
File "<pyshell#54>", line 1, in <module>
g.__next__()
StopIteration
（3）for循环遍历生成器对象
>>> g=((i+2)**2 for i in range(10))
>>> for i in g:
print(i,end=' ')
4 9 16 25 36 49 64 81 100 121
>>>
对比列表推导式
定界符：[]
返回值：生成列表
8.元组支持切片操作
三、字典
1. 基本定义
比较项 字典
类型名称 dict
定界符 大括号{}
是否可变 是
是否有序 否
是否支持下标 是（使用键作为下标）
元素分隔符 逗号
对元素值的要求 键：键可以为任意不可变数据，比如整数、实数、复数、字符串、元组等等
元素是否可重复 键：键不允许重复
2.字典的创建、删除
（1）使用=将一个字典赋值给一个变量
>>> a={}
>>> type(a)
<class 'dict'>
>>> a={"a":1,"b":2,"b":3}
>>> a
{'a': 1, 'b': 3}
>>> a={"a":1,"b":2,"c":2}
>>> a
{'a': 1, 'b': 2, 'c': 2}
（2）使用dict利用已有数据创建字典
>>> keys=['a','b','c','d']
>>> values=[1,2,3,4]
>>> zip(keys,values)
<zip object at 0x000001A869169988>
>>> list(zip(keys,values))
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> d=dict(zip(keys,values))
>>> d
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>> x=dict()
>>> x
{}
（3）使用dict根据给定的键、值创建字典
>>> dict(name='Dong',age=37)
{'name': 'Dong', 'age': 37}
（4）以给定内容为键，创建值为空的字典
dict.fromkeys(seq[， value])
返回一个新字典,，会将seq序列中的每个元素作为新字典key，如果省略value，默认为None
>>> newDict=dict.fromkeys(['name','age','sex'])
>>> newDict
{'name': None, 'age': None, 'sex': None}
>>> newDict=dict.fromkeys(['name','age','sex'],[1,2,3])
>>> newDict
{'name': [1, 2, 3], 'age': [1, 2, 3], 'sex': [1, 2, 3]}
（5）字典的删除：del 字典对象
3.字典元素的读取
（1）以键作为下标可以读取字典元素，若键不存在则抛出异常
>>> aDict={'name':'Dong', 'sex':'male', 'age':37}
>>> aDict[0]
Traceback (most recent call last):
File "<pyshell#24>", line 1, in <module>
aDict[0]
KeyError: 0
>>> aDict["name"]
'Dong'
>>> aDict["age"]
37
>>> aDict["address"]
Traceback (most recent call last):
File "<pyshell#27>", line 1, in <module>
aDict["address"]
KeyError: 'address'
>>>
（2）使用字典对象的get方法获取指定键对应的值，并且可以在键不存在的时候返回指定值。
说明：dict.get(key[,value_default])
获取指定key的value值，如果字典中没有key值，默认返回结果为None，如果指定默认返回结果，则返回指定结果。
>>> aDict
{'name': 'Dong', 'sex': 'male', 'age': 37}
>>> print(aDict.get("name"))
Dong
>>> print(aDict.get('address'))
None
>>> print(aDict.get('address',"济南"))
济南
>>> aDict['score']
Traceback (most recent call last):
File "<pyshell#32>", line 1, in <module>
aDict['score']
KeyError: 'score'
>>> print(aDict.get('score',[]))
[]
>>> aDict['score']=aDict.get('score',[])
>>> aDict['score'].append(98)
>>> aDict['score'].append(97)
>>> aDict['score']
[98, 97]
>>> aDict
{'name': 'Dong', 'sex': 'male', 'age': 37, 'score': [98, 97]}
（3） 使用字典对象的items方法可以返回字典的键、值对列表
使用字典对象的keys方法可以返回字典的键列表
使用字典对象的values方法可以返回字典的值列表
>>> aDict={'name':'Dong', 'sex':'male', 'age':37}
>>> aDict.items()
dict_items([('name', 'Dong'), ('sex', 'male'), ('age', 37)])
>>> list(aDict.items())
[('name', 'Dong'), ('sex', 'male'), ('age', 37)]
>>> for key in aDict:
print(key)
name
sex
age
>>> aDict.keys()
dict_keys(['name', 'sex', 'age'])
>>> list(aDict.keys())
['name', 'sex', 'age']
>>> list(aDict.items())
[('name', 'Dong'), ('sex', 'male'), ('age', 37)]
>>>
4.字典元素的添加和修改
当以指定键为下标为字典赋值时，若键存在，则可以修改该键的值；若不存在，则表示添加一个键、值对。
>>> aDict={'name':'Dong', 'sex':'male', 'age':37}
>>> aDcit['name']
Traceback (most recent call last):
File "<pyshell#49>", line 1, in <module>
aDcit['name']
NameError: name 'aDcit' is not defined
>>> aDict['name']
'Dong'
>>> aDict['name']="Wang"
>>> aDict
{'name': 'Wang', 'sex': 'male', 'age': 37}
>>> aDict['address']="威海"
>>> aDict
{'name': 'Wang', 'sex': 'male', 'age': 37, 'address': '威海'}
>>>
>>> aDict={'name':'Dong', 'sex':'male', 'age':37}
>>> aDcit['name']
Traceback (most recent call last):
File "<pyshell#49>", line 1, in <module>
aDcit['name']
NameError: name 'aDcit' is not defined
>>> aDict['name']
'Dong'
>>> aDict['name']="Wang"
>>> aDict
{'name': 'Wang', 'sex': 'male', 'age': 37}
>>> aDict['address']="威海"
>>> aDict
{'name': 'Wang', 'sex': 'male', 'age': 37, 'address': '威海'}
>>> aDict['address']=['威海','德州']
>>> aDict
{'name': 'Wang', 'sex': 'male', 'age': 37, 'address': ['威海', '德州']}
>>> aDict.update({'a':'a','b':'b'})
>>> aDict
{'name': 'Wang', 'sex': 'male', 'age': 37, 'address': ['威海', '德州'], 'a': 'a', 'b': 'b'}
>>> aDict.update({'a':'b','c':'c'})
>>> aDict
{'name': 'Wang', 'sex': 'male', 'age': 37, 'address': ['威海', '德州'], 'a': 'b', 'b': 'b', 'c': 'c'}
>>>
5.字典元素的删除
pop(key[,default])
popitem()：返回并删除字典中的最后一对键和值
参数：无
返回值：返回一个键值对（key，value）形式
（1）使用del删除字典中指定键的元素
（2）使用字典对象的clear方法来删除字典中所有元素
（3）使用字典对象的pop 方法删除并返回指定键的元素
（4）使用字典对象的popitem方法删除并返回字典中的一个元素
>>> aDict
{'name': 'Wang', 'sex': 'male', 'age': 37, 'address': ['威海', '德州'], 'a': 'b', 'b': 'b', 'c': 'c'}
>>>
>>> del aDict['b']
>>> aDict
{'name': 'Wang', 'sex': 'male', 'age': 37, 'address': ['威海', '德州'], 'a': 'b', 'c': 'c'}
>>> aDict.clear()
>>> aDict
{}
>>> type(aDict)
<class 'dict'>
>>> del aDict
>>> aDict
Traceback (most recent call last):
File "<pyshell#68>", line 1, in <module>
aDict
NameError: name 'aDict' is not defined
>>> aDict={'name': 'Wang', 'sex': 'male', 'age': 37, 'address': ['威海', '德州'], 'a': 'b', 'c': 'c'}
>>> aDict
{'name': 'Wang', 'sex': 'male', 'age': 37, 'address': ['威海', '德州'], 'a': 'b', 'c': 'c'}
>>> aDict.pop("c")
'c'
>>> aDict
{'name': 'Wang', 'sex': 'male', 'age': 37, 'address': ['威海', '德州'], 'a': 'b'}
>>> aDict.pop("name")
'Wang'
>>> aDict
{'sex': 'male', 'age': 37, 'address': ['威海', '德州'], 'a': 'b'}
>>> aDict.popitem()
('a', 'b')
>>> aDict.popitem()
('address', ['威海', '德州'])
>>> aDict.popitem()
('age', 37)
>>> aDict.popitem()
('sex', 'male')
>>> aDict.popitem()
Traceback (most recent call last):
File "<pyshell#79>", line 1, in <module>
aDict.popitem()
KeyError: 'popitem(): dictionary is empty'
>>> aDict
{}
6.有序字典
x=collections.OrderedDict() #有序字典
7.字典推导式
定界符{}
作用：生成一个字典
{表达式 forXXX 0-多个for /if语句}
表达式 字典元素格式 key：value
8.
globals()返回包含当前作用域内所有全局变量和值的字典
locals()返回包含当前作用域内所有局部变量和值的字典
a=1 #定义了一个全局变量a
def demo():
x=100 #定义了一个局部变量x
global b
b=2 #在函数内部，定义了一个全局变量b
print(globals())#{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000026D698FB198>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/allproject/PythonProjects/Test01/test1.py', '__cached__': None, 'a': 1, 'demo': <function demo at 0x0000026D69382F28>, 'print_b': <function print_b at 0x0000026D69B62A60>, 'print_x': <function print_x at 0x0000026D69B628C8>, 'b': 2}
print(locals())#{'x': 100}
#globals() 生成的字典，可写，增加、删除、修改
#locals() 生成的字典，不可以修改，可以增加、删除
globals()['a']="修改a" #成功
globals()['b'] = "修改b"
globals()['c'] = "新增c"
globals()['d'] = "新增d"
locals()['x']='修改x' #失败
locals()['y']='新增y'
globals().pop('d')
locals().pop('y') #成功
print("=============================")
print(globals())
print(locals())
def print_b():
try:
print(b)
except NameError as e:
print(e)
def print_x():
try:
print(x)
except NameError as e:
print(e)
print_b()
demo()
print_x()
四、集合
1. 基本定义
比较项 集合
类型名称 set
定界符 大括号{}
是否可变 是
是否有序 否
是否支持下标 否
元素分隔符 逗号
对元素值的要求 任意不可变数据，比如整数、实数、复数、字符串、元组等等 （可哈希）
元素是否可重复 否
>>> a={3,5}
>>> a
{3, 5}
>>> type(a)
<class 'set'>
>>> a={3,2,5,3}
>>> a
{2, 3, 5}
>>> a={3,2.0,'a',(1,2,3)}
>>> a
{'a', 2.0, 3, (1, 2, 3)}
>>> a={3,2.0,'a',(1,2,3),[1,2,3]}
Traceback (most recent call last):
File "<pyshell#7>", line 1, in <module>
a={3,2.0,'a',(1,2,3),[1,2,3]}
TypeError: unhashable type: 'list'
2.集合的创建和删除
集合创建
（1）
>>> a
{'a', 2.0, 3, (1, 2, 3)}
>>> a.add(7)
>>> a
{2.0, 3, 7, (1, 2, 3), 'a'}
>>>
（2）set()
创建空集合x=set()
x={} ———创建集合错误，创建空字典
对比：空(列表、元组、字典，集合)
x=[]
x=list()
x=()
x=tuple()
x={}
x=dict()
x=set()
集合删除
del 集合对象
3.集合元素的删除
使用集合对象的pop()方法弹出并删除其中一个元素
使用集合对象的remove()方法直接删除指定元素
使用集合对象的clear()方法清空集合删除所有元素
>>> a={1,2,3,4}
>>> a.pop()
1
>>> a
{2, 3, 4}
>>> a.pop
<built-in method pop of set object at 0x0000020D9CD82AC8>
>>> a.pop()
2
>>> a
{3, 4}
>>> a.pop(3)
Traceback (most recent call last):
File "<pyshell#27>", line 1, in <module>
a.pop(3)
TypeError: pop() takes no arguments (1 given)
>>> a.remove(3)
>>> a
{4}
>>> a.add(3)
>>> a
{3, 4}
>>> a.clear()
>>> a
set()
3.集合元素的增加
a.add(XXXXX)
4.内置函数len()，max(),min(),sum(),map()…也适用于集合
>>> a={2,3,1,5}
>>> a
{1, 2, 3, 5}
>>> len(a)
4
>>> max(a)
5
>>> min(a)
5.Python集合还支持数学意义上的集合运算
>>> a_set=set(range(8,14))
>>> b_set=set([0,1,2,3,0,1,2,3,7,8])
>>> a_set
{8, 9, 10, 11, 12, 13}
>>> b_set
{0, 1, 2, 3, 7, 8}
>>> a_set.union(b_set)
{0, 1, 2, 3, 7, 8, 9, 10, 11, 12, 13}
>>> a_set | b_set
{0, 1, 2, 3, 7, 8, 9, 10, 11, 12, 13}
>>> a_set.intersection(b_set)
{8}
>>> a_set & b_set
{8}
>>> a_set.difference(b_set)
{9, 10, 11, 12, 13}
>>> a_set - b_set
{9, 10, 11, 12, 13}
>>> a_set.symmetric_difference(b_set)
{0, 1, 2, 3, 7, 9, 10, 11, 12, 13}
>>> a_set ^ b_set
{0, 1, 2, 3, 7, 9, 10, 11, 12, 13}
案例1：使用集合快速提取序列中单一元素——集合中元素不可重复
>>> import random
>>> listRandom=[random.choice(range(10000)) for i in range(100)]
>>> listRandom
[5201, 7377, 7336, 9695, 6902, 2136, 1371, 7946, 1266, 7720, 4399, 4603, 6428, 6811, 7716, 3679, 788, 7516, 106, 7317, 7138, 7315, 621, 8557, 4617, 23, 675, 9488, 1113, 9858, 5412, 8619, 3435, 897, 8461, 4895, 8259, 3834, 4524, 3364, 3666, 3797, 5761, 2039, 716, 9621, 6357, 6202, 9259, 4921, 2472, 2210, 5416, 8514, 9567, 996, 6031, 2859, 9664, 5624, 9505, 4441, 7067, 383, 3452, 3906, 6766, 6983, 9037, 6249, 5705, 5587, 2982, 7201, 9335, 4843, 9942, 2625, 7715, 6620, 4453, 8250, 25, 9870, 3136, 6470, 4089, 6536, 1641, 1675, 5373, 2353, 702, 3272, 6099, 7973, 478, 308, 4380, 9986]
>>> len(listRandom)
100
>>> noRepeat=[]
>>> for i in listRandom:
if i not in noRepeat:
noRepeat.append(i)
>>> noRepeat
[5201, 7377, 7336, 9695, 6902, 2136, 1371, 7946, 1266, 7720, 4399, 4603, 6428, 6811, 7716, 3679, 788, 7516, 106, 7317, 7138, 7315, 621, 8557, 4617, 23, 675, 9488, 1113, 9858, 5412, 8619, 3435, 897, 8461, 4895, 8259, 3834, 4524, 3364, 3666, 3797, 5761, 2039, 716, 9621, 6357, 6202, 9259, 4921, 2472, 2210, 5416, 8514, 9567, 996, 6031, 2859, 9664, 5624, 9505, 4441, 7067, 383, 3452, 3906, 6766, 6983, 9037, 6249, 5705, 5587, 2982, 7201, 9335, 4843, 9942, 2625, 7715, 6620, 4453, 8250, 25, 9870, 3136, 6470, 4089, 6536, 1641, 1675, 5373, 2353, 702, 3272, 6099, 7973, 478, 308, 4380, 9986]
>>> len(noRepeat)
100
>>> newSet=set(listRandom)
>>> newSet
{4617, 23, 25, 7201, 7715, 7716, 7720, 9259, 6202, 8250, 3136, 2625, 8259, 5705, 5201, 3666, 2136, 1113, 3679, 6249, 106, 1641, 621, 6766, 9335, 5761, 9858, 1675, 9870, 7315, 7317, 6811, 2210, 675, 7336, 702, 3272, 716, 7377, 3797, 6357, 9942, 4843, 1266, 6902, 3834, 5373, 9986, 7946, 8461, 9488, 788, 6428, 4380, 4895, 9505, 5412, 3364, 7973, 5416, 2859, 4399, 2353, 308, 4921, 8514, 3906, 6470, 6983, 9037, 4441, 1371, 7516, 9567, 4453, 3435, 8557, 3452, 383, 897, 6536, 6031, 9621, 7067, 2982, 2472, 8619, 4524, 9664, 5587, 6099, 6620, 478, 9695, 7138, 996, 2039, 5624, 4089, 4603}
>>> len(newSet)
100
>>> listRandom=[random.choice(range(10000)) for i in range(100)]
>>> newSet=set(listRandom)
>>> len(newSet)
99
>>> len(listRandom)
100
集合推导式:
生成集合
>>> s = {x.strip() for x in (' he ', 'she ', ' I')}
>>> s
{'I', 'she', 'he'}
>>>
总结：
列表、元组、字典、集合
1. 基本定义
比较项 列表 元组 字典 集合
类型名称 list tuple dict set
定界符 方括号[] 圆括号() 大括号{} 大括号{}
是否可变 是 否 是 是
是否有序 是 是 否 否
是否支持下标 是（使用序号作为下标） 是（使用序号作为下标） 是（使用键作为下标） 否
元素分隔符 逗号 逗号 逗号 逗号
对元素值的要求 无 [‘a’,1,1.0,[1,2,3],’a’] 无 ( ‘a’,1,1.0,[1,2,3],’a’) 键：键可以为任意不可变数据，比如整数、实数、复数、字符串、元组等等 任意不可变数据，比如整数、实数、复数、字符串、元组等等 （可哈希）
元素是否可重复 是 是 键：键不允许重复 否
函数作用、定义和使用，函数参数类型
- 函数作用：可以实现代码的复用，更重要的是可以保证代码的一致性
- 函数定义：
def 函数名([参数列表]):
‘’‘注释’’’
函数体
总结：
（1）函数定义时括弧内为形参，一个函数可以没有形参，但是括弧必须要有，表示该函数不接受参数。
（2）函数的形参不需要声明其类型，也不需要指定函数的返回值类型
（3）括号后的冒号（：）必不可少。
（4）函数体相对于def关键字必须保持一定空格缩进。
（5）在定义函数时，开头部分的注释并不是必需的，但是如果为函数的定义加上这段注释的话，可以为用户提供友好的提示和使用帮助
- 形参和实参
（1）定义:
形参：函数定义时括弧内为形参，一个函数可以没有形参，但是括弧必须要有，表示该函数不接受参数。
实参：函数调用时向其传递实参，将实参的值或引用传递给形参。
def ad(x,y): #此时x,y是形参，ad是被调函数
c = x + y
return c
def main():
a=1 #此处a,b是实参
b=2 #此处a,b是实参
d = ad(a,b) #此处a,b是实参，a.b在主调函数main中可以使用，但在被调函数ad中只能用x,y
print(d)
main()
函数定义时小括号内为形参，形参不需要声明类型,一个函数可以没有形参，但是小括号必须要有，表示该函数不接受参数。参数个数并没有限制，若有多个形参，需要使用逗号进行分割。
函数调用时向其传递实参，将实参的值或引用传递给形参。
（2）改变形对实参的影响
对于绝大多数情况下，在函数内部直接修改形参的值不会影响实参。
样例：
def change(n):
n+=1
print('a通过函数change改变后的值：',n)
def main():
a=1
print('a的初始默认值：',a)
change(a)
print('验证a的实参值是否被函数中形参所影响：',a)
main()
运行结果是：
a的初始默认值： 1
a通过函数change改变后的值： 2
验证a的实参值是否被函数中形参所影响： 1
可见函数内部直接修改形参的值不会影响实参
（2）在有些情况下，可以通过特殊的方式在函数内部修改实参的值。（如果传递给函数的参数时列表、字典、集合或者其他自定义的可变序列，并且在函数体中使用下标或者序列自身支持方式，增加、修改、删除序列中的元素，
会将修改之后的结果，反映到函数外，也就说，实参也会相应修改。）
样例：
def change(n):
b=[4,5,6]
n.extend(b)
print('a通过函数change改变后的值：',n)
def main():
a=[1,2,3]
print('a的初始默认值：',a)
change(a)
print('验证a的实参值是否被函数中形参所影响：',a)
main()
运行结果是：
a的初始默认值： [1, 2, 3]
a通过函数change改变后的值： [1, 2, 3, 4, 5, 6]
验证a的实参值是否被函数中形参所影响： [1, 2, 3, 4, 5, 6]
- 函数参数类型
在 Python 中，函数参数有很多种：可以为普通参数、默认值参数、关键字参数、可变长度参数等。
Python 在定义函数时不需要指定形参的类型，完全由调用者传递的实参类型以及 Python 解释器的理解和推断来决定，类似于重载和泛型。
Python 函数定义时也不需要指定函数返回值的类型，这将由函数中的 return 语句来决定，如果没有 return 语句或者 return 没有得到执行，则认为返回空值 None。
仅仅是不需要指定，并非完全不能指定，Python支持对函数参数和返回值类型的标注，但实际上并不起任何作用，只是看起来方便。
例如：
def change(n:str) ->str: #此处两种指定“:str”和“->str”都是错误的，n应该是int型才对，但这不影响结果，不会出异常。
n+=1
print('a通过函数change改变后的值：',n)
def main():
a=1
print('a的初始默认值：',a)
change(a)
print('验证a的实参值是否被函数中形参所影响：',a)
main()
运行结果：
a的初始默认值： 1
a通过函数change改变后的值： 2
验证a的实参值是否被函数中形参所影响： 1
（1） 普通参数（位置参数、必备参数）
调用函数时，要求实参和形参必须严格一致，且要求形参和实参的数量必须一致。
>>> def func(a,b,c):
print(a,b,c)
>>> func(10)
Traceback (most recent call last):
File "<pyshell#22>", line 1, in <module>
func(10)
TypeError: func() missing 2 required positional arguments: 'b' and 'c'
>>> func(10,20)
Traceback (most recent call last):
File "<pyshell#23>", line 1, in <module>
func(10,20)
TypeError: func() missing 1 required positional argument: 'c'
>>> func(10,20,30)
10 20 30
>>>
（2） 默认值参数
默认值参数必须出现在函数参数列表的最右端，且任何一个默认值参数右边不能有非默认值参数。
错误样例就是最右端不是默认值参数：
def change(a,b=0,c,d): #默认值参数b不在最右端
print(a,b,c,d)
def main():
a=1
b=2
c=3
d=4
change(a,b,c,d)
main()
结果是：
def change(a,b=0,c,d):
^
SyntaxError: non-default argument follows default argument
>>> def func(a,b=20,c):
print(a,b,c)
SyntaxError: non-default argument follows default argument
>>> def func(a,c,b=20):
print(a,b,c)
>>> def func(a,b=20,c=30):
print(a,b,c)
>>>
>>> func(10)
10 20 30
>>> func(10,40,50)
10 40 50
>>> def say( message, times =1 ):
print(message * times)
>>> say("hi")
hi
>>> say("hi",7)
hihihihihihihi
>>> say("hi ",7)
hi hi hi hi hi hi hi
>>>
默认值参数如果使用不当，会导致很难发现的逻辑错误
一般情况，要避免使用列表、字典、集合或者其他的可变序列作为函数参数的默认值
>>> def demo(newitem,old_list=[]):
old_list.append(newitem)
return old_list
>>> new_list=demo('5',[1,2,3,4])
>>> new_list
[1, 2, 3, 4, '5']
>>> new_list2=demo('aaa',['a','b'])
>>> new_list2
['a', 'b', 'aaa']
>>> new_list3=demo('a')
>>> new_list3
['a']
>>> new_list4=demo("b") #['b']
>>> new_list4
['a', 'b']
>>> new_list5=demo("a") #['b']
>>> new_list5
['a', 'b', 'a']
>>> def demo(newitem,old_list=None):
if old_list is None:
old_list=[]
old_list.append(newitem)
return old_list
>>> demo("a")
['a']
>>> demo("b")
['b']
>>> demo("c")
['c']
>>>
（3） 关键参数：主要指调用函数时的参数传递方式
（4） 可变长度参数
参数：**p——调用该函数时自动将接受到的参数转换为字典
参数：*p——无论调用该函数时传递了多少实参，一律将其放置到元组中
*不光会将之后的参数强制为关键字参数，也会将它贴着的参数视为元组
由于强制关键字参数的缘故，可变长度参数要放在最右端。
>>> def demo(*p):
print(p)
>>> demo(1)
(1,)
>>> demo(1,2)
(1, 2)
>>> demo(1,2,3,4,5,6)
(1, 2, 3, 4, 5, 6)
items方法是将字典中所有的项以列表的形式返回，列表中的每一项都是以键值对的形式表现的
>>> def demo(**p):
for item in p.items():
print(item)
>>> demo(x=1,y=2,z=3)
('x', 1)
('y', 2)
('z', 3)
>>> def demo(**p):
print(p)
print(p.items())
for item in p.items():
print(item)
>>> demo(x=1,y=2,z=3)
{'x': 1, 'y': 2, 'z': 3}
dict_items([('x', 1), ('y', 2), ('z', 3)])
('x', 1)
('y', 2)
('z', 3)
>>> def demo(a,b,c=4,*aa,**bb):
print(a,b,c)
print(aa)
print(bb)
>>> demo(1,2,3,4,5,6,7,8,9,x='1',y='2',z='3')
1 2 3
(4, 5, 6, 7, 8, 9)
{'x': '1', 'y': '2', 'z': '3'}
>>> def demo(a,b,c):
print(a+b+c)
>>> demo([1,2,3])
Traceback (most recent call last):
File "<pyshell#101>", line 1, in <module>
demo([1,2,3])
TypeError: demo() missing 2 required positional arguments: 'b' and 'c'
>>> seq=[1,2,3]
>>> demo(*seq)
6
>>>
python内存管理机制
基于值的内存存储机制，python会为每一个对象都设置对应的内存空间，但是，为提高内存应用效率，才有驻留机制。
内存分配理解
(1) python中会为每个对象分配内存，哪怕他们的值完全相等。
(2)为了提高内存利用效率对于一些简单的对象，如一些数值较小的int对象，字符串对象等，或者由数字、字符和下划线(_)组成的Python标识符和整数[-5,256]
python采取重用对象内存的办法。
整数类型：-5~256:在解释器加载时，已经自动分配了这些数字的内存
超出-5~256范围的整数，在一个代码块中申请一次内存。
（i）如指向x=3，y=3时，由于3作为简单的int类型且数值小，python不会两次为其分配内存，
而是只分配一次，然后将x与y同时指向已分配的对象。例如：
>>> y=3
>>> x=3
>>> id(x)
140724961924192
>>> id(y)
140724961924192
（ii）如对于数值较大的int对象，python会为x和y分别申请一块内存，来存储1000000000000。例如：
>>> x=1000000000000
>>> y=1000000000000
>>> id(x)
2078138287184
>>> id(y)
2078138287120
(iii) 内存分配理解
x=+6 这句的执行过程并不是先获取x原来指向的对象的地址，再把内存中的值更改为9，而是新申请
一段内存来存储对象9，再让x去指向对象9，所以两次id(x)的值不同。
#案例1：
x=3
y=x
x+=6
课堂示例：
>>> a=3
>>> b=3
>>> id
<built-in function id>
>>> id(a)
140725035586656
>>> id(b)
140725035586656
>>>
>>> str1='aaaa'
>>> str2='aaaa'
>>> id(str1)
2129228729904
>>> id(str2)
2129228729904
>>> str1='aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
>>> str2='aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
>>> id(str1) == id(str2)
True
>>> id(str1)
2129227402576
>>> id(str2)
2129227402576
>>> str2='aa aa'
>>> str1='aa aa'
#此处含有空格，储存的内存地址发生变化
>>> id(str1)
2129228729904
>>> id(str2)
2129228729848
>>>
isinstance(str1,str)方法的使用
type(str1)
>>> isinstance(str1,str)
True
>>> isinstance(str1,float)
False
>>>
变量和常量
变量和常量定义
1.变量和常量概念：
常量：不需要改变的字面值。数字3，列表 [1,2,3]都是常量。
变量：和常量相反，变量的值可以变化
2.变量创建方式
在Python中不需要事先声明变量名及其类型，直接赋值即可创建任意类型的对象变量，不仅变量的值
是可以变化的， 变量的类型也是随时可以发生变化的。也就是说，也就是说，Python中变量不需要声明，但每个
变量在使用前都必须赋值，变量赋值后该变量才会被创建。
在Python中，= 是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以
是不同类型的变量，例如：
a = 123 # a是整数
a = 'imooc' # a变为字符串
3.变量存储管理方式
Python采用的是基于值的内存管理方式，赋值语句的执行过程：首先把等号右侧的表达式计算出来，
然后在内存中寻找一个位置把值存放进入，最后创建变量指向这个内存地址。
Python中的变量不直接存储值，而是存储了值的内存地址或者引用，这也是变量类型随时可以改变的原因。
虽然不需要在使用之前显式地声明变量及其类型，但是Python仍属于强类型编程语言，Python解释器会
根据赋值或运算来自动推断变量类型。
#用来判断一个量是否是相应的类型，接受的参数是一个对象和一种类型
>>>a = 1
>>>print(isinstance(a,int))
#返回数据结构类型（list、dict、numpy.ndarray 等）
>>>type(a)
#用于获取对象的内存地址。
>>> c = 'sss'
>>> d = 1
>>> id(c)
139846936659424
>>> id(d)
9319328
4.可以使用del语句删除一些对象引用。
Python具有自动内存管理功能，对于没有任何变量指向的值，Python将会自动将其删除。
可以使用del语句删除一些对象引用。
del语句的语法是：del var1[,var2[,var3[....,varN]]]，通过使用del语句删除单个或多个对象。例如：
del var
del var_a, var_b
例如：
del x执行后，x变量已删除，不存在，此时print()，打印x值，提示异常
5.变量赋值：多个变量赋值
Python允许你同时为多个变量赋值。例如：a = b = c = 1，以上实例，创建一个整型对象，值为 1，
从后向前赋值，三个变量被赋予相同的数值。
也可以为多个对象指定多个变量。例如：a, b, c = 1, 2, "runoob"，以上实例，两个整型对象 1 和 2
的分配给变量 a 和 b，字符串对象 "runoob" 分配给变量 c。
6.变量命名，避开关键字和内置函数
编译型语言和解释性语言
计算机是不能够识别高级语言的，所以当我们运行一个高级语言程序的时候，就需要一个“翻译机”
来从事把高级语言转变成计算机能读懂的机器语言的过程。这个过程分成两类，第一种是编译，第二种是解释
编译型语言在程序执行之前，先会通过编译器对程序执行一个编译的过程，把程序转变成机器语言。
运行时就不需要翻译，而直接执行就可以了，最典型的例子就是C/java。
解释型语言就没有这个编译过程，而是在程序运行的时候，通过解释器对程序逐行做出解释，然后直接运行，
最典型的例子是python。
对比：
（1）运行机制不同
（2）编译型语言执行效率高，但跨平台性较差。解释型语言执行效率低，但跨平台性较高。
return语句
（1）定义函数时也不需要声明函数的返回值类型.而是使用return语句结束函数执行的同时返回任意类型的值，也就是说函数返回值类型与return语句返回表达式的类型一致。
（2）不论return语句出现在函数的什么位置，一旦得到执行将直接结束函数的执行。
（3）如果函数没有return语句、有return语句但没有执行到或者执行了但不返回任何值的return语句，解释器都会认为该函数以return None结束，即返回空值。
>>> def demo(x,y):
if x==1:
return x
if y==1:
return y
if x==y:
return x
>>> demo(1,2)
1
>>> demo(2,1)
1
>>> demo(1,1)
1
>>> def demo(x,y):
if x==1:
return "x=1"
if y==1:
return "y=1"
if x==y:
return "x==y"
>>> demo(1,2)
'x=1'
>>> demo(2,1)
'y=1'
>>> demo(1,1)
'x=1'
>>> def demo(x,y):
if x==1:
print("x=1")
if y==1:
print("y=1")
if x==y:
print("x==y")
>>> demo(1,1)
x=1
y=1
x==y
append（）、insert（）、extend（）、id()、eval()、count()、len()、sum()、min()、max()、isinstance()、type()…等函数的使用
python注释、缩进
单行注释：可以使用# 注释的内容来进行快速的单行注释，主要用于对单行代码的解读；
同时也可以使用"""注释的内容"""，主要用于包、模块、类或者函数里面的第一个语句。
多行注释：第一种方法是使用"""注释的内容"""方式，只是将注释的内容放在三重双引号里面，
并且可以多行；第二种方法其实是用#，在每一行前面进行注释，从而达到多行注释的效果。
# 单行注释
print("hello world!") # 单行注释
def sum_all(a,b):
"""return the sum of a and b"""
return a + b
"""
这里是注释的内容
这里是多行注释
"""
# 这里是注释的内容
# 这里是多行注释
# 达到多行注释的效果
代码缩进是为了代码结构更加清晰易读，但像JAVA语言，由于强制使用分号结束语句，所以即使不缩进，
也可以正常执行代码，如果使用缩进，空格或TAB都是可以的。
Python有些不一样，规定只使用空格实现缩进，必须使用4个空格表示每一级缩进，如果使用Tab，
也可以通过，但不符合规范。必须注意的是，在同一段代码内，不能混合使用缩进方式，因此建议全部使用4个
空格作为每级缩进，或者至少使用同样的缩进方式。
下面是使用4个空格的示例：
# 正确的缩进
if 1:
print("you are right")
else:
print("you are wrong")
说明一下这里出现的一些写法
1、if 的内容不需要小括号，使用冒号作为 if 行的结束
2、Python通过换行识别每一条代码，所以可以不用加分号；如果多条代码写在一行，则需要加分号识别。
3、IDLE界面使用 ctrl+j 换行，直接输入回车则执行代码
4、一条语句可以分多行编写，多行编写时语句后边以\结尾
然后我们在 else: 后的2行代码，使用不同的缩进方式，然后执行就会报错
因此，我们在写Python代码时要仅使用一种缩进方式。
python和其他语言最容易区分的特点就是其使用缩进来表示代码块，而不是括号。
最好是使用4个空格进行悬挂式缩进，并且属于同一个代码块的代码需要具有相同的缩进空格数，
否则程序会出现错误。
# 错误的缩进
if 1:
print("you are right")
else:
print("you are wrong")
print("错误的缩进") #这条语句出现了错误缩进
# 下面一条语句是错误的提示信息
# IndentationError: unindent does not match any outer indentation level
python语言特点
Python是一门跨平台、开源、免费的解释型高级动态编程语言。
优点: 简单易学免费开源，⾼级语⾔
可移植性，⾯向对象，可扩展性
丰富的库等
缺点: 运⾏速度
国内市场较⼩,做主要开发⽬前只有⼀些web2.0公司
中⽂资料匮乏
构架选择太多
Python常见内置数据类型
内置对象
（1） 数字：不可变对象
支持三种数据类型：
整型（整数、int）：正、负（十进制、八进制、十六进制、二进制），python3中整数没有精度限制
浮点型（小数、float）：整数.XXXX
支持科学计数法 2.5e2=2.5*102
复数：
>>> a = 3+4j
>>> b = 5+6j
>>> c = a+b
>>> c
(8+10j)
>>> c.real #查看复数实部
8.0
>>> c.imag #查看复数虚部
int()
float()
complex ()
#在Python数值分成了三种：整数、浮点数（小数）、复数
#在Python中所有的整数都是int类型
a-10
b=20
#Python中的整数的大小没有限制，可以是一个无限大的整数
#C=999999999999999999999999999999999999999999999**100
#如果数字的长度过大，可以使用下划线作为分隔符
c=123_456_789
I
#d=0123
10进制的数字不能以0开头
#其他进制的整数，只要是数字打印时一定是以十进制的形式显示的
#二进制0b开头
c=Ob10 #二进制的10
#八进制0o开头
C=0o18
#十六进制0x开头
C=0x10
#也可以通过运算符来对数字进行运算，并且可以保证整数运算的精确
c=-100
C= C+1
#浮点数（小数），在Python中所有的小数都是float类型
c=1.23
C=4.56
#对浮点数进行运算，可能会得到一个不精确的值，比如
0.1+0.2
# 0.30000000000000004 就好比10进制里不能完全得到三分之一的结果一样，只能得一个近似值，所以涉及金额方面的
#一定不能用浮点计算
（2）字符串，在Python中字符串需要使用引号引起来
s = 'hello'
s = abc # 字符串必须使用引号引起来，不使用不是字符串
# 引号可以是双引号，也可以是单引号，但是注意不要混着用
s = 'hello'
s = "hello"
# 相同的引号之间不能嵌套
s = "子曰:"学而时习之，乐呵乐呵！""#错误写法
s = '子曰:"学而时习之，乐呵乐呵！"'
# 单引号和双引号不能跨行使用，如下代码不是换行（一条语句可以分多行编写，多行编写时语句后边以\结尾）
s = '锄禾日当午，\
汗滴禾下土，\
谁知盘中餐，\
粒粒皆辛苦'
# 使用三重引号来表示一个长字符串 '''或 """，三重引号可以换行，并且会保留字符串中的格式
s = '''锄禾日当午，
汗滴禾下土，
谁知盘中餐，
粒粒皆辛苦'''
# 常用转义字符
# \' 表示 '
# \" 表示 "
# \t 表示制表符
# \n 表示换行符
# \\ 表示 \
# \uxxxx 表示Unicode编码
s = "子曰:\"学而时习之，\\\\n乐呵乐呵！\""
s = '\u2250'
print(s)
字符串格式化
# 格式化字符串
a = 'hello'
# 如果将两个字符串进行相加，则会自动将两个字符串拼接为一个
a = 'abc' + 'haha' + '哈哈' #输出结果：'abchaha哈哈'
# 字符串不能和其他的类型进行加法运算，如果做了会出现异常
#通过，进行字符串拼接
print("a = "+a) # 这种写法在Python中不常见
a = 123
print('a =',a)
# 在创建字符串时，可以在字符串中指定占位符
# %s 在字符串中表示任意字符，%f 浮点数占位符，%d 整数占位符
b = 'Hello %s'%'孙悟空'
b = 'hello %s 你好 %s'%('tom','孙悟空') # hello tom 你好 孙悟空
b = 'hello %3.5s'%'abcdefg' # %3.5s字符串的长度限制在3-5之间
b = 'hello %s'%123.456
b = 'hello %.2f'%123.456 #'hello 123.46'，四舍五入
b = 'hello %d'%123.95 #'hello 123'
b = '呵呵'
# 格式化字符串，可以通过在字符串前添加一个f来创建一个格式化字符串
# 在格式化字符串中可以直接嵌入变量
c = f'hello {a} {b}'
print(f'a = {a}')
# 字符串的复制（将字符串和数字相乘），* 在语言中表示乘法
a = 'abc'
# 如果将字符串和数字相乘，则解释器会将字符串重复指定的次数并返回
a = a * 20
print(a) #abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc
非内置对象
需要导入模块才能使用，如正弦函数sin(x)，随机数产生函数random( )等
操作符和表达式
（1） x==y（比较值） x is y（地址） True/False
（2） / //
/ 除法运算
// 返回结果取不大于正常除法运算结果的最大整数
（3） 补充运算法则：整型优先级：复数》浮点数》整数
（4） + 加法运算/字符串连接符
* 乘法运算/[列表、字符串、元组等]*整数，表示对内容进行重复并返回重复后的新对象。
Python中逗号“,”并不是运算符，而只是一个普通分隔符（元组的使用）
常见内置函数
1.内置函数不需要导入任何模块即可使用
2.执行下面的命令可以列出所有内置函数
>>> dir(__builtins__)
3.常见内置函数可查阅开发文档或者PPT。
sum()、max()、min()、sum()/len()用于计算列表、元组或其他可迭代对象中所有元素最大值、最小值以及所有元素之和、所有元素平均值。
sum()只支持数值型元素的序列或可迭代对象，max()和min()则要求序列或可迭代对象中的元素之间可比较大小
说明：
>>> import random
>>> a = [random.randint(1,100) for i in range(10)]
>>> a
[23, 60, 24, 2, 51, 27, 68, 18, 9, 80]
>>> sum(a)
362
>>> min(a)
2
>>> max(a)
80
>>> sum(a)/len(a)
36.2
==============================================================
>>> b=['a','b','c']
>>> b
['a', 'b', 'c']
>>> sum(b)
Traceback (most recent call last):
File "<pyshell#12>", line 1, in <module>
sum(b)
TypeError: unsupported operand type(s) for +: 'int' and 'str'
>>> min(b)
'a'
>>> max(b)
'c'
>>>
字符串和正则表达式
1.基本定义
不可变序列，有序序列，支持双向索引，支持切片，支持字符串常用方法
>>> testString="good"
>>> testString
'good'
>>> testString[0]
'g'
>>> testString[-2]
'o'
>>> testString[1:3]
'oo'
>>> testString[0]='b'
Traceback (most recent call last):
File "<pyshell#15>", line 1, in <module>
testString[0]='b'
TypeError: 'str' object does not support item assignment
>>>
Python字符串格式化
方式一
方式二：format方法
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的 % 。
format 函数可以接受不限个参数，位置可以不按顺序。
实例
>>>"{} {}".format("hello", "world") # 不设置指定位置，按默认顺序
'hello world'
>>> "{0} {1}".format("hello", "world") # 设置指定位置
'hello world'
>>> "{1} {0} {1}".format("hello", "world") # 设置指定位置
'world hello world'
也可以设置参数：
实例
#!/usr/bin/python
# -*- coding: UTF-8 -*-
print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com")) # 通过字典设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的
输出结果为：
网站名：菜鸟教程, 地址 www.runoob.com
网站名：菜鸟教程, 地址 www.runoob.com
方式三、数字格式化（记住几个常用的即可）
下表展示了 str.format() 格式化数字的多种方法：
>>> print("{:.2f}".format(3.1415926))
3.14
^, <, > 分别是居中、左对齐、右对齐，后面带宽度
: 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充
+ 表示在正数前显示 +，负数前显示 -；
（空格）表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制。
python变量命名规范
1、变量名只能是字母、数字或下划线的任意组合；
2、变量名的第一个字符不能是数字；
3、变量名不能是关键字；
4、变量名不能包含空格。
5、一般类名使用首字母大写来定义，也就是类名采用驼峰命名法
class Person #类名
6、在Python中，常量如何定义？由于python不像C#、C、Java等在声明变量时，需声明类型。
因此，常量在python中，采用所有大写字母来定义常量：
AGE_OF_MAN=88 #常量
例如下面变量，有些是合法的，有些是不合法的
abc_xyz：合法。
HelloWorld：合法。
abc：合法。
xyz#abc：不合法，标识符中不允许出现“#”号。
abc1：合法。
1abc：不合法，标识符不允许数字开头。
Python 条件表达式认定为True的情况
条件表达式被认定为true的情况
在选择和循环结构中，条件表达式的值只要不是False、0（或0.0、0j等）、空值None、空列表、
空元组、空集合、空字典、空字符串、空range对象或其他空迭代对象，Python解释器均认为与True等价。
pass作用
pass是用来在判断或循环语句中占位的
在python中有时候能看到定义一个def函数，函数内容部分填写为pass。
这里的pass主要作用就是占据位置，让代码整体完整。如果定义一个函数里面为空，
那么就会报错，当你还没想清楚函数内部内容，就可以用pass来进行填坑。
def demo():
i = 0
if i < 5:
pass
lambda表达式的使用
（1）定义：lambda表达式可以用来声明匿名函数（意为不再使用 def 语句这样标准的形式定义一个函数），即没有函数名字
的临时使用的小函数，只可以包含一个表达式，且该表达式的计算结果为函数的返回值，不允许包含其他复杂的语句，但在表达式中可以调用其他函数。
（2）语法：
lambda [参数列表]：expression
（3）简单案例：
sum=lambda arg1，arg2:arg1+arg2
sum(10,20)
>>> sum=lambda arg1,arg2:arg1+arg2
>>> sum(10,20)
30
>>> g=lambda x,y=2,z=3:x+y+z
>>> g(1)
6
>>> g(2,z=4,y=5)
11
>>> L=[(lambda x:x**2),(lambda x:x**3),(lambda x:x**4)]
>>> print(L[0](2),L[1](2),L[2](2))
4 8 16
>>> L=[1,2,3,4,5]
>>> print(list(map((lambda x:x+10),L)))
[11, 12, 13, 14, 15]
>>> L
[1, 2, 3, 4, 5]
表达式中可以调用其他函数
>>> def demo(n):
return n*n
>>> demo(5)
25
>>> a_list=[1,2,3,4,5]
>>> list(map(lambda x:demo(x),a_list))
[1, 4, 9, 16, 25]
lambda表达式，被称为匿名函数，如：lambda x, y : x+y，冒号前的x、y是所需参数，
冒号后的x+y是所要运行的表达式，返回值就是计算后的结果，如：(lambda x, y : x+y)(1, 2)，结果为3。
def demon(x,y):
return x * y
demon(9,14)
#output
126
#用lambda表达式表示如下
f = lambda x,y: x * y
f(9,14)
#output
126
is 和 == 的区别
（1）==表示两个对象是否相等，相当于调用__eq__()方法，即’a==b’ ==> a.eq(b)。
（2）is表示的是对象标识符，用来检查对象的标识符是否一致，即两个对象在内存中的地址是否一致。
在使用 a is b 的时候，相当于id(a)==id(b)。
==是python标准操作符中的比较操作符，用来比较判断两个对象的value(值)是否相等，
例如下面两个字符串间的比较：
>>> a = 'cheesezh'
>>> b = 'cheesezh'
>>> a == b
True
is也被叫做同一性运算符，这个运算符比较判断的是对象间的唯一身份标识，也就是id是否相同。
例如下面几个list间的比较：
>>> x = y = [4,5,6]
>>> z = [4,5,6]
>>> x == y
True
>>> x == z
True
>>> x is y
True
>>> x is z
False
>>>
>>> print id(x)
3075326572
>>> print id(y)
3075326572
>>> print id(z)
3075328140
可以看到，前三个比较都是True，最后一个 x is z 是False，x、y和z的值是相同的，
所以前两个是True没有问题。至于最后一个为什么是False，看看三个对象的id分别是什么就会明白了。
x和y指向同一个对象，x和z指向不同的对象。
input()函数
input()函数
# input()调用后，程序会立即暂停，等待用户输入
# 用户输入完内容以后，点击回车程序才会继续向下执行
# 用户输入完成以后，其所输入的的内容会以返回值得形式返回
注意：input()的返回值是一个字符串
# input()函数中可以设置一个字符串作为参数，这个字符串将会作为提示文字显示
a = input('请输入任意内容：')
选择结构（if）
（1）单分支结构 if
username = input('请输入你的用户名:')
if username == 'admin' :
print('欢迎管理员光临！')
（2）双分支结构 if else
语法：
if 条件表达式 :
代码块
else :
代码块
执行流程：
if-else语句在执行时，先对if后的条件表达式进行求值判断
如果为True，则执行if后的代码块
如果为False，则执行else后的代码块
age = 7
if age > 18 :
print('已经成年')
else :
print('尚未成年')
Value1 if condition else value2【惰性求值】
惰性求值：就是在需要是才进行求值的计算方式，比如 a and b 如果a 为0则不需要去计算b是否为真
同理a or b 如果a为1则不需要去计算b是否为真。
（3）多分支结构 if elif else：
语法：
if 条件表达式 :
代码块
elif 条件表达式 :
代码块
elif 条件表达式 :
代码块
elif 条件表达式 :
代码块
else :
代码块
执行流程：
if-elif-else语句在执行时，会自上向下依次对条件表达式进行求值判断，
如果表达式的结果为True，则执行当前代码块，然后语句结束
如果表达式的结果为False，则继续向下判断，直到找到True为止
如果所有的表达式都是False，则执行else后的代码块
if-elif-else中只会有一个代码块会执行
def func(score):
if score > 100:
return 'wrong score.must <= 100.'
elif score >= 90:
return 'A'
elif score >= 80:
return 'B'
elif score >= 70:
return 'C'
elif score >= 60:
return 'D'
elif score >= 0:
return 'E'
else:
return 'wrong score.must >0'
c=func(88)
print(c)
print(func(88))
print("=================")
def func(score):
if score > 100:
print('wrong score.must <= 100.')
return
elif score >= 90:
print('A')
elif score >= 80:
print('B')
elif score >= 70:
print('C')
elif score >= 60:
print('D')
elif score >= 0:
print('E')
else:
print('wrong score.must >0')
func(-88)
print(func(-88))
print("=================")
def func(score):
if score > 100:
print('wrong score.must <= 100.')
if score >= 90:
print('A')
if score >= 80:
print('B')
if score >= 70:
print('C')
if score >= 60:
print('D')
if score >= 0:
print('E')
else:
print('wrong score.must >0')
func(88)
print("=================")
#多个if型:
a=0
if a==0:
a+=1
print("aaa")
if a==1:
print("bbb")
if a==2:
print("ccc")
# 最终输出:aaabbb
在多个if语句中,所有的if都会进行判断,无论是否满足情况.
所以在满足a==0时,执行了a+=1,a就变成了1,当进行a==1判断时,也符合,故也执行了print("bbb")
print("=================")
#if elif else型:只有一个出口
a=2
if a==0:
a+=1
print("aaa")
elif a==1:
print("bbb")
else:
print("ccc")
# 最终只输出了aaa.在if elif else中,只要有一个条件满足,则其余条件不用判断,直接跳过即可,所以a+=1,a=1之后不会去判断else if中的a==1,
# 所以也就不会执行printf("bbb")
for循环的使用
语法:
for 变量 in 序列:
循环体
在使用for之前先来了解一下range，大致有以下三种用法
1、只有一个参数，表示从0到这个参数内的所有整数，不包括该参数
a=range(10)
定义一个list，用来将range的范围的所有数进行陈放为list形式
b=list(a)
print(a)
print(b)
range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
2、两个参数，第一个表示左边界，第二个表示右边界，range表示从左边界到右边界的所有整数，左闭右开。
a=range(1,15)
b=list(ran)
print(a)
print(b)
range(1, 15)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
3、三个参数，第一个表示左边界，第二个表示右边界，第三个表示步长step，即两个整数之间相差的数，左闭右开。
a=range(1,15,2)
b=list(ran)
print(a)
print(b)
range(1, 15, 2)
[1, 3, 5, 7, 9, 11, 13]
for循环练习：
for item in range(5):
print(item)
for num in range(10,15):
print(num)
for a in range(20,30,2):
print(a)
for循环实例：
##求1、3、5...99的和
sum = 0
for i in range(1,101,2):
sum += i
print(sum)
while循环的使用
# while循环
# 语法：
while 条件表达式 :
代码块
else :
代码块
执行流程：
while语句在执行时，会先对while后的条件表达式进行求值判断，
如果判断结果为True，则执行循环体（代码块），
循环体执行完毕，继续对条件表达式进行求值判断，以此类推，
直到判断结果为False，则循环终止，如果循环有对应的else，则执行else后的代码块
条件表达式恒为True的循环语句，称为死循环，它会一直运行，慎用！
while True :
print('hello')
循环的三个要件（表达式）
#初始化表达式，通过初始化表达式初始化一个变量
i = 0
#条件表达式，条件表达式用来设置循环执行的条件
while i < 10 :
print(i)
# 更新表达式，修改初始化变量的值
i += 1
创建一个执行十次的循环
i = 0
while i < 10 :
i += 1
print(i,'hello')
else :
print('else中的代码块')
练习1(求100以内所有的奇数之和)
# 获取所有100以内数
i = 0
# 创建一个变量，用来保存结果
result = 0
while i < 100 :
i += 1
# 判断i是否是奇数
if i % 2 != 0:
result += i
print('result =',result)
#获取100以内所有的奇数
i = 1
result = 0
while i < 100:
print(i)
i += 2
result += i
print('result =',result)
break和continue作用
break语句在while循环和for循环中都可以使用，一般放在if选择结构中，一旦break语句被执行，将使得整个循环提前结束。
continue语句的作用是终止当前循环，并忽略continue之后的语句，然后回到循环的顶端，提前进入下一次循环。
break和continue都是只对离他最近的循环起作用
创建一个5次的循环
#break练习
i = 0
while i<5:
if i==3:
break
print(i)
else:
print("循环结束")
#continue练习
i = 0
while i < 5:
i += 1
if i == 2:
continue
print(i)
else :
print('循环结束')
879
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
