Python笔记
安装python
基础语法
设置编码方式
# coding=utf-8
注释
单行注释:
# 单行注释
多行注释: 三个单引号
'''
多行注释
'''
输出语句
语法
print()
默认以\n结尾
可以自定义结尾
print(’’, end=’’)
print()
# 输出数字
print(1)
# 输出字符串
print('字符串')
print("字符串")
# 输出含有运算符 表达式
print(3+1) # 4
# 将数据输出到文件中
fp = open('C:/Users/WZF/PycharmProjects/pythonProject/test.txt','a+') # a+为追加的写入方式
print('hello word',file=fp)
fp.close()
# print函数可传多个参数 会自动在中间添加空格
print('hello', 'word', '!') # 输出 hello word !
保留关键字
import keyword
print(keyword.kwlist)
输出:
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
变量
变量命名规则
规则
- 只能使用字母、数字、下划线_
- 不能以数字开头
- 不能使用保留字
- 严格区分大小写
变量定义
变量的组成
- 标识: 对象所存储的地址，可以通过id(obj)来获取
- 类型: 对象的数据类型,可以通过type(obj)来获取
- 值: 对象所存储的具体数据,使用print(obj)可以将值进行打印输出
name='wzf'
print('标识',id(name)) # 标识 3042687264560
print('类型',type(name)) # 类型 <class 'str'>
print('值',name) # 值 wzf
变量中实际储存的是id 内存分析图↓
数据类型
int 整数
- 整数的不同表示方式(打印时会自动格式化为十进制)
- 默认存储10进制
- 二进制
- 以0b开头
- 八进制
- 以0o开头
- 十六进制
- 以0x开头
float 浮点型
- python中浮点数储存为float类型，不是十分准确
- 例:1.1+2.2 => 3.30000000000003
- 解决方法:
- 引入decimal模块
- from decimal import Decimal
- Decimal(‘1.1’)+Decimal(‘2.2’)
bool 布尔类型
- 真True(代表1)
- 假False(代表0)
- 可以转为整数
- True+1 = 2
str 字符串
-
单引号
'单行字符串' ''' 多行字符串 ''' -
双引号
"单行字符串" """ 多行字符串 """
类型转换
隐式类型的转换
-
int + bool => int
- 1+True
- 2
- 1+True
-
int + float => float
- 1+1.0
- 2.0
- 1+1.0
-
float + bool => float
- 1.0+True
- 2.0
- 1.0+True
显示类型转换
- bool
bool()
bool(0)
>>> False
bool(1)
>>> True
bool(3)
>>> True
bool('')
>>> False # 空字符串转换为False
bool(' ')
>>> True # 其他非空字符串会被转换为True
bool([])
>>> False # 空列表会被转换为False
bool({}) # 空字典会被转换成False
- int
int()
int(False)
>>> 0
int(True)
>>> 1
int(0.6) # 向下取整
>>> 0
int('123')
>>> 123
int("123")
>>> 123
- float
float()
float(5)
>>> 5.0
float(False)
>>> 0.0
float(True)
>>> 1.0
float('123')
>>> 123.0
- str
str()
str(123)
>>> '123'
算术运算符
| 运算法 | 名称 | 例子 | 说明 |
|---|---|---|---|
| + | 加 | a + b | 求和 |
| - | 减 | a - b | 求差(-a => 对A取反 a=3 -a => -3) |
| * | 乘 | a * b | 乘积 |
| / | 除 | a / b | 相除 |
| % | 模运算 | a % b | 取余 |
| ** | 幂运算 | a ** b | a 的 b次幂 |
| // | 地板除法 | a // b | 求小于a与b的商的最大整数 |
比较运算符
| 运算符 | 名称 | 例子 | 说明 |
|---|---|---|---|
| == | 等于 | a == b | 比较是否相等 相等为True 反之为False |
| is | 比较地址 | a is b | 比较地址是否相等 相等为True 反之为False |
| != | 不等于 | a != b | 比较是否不相等 不相等为True 反之为False |
| > | 大于 | a > b | (字符串之间的比较是比较unicode编码的大小) (列表之间的比较是逐一比较其中元素的大小) |
| < | 小于 | a < b | |
| >= | 大于等于 | a >= b | |
| <= | 小于等于 | a <= b |
逻辑运算符
| 运算符 | 名称 | 例子 | 说明 |
|---|---|---|---|
| not | 逻辑非 | not a | |
| and | 逻辑与 | a and b | |
| or | 逻辑或 | a or b |
位运算
| 运算符 | 名称 | 例子 | 说明 |
|---|---|---|---|
| ~ | 按位取反 | ~x | 将x的值按位取反 |
| & | 按位取与 | x & y | 将x的值按位取与 |
| | | 按位取或 | x | y | 将x的值按位取或 |
| ^ | 按位取异或 | x ^ y | 将x的值按位取异或 |
| >> | 右移 | x >> a | 将x的值右移a位，高位用符号位补位 |
| << | 左移 | x << a | 将x的值左移a位，低位用0补位 |
赋值运算符
| 运算符 | 例子 | 说明 |
|---|---|---|
| += | a += b | a = a + b |
| -= | a -= b | a = a - b |
| *= | a *= b | a = a * b |
| /= | a /= b | a = a / b |
| %= | a % b | a = a% b |
| **= | a ** = b | a = a** b |
| //= | a // = b | a = a // b |
| &= | a &= b | a = a & b |
| |= | a |= b | a = a | b |
| ^= | a ^= b | a = a ^ b |
| <<= | a <<=b | a = a << b |
| >>= | a >>= b | a = a >> b |
运算符的优先级
| 优先级 | 运算符 | 说明 |
|---|---|---|
| 1 | () | 小括号 |
| 2 | ** | 幂 |
| 3 | ~ | 按位取反 |
| 4 | + , - | 正负号 |
| 5 | * , / , % , // | 乘 ，除 ，取余 ，地板除法 |
| 6 | + , - | 加 ， 减 |
| 7 | << , >> | 位移 |
| 8 | & | 按位取与 |
| 9 | ^ | 位异或 |
| 10 | | | 按位取或 |
| 11 | < , <= , > , >= , <> , != , == | 比较 |
| 12 | not | 逻辑非 |
| 13 | and , or | 逻辑与 ，逻辑或 |
分支语句
if
if 条件:
语句组1
else:
语句组2
if 条件1:
语句组1
elif 条件2:
语句组2
else:
语句组
获取用户输入
text = input('提示语句')
num = int(input('提示语句'))
分支表达式(三元运算)
语法结构
x if 条件语句 else y
print('大于') if a > b else print('小于')
pass 语句
语句什么都不做，只是一个占位符，用在语法上需要语句的地方
作用
在搭建语法结构的时候起占位符的作用，适合在构建逻辑时使用，专注构建逻辑，后续再补充具体内容
a=20
if a > 20:
pass
elif a < 20:
pass
else:
pass
循环语句
While
while 条件语句
# 循环执行的语句
for in循环
特点
- in表达从(字符串，序列等)中依次取值，又称为遍历
- for-in遍历的对象必须是可迭代对象(比如字符串(一个一个遍历)，序列)
语法结构
for 自定义的变量 in 可迭代对象:
循环体
for item in b:
print(item)
如果不需要item可以写成_
for _ in b:
print('test');
执行图
列表
列表的创建
方法一
使用方括号[]创建
lst = ['a','b','c',90,True]
# 列表中存储的是对象的引用(id)
方法二
使用内置函数list
lst = list(['a','b',100])
列表特点
- 按输入顺序存放
- 索引从0开始一一映射，负数索引访问0
- 数据可重复
- 任意数据类型
- 根据需要动态分配和回收内存
获取列表索引
.index()
如果有多个值则返回从左往右第一个值
注意:当找不到值时会报异常
.index()
lst = ['hello', 'word', 1
print(lst.index('hello')) # 0
# 在范围内查找
.index('要查找的字符串',起始位置,结束位置)
print(lst.index('hello',0, 2)) # 0
列表切片
语法
-
列表名[start : stop] -
列表名[start : stop : step]- step为正数
- 从第一个开始到stop
列表名[: stop : step] - 从start开始到最后一个元素
列表名[start :: step] - 整个列表 列表名
[::step]
- 从第一个开始到stop
- step为负数
- 从末尾开始到stop
列表名[: stop : step] - 从start开始到0
列表名[start::setp]
- 从末尾开始到stop
- step为正数
lst = ['hello', 'word', 100, 'a', 'b', 'c']
print(lst[0:3]) # ['hello', 'word', 100]
print(lst[0:6:2]) # ['hello', 100, 'b'] 从第一个开始到stop
print(lst[0::2]) # ['hello', 100, 'b'] 从start开始到最后一个元素
print(lst[::]) # ['hello', 'word', 100, 'a', 'b', 'c'] 整个列表
print(lst[:3:-1]) # ['c', 'b'] 从末尾开始到stop
print(lst[3::-1]) # ['a', 100, 'word', 'hello'] 从start开始到0
列表元素增删改查操作
列表查询
语法
判断指定元素在列表中是否存在
-
元素 in 列表名 -
元素 not in 列表名
列表元素的遍历
for 迭代变量 in 列表名
添加
语法
| 方法 | 描述 |
|---|---|
| append() | 在列表的末尾添加一个元素，当元素为列表时，整个列表视为一个一个元素(一个整体) |
| extend() | 在列表的末尾至少添加一个元素 |
| insert() | 在列表的任意位置添加一个元素 |
| 切片 | 在列表的任意位置至少添加一个元素 |
| + | 两个列表相加元素合并 |
| * n | 列表元素翻n倍 |
lst = ['hello', 'word', 100, 'a', 'b', 'c']
lst.append('d')
print(lst) # ['hello', 'word', 100, 'a', 'b', 'c', 'd']
lst.insert(1, 'test')
print(lst) # ['hello', 'test', 'word', 100, 'a', 'b', 'c', 'd']
lst.extend(['e', 'f', 'g'])
print(lst) # ['hello', 'test', 'word', 100, 'a', 'b', 'c', 'd', 'e', 'f', 'g']
lst = lst + ['h']
print(lst) # ['hello', 'test', 'word', 100, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
lst = lst * 2
print(lst) # ['hello', 'test', 'word', 100, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'hello', 'test', 'word', 100, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
lst.append(['i', 'j', 'k']) # 当元素为列表时，整个列表视为一个一个元素(一个整体)
print(lst) # ['hello', 'test', 'word', 100, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'hello', 'test', 'word', 100, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', ['i', 'j', 'k']]
# 切片添加
lst[1:] = ['aaa']
print(lst)
删除操作
| 方法 | 操作 |
|---|---|
| remove() | 一次删除一个元素，重复元素只删除第一个，元素不存在抛出ValueError异常 |
| pop() | 删除一个指定索引位置上的元素，指定索引不存在抛出IndexError，不指定索引，删除列表中的最后一个元素 |
| 切片 | 一次至少删除一个元素 |
| clear() | 清空列表 |
| del | 删除列表 |
lst1 = ['a', 'b', 'c', 'd', 'e', 'e', 'f']
print(lst1) # ['a', 'b', 'c', 'd', 'e', 'e', 'f']
lst1.remove('b')
print(lst1) # ['a', 'c', 'd', 'e', 'e', 'f']
lst1.pop(0)
print(lst1) # ['c', 'd', 'e', 'e', 'f']
lst1[1:3] = []
lst1.clear() # []
print(lst1)
del lst1
del lst1
# print(lst1) 报错
修改操作
| 方法 | 操作 |
|---|---|
| 直接赋值 | lst[index]=item |
| 切片修改 | lst[1:]=[] |
lst2 = ['a', 'b', 'c', 'd', 'e', 'e', 'f']
print(lst2)
lst2[0] = 'a1'
print(lst2) # ['a1', 'b', 'c', 'd', 'e', 'e', 'f']
lst2[1:3] = ['new Item']
print(lst2) # ['a1', 'new Item', 'd', 'e', 'e', 'f']
排序
| 方法 | 操作 |
|---|---|
| .sort() | 默认升序排序，可通过reverse=True来标识降序排序 |
| sorted(lst) | 默认升序排序，产生一个新的列表，愿列表不变，可以通过rever se=True来降序排序 |
列表生成式
语法
[列表元素的表达式 for 自定义变量 in 可迭代对象]
- 例
[i for i in range(1,10)]
lst3 = [i for i in range(1, 10)]
print(lst3) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
lst4 = [i * i for i in range(1, 10)]
print(lst4) # [1, 4, 9, 16, 25, 36, 49, 64, 81]
# 生成一个2 4 6 8 10的列表
lst5 = [i * 2 for i in range(1, 6)]
print(lst5) # [2, 4, 6, 8, 10]
其他语法
list(range(1,10))
字典
概念
- 是Python内置的数据结构之一，与列表一样是一个可变序列
- 以键值对的方式存储数据，字典是一个无序的序列
字典的创建
语法
-
使用花括号创建
dictionary = {'key1':100,'key2':90,'key3':80} -
使用内置函数dict()
dict()
例
dictionary = {'key1': 100, 0: 80, 'test': 90}
print(dictionary) # {'key1': 100, 0: 80, 'test': 90}
dictionary1 = dict(key1=1, key2=2, kry3=3)
print(dictionary1) # {'key1': 1, 'key2': 2, 'kry3': 3}
字典元素的获取
语法
[key]- 如果字典中不存在指定的key，会抛出keyError异常
.get(key)- 如果字典中不存在指定的key，返回None，也可以通过参数设置默认的value，以便指定的key不存在是返回
.get(key,defalut)
dictionary = {'key1': 100, 0: 80, 'test': 90}
print(dictionary) # {'key1': 100, 0: 80, 'test': 90}
value1 = dictionary['key1']
print(value1) # 100
value2 = dictionary.get('key2')
print(value2) # None
value3 = dictionary.get('key4', '无')
print(value3) # 无
字典的常用操作
key的判断
| 操作 | 例子 | 说明 |
|---|---|---|
| in | ‘key1’in dictionary | 判断键是否存在于字典中，存在返回True，反之返回False |
| not in | ‘key1’not in dictionary | 判断减是否不存在于字典中，不存在返回True，反之返回Flase |
字典元素的删除
del dictionary['key1']
字典元素的新增
dictionary['newKey'] = newValue
获取字典视图
| 操作 | 例子 | 说明 |
|---|---|---|
| keys() | keys=dictionary.keys() | 获取字典中的所有key,返回一个dict_keys类型，可以通过list函数转换成列表 |
| values() | values = dictionary.values() | 获取字典中的所有value |
| items() | items = dictionary.items() | 获取字典中所有key,value对 |
dictionary = {'key1': 100, 0: 80, 'test': 90}
keys = dictionary.keys()
print(keys) # dict_keys(['key1', 0, 'test'])
print(list(keys)) # ['key1', 0, 'test']
values = dictionary.values()
print(values) # dict_values([100, 80, 90])
print(list(values)) # [100, 80, 90]
items = dictionary.items()
print(items) # dict_items([('key1', 100), (0, 80), ('test', 90)])
# items转换之后的列表元素由元组组成
print(list(items)) # [('key1', 100), (0, 80), ('test', 90)]
字典的遍历
for item in dictionary:
print(item) # 输出的是键
# key1
# 0
# test
字典生成式
keys = ['key1', 'key2', 'key3']
values = [100, 90, 80]
d = {k: v for k, v in zip(keys, values)}
print(d) # {'key1': 100, 'key2': 90, 'key3': 80}
字典的特点
- 所有的元素都是一个key-value键值对，key不允许重复，value可以重复
- 字典中的元素是无序的
- 字典中的key必须是不可变对象
- 字典也可以根据需要动态的伸缩
- 字典会浪费较大的内存，是一种使用空间换时间的数据结构
元组
定义
python内置的数据结构之一，是一个不可变序列
- 不可变序列: 字符串，元祖
- 没有增删改查，修改后内存地址发生改变，生成了全新对象
- 可变序列：列表，字典
- 可以对序列执行增删改查，对象地址不发生更改
元祖的创建方式
直接使用小括号
t = ('a', 'b', 'c')
print(t) # ('a', 'b', 'c')
print(type(t)) # <class 'tuple'>
**注意:**只包含一个元组的元素也需要使用逗号和小括号
t=(10,)
c = ('a')
print(c) # a
print(type(c)) # <class 'str'>
c = ('a',)
print(c) # ('a',)
print(type(c)) # <class 'tuple'>
省略小括号写法
t = 'a', 'b', 'c' # 省略小括号写法
print(t) # ('a', 'b', 'c')
print(type(t)) # <class 'tuple'>
**注意:**只包含一个元组的元素也需要使用逗号
t=10,
使用内置函数tuple()
t = tuple(('a', 'b', 'c'))
print(t) # ('a', 'b', 'c')
print(type(t)) # <class 'tuple'>
空元组
t=()
t=tuple()
注意
- 元祖中存储的是对象的引用
- 如果元祖中对象本身是不可变对象，则不能再引用其他对象
- 如果元祖中的对象是可变对象，则可变对象的引用不允许改变，但数据可改变
元祖中的列表或者字典或者集合中的元素可变
t = 'a', 'b', 'c', [1]
print(t) # ('a', 'b', 'c', [1])
t[3].append(2)
print(t) # ('a', 'b', 'c', [1, 2])
元祖的遍历
使用索引访问元组
缺点：需要知道一共有多少索引
t=('a','b','c')
print(t[0])
print(t[1])
print(y[2])
使用for in访问元组
t=('a','b','c')
for i in t:
print(i)
集合
定义
-
是Python语言提供的内置数据结构
-
与列表，字典一样都属于可变类型的序列
-
集合是没有value的字典
特点
-
元素不允许重复，会自动去除重复元素
-
元素无序
集合的创建
通过{}来创建
s = {2, 3, 4, 5, 6, 7, 8, 7, 7}
print(s) # {2, 3, 4, 5, 6, 7, 8}
通过set()来创建
s1 = set([2, 3, 4, 5, 6, 7, 8])
print(s1) # {2, 3, 4, 5, 6, 7, 8}
s2 = set((1, 2, 3))
print(s2) # {1, 2, 3}
s3 = set('abcfawfsda') # 无序
print(s3) # {'f', 'w', 'd', 'c', 'b', 'a', 's'}
s4 = set({1, 2, 3, 4})
print(s4) # {1, 2, 3, 4}
定义空集合
s5 = set()
print(s5) # set()
**注意:**使用{}为空字典类型
集合的相关操作
集合元素的判断操作
in 或者 not in
集合元素的添加操作
| 方法 | 例 | 描述 |
|---|---|---|
| .add() | .add(20) | 一次添加一个元素 |
| .update(集合或元组) | .add({20,30,40}) 或 .add((50,60,70)) | 一次至少添加一个元素 |
集合的删除操作
| 方法 | 例 | 描述 |
|---|---|---|
| .remove() | .remove(10) | 一次删除一个指定元素，如果指定的元素不存在抛出KeyError |
| .discard() | .discard(10) | 一次删除一个指定元素，如果指定的元素不存在不抛出异常 |
| .pop() | .pop() | 一次只删除一个随机元素 |
| .clear() | .clear() | 清空集合 |
集合之间的关系
| 运算 | 功能 | 例 | 描述 |
|---|---|---|---|
| == / != | 判断是否相等 / 不相等 | A==B / a!=b | 元素都相同就相等 |
| .issubset() | 判断一个A集合是否是B集合的子集 | A.issubset(B) | 是子集则为True 反之为False |
| .issuperset() | 判断一个A集合是否是B集合的超集 | A.issuperset(B) | 是超集则为True 反之为False |
| .isdisjoint() | 判断两个集合是否有交集 | A.isdisjoint(B) | 有交集则为True反之为False |
集合的数学操作
| 运算 | 运算符号 | 功能 | 例 | 韦恩图 |
|---|---|---|---|---|
| .intersection() | & | 求A集合和B集合的交集 | A.intersection(B) / A & B |  |
| .union() | | | 求A集合和B集合的并集 | A.union(B) / A | B |  |
| .difference() | - | 求A集合和B集合的差集 | A.difference(B) / A - B |  |
| .symmetric_difference | ^ | 求A集合和B集合的对称差集 | A.symmetric_difference(B) /A ^ B |  |
集合生成式
语法
{集合元素的表达式 for 自定义变量 in 可迭代对象}
l = {i for i in range(1, 10)}
print(l) # {1, 2, 3, 4, 5, 6, 7, 8, 9}
列表、字典、元祖、集合总结
| 名称 | 数据结构 | 是否可变 | 是否重复 | 是否有序 | 定义符号 |
|---|---|---|---|---|---|
| 列表list | [1, 2, 3, 4] | 可变 | 可重复 | 有序 | [] |
| 元祖tuple | (1, 2, 3, 4) | 不可变 | 可重复 | 有序 | () |
| 字典dict | {key1 : value1, key2 : value2} | 可变 | key不可重复/value可重复 | 无序 | {key:value} |
| 集合set | {1, 2, 3, 4} | 可变 | 不可重复 | 无序 | {} |
字符串
定义
字符串是基本数据类型，是不可变的字符序列
字符串驻留机制
定义
仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时,不会开辟新空间，而是把该字符串的地址赋给新创建的
变量
驻留机制的几种情况**(交互模式，控制台中)**
- 字符串的长度为0或1是
- 符合标识符的字符串
- 字符串只在编译时进行驻留，而非运行时
- 图中ab+c的操作是在编译时计算
- .join([])的运算是在运行时计算，所以不会驻留
- [-5,256]之间的整数数字
- sys中的intern方法强制2个字符串指向同一个对象
**注意:**PyCharm对字符串进行了优化处理
s1 = "abc"
s2 = "abc"
print(s1 is s2) # True
a = 'abc'
b = 'ab' + 'c'
c = ''.join(['ab', 'c'])
print(c) # abc
print(a is b) # True
print(a is c) # False
# 特殊情况
# 此处与控制台结果不同，因为此处PyCharm对字符串进行了优化
s1 = "abc%"
s2 = "abc%"
print(s1 is s2) # True
print(id(s1),id(s2)) #2011173562864 2011173562864
a = -100
b = -100
print(a is b) # True 此处与交互式不同
优缺点
- 优点:
- 当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是会比较影响性能的。
- 缺点
- 在需要进行字符串拼接时建议使用 str类型的join方法，而非+ ,因为join()方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率要比"+"效率高
字符串的查询操作
| 方法名称 | 作用 |
|---|---|
| index() | 查找子串substr第一次出现的位置,如果查找的子串不存在时，则抛出ValueError |
| rindex() | 查找子串substr最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError |
| find() | 查找子串substr第一次出现的位置,如果查找的子串不存在时，则返回-1 |
| rfind() | 查找子串substr最后一次出现的位置,如果查找的子串不存在时，则返回-1 |
字符串的大小写转换操作
| 方法名称 | 作用 |
|---|---|
| upper() | 把字符串中所有字符都转成大写字母 |
| lower() | 把字符串中所有字符都转成小写字母 |
| swapcase() | 把字符串中所有大写字母转成小写字母，把所有小写字母都转成大写字母 |
| capitalize() | 把第一个字符转换为大写，把其余字符转换为小写 |
| title() | 把每个单词的第一个字符转换为大写，把每个单词的剩余字符转换为小写 |
**注意:**转换之后，会产生一个新的字符串对象，哪怕内容没有改变，但是地址已经发生改变了
字符串内容对齐操作的方法
| 方法名称 | 作用 | 例 |
|---|---|---|
| center(宽度，填充符) | 居中对齐，第1个参数指定宽度，第2个参数指定填充符,第2个参数是可选的，默认是空格,如果设置宽度小于实际宽度则则返回原字符串 | s.center(20,’*’) |
| ljust() | 左对齐，第1个参数指定宽度，第2个参数指定填充符，第2个参数是可选的，默认是空格如果设置宽度小于实际宽度则则返回原字符串 | s.ljust(20,’*’) |
| rjust() | 右对齐,第1个参数指定宽度，第2个参数指定填充符,第2个参数是可选的，默认是空格如果设置宽度小于实际宽度则则返回原字符串 | s.rjust(20,’*’) |
| zfill( ) | 右对齐，左边用0填充，该方法只接收一个参数，用于指定字符串的宽度，如果指定的宽度小于等于字符串的长度，返回字符串本身 | s.zfill(20) |
字符串劈分操作
| 方法名称 | 作用 |
|---|---|
| split() | 从字符串的左边开始劈分，默认的劈分字符是空格字符串,返回的值都是一个列表, |
| 通过参数sep指定劈分字符串的劈分符 | |
| 通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的串会单独做为一部子分 | |
| rsplit() | 从字符串的右边开始劈分，默认的劈分字符是空格字符串,返回的值都是一个列表 |
| 以通过参数sep指定劈分字符串是的劈分符 | |
| 通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独做为一部分 |
字符串的判断
| 方法名称 | 作用 |
|---|---|
| isidentifier() | 判断指定的字符串是不是合法的标识符(只包含字母、数字、下划线) |
| isspace() | 判断指定的字符串是否全部由空白字符组成(回车、换行，水平制表符) |
| isalpha() | 判断指定的字符串是否全部由字母(包含中文)组成 |
| isdecimal() | 判断指定字符串是否全部由十进制的数字组成(不能有小数，因为包含小数点，小数点不是十进制数字) |
| isnumeric() | 判断指定的字符串是否全部由数字组成 |
| isalnum() | 判断指定字符串是否全部由字母和数字组成 |
字符串的替换与合并
| 方法名称 | 作用 | 例 |
|---|---|---|
| replace() | 第1个参数指定被替换的子串，第2个参数指定替换子串的字符串,该方法返回替换后得到的字符串，替换前的字符串不发生变化,调用该方法时可以通过第3个参数指定最大替换次数 | s1.replace(‘被替换的字符串’,‘替换后的字符串’,‘最大替换次数(可选)’) |
| join() | 将列表或元组中的字符串合并成一个字符串 | s1.join(s2) s1.join([s2,s3,s4]) s1.join((s2,s3,s4)) |
s1 = '|'
print(s1.join(['test1', 'test2', 'test3']))
# test1|test2|test3
s2 = '*'
print(s2.join(('test1', 'test2', 'test3')))
# test1*test2*test3
s3 = '^'
print(s3.join('test'))
# t^e^s^t
字符串的比较操作
-
通过运算符比较
-
**比较规则:**首先比较两个字符串中的第一个字符, 如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较
-
**比较原理:**两上字符进行比较时,比较的是其ordinalvalue(原始值),调用内置函数ord可以 得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr,调用内置函数chr时指定ordinal value可以得到其对应的字符
print(ord('a')) # 97(实际上就是比较unicode码)
字符串的切片操作
注意
字符串是不可变类型，不具备增删改查等操作，切片操作会产生新的对象(同列表切片操作)
s1 = 'to be or not to be ,this is a question'
print(s1[0:5]) # to be
print(s1[:2]) # to
print(s1[20:]) # this is a question
print(s1[0:len(s1):2]) # t eo o ob ti i aqeto
格式化字符串
格式化字符串的方式
- % 作占位符
- %s 字符串占位符
- %i或%d 整数占位符
- %f 浮点数占位符
print('%s是%d年%d月%d日' % ('今天', 2022, 2, 3))
# 今天是2022年2月7日
- {}作占位符
- {index}代表获取传入参数的第几个
s = '我的名字叫做:{0},今年{1}岁,生日是在{1}年前的今天'.format('wzf', '20')
print(s) # 我的名字叫做:wzf,今年20岁,生日是在20年前的1月
- f-string
- 通过在字符串前面添加 f 可在字符串中调用变量
name = 'wzf'
age = 20
print(f'我叫{name},今年{age}岁') # 我叫wzf,今年20岁
- 通过占位符来限制宽度和精度
- 类似C中printf语法
# 限制宽度
print('%10d' % 99) # 99
print('{0:20}'.format(3.1415926535897932384626433)) # 3.141592653589793 设置宽度
# 限制精度
print('%.5f' % 3.1415926535897932384626433) # 3.14159(这里小数表示的是小数的数量)
print('{0:.3}'.format(3.1415926535897932384626433)) # 3.14(这里标识的是有效数字的个数)
# 或者 {0:.3f}
# 同时限制
print('%3.5f' % 3.1415926535897932384626433) # 3.14159
print('{0:5.3}'.format(3.1415926535897932384626433)) # 3.14
字符串的编码转换
字符串编码转换的作用
方便网络传输
解码与编码的方式
- **编码:**将字符串转换为二进制数据(bytes)
- **解码:**将bytes类型的数据转换成字符串类型
s = '测试文本'
# 编码
print(s.encode(encoding='GBK')) # b'\xb2\xe2\xca\xd4\xce\xc4\xb1\xbe'
print(s.encode(encoding='UTF-8')) # b'\xe6\xb5\x8b\xe8\xaf\x95\xe6\x96\x87\xe6\x9c\xac'
# 解码
byte = s.encode(encoding='GBK')
print(byte.decode(encoding='GBK')) # 测试文本
# print(byte.decode(encoding='UTF-8')) # 报错UnicodeDecodeError: 'utf-8' codec can't decode byte 0xb2 in position 0: invalid start byte
byte1 = s.encode('UTF-8')
print(byte1.decode(encoding='UTF-8')) # 测试文本
函数
分类
-
函数: 在模块中但是类之外定义，作用域是当前模块，我们称之为函数
-
嵌套函数：在别的函数中定义
-
方法：在类中定义
函数的创建和调用
什么是函数
函数是执行特定任务和完成特定功能的一段代码
为什么需要函数
- 复用代码
- 隐藏实现细节
- 提高可维护性
- 提高可读性便于调试
函数的创建
def 函数名 (参数):
函数体
retrun 返回值
def sum(a,b):
c = a + b
return c
函数的调用
result = sum(1,2)
print(result) # 3
函数的参数传递
位置传参
根据形参对应的位置进行实参传递
关键字实参
根据形参名称进行实参传递
函数调用的参数传递内存分析图
规律
参数传递时:
如果是不可变对象，在函数体的修改不会影响实参的值。arg1修改为100，不会影响n1的值
如果是可变对象，在函数体的修改会影响到实参的值。arg2的修改，append(10)，会影响到n2的值
函数的返回值
- 如果函数没有返回值(函数执行完之后，不需要给调用处提供数据) return可以省略不写
- 函数的返回值，如果是1个，直接返回类型
- 函数返回多个值时，结果为元组(不可变序列)
def divide(num):
odd = [] # 存奇数
even = [] # 存偶数
for i in num:
if i % 2:
odd.append(i)
else:
even.append(i)
return odd, even
print(divide([10, 29, 34, 23, 33, 53, 55]))
# ([29, 23, 33, 53, 55], [10, 34])
函数的参数定义
函数定义默认值参数
- 函数定义时， 给形参设置默认值，只有与默认值不符的时候才需要传递实参
def sum(a, b=10):
print(a, b) # 100 10
return a + b
print(sum(100)) # 110
可变参数
个数可变的位置参数
- 定义函数时，可能无法实现确定传递的位置实参的个数时，使用可变的位置参数
- 使用*定义个数可变的位置形参
- 形参为一个元祖
def test(*args):
print(args)
test(10) # (10,)
test(10, 20, 30) # (10, 20, 30)
个数可变的关键字形参
- 定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参
- 使用**定义个数可变的关键字形参
- 形参为一个字典
def test(**args):
print(args)
test(a=10) # {'a': 10}
test(a=10, b=20, c=30) # {'a': 10, 'b': 20, 'c': 30}
注意
定义可参数时
- 不能同时定义两个可变位置参数
def test(*arg1, *arg2):(X)
- 不能同时定义两个可变关键字参数
def test(**arg1, **arg2):(X)
- 可以先定义一个可变位置参数再定义一个可变关键字参数
def test(*arg1, **arg2):(√)
- 不可以先定义一个可变关键字参数再定义一个可变位置参数
def test(**arg1, *arg2):(X)
列表和字典转换给实参
列表元素转换为位置实参传入
def test(a, b, c):
print('a=', a)
print('b=', b)
print('c=', c)
test(10, 20, 30)
lst=[40, 50, 60]
test(*lst) # 在函数调用时，将列表中的每个元素都转换为位置实参传入
字典元素转换为关键字实参传入
def test(a, b, c):
print('a=', a)
print('b=', b)
print('c=', c)
test(a=100, b=100, c=100)
dic = {'a':200, 'b':200, 'c'=200}
test(**dic)
变量的作用域
概念
-
程序代码能访问该变量的区域
-
根据变量的有效范围可分为
- 局部变量
- 在函数内定义并使用的变量，只在函数内部有效
- 全局变脸
- 函数体外定义的变量，可作用于函数内外
- 局部变量通过global声明就能转化为全局变量(该变量只有在函数调用过才会生效)
- 局部变量
常用函数
range()
作用
生成一个序列
特点
不管range对象表示的整数序列有多长，所有的range对象占用的内存空间都是相同的，因为仅仅需要存储start end 和 step ，只有当用到range对象时，才会去计算序列中的相关元素
可以通过in 与not in 判断整数序列中是否存在指定的整数
用法
- range(end)
range(10) # 生成一个从0-10的列表
b = range(10)
print(b) # range(0, 10)
# list的作用是显示出列表
print(list(b)) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
- range(start , end)
range(1,10)
b = range(1, 10)
print(b) # range(1, 10)
print(list(b)) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
- range(start , end , step)
range(1,10,2)
b = range(1, 10, 2)
print(b) # range(1, 10, 2)
print(list(b)) # [1, 3, 5, 7, 9]
异常
异常处理机制
try - except结构
try:
# 要进行异常捕获的代码
except 异常类型1 :
# 异常处理代码
except 异常类型2 : # 按照先子类后父类的顺序进行捕获
# 异常处理代码
except BaseException as e : # BaseException基础异常类型
print(e)
try - except - else结构
**规则:**如果try块中没有抛出异常，则执行except块，如果try中抛出异常，则执行except块
try:
# 要进行异常捕获的代码
except 异常类型1 :
# 异常处理代码
except 异常类型2 : # 按照先子类后父类的顺序进行捕获
# 异常处理代码
except BaseException as e : # BaseException基础异常类型
print(e)
else:
# 正常运算后代码
try - except - else - finally
try:
# 要进行异常捕获的代码
except 异常类型1 :
# 异常处理代码
except 异常类型2 : # 按照先子类后父类的顺序进行捕获
# 异常处理代码
except BaseException as e : # BaseException基础异常类型
print(e)
else:
# 正常运算后代码
finally:
# 无论是否出现异常都会执行的代码
# 常用来释放try块中申请的资源
常见异常类型
| 异常类型 | 描述 |
|---|---|
| ZeroDuvusuibErrir | 除(或取模)0(所有数据类型) |
| IndexError | 序列中没有此索引 |
| keyError | 映射中没有这个键 |
| NameEroor | 未声明/初始化对象(没有属性) |
| SyntaxError | Python 语法错误 |
| ValueError | 传入无效的参数 |
traceback模块
使用traceback模块打印异常信息
import traceback
try:
num=10/0
except:
traceback.print_exc() # 打印错误信息
面向对象
类与对象
类的定义
类是现实世界或思维世界中的实体在计算机中的反映，它将数据以及这些数据上的操作封装在一起
对象的定义
对象是具有类类型的变量
类的创建
- 类的组成
- 类属性
- 市里实例方法
- 静态方法
- 类方法
语法
class Student:
name = 'wzf' # 类属性(静态属性，不需要创建对象来访问)
# 构造器
def __init__(self, sex, age): # 必须创建对象后才能调用内部的变量
self.sex = sex
self.age = age
# 实例方法
def test(self):
print('这是一个实例方法') # 必须创建对象后才能调用
# 静态方法
@staticmethod
def method():
print('使用staticmethod修饰的是静态方法')
# 类方法
@classmethod
def method1(cls):
print('使用classmethod修饰的是类方法')
对象的创建
对象的创建又称为类的实例化
语法
实例名 = 类名()
stu = Student() # 调用无参构造器
stu = Student('男', 20)
print(stu.name)
print(stu.sex)
print(stu.age)
print(Student.name)
stu.test() # 这是一个实例方法
Student.method1() # 使用classmethod修饰的是类方法
stu.method1()
stu.method()
Student.method()
stu1 = Student('男','20') # 调用构造器
print(id(stu1)) # 1421362237888
print(type(stu1)) # <class '__main__.Student'>
print(stud1) # <__main__.Student object at 0x0000014AEFCA91C0> (0x0000014AEFCA91C0是id的十六进制)
扫一扫
1107
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
