Pythen入门学习笔记

于 2023-08-08 15:53:24 发布
阅读量285 收藏 2
点赞数
文章标签： 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33266327/article/details/130415025
版权

文章目录

一、安装Pythen环境(解释器)

  1. 官网下载：https://www.python.org/downloads/windows/
    在这里插入图片描述
    这边建议下载32位的，因为64位环境中写的无法在32位中运行

  2. 安装
    在这里插入图片描述
    将自动配置环境变量勾选上，不然到时候手动配很麻烦的

  3. 测试安装是否成功
    打开cmd终端，输入python进入python环境：
    在这里插入图片描述

  4. 运行文件
    创建一个index.py：
    在这里插入图片描述
    在cmd中输入python index.py运行：
    在这里插入图片描述

二、安装Pycharm编辑工具

资源获取私信联系！

1.安装

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
打开Python：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.汉化

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
汉化成功！
0

三、Python基础

1.Python的数据基本类型

数字：int(有符号整数)、long(长整形,python3中取消)、float(浮点型)、complex(负数)、布尔值(bool)
字符串(str)
字典(dict)
元组(Tuple)
列表(list)

通过type()方法查看变量类型

# 数字类型
a=20
print(type(a))

# 字符串类型
a='秦老师'
print(type(a))

# 布尔类型
a=True
print(type(a))

# 元组类型
b=()
print(type(b))

# 列表类型
b=[]
print(type(b))

# 字典类型
b={}
print(type(b))

2.Python的基本运算符

算数运算符：

+ 加法
- 减法
* 乘法
** 指数
% 取余
/ 除法
// 地板除

