最近相对整块时间比较多,所以决定把python的一些知识复习一下:
python的一些数字类型:
整型
浮点型
布尔类型(特殊的整型)
e记法 1.5e10(并非数字类型)
分支与循环:
需求:为了方便成绩判定,请将分数为大于等于90分小于100分判定为A, 分数大于等于80分小于90分判定为B, 分数大于等于70分小于80分判定为C, 分数大于等于60分小于10分判定为D。
score = int(input("请输入一个分数"))
if 100 >= score >= 90:
print("A")
elif 90 > score >= 80:
print("B")
elif 80 > score >= 70:
print("C")
elif 70 > score >= 60:
print("D")
else:
print("输入错误")
三元操作符
例:x,y = 4,5
if x < y:
small = x
else:
small = y
例子可以改进为:small = x if x < y else y
断言(assert)
assert 3 > 4
AssertionError
assert 3 < 4
程序正常运行
While循环
while 条件:
循环体
for循环:
for 目标(变量) in 表达式(列表,元组):
循环体
range()(for 循环的小伙伴)
range([strat,] stop[, step = 1])
for i in range(1,10,2):
print(i)
1
3
5
7
9
break和continue
break:终止当前循环并跳出当前循环体
continue:终止本轮循环并开启下一轮循环
continue范例:
for i in range(10):
if i%2 != 0:
print(i)
continue
i += 2
print(i)
2
1
4
3
6
5
8
7
10
9
列表:一个打了激素的数组
append()(只有一个参数,准备插入列表的元素)
extend()(只有一个参数,列表作为其参数)
向列表添加参数的两个方法。
insert()(两个参数)(插入列表的位置,准备插入的元素)
删除列表元素:
remove()(不需要知道具体位置,知道元素的名字即可)
del语句
del + 列表名字会删除整个列表
pop()
member.pop()(删除列表最后一个元素)
列表分片(slice)
memeber[1:3](原列表的一个拷贝)
member[:3]
member[1:]
member[:]
列表的一些常用操作符:
比较操作符:< >
逻辑操作符: and
连接操作符: +(两个列表相加)
重复操作符: list3 * 3 ; list3 *= 3
成员关系操作符: in 、 not in
list = ['小甲鱼', ['老甲鱼','牡丹'],'玩具']
'老甲鱼' in list[1]
True
list[1][1]
'牡丹'
列表类型的内置函数
count()
index()
reverse()(两级反转)(不需要参数)
sort(func(算法), key(与算法搭配的关键字), reverse)(排序)
sort(reverse = True)
元组:
tuple = (1,2,3,4,5,6,7,8,9,10)
8*8
64
8 * (8,)
(8,8,8,8,8,8,8,8)
如何给元组增加元素:
temp = ('1', '2', '3', '4')
temp = temp[:2] + ('敏儿',) + temp[2:]
temp
('1', '2', '敏儿', '3', '4')
用del可以删除整个元组
哪些操作符可以运用在元组之上呢?它和列表是一样的
比较操作符:< >
逻辑操作符: and
连接操作符: +(两个列表相加)
重复操作符: list3 * 3 ; list3 *= 3
成员关系操作符: in 、 not in
字符串也能进行切片操作:
str1 = "I love 123"
str1[5]
'e'
字符串常用的方法:
capitalize() 把字符串的第一个字符改为大写
casefold() 把整个字符串的所有字符改为小写
center(width) 将字符串居中,并使用空格填充至长度 width 的新字符串
str2 = 'DAXIExiaoxie'
str2.center(40)
' DAXIExiaoxie '
count(sub[,start[,end]])返回 sub 在字符串里边出现的次数,start 和 end 参数表示范围,可选。
string2.count('xi')
2
encode() 表示编码
endswith(sub,[,start[,end]]) 检查字符串是否以 sub 子字符串结束,如果是返回 True,否则返回 False。start 和 end 参数表示范围,可选。
str2.endswith('xi')
False
str2.endswith('xie')
True
expandtabs([tabtize = 8]) 把字符串中的 tab 符号(\t)转换为空格,如不指定参数,默认的空格数是 tabsize=8。
str3 = "I\tlove\tFishC.com"
str3.expandtabs()
'I love FishC.com'
find(sub[,start[,end]]) 检测 sub 是否包含在字符串中,如果有则返回索引值,否则返回 -1,start 和 end 参数表示范围,可选。
str3.find('efc')
-1
str3.find('com')
13
index(sub[,start[,end]]) 跟 find 方法一样,不过如果 sub 不在 string 中会产生一个异常。
join(sub) 以字符串作为分隔符,插入到 sub 中所有的字符之间。
str6 = 'Fishc'
str6.join(12345)
'1Fishc2Fishc3Fishc4Fishc5'
split(sep = None, maxsplit = 1) 不带参数默认是以空格为分隔符切片字符串,如果 maxsplit 参数有设置,则仅分隔 maxsplit 个子字符串,返回切片后的子字符串拼接的列表。
str6 = 'I love fishc'
str6.split()
['I', 'love', 'fishc' ]
str6.split(I)
['', 'love', 'fishc']
strip([chars]) 默认去字符串两边的空格,也可以自己指定参数
str7 = ' ssssaaaa '
str7.strip()
'ssssaaaa'
str7 = str7.strip()
str7
'ssssaaaa'
str7.strip('s')
'aaaa'
swapcase() 字符串大写变小写,小写变大写
title() 单词首字母大写
translate(table) 变换字符串其中的内容
str7 = 'ssssaaaa'
str7.translate(str, maketrans('s', 'b'))
'bbbbaaaa'
islower() 如果字符串中至少包含一个区分大小写的字符,并且这些字符都是小写,则返回 True,否则返回 False。
str4 = '小甲鱼'
str4.islower()
False
istitle() 如果字符串是标题化(所有的单词都是以大写开始,其余字母均小写),则返回 True,否则返回 False。
str5 = 'FishC'
str5.istitle()
False
lstrip() 去掉字符串左边的所有空格
str6 = ' I love you.'
str6.lstrip()
'I love you.'
partition(sub) 找到子字符串 sub,把字符串分成一个 3 元组 (pre_sub, sub, fol_sub),如果字符串中不包含 sub 则返回 ('原字符串', '', '')
str6 = 'I love you.'
str6.partition(ov)
('I l', 'ov', 'e you.')
replace(old,new[,count]) 把字符串中的 old 子字符串替换成 new 子字符串,如果 count 指定,则替换不超过 count 次。
str6 = 'I love fishC.'
str6.replace('fishC', 'FishC')
'I love FishC.'
swapcase()
str = 'FishC'
str.swapcase()翻转字符串中的大小写。
'fISHc'
Python中的format()
format()接受位置参数和关键字参数
replacement用花括号表示
"{0} love{1}.{2}".format("I", "FishC", "com")
'I love FishC.com'
"{a} love{b}.{c}".format(a="I", b="FishC", c="com")
'I love FishC.com'
"{0} love{b}.{c}".format("I", b="FishC", c="com")
print('\ta')
a
print('\\')
\
"{{0}}".format("不打印")
'{0}'
'{0:.1f}{1}'.format(27.658, 'GB')
'27.7GB'
字符串格式化符号含义及转义字符含义:
%c 格式化字符及ASCII码
'%c' % 97
'a'
'%c %c %c '% (97, 98, 99)
'a, b, c'
%s 用字符串格式化字符串
'%s' % 'I love you'
%d 格式化整数
'%d + %d = %d' % (4, 5, 4+5)
'4+5 = 9'
%o格式化无符号八进制数
'%o' % 10
12
%x格式化无符号十六进制数
'%x' % 10
a
%X格式化无符号十六进制数
'% X' % 10
A
'%X' % 160
'A0'
%f格式化定点数,可指定小数点后的精度
'%f' % 27.658
'27.658000'
%e用科学计数法格式化定点数
'%e' % 27.658
'2.765800e + 01'
格式化操作符辅助指令
m,n m是显示的最小总宽度,n是小数点后的位数
'%5.1f'% 27.658
' 27.7'
'%.2e' % 27.658
'2.77e+01'
-用于左对齐
'%-10d'% 5
'5 '
+在正数面前显示加号
'+d' % 5
'+5'
'+d' % -5
'-5'
#在八进制面前显示('0'),在十六进制面前显示'0x'或'0X'
'%#o' % 10
0o12
'%#X'% 108
'0X6C'
'%d'% 10
10
0显示的数字前面填充'0'取代空格
'010d'% 5
'0000000005'
'%0-10d' % 5
'5 '
列表、元组、字符串的共同点:
-都可以通过索引得到每一个元素
-默认索引值总是从0开始
-可以通过分片的方法得到一个范围内元素的集合
-有很多共同操作符(重复操作符,拼接操作符,共同成员操作符)
序列的内置函数:
list([iterable]):把一个可迭代对象转换为列表
tuple([iterable]): 把一个可迭代对象转换为元组
str(obj):把obj对象转换为字符串
len(sub):返回参数sub的长度
max():返回序列或者参数集合中的最大值
min()返回序列参数集合中的最小值
Python3 中有六个标准的数据类型:
Number(数字)
String(字符串)
List(列表)
Tuple(元组)
Set(集合)
Dictionary(字典)
sum(iterable,[, start=0])返回序列iterable和可选参数start的总和
sorted() 对序列中的数值大小进行排序
reversed()
numbers = [1, 2, 3, 4]
list(numbers(reversed))
[4, 3, 2, 1]
enumerated()
numbers = [1, 2, 3, 4]
list(enumerated(reversed))
[(0,1), (1,2), (2,3), (3,4)]
zip()
a = [1, 2, 3, 4, 5, 6, 7, 8]
b = [1, 2, 3, 4, 5]
list(zip(a, b))
[(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)]
函数:
关键字:
def;return
形参与实参,函数的参数可以为无限个
写函数功能文档是种好习惯哦
函数介绍:函数名.__doc__ ; help(函数名);
关键字参数:
def saysome(name, words):
print(name + '->' + words)
saysome('敏儿','让编程改变世界!')
敏儿->让编程改变世界!saysome(words= '让编程改变世界!, name= '敏儿')
敏儿->让编程改变世界!
默认参数:
def saysome(name='敏儿', words='让编程改变世界!'):
print(name + '->' + words)saysome()
敏儿->让编程改变世界!saysome('大猪蹄子')
大猪蹄子->让编程改变世界!
收集参数:
def test(*params):
print('参数的长度是:', len(params))
print('第二个参数是:', params[1])test(1, '敏儿', 3.14, 5, 6, 7, 8)
参数的长度是:7
第二个参数是:敏儿
闭包:
defX(x):
defY(y):
return x*y
return FunY
def fun1():
x = 5
def fun2():
x *= x
return x
return fun2
def fun1():
x = 5
def fun2():
x[0] *= x[0]
return x[0]
return fun2fun1()
25def fun1():
x = 5
def fun2():
nonlocal x
x *= x
return x
return fun2
nonlocal不是全局变量
lambda函数
def ds(x):
return 2 * x+1ds(5)
11lambda x : 2 * x + 1
g = lambda x : 2 * x + 1
g (5)
11def add(x, y):
return x + yadd(3, 4)
7lambda x, y : x + y
g = lambda x, y : x + y
g(3, 4)
7
两个牛逼的函数:
filter()
filter(None, [1, 0, True, False])list(filter(None, [1, 0, True, False]))
[1, True]
利用filter函数筛选奇数:
def odd(x):
return x % 2temp = range(10)
show = filter(odd, temp)
list(show)
[1, 3, 5, 7, 9]list(filter(lambda x : x % 2, range(9)))
[1, 3, 5, 7, 9]
map()函数
list(map(lambda x : x % 2, range(9)))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
递归是神马
def factorial(n):
result = n
for i in range(1, n):
result* = i
return result
number = int(input('请输入一个正整数:'))
result = factorial(number)
print()
闭包:
defX(x):
defY(y):
return x*y
return FunY
def fun1():
x = 5
def fun2():
x *= x
return x
return fun2
def fun1():
x = 5
def fun2():
x[0] *= x[0]
return x[0]
return fun2fun1()
25
def fun1():
x = 5
def fun2():
nonlocal x
x *= x
return x
return fun2
nonlocal不是全局变量
lambda函数
def ds(x):
return 2 * x+1ds(5)
11lambda x : 2 * x + 1
g = lambda x : 2 * x + 1
g (5)
11
def add(x, y):
return x + yadd(3, 4)
7
lambda x, y : x + y
g = lambda x, y : x + y
g(3, 4)
7
两个牛逼的函数:
filter()
filter(None, [1, 0, True, False])list(filter(None, [1, 0, True, False]))
[1, True]
利用filter函数筛选奇数:
def odd(x):
return x % 2temp = range(10)
show = filter(odd, temp)
list(show)
[1, 3, 5, 7, 9]list(filter(lambda x : x % 2, range(9)))
[1, 3, 5, 7, 9]
map()函数
list(map(lambda x : x % 2, range(9)))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
递归是神马
def factorial(n):
result = n
for i in range(1, n):
result *= i
return result
number = int(input('请输入一个正整数:'))
result = factorial(number)
print("%d的阶乘是: %d" % (number, result))
def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n-1)number = int(input('请输入一个正整数:'))
result = factorial(number)
print("%d的阶乘是: %d" % (number, result))
斐波那契数列:
def fab(n):
#此处n为时间
n1 = 1
n2 = 1
n3 = 1
if n < 1:
print('输入有误!')
return -1
while (n-2) > 0:
n3 = n2 + n1
n1 = n2
n2 = n3
n -= 1
return n3
result = fab(20)
if result!= -1:
print("总共有%d对小兔崽子诞生!" % result)
def fab(n):
if n < 1:
print('输入有误!')
return -1if n == 1 or n == 2:
return 1
else:
return fab(n-1) + fab(n-2)result = fab(20)
if result != -1:
print("总共有%d对小兔崽子诞生!" % result)
字典
name = ['黑夜','一束光', '敏儿', '秀乐']
slogen = ['技术第二', '人品第一', '还会再见嘛', '会再见的']
print('秀乐的口号是:',slogen[name.index('秀乐')])
秀乐的口号是:会再见的
dict1 = {'黑夜':'技术第二', '一束光':'人品第一', '敏儿': '还会再见嘛' '秀乐':'会再见的'}
print('秀乐的口号是 :', dict1['秀乐'])(键的值:整型,变量,字符串,字符类型)
秀乐的口号是:会再见的dict2 = {1:'one', 2:'two', 3:'three'}
dict[2]
two
dict3 = {}
dict3 = dict((('F',70), ('i', 105), ('s', 115), ('C', 67)))
dict3
{'F': 70, 'C': 67, 's': 115, 'h': 104, 'i': 105}
注:其中dict(mapping)的参数只有一个,所以要在外面多加两个括号。
dict4 = dict(敏儿= '你不懂我我也不怪你', 秀乐= '我还是无法理解')
dict4
{ '秀乐':'我还是无法理解','敏儿':'你不懂我我也不怪你',}
注:如果通过关键字参数创建字典,键值对可能会产生顺序上的变化。
通过关键字参数创建字典,其中的“敏儿”和“秀乐”不能加引号否则会报错。
dict4 = ['秀乐']= '所有从业者都要通过学习编程来提高职业技能'
dict4
{'秀乐': '所有从业者都要通过学习编程来提高职业技能', '敏儿': '你不懂我我也不怪你'}dict4['爱迪生'] = '天才就是99%的汗水加1%的灵感,但这1%的灵感远比99%的汗水重要'
dict4
{'秀乐': '所有从业者都要通过学习编程来提高职业技能', '敏儿': '你不懂我我也不怪你', '爱迪生': '天才就是99%的汗水加1%的灵感,但这1%的灵感远比99%的汗水更重要。'}
当索引不好用时:
dict(工厂函数)
str()
int()
list()
tuple()
以上均为类型函数。
fromkeys()(创建并返回一个新的字典)
dict.fromkeys(s[,v]) (s,代表的是字典对应的键值。v时可选的,如果第二个参数不提供时,它默认的就是None)
dict1 = {}
dict1.fromkeys((1, 2, 3))
{1:None, 2:None, 3:None}
dict1.fromkeys((1, 2, 3), 'Number')
{1:'Number', 2: 'number', 3: 'number'}dict1.fromkeys((1, 2, 3), ('one', 'two', 'three'))
{1: ('one', 'two', 'three'), 2:('one', 'two', 'three'),3:('one', 'two', 'three')}dict1.fromkeys((1,3), '数字')
{1: '数字',3: '数字'}
keys()返回字典键的引用
values()
items()
访问字典的几个方法
dict1 = dict1.fromkeys(range(32), '赞')
dict1
{0: '赞', 1: '赞', 2:'赞'...}
for eachkey in dict1.keys():
print(eachkey)
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
for eachvalue in dict.value():
print(eachvalue)
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
赞
for eachItem in dict1.fromkeys():
print(eachItem)
(0, '赞')
(1, '赞')
(2, '赞')
(3, '赞')
(4, '赞')
(5, '赞')
(6, '赞')
(7, '赞')
(8, '赞')
(9, '赞')
(10, '赞')
(11, '赞')
(12, '赞')
(13, '赞')
(14, '赞')
(15, '赞')
(16, '赞')
(17, '赞')
(18, '赞')
(19, '赞')
(20, '赞')
(21, '赞')
(22, '赞')
(23, '赞')
(24, '赞')
(26, '赞')
(27, '赞')
(28, '赞')
(29, '赞')
(30, '赞')
(31, '赞')
print(dict1[32])
keyerror
dict1.get(32)
print(dict1.get(32))
None
clear()方法 (清空字典)
dict1.clear()
dict1()
{}
浅拷贝和赋值是不一样的:
a = {1: 'one', 2: 'two', 3: 'three'}
b = a.copy()
c = a
a.pop(2)
'two'
a
{1: 'one', 3: 'three'}
a.popitem()
{1: 'one'}
a
{3: 'three'}
a.setdefault('小白')
{'小白': None, 3: 'three'}
a.setdefault(5: 'five')
five
a
{'小白':None, 5: 'five', 3: 'three'}
b = {'小大白': '狗'}
a = update.b
a
{'小大白': '狗', '小白':None, 5: 'five', 3: 'three'}
集合:
num = {}
num2 = {1, 2, 3, 4, 5}
num2 = {1, 2, 3, 4, 5, 5, 4, 3, 2, 1}
num2
{1, 2, 3, 4, 5}
注:集合具有唯一性,集合不支持索引。
set1 = set([1, 2, 3, 4, 5])
set1
{1, 2, 3, 4, 5}
如何访问集合中的值:
1.可以使用for把集合中的数据一个个都取出来
2.可以通过in和not in判断一个元素是否在集合中已经存在
num2 = {1, 2, 3, 4, 5}
num2.add(6)
num2
{1, 2, 3, 4, 5, 6}
同理还有remove()方法
不可变集合L:
frozen
num3 = frozenset({1, 2, 3, 4, 5})
num3.add()
报错
文件
模块:
OS模块:Operating System(操作系统)
OS模块下的函数:(模块必须先导入)
getcwd()
chdir(path)(path需为字符串形式)
listdir()(列举当前目录的文件名)
mkdir()(创建当前文件夹)
mkdirs(path)(递归创建多层目录)
remove(path)(删除文件)
rmdir()(删除单层目录,如目录非空就会报错)
removedirs(path)(删除多层目录,在此之前先删除其中的子目录及文件)
rename(old, new)(将文件old重命名为new)
system(command)运行系统的shell命令
os.curdir 指代当前目录(".")
os.pardir 指代上一级目录("..")
os.sep 输出操作系统特定的路径分隔符:(Win下为'\\', Linux下为'/')
os.linesep 当前系统使用的行终止符(Win下为'\r\n', Linux下为'\n')
os.name 指代当前的操作系统(包括:'posix', 'nt', 'mac', 'os2', 'ce', 'java')
os.path模块中关于路径常用的函数使用方法:
basename(path) 去掉目录路径,单独返回文件名
dirname(path)去掉文件名,单独返回目录路径
join(path1[,path2[,...]])
split(path)(分割文件名和路径)
splitext(path)分离文件名和扩展名
getsize(file)返回指定文件的尺寸,单位是字节
getatime(file)返回指定文件最近的访问时间
getctime(file)返回指定文件的创建时间
getmtime(file)返回指定文件最新的修改时间
exists(path)判断指定路径(目录或文件)是否存在
isabs(path)判断指定路径是否为绝对路径
isdir(path)判断指定路径是否存在且是一个目录
isfile(path)判断指定路径是否存在且是一个文件
islink(path)判断制定路径是否存在且是一个符号链接
ismount(path)判断指定路径是否存在且是一个挂载点
samefile(path1, path2)判断path1和path2两个路径是否指向同一个文件
文件的永久储存:
import pickle
my_list = [1, 3.14, 'dog', ['another list']]
pickle_file = open('my_list.pk1', 'wb')
pickle.dump(my_list, pickle_file)
pickle_file.close()pickle_file = open('my_list.pk1', 'rb')
my_list2 = pickle.load(pickle_file)
print(my_list2)
Python标准异常总结:
AssertioneError 断言语句(assert)失败
AttributeError 尝试访问未知的对象属性
IndexError 索引超出序列的范围
KeyError 字典中查找一个不存在的关键字
NameError 尝试访问一个不存在的变量
OSError 操作系统产生的异常(例如打开一个不存在的文件)
OverflowError 数值运算超出最大限制
SyntaxError python的语法错误
TypeError 不同类型间的无效操作
ZeroDivisionError 除数为零
异常检测:
try:
检测范围
except Exception[as reason]:
出现异常(Exception)后的处理代码
finally:
无论如何都会被执行的代码try:
sum = 1 +'1'
f = open('我为什么是一个文件')
print(f.read())
f.close()
except OSError as reason:
print('文件出错啦\n出错的原因是:' + str(reason))
except TypeError as reason:
print('类型出错啦\n出错的原因是:' +str(reason))try:
sum = 1 +'1'
f = open('我为什么是一个文件')
print(f.read())
f.close()except(OSError, TypeError):
print('出错啦-_-')
try:
f = open('我为什么是一个文件.txt', 'w')
print(f.write('我存在了!'))
sum = 1 + '1'except(OSError, TypeError):
raise:自己引发一个异常
raise ZeroDivisionError('除数为0的异常')
ZeroDivisionError:除数为0的异常
print('出错啦-_-')
finally
f.close()
else的丰富用法:
def showMaxFactor(num):
count = num // 2
while count > 1:
if num % count ==0:
print('%d最大的约数是%d' % (num, count))
else:
print('%d是素数!'% num)num = int(input('请输入一个数'))
showMaxFactor(num)
简洁的with语句
try:
with open('data.txt', 'w') as f:
for each_line in f:
print(each_line)
except OSError as reason:
print('出错啦' + str(reason))
面向对象的特征:
1.封装(属性和方法)
2.继承(子类自动共享父类之间数据和方法的机制)
3.多态
Class A:
def fun(self):
print("我是小A")
Class B:def fun(self):
print("我是小B")
a = A()
b = B()
a.fun()
我是小A
b.fun()
我是小Bclass Ball:
def setName(self, name):
self.name = name
def kick(self):
print("我叫%s, 该死的,谁踢我..." % self.name)a = Ball()
a.setName('球A')
b = Ball()
b.setName('球B')
c = Ball('土豆')
a.kick()
我叫球A,该死的,谁踢我...
c.kick()
我叫土豆,该死的,谁踢我...
你听说过python的魔法方法嘛
__init__(self) 构造
class Ball:
def __init__(self, name):
self.name = name
def kick(self):
print("我叫%s, 该死的,谁踢我..." % self.name)b = Ball('土豆')
b.kick()
我叫土豆,该死的,谁踢我...
公有和私有
class Person:__name = '小甲鱼'
def getName(self):
return self.__namep = person()
p.__name
p.getName()
'小甲鱼'
p._person__name
'小甲鱼'