新人上路之python入门学习
- 标识符和变量
- 输入/输出函数
- 数字类型
- 字符串类型
- 关系运算
- 逻辑运算(与、或、非、异或)
- 运算符的优先级和结合性
- 内置函数
- 语句
- 格式化输出format函数
- 容器
- 字符串切片输出
- 列表
- 注意:python中,列表变量是列表的管理者,而不是变量本身是一个列表
- 字符串能和列表之间的操作
- 序列容器之元组(我们已经学了另外两大序列容器:字符串和列表)
- python的随机模块
- 条件语句(if,else,elif)
- while循环语句
- for循环语句(比其他语言多了一种用法else)
- 异常
- 集合{}(集合是一种容器)
- 集合的操作
- 字典(dict) key:value 用key来访问value,而不能用位置访问(因为字典也是无序):d[key]
- 函数
- 再学python内置函数
- sorted()函数:对字符串,列表,元组,字典等对象进行排序
- map()函数:会根据提供的函数对指定序列做映射。
- zip()函数:用于将可迭代的对象作为参数,将对象中对应的元素打包成一个元组,然后返回由这些元组组成的列表或者迭代器。
- eval()函数:用来执行一个字符串表达式,并返回表达式的值
- exec()函数:执行储存在字符串或文件中的Python语句,相比于 eval,exec可以执行更复杂的 Python 代码。
- all()函数:将可迭代对象作为参数,当参数全为True,才返回True;否则返回False。
- any()函数:将可迭代对象作为参数,当有一个参数为True时,返回True;全为False时,才返回False。
- 程序结构
- 模块名字空间
- 包:把多个模块文件组织成目录,即为包
- 文件
- 类和对象的概念
- 面向对象编程的三大特性:封装、继承、多态
标识符和变量
标识符
标识符是指用来标某个实体的一个符号,在不同的应用环境下有不用的含义。
标识符由字母、下划线和数字组成,而且不能够以数字开头。
标识符区分大小写,adc和Abc是不同的标识符。
标识符不能用关键字,如:class,int。
变量
变量可以值改变,类型也可以改变。
python中,对变量是不需要声明的。(这是与java,c等其他语言不同的地方)。python是动态语言,而c,java是静态语言。
在python中,可以对一个变量反复赋值,并且类型也可以不一样。
可以使用type函数查看变量类型:如type(a),就可以查看变量a的类型。
在python中,变量名也是大小写敏感的,即A和a是两个不同的变量。
同样,不要使用python的一些函数作为变量,比如:sum求和函数。
sum([1,2,3])可以求和得到5.
同样,sum不是关键字,因此sum符合变量的命名规则,所以理论上sum也可以作为变量被赋值,如sum=5.
但是,此时sum仅仅是一个整型变量,无法调用sum函数进行求和。
如何恢复sum函数的功能呢?
del(sum)即可。
python的变量,仅仅将名字与对象进行关联,让变量指向对象,而不是真正的赋值。
id函数:是内置函数,用来显示对象的地址,如:id(a)。
输入/输出函数
输入函数 input()
input():是内建函数,实现从键盘中读入一个字符串,如:
st = input()
注意: input()读入的数据均是字符串格式。倘若想得到其他的数据类型,需要输入之后进行强制类型转换,比如:
想读入一个整型123
st = int(input())
123
此时的st即为int类型。
倘若想在一行中输入多个值,则需要用split()函数,比如:
a, b = input().split()
123 987
可以得到a=‘123’,b=‘987’.
倘若想给出一个“请输入”的提示语,则可以:
n = input(“请输入一个字符串:”)
按下回车,此时会显示:
请输入一个字符串:
然后输入一个字符串赋值即可。
输出函数print()
print()函数:默认输出换行符。若不想换行,可以输出:
print(i,end = ‘’)
数字类型
整数
浮点数
取值和精度有限制
表示方式有两种:
1.小数: 1.23, -7.8
2.科学计数法:1.23 X 10^9 可以写为:1.23e9
0.000012 可以写为:1.2e-5
由于精度问题,十进制的0.1,用二进制表示,只能用无限接近0.1的小数来表示,因此,进行浮点数计算,会有一定的极小的尾数的精度误差。
比如:0.1+0.2,十进制是等于0.3的。
但是,在python中,做 0.1+0.2 == 0.3的判断,结果是Flase。这就是精度带来的影响。
如何消除这种精度误差的影响?
使用round()函数。
round(0.1+0.2,2)其中的2表示保留2位小数
复数(complex)
由实部和虚部组成,如:2+3j
使用real方法取实部,imag方法取虚部
complex()函数可用于创建一个值为real+imag*j的复数,比如:
a = complex(1,2)
算术运算符
/是浮点数除法,
//是整数除法。 此处的取整,是数轴上的向左取整。比如:
3//2 = 1, -3//2 = -2
注意,python可以实现浮点数的模运算。
数学库(math)函数
字符串类型
python中,不提供单字符类型(c中的char),全部以字符串(str)类型表示。
字符串:以引号括起来的任意文本。
字符串是一个有序序列。
字符串表示形式有:
1.单引号: ‘abc’
2.双引号: “abc”
3.三引号: ‘’’ hello
world’’’
三引号用来表示多行文本。
倘若字符串本身包含了单引号,那么该字符串可以用双引号括起来。
同理,若字符串本分包含了双引号,亦可以单引号括起来。
若该字符串中既有单引号,又有双引号,则用三引号括起来。
字符串运算符
注意,在字符串运算符这里,+只能连接两个字符串,而不能做字符串和整型的数相加。
字符串切片
字符串是一个顺序序列,可以是正向递增,也可以是反向递减:
索引:在[]中给出序号
切片:在[]中给出切片序号范围
关系运算
关系运算符
注意,字符串不能和数字进行比较。
逻辑运算(与、或、非、异或)
注意,python中执行短路运算,如:
输入:
3>5 and a>5
输出:
Flase
这是因为对于与运算,只要有一个为假,则为假。因此,判断3>5为假之后,计算机不会再判断a>5,而是直接输出结果 F;
而输入:
a>5 and 3>5
输出:
Traceback (most recent call last):
File “<pyshell#17>”, line 1, in
a>5 and 3>5
NameError: name ‘a’ is not defined
因为a没有定义,所以出错。
同理,对于或运算,倘若第一个为真,计算机不会再判断第二个式子的真假,直接输出结果True;
对于 非 :
输入:
not 0
输出:
True
输入:
not 3
输出:
False
即在逻辑运算中,所有的非零值均看做真的逻辑量;
运算符的优先级和结合性
内置函数
python中封装了大量的内置函数,如:
运算类 内置函数
min,max
判断类 内置函数
操作类 内置函数
map()函数:map(function,iterable):就是对iteratable执行function函数
比如:
我们知道,
单个输入(字符串)是:x = input()
单个输入一个整数是:x = int(input())
多个输入(字符串)是:x,y = input().split()
得到x,y是两个字符串,倘若想同时输入两个int型,则需要再分别对x和y进行类型转换:x = int(x),y = int(y)
如果我们想多个输入整数:
可以调用map函数:
x,y = map(int,input().split())
内置转换函数
bool,int,float,complex,str可以看做类型转换函数
ord,chr,bin,oct,hex可以看做编码类转换函数
list就是列表转换函数,如:
输入:list(‘abcd’)
则字符串’abcd’转换为列表类型:[‘a’,‘b’,‘c’,‘d’]
对于int,
输入int(),得到结果0
输入int(“02”),得到结果0
输入int( " 35 "),得到结果35
输入int(“35”,8),得到结果29(8表示是八进制)
语句
赋值语句
python中,可以单赋值,如:a = 1
也可以序列赋值(左侧变量个数和值的个数相等),如:
x,y = 4,8,得到x=4,y=8
a,b = “34”,得到a=“3”,b= “4”
注意,交换a和b的值,不需要引入第三个变量,可以直接输入:
a,b = b,a 即可完成a和b的数值交换。
倘若等号两边个数不等,如:变量个数少于赋值的个数:
输入:
i,j =[1,2,3] 会报错
而输入:
i, *j =[1,2,3]
则,i =1,j=[2,3]
还可以多变量赋值,如:
a=b=c=5
if 语句
格式: if 逻辑表达式 :
语句块1
else :
语句块2
要注意首行缩进,python中的逻辑关系是通过缩进来实现的。没有缩进,会报错。
额外补充:对于输出y时,输出结果保留2位小数,可以这么实现:
print("{:.2f}".format(y))
for 语句
格式:
for 变量 in 列表:
语句块
例如: for i in [1,2,3,4]:
print(i)
range 函数
range(start,stop,step)
其中,start:计数从start开始,默认是0开始,例如:
range(5)等价于range(0,5)
stop:计数到stop结束,但不包括stop,例如:
list(range(0,5)) 是[0,1,2,3,4],没有5
step:步长,默认是1,例如:
range(0,5)等价于range(0,5,1)
步长是正数,则得到一个递增序列,步长为负数,则可以得到一个递减序列,比如:
输入:
list(range(10,0,-1))
输出为:
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
推导式(解析式)
是python独有特性。
推导式,可以从一个序列构建另外一个序列。
推到式包括:列表推导式,字典推导式和集合推导式。
列表推导式
列表:是python中最常用的数据类型之一:
由零个或者多个元素组成,元素之间用逗号分隔开,这个列表用一个方括号所包裹。
元素类型可以相同,也可以不同、(这与其他语言中的数组不同)
通过序号可以引用列表中的元素。
支持加法、乘法、比较、索引、切片等操作,如:
加法: [1,2,3]+[‘c’,‘java’,‘python’]
输出:[1,2,3,‘c’,‘java’,‘python’]
乘法:[1] * 10
输出:[1,1,1,1,1,1,1,1,1,1]
比较:[1,2,3]<[2,3,4]
输出:True
这里的比较,仅比较两个列表中的第一个元素
比如:[2,5,6]<[1,3,4]
输出:False
比如:[1,5,6]<[2,3,4]
输出:True
索引:w = [1,5,6]
输入:w[0]
输出:1
输入:w[1]
输出:5
列表推导式:又称列表解析式,提供了一种简明扼要的方法来创建列表。
它可以将循环和条件判断相结合,从而避免语法冗长的代码,提高程序性能。
基本格式:
[expression for item in iterable]
例如:
普通的列表推导式:
n1 = [2 * number for number in [1,2,3,4,5]]
输出n1可以得到:[2,4,6,8,10]
带条件的列表推导式:
n1 = [ number for number in range(1,8) if number % 2 == 1]
输出n1可以得到:[1,3,5,7]
比如:求和1+1/2+1/3…+1/20
sum([1/i for i in range(1,21)])即可
比如:求和1-1/2+1/3-1/4…-1/10
sum([1/i if i % 2 ==1 else (-1)/i for i in range(1,11)])
比如: 求和6+66+。。。66666
sum([int(‘6’*i) for i in range(1,6)])
格式化输出format函数
之前提到过的,想要输出的结果result保留2位小数,则可以:
print("{:.2f}".format(y))
其基本格式为:str.format()
若想同时格式化输出多个结果,,则可以:
print("{0:.2f} {1:5f}".format(x,y))
其中0和1表示format函数中的第一个和第二个人参数
.2f和.5f分别表示表示保留2位小数和保留5位小数,四舍五入
容器
容器包括序列容器和无序列容器
序列类型容器
包括:字符串和列表。
字符串,如:‘abcef’
列表,如:[1,2,3,4,5]或者[‘a’,‘b’,‘c’,‘d’,‘e’,‘f’]
t=[1,2,3]
则通过索引可以取值,如:
输入:t[0]
输出:1
因此,t[]中能输入的是t列表中元素个数减一(因为是从0开始)
比如:
输入:t[3]
则会越界报错
若在t[]中输入负数,则是指葱油往左数,注意,从右往左的第一个元素的序号是-1而不是-0.
比如:
输入:t[-1]
输出:3
即容器中的每个元素都有两个编号,从左向右是正的,从0开始;
从右向左是负的,从-1开始。
我们还可以这样对列表中的值进行修改,比如:
输入:t[0] =5
此时的t列表变成了[5,2,3]
但是,不能通过这种方式对字符串进行赋值或者修改,比如:
n=‘abcd’
输入:n[0] = ‘f’
输出:会报错:TypeError: ‘str’ object does not support item assignment
字符串切片输出
如:
这里的切片,如[10:16],是指第十个到第十五个。
可以这么理解:
切片[a:b],就是在a和b前面各且一刀,取出中间的部分,刚好是a到b-1这一段;
month = [‘26c’,‘8c’,‘560d’,‘qwer123456swxw’];
前三个如何只输出前三个?(不用循环)
month[0:3]即可
对于26c,8c,560d三个长度不同的字符串,如何使其只输出前几位的数字,而不输出最后一位的字母?
‘26c’[0:-1]
‘8c’[0:-1]
‘560d’[0:-1]
因为负数表示从右开始数,因此-1代表右边第一位,所以[0:-1]代表从第一位到最后一位的前一位的切片;
对于从0位(第一位)开始的切片,还可以省略0,如[0:123]可以简写为[:123];
同理,对于从中间某一位开始,一直取到最后的切片,可以把:后面的数字省略,比如:
‘helloWorld’,想取出World,按照常规,应该是’helloWorld’[5:10],注意,这个字符串其实是0-9,并没有’helloWorld’[10]这个元素,因此’helloWorld’[5:10]并不是很规范和安全。
正确的切片方法是:‘helloWorld’[5:]
序列的函数
1.len()函数:求长度。
对于列表来说,他的长度就是其中包含元素的个数。
比如:t = [12,34,5]
输入:len(t)
输出:3
2.min()和max()函数:用来求列表中的最小(大)的那个元素。
比如:
输入:min(t)
输出:5
字符串和数字之间的转换
.数字转换成字符串函数: str()函数(str()是一个全局函数,不是字符串自己独有的函数)
比如:
输入:str(123)
输出:‘123’
对于指定格式的数字到字符串的转化:
首先 %:
比如: 整数,用%d
输入 :‘I am %d years old’ % 18
输出 :‘I am 18 years old’
还可以控制要替换的数值占多大的距离:
比如:‘I am %10d years old’ % 18
输入:‘I am 18 years old’
对于有多个要替换的:% (x,y)
比如:
输入:‘I am %d years old and weight %d kg’ % (18,50)
输出:‘I am 18 years old and weight 50 kg’
对于有小数点精度要求的,可以用:%f
比如:
输入:‘it is %.1f ℃’ % 30
输出:‘it is 30.0 ℃’
综上,%就是字符串格式化的运算符。
字符串中有单引号或双引号时的处理和转义字符的使用
1.最简单的处理方法,若字符串中有单引号,则用双引号把字符串包裹起来;若字符串中有双引号,则用单引号把字符串包裹起来。
比如:对于字符串:I’m a good guy.
可以:“I’m a good guy.”
2.也可以使用转义字符(反斜杠\)
比如:‘I’m a good guy.’
输出:‘I’m a good guy.’
倘若一行装不下字符串的时候,可以使用三引号,还可以使用\,比如:
输入:’ this
is
a
test
’
输出:‘thisisatest’
这里的反斜杠的作用就是告诉电脑,到this这里字符串没有结束,下一行的is要紧紧和this相连在一起。
另外一个方法,如何保证字符串中的\n不被误认为是换行呢?
比如:
输入:s=r’this\nis\na\test’
输出s:‘this\nis\na\test’
而print(s),则会输出:this\nis\na\test
这里的r表示字符串那种的反斜杠,就是原始的字符\的意思,而不是转义字符。
字符串自己独有的函数
对于字符串自己的函数,调用是需要用 .来调用。
比如:
lower()函数:大写转化成小写
比如:s = ‘John Smith’
输入:s1 = s.lower
s1
输出:‘john smith’
注意,字符串自己本身的函数不会对自己本身做修改,而是产生以个新的字符串(这里是s1)这里的s.lower操作执行后,s仍然是’John Smith’,而不会变成’john smith’,这里要特别注意。
find()函数:在字符串找到子字符串并返回其位置位置
比如:
输入:s.find(‘hn’)
输出:2
这里的2就是h的位置
输入:s.find(‘ed’)
输出:-1
-1表示没有找到
像我们之前用的判断, ‘hn’ in s
输出:True,但是并不能告诉我们该子字符串的位置。
注意,倘若要查找的子字符串在字符串中出现多次,find函数仅返回第一个子字符串出现的位置。
比如:
输入:‘hello world’.find(‘l’)
输出:2
find()函数值还有第二和第三个参数,第二个参数告诉我们从哪里开始找子串,第三个参数告诉我们查找到哪里结束。
比如:
输入:‘hello world’.find(‘l’,4)
输出:9 因为我们从第4号位置开始找,因此找到了world中的l的位置9.
输入:‘hello world’.find(‘l’,4,8)
输出:-1,因为我们要求从第4号位置o处开始查找,到第8号位置r处结束查找,这一段没有l,因此返回-1表示没有查找到。
count()函数:用来查看要查找的子串在该字符串中出现的次数
比如:
输入:‘hello world’.count(‘l’)
输出:3
strip()函数以及他的引申函数rstrip()和lstrip()函数:用来去掉字符串中的空格,其中strip()去掉字符串两端的空格,rstrip去掉右端的空格,lstrip用来去掉左端的空格
比如:s = ’ hello world ’
输入:s.strip()
输出为:‘hello world’
输入:s.rstrip()
输出:’ hello world’
输入:s.lstrip()
输出:'hello world ’
replace()函数:替换一段为其他的内容
replace(‘a’,‘b’):其中a为被替换的内容,b为要替换的内容
比如:
输入:s.replace(’ ‘,’-’)
输出:’-hello-world-’
再次注意,对字符串调用了无数次的字符串自身的函数,字符串本身不会改变。!!!!!!!!!!!!!!!!!!!
列表
list()函数:可以将字符串转换为列表
比如:
输入:t = list(‘this is’)
输出t,得到:[‘t’,‘h’,‘i’,‘s’,’ ',‘i’,‘s’]
列表中的元素还可以是列表,比如:t =[[1,2,3],[4,5,6],[7,8,9]]
输入:len(t)
输出:3
输入:t[0]
输出:[1,2,3]
输入:t[0][0]
输出:1
因此,可以看做是一个3X3矩阵。
注意:python中,列表变量是列表的管理者,而不是变量本身是一个列表
比如:
a1 =[1,2,3]
a2 = a1
则,此时,a1和a2输出均为:[1,2,3]
但是,此时:
输入:a2 [0] = 4
此时, a2 变成了[4,2,3]这是毫无疑问的,
但是,输出a1,会发现:
输入:a1
输出:[4,2,3]
a1也变了,这是很关键的一点。因为a2 = a1仅仅表示a2也成为了a1所管理的那个列表的管理者。
那么,如何获得a2,使得a2的列表内容和a1相同,但不是管理同一个列表呢?
方法就是:使用列表切片:
a2 = a1[:]即可
而:
n1 = 2
n2 = n1
n2 =3
输出n1和n2会发现,n1仍是2,n2变成了3.
del()函数:可以删除列表中的某个元素
比如:a = [1,2,3,4,5]
输入:del(a[2])
输出a得到:[1,2,4,5]
列表自己的函数,即用.函数来调用
append()函数:在列表后面添加一个元素
比如:a = [1,2,3,4]
输入:a.append(5)
输出a得到:[1,2,3,4,5]
注意,a.append([5,6,7])
会得到:[1,2,3,4,[5,6,7]]
这和extend()函数不一样
extend函数:把extend中的列表的值添加到要添加的列表的后面,注意是值,而不是把列表添加到该列表后面
比如:a= [1,2,3,4]
输入:a.extend([7,8,9])
输出a可以得到:[1,2,3,4,7,8,9]
insert()函数:把一个元素插入到列表的某个位置
形式:insert(address,content)
比如:a= [1,2,3,4]
输入:a.insert(2,10)
输出a可以得到:[1,2,10,3,4],即把10插入到第2号位置。
注意:insert可以插入一个列表,比如:
输入:a.insert(1,[5,6,7])
输出a可以得到:[1,[5,6,7],2,3,4]
remove()函数:删除某个位置的元素
pop()函数:删除某个位置的值,默认是删除最后的值
比如:a=[1,2,3,4]
输入:a.pop()
此时输出a得到:[1,2,3]
还可以删除指定位置:
输入:a.pop(1)
此时输出a得到:[1,3,4]
pop()可以删除某个位置的元素值,并且返回该删除的值,比如:
输入:print(a.pop(1))
输出:2
2就是被删除的元素值。
reverse()函数:把列表中的元素顺序倒过来
如: a =[1,2,3,4]
输入:a.reverse()
此时输出a得到:[4,3,2,1]
index()函数:可以用来查找某个元素是不是在列表中
比如:a = [1,2,3,[5,6,7]]
输入:print(a.index([5,6,7]))
输出:3
字符串能和列表之间的操作
split()函数:把字符串分隔开,形成一个列表(字符串——>列表)
比如:a = ‘this is a test’
输入:a.split()
输出:[‘this’,‘is’,‘a’,‘test’]
再比如:b = ‘12:35’
输入:b.split(’:’)
输出:[‘12’,‘35’]
注意:
c = ‘12::35’
输入:c.split(’:’)
输出:[‘12’,’’,‘35’]
为什么呢?
因为split做操作: 12 ::35
先查到第一个:,然后把:删掉,12分割出去得到’12’;然后查到第二个:,然后把:删掉,把?分割出去得到’’;再把最后的35分割成’35’,形成了列表[‘12’,’’,‘35’]
怎么把列表中的字符连接成字符串呢?
用 join()函数
join()函数:把列表中的字符连接成一个字符串(列表——>字符串)
比如:a = ‘this is a test’
t = a.split()
因此,t 就是[‘this’,‘is’,‘a’,‘test’]
输入:’ '.join(t)
输出:‘this is a test’
也就是说,用 (即空格)来把列表t连接起来。
序列容器之元组(我们已经学了另外两大序列容器:字符串和列表)
元组和列表很相似,只有两点不同:
1.元组用()来表示字面量,而列表用[]表示
2.元组是一种不可修改的数据。
比如:a = [1,2,3]
b = (1,2,3)
但是,输入:a[0]=4是ok的,可以执行的。
但是,输入:b[0]=4,
会报错:TypeError: ‘tuple’ object does not support item assignment
这一点和字符串一样,字符串也不支持修改。
元组也可以使用 对列表进行的一些操作,比如:len,min,max等函数。
但是,有一些函数是元组不能操作的。
会对元组本身造成修改的函数,元组是无法使用的,包括:append(),extend(),insert(),pop(),reverse(),join()等函数。
使用元组的一些场景
既然元组不如列表那么方便操作,为什么要使用元组?
比如:我们有一组数据,可以交给另一方查阅观看,但不想让他们修改,就可以以元组的形式传输这份数据给对方。
使用tuple()函数,可以把字符串或者列表转换成元组
比如:
a= ‘abc’
b = [1,2,3]
输入:c = tuple(a)
输出c可以得到:(‘a’,‘b’,‘c’)
输入:d = tuple(b)
输出d可以得到:(1,2,3)
倘若有用逗号分隔的量,则其天生被认为是元组:
比如:
输入:p=3,4
输出p可以得到:(3,4)
再比如:之前提到的同步赋值:
输入:a,b = 3,4
和输入:a,b = (3,4)
以及输入:(a,b) = 3,4
都是和(a,b) = (3,4)是一样的。
python的随机模块
sort()函数:可以对列表中的元素值进行排序
比如:a=[4,6,1,3,2]
输入:a.sort()
输出a得到:[1,2,3,4,6]
我们想要打乱一个有序的列表,怎么办呢?
这时,就需要引入一个随机模块(其实就是一个库),使用这个库中的一些函数可以实现打乱列表中的元素值的功能
随机模块(库):random
random中的shuffle()函数:用来打乱列表(元组是不可修改的,所以不能对元组使用)
输入:import random
然后调用random中的一个函数shuffle就可以实现打乱。
输入:random.shuffle(a)
这时,a列表中的顺序就打乱了。
choice()函数:从列表(元组,字符串也可以)中随机选一个元素值出来
输入:random.choice(a)
输出:4(此为随机)
random()函数:随机给出一个(0,1)之间的小数
输入:random.random()
输出:0.7376170866004631
randint(a,b)函数:随机生成一个[a,b)之间的整数
seed()函数:给定一个seed,之后生成的随机数是相同的。
比如:
random.seed(0)
random.randint(1,100)
50random.randint(1,100)
98
再次输入:random.seed(0)
random.randint(1,100)
50random.randint(1,100)
98
两次得到的randint是一样的。
因为randint的随机数,其实是电脑根据一定的公式计算出来的,给定固定的seed,输入相同的randint区间,永远会得到相等的随机值。
应用:这样一来,我们其实可以用来对一些软件做测试的时候,相同的随机数是非常棒的。
条件语句(if,else,elif)
格式:
if 条件:
执行代码
else :
执行代码
或者:
if 条件:
执行代码
elif 条件:
执行代码
else:
执行代码
while循环语句
和其他语言一样
for循环语句(比其他语言多了一种用法else)
在python中,for循环比其他语言多了一种用法是:
for :
else:
比如:
for i in range(2,i):
执行语句1
else:
执行语句2
什么意思呢?
就是在for循环中,正常执行语句1
倘若for循环把range(2,i)全部执行完毕,没有提前终止for循环,则执行else中的语句2;如果for循环执行时,触发某个跳出for循环的条件,没有把range(2,i)全部遍历完,则不会执行else。
异常
异常处理(try,except)
try:
测试语句1
except:
测试语句1异常(报错时),要执行的语句2
针对不同的异常进行不同的处理:
try:
语句块1
except 异常类型1:
语句块2
except 异常类型2:
语句块3
.
.
.
except 异常类型N:
语句块n+1
except:
语句块n+2
else:
语句块n+3
finally:
语句块n+4
其中,
else:是指:倘若这次运行,没有报错,则会执行else中的语句块n+3。(类似于for+else)
finally:是指:无论try中的语句块有没有异常,都要执行finally中的语句块n+4.
集合{}(集合是一种容器)
集合的两大特点:1.没有重复的元素;2.无序,所谓无序,是指程序员无法指定元素在集合中的位置。
比如:
输入: s = {1,2,3,3,4}
输出s得到:s ={1,2,3,4}
再比如:
输入:s = {1,2,5,3,6}
输出s得到:s ={1,2,3,5,6}
set()函数:将列表,字符串,元组转换成集合
比如:t = [1,3,2]
s1 = set(t)
得到s1为{1,2,3}
注意:python中,直接输入{}不会得到一个空集合{}
即使 输入:{}不会报错,但是查看{}类型,你会发现:
输入:type({})
输出:<class ‘dict’>
这是一个字典dict,字典和集合公用花括号{}。
如何输入一个空集合呢?
方法:set()就会得到一个空集合。
集合的操作
add()和remove()函数对集合进行添加删除
min,max,len,sum()对集合进行操作
由于集合中的元素是无序的,所以不能够通过想列表那样使用下标来访问集合中的元素。
可以用>、<、<=、>=、=、来判断两个集合的关系
a<b:说明a是b的真子集
a=b:说明a和b是用一个集合
a<=b:说明a是b的子集
可以用 |取并集,用&取并集, 用^先取并集,再去掉交集
可以用s1-s2来取差集:在s1中去掉在s2中存在的元素
字典(dict) key:value 用key来访问value,而不能用位置访问(因为字典也是无序):d[key]
格式:
d = {‘one’:1,‘two’:2}
其中,冒号前面的项叫做 键
冒号后面的项叫做 值
用键来访问值,比如:
输入:d[‘one’]
输出:1
字典添加一对键值对:使用直接赋值的方式:d[key] = value
如何往字典中添加键值对?
不能用add和append,而是直接赋值,比如:
d[‘three’] = 3即可
字典删除一对键值对:del()函数:del(d[key])
比如:
del(d[‘two’])就删除了字典d 中的’two’:2
字典修改一对键值对:直接修改:d[key] = value
访问value:除了直接访问:d[key],还可以用get()函数
如:d.get(‘one’)
但是注意区别:
d[key]访问字典d中没有的键值对,会直接报错,比如:d[‘ok’],会报错
而使用d,get(‘ok’),不会报错
还可这样使用get()函数:
d.get(‘ok’,0)
代表倘若d中没有’ok’这个ok,则其值value赋值为0添加到字典中。
函数
函数参数
位置参数
python中处理参数的方式比其他语言更加灵活,其中最熟悉的参数类型是位置参数,传入的参数的值是按照顺序依次赋值给形参。
比如:函数dis(x1,y1,x2,y2)
调用时:print(dis(2,3,5,6))即可。
关键字参数
调用参数时,可以指定对应形式参数的名字,他可以采用与函数定义时不同的顺序。
比如:一个函数 dis(x1,y1,x2,y2)
调用时:print(dis(x1=1,y2=4,y1=3,x2=7))是可以的。
注意,位置参数和关键字参数可以混合使用,在使用时,要先写位置参数, 然后才是关键字参数。
比如:
print(dis(1,3,y2=5,x2=9))是可以的。
但是,print(dis(1,y1=3,4,5))是错误的。X
默认值参数
在调用时,倘若调用方没有提供对应形参的值时,可以指定形参的默认值。而若提供了实参,则用实参的值。
即:有实参,用实参;没实参,用默认值。
比如:定义时:def dis(x1,y1,x2,y2 = 5)
调用时:
print(dis(1,3,8))
y2没有传实参,因此用默认值y2 = 5.
再比如:
print(dis(4,5,6,7))
y2有传实参7,则此时y2 = 7.
数量可变参数:一个星号和两个星号
当函数参数数目不确定时,星号将一组可变数量的位置参数 集合成 参数值的元组。
一个星号*:表示收集参数到元组。
两个星号**:表示收集参数到字典中。
实参拆包
*加在形参前面,表示不定长参数;而加在实参前面,表示将序列拆成一个个单独实参。
可变对象和不可变对象单参数,效果可能是不同的
当实参是不可变对象时,形参值改变不能影响实参;
当实参是可变对象时,形参值改变可能会影响实参。
change函数中的形参是不可变对象,因此,在函数体中,a=3,不会改变x的值。
而change1函数中的形参是一个列表,是可变对象。因此,在函数体中,a[0]=3,会使得l的列表元素值也改变。l[0]也从7变成了3.
函数返回值
第一种:倘若函数用return语句返回值,则return后面的表达式的值就成为本次函数调用的返回值。
第二种:倘若函数没有用return语句返回值,此时函数的返回值是None;如果return后面没有跟表达式,直接return返回,此时的返回值也是None。
注意:None是python中一个特殊的值,虽然它不表示任何数据,但仍然具有重要作用。
命名空间和作用域
1.变量可被访问的范围恒伟变量的作用域,又称作变量命名空间或者变量名字空间。Python用命名空间来区分不同空间的相同名字。
2.Python解释器启动时会建立一个全局命名空间,全局变量就放在此空间。此外,还建立内置命名空间,其中记录所有标准常量名,标准函数名等。在全局命名空间定义的变量是全局变量。
3.每个函数都有自己的命名空间,在函数内部定义的变量是局部变量。
global关键字:可以在函数内部定义一个全局变量
递归
递归的能力在于用有限的语句来定义对象的无限集合。一般来说,递归需要终止条件和递归条件。当终止条件不满足时,递归前进;当终止条件满足时,递归返回。编写递归函数时,必须告诉它何时停止递归,从而避免无限循环。
再学python内置函数
sorted()函数:对字符串,列表,元组,字典等对象进行排序
sort是仅应用在list,而sorted应用范围更广。
即便都是对列表操作,list的sort方法返回的是对已经存在的列表进行操作,而内建函数sorted返回的是一个新的list,而不是在原来的基础上进行操作。
sorted函数语法:
map()函数:会根据提供的函数对指定序列做映射。
语法:map(function,iterable)
返回值是一个新列表或者新的迭代器,其中的每个元素都是调用function函数的返回值。
zip()函数:用于将可迭代的对象作为参数,将对象中对应的元素打包成一个元组,然后返回由这些元组组成的列表或者迭代器。
eval()函数:用来执行一个字符串表达式,并返回表达式的值
exec()函数:执行储存在字符串或文件中的Python语句,相比于 eval,exec可以执行更复杂的 Python 代码。
all()函数:将可迭代对象作为参数,当参数全为True,才返回True;否则返回False。
any()函数:将可迭代对象作为参数,当有一个参数为True时,返回True;全为False时,才返回False。
程序结构
引入模块:
方法一: import 模块名
方法二:from 模块名 import * 这种方法引入模块中的所有函数,调用时不需要再加模块名。
注意两种方式的区别:
方法一,引入模块之后,调用时需要加模块名,比如:
import math
使用math库中的fabs函数求绝对值,需要:
math.fabs(-10)
而方法二:
from math import *
fabs(-10)即可。
方法三:
from 模块名 import 函数名
是从模块中仅引入了一个函数。
模块名字空间
注意,主程序的模块名是"main"
包:把多个模块文件组织成目录,即为包
包是一个目录,其中包括:一组模块文件和一个init.py文件。
如果模块存在于包中,使用"import 包名.模块名"形式可以导入包中模块,用以下形式调用函数:“包名.模块名.函数”
sys模块:倘若两个或多个py文件不在同一个目录下,需要用sys模块加入搜索路径调用。
模块的查找路径:sys.path
sys模块中的常用量:
文件
文件读写
文件处理三个步骤:1.打开文件;2.处理文件;3.关闭文件。
open()函数:打开文件,其返回值是一个文件对象。
文件打开方式
文件读写函数
多行文件读写:readlines()函数
输入输出重定向
sys.stdin 标准输入
sys.stdout 标准输出
sys.stderr 标准错误输出
而:sys.stdin.read()重定向为键盘输入
python的模块函数分为3个层次:
一、内置函数
不用import语句引入,函数可以直接调用
二、标准模块函数:如math
用jmport语句引入模块后再调用,但是不必安装。
三、第三方模块函数:如pandas
需要先安装,再用import语句把模块引入,然后才能调用模块里面的函数。
第三方库安装:打开网页:https://pypi.org/
输入模块名,即可查询模块的详细说明。
在命令行下,pip install pandas,即可安装pandas模块。
pandas模块:读写常见格式文件
是一个数据分析包,提供了大量方便我们快速便捷处理数据的函数和方法。
用pandas可以读写各种类型的文件:
比如:读写csv文件:
DataFrame数据类型
是pandas库中的一种数据类型,它是一个行和列都具有标签的表格,他与excel表格没有不同。
plotly模块:基于JS的动态绘图模块
sqlalchemy模块:用于数据文件读写
类和对象的概念
类
类:是一种对象的模型和数据类型,它定义了对象的属性(数据),并提供用于初始化对象的初始化程序和操作这些属性的方法。
定义类,和其他语言类似:使用class关键字来定义类,class之后是一个空格,然后是类名,再然后是一个冒号,最后换行并定义类的内部实现。
格式:
class Classname:
initializer #初始化
methods #定义方法
比如,定义一个Students类
class Students:
uname = '浙江大学'
def _init_(self,ino,iname): #_init_是一个特殊的方法,是构造方法,用于创建对象
self.no = ino
self.name = iname
def getInofo(self):
print('学校:',Students.uname,',学号:',self.no,',姓名:',self.name)
注意:定义类时,所有方法必须有self这个参数(可以不叫这个名字,位置必须在第一位),他代表对象本身。
对象
对象:是类的一个实例,使用构造方法来创建一个对象。使用圆点运算符(.)通过引用方法和变量啦访问对象的成员。
面向对象程序设计(oop):使用对象进行程序设计,实现代码复用和设计复用,使得软件开发更高效方便。
python是真正面向对象的编程语言,完全支持面向对象的基本功能,包括:封装、继承、多态以及对基类方法的覆盖或重写。
比如:
s1 = Students(‘20131813’,‘ykk’) 这是创建了一个Students对象s1
s = ‘浙江大学’ 这是创建了一个字符串对象s,等价于s=str(‘浙江大学’)
而传统的C语言,是面向过程程序设计。
isinstance()函数:内置函数,用来测试一个对象是不是某个类的实例
isinstance(s1,Students)
True
访问对象
访问对象的数据:
s1.name
调用对象的方法:
s1.getInfo()
面向对象编程的三大特性:封装、继承、多态
封装
封装:将数据和对数据的操作组合起来构成类,类是一个不可分割的独立单位。
类中既要提供与外部联系的接口,同时又要尽可能的隐藏类的实现细节。
Python类中成员分为变量(数据、属性)和方法(函数)。
变量(数据)又分为:
1.类变量:是在类中所有方法之外定义的。
2.实例变量:一般是指在构造方法_init_()中定义的,定义和使用时以self作为前缀。
比如:
class Car:
price = 10000 #定义类变量
def _init_(self,color):
self.color = c #定义实例变量
car1 = Car('red')
car2 = Car('yellow')
print(car1.color,Car.price) #查看实例变量和类变量的值,但是查看price这个类变量的值,可以用类.price(即Car.price),也可以用对象.price(即car1.price)来查看。
Car.price = 11000 #修改类变量的值
Car.name = 'qq' #动态增加类变量
car1.color = 'yellow' #修改实例变量
方法(函数)又分为:
1.公有方法
2.私有方法:方法名以两个下划线’_'前缀
3.类方法:@classmethod
4.静态方法:@staticmethod
实例方法:在类的方法中第一个参数如果是self,这种方法称为实例方法。实例方法对类的某个给定的实例进行操作,可以通过self显式地访问该实例。
类方法:python中允许声明属于类本身的方法,即类方法。类方法不对特定实例进行操作,在类方法中不能访问对象的实例变量。类方法通过@classmethod来定义,以一个形式参数必须是类对象本身,通常为cls。
类方法和实例方法的不同:
1、类方法是属于整个类,而不属于某个对象。
2、类方法只能访问类成员变量,不能访问实例变量,而实例方法可以访问类成员变量和实例变量。
3、类方法的调用可以通过类名.类方法和对象.类方法,而实例方法只能通过对象.实例方法访问。
4、类方法只能访问类方法,而实例方法可以访问类方法和实例方法。
5、类方法不能被覆盖,实例方法可以被覆盖。
私有成员和公有成员:
在python中,以下划线’_'开头的方法名和变量名有特殊的含义,尤其是在类的定义中:
1._xxx:受保护成员,不能用’from module import *'导入;
2.xxx:系统定义的特殊成员。
3.__xx:私有成员,只有类内自己访问,不能使用对象直接访问到这个成员。