一.Python中标识符的命名规则
1 区分大小写:Myname与myname是两个不同的标识符。
2 首字符可以是下画线(_)或字母,但不能是数字。
3 除首字符外的其他字符必须是下画线、字母和数字。
4 关键字不能作为标识符。
5 不要使用Python的内置函数作为自己的标识符。
6 Unicode命名规则
二.变量、语句、注释
1.定义变量不需要定义类型,后续也可以修改
2.语句结束后不需要加分号,形如:a=b=c=3 这种链式赋值语句可以同时给多个变量相同的值
3.注释:单行注释 #
三.模块
1.import 模块名 这样可以导入模块所有代码元素,在访问时前缀模块名字
import m2
y=20
print(m2.x)
x=20.0
from m2 import x
y=20
print(x)
2.from 模块 import x 意为导入模块中的x元素,访问时不需要加模块名字
from m2 import x as x2
x=100
y=20
print(x2)
3.from 模块 import 代码元素 as 代码元素别名:
与第二种情况类似,在当前m1模块的代码元素(x变量)与要导入的m2模块的代码元素(x变量)名称有冲突时,可以给要导入的代码元素(m2中的x)一个别名x2
示例
# py1.py
x="你好"
# py2.py
# import py1
# print(py1.x)
# from py1 import x
# print(x)
from py1 import x as x1
print(x1)
四.数据类型(数字)
在Python中所有的数据类型都是类,每个数据值都是类的“实例”。
在Python中有6种主要的内置数据类型:数字、字符串、列表、元组、集合和字典。列表、元组、集合和字典统称容器类型。
Python中的数字类型有4种:整数类型、浮点类型、复数类型和布尔类型。需要注意的是,布尔类型也是数字类型,它事实上是整数类型的一种
1.整数类型
a=type(28) #返回数据类型
a=0b11100 #二进制
a=0o34 #八进制
a=0x1c #十六进制
print(a)
2.浮点类型
a=type(1.0) #返回数据类型
a=3.36e2 #科学计数法
a=.336e-2 #省略前缀0
print(a)
3.复数类型
a=type(1+2j) # 返回数据类型<complex>
a=(1+2j) + (2+3j) # 复数相加
print(a)
4.布尔类型
python中的数据类型转换很灵活,任何类型的数据都可以通过 bool()函数转换为布尔值 ,,空值和0值会被转换为False,反之会被转换为True
空值包括空字符串‘’,空列表[],空字典{}
5.数字类型转换
隐式转换(也就是默认的自动的转换)
布尔和整数类型运算,结果是整数
布尔或整数和浮点运算,结果是浮点数
a=1
b=True
print(a+b) # 2
c=2.0
print(a+b+c) # 4.0
显式转换
int() bool() float()
a=(1.0)+1
print(int(a)) # 2
print(float(a)) # 2.0
print(bool(a)) # True
五.运算符
1.算术运算符
2.比较运算符
1.比较字符串的大小时,逐一遍历比较字符编码的大小,如果两个字符串第一个字符不能比较出大小,则比较两个字符串的第二个字符,直到比较出结果
2.比较列表大小,即逐一比较其中元素的大小,如果两个列表中的第一个元素不能比较出大小,则比较两个字符串的第二个字符,直到比较出结果。(两个列表中元素类型要兼容)
3.逻辑运算符
4.位运算符
位运算都是相对于二进制位数来运算的
按位取反公式:~a=(a+1)*(-1)
5.赋值运算符
6.运算符优先级
优先级从高到低大概是:算术运算符,位运算符,关系运算符,逻辑运算符,赋值运算符
六.程序流程控制
1.分支语句
'''
if 条件:
语句组
'''
score=int(input("请输入一个0~100的整数:")) # input() 函数从控制台获取用户输入的字符串
if score >=85:
print("您很优秀!")
if score <60:
print("您需要继续努力")
if (score>=60) and (score<85):
print("您的成绩还可以,仍需努力")
'''
if 条件:
语句组1
else:
语句组2
'''
score=int(input("请输入一个0~100的整数:")) # input() 函数从控制台获取用户输入的字符串
if score >=60:
if score>=85:
print("您很优秀!")
else:
print("您的成绩还可以,仍需努力")
else:
print("您仍需努力")
'''
if 条件:
语句组1
elif 条件2:
语句组2
elif 条件3:
语句组3
else:
语句组
'''
score=int(input("请输入一个0~100的整数:")) # input() 函数从控制台获取用户输入的字符串
if score >=90:
grade = 'A'
elif score >=80:
grade = 'B'
elif score >=70:
grade = 'C'
elif score >=60:
grade = 'D'
else:
grade = 'F'
print("Grade = "+grade)
2.循环语句
1.while
'''
while 循环条件:
循环体语句组
[else:
语句组] #中括号部分可以省略
'''
i=0
while i*i<1000:
i+=1
print("i="+str(i)) # str() 函数为将括号内元素转换为字符串
else:
print("while over!")
若while循环体没有中断,而是正常执行完结束,就执行else语句
循环控制:break中断,continue继续,
2.for
由于简单的设计理念,python中只有一种for语句,就是for-in语句,可以遍历任意可迭代对象中的元素
'''
for 变量 in 可迭代对象:
循环体语句组
[else:
语句组]
'''
print("----字符串-----")
for item in 'Hello':
print(item)
# 声明一个整数列表
numbers = [43,32,55,74]
print("-----整数列表-----")
for items in numbers:
print(item)
range(数字)函数,返回整数序列,取值大于等于0且小于数字,共有数字个整数
# 计算水仙花数
i = 101
while i<=999:
a = i // 100
b = i // 10 % 10
c = i % 10
if (a**3+b**3+c**3) == i:
print(str(i))
i+=1
七.容器类型的数据
Python内置的数据类型如序列(列表、元组等)、集合和字典等可以容纳多项数据,我们称它们为容器类型的数据
1.序列
序列(sequence)是一种可迭代的、元素有序的容器类型的数据
序列包括列表(list)、字符串(str)、元组(tuple)和字节序列(bytes)等。
a.索引
序列中的元素都是有序的,每一个元素都带有序号,这个序号叫作索引。索引有正值索引和负值索引之分。
a = 'hello'
print(a[0])
print(a[4])
print(a[-5])
print(max(a)) # max()函数用于返回最后一个元素
print(min(a)) # min()函数用于返回第一个元素
print(len(a)) # len()函数用于获取序列的长度
b.加和乘操作
加(+)和乘()运算符也可以用于序列中的元素操作。加(+)运算符可以将两个序列连接起来,乘()运算符可以将两个序列重复多次。
a='hello'
print(a*2)
print(a+',,,')
a+='world'
print(a)
c.切片操作
序列的切片(Slicing)就是从序列中切分出小的子序列
切片运算符的语法形式为[start:end:step]。其中,start是开始索引,end是结束索引,step是步长(切片时获取的元素的间隔,可以为正整数,也可以为负整数)
注意:切下的小切片包括start位置的元素,但不包括end位置的元素,start和end都可以省略。
d.成员测试
成员测试运算符有两个:in和not in,in用于测试是否包含某一个元素,not in用于测试是否不包含某一个元素。
a="hello"
print('e' in a)
print('1' in a)
2.列表
列表(list)是一种可变序列类型,我们可以追加、插入、删除和替换列表中的元素。
a.创建列表
创建列表有两种方法。
1、list(iterable)函数:参数iterable是可迭代对象(字符串、列表、元组、集合和字典等)。
2、 [元素1,元素2,元素3,⋯]:指定具体的列表元素,元素之间以逗号分隔,列表元素需要使用中括号括起来
# 方式1
a=[20,10,20,5]
b=['aa',1,2,3,'bb']
c=[]
# 方式2
d=list('hello')
print(a)
print(b)
print(c)
print(d)
'''结果
[20, 10, 20, 5]
['aa', 1, 2, 3, 'bb']
[]
['h', 'e', 'l', 'l', 'o']
'''
b.追加元素
列表是可变的序列对象,列表可以追加元素。
1 、在列表中追加单个元素时,可以使用列表的append(x)方法。
2 、在列表中追加多个元素时,可以使用加(+)运算符或列表的extend(t)方法。
问题:append(x)是方法,list(iterable)是函数,方法和函数有什么区别?
在Python中方法和函数是有区别的,方法隶属于类,通过类或对象调用方法,例如在list.append(x)中,list是列表对象;函数不属于任何类,直接调用即可,例如list(iterable)
list = [20,10,50,30]
list.append(80) # 追加单个元素
print(list)
t=[1,2,3,4]
list+=t # 使用+=追加多个元素
print(list)
list.extend(t) # 使用extend()方法追加多个元素
print(list)
c.插入元素
想向列表中插入元素时,可以使用列表的list.insert(i,x)方法,其中,i指定索引位置,x是要插入的元素。
list = [20,10,50,30]
list.insert(2,80) # 在索引2的位置之前插入一个元素,新元素的索引是2
print(list)
d.替换元素
list = [19,20,21,22]
list[1]=30
print(list)
e.删除元素
想在列表中删除元素时,可使用列表的list.remove(x)方法,如果找到匹配的元素x,则删除该元素,如果找到多个匹配的元素,则只删除第一个匹配的元素。
list = [19,20,21,22]
list.remove(20) # 删掉20
print(list)
list = [19,20,19,21,19]
list.remove(19) # 删掉第一个19
print(list)
3.元组
元组(tuple)是一种不可变序列类型。
a.创建元组
创建元组时有两种方法。
1 tuple(iterable)函数:参数iterable是可迭代对象(字符串、列表、元组、集合和字典等)。
2 (元素1,元素2,元素3,⋯):指定具体的元组元素,元素之间以逗号分隔。对于元组元素,可以使用小括号括起来,也可以省略小括号
a=5,6,7,8 # 元组创建可以省略括号
print(a)
print(type(a)) # 元组
b=(5,6,7,8) # 元组指定元素创建
print(b)
print(type(b)) # 元组
c=tuple([5,6,7,8]) # tuple()函数创建元组
print(c)
print(type(c))
d=tuple(1,) # 创建只有一个元素的元组,元素后面的逗号不能省略
d=1,
b.元组拆包
创建元组,并将多个数据放到元组中,这个过程被称为元组打包。
与元组打包相反的操作是拆包,就是将元组中的元素取出,分别赋值给不同的变量
s_id,s_name=(102,'张三') # 分别赋值装包
print(s_id) # 拆包
print(s_name) # 拆包
问题:本例元组(102,'张三')中的两个元素分别是不同的数据类型,这种情况是否允许?
答:当然允许,不仅是元组,事实上所有容器类型的数据中都可以保存任意类型的数据,只不过通常在容器中只保存相同类型的容器
4.集合
集合(set)是一种可迭代的、无序的、不能包含重复元素的容器类型的数据。
a.创建集合
序列中的元素是有序的;集合中的元素是无序的,但元素不能重复
我们可以通过以下两种方式创建集合。
1 set(iterable)函数:参数iterable是可迭代对象(字符串、列表、
元组、集合和字典等)。
2 {元素1,元素2,元素3,⋯}:指定具体的集合元素,元素之间以
逗号分隔。对于集合元素,需要使用大括号括起来
a = set('hello')
print(a) # 无序不重复随机输出
b= {'o','e','l','l','h'}
print(b) # 无序不重复随机输出
c={}
print(type(b)) # <class 'set'>
print(type(c)) # <class 'dict'>
b.修改集合
修改集合类似于修改列表,可以向其中插入和删除元素。修改可变集合有如下常用方法。
add(elem):添加元素,如果元素已经存在,则不能添加,不会抛出错误。
remove(elem):删除元素,如果元素不存在,则抛出错误。
clear():清除集合
s_set = {'张三','李四','王五'}
s_set.add('懂六')
print(s_set) # {'王五', '张三', '李四', '懂六'}
s_set.remove('李四')
print('李四' in s_set) # False
s_set.clear()
print(s_set) # set()
5.字典
字典(dict)是可迭代的、通过键(key)来访问元素的可变的容器类型的数据。
字典由两部分视图构成:键视图和值视图。键视图不能包含重复的元素,值视图能。在键视图中,键和值是成对出现的。
a.创建字典
我们可以通过以下两种方法创建字典。
1 dict()函数
2 {key1:value1,key2:value2,...,key_n:value_n}:指定具体的字典键值对,键值对之间以逗号分隔,最后用大括号括起来
a=dict({102:'zy',103:'ls',106:'ww'}) # dict()函数创建字典,参数是另一个字典
b=dict(((102,'zy'),(103,'ls'),(106,'ww'))) # dict()函数创建字典,参数是一个元组,元组里至少有三个只有两个元素的元组
c=dict([(102,'zy'),(103,'ls'),(106,'ww')]) # dict()函数创建字典,参数是一个列表,列表里至少有三个只有两个元素的元组
d=dict(zip([102,105,106],['zy','ls','ww'])) # zip()函数将两个可迭代对象打包成元组,第一个参数是字典的键,第二个参数是字典值,个数相同,一一对应
e={102:'zy',103:'ls',106:'ww'}
print(a) # {102: 'zy', 103: 'ls', 106: 'ww'}
print(b) # {102: 'zy', 103: 'ls', 106: 'ww'}
print(c) # {102: 'zy', 103: 'ls', 106: 'ww'}
print(d) # {102: 'zy', 103: 'ls', 106: 'ww'}
print(e) # {102: 'zy', 103: 'ls', 106: 'ww'}
b.修改字典
字典可以被修改,但都是针对键和值同时操作的,对字典的修改包括添加、替换和删除。
dict1={102:'zs',103:'ls',104:'ww'}
print(dict1[104]) # ww
dict1[110]='yh' # 若此时字典里有110,就修改为‘yh';反之,添加110,’yh‘
print(dict1) # {102: 'zs', 103: 'ls', 104: 'ww', 110: 'yh'}
dict1.pop(102) # pop(key)函数删除键值对
print(dict1) # {103: 'ls', 104: 'ww', 110: 'yh'}
c.访问字典视图
我们可以通过字典中的三种方法访问字典视图。
items():返回字典的所有键值对视图。keys():返回字典键视图。values():返回字典值视图。
dict1 = {102:'zs',103:'ls',104:'ww'}
print(dict1.items()) # 返回字典的所有键值对视图dict_items([(102, 'zs'), (103, 'ls'), (104, 'ww')])
print(list(dict1.items())) # dict_items可以使用list()函数返回键值对列表[(102, 'zs'), (103, 'ls'), (104, 'ww')]
print(dict1.keys()) # 返回字典键视图dict_keys([102, 103, 104])
print(list(dict1.keys())) # dict_keys可以使用list()函数返回键列表[102, 103, 104]
print(dict1.values()) # 返回字典值视图dict_values(['zs', 'ls', 'ww'])
print(list(dict1.values())) # dict_values可以使用list()函数返回键列表['zs', 'ls', 'ww']
d.遍历字典
遍历就是从容器中取出每一个元素的过程,我们在进行序列和集合遍历时使用for循环就可以了
字典有两个视图,在遍历时,可以只遍历值视图,也可以只遍历键视图,还可以同时遍历,具体遍历哪个视图就要看你的业务需求了,这些遍历都是通过for循环实现的
s_dict={102:'zs',103:'ls',104:'ww'}
print('----遍历键----')
for s_id in s_dict.keys():
print('学号:'+str(s_id))
print('----遍历值----')
for s_name in s_dict.values():
print('姓名:'+str(s_name))
print('----遍历键:值---')
for s_id,s_name in s_dict.items():
print('学号:{0} - 姓名:{1}'.format(s_id,s_name))
容器类型都是可迭代的,最大的特点如下:
1.序列元素是有序的,其中列表是可变的,元组是不可变的
2.集合元素是无序的,不可重复的
3.字典通过键来访问元素,由键视图和值视图构成,键视图不能包含重复的元素
八.字符串
在Python中,字符串(str)是一种不可变的字符序列,序列操作完全适用于字符串
1.字符串的表示方式:
字符串有三种表示方式:普通字符串、原始字符串和长字符串。
a.普通字符串
普通字符串是指用单引号或双引号括起来的字符串
字符转义:如果想在字符串中包含一些特殊的字符,例如换行符、制表符等,在普通字符串中需要转义,前面要加反斜杠(\)
b.原始字符串
实际开发中,普通字符串可能有很多转义符,特别麻烦,这时候我们可以使用原始字符串(raw string)表示,原始字符串中的特殊字符不需要被转义,按照字符串的本来样子呈现,在普通字符串前加r就是原始字符串了
a='hello \n world'
print(a)
b=r'hello \n world'
print(b)
c.长字符串
如果要使用字符串表示一篇文章,其中包含了换行、缩进等排版字符,则可以使用长字符串表示。对于长字符串,要使用三个单引号(''')或三个双引号(""")括起来。
s='''
锦瑟
锦瑟无端五十弦,一弦一柱思华年
庄生晓梦迷蝴蝶,望帝春心托杜鹃
沧海月明珠有泪,蓝田日暖玉生烟
此情可待成追忆,只是当时已惘然
'''
print(s)
2.字符串与数字的相互转换
字符串与数字互不兼容,只能通过函数进行显式转换
a.将字符串转换为数字
将字符串转换为数字,可以使用int()和float()实现,如果成功则返回数字,否则引发异常
num='80'
print(int(num))
num='AB'
print(int(num,16)) # 指定按照十六进制转换num
b.将数字转换为字符串
将数字转换为字符串,可以使用str()函数,str()函数可以将很多类型的数据都转换为字符串
3.格式化字符串
字符串的format()方法,不仅可以实现字符串的拼接,还可以格式化字符串,例如在计算的金额需要保留小数点后四位、数字需要右对齐等时,可以使用该方法
a.使用占位符
要想将表达式的计算结果插入字符串中,则需要用到占位符。对于占位符,使用一对大括号({})表示
i=32
s='i * i = '+str(i*i) # 方法1
print(s)
s='i * i = {}'.format(i *i) # 方法2
print(s)
s='{0} * {1} = {2}'.format(i,i,i*i) # 方法3
print(s)
s='{p1} * {p1} = {p3}'.format(p1=i,p3=i*i) # 方法4
print(s)
b.格式化控制符
在占位符中还可以有格式化控制符,对字符串的格式进行更加精准的控制。
字符串的格式化控制符及其说明如下表所示。
格式化控制符位于占位符索引或占位符名字的后面,之间用冒号分隔,语法:{参数序号:格式控制符}或{参数名:格式控制符}。
money = 5834.5678
name = 'Tony'
s='{0:s}今年{1:d}岁,工资是{2:f}元'.format(name,20,money)
print(s)
s='{0}年龄{1},工资是{2:0.2f}元'.format(name,20,money)
print(s)
s='{0}今天收入是{1:G}元'.format(name,money)
print(s)
s='{0}今天收入是{1:e}元'.format(name,money)
print(s)
s='十进制数{0:d}的八进制表示为{0:o}'.format(18)
print(s)
s='十进制数{0:d}的十六进制表示为{0:x}'.format(18)
print(s)
4.操作字符串
a.字符串查找
字符串的find()方法用于查找子字符串。该方法的语法为str.find(sub[,start[,end]]),表示:在索引start到end之间查找子字符串sub,如果找到,则返回最左端位置的索引;如果没有找到,则返回-1。
s='hello world'
print(s.find('e')) # 在s里找第一个e的下标
print(s.find('l',4)) # 在s里从4号元素开始往后找第一个l
print(s.find('l',4,8)) # 在s的4到8号元素中找第一个l
b.字符串替换
若想进行字符串替换,则可以使用replace()方法替换匹配的子字符串,返回值是替换之后的字符串。
该方法的语法为str.replace(old,new[,count]),表示:用new子字符串替换old子字符串。
count参数指定了替换old子字符串的个数,如果count被省略,则替换所有old子字符串
s= 'ab cd ef gh ij'
print(s.replace(' ','|',2)) # ab|cd|ef gh ij
print(s.replace(' ','|',1)) # ab|cd ef gh ij
print(s.replace(' ','|')) # ab|cd|ef|gh|ij
c.字符串分割
若想进行字符串分割,则可以使用split()方法,按照子字符串来分割字符串,返回字符串列表对象。该方法的语法为str.split(sep=None,maxsplit=-1),表示:使用sep子字符串分割字符串str。maxsplit是最大分割次数,如果maxsplit被省略,则表示不限制分割次数。默认为所有的空字符,包括空格、换行符、制表符等等
text = 'ab cd ef gh ij'
a=text.split(' ') # ['ab', 'cd', 'ef', 'gh', 'ij']
print(a)
a=text.split(' ',maxsplit=0) # ['ab cd ef gh ij']
print(a)
a=text.split(' ',maxsplit=1) # ['ab', 'cd ef gh ij']
print(a)
a=text.split(' ',maxsplit=2) # ['ab', 'cd', 'ef gh ij']
print(a)
5.统计英文文章中单词出现的频率
wordstring = '''
it was the best of times id was the worst of times.
it was the age of wisdom it was the age of foolishness.
'''
# 先替换标点符号
wordstring = wordstring.replace('.','')
# 分割单词
a=wordstring.split() # 默认为所有的空字符,包括空格、换行符、制表符等等
wordfreq=[]
for w in a:
# 统计单词出现个数
wordfreq.append(a.count(w)) # count()方法可以返回列表a中w元素的个数
d= dict(zip(a,wordfreq)) # # zip()函数将两个可迭代对象打包成元组,第一个参数是字典的键,第二个参数是字典值,个数相同,一一对应
print(d)
#{'it': 3, 'was': 4, 'the': 4, 'best': 1, 'of': 4, 'times': 2, 'id': 1, 'worst': 1, 'age': 2, 'wisdom': 1, 'foolishness': 1}
九.函数
程序中需要反复执行的某些代码可以封装在函数里
函数有函数名、参数和返回值。Python中的函数很灵活:可以在模块中但是类之外定义,作用于是当前模块,我们称之为函数;也可以在别的函数中定义,我们称之为嵌套函数;还可以在类中定义,我们称之为方法。
1.定义函数
自定义函数的语法格式如下:
以英文半角冒号结尾
def 函数名(形式参数列表):
函数体
return 返回值
什么是形式参数?
由于定义函数时的参数不是实际数据,会在 调用函数时传递给它们实际数据,所以我们称定义函数时的参数为形式参数;称调用函数时传递的实际数据为实际参数。
def rect_area(width,height):
area=width*height
return area
def print_area(width,height):
area=width*height
print("{0} x {1} 长方形的面积:{2}".format(width,height,area))
2.调用函数
a.使用位置参数调用函数
在调用函数时传递的实参与定义函数时的形参顺序一致,这是调用函数的基本形式。
def rect_area(width,height):
area=width*height
return area
r_area=rect_area(320,480)
print("{0} x {1} 长方形的面积:{2:.2f}".format(320,480,r_area))
b.使用关键字参数调用函数
在调用函数时可以采用“关键字=实参”的形式,其中,关键字的名称就是定义函数时形参的名称。
def rect_area(width,height):
area=width*height
return area
r_area = rect_area(width=320, height=480)
print("{0} x {1} 长方形的面积:{2:.2f}".format(320,480,r_area))
r_area = rect_area(height=480, width=320) # 实参不再受形参的顺序限制
print("{0} x {1} 长方形的面积:{2:.2f}".format(320,480,r_area))
使用关键字参数调用函数时,调用者能清晰地看出所传递参数的含义,提高函数调用的可读性
3.参数的默认值
C语言有函数重载,即可以定义多个同名函数,但是参数列表不同,这样在调用时可以传递不同的实参,使用起来非常方便。在Python中是否也有函数重载的概念?
没有,函数重载会增加代码量,所以在Python中没有函数重载的概念,而是为函数的参数提供默认值实现的。
def make_coffee(name='卡布奇诺'):
return "制作一杯{0}咖啡".format(name)
coffee1=make_coffee("拿铁")
coffee2=make_coffee()
print(coffee1) # 制作一杯拿铁咖啡
print(coffee2) # 制作一杯卡布奇诺咖啡
4. 可变参数
我发现一个很奇怪的问题:在使用格式化字符串的format()方法时,有时可以传递1个参数,有时可以传递3个参数,这是怎么回事?
print("320 x 480 长方形的面积:{0:.2f}".format(r_area))
print("{0} x {1} 长方形的面积:{2:.2f}".format(320,480,r_area))
Python中的函数可以定义接收不确定数量的参数,这种参数被称为可变参数,可变参数有两种,即在参数前加*或**
a.基于元组的可变参数(*可变参数)
*可变参数在函数中被组装成一个元组
def sum(*numbers):
total=0.0
for number in numbers:
totals += number
return total
print(sum(100.0,20.0,30.0)) # 输出150.0
print(sum(30.0,80.0)) # 输出110.0
b.基于字典的可变参数(**可变参数)
**可变参数在函数中被组装成一个字典
def show_info(**info)
print('----show_info------')
for key,value in info.items():
print('{0} - {1}'.format(key, value))
show_info(name='Tony',age=18,sex=True)
# 多个参数被组装成字典info,字典的健是name\age\sex,字典的值是‘Tony'、18、True
show_info(student_name='Tony',student_no='1000')
# 多个参数备组装成字典info,字典的健是student_name,student_no,字典的值是'Tony''1000'
5.函数中变量的作用域
变量可以在模块中创建,作用域(变量的有效范围)是整个模块,被称为全局变量。变量也可以在函数中创建,在默认情况下作用域是整个函数,被称为局部变量。
x=20 # 在模块中定义变量X,作用域是整个模块
def print_value():
x=10 # 在模块中定义变量x,作用域是整个函数,它会屏蔽模块变量x
print("函数中x = {0}".format(x))
print_value()
print("全局变量x = {0}".format(x))
对于模块和函数中各定义的一个同名变量,如果在函数中将其声明为global ,则会将函数中的这个同名变量提升为全局变量,就会与原本的全局变量产生命名冲突。把原来的数值抵消掉
x=20
def print_value():
global x # 将x变量提升为全局变量
x = 10
print("函数中x = {0}".format(x))
print_value()
print("全局变量x = {0}".format(x)) # x=10
6.函数类型
Python中的任意一个函数都有数据类型,这种数据类型是function,被称为函数类型。
a.理解函数类型
函数类型的数据与其他类型的数据是一样的,任意类型的数据都可以作为函数返回值使用,还可以作为函数参数使用。因此,一个函数可以作为另一个函数返回值使用,也可以作为另一个函数参数使用。
# 定义加法函数
def add(a,b):
return a + b
# 定义减法函数
def sub(a,b):
return a - b
# 定义计算函数
def calc(opr):
if opr == '+':
return add
else:
return sub
f1=calc('+') # f1实际上是add()函数
f2=calc('-') # f1实际上是sub()函数
print("10 + 5 = {0}".format(f1(10, 5)))
print("10 - 5 = {0}".format(f2(10, 5)))
函数类型的差别:主要是函数参数列表,有两个参数的函数和有一个参数的函数是不同的函数类型
b.过滤函数filter()
在Python中定义了一些用于数据处理的函数,如filter()和map()等。我们先介绍filter()函数。
filter()函数用于对容器中的元素进行过滤处理。
filter()函数的语法如下:filter(function,iterable)
参数function是一个提供过滤条件的函数,返回布尔值。
参数iterable是容器类型的数据。
在调用filter()函数时,iterable会被遍历,它的元素会被逐一传入function()函数中,function()函数若返回True,则元素会被保留;若返回False,则元素被过滤。最后遍历完成,已保留的元素被放到一个新的容器数据中
# 提供过滤条件函数
def f1(x):
return x > 50 # 找出大于50元素
data1 = [66,15,91,28,98,50,7,80,99]
filtered = filter(f1,data1)
data2 = list(filtered) # 转换为列表
print(data2)
filter()函数的返回值并不是一个列表,如果需要返回列表类型的数据,则还需要通过list()函数进行转换
c.映射函数map()
map()函数用于对容器中的元素进行映射(或变换)。例如:我想将列表中的所有元素都乘以2,返回新的列表。
map(function,iterable)
参数function是一个提供变换规则的函数,返回变换之后的元素。
参数iterable是容器类型的数据。
def f1(x):
return x *2 # 变换规则乘以2
data1=[66,15,91,28,98,50,7,80,99]
mapped = map(f1,data1)
data2 = list(mapped) # 转换为列表
print(data2)
7.lambda()函数
我们之前学习的函数都是有名称的函数,例如rect_area()函数,rect_area就是其函数名。我们也可以定义匿名函数,匿名函数就是没有名称的函数。
在Python中使用lambda关键字定义匿名函数。lambda关键字定义的函数也被称为lambda()函数,定义lambda()函数的语法如下。
lambda 参数列表:lambda体
注意:lambda体部分不能是一个代码块,不能包含多条语句,只有一条语句,语句会计算一个结果并返回给lambda()函数,但与有名称的函数不同的是,不需要使用return语句返回
lambda()函数与有名称的函数一样,都是函数类型,所以上面的add()和sub()函数可以被lambda()函数替代。修改上面的代码示例如下:
# 定义计算函数
def calc(opr):
if opr == '+':
return lambda a,b:(a+b) # 替代add()函数
else:
return lambda a,b:(a-b) # 替代sub()函数
f1=calc('+') # f1实际上是add()函数
f2=calc('-') # f1实际上是sub()函数
print("10 + 5 = {0}".format(f1(10, 5)))
print("10 - 5 = {0}".format(f2(10, 5)))
lambda()函数可以减少代码量
data1 = [66,15,91,28,50,98,7,80,99]
filtered = filter(lambda x:(x > 50),data1)
data2 = list(filtered)
print(data2)
mapped = map(lambda x:(x*2),data1)
data3 = list(mapped)
print(data3)
十、异常处理
为增强程序的健壮性,我们也需要考虑异常处理方面的内容。例如,在读取文件时需要考虑文件不存在、文件格式不正确等异常情况。这就是本章要介绍的异常处理。
1.除零异常
在数学中,任何整数都不能除以0,如果在计算机程序中将整数除以0,则会引发异常。
2.捕获异常
我们不能防止用户输入0,但在出现异常后我们能捕获并处理异常,不至于让程序发生终止并退出。亡羊补牢,为时未晚。
a. try-except语句
异常捕获是通过try-except语句实现的,基本的try-except语句的语法如下。
在try代码块中包含在执行过程中可能引发异常的语句,如果没有发生异常,则跳到except代码块执行,这就是异常捕获。
i = input('请输入数字:')
n = 8888
try:
result = n / int(i)
print(result)
print('{0}除以{1}等于{2}'.format(n,i,result))
except:
print("不能除以0")
指定异常
i = input('请输入数字:')
n = 8888
try:
result = n / int(i)
print(result)
print('{0}除以{1}等于{2}'.format(n,i,result))
except ZeroDivisionError as e:
print("不能除以0,异常:{}".format(e))
b.多个except代码块
多条语句可能会引发多种不同的异常,对每一种异常都会采用不同的处理方式。
c.多重异常捕获
如果同时出现多个异常
i = input('请输入数字:')
n = 8888
try:
result = n / int(i)
print(result)
print('{0}除以{1}等于{2}'.format(n,i,result))
except (ZeroDivisionError, ValueError) as e:
print("异常发生:{}".format(e))
d. try-except语句嵌套
i = input('请输入数字:')
n = 8888
try:
i2 = int(i)
try:
result = n/i2
print('{0}除以{1}等于{2}'.format(n,i2,result))
except ZeroDivisionError as e1:
print('不能除0')
except ValueError as e2:
print('输入的是无效数字,异常')
3.使用finally代码块释放资源
有时在try-except语句中会占用一些资源,例如打开的文件、网络连接、打开的数据库及数据结果集等都会占用计算机资源,需要程序员释放这些资源。为了确保这些资源能够被释放,可以使用finally代码块。
在try-except语句后面还可以跟一个finally代码块,语法如下。
无论是try代码块正常结束还是except代码块异常结束,都会执行finally代码块。
4. 自定义异常类
5.动动手——手动引发异常
class ZhijieketangException(Exception):
def __init__(self,message):
super().__init__(message)
i = input('请输入数字:')
n = 8888
try:
result = n / int(i)
print(result)
print('{0}除以{1}等于{2}'.format(n,i,result))
except ZeroDivisionError as e:
raise ZhijieketangException('不能除以0')
except ValueError as e:
raise ZhijieketangException('输入的是无效数字')