a=7
b=3
print(a+b)
print(a-b)
print(a*b)
print(a/b)
print(a%b)
print(a//b) #除去后取整数

输出：
10
4
21
2.3333333333333335
1
2

赋值运算符：

= 赋值运算符
+= 加法赋值运算符，c += a 等同于 c = c + a。
-= 减法赋值运算符，c -= a 等同于 c = c - a。
/= 除法赋值运算符，c /= a 等同于 c = c / a。
*= 乘法赋值运算符，c *= a 等同于 c = c * a。
%= 取模赋值运算符，c %= a 等同于 c = c % a。
**= 幂赋值运算符，c **= a 等同于 c = c ** a。
//= 取整赋值运算符，c //= a 等同于 c = c // a。

比较运算符：

== 等于
!= 不等于
> 大于
< 小于
>= 大于或等于
< 小于或等于

a,b=10,5
print(a==b)
print(a!=b)
print(a>b)
print(a<b)
print(a>=b)
print(a<=b)

输出：
False
True
True
False
True
False

逻辑运算符：

优先级：() -> not -> and -> or

and： x and y 同时为真，结果为真，反之
or： x and y 任意一个为真，结果为真，反之
not：值取反

a,b,c,d=23,18,10,3
print(a+b>c and b<c)
print(a+b>c or b<c)
print(not b<c)

输出：
False
True
True

3.Python输入与输出

输出：

# 简单的输出
print('你好，python')

# 格式化输出（%占位符）
# %s是字符类型
# %d是数字类型
name='吾听安'
age=22
print('我的名字是%s,今年%s岁了'%(name,age))

# .format()格式方式(不需要指定数据类型)
print('我叫{}'.format(name))

%s是字符类型
%d是数字类型
\n是换行

在这里插入图片描述

输入：

# 基本输入
name=input("请输入你的姓名:")
print('我的姓名是{}'.format(name))

# 输入类型转换
age=int(input("请输入你的年龄:"))
print('我的年龄是%d岁'%(age))

4.流程控制

流程控制的分类：

  1. 顺序流程： 代码自上而下的执行，也是python默认的
  2. 选择流程/分支流程： 根据在某一步的判断，有选择的去执行相对应的逻辑的一种结构
    2.1 单分支：if …
    2.2 双分支：if … else …
    2.3 多分支：if … elif … else …
  3. 循环流程： 在满足一定的条件下，一直重复的去执行某段代码逻辑
    3.1 while 表达式
    3.2 for表达式

单分支示例：

# 单分支
score=20
if score<=60:
    print('成绩不太理想，要继续加油哦')
    pass #空语句
print('语句执行结束')

双分支示例：

# 双分支
score=90
if score<=60:
    print('成绩不太理想，要继续加油哦')
    pass #空语句
else:
    print('成绩及格，要继续保持哦')
    pass
print('语句执行结束')

多分支示例：

# 多分支
score=91
if score<=60:
    print('成绩不太理想，要继续加油哦')
    pass #空语句
elif score>=90:
    print('这成绩非常优秀，奖励一个小红花')
    pass  # 空语句
else:
    print('成绩及格，要继续保持哦')
    pass
print('语句执行结束')

while循环示例：

# while 循环
i = 0
while i<5:
    print('循环输出i:%d'%(i))
    i += 1
    pass
print('语句执行结束')

for循环示例：

# for 循环
tags='我是一个中国人'
for tag in tags:
    print(tag)
    pass
print('语句执行结束')

循环中的特殊关键字：
break退出整个循环
continue直接退出这一次循环，进入下一个循环

5.基本数据类型的操作

(1).字符串操作

  • 字符串可以支持索引
Test='python'
print(Test[0]) # 打印出 p
  • 字符切片

dataStr[2:5] 包含2的位置 不包含5的位置

dataStr='I love Python'
print(dataStr[2:5]) # 打印 lov
print(dataStr[2:]) # 打印 love Python  第三个后的所以字符，包含2的索引位置
print(dataStr[:3]) # 打印 I l  零可以省略
print(dataStr[::-1]) # 打印 nohtyP evol I  倒序输出
  • .capitalize() 将首字母转换为大写
    .title() 将每个单词的首字母变成大写
Test='python'
print(Test.capitalize()) # 打印 Python
  • .strip() 清除字符串中的空格 .lstrip()消除左边空格 .rstrip()消除右边空格
a='    hello    '
print(a.strip())  # 打印 hello
  • .find() 查找对应字符在字符串中的索引位置 当找不到时返回结果为-1
    .index()同理，只不过index如果找不到会直接报错
dataStr='I love Python'
print(dataStr.find('P'))  # 打印 7
  • .startswith()查看是否为指定的字符开头 返回布尔值
    .endswith() 查看是否为指定的字符结尾
dataStr='I love Python'
print(dataStr.startswith("I"))  # 打印 True
  • .lower() 将字符转换为小写
    upper() 将字符转换为大写
dataStr='I love Python'
print(dataStr.lower())  # 打印 i love python
  • .count() 统计出现过几次
dataStr='I love Python'
print(dataStr.count('o')) # 打印 2

(2).列表操作(list)

  1. 列表中的数据是可以变化的（数据项可以变化，内存地址不会改变）
  2. 用[]来表示列表类型，数据项之间用逗号来分割，注意: 数据项可以是任何类型的数据
  3. 支持索引和切片，和字符串操作一致
  • 基本定义
li=[1,2,3,'你好']
print(li)  # 打印 [1, 2, 3, '你好']
  • 切片
li=[1,2,3,'你好']
print(li[1:3]) # 打印 [2, 3]
print(li[1:]) # 打印 [2, 3, '你好']  第二个后的所以元素，包含1的索引位置
print(li[:2]) # 打印 [1, 2]  零可以省略
print(li[::-1]) # 打印 ['你好', 3, 2, 1]  倒序输出
  • 添加
    • .append() 在列表的最后追加数据
      li=[1,2,3,'你好']
li.append("你好啊")
print(li)  # 打印 [1, 2, 3, '你好', '你好啊']
    • .insert() 在指定位置插入数据，之前位置的数据往后移
      li=[1,2,3,'你好']
li.insert(1,"你好啊")
print(li)  # 打印 [1, '你好啊', 2, 3, '你好']
    • .extend()将应该列表批量的添加到另一个列表的尾部
      li2=[61,27,39]
li=[1,2,3,'你好']
li.extend(li2)
print(li)  # 打印 [1, 2, 3, '你好', 61, 27, 39]
  • 修改
li=[1,2,3,'你好']
li[0]=5
print(li)  # 打印 [5, 2, 3, '你好']
  • 删除

单个删除 和.pop()效果一样

li=[1,2,3,'你好']
del li[1]
print(li)  # 打印 [1, 3, '你好']

批量删除

li=[1,2,3,'你好']
del li[1:3]
print(li)  # 打印 [1, '你好']

删除指定值的元素

li=[1,2,3,'你好']
li.remove('你好')
print(li)  # 打印 [1, 2, 3]
  • 获取指定元素的索引
li=[1,2,3,'你好']
print(li.index(2))  # 打印 1
  • 反转列表
li=[1,2,3,'你好']
li.reverse()
print(li)

(3).元组操作

  1. 元组是一个不可变的序列，在创建之后不能做任何修改，
  2. 用()创建
  3. 当元组中只有一个元素时，要加上逗号，不然会被解释器当作整形来处理
  4. 支持切片操作

创建

tupleA=(1,2,9,65,'ss')
print(tupleA)  # 打印 (1, 2, 9, 65, 'ss')

切片

tupleA=(1,2,9,65,'ss')
print(tupleA[0:3])  # 打印 (1, 2, 9)
print(tupleA[::-2])  # 打印 ('ss', 9, 1) 隔两个取一个，包括被取的值
print(tupleA[-2:-1])  # 打印 (65,) 元组中单个数据要带,号

(4).字典操作

  1. 不是序列类型 没有下标的概念，是一个无序的 键值集合，是内置的高级数据类型
  2. 用{}来表示字典对象，每个键值对用逗号分隔
  3. 键 必须是不可变的类型【元组、字符串】值可以是任意的类型
  4. 每个键必定是惟一的，如果存在重复的键，后者会覆盖前者
  • 创建
dictA={}
dictB={'name':'秦','age':22}
print(dictB)  # 打印 {'name': '秦', 'age': 22}
  • 添加修改(相同key值则覆盖)
dictB={'name':'秦','age':22}
dictB['age']=19
dictB['sex']='男'
dictB.update({'name':'秦璇'})
print(dictB)  # 打印 {'name': '秦璇', 'age': 19, 'sex': '男'}
  • 查询
dictB={'name':'秦','age':22}
print(dictB['name'])  # 打印 秦
  • 删除
dictB={'name':'秦','age':22,'add':'add'}
del dictB['add']
dictB.pop('age')
print(dictB)  # 打印 {'name': '秦'}
  • 获取全部键值
dictB={'name':'秦','age':22,'add':'add'}
# 获取全部的键key
print(dictB.keys())  # 打印 dict_keys(['name', 'age', 'add'])
# 获取全部的值value
print(dictB.values())  # 打印 dict_values(['秦', 22, 'add'])
# 获取全部的键key和值value
print(dictB.items())  # 打印 dict_items([('name', '秦'), ('age', 22), ('add', 'add')])

(5).公共方法

+:

strA='人生苦恼'
strB='我用Python'
listA=list(range(10))
listB=list(range(20,30))
print(strA+strB)  # 打印 人生苦恼我用Python
print(listA+listB)  # 打印 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]

*:

strA='人生苦恼'
listA=list(range(10))
print(strA*2)  # 打印 人生苦恼人生苦恼
print(listA*2)  # 打印 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

in:

strA='人生苦恼'
listA=list(range(10))
print('人' in strA)  # 打印 True  (判断'人'是否在strA中存在)
print(1 in listA)  # 打印 True  (判断1是否在listA中存在)

6.函数

  1. 什么是函数:一系列Python语句的组合，可以在程序中运行一次或者多次
  2. 一般是完成具体的独立的功能
  3. 代码的复用最大化以及最小化冗余代码，整体代码结构清晰，问题局部化

函数定义：

# 定义函数
def test(name):
    #代码块
    print('我是%s'%(name))

函数调用：

# 调用函数
test('秦璇')  # 打印 我是秦璇

(1).参数

必选参数、默认参数(缺省参数)、可选参数、关键字参数
1.必选参数：
下面示例的name就是必填参数，调用时不填会报错

def test(name):
    #代码块
    print('我是%s'%(name))
    # 调用函数
    test('秦璇')  # 打印 我是秦璇

2.默认参数：
下面示例的name就是默认参数，调用时可以不填，值回事默认参数

# 定义函数
def test(name='玉皇大帝'):
    #代码块
    print('我是%s'%(name))
# 调用函数
test()  # 打印 我是玉皇大帝

3.可变参数(不定长参数)：

def getComputer(*ager):
    #代码块
    print(ager)

# 调用函数
getComputer(1,54,2,3,42)  # 打印 (1, 54, 2, 3, 42)

ager得到的数值是元组。

关键字可变参数
关键字参数只能放在可变长参数后面

def keyFunc(**kwargs):
    print(kwargs)
    pass

# 两种方式
keyFunc(name=20,age=26)  # 打印 {'name': 20, 'age': 26}
keyFunc(**{'name':'吾','age':'21'})  # 打印 {'name': '吾', 'age': '21'}

(2).返回值

  1. 函数执行完以后会返回一个对象，如果在函数的内部有return 就可以返回实际的值,否则返回None
  2. 可以返回任意类型，返回值类型应该取决于return后面的类型
  3. 在一个函数体内可以出现多个return值: 但是肯定只能返回一个return
  4. 如果在一个函数体内 执行了return,意味着函数就执行完成退出了，return后面的代码语句将不会执行
def sum(a,b):
    return a*b
print(sum(40,5))

(3).匿名函数

lambda表达式

M = lambda x,y:x+y
print(M(12,18))  # 打印 30

三元表达式：

b=17
print('出去工作' if b>=18 else '继续上学')  # 打印 继续上学

结合:

M=lambda b:'出去工作' if b>=18 else '继续上学'
print(M(19))  # 打印 出去工作

7.内置函数(官方自带的函数)

(1).数学运算函数：

abs():取绝对值
round():四舍五入
pow():求幂运算
divmod():求余和商的
max():最大值
min():最小值
sum():求和
eval():动态执行的

(2).类型转换函数

int():转int类型
float():转float类型
str():转字符类型
ord():字符转数字，ASCII码
chr():数字转字符，ASCII码
bool():转布尔类型
bin():十进制转二进制
hex():十进制转十六进制
oct():十进制转八进制
list():元组转列表
tuple():列表转元组
dict():转换成一个字典
bytes():转换编码

(3).序列操作函数

all():序列中有一个为0、空、false，则返回false
any():序列中有一个为true，则返回true
sorted():对序列进行排序
reverse():反转顺序
range():生成整数列表
zip():压缩组装多个可迭代对象
enumerate():给序列打包成元组，第一个元素是索引，第二个是值

(4).集合Set

创建的两种方式：

set = {'1',2,9}
print(type(set))  # 打印 <class 'set'>

a=['1','3','2']
b=set(a)
print(type(b))  # 打印 <class 'set'>

添加：

set = {'1',2,9}
set.add("你好世界")
print(set)  # 打印 {'你好世界', 9, 2, '1'}

清空：

set = {'1',2,9}
set.clear()
print(set)  # 打印 set()

差集：

set1 = {1,2,3}
set2 = {3,4}
print(set1.difference(set2))  # 打印 {1, 2}
print(set1 - set2)  # 打印 {1, 2}
print(set1)  # 打印 {1, 2, 3}

交集：

set1 = {1,2,3}
set2 = {3,4}
print(set1.intersection(set2))  # 打印 {3}
print(set1 & set2)  # 打印 {3}
print(set1)  # 打印 {1, 2, 3}

并集：

set1 = {1,2,3}
set2 = {3,4}
print(set1.union(set2))  # 打印 {1, 2, 3, 4}
print(set1 | set2)  # 打印 {1, 2, 3, 4}
print(set1)  # 打印 {1, 2, 3}

取出第一个：

set1 = {1,2,3}
print(set1.pop())  # 打印 1
print(set1)  # 打印 {2, 3}

移除指定元素：

set1 = {1,2,3}
set1.discard(2)
print(set1)  # 打印 {1, 3}

更新集合(批量添加)

set1 = {1,2,3}
set1.update({4,5,6})
print(set1)  # 打印 {1, 2, 3, 4, 5, 6}

四、面向对象

特征：封装、继承、多态

类的创建和对象的创建：

# 创建类
class Person:
    # 定义属性
    name=''
    age=0

    # 定义函数(方法)
    def eat(self):
        print('干饭')
        pass
    def run(self):
        print('造人')
        pass
    pass

# 创建对象
p=Person()
# 调用函数
p.eat()

在类的内部定义的叫实例方法

1.__init__()初始化方法

类似于java中的构造方法
声明实例属性：

# 创建类
class Person:

    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    # 定义函数(方法)
    def eat(self):
        print(self.name)
        pass
    def run(self):
        print('造人')
        pass
    pass

# 创建对象
p=Person('吾',19,'男')
p.eat()  # 打印 吾

2.self是什么？

self和对象指向同一个内存地址，可以认为self就是对象的引用。
不需要我们传入进去，是在Python解释器去自动指向的。
不一定是self，可以自定义其他名字

3.魔术方法

什么是魔术方法？由两个下划线包起来的通常被叫做魔术方法，比如之前的__init__()方法就是魔术方法。
在执行特定的操作的时候会被自动调用

__init__(): 初始化一个类，在创建实例对象为其赋值时使用。
__str__(): 在将对象转换成字符串str(对象)测试的时候，打印对象的信息
__new__(): 创建并返回一个实例对象，调用了一次，就会得到一个对象
__class__(): 获得已知对象的类（对象：__class__）
__del__(): 对象在程序运行结束后进行对象销毁的时候调用这个方法

4.析构方法

当一个对象被删除或者被销毁时，python解释器也会默认调用一个方法，这个方法为__del__()方法,也称为析构方法

5.继承

讲多个类中共有的方法提取到父类中，减少重复代码，提高开发效率

(1).单继承

代码示例：

class Animal:
    def eat(self):
        print('动物吃东西')
        pass
    def drink(self):
        print('动物叫！')
        pass
    pass

class Dog(Animal):
    pass

dog=Dog()
dog.eat()  # 打印 '动物吃东西'

(2).多继承

示例代码：

# 多继承
# 神仙
class shenxian:
    def fly(self):
        print('神仙会飞')
        pass
    pass

# 猴子
class Monkey:
    def chitao(self):
        print('猴子喜欢吃桃子')
        pass
    pass

# 孙悟空
class SunwuKong(shenxian,Monkey):
    pass

swk=SunwuKong()
swk.fly()  # 打印 神仙会飞
swk.chitao()  # 打印 猴子喜欢吃桃子

如果父类中出现了相同的方法名，会按照优先级来选择：
父类的继承顺序 --》父类的父类的继承顺序

重写方法

当子类拥有和父类方法名和参数相同的方法时，子类方法将覆盖父类的改方法

示例代码：

# 重写
class A:
    def eat(self):
        print("吃A")

class B(A):
    def eat(self):
        print("吃B")

b=B()
b.eat()  # 打印 吃B

重写继承父类构造方法

# 重写继承父类构造方法
class A:
    def __init__(self,name):
        self.name=name
    def eat(self):
        print(self.name)
        pass
    pass

class B(A):
    def __init__(self,name):
        A.__init__(self,name)
        pass
    def eat(self):
        print(self.name)
        pass
    pass
b=B('你好啊')
b.eat()

6.多态

继承、重写即可叫做多态
同一种行为不同的子类有不同的实现，这就叫做多态

class A:
    def eat(self):
        print('动物')
        pass
    pass

class B(A):
    def eat(self):
        print("鸭子")
        pass
    pass

class C(A):
    def eat(self):
        print('老虎')
        pass
    pass

B().eat()  # 打印 鸭子
C().eat()  # 打印 老虎

7.类属性和实例属性

  1. 类属性：在类中直接定义的属性，可直接通过类获取并修改值，实例对象也可以获取到，但无法修改类属性的值。
  2. 实例属性：创建实例后通过实例可以获取并修改，无法通过类获取并修改。

示例代码：

class Student:
    name='吾'
    def __init__(self,age):
        self.age=age
        pass
    pass

print(Student.name)  # 打印 吾
student=Student(20)
print(student.name)  # 打印 吾
print(student.age)  # 打印 20

8.类方法

  • 类对象所拥有的方法，需要用装饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象,一般以cls作为第一个参数，类方法可以通过类对象，实例对象调用
class Student:
    name='吾'

    @classmethod
    def get_name(cls):
        return cls.name
    pass

    def __init__(self,age):
        self.age=age
        pass
    pass

print(Student.get_name())  # 打印 吾
print(Student().get_name())  # 打印 吾

9.静态方法

类对象所拥有的方法，需要用@staticmethod来表示静态方法，静态方法可以不需要任何参数

import time  # 导入第三方包
class TimeTest:
    @staticmethod
    def showTime():
        return time.strftime('%H:%M:%S',time.localtime())
        pass
    pass

print(TimeTest.showTime())  # 打印 15:33:46

10.私有属性

私有属性无法被从类外部访问也无法被继承。在属性前加上__即可对属性私有化

class Person:
    def __init__(self):
        self.__name='李四'
        self.age=19
        pass
    def getName(self):
        return self.__name
    pass

person=Person()
print(person.age)  # 打印 19
print(person.getName())  # 打印 李四

11.私有方法

私有方法无法被从类外部访问也无法被继承。在方法前加上__即可对属性私有化

class Animal:
    def __eat(self):
        print('吃东西')
        pass
    def run(self):
        self.__eat()
        print('飞块的跑')
        pass
    pass

class Bird(Animal):
    pass

b=Bird()
b.run()  # 打印 吃东西 \ 飞块的跑
b.__eat()  # 打印报错

12.Property函数

设置一个类属性等于Property函数,指定的该函数的获取方法和修改方法。当修改时会调用你指定的修改方法，获取也一样。

class Person:
    def __init__(self):
        self.__age=19
        pass
    def get_age(self):
        return self.__age
    def set_age(self,age):
        self.__age=age
        pass
    age=property(get_age,set_age)
person=Person()
print(person.age)  # 打印 19
person.age=25
print(person.age)  # 打印 25

使用装饰器实现上面代码的功能：

class Person:
    def __init__(self):
        self.__age=19
        pass
    @property
    def age(self):
        return self.__age
    @age.setter
    def age(self,age):
        self.__age=age
        pass
person=Person()
print(person.age)  # 打印 19
person.age=25
print(person.age)  # 打印 25

13.多态绑定属性和方法

class Student:
    def __init__(self):
        self.name='吾听安'
        self.age='18'
        pass
    pass

s=Student()
# 多态属性
s.sex='男'
print(s.sex)
print(s.name)
print(s.age)

import types

def chi(self):
    print("{}岁的{}在吃饭".format(self.age,self.name))

# 多态方法
s.chi=types.MethodType(chi,s)
s.chi()

14.__slots__属性

  • `__slots__是一个元组类型，里面的类型是字符类型，被它所自定的实例属性名才可被创建，否则就报错。
  • 这种存数据的方式可以节省资源，减少资源的占用。
  • 当子类中没有声明 __slots__属性时，这种限定方式是不会被继承的，如果有声明了，那么就会将父类的 __slots__属性继承下来。
class Student:
    __slots__ = ('name','age')
    def __str__(self):
        return '{}....{}'.format(self.name,self.age)
    pass

s=Student()
s.name='吾听安'
s.age=19
print(s)  # 打印 吾听安....19
s.score=50  # 打印 报错

五、异常处理

1.异常的捕获

  • try: 可能会出错的代码块
  • except: 出错之后执行的代码块
  • else: 没有出错之后执行的代码块
  • finally: 不管出没出错都执行的代码块
try:
    print(b);
    pass
except NameError as msg:
    print(msg)  # 打印 name 'b' is not defined
    pass
else:
    print("无异常发生")
finally:
    print('一定执行')  # 打印 一定执行
print("异常被捕获并处理")  # 打印 异常被捕获并处理

异常类型：
在这里插入图片描述

2.自定义异常类

直接或者间接继承了Error或Exception类，由开发者主动使用raise关键字抛出。

# 自定义异常
class QinXuanException(Exception):
    def __init__(self,str='QinXuan自定义异常'):
        self.str=str
    def __str__(self):
        return self.str
        pass
    pass

try:
    print('你好')
    raise QinXuanException('报错了')
    print('没有报错哦')
    pass
except QinXuanException as msg:
    print(msg)  # 打印 报错了
    pass
print('执行完毕')

六、文件操作

1.文件读写

1.打开文件 open(‘文件路径’,‘打开的模式’,encoding=‘utf-8’)

  • 'r'以只读的方式打开文件,光标在开头位置,默认模式
  • 'r+'以读写的方式打开文件,光标在开头位置
  • 'w'打开文件只用于写入，如果该文件存在内容则会被覆盖，文件>* 不存在会创建新的文件
  • 'w+'打开文件用于读写，如果该文件存在内容则会被覆盖，文件不存在会创建新的文件
  • 'a'打开一个文本用于追加。如果该文本已存在，则追加在文件的末尾，文件不存在会创建新的文件
  • 'a+'打开一个文本用于读写。如果该文本已存在，则追加在文件的末尾，文件不存在会创建新的文件

写：

# 1.打开文件 open('文件路径','打开的模式')
fobj=open('./Text.txt','w',encoding='utf-8')
# 2.读/写操作
# 写操作
fobj.write('苍茫的天涯是我的爱')
fobj.write('\n万紫千红')
fobj.close()

读：

fobj=open('./Text.txt','r',encoding='utf-8')
# str1=fobj.read() # 一次性读取全部
# str1=fobj.read(2) # 指定读取个数
# str1=fobj.readlines() # 一次性读取全部内容,按行读取，返回一个列表
# str1=fobj.readlines(24) # 获取这么多字节的列，如果后面的字数不够，也会输出那一行
str1=fobj.readline() # 读一行
fobj.close()
print(str1)

with：

# 不管是否发生错误都会去关闭文件
with open('./Text.txt','r',encoding='utf-8') as f:
    str1=f.read() # 一次性读取全部
    print(str1)

2.文件定位

  • .tell() 获取当前光标位置
  • .truncate(15) 修改源文件，截取剩下15个字符
  • .seek(x1,x2,x3) x1偏移量正数往右反之，x2:0从文本开头开始、1从当前位置开始、2从文本末尾开始
# 不管是否发生错误都会去关闭文件
with open('./Text.txt','r+',encoding='utf-8') as f:
    str1=f.read(3) # 一次性读取全部
    # f.seek(x1,x2,x3) x1偏移量正数往右反之，x2:0从文本开头开始、1从当前位置开始、2从文本末尾开始
    f.seek(2,0)
    print(f.tell())  # 获取当前光标位置
    f.truncate(15) # 截取剩下15个字符
    print(str1)

七、模块

1.导入

  1. 默认在当前目录中查找
  2. 找不到就会在python环境指定文件下查找
import time
print(time.ctime())  # 打印 Fri May 19 15:08:58 2023

，上面这种导入方式默认导入区别功能，如果只想导入其中的某一些功能，则可以：

from time import ctime
# 直接调用函数名即可
print(ctime())  # 打印 Fri May 19 15:08:58 2023

2.模块制作

一个.py文件可以作为一个模块，模块名字就说文件的名字。

创建名为MyMod.py的文件：

def add(x,y):
    return x+y

调用：

import MyMod
print(MyMod.add(1,2))
# 或
from MyMod import add
print(add(1,2))

3.模块发布与安装

(1).模块发布

创建名为MyMod.py的文件：

def add(x,y):
    return x+y

创建名为setup.py的文件：

from distutils.core import setup
# name 模块名称
# version 版本号
# description 描述
# author 作者
# py_modules 发布内容
setup(name='qinxuan',version='1.0',description='加减乘除测试',author='qinxuan',py_modules=['MyMod'])

创建模块，打开终端，cd定位到要创建模块的文件夹中，并输入python setup.py build，会生成build文件夹：
在这里插入图片描述

生成压缩包，gz类型的压缩包，输入python setup.py sdist，压缩包会生成在dist文件夹下：
在这里插入图片描述

(2).安装模块

本地安装，打开终端定位到模块压缩包的位置，然后输入pip install 压缩包名即可：

在这里插入图片描述

吾听安
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python入门到精通
m0_72882572的博客
08-18 1312
Python是完全面向对象的语言。函数、模块、数字、字符串都是对象。并且完全支持继承、重载、派生、多继承，有益于增强源代码的复用性。Python支持重载运算符和动态类型。相对于Lisp这种传统的函数式编程语言，Python对函数式设计只提供了有限的支持。有两个标准库（functools，itertools）提供了Haskell和Standard ML中久经考验的函数式程序设计工具。...
pythen知识点
qq_33305704的博客
07-31 1833
1、python下多线程的限制以及多进程中传递参数的方式 　  python多线程有个全局解释器锁（global interpreter lock），这个锁的意思是任一时间只能有一个线程使用解释器，跟单cpu跑多个程序一个意思，大家都是轮着用的，这叫“并发”，不是“并行”。 多进程间共享数据，可以使用 multiprocessing.Value 和 multiprocessing.Array ...
Pycharm及python安装详细教程
热门推荐
陌上行走的博客
09-25 73万+
首先我们来安装python 1、首先进入网站下载：点击打开链接（或自己输入网址https://www.python.org/downloads/），进入之后如下图，选择图中红色圈中区域进行下载。 2、下载完成后如下图所示 3、双击exe文件进行安装，如下图，并按照圈中区域进行设置，切记要勾选打钩的框，然后再点击Customize install
10年程序员职业生涯感悟—写给正在迷茫的你
pythonandaiot的博客
06-17 1万+
希望能带给大家不一样的参考。或者能提前预防，少走弯路！
Python入门基础知识总结（赶紧收藏）
Python84310366的博客
07-13 7万+
Python入门基础知识总结（赶紧收藏）
python安装方法_Python入门基础教程（非常详细）
weixin_39813200的博客
11-16 1359
Python 是一门开源免费、通用型的脚本编程语言，它上手简单，功能强大，坚持「极简主义」。Python 类库(模块)极其丰富，这使得 Python 几乎无所不能，不管是传统的 Web 开发、PC 软件开发、Linux 运维，还是当下火热的机器学习、大数据分析、网络爬虫，Python 都能胜任。这套 Python 基础教程不是教科书，不会玩弄概念，而是力求口语化和通俗化，让读者尽快入门。如果有小朋...
python基础学习笔记
02-20
"Python基础学习笔记"涵盖了Python入门所需的关键知识点，是初学者踏入编程世界的重要资源。 首先，Python的基础语法是学习的起点。它使用缩进来定义代码块，这与大多数其他编程语言的花括号不同。Python的变量声明...
python入门学习笔记
最新发布
03-15
"Python入门学习笔记"是一份旨在帮助新手掌握Python编程基础的资料，它涵盖了Python语言的核心概念、基本语法以及常用库的使用。 在Python的世界里，初学者首先要了解的是其基本语法结构，包括变量的声明与赋值、...
Python基础学习笔记
03-21
1.Python基础 1.1使用基础 1.2PIP使用 1.3内置函数/变量/模块 1.4代码输入基础知识细节 1.5列表 1.6元组 1.7字典 1.8集合 1.9公共方法 1.10推导式 1.11函数 1.12文件操作 1.13语法错误与异常处理 1.14生成器 1.15...
Python入门学习笔记
01-09
包含学习Python前的准备工作，环境搭建，以及详细的语法入门，数据类型介绍运算符以及控制流程语句学习。并且内部包含丰富详细的案例以供课下练习，当然代码不唯一...因为这里面只是我的学习笔记，并没有视频看的直观。
python基础学习笔记.pdf
08-21
python基础学习笔记
Python基础学习笔记.pdf
05-15
Python 基础学习笔记是 Python 语言的入门教程，涵盖了 Python 语言的基础知识点，包括计算机的概念、程序设计基本方法、Python 语言概述、Python 语言开发环境配置、程序的基本编写方法等。 计算机的概念是指根据...
python基础学习笔记整理
11-08
适合python入门学习，笔记含有示例代码，贴入工具中可执行查看效果。 1、环境准备 2、基础知识 2.1、语法 2.1.1、变量和数据类型 2.1.2、控制流程if for while 2.1.3、函数实例 2.1.4、购物车 2.1.5、字符编码与文件...
python基础学习笔记（1）
05-20
### Python基础学习笔记知识点梳理 #### 一、Python语言特性 - **解释型语言**: Python是一种解释型语言，这意味着代码可以一行一行地被执行而无需事先进行编译过程。这种特性使得Python非常适合快速开发和测试。 ...
Python基础学习笔记.zip
02-21
本压缩包“Python基础学习笔记.zip”似乎包含了一份关于Python入门的学习资料，可能涵盖了变量、数据类型、控制流、函数、模块等基础知识。 1. **Python变量与数据类型** Python中的变量可以存储各种数据类型，...
visual studio code Python终端运行_Python快速入门(一)
weixin_39830205的博客
10-24 4809
引言Python作为一个，目前最火的编程语言之一，已经渗透到了各行各业。它易学好懂，拥有着丰富的库，功能齐全。人生苦短，就用Python。这个快速入门系列分为六篇，包含了Python大部分基础知识，每篇阅读时间不长，且内容含量高。大家最好亲自码一遍代码，这样可以更有收获。概要1、了解和安装编写和运行Python代码利器：VsCode；2、掌握Python的注释功能，从一开始就可以学会规范代码；3、...
24个好用到爆的Python实用技巧
m0_59163425的博客
06-08 903
Python 是一种非常多样化且发展良好的语言，因此肯定会有许多我没有考虑的功能。Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。（全套教程文末领取哈）
Python入门教程(从小白到高级)(新版)
weixin_47585269的博客
06-28 22万+
Python从一无所知到精通（新版） 吐槽：Hello,everyone.经历完广东中考折磨的我回来啦！不得不说这届广东考生真的有些困难，先后经历了疫情，然后这次中考又来了一份折磨人的数学试卷（初高中衔接，难度我也觉得有些大）…最后我也不多说了，但愿看到这篇教程的广东初三中考生知道过去的都过去了，不要再这么纠结与郁闷。人生路漫漫，不必因为数学失利而感到绝望，毕竟你难别人也会觉得难，你死了别人也可能跟你一样陪葬。收拾好行装，整理好心态，重新出发，活在当下，为未来努力奋斗才是实在。同时也祝愿广州考生能在七月的中
python入门教程(非常详细),python基础教程 入门教程
神器榜
09-19 14万+
用Python写网络爬虫》作者： 【澳】Richard Lawson（理查德 劳森）本书讲解了如何使用Python来编写网络爬虫程序，内容包括网络爬虫简介，从页面中抓取数据的三种方法，提取缓存中的数据，使用多个线程和进程来进行并发抓取，如何抓取动态页面中的内容，与表单进行交互，处理页面中的验证码问题，以及使用Scarpy和Portia来进行数据抓取，并在最后使用本书介绍的数据抓取技术对几个真实的网站进行了抓取，旨在帮助读者活学活用书中介绍的技术。而不同的编程语言，干同一个活，编写的代码量，差距也很大。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值