杨小彧-Python笔记
文章目录
小知识
- 0b表示二进制，0o八进制
- 可迭代对象：可以用
for in遍历的
尚存问题
-
打开文件写入字符的操作
-
转义字符
\的使用 -
end=
-
静态方法
bug集锦
-
input()输入类型为str#错误示范 age=input('请输入你的年龄') #正确示范：age=int(input('请输入你的年龄')) if age>=18: print('你成年了')
| 报错名称 | 错误原因 |
|---|---|
ZeroDivisionError | 分母为0 |
IndexError | 序列中没有该索引 |
KeyError | 映射中没有这个键 |
NameError | 未声明/初始化 对象 |
SyntaxError | 语法错误 |
ValueError | 传入无效的参数 |
基础语法
语法知识
数据类型转换
| 转换目标类型 | 举例 | 注意 |
|---|---|---|
| 字符串 | str(123)'123' | |
| 整数 | int(12) | 小数串'1.1'无法转换为int类型浮点转换抹去小数部分 |
| 浮点数 | float() | 整数转换+.0 |
- 多行注释：三引号
"""、'''
运算
| 符号 | 意义 |
|---|---|
+ | 加 |
- | 减 |
* | 乘 |
/ | 除 |
// | 整除（一正一负的整数运算，向下取整） |
% | 求余（一正一负，余数=被除数-除数 × × ×商（已向下取整）） |
a**b | a b a^b ab |
赋值
| 方式 | 举例 |
|---|---|
| 链式赋值 | a=b=c=20 |
| 参数赋值 | a+=30 |
| 系列解包赋值 | a,b,c=2,3,4 |
比较运算
- 结果为
bool类型False、True
| 方式 | 作用 |
|---|---|
>、!=、== | 对象value的比较 |
is、is not | 对象id的比较 |
布尔运算
| 运算符 | 释义 |
|---|---|
and | 与门 |
or | 或门 |
not | 非门 |
'a' in s | a在字符串s里吗 |
'a' not in s | a不在字符串s里吗 |
- 结果只为
True、False
位运算
| 运算符 | 释义 |
|---|---|
& | 按位与，同为1结果为1 |
| ` | ` |
<< | 二进制下左移一位 |
>> | 二进制下右移一位 |
优先级
() -> 算术 -> 位 -> 比较 -> 布尔 -> 赋值
字符相关
| 转义字符 | 释义 |
|---|---|
\n | 换行(newline) |
\t | 等同于按下Tab |
\r | 光标回到本行开头 |
\b | 等同于按下Backspace |
-
原字符：
r- 抑制转义字符的作用
-
字符串类型中，可以用用
"""、'''使其分布在多行
流程控制
| 语句 | 作用 |
|---|---|
break | 跳出本层循环 |
continue | 结束本层循环 |
else | 和循环搭配时，无break循环结束执行else有 break不执行 |
基础函数
输出函数
print()
print(1+1) #2
print('A') #A
print() #换行
- 输出数字、计算式不用加
'，计算式输出的是结果 - 默认换行输出，可以用
,抑制换行 - 输出中嵌入变量使用
+<变量>+ - 内部只能连接
str类型数据 - 结尾默认换行，可用
end=""改变
输入函数
input()
#将输入的数赋值给a
a = input('请输入一个数')
- 单引号内为提示语句
选择函数
单分支
if else
#判断奇偶
num=int(input('请输入一个数'))
if num%2==0:
print(num,'是偶数')
else:
print(num,'是奇数')
多分支
if elif else
#判断成绩属于什么档次
score=float(input('请输入成绩'))
if score>=90:
print('A')
elif 60<=score<90:
print('B')
elif score<60:
print('C')
条件表达式
_if_else_
#判断a,b哪个大
a=int(input('输入a'))
b=int(input('输入b'))
print('a>b' if a>b else 'a<b')
- 为真执行的语句 判断 为假执行的语句
循环函数
while
a=1
whhile a<5: #满足条件进行循环
a+=1
print(a)
#5
for-in
for _ in range(10) #循环10次
for i in range(1,10) #变量i的值从1~9，循环9次
- 如果用不到变量
i，可以用_代替 in后面接可迭代的对象（序列或字符串）
其余函数
range()
| 方式 | 创建对象 |
|---|---|
range(stop) | [0,stop)间的整数序列，步长为1 |
range(start,stop) | [start,stop)间的整数序列，步长为1 |
range(start,stop,step) | [start,stop)间的整数序列，步长为step |
| 函数名 | 释义 |
|---|---|
id(x) | 变量x的存储地址 |
type(x) | 变量x的数据类型 |
list(a) | 将a转换成列表形式 |
items=['FRUits','BOOKS','others']
prices=[12,3,5]
a={item.upper():price for item,price in zip(items,prices)}
print(a)
#{'FRUITS': 12, 'BOOKS': 3, 'OTHERS': 5}
b={item.lower():price for item,price in zip(items,prices)}
print(b)
#{'fruits': 12, 'books': 3, 'others': 5}
c={item.capitalize():price for item,price in zip(items,prices)}
print(c)
#{'Fruits': 12, 'Books': 3, 'Others': 5}
d={item.title():price for item,price in zip(items,prices)}
print(d)
#{'Fruits': 12, 'Books': 3, 'Others': 5}
列表
创建
| 方式 | 形式 |
|---|---|
| 直接生成 | ['你好',520] |
| 函数生成 | list([‘你好’,520]) |
索引
获取单个元素
- 从左数 : 0 -> ∞ \infty ∞ ，从右数 : -1 -> − ∞ -\infty −∞
lst=['hello','python',520,'hello',1]
print(lst[0],lst[-3])
#hello 520
获取多个元素
- 片段选取，默认步长是
1 [a:b:c]，获取区间[a,b)内，步长为c的所有元素start默认0，stop默认 ± ∞ \pm\infty ±∞，step默认1
lst=['hello','python',520,'hello',1]
print(lst[1:3])
#['python', 520]
查找元素位置
- 存在相同元素，返回第一个元素的位置
lst = ['hello', 'python', 520, 'hello', 1]
print(lst.index('hello'))
# 0
print(lst.index('hello', 1, 3)) # 在序列[1,3)之间查找
# ValueError: 'hello' is not in list
查询元素是否存在
in、not in判断
lst = [1, 2, 3, 4, 5, 6]
print(1 in lst) # True
print(7 not in lst) # False
添加元素
| 函数 | 作用 |
|---|---|
append() | 列表末尾添加一个元素 |
extend() | 列表末尾添加多个元素 |
insert(a,b) | 列表**a位置**添加b元素 |
| 切片 | 替换一部分元素 |
lst = [1, 2, 3, 4, 5, 6]
lst.append(100) #末尾添加100这个元素
print(lst)
#[1, 2, 3, 4, 5, 6, 100]
lst1 = ['a', 'b']
# lst.append(lst1) #将lst1作为一个元素添加
# [1, 2, 3, 4, 5, 6, 100, ['a', 'b']]
lst.extend(lst1) #添加lst1中的元素
print(lst)
#[1, 2, 3, 4, 5, 6, 100, 'a', 'b']
lst.insert(2, '哈') #在索引为2的位置添加元素
print(lst)
#[1, 2, '哈', 3, 4, 5, 6, 100, 'a', 'b']
lst2 = [22, 33, 44]
lst[1:3] = lst2 #将[1,3)中间的元素替换
print(lst)
#[1, 22, 33, 44, 3, 4, 5, 6, 100, 'a', 'b']
删除元素
| 函数 | 作用 |
|---|---|
reove(a) | 移除a这个元素重复元素删第一个 |
pop(x) | 移除x位置的元素不指定 x，删除最后一个 |
| 切片 | 删除一段元素 |
clear() | 清空列表 |
del | 删除列表 |
lst = [1, 2, 3, 4, 5, 6, 7, 8]
lst.remove(8) #移除8这个元素
print(lst)
#[1, 2, 3, 4, 5, 6, 7]
lst.pop(4) #移除位置为4的元素
print(lst)
#[1, 2, 3, 4, 6, 7]
lst[0:3] = [] #删除[0,3)内的元素
print(lst)
#[4, 6, 7]
lst.clear() #清空列表
print(lst)
#[]
del lst #删除列表
修改元素
- 和matlab一样
排序元素
| 函数 | 作用 |
|---|---|
sort(reverse=True) | 降序排列 |
sort(reverse=False)/sort() | 升序排列 |
sorted(x,a) | 对x进行a排序，并创建新的对象 |
函数生成
lst=[i*2 for i in range(1,6)] #i的操作就是列表的操作
print(lst)
#[2, 4, 6, 8, 10]
字典
属性
- 以键值对的方式存储数据
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zFZupqob-1658892697361)(D:/Efficiency/Typora/image/image-20220717082806272.png)]
- 键不能重复，值可以重复
- 元素是无序的，所以不能指定在哪个位置插入
- 键为不可变对象，所以不能用用列表作为键
创建
-
直接创建
-
函数创建
scores={'张三':100,'李四':20}
print(scores)
#{'张三': 100, '李四': 20}
student=dict(name='张三',age=20)
print(student)
#{'name': '张三', 'age': 20}
获取
score[]无法获取会报错score.get()无法获取返回指定值
score={'张三':100,'李四':20}
print(score['张三'])
#100 #返回该键的值
print(score.get('张三'))
#100 #返回该键的值
print(score.get('麻七',11))
#11 #找不到，返回指定的值
查询是否存在
score = {'张三': 100, '李四': 20}
print(100 in score) #False
print('王五' not in score) #True
删除 与 清空
del score['张三'] #删除该元素及其匹配键值
#{'李四': 20}
score.clear() #清空字典元素
添加 与 修改
score={'张三':100,'李四':88}
score['陈六']=45 #添加该元素
print(score)
#{'张三': 100, '李四': 88, '陈六': 45}
score['陈六']=90
print(score) #修改该元素对应的值
#{'张三': 100, '李四': 88, '陈六': 90}
获取视图
score={'张三':100,'李四':88}
a=score.keys() #获取键名
print(list(a)) #列表形式输出
#['张三', '李四']
b=score.values() #获取键值
print(list(b))
#[100, 88]
c=score.items() #获取字典全部
print(list(c))
#[('张三', 100), ('李四', 88)]
遍历
score={'张三':100,'李四':88}
for i in score: #遍历字典中元素
print(i,score[i],end="\t") #输出键与值，间距一个Tab
#张三 100 李四 88
字典生成式
items=['fruits','books','others']
prices=[12,3,5]
a={item:price for item,price in zip(items,prices)}
print(a)
#{'fruits': 12, 'books': 3, 'others': 5}
元组
属性
- 不可变序列
- 内部元素同字符串一样无法进行增、删、改操作
- 内部的引用不可变，但如果引用的对象可变如；列表，则可以给列表添加元素
- 有序对象
- 可以使用指定索引
创建
#直接法
t1='我','hello',10
t2=('我','hello',10)
#函数法
t3=tuple(('我','hello',10))
#单元素元组
t4=(10,)
遍历
同字典的遍历一样 使用for in循环
集合
属性
- 重复的元素只会呈现一个
- 和字典不同，只有键没有值
创建
- 大括号直接生成
set()函数转换
#直接生成
s={'hello',90} #只有键，没有值
print(s)
#{'hello', 90}
print(set(range(6)))
#{0, 1, 2, 3, 4, 5}
print(set([2,3,4]))
#{2, 3, 4}
print(set((2,3,4)))
#{2, 3, 4}
print(set('python'))
#{'n', 'y', 'p', 'o', 't', 'h'} #无序排列
print(set({2,3,4}))
#{2, 3, 4}
s1=set() #创建空集合
判断
s={1,2,3}
print(1 in s)
#True
添加
s.add添加一个元素s.update添加多个元素
s={1,2,3,4,5}
s.add(77)
print(s)
#{1, 2, 3, 4, 5, 77}
s.update({210,330})
s.update([110,520])
s.update((222,444))
print(s)
#{1, 2, 3, 4, 5, 520, 330, 77, 210, 222, 110, 444}
删除
s.remove(a)删除a，a不存在抛出异常s.discard(a)删除a，a不存在不抛出异常s.pop()随机删除元素，不能指定删除什么s.clear清空
s={1,2,3,4,5}
s.remove(1) #删除1
print(s)
#{2, 3, 4, 5}
s.pop() #随机删除
print(s)
#{4, 5}
判断关系
a={10,20,30,40}
b={20,30,40,50,60}
相等
- 使用
==、!=判断
子集
- 使用
a.issubest(b)a是b的子集吗
超集
- 使用
a.issuperset(b)a是b的超集吗
交集
- 使用
a.isdisjoint(b)a与b有交集吗
数学操作
a={10,20,30,40}
b={20,30,40,50,60}
交集
a与b的交集a & ba.intersection(b)
并集
-
a与b的并集-
a.union(b) -
a | b
-
差集
-
a与b的差集a.difference(b)a - b
print(a-b) #{10}
对称差集
-
a与b的对称差集a.symmetric_difference(b)a ^ b
print(a^b) #{50, 10, 60}
集合生产式
s={i for i in range(6)}
print(s)
#{0, 1, 2, 3, 4, 5}
| 数据结构 | 是否可变 | 可否重复 | 是否有序 | 定义符号 |
|---|---|---|---|---|
| 列表(list) | 可变 | 可以 | 有 | [] |
| 元组(tuple) | 不可变 | 可以 | 有 | () |
| 字典(dict) | 可变 | key可value不可 | 无 | {key:value} |
| 集合(set) | 可变 | 不可 | 无 | {} |
字符串
驻留机制
-
驻留机制的几种情况（交互模式）
-
字符串的长度为
0或1 -
符合标识符的字符串
-
只在编译时驻留，而非运行时
-
[-5,256]之间的整数
-
-
a=sys.intern(b)- 强制将两个字符串指向同一个对象
查询
| 方法 | 作用 |
|---|---|
index() | 查找第一次出现的位置，若不存在返会error |
rindex() | 查找最后一次出现的位置，若不存在返回error |
find | 查找第一次出现的位置，若不存在返-1 |
rfind | 查找最后一次出现的位置，若不存在返回-1 |
修改大小写
| 函数 | 作用 |
|---|---|
a.upper() | 将变量a的值转为大写字幕 |
a.lower() | 改小写 |
a.capitalize() | 首字母大写 |
a.title() | 每个单词首字母大写 |
a.swapcase() | 大写变小写，小写变大写 |
对齐
| 方法 | 作用 |
|---|---|
center(a,b) | 居中对齐，a表示宽度，b表示填充符（默认空格） |
ljust(a,b) | 左对齐，a表示宽度，b表示填充符（默认空格） |
rjust(a,b) | 右对齐，a表示宽度，b表示填充符（默认空格） |
zfill(a) | 右对齐，a表示宽度，用0填充 |
常用操作
劈分
split()- 从左边开始劈分，默认劈分字符是空格，返回值是一个列表
- 可以通过
sep='a'指定a为劈分字符 - 可以通过
maxsplit=x指定劈分次数x
resplit()- 从右边开始劈分，其他同上
s='hello|world|python'
print(s.split(sep="|",maxsplit=1))
#['hello', 'world|python']
判断
| 方法 | 判断 |
|---|---|
isidentifier() | 是不是合法的 |
isspace() | 是否全部由空白字符（回车，换行，水平制表符）组成 |
isalpha() | 是否全部由字母组成 |
isdecimal() | 是否全部由十进制的数字组成 |
isnumeric() | 是否全部由数字组成 |
isalnum() | 是否全部由字母和数字组成 |
替换与合并
| 方法 | 作用 |
|---|---|
replace('a','b',c) | 将a替换为b，从左往右替换c次 |
a.join(b) | 用a将列表或元组b合并成一个字符串 |
s = ['hello','world']
print('|'.join(s))
#hello|world
比较
- 先比较首字符，相等则一直比下去
- 比较的是ASCLL码值
切片
- 字符串是不可变类型
- 不具备增、删、改操作
- 切片将产生新的对象
格式化
方式
%作占位符%s字符串，%i,%d整数，%f浮点数
name='张三'
age=20
#第一种
print('我是%s,今年%d岁'%(name,age))
#第二种
print('我是%s,今年%d岁'%('张三',20))
#我是张三,今年20岁
{}作占位符
name='张三'
age=20
#第一种
print('我叫{0},今年{1}岁'.format(name,age))
#第二种
print(f'我叫{name},今年{age}岁')
#我叫张三,今年20岁
格式
print('%10d'%88) #宽度10位
# 88
print('%.3f'%3.1415926) #保留3位小数
#3.142
print('{0:.3}'.format(3.1415926))#总共3位
#3.14
print('{0:.3f}'.format(3.1415926))#保留3位小数
#3.142
print('{0:10.3}'.format(3.1415926))#宽度10位，保留3位小数
# 3.14
编码与解码
- **编码：**字符串转二进制
bytes - **解码：**将
bytes类型数据转换成字符串类型
s='天涯共此时' #字符串
print(s.encode(encoding='GBK')) #输出编码值
#b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1' #x表示16进制
byte=s.encode(encoding='GBK')
#编码成GBK形式
print(byte.decode(encoding='GBK'))
#将GBK形式解码
函数
创建与调用
def calc(a,b): #创建函数
c=a+b #执行体
return c #返回值
d=calc(10,20) #调用
print(d) #输出值
参数传递
传递方法
- 位置传递
- 根据位置对应传参
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PdvKgZlc-1658892697362)(D:/Efficiency/Typora/image/image-20220721081931189.png)]
- 关键字传递
- 根据形参名字进行实参传递
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NfLopTVN-1658892697362)(D:/Efficiency/Typora/image/image-20220721081944023.png)]
内存分析
- 形参用完被销毁
返回值
-
没有返回值，
return可省略 -
返回一个值，是原值类型
-
返回多个值时，结果为元组
参数定义
-
可以给形参设置默认值，不指定即为默认值
def fun(a,b=10): print(a,b) fun(100) #没有指定b #100 10 fun(22,33) #有指定 #22 33 -
个数可变的位置参数
- 使用
*定义，一个函数只能定义一个 - 参数数量可变
- 返回值为元组
def fun(*arg): print(arg) fun(100) #100 fun(22,33) #22 33 - 使用
-
个数可变的关键字形参
- 使用
**定义，一个函数只能定义一个 - 返回值是字典
def fun(**arg): print(arg) fun(a=10) #{'a': 10} fun(a=22,b=33) #{'a': 22, 'b': 33} - 使用
-
如果函数既有个数可变的位参，也有个数可变的关键字形参，位参在前
def fun(*arg1,**arg2):
其他
-
传递列表到函数，加
*lst=[1,2,3] fun(*lst) -
传递字典到函数，加
**s={'a':1,'b':2,'c':3} fun(**s) -
使用
*指定其后参数只能使用关键字参数传递def fun(a,b,*,c,d) #指定c和d只能使用关键字传递
变量的作用域
- 函数内定义的变量为局部变量，使用
global可将其变为全局变量
递归函数
- 定义
- 一个函数在函数体内调用它本身
异常处理
try-except
try块抛出异常，执行except块
try:
a=int(input('请输入被除数'))
b=int(input('请输入除数'))
c=a/b
print(b)
except ZeroDivisionError:
print('除数不能为0')
except ValueError:
print('请输入数字')
except BaseException as e: #非以上两种情况的错误
print('出错了')
try-except-else
try块没有抛出异常，执行else块
try:
a=int(input('请输入被除数'))
b=int(input('请输入除数'))
c=a/b
except BaseException as e:
print('出错了')
else:
print('结果为',c)
try-except-else-finally
- 无论是否发生异常，都会执行
finally块- 常用来释放
try块中申请的资源
- 常用来释放
try:
a=int(input('请输入被除数'))
b=int(input('请输入除数'))
c=a/b
except BaseException as e:
print('出错了')
else:
print('结果为',c)
finally:
print('谢谢使用')
traceback
- 输出错误
import traceback
try:
print('hihi')
print(1/0)
except: #可以省略错误
traceback.print_exc()
类与对象
基本概念
-
类的组成
- 类属性
- 实例方法
- 静态方法
- 类方法
-
方法：
- 在类之内定义的函数
-
类属性：类中，方法外，的变量，被该类的所有对象所共享
-
静态方法：
- 使用
@staticmethod修饰的方法，使用类名直接访问 ()内什么都不写
- 使用
-
类方法：
- 使用
@calssmethod修饰的方法，使用类名直接访问 ()内写cls
- 使用
创建与调用
- 实例方法的调用
- 实例名.实例方法
- 类名.方法名(对象)
- 类属性，类方法，静态方法
- 类名.方法名
class Student: # 大驼峰命名法
native_place = '吉林' # 类属性，类内所有对象共享,其不在方法内
def __init__(self, name, age): # 初始化方法
self.name = name # 实例属性，局部变量赋值给实例属性
self.age = age
# 实例方法
def eat(self):
print('学生在吃饭')
# 静态方法，使用@staticmethod修饰
@staticmethod
def sm(): # 无参数
print('静态方法')
# 类方法，使用@classmethod修饰
@classmethod
def cm(clS): # 参数是cls
print('类方法')
stu1 = Student('张三', 20) # 创建实例对象：实例名=类名
stu1.eat() # 实例方法
print(stu1.name) # 实例属性
print(stu1.age) # 实例属性
Student.eat(stu1) # 实例方法：类名.方法名
print(Student.native_place) # 访问类属性
Student.sm() # 调用静态方法
Student.cm() # 调用类方法
动态绑定
class Student: # 创建类
def __init__(self, name): # 初始化方法
self.name = name # 实例属性
stu1 = Student('张三') # 创建实例
print(stu1.name) # 访问实例属性
stu1.age = 20 # 添加属性
print(stu1.age) # 访问添加的属性
def show(): # 一个类外的函数
print('绑定的方法')
stu1.show = show # 绑定函数到实例的方法
stu1.show() # 调用实例的方法
面向对象
三大特征
封装
-
将数据（属性）和行为（方法）包装到类对象中。
-
在方法内部对属性操作，在类对象外调用方法
-
前边使用两个
_抑制该属性的外部调用- 但可以用
dir()遍历查询对象的属性
class Student: # 创建类 def __init__(self, name, __age): # 初始化方法 self.name = name # 实例属性 self.__age = __age # 抑制外部调用 def show(self): # 内部方法调用 print(self.name, self.__age) stu1 = Student('张三', 20) # 创建实例 print(stu1.name) # 访问实例属性 stu1.show() # 类之内调用 print(dir(stu1)) # 遍历实例属性，查询被隐藏的属性 print(stu1._Student__age) # 调用查询到的被隐藏的属性 - 但可以用
继承
-
实现方式
-
子类名（父类名）
-
如果一个类没有继承任何类，则默认继承
object -
Python支持多继承
-
#Studnet和Teacher继承父类Person的方法
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def info(self):
print(self.name, self.age)
class Student(Person): # 继承Person类
def __init__(self, name, age, stu_no):
super().__init__(name, age) # 调用父类方法
self.stu_no = stu_no
class Teacher(Person, object): # 多继承
def __init__(self, name, age, teach_of_year):
super().__init__(name, age)
self.teach_of_year = teach_of_year
stu = Student('张三', 20, '1001')
tea = Teacher('李四', 30, 5)
stu.info() #调用子类继承的父类的方法
tea.info()
- 方法重写
- 在子类对父类中的方法重新编写
- 通过
super().xx()调用被重写的方法
#父类方法无法输出学号，子类重写父类方法使之能输出学号
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def info(self):
print(self.name, self.age)
class Student(Person):
def __init__(self, name, age, stu_no):
super().__init__(name, age)
self.stu_no = stu_no
def info(self):
super().info() # 调用父类方法
print('学号', self.stu_no) # 重写父类方法，生成属于自己的方法
stu = Student('张三', 20, '1001')
stu.info()
- object类
- 是所有类的父亲，因此所有类都有object类的属性和方法
多态
扫一扫
1477
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